| blob | c025a8276dc18b5844e7a6870b42236ac45bd86c |
1 /*
2 * raid10.c : Multiple Devices driver for Linux
3 *
4 * Copyright (C) 2000-2004 Neil Brown
5 *
6 * RAID-10 support for md.
7 *
8 * Base on code in raid1.c. See raid1.c for further copyright information.
9 *
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2, or (at your option)
14 * any later version.
15 *
16 * You should have received a copy of the GNU General Public License
17 * (for example /usr/src/linux/COPYING); if not, write to the Free
18 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
21 #include <linux/slab.h>
22 #include <linux/delay.h>
23 #include <linux/blkdev.h>
24 #include <linux/seq_file.h>
25 #include <linux/ratelimit.h>
31 /*
32 * RAID10 provides a combination of RAID0 and RAID1 functionality.
33 * The layout of data is defined by
34 * chunk_size
35 * raid_disks
36 * near_copies (stored in low byte of layout)
37 * far_copies (stored in second byte of layout)
38 * far_offset (stored in bit 16 of layout )
39 *
40 * The data to be stored is divided into chunks using chunksize.
41 * Each device is divided into far_copies sections.
42 * In each section, chunks are laid out in a style similar to raid0, but
43 * near_copies copies of each chunk is stored (each on a different drive).
44 * The starting device for each section is offset near_copies from the starting
45 * device of the previous section.
46 * Thus they are (near_copies*far_copies) of each chunk, and each is on a different
47 * drive.
48 * near_copies and far_copies must be at least one, and their product is at most
49 * raid_disks.
50 *
51 * If far_offset is true, then the far_copies are handled a bit differently.
52 * The copies are still in different stripes, but instead of be very far apart
53 * on disk, there are adjacent stripes.
54 */
56 /*
57 * Number of guaranteed r10bios in case of extreme VM load:
58 */
59 #define NR_RAID10_BIOS 256
61 /* When there are this many requests queue to be written by
62 * the raid10 thread, we become 'congested' to provide back-pressure
63 * for writeback.
64 */
71 {
75 /* allocate a r10bio with room for raid_disks entries in the bios array */
77 }
80 {
82 }
84 /* Maximum size of each resync request */
85 #define RESYNC_BLOCK_SIZE (64*1024)
86 #define RESYNC_PAGES ((RESYNC_BLOCK_SIZE + PAGE_SIZE-1) / PAGE_SIZE)
87 /* amount of memory to reserve for resync requests */
88 #define RESYNC_WINDOW (1024*1024)
89 /* maximum number of concurrent requests, memory permitting */
90 #define RESYNC_DEPTH (32*1024*1024/RESYNC_BLOCK_SIZE)
92 /*
93 * When performing a resync, we need to read and compare, so
94 * we need as many pages are there are copies.
95 * When performing a recovery, we need 2 bios, one for read,
96 * one for write (we recover only one drive per r10buf)
97 *
98 */
100 {
114 else
117 /*
118 * Allocate bios.
119 */
125 }
126 /*
127 * Allocate RESYNC_PAGES data pages and attach them
128 * where needed.
129 */
135 /* we can share bv_page's during recovery */
145 }
146 }
150 out_free_pages:
157 out_free_bio:
162 }
165 {
177 }
179 }
180 }
182 }
185 {
193 }
194 }
197 {
202 }
205 {
211 }
214 {
224 /* wake up frozen array... */
228 }
230 /*
231 * raid_end_bio_io() is called when we have finished servicing a mirrored
232 * operation and are ready to return a success/failure code to the buffer
233 * cache layer.
234 */
236 {
253 /*
254 * Wake up any possible resync thread that waits for the device
255 * to go idle.
256 */
258 }
260 }
262 /*
263 * Update disk head position estimator based on IRQ completion info.
264 */
266 {
271 }
273 /*
274 * Find the disk number which triggered given bio
275 */
278 {
291 }
294 {
303 /*
304 * this branch is our 'one mirror IO has finished' event handler:
305 */
309 /*
310 * Set R10BIO_Uptodate in our master bio, so that
311 * we will return a good error code to the higher
312 * levels even if IO on some other mirrored buffer fails.
313 *
314 * The 'master' represents the composite IO operation to
315 * user-side. So if something waits for IO, then it will
316 * wait for the 'master' bio.
317 */
322 /*
323 * oops, read error - keep the refcount on the rdev
324 */
333 }
334 }
337 {
338 /* clear the bitmap if all writes complete successfully */
344 }
347 {
355 else
357 }
358 }
359 }
362 {
372 /*
373 * this branch is our 'one mirror IO has finished' event handler:
374 */
380 /*
381 * Set R10BIO_Uptodate in our master bio, so that
382 * we will return a good error code for to the higher
383 * levels even if IO on some other mirrored buffer fails.
384 *
385 * The 'master' represents the composite IO operation to
386 * user-side. So if something waits for IO, then it will
387 * wait for the 'master' bio.
388 */
389 sector_t first_bad;
394 /* Maybe we can clear some bad blocks. */
403 }
404 }
406 /*
407 *
408 * Let's see if all mirrored write operations have finished
409 * already.
410 */
414 }
417 /*
418 * RAID10 layout manager
419 * As well as the chunksize and raid_disks count, there are two
420 * parameters: near_copies and far_copies.
421 * near_copies * far_copies must be <= raid_disks.
422 * Normally one of these will be 1.
423 * If both are 1, we get raid0.
424 * If near_copies == raid_disks, we get raid1.
425 *
426 * Chunks are laid out in raid0 style with near_copies copies of the
427 * first chunk, followed by near_copies copies of the next chunk and
428 * so on.
429 * If far_copies > 1, then after 1/far_copies of the array has been assigned
430 * as described above, we start again with a device offset of near_copies.
431 * So we effectively have another copy of the whole array further down all
432 * the drives, but with blocks on different drives.
433 * With this layout, and block is never stored twice on the one device.
434 *
435 * raid10_find_phys finds the sector offset of a given virtual sector
436 * on each device that it is on.
437 *
438 * raid10_find_virt does the reverse mapping, from a device and a
439 * sector offset to a virtual address
440 */
443 {
445 sector_t sector;
446 sector_t chunk;
447 sector_t stripe;
452 /* now calculate first sector/dev */
464 /* and calculate all the others */
470 slot++;
479 slot++;
480 }
481 dev++;
485 }
486 }
488 }
491 {
507 else
509 }
511 }
515 }
517 /**
518 * raid10_mergeable_bvec -- tell bio layer if a two requests can be merged
519 * @q: request queue
520 * @bvm: properties of new bio
521 * @biovec: the request that could be merged to it.
522 *
523 * Return amount of bytes we can accept at this offset
524 * If near_copies == raid_disk, there are no striping issues,
525 * but in that case, the function isn't called at all.
526 */
530 {
541 else
543 }
545 /*
546 * This routine returns the disk from which the requested read should
547 * be done. There is a per-array 'next expected sequential IO' sector
548 * number - if this matches on the next IO then we use the last disk.
549 * There is also a per-disk 'last know head position' sector that is
550 * maintained from IRQ contexts, both the normal and the resync IO
551 * completion handlers update this position correctly. If there is no
552 * perfect sequential match then we pick the disk whose head is closest.
553 *
554 * If there are 2 mirrors in the same 2 devices, performance degrades
555 * because position is mirror, not device based.
556 *
557 * The rdev for the device selected will have nr_pending incremented.
558 */
560 /*
561 * FIXME: possibly should rethink readbalancing and do it differently
562 * depending on near_copies / far_copies geometry.
563 */
565 {
577 retry:
583 /*
584 * Check if we can balance. We can balance on the whole
585 * device if no resync is going on (recovery is ok), or below
586 * the resync window. We take the first readable disk when
587 * above the resync window.
588 */
594 sector_t first_bad;
596 sector_t dev_sector;
611 /* Already have a better slot */
614 /* Cannot read here. If this is the
615 * 'primary' device, then we must not read
616 * beyond 'bad_sectors' from another device.
617 */
624 sector_t good_sectors =
629 }
631 /* Must read from here */
633 }
641 /* This optimisation is debatable, and completely destroys
642 * sequential read speed for 'far copies' arrays. So only
643 * keep it for 'near' arrays, and review those later.
644 */
648 /* for far > 1 always use the lowest address */
651 else
657 }
658 }
669 /* Cannot risk returning a device that failed
670 * before we inc'ed nr_pending
671 */
674 }
682 }
685 {
703 }
704 }
707 }
710 {
711 /* Any writes that have been queued but are awaiting
712 * bitmap updates get flushed here.
713 */
721 /* flush any pending bitmap writes to disk
722 * before proceeding w/ I/O */
731 }
734 }
736 /* Barriers....
737 * Sometimes we need to suspend IO while we do something else,
738 * either some resync/recovery, or reconfigure the array.
739 * To do this we raise a 'barrier'.
740 * The 'barrier' is a counter that can be raised multiple times
741 * to count how many activities are happening which preclude
742 * normal IO.
743 * We can only raise the barrier if there is no pending IO.
744 * i.e. if nr_pending == 0.
745 * We choose only to raise the barrier if no-one is waiting for the
746 * barrier to go down. This means that as soon as an IO request
747 * is ready, no other operations which require a barrier will start
748 * until the IO request has had a chance.
749 *
750 * So: regular IO calls 'wait_barrier'. When that returns there
751 * is no backgroup IO happening, It must arrange to call
752 * allow_barrier when it has finished its IO.
753 * backgroup IO calls must call raise_barrier. Once that returns
754 * there is no normal IO happeing. It must arrange to call
755 * lower_barrier when the particular background IO completes.
756 */
759 {
763 /* Wait until no block IO is waiting (unless 'force') */
767 /* block any new IO from starting */
770 /* Now wait for all pending IO to complete */
776 }
779 {
785 }
788 {
794 );
796 }
799 }
802 {
808 }
811 {
812 /* stop syncio and normal IO and wait for everything to
813 * go quiet.
814 * We increment barrier and nr_waiting, and then
815 * wait until nr_pending match nr_queued+1
816 * This is called in the context of one normal IO request
817 * that has failed. Thus any sync request that might be pending
818 * will be blocked by nr_pending, and we need to wait for
819 * pending IO requests to complete or be queued for re-try.
820 * Thus the number queued (nr_queued) plus this request (1)
821 * must match the number of pending IOs (nr_pending) before
822 * we continue.
823 */
833 }
836 {
837 /* reverse the effect of the freeze */
843 }
846 {
865 }
867 /* If this request crosses a chunk boundary, we need to
868 * split it. This will only happen for 1 PAGE (or less) requests.
869 */
874 /* Sanity check -- queue functions should prevent this happening */
878 /* This is a one page bio that upper layers
879 * refuse to split for us, so we need to split it.
880 */
884 /* Each of these 'make_request' calls will call 'wait_barrier'.
885 * If the first succeeds but the second blocks due to the resync
886 * thread raising the barrier, we will deadlock because the
887 * IO to the underlying device will be queued in generic_make_request
888 * and will never complete, so will never reduce nr_pending.
889 * So increment nr_waiting here so no new raise_barriers will
890 * succeed, and so the second wait_barrier cannot block.
891 */
908 bad_map:
915 }
919 /*
920 * Register the new request and wait if the reconstruction
921 * thread has put up a bar for new requests.
922 * Continue immediately if no resync is active currently.
923 */
935 /* We might need to issue multiple reads to different
936 * devices if there are bad blocks around, so we keep
937 * track of the number of reads in bio->bi_phys_segments.
938 * If this is 0, there is only one r10_bio and no locking
939 * will be needed when the request completes. If it is
940 * non-zero, then it is the number of not-completed requests.
941 */
946 /*
947 * read balancing logic:
948 */
952 read_again:
958 }
963 max_sectors);
975 /* Could not read all from this device, so we will
976 * need another r10_bio.
977 */
984 else
987 /* Cannot call generic_make_request directly
988 * as that will be queued in __generic_make_request
989 * and subsequent mempool_alloc might block
990 * waiting for it. so hand bio over to raid10d.
991 */
1006 }
1008 /*
1009 * WRITE:
1010 */
1015 }
1016 /* first select target devices under rcu_lock and
1017 * inc refcount on their rdev. Record them by setting
1018 * bios[x] to bio
1019 * If there are known/acknowledged bad blocks on any device
1020 * on which we have seen a write error, we want to avoid
1021 * writing to those blocks. This potentially requires several
1022 * writes to write around the bad blocks. Each set of writes
1023 * gets its own r10_bio with a set of bios attached. The number
1024 * of r10_bios is recored in bio->bi_phys_segments just as with
1025 * the read case.
1026 */
1030 retry_write:
1042 }
1047 }
1049 sector_t first_bad;
1055 max_sectors,
1058 /* Mustn't write here until the bad block
1059 * is acknowledged
1060 */
1065 }
1067 /* Cannot write here at all */
1070 /* Mustn't write more than bad_sectors
1071 * to other devices yet
1072 */
1074 /* We don't set R10BIO_Degraded as that
1075 * only applies if the disk is missing,
1076 * so it might be re-added, and we want to
1077 * know to recover this chunk.
1078 * In this case the device is here, and the
1079 * fact that this chunk is not in-sync is
1080 * recorded in the bad block log.
1081 */
1083 }
1088 }
1089 }
1092 }
1096 /* Have to wait for this device to get unblocked, then retry */
1104 }
1109 }
1112 /* We are splitting this into multiple parts, so
1113 * we need to prepare for allocating another r10_bio.
1114 */
1119 else
1122 }
1136 max_sectors);
1151 }
1153 /* Don't remove the bias on 'remaining' (one_write_done) until
1154 * after checking if we need to go around again.
1155 */
1159 /* We need another r10_bio. It has already been counted
1160 * in bio->bi_phys_segments.
1161 */
1171 }
1174 /* In case raid10d snuck in to freeze_array */
1180 }
1183 {
1194 else
1196 }
1204 }
1206 /* check if there are enough drives for
1207 * every block to appear on atleast one.
1208 * Don't consider the device numbered 'ignore'
1209 * as we might be about to remove it.
1210 */
1212 {
1221 cnt++;
1223 }
1228 }
1231 {
1235 /*
1236 * If it is not operational, then we have already marked it as dead
1237 * else if it is the last working disks, ignore the error, let the
1238 * next level up know.
1239 * else mark the drive as failed
1240 */
1243 /*
1244 * Don't fail the drive, just return an IO error.
1245 */
1252 /*
1253 * if recovery is running, make sure it aborts.
1254 */
1256 }
1265 }
1268 {
1276 }
1288 }
1289 }
1292 {
1298 }
1301 {
1308 /*
1309 * Find all non-in_sync disks within the RAID10 configuration
1310 * and mark them in_sync
1311 */
1317 count++;
1319 }
1320 }
1327 }
1331 {
1339 /* only hot-add to in-sync arrays, as recovery is
1340 * very different from resync
1341 */
1352 else
1363 /* as we don't honour merge_bvec_fn, we must
1364 * never risk violating it, so limit
1365 * ->max_segments to one lying with a single
1366 * page, as a one page request is never in
1367 * violation.
1368 */
1373 }
1383 }
1388 }
1391 {
1404 }
1405 /* Only remove faulty devices in recovery
1406 * is not possible.
1407 */
1413 }
1417 /* lost the race, try later */
1421 }
1423 }
1424 abort:
1428 }
1432 {
1441 else
1442 /* The write handler will notice the lack of
1443 * R10BIO_Uptodate and record any errors etc
1444 */
1448 /* for reconstruct, we always reschedule after a read.
1449 * for resync, only after all reads
1450 */
1454 /* we have read all the blocks,
1455 * do the comparison in process context in raid10d
1456 */
1458 }
1459 }
1462 {
1467 /* the primary of several recovery bios */
1472 else
1481 else
1484 }
1485 }
1486 }
1489 {
1495 sector_t first_bad;
1513 }
1515 /*
1516 * Note: sync and recover and handled very differently for raid10
1517 * This code is for resync.
1518 * For resync, we read through virtual addresses and read all blocks.
1519 * If there is any error, we schedule a write. The lowest numbered
1520 * drive is authoritative.
1521 * However requests come for physical address, so we need to map.
1522 * For every physical address there are raid_disks/copies virtual addresses,
1523 * which is always are least one, but is not necessarly an integer.
1524 * This means that a physical address can span multiple chunks, so we may
1525 * have to submit multiple io requests for a single sync request.
1526 */
1527 /*
1528 * We check if all blocks are in-sync and only write to blocks that
1529 * aren't in sync
1530 */
1532 {
1539 /* find the first device with a block */
1550 /* now find blocks with errors */
1562 /* We know that the bi_io_vec layout is the same for
1563 * both 'first' and 'i', so we just compare them.
1564 * All vec entries are PAGE_SIZE;
1565 */
1569 PAGE_SIZE))
1575 /* Don't fix anything. */
1577 }
1578 /* Ok, we need to write this bio, either to correct an
1579 * inconsistency or to correct an unreadable block.
1580 * First we need to fixup bv_offset, bv_len and
1581 * bi_vecs, as the read request might have corrupted these
1582 */
1600 PAGE_SIZE);
1601 }
1612 }
1614 done:
1618 }
1619 }
1621 /*
1622 * Now for the recovery code.
1623 * Recovery happens across physical sectors.
1624 * We recover all non-is_sync drives by finding the virtual address of
1625 * each, and then choose a working drive that also has that virt address.
1626 * There is a separate r10_bio for each non-in_sync drive.
1627 * Only the first two slots are in use. The first for reading,
1628 * The second for writing.
1629 *
1630 */
1632 {
1633 /* We got a read error during recovery.
1634 * We repeat the read in smaller page-sized sections.
1635 * If a read succeeds, write it to the new device or record
1636 * a bad block if we cannot.
1637 * If a read fails, record a bad block on both old and
1638 * new devices.
1639 */
1652 sector_t addr;
1661 addr,
1669 addr,
1675 }
1677 /* We don't worry if we cannot set a bad block -
1678 * it really is bad so there is no loss in not
1679 * recording it yet
1680 */
1684 /* need bad block on destination too */
1689 /* just abort the recovery */
1691 "md/raid10:%s: recovery aborted"
1700 }
1701 }
1702 }
1706 idx++;
1707 }
1708 }
1711 {
1720 }
1722 /*
1723 * share the pages with the first bio
1724 * and submit the write request
1725 */
1732 }
1735 /*
1736 * Used by fix_read_error() to decay the per rdev read_errors.
1737 * We halve the read error count for every hour that has elapsed
1738 * since the last recorded read error.
1739 *
1740 */
1742 {
1751 /* first time we've seen a read error */
1754 }
1761 /*
1762 * if hours_since_last is > the number of bits in read_errors
1763 * just set read errors to 0. We do this to avoid
1764 * overflowing the shift of read_errors by hours_since_last.
1765 */
1768 else
1770 }
1774 {
1775 sector_t first_bad;
1782 /* success */
1786 /* need to record an error - either for the block or the device */
1790 }
1792 /*
1793 * This is a kernel thread which:
1794 *
1795 * 1. Retries failed read operations on working mirrors.
1796 * 2. Updates the raid superblock when problems encounter.
1797 * 3. Performs writes following reads for array synchronising.
1798 */
1801 {
1808 /* still own a reference to this rdev, so it cannot
1809 * have been cleared recently.
1810 */
1814 /* drive has already been failed, just ignore any
1815 more fix_read_error() attempts */
1825 "md/raid10:%s: %s: Raid device exceeded "
1834 }
1847 sector_t first_bad;
1860 sect,
1867 }
1868 sl++;
1875 /* Cannot read from anywhere, just mark the block
1876 * as bad on the first device to discourage future
1877 * reads.
1878 */
1883 rdev,
1889 }
1892 /* write it back and re-read */
1899 sl--;
1910 sect,
1913 /* Well, this device is dead */
1915 "md/raid10:%s: read correction "
1916 "write failed"
1926 }
1929 }
1936 sl--;
1947 sect,
1949 READ)) {
1951 /* Well, this device is dead */
1953 "md/raid10:%s: unable to read back "
1954 "corrected sectors"
1967 "md/raid10:%s: read error corrected"
1974 }
1978 }
1983 }
1984 }
1987 {
1989 }
1992 {
2003 }
2006 {
2011 /* bio has the data to be written to slot 'i' where
2012 * we just recently had a write error.
2013 * We repeatedly clone the bio and trim down to one block,
2014 * then try the write. Where the write fails we record
2015 * a bad block.
2016 * It is conceivable that the bio doesn't exactly align with
2017 * blocks. We must handle this.
2018 *
2019 * We currently own a reference to the rdev.
2020 */
2023 sector_t sector;
2041 /* Write at 'sector' for 'sectors' */
2049 /* Failure! */
2058 }
2060 }
2063 {
2073 /* we got a read error. Maybe the drive is bad. Maybe just
2074 * the block and we can fix it.
2075 * We freeze all other IO, and try reading the block from
2076 * other devices. When we find one, we re-write
2077 * and check it that fixes the read error.
2078 * This is all done synchronously while the array is
2079 * frozen.
2080 */
2085 }
2092 read_more:
2102 }
2110 KERN_ERR
2111 "md/raid10:%s: %s: redirecting"
2120 max_sectors);
2129 /* Drat - have to split this up more */
2138 else
2145 GFP_NOIO);
2159 }
2162 {
2163 /* Some sort of write request has finished and it
2164 * succeeded in writing where we thought there was a
2165 * bad block. So forget the bad block.
2166 * Or possibly if failed and we need to record
2167 * a bad block.
2168 */
2182 rdev,
2187 rdev,
2191 }
2192 }
2201 rdev,
2211 }
2213 }
2214 }
2219 }
2220 }
2223 {
2241 }
2259 /* just a partial read to be scheduled from a
2260 * separate context
2261 */
2264 }
2269 }
2271 }
2275 {
2285 }
2287 /*
2288 * perform a "sync" on one "block"
2289 *
2290 * We need to make sure that no normal I/O request - particularly write
2291 * requests - conflict with active sync requests.
2292 *
2293 * This is achieved by tracking pending requests and a 'barrier' concept
2294 * that can be installed to exclude normal IO requests.
2295 *
2296 * Resync and recovery are handled very differently.
2297 * We differentiate by looking at MD_RECOVERY_SYNC in mddev->recovery.
2298 *
2299 * For resync, we iterate over virtual addresses, read all copies,
2300 * and update if there are differences. If only one copy is live,
2301 * skip it.
2302 * For recovery, we iterate over physical addresses, read a good
2303 * value for each non-in_sync drive, and over-write.
2304 *
2305 * So, for recovery we may have several outstanding complex requests for a
2306 * given address, one for each out-of-sync device. We model this by allocating
2307 * a number of r10_bio structures, one for each out-of-sync device.
2308 * As we setup these structures, we collect all bio's together into a list
2309 * which we then process collectively to add pages, and then process again
2310 * to pass to generic_make_request.
2311 *
2312 * The r10_bio structures are linked using a borrowed master_bio pointer.
2313 * This link is counted in ->remaining. When the r10_bio that points to NULL
2314 * has its remaining count decremented to 0, the whole complex operation
2315 * is complete.
2316 *
2317 */
2321 {
2328 sector_t sync_blocks;
2336 skipped:
2341 /* If we aborted, we need to abort the
2342 * sync on the 'current' bitmap chucks (there can
2343 * be several when recovering multiple devices).
2344 * as we may have started syncing it but not finished.
2345 * We can find the current address in
2346 * mddev->curr_resync, but for recovery,
2347 * we need to convert that to several
2348 * virtual addresses.
2349 */
2355 sector_t sect =
2359 }
2367 }
2369 /* if there has been nothing to do on any drive,
2370 * then there is nothing to do at all..
2371 */
2374 }
2379 /* make sure whole request will fit in a chunk - if chunks
2380 * are meaningful
2381 */
2385 /*
2386 * If there is non-resync activity waiting for us then
2387 * put in a delay to throttle resync.
2388 */
2392 /* Again, very different code for resync and recovery.
2393 * Both must result in an r10bio with a list of bios that
2394 * have bi_end_io, bi_sector, bi_bdev set,
2395 * and bi_private set to the r10bio.
2396 * For recovery, we may actually create several r10bios
2397 * with 2 bios in each, that correspond to the bios in the main one.
2398 * In this case, the subordinate r10bios link back through a
2399 * borrowed master_bio pointer, and the counter in the master
2400 * includes a ref from each subordinate.
2401 */
2402 /* First, we decide what to do and set ->bi_end_io
2403 * To end_sync_read if we want to read, and
2404 * end_sync_write if we will want to write.
2405 */
2409 /* recovery... the complicated one */
2416 sector_t sect;
2425 /* want to reconstruct this device */
2428 /* Unless we are doing a full sync, we only need
2429 * to recover the block if it is set in the bitmap
2430 */
2437 /* yep, skip the sync_blocks here, but don't assume
2438 * that there will never be anything to do here
2439 */
2442 }
2457 /* Need to check if the array will still be
2458 * degraded
2459 */
2465 }
2481 /* This is where we read from */
2491 bad_sectors -= (sector
2496 }
2497 }
2510 /* and we write to 'i' */
2533 }
2535 /* Cannot recover, so abort the recovery or
2536 * record a bad block */
2542 /* problem is that there are bad blocks
2543 * on other device(s)
2544 */
2554 }
2563 }
2565 }
2566 }
2573 }
2575 }
2577 /* resync. Schedule a read for every block at this virt offset */
2586 /* We can skip this block */
2589 }
2627 }
2628 }
2639 count++;
2640 }
2647 mddev);
2648 }
2652 }
2653 }
2664 }
2682 /* stop here */
2687 /* remove last page from this bio */
2691 }
2693 }
2697 bio_full:
2711 }
2712 }
2715 /* pretend they weren't skipped, it makes
2716 * no important difference in this case
2717 */
2721 giveup:
2722 /* There is nowhere to write, so all non-sync
2723 * drives must be failed or in resync, all drives
2724 * have a bad block, so try the next chunk...
2725 */
2730 chunks_skipped ++;
2733 }
2735 static sector_t
2737 {
2738 sector_t size;
2752 }
2756 {
2768 }
2779 }
2787 GFP_KERNEL);
2813 /* 'size' is now the number of chunks in the array */
2814 /* calculate "used chunks per device" in 'stride' */
2817 /* We need to round up when dividing by raid_disks to
2818 * get the stride size.
2819 */
2827 else
2845 out:
2854 }
2856 }
2859 {
2864 sector_t size;
2866 /*
2867 * copy the already verified devices into our private RAID10
2868 * bookkeeping area. [whatever we allocate in run(),
2869 * should be freed in stop()]
2870 */
2877 }
2889 else
2904 /* as we don't honour merge_bvec_fn, we must never risk
2905 * violating it, so limit max_segments to 1 lying
2906 * within a single page.
2907 */
2912 }
2915 }
2916 /* need to check that every block has at least one working mirror */
2921 }
2934 }
2936 }
2946 /*
2947 * Ok, everything is just fine now
2948 */
2957 /* Calculate max read-ahead size.
2958 * We need to readahead at least twice a whole stripe....
2959 * maybe...
2960 */
2961 {
2967 }
2977 out_free_conf:
2985 out:
2987 }
2990 {
3004 }
3007 {
3017 }
3018 }
3021 {
3029 }
3031 /* Set new parameters */
3033 /* new layout: far_copies = 1, near_copies = 2 */
3038 /* make sure it will be not marked as dirty */
3047 }
3050 }
3053 {
3056 /* raid10 can take over:
3057 * raid0 - providing it has only two drives
3058 */
3060 /* for raid0 takeover only one zone is supported */
3067 }
3069 }
3071 }
3074 {
3090 };
3093 {
3095 }
3098 {
3100 }