| blob | 3b4d69c0562301b18039657ac0d47261a4eed6af |
1 /*
2 * raid1.c : Multiple Devices driver for Linux
3 *
4 * Copyright (C) 1999, 2000, 2001 Ingo Molnar, Red Hat
5 *
6 * Copyright (C) 1996, 1997, 1998 Ingo Molnar, Miguel de Icaza, Gadi Oxman
7 *
8 * RAID-1 management functions.
9 *
10 * Better read-balancing code written by Mika Kuoppala <miku@iki.fi>, 2000
11 *
12 * Fixes to reconstruction by Jakob Østergaard" <jakob@ostenfeld.dk>
13 * Various fixes by Neil Brown <neilb@cse.unsw.edu.au>
14 *
15 * Changes by Peter T. Breuer <ptb@it.uc3m.es> 31/1/2003 to support
16 * bitmapped intelligence in resync:
17 *
18 * - bitmap marked during normal i/o
19 * - bitmap used to skip nondirty blocks during sync
20 *
21 * Additions to bitmap code, (C) 2003-2004 Paul Clements, SteelEye Technology:
22 * - persistent bitmap code
23 *
24 * This program is free software; you can redistribute it and/or modify
25 * it under the terms of the GNU General Public License as published by
26 * the Free Software Foundation; either version 2, or (at your option)
27 * any later version.
28 *
29 * You should have received a copy of the GNU General Public License
30 * (for example /usr/src/linux/COPYING); if not, write to the Free
31 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32 */
35 #include <linux/raid/raid1.h>
36 #include <linux/raid/bitmap.h>
38 #define DEBUG 0
39 #if DEBUG
40 #define PRINTK(x...) printk(x)
41 #else
42 #define PRINTK(x...)
43 #endif
45 /*
46 * Number of guaranteed r1bios in case of extreme VM load:
47 */
48 #define NR_RAID1_BIOS 256
57 {
62 /* allocate a r1bio with room for raid_disks entries in the bios array */
68 }
71 {
73 }
75 #define RESYNC_BLOCK_SIZE (64*1024)
76 //#define RESYNC_BLOCK_SIZE PAGE_SIZE
77 #define RESYNC_SECTORS (RESYNC_BLOCK_SIZE >> 9)
78 #define RESYNC_PAGES ((RESYNC_BLOCK_SIZE + PAGE_SIZE-1) / PAGE_SIZE)
79 #define RESYNC_WINDOW (2048*1024)
82 {
93 }
95 /*
96 * Allocate bios : 1 for reading, n-1 for writing
97 */
103 }
104 /*
105 * Allocate RESYNC_PAGES data pages and attach them to
106 * the first bio.
107 * If this is a user-requested check/repair, allocate
108 * RESYNC_PAGES for each bio.
109 */
112 else
122 }
123 }
124 /* If not user-requests, copy the page pointers to all bios */
130 }
136 out_free_pages:
141 out_free_bio:
146 }
149 {
160 }
165 }
168 {
176 }
177 }
180 {
183 /*
184 * Wake up any possible resync thread that waits for the device
185 * to go idle.
186 */
191 }
194 {
202 }
207 }
210 {
222 }
224 /*
225 * raid_end_bio_io() is called when we have finished servicing a mirrored
226 * operation and are ready to return a success/failure code to the buffer
227 * cache layer.
228 */
230 {
233 /* if nobody has done the final endio yet, do it now */
243 }
245 }
247 /*
248 * Update disk head position estimator based on IRQ completion info.
249 */
251 {
256 }
259 {
269 /*
270 * this branch is our 'one mirror IO has finished' event handler:
271 */
275 /*
276 * Set R1BIO_Uptodate in our master bio, so that
277 * we will return a good error code for to the higher
278 * levels even if IO on some other mirrored buffer fails.
279 *
280 * The 'master' represents the composite IO operation to
281 * user-side. So if something waits for IO, then it will
282 * wait for the 'master' bio.
283 */
289 /*
290 * oops, read error:
291 */
297 }
301 }
304 {
322 /* Don't rdev_dec_pending in this branch - keep it for the retry */
324 /*
325 * this branch is our 'one mirror IO has finished' event handler:
326 */
331 /* an I/O failed, we can't clear the bitmap */
334 /*
335 * Set R1BIO_Uptodate in our master bio, so that
336 * we will return a good error code for to the higher
337 * levels even if IO on some other mirrored buffer fails.
338 *
339 * The 'master' represents the composite IO operation to
340 * user-side. So if something waits for IO, then it will
341 * wait for the 'master' bio.
342 */
351 /* In behind mode, we ACK the master bio once the I/O has safely
352 * reached all non-writemostly disks. Setting the Returned bit
353 * ensures that this gets done only once -- we don't ever want to
354 * return -EIO here, instead we'll wait */
358 /* Maybe we can return now */
366 }
367 }
368 }
370 }
371 /*
372 *
373 * Let's see if all mirrored write operations have finished
374 * already.
375 */
380 /* it really is the end of this request */
382 /* free extra copy of the data pages */
386 }
387 /* clear the bitmap if all writes complete successfully */
391 behind);
394 }
395 }
401 }
404 /*
405 * This routine returns the disk from which the requested read should
406 * be done. There is a per-array 'next expected sequential IO' sector
407 * number - if this matches on the next IO then we use the last disk.
408 * There is also a per-disk 'last know head position' sector that is
409 * maintained from IRQ contexts, both the normal and the resync IO
410 * completion handlers update this position correctly. If there is no
411 * perfect sequential match then we pick the disk whose head is closest.
412 *
413 * If there are 2 mirrors in the same 2 devices, performance degrades
414 * because position is mirror, not device based.
415 *
416 * The rdev for the device selected will have nr_pending incremented.
417 */
419 {
428 /*
429 * Check if we can balance. We can balance on the whole
430 * device if no resync is going on, or below the resync window.
431 * We take the first readable disk when above the resync window.
432 */
433 retry:
436 /* Choose the first operation device, for consistancy */
452 }
453 }
455 }
458 /* make sure the disk is operational */
471 new_disk--;
475 }
476 }
482 /* now disk == new_disk == starting point for search */
484 /*
485 * Don't change to another disk for sequential reads:
486 */
494 /* Find the disk whose head is closest */
499 disk--;
511 }
516 }
519 rb_out:
528 /* cannot risk returning a device that failed
529 * before we inc'ed nr_pending
530 */
533 }
536 }
540 }
543 {
561 }
562 }
564 }
567 {
572 }
576 {
594 error_sector);
597 }
598 }
599 }
602 }
604 /* Barriers....
605 * Sometimes we need to suspend IO while we do something else,
606 * either some resync/recovery, or reconfigure the array.
607 * To do this we raise a 'barrier'.
608 * The 'barrier' is a counter that can be raised multiple times
609 * to count how many activities are happening which preclude
610 * normal IO.
611 * We can only raise the barrier if there is no pending IO.
612 * i.e. if nr_pending == 0.
613 * We choose only to raise the barrier if no-one is waiting for the
614 * barrier to go down. This means that as soon as an IO request
615 * is ready, no other operations which require a barrier will start
616 * until the IO request has had a chance.
617 *
618 * So: regular IO calls 'wait_barrier'. When that returns there
619 * is no backgroup IO happening, It must arrange to call
620 * allow_barrier when it has finished its IO.
621 * backgroup IO calls must call raise_barrier. Once that returns
622 * there is no normal IO happeing. It must arrange to call
623 * lower_barrier when the particular background IO completes.
624 */
625 #define RESYNC_DEPTH 32
628 {
631 /* Wait until no block IO is waiting */
636 /* block any new IO from starting */
639 /* No wait for all pending IO to complete */
646 }
649 {
655 }
658 {
666 }
669 }
672 {
678 }
681 {
682 /* stop syncio and normal IO and wait for everything to
683 * go quite.
684 * We increment barrier and nr_waiting, and then
685 * wait until barrier+nr_pending match nr_queued+2
686 */
695 }
697 {
698 /* reverse the effect of the freeze */
704 }
707 /* duplicate the data pages for behind I/O */
709 {
713 GFP_NOIO);
725 }
729 do_sync_io:
736 }
739 {
754 /*
755 * Register the new request and wait if the reconstruction
756 * thread has put up a bar for new requests.
757 * Continue immediately if no resync is active currently.
758 * We test barriers_work *after* md_write_start as md_write_start
759 * may cause the first superblock write, and that will check out
760 * if barriers work.
761 */
770 }
777 /*
778 * make_request() can abort the operation when READA is being
779 * used and no empty request is available.
780 *
781 */
791 /*
792 * read balancing logic:
793 */
797 /* couldn't find anywhere to read from */
800 }
817 }
819 /*
820 * WRITE:
821 */
822 /* first select target devices under spinlock and
823 * inc refcount on their rdev. Record them by setting
824 * bios[x] to bio
825 */
827 #if 0
832 }
833 #endif
844 targets++;
847 }
853 /* array is degraded, we will not clear the bitmap
854 * on I/O completion (see raid1_end_write_request) */
856 }
858 /* do behind I/O ? */
890 /* Yes, I really want the '__' version so that
891 * we clear any unused pointer in the io_vec, rather
892 * than leave them unchanged. This is important
893 * because when we come to free the pages, we won't
894 * know the originial bi_idx, so we just free
895 * them all
896 */
901 }
906 }
918 #if 0
921 #endif
924 }
927 {
938 }
941 }
945 {
949 /*
950 * If it is not operational, then we have already marked it as dead
951 * else if it is the last working disks, ignore the error, let the
952 * next level up know.
953 * else mark the drive as failed
954 */
957 /*
958 * Don't fail the drive, act as though we were just a
959 * normal single drive
960 */
965 /*
966 * if recovery is running, make sure it aborts.
967 */
969 }
976 }
979 {
986 }
999 }
1001 }
1004 {
1010 }
1013 {
1017 /*
1018 * Find all failed disks within the RAID1 configuration
1019 * and mark them readable.
1020 * Called under mddev lock, so rcu protection not needed.
1021 */
1030 }
1031 }
1035 }
1039 {
1050 /* as we don't honour merge_bvec_fn, we must never risk
1051 * violating it, so limit ->max_sector to one PAGE, as
1052 * a one page request is never in violation.
1053 */
1061 /* As all devices are equivalent, we don't need a full recovery
1062 * if this was recently any drive of the array
1063 */
1068 }
1072 }
1075 {
1088 }
1092 /* lost the race, try later */
1095 }
1096 }
1097 abort:
1101 }
1105 {
1117 /*
1118 * we have read a block, now it needs to be re-written,
1119 * or re-read if the read failed.
1120 * We don't do much here, just schedule handling by raid1d
1121 */
1128 }
1131 {
1146 }
1151 /* make sure these bits doesn't get cleared. */
1159 }
1166 }
1168 }
1171 {
1181 /* We have read all readable devices. If we haven't
1182 * got the block, then there is no hope left.
1183 * If we have, then we want to do a comparison
1184 * and skip the write if everything is the same.
1185 * If any blocks failed to read, then we need to
1186 * attempt an over-write
1187 */
1197 }
1204 }
1216 PAGE_SIZE))
1224 /* fixup the bio for reuse */
1238 }
1239 }
1240 }
1242 /* ouch - failed to read all of that.
1243 * Try some synchronous reads of other devices to get
1244 * good data, much like with normal read errors. Only
1245 * read into the pages we already have so we don't
1246 * need to re-issue the read request.
1247 * We don't need to freeze the array, because being in an
1248 * active sync request, there is no normal IO, and
1249 * no overlapping syncs.
1250 */
1265 /* No rcu protection needed here devices
1266 * can only be removed when no resync is
1267 * active, and resync is currently active
1268 */
1274 READ)) {
1277 }
1278 }
1279 d++;
1286 /* write it back and re-read */
1291 d--;
1302 }
1307 d--;
1317 }
1320 /* Cannot read from anywhere, array is toast */
1329 }
1332 idx ++;
1333 }
1334 }
1336 /*
1337 * schedule writes
1338 */
1354 }
1357 /* if we're here, all write(s) have completed, so clean up */
1360 }
1361 }
1363 /*
1364 * This is a kernel thread which:
1365 *
1366 * 1. Retries failed read operations on working mirrors.
1367 * 2. Updates the raid superblock when problems encounter.
1368 * 3. Performs writes following reads for array syncronising.
1369 */
1372 {
1391 /* flush any pending bitmap writes to disk before proceeding w/ I/O */
1400 }
1404 }
1419 /* some requests in the r1bio were BIO_RW_BARRIER
1420 * requests which failed with -EOPNOTSUPP. Hohumm..
1421 * Better resubmit without the barrier.
1422 * We know which devices to resubmit for, because
1423 * all others have had their bios[] entry cleared.
1424 * We already have a nr_pending reference on these rdevs.
1425 */
1438 /* copy pages from the failed bio, as
1439 * this might be a write-behind device */
1451 }
1455 /* we got a read error. Maybe the drive is bad. Maybe just
1456 * the block and we can fix it.
1457 * We freeze all other IO, and try reading the block from
1458 * other devices. When we find one, we re-write
1459 * and check it that fixes the read error.
1460 * This is all done synchronously while the array is
1461 * frozen
1462 */
1475 /* Note: no rcu protection needed here
1476 * as this is synchronous in the raid1d thread
1477 * which is the thread that might remove
1478 * a device. If raid1d ever becomes multi-threaded....
1479 */
1489 d++;
1492 }
1496 /* write it back and re-read */
1501 d--;
1508 /* Well, this device is dead */
1510 }
1511 }
1516 d--;
1523 /* Well, this device is dead */
1529 }
1530 }
1531 }
1533 /* Cannot read from anywhere -- bye bye array */
1536 }
1539 }
1570 }
1571 }
1572 }
1576 }
1580 {
1591 }
1593 /*
1594 * perform a "sync" on one "block"
1595 *
1596 * We need to make sure that no normal I/O request - particularly write
1597 * requests - conflict with active sync requests.
1598 *
1599 * This is achieved by tracking pending requests and a 'barrier' concept
1600 * that can be installed to exclude normal IO requests.
1601 */
1604 {
1617 {
1618 /*
1619 printk("sync start - bitmap %p\n", mddev->bitmap);
1620 */
1623 }
1627 /* If we aborted, we need to abort the
1628 * sync on the 'current' bitmap chunk (there will
1629 * only be one in raid1 resync.
1630 * We can find the current addess in mddev->curr_resync
1631 */
1641 }
1649 }
1650 /* before building a request, check if we can skip these blocks..
1651 * This call the bitmap_start_sync doesn't actually record anything
1652 */
1655 /* We can skip this block, and probably several more */
1658 }
1659 /*
1660 * If there is non-resync activity waiting for a turn,
1661 * and resync is going fast enough,
1662 * then let it though before starting on this new sync request.
1663 */
1673 /*
1674 * If we get a correctably read error during resync or recovery,
1675 * we might want to read from a different device. So we
1676 * flag all drives that could conceivably be read from for READ,
1677 * and any others (which will be non-In_sync devices) for WRITE.
1678 * If a read fails, we try reading from something else for which READ
1679 * is OK.
1680 */
1691 /* take from bio_init */
1711 write_targets ++;
1713 /* may need to read from here */
1722 }
1723 read_targets++;
1724 }
1729 }
1736 /* extra read targets are also write targets */
1740 /* There is nowhere to write, so all non-sync
1741 * drives must be failed - so we are finished
1742 */
1747 }
1767 }
1774 /* stop here */
1777 i--;
1781 /* remove last page from this bio */
1785 }
1787 }
1788 }
1789 }
1794 bio_full:
1797 /* For a user-requested sync, we read all readable devices and do a
1798 * compare
1799 */
1807 }
1808 }
1815 }
1817 }
1820 {
1831 }
1836 }
1837 /*
1838 * copy the already verified devices into our private RAID1
1839 * bookkeeping area. [whatever we allocate in run(),
1840 * should be freed in stop()]
1841 */
1848 GFP_KERNEL);
1862 r1bio_pool_free,
1878 /* as we don't honour merge_bvec_fn, we must never risk
1879 * violating it, so limit ->max_sector to one PAGE, as
1880 * a one page request is never in violation.
1881 */
1889 }
1907 }
1918 }
1919 }
1921 /*
1922 * find the first working one and use it as a starting point
1923 * to read balancing.
1924 */
1938 }
1944 /*
1945 * Ok, everything is just fine now
1946 */
1954 out_no_mem:
1958 out_free_conf:
1967 }
1968 out:
1970 }
1973 {
1978 /* wait for behind writes to complete */
1980 behind_wait++;
1981 printk(KERN_INFO "raid1: behind writes in progress on device %s, waiting to stop (%d)\n", mdname(mddev), behind_wait);
1984 /* need to kick something here to make sure I/O goes? */
1985 }
1997 }
2000 {
2001 /* no resync is happening, and there is enough space
2002 * on all devices, so we can resize.
2003 * We need to make sure resync covers any new space.
2004 * If the array is shrinking we should possibly wait until
2005 * any io in the removed space completes, but it hardly seems
2006 * worth it.
2007 */
2014 }
2018 }
2021 {
2022 /* We need to:
2023 * 1/ resize the r1bio_pool
2024 * 2/ resize conf->mirrors
2025 *
2026 * We allocate a new r1bio_pool if we can.
2027 * Then raise a device barrier and wait until all IO stops.
2028 * Then resize conf->mirrors and swap in the new r1bio pool.
2029 *
2030 * At the same time, we "pack" the devices so that all the missing
2031 * devices have the higher raid_disk numbers.
2032 */
2041 /* Cannot change chunk_size, layout, or level */
2049 }
2057 cnt++;
2060 }
2073 }
2079 }
2083 /* ok, everything is stopped */
2091 }
2109 }
2112 {
2122 }
2123 }
2127 {
2143 };
2146 {
2148 }
2151 {
2153 }