| blob | 8a62c920bb6544917f2979064af568d5c4f071ad |
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * raid10.c : Multiple Devices driver for Linux
4 *
5 * Copyright (C) 2000-2004 Neil Brown
6 *
7 * RAID-10 support for md.
8 *
9 * Base on code in raid1.c. See raid1.c for further copyright information.
10 */
12 #include <linux/slab.h>
13 #include <linux/delay.h>
14 #include <linux/blkdev.h>
15 #include <linux/module.h>
16 #include <linux/seq_file.h>
17 #include <linux/ratelimit.h>
18 #include <linux/kthread.h>
19 #include <linux/raid/md_p.h>
20 #include <trace/events/block.h>
26 /*
27 * RAID10 provides a combination of RAID0 and RAID1 functionality.
28 * The layout of data is defined by
29 * chunk_size
30 * raid_disks
31 * near_copies (stored in low byte of layout)
32 * far_copies (stored in second byte of layout)
33 * far_offset (stored in bit 16 of layout )
34 * use_far_sets (stored in bit 17 of layout )
35 * use_far_sets_bugfixed (stored in bit 18 of layout )
36 *
37 * The data to be stored is divided into chunks using chunksize. Each device
38 * is divided into far_copies sections. In each section, chunks are laid out
39 * in a style similar to raid0, but near_copies copies of each chunk is stored
40 * (each on a different drive). The starting device for each section is offset
41 * near_copies from the starting device of the previous section. Thus there
42 * are (near_copies * far_copies) of each chunk, and each is on a different
43 * drive. near_copies and far_copies must be at least one, and their product
44 * is at most raid_disks.
45 *
46 * If far_offset is true, then the far_copies are handled a bit differently.
47 * The copies are still in different stripes, but instead of being very far
48 * apart on disk, there are adjacent stripes.
49 *
50 * The far and offset algorithms are handled slightly differently if
51 * 'use_far_sets' is true. In this case, the array's devices are grouped into
52 * sets that are (near_copies * far_copies) in size. The far copied stripes
53 * are still shifted by 'near_copies' devices, but this shifting stays confined
54 * to the set rather than the entire array. This is done to improve the number
55 * of device combinations that can fail without causing the array to fail.
56 * Example 'far' algorithm w/o 'use_far_sets' (each letter represents a chunk
57 * on a device):
58 * A B C D A B C D E
59 * ... ...
60 * D A B C E A B C D
61 * Example 'far' algorithm w/ 'use_far_sets' enabled (sets illustrated w/ []'s):
62 * [A B] [C D] [A B] [C D E]
63 * |...| |...| |...| | ... |
64 * [B A] [D C] [B A] [E C D]
65 */
77 #define raid10_log(md, fmt, args...) \
82 /*
83 * for resync bio, r10bio pointer can be retrieved from the per-bio
84 * 'struct resync_pages'.
85 */
87 {
89 }
92 {
96 /* allocate a r10bio with room for raid_disks entries in the
97 * bios array */
99 }
101 #define RESYNC_SECTORS (RESYNC_BLOCK_SIZE >> 9)
102 /* amount of memory to reserve for resync requests */
103 #define RESYNC_WINDOW (1024*1024)
104 /* maximum number of concurrent requests, memory permitting */
105 #define RESYNC_DEPTH (32*1024*1024/RESYNC_BLOCK_SIZE)
106 #define CLUSTER_RESYNC_WINDOW (32 * RESYNC_WINDOW)
107 #define CLUSTER_RESYNC_WINDOW_SECTORS (CLUSTER_RESYNC_WINDOW >> 9)
109 /*
110 * When performing a resync, we need to read and compare, so
111 * we need as many pages are there are copies.
112 * When performing a recovery, we need 2 bios, one for read,
113 * one for write (we recover only one drive per r10buf)
114 *
115 */
117 {
132 else
135 /* allocate once for all bios */
138 else
144 /*
145 * Allocate bios.
146 */
158 }
159 /*
160 * Allocate RESYNC_PAGES data pages and attach them
161 * where needed.
162 */
180 }
187 }
188 }
192 out_free_pages:
197 out_free_bio:
203 }
205 out_free_r10bio:
208 }
211 {
224 }
229 }
231 /* resync pages array stored in the 1st bio's .bi_private */
235 }
238 {
250 }
251 }
254 {
259 }
262 {
268 }
271 {
281 /* wake up frozen array... */
285 }
287 /*
288 * raid_end_bio_io() is called when we have finished servicing a mirrored
289 * operation and are ready to return a success/failure code to the buffer
290 * cache layer.
291 */
293 {
301 /*
302 * Wake up any possible resync thread that waits for the device
303 * to go idle.
304 */
308 }
310 /*
311 * Update disk head position estimator based on IRQ completion info.
312 */
314 {
319 }
321 /*
322 * Find the disk number which triggered given bio
323 */
326 {
336 }
337 }
347 }
350 {
359 /*
360 * this branch is our 'one mirror IO has finished' event handler:
361 */
365 /*
366 * Set R10BIO_Uptodate in our master bio, so that
367 * we will return a good error code to the higher
368 * levels even if IO on some other mirrored buffer fails.
369 *
370 * The 'master' represents the composite IO operation to
371 * user-side. So if something waits for IO, then it will
372 * wait for the 'master' bio.
373 */
376 /* If all other devices that store this block have
377 * failed, we want to return the error upwards rather
378 * than fail the last device. Here we redefine
379 * "uptodate" to mean "Don't want to retry"
380 */
384 }
389 /*
390 * oops, read error - keep the refcount on the rdev
391 */
399 }
400 }
403 {
404 /* clear the bitmap if all writes complete successfully */
410 }
413 {
421 else
423 }
424 }
425 }
428 {
448 }
449 /*
450 * this branch is our 'one mirror IO has finished' event handler:
451 */
454 /* Never record new bad blocks to replacement,
455 * just fail it.
456 */
468 }
470 /*
471 * When the device is faulty, it is not necessary to
472 * handle write error.
473 * For failfast, this is the only remaining device,
474 * We need to retry the write without FailFast.
475 */
482 }
483 }
485 /*
486 * Set R10BIO_Uptodate in our master bio, so that
487 * we will return a good error code for to the higher
488 * levels even if IO on some other mirrored buffer fails.
489 *
490 * The 'master' represents the composite IO operation to
491 * user-side. So if something waits for IO, then it will
492 * wait for the 'master' bio.
493 */
494 sector_t first_bad;
497 /*
498 * Do not set R10BIO_Uptodate if the current device is
499 * rebuilding or Faulty. This is because we cannot use
500 * such device for properly reading the data back (we could
501 * potentially use it, if the current write would have felt
502 * before rdev->recovery_offset, but for simplicity we don't
503 * check this here.
504 */
509 /* Maybe we can clear some bad blocks. */
517 else
521 }
522 }
524 /*
525 *
526 * Let's see if all mirrored write operations have finished
527 * already.
528 */
534 }
536 /*
537 * RAID10 layout manager
538 * As well as the chunksize and raid_disks count, there are two
539 * parameters: near_copies and far_copies.
540 * near_copies * far_copies must be <= raid_disks.
541 * Normally one of these will be 1.
542 * If both are 1, we get raid0.
543 * If near_copies == raid_disks, we get raid1.
544 *
545 * Chunks are laid out in raid0 style with near_copies copies of the
546 * first chunk, followed by near_copies copies of the next chunk and
547 * so on.
548 * If far_copies > 1, then after 1/far_copies of the array has been assigned
549 * as described above, we start again with a device offset of near_copies.
550 * So we effectively have another copy of the whole array further down all
551 * the drives, but with blocks on different drives.
552 * With this layout, and block is never stored twice on the one device.
553 *
554 * raid10_find_phys finds the sector offset of a given virtual sector
555 * on each device that it is on.
556 *
557 * raid10_find_virt does the reverse mapping, from a device and a
558 * sector offset to a virtual address
559 */
562 {
564 sector_t sector;
565 sector_t chunk;
566 sector_t stripe;
577 /* now calculate first sector/dev */
589 /* and calculate all the others */
596 slot++;
610 }
614 slot++;
615 }
616 dev++;
620 }
621 }
622 }
625 {
637 }
640 {
642 /* Never use conf->prev as this is only called during resync
643 * or recovery, so reshape isn't happening
644 */
658 }
659 }
674 else
676 }
678 }
682 }
684 /*
685 * This routine returns the disk from which the requested read should
686 * be done. There is a per-array 'next expected sequential IO' sector
687 * number - if this matches on the next IO then we use the last disk.
688 * There is also a per-disk 'last know head position' sector that is
689 * maintained from IRQ contexts, both the normal and the resync IO
690 * completion handlers update this position correctly. If there is no
691 * perfect sequential match then we pick the disk whose head is closest.
692 *
693 * If there are 2 mirrors in the same 2 devices, performance degrades
694 * because position is mirror, not device based.
695 *
696 * The rdev for the device selected will have nr_pending incremented.
697 */
699 /*
700 * FIXME: possibly should rethink readbalancing and do it differently
701 * depending on near_copies / far_copies geometry.
702 */
706 {
729 /*
730 * Check if we can balance. We can balance on the whole
731 * device if no resync is going on (recovery is ok), or below
732 * the resync window. We take the first readable disk when
733 * above the resync window.
734 */
743 sector_t first_bad;
745 sector_t dev_sector;
767 /* Already have a better slot */
770 /* Cannot read here. If this is the
771 * 'primary' device, then we must not read
772 * beyond 'bad_sectors' from another device.
773 */
780 sector_t good_sectors =
786 }
788 /* Must read from here */
790 }
805 }
808 /* At least 2 disks to choose from so failfast is OK */
810 /* This optimisation is debatable, and completely destroys
811 * sequential read speed for 'far copies' arrays. So only
812 * keep it for 'near' arrays, and review those later.
813 */
817 /* for far > 1 always use the lowest address */
820 else
828 }
829 }
837 }
838 }
849 }
852 {
864 i++) {
870 }
871 }
874 }
877 {
878 /* Any writes that have been queued but are awaiting
879 * bitmap updates get flushed here.
880 */
891 /*
892 * As this is called in a wait_event() loop (see freeze_array),
893 * current->state might be TASK_UNINTERRUPTIBLE which will
894 * cause a warning when we prepare to wait again. As it is
895 * rare that this path is taken, it is perfectly safe to force
896 * us to go around the wait_event() loop again, so the warning
897 * is a false-positive. Silence the warning by resetting
898 * thread state
899 */
903 /* flush any pending bitmap writes to disk
904 * before proceeding w/ I/O */
917 /* Just ignore it */
919 else
922 }
926 }
928 /* Barriers....
929 * Sometimes we need to suspend IO while we do something else,
930 * either some resync/recovery, or reconfigure the array.
931 * To do this we raise a 'barrier'.
932 * The 'barrier' is a counter that can be raised multiple times
933 * to count how many activities are happening which preclude
934 * normal IO.
935 * We can only raise the barrier if there is no pending IO.
936 * i.e. if nr_pending == 0.
937 * We choose only to raise the barrier if no-one is waiting for the
938 * barrier to go down. This means that as soon as an IO request
939 * is ready, no other operations which require a barrier will start
940 * until the IO request has had a chance.
941 *
942 * So: regular IO calls 'wait_barrier'. When that returns there
943 * is no backgroup IO happening, It must arrange to call
944 * allow_barrier when it has finished its IO.
945 * backgroup IO calls must call raise_barrier. Once that returns
946 * there is no normal IO happeing. It must arrange to call
947 * lower_barrier when the particular background IO completes.
948 */
951 {
955 /* Wait until no block IO is waiting (unless 'force') */
959 /* block any new IO from starting */
962 /* Now wait for all pending IO to complete */
968 }
971 {
977 }
980 {
984 /* Wait for the barrier to drop.
985 * However if there are already pending
986 * requests (preventing the barrier from
987 * rising completely), and the
988 * pre-process bio queue isn't empty,
989 * then don't wait, as we need to empty
990 * that queue to get the nr_pending
991 * count down.
992 */
1004 }
1007 }
1010 {
1014 }
1017 {
1018 /* stop syncio and normal IO and wait for everything to
1019 * go quiet.
1020 * We increment barrier and nr_waiting, and then
1021 * wait until nr_pending match nr_queued+extra
1022 * This is called in the context of one normal IO request
1023 * that has failed. Thus any sync request that might be pending
1024 * will be blocked by nr_pending, and we need to wait for
1025 * pending IO requests to complete or be queued for re-try.
1026 * Thus the number queued (nr_queued) plus this request (extra)
1027 * must match the number of pending IOs (nr_pending) before
1028 * we continue.
1029 */
1041 }
1044 {
1045 /* reverse the effect of the freeze */
1051 }
1055 {
1059 else
1061 }
1067 };
1070 {
1072 cb);
1086 }
1088 /* we aren't scheduling, so we can do the write-out directly. */
1102 /* Just ignore it */
1104 else
1107 }
1109 }
1111 /*
1112 * 1. Register the new request and wait if the reconstruction thread has put
1113 * up a bar for new requests. Continue immediately if no resync is active
1114 * currently.
1115 * 2. If IO spans the reshape position. Need to wait for reshape to pass.
1116 */
1119 {
1129 sectors);
1131 }
1132 }
1136 {
1149 /*
1150 * This is an error retry, but we cannot
1151 * safely dereference the rdev in the r10_bio,
1152 * we must use the one in conf.
1153 * If it has already been disconnected (unlikely)
1154 * we lose the device name in error messages.
1155 */
1157 /*
1158 * As we are blocking raid10, it is a little safer to
1159 * use __GFP_HIGH.
1160 */
1170 /* This never gets dereferenced */
1172 }
1174 }
1183 }
1186 }
1202 }
1226 }
1231 {
1246 /* Replacement just got moved to main 'rdev' */
1249 }
1256 else
1274 /* flush_pending_writes() needs access to the rdev so...*/
1282 else
1293 }
1294 }
1298 {
1302 sector_t sectors;
1317 }
1319 }
1329 /* Need to update reshape_position in metadata */
1339 }
1346 }
1347 /* first select target devices under rcu_lock and
1348 * inc refcount on their rdev. Record them by setting
1349 * bios[x] to bio
1350 * If there are known/acknowledged bad blocks on any device
1351 * on which we have seen a write error, we want to avoid
1352 * writing to those blocks. This potentially requires several
1353 * writes to write around the bad blocks. Each set of writes
1354 * gets its own r10_bio with a set of bios attached.
1355 */
1359 retry_write:
1375 }
1380 }
1392 }
1394 sector_t first_bad;
1402 /* Mustn't write here until the bad block
1403 * is acknowledged
1404 */
1409 }
1411 /* Cannot write here at all */
1414 /* Mustn't write more than bad_sectors
1415 * to other devices yet
1416 */
1418 /* We don't set R10BIO_Degraded as that
1419 * only applies if the disk is missing,
1420 * so it might be re-added, and we want to
1421 * know to recover this chunk.
1422 * In this case the device is here, and the
1423 * fact that this chunk is not in-sync is
1424 * recorded in the bad block log.
1425 */
1427 }
1432 }
1433 }
1437 }
1441 }
1442 }
1446 /* Have to wait for this device to get unblocked, then retry */
1454 }
1460 /* Race with remove_disk */
1463 }
1465 }
1466 }
1472 }
1486 }
1496 }
1498 }
1501 {
1517 else
1519 }
1522 {
1531 }
1536 /*
1537 * If this request crosses a chunk boundary, we need to split
1538 * it.
1539 */
1541 sectors > chunk_sects
1550 /* In case raid10d snuck in to freeze_array */
1553 }
1556 {
1567 else
1571 }
1578 }
1581 }
1583 /* check if there are enough drives for
1584 * every block to appear on atleast one.
1585 * Don't consider the device numbered 'ignore'
1586 * as we might be about to remove it.
1587 */
1589 {
1599 }
1611 cnt++;
1613 }
1619 out:
1622 }
1625 {
1626 /* when calling 'enough', both 'prev' and 'geo' must
1627 * be stable.
1628 * This is ensured if ->reconfig_mutex or ->device_lock
1629 * is held.
1630 */
1633 }
1636 {
1641 /*
1642 * If it is not operational, then we have already marked it as dead
1643 * else if it is the last working disks with "fail_last_dev == false",
1644 * ignore the error, let the next level up know.
1645 * else mark the drive as failed
1646 */
1650 /*
1651 * Don't fail the drive, just return an IO error.
1652 */
1655 }
1658 /*
1659 * If recovery is running, make sure it aborts.
1660 */
1671 }
1674 {
1682 }
1686 /* This is only called with ->reconfix_mutex held, so
1687 * rcu protection of rdev is not needed */
1696 }
1697 }
1700 {
1705 }
1708 {
1715 /*
1716 * Find all non-in_sync disks within the RAID10 configuration
1717 * and mark them in_sync
1718 */
1725 /* Replacement has just become active */
1728 count++;
1730 /* Replaced device not technically faulty,
1731 * but we need to be sure it gets removed
1732 * and never re-added.
1733 */
1737 }
1743 count++;
1745 }
1746 }
1753 }
1756 {
1764 /* only hot-add to in-sync arrays, as recovery is
1765 * very different from resync
1766 */
1781 else
1801 }
1815 }
1821 }
1824 {
1836 else
1843 }
1844 /* Only remove non-faulty devices if recovery
1845 * is not possible.
1846 */
1854 }
1859 /* lost the race, try later */
1863 }
1864 }
1866 /* We must have just cleared 'rdev' */
1870 * but will never see neither -- if they are careful.
1871 */
1873 }
1878 abort:
1882 }
1885 {
1890 else
1891 /* The write handler will notice the lack of
1892 * R10BIO_Uptodate and record any errors etc
1893 */
1897 /* for reconstruct, we always reschedule after a read.
1898 * for resync, only after all reads
1899 */
1903 /* we have read all the blocks,
1904 * do the comparison in process context in raid10d
1905 */
1907 }
1908 }
1911 {
1917 }
1920 {
1921 /* reshape read bio isn't allocated from r10buf_pool */
1925 }
1928 {
1933 /* the primary of several recovery bios */
1938 else
1947 else
1950 }
1951 }
1952 }
1955 {
1960 sector_t first_bad;
1969 else
1981 }
1991 }
1993 /*
1994 * Note: sync and recover and handled very differently for raid10
1995 * This code is for resync.
1996 * For resync, we read through virtual addresses and read all blocks.
1997 * If there is any error, we schedule a write. The lowest numbered
1998 * drive is authoritative.
1999 * However requests come for physical address, so we need to map.
2000 * For every physical address there are raid_disks/copies virtual addresses,
2001 * which is always are least one, but is not necessarly an integer.
2002 * This means that a physical address can span multiple chunks, so we may
2003 * have to submit multiple io requests for a single sync request.
2004 */
2005 /*
2006 * We check if all blocks are in-sync and only write to blocks that
2007 * aren't in sync
2008 */
2010 {
2019 /* find the first device with a block */
2034 /* now find blocks with errors */
2051 /* We know that the bi_io_vec layout is the same for
2052 * both 'first' and 'i', so we just compare them.
2053 * All vec entries are PAGE_SIZE;
2054 */
2062 len))
2065 }
2070 /* Don't fix anything. */
2073 /* Just give up on this device */
2076 }
2077 /* Ok, we need to write this bio, either to correct an
2078 * inconsistency or to correct an unreadable block.
2079 * First we need to fixup bv_offset, bv_len and
2080 * bi_vecs, as the read request might have corrupted these
2081 */
2104 }
2106 /* Now write out to any replacement devices
2107 * that are active
2108 */
2123 }
2125 done:
2129 }
2130 }
2132 /*
2133 * Now for the recovery code.
2134 * Recovery happens across physical sectors.
2135 * We recover all non-is_sync drives by finding the virtual address of
2136 * each, and then choose a working drive that also has that virt address.
2137 * There is a separate r10_bio for each non-in_sync drive.
2138 * Only the first two slots are in use. The first for reading,
2139 * The second for writing.
2140 *
2141 */
2143 {
2144 /* We got a read error during recovery.
2145 * We repeat the read in smaller page-sized sections.
2146 * If a read succeeds, write it to the new device or record
2147 * a bad block if we cannot.
2148 * If a read fails, record a bad block on both old and
2149 * new devices.
2150 */
2164 sector_t addr;
2173 addr,
2181 addr,
2191 }
2192 }
2194 /* We don't worry if we cannot set a bad block -
2195 * it really is bad so there is no loss in not
2196 * recording it yet
2197 */
2201 /* need bad block on destination too */
2206 /* just abort the recovery */
2215 }
2216 }
2217 }
2221 idx++;
2222 }
2223 }
2226 {
2235 }
2237 /*
2238 * share the pages with the first bio
2239 * and submit the write request
2240 */
2244 /* Need to test wbio2->bi_end_io before we call
2245 * generic_make_request as if the former is NULL,
2246 * the latter is free to free wbio2.
2247 */
2254 }
2260 }
2261 }
2263 /*
2264 * Used by fix_read_error() to decay the per rdev read_errors.
2265 * We halve the read error count for every hour that has elapsed
2266 * since the last recorded read error.
2267 *
2268 */
2270 {
2278 /* first time we've seen a read error */
2281 }
2288 /*
2289 * if hours_since_last is > the number of bits in read_errors
2290 * just set read errors to 0. We do this to avoid
2291 * overflowing the shift of read_errors by hours_since_last.
2292 */
2295 else
2297 }
2301 {
2302 sector_t first_bad;
2309 /* success */
2316 }
2317 /* need to record an error - either for the block or the device */
2321 }
2323 /*
2324 * This is a kernel thread which:
2325 *
2326 * 1. Retries failed read operations on working mirrors.
2327 * 2. Updates the raid superblock when problems encounter.
2328 * 3. Performs writes following reads for array synchronising.
2329 */
2332 {
2339 /* still own a reference to this rdev, so it cannot
2340 * have been cleared recently.
2341 */
2345 /* drive has already been failed, just ignore any
2346 more fix_read_error() attempts */
2363 }
2376 sector_t first_bad;
2390 sect,
2398 }
2399 sl++;
2406 /* Cannot read from anywhere, just mark the block
2407 * as bad on the first device to discourage future
2408 * reads.
2409 */
2414 rdev,
2421 }
2423 }
2426 /* write it back and re-read */
2433 sl--;
2445 sect,
2448 /* Well, this device is dead */
2452 sect +
2454 rdev)),
2459 }
2462 }
2469 sl--;
2481 sect,
2483 READ)) {
2485 /* Well, this device is dead */
2489 sect +
2500 sect +
2504 }
2508 }
2513 }
2514 }
2517 {
2522 /* bio has the data to be written to slot 'i' where
2523 * we just recently had a write error.
2524 * We repeatedly clone the bio and trim down to one block,
2525 * then try the write. Where the write fails we record
2526 * a bad block.
2527 * It is conceivable that the bio doesn't exactly align with
2528 * blocks. We must handle this.
2529 *
2530 * We currently own a reference to the rdev.
2531 */
2534 sector_t sector;
2551 sector_t wsector;
2554 /* Write at 'sector' for 'sectors' */
2564 /* Failure! */
2573 }
2575 }
2578 {
2584 /* we got a read error. Maybe the drive is bad. Maybe just
2585 * the block and we can fix it.
2586 * We freeze all other IO, and try reading the block from
2587 * other devices. When we find one, we re-write
2588 * and check it that fixes the read error.
2589 * This is all done synchronously while the array is
2590 * frozen.
2591 */
2609 }
2612 {
2613 /* Some sort of write request has finished and it
2614 * succeeded in writing where we thought there was a
2615 * bad block. So forget the bad block.
2616 * Or possibly if failed and we need to record
2617 * a bad block.
2618 */
2632 rdev,
2637 rdev,
2641 }
2649 rdev,
2654 rdev,
2658 }
2659 }
2669 rdev,
2679 }
2681 }
2686 rdev,
2690 }
2691 }
2697 /*
2698 * In case freeze_array() is waiting for condition
2699 * nr_pending == nr_queued + extra to be true.
2700 */
2708 }
2709 }
2710 }
2713 {
2731 }
2732 }
2736 retry_list);
2745 }
2746 }
2757 }
2776 else
2782 }
2784 }
2787 {
2802 }
2805 {
2815 else
2828 }
2829 }
2831 }
2833 /*
2834 * Set cluster_sync_high since we need other nodes to add the
2835 * range [cluster_sync_low, cluster_sync_high] to suspend list.
2836 */
2838 {
2839 sector_t window_size;
2842 /*
2843 * First, here we define "stripe" as a unit which across
2844 * all member devices one time, so we get chunks by use
2845 * raid_disks / near_copies. Otherwise, if near_copies is
2846 * close to raid_disks, then resync window could increases
2847 * linearly with the increase of raid_disks, which means
2848 * we will suspend a really large IO window while it is not
2849 * necessary. If raid_disks is not divisible by near_copies,
2850 * an extra chunk is needed to ensure the whole "stripe" is
2851 * covered.
2852 */
2857 else
2861 /*
2862 * At least use a 32M window to align with raid1's resync window
2863 */
2868 }
2870 /*
2871 * perform a "sync" on one "block"
2872 *
2873 * We need to make sure that no normal I/O request - particularly write
2874 * requests - conflict with active sync requests.
2875 *
2876 * This is achieved by tracking pending requests and a 'barrier' concept
2877 * that can be installed to exclude normal IO requests.
2878 *
2879 * Resync and recovery are handled very differently.
2880 * We differentiate by looking at MD_RECOVERY_SYNC in mddev->recovery.
2881 *
2882 * For resync, we iterate over virtual addresses, read all copies,
2883 * and update if there are differences. If only one copy is live,
2884 * skip it.
2885 * For recovery, we iterate over physical addresses, read a good
2886 * value for each non-in_sync drive, and over-write.
2887 *
2888 * So, for recovery we may have several outstanding complex requests for a
2889 * given address, one for each out-of-sync device. We model this by allocating
2890 * a number of r10_bio structures, one for each out-of-sync device.
2891 * As we setup these structures, we collect all bio's together into a list
2892 * which we then process collectively to add pages, and then process again
2893 * to pass to generic_make_request.
2894 *
2895 * The r10_bio structures are linked using a borrowed master_bio pointer.
2896 * This link is counted in ->remaining. When the r10_bio that points to NULL
2897 * has its remaining count decremented to 0, the whole complex operation
2898 * is complete.
2899 *
2900 */
2904 {
2911 sector_t sync_blocks;
2921 /*
2922 * Allow skipping a full rebuild for incremental assembly
2923 * of a clean array, like RAID1 does.
2924 */
2934 }
2936 skipped:
2945 /* If we aborted, we need to abort the
2946 * sync on the 'current' bitmap chucks (there can
2947 * be several when recovering multiple devices).
2948 * as we may have started syncing it but not finished.
2949 * We can find the current address in
2950 * mddev->curr_resync, but for recovery,
2951 * we need to convert that to several
2952 * virtual addresses.
2953 */
2958 }
2965 sector_t sect =
2969 }
2971 /* completed sync */
2975 /* Completed a full sync so the replacements
2976 * are now fully recovered.
2977 */
2984 }
2986 }
2988 }
2993 }
2999 /* if there has been nothing to do on any drive,
3000 * then there is nothing to do at all..
3001 */
3004 }
3009 /* make sure whole request will fit in a chunk - if chunks
3010 * are meaningful
3011 */
3016 /*
3017 * If there is non-resync activity waiting for a turn, then let it
3018 * though before starting on this new sync request.
3019 */
3023 /* Again, very different code for resync and recovery.
3024 * Both must result in an r10bio with a list of bios that
3025 * have bi_end_io, bi_sector, bi_disk set,
3026 * and bi_private set to the r10bio.
3027 * For recovery, we may actually create several r10bios
3028 * with 2 bios in each, that correspond to the bios in the main one.
3029 * In this case, the subordinate r10bios link back through a
3030 * borrowed master_bio pointer, and the counter in the master
3031 * includes a ref from each subordinate.
3032 */
3033 /* First, we decide what to do and set ->bi_end_io
3034 * To end_sync_read if we want to read, and
3035 * end_sync_write if we will want to write.
3036 */
3040 /* recovery... the complicated one */
3047 sector_t sect;
3070 }
3073 /* want to reconstruct this device */
3077 /* last stripe is not complete - don't
3078 * try to recover this sector.
3079 */
3082 }
3085 /* Unless we are doing a full sync, or a replacement
3086 * we only need to recover the block if it is set in
3087 * the bitmap
3088 */
3096 /* yep, skip the sync_blocks here, but don't assume
3097 * that there will never be anything to do here
3098 */
3102 }
3122 /* Need to check if the array will still be
3123 * degraded
3124 */
3132 }
3133 }
3150 /* This is where we read from */
3159 bad_sectors -= (sector
3164 }
3165 }
3178 /* and we write to 'i' (if not in_sync) */
3203 /* and maybe write to replacement */
3207 /* Note: if need_replace, then bio
3208 * cannot be NULL as r10buf_pool_alloc will
3209 * have allocated it.
3210 */
3222 }
3225 /* Cannot recover, so abort the recovery or
3226 * record a bad block */
3228 /* problem is that there are bad blocks
3229 * on other device(s)
3230 */
3238 mrdev,
3244 mreplace,
3248 }
3254 mirror->recovery_disabled
3256 }
3265 }
3270 /* Only want this if there is elsewhere to
3271 * read from. 'j' is currently the first
3272 * readable copy.
3273 */
3280 targets++;
3281 }
3285 }
3286 }
3293 }
3295 }
3297 /* resync. Schedule a read for every block at this virt offset */
3300 /*
3301 * Since curr_resync_completed could probably not update in
3302 * time, and we will set cluster_sync_low based on it.
3303 * Let's check against "sector_nr + 2 * RESYNC_SECTORS" for
3304 * safety reason, which ensures curr_resync_completed is
3305 * updated in bitmap_cond_end_sync.
3306 */
3315 /* We can skip this block */
3318 }
3351 }
3363 }
3364 }
3375 count++;
3381 }
3384 /* Need to set up for writing to the replacement */
3397 count++;
3399 }
3406 mddev);
3411 mddev);
3412 }
3416 }
3417 }
3432 /*
3433 * won't fail because the vec table is big enough
3434 * to hold all these pages
3435 */
3437 }
3445 /* It is resync not recovery */
3449 /* Send resync message */
3453 }
3455 /* This is recovery not resync */
3460 /*
3461 * sector_nr is a device address for recovery, so we
3462 * need translate it to array address before compare
3463 * with cluster_sync_high.
3464 */
3469 /*
3470 * curr_resync_completed is similar as
3471 * sector_nr, so make the translation too.
3472 */
3479 }
3480 }
3486 }
3487 }
3501 }
3502 }
3505 /* pretend they weren't skipped, it makes
3506 * no important difference in this case
3507 */
3511 giveup:
3512 /* There is nowhere to write, so all non-sync
3513 * drives must be failed or in resync, all drives
3514 * have a bad block, so try the next chunk...
3515 */
3520 chunks_skipped ++;
3523 }
3525 static sector_t
3527 {
3528 sector_t size;
3543 }
3546 {
3547 /* Calculate the number of sectors-per-device that will
3548 * actually be used, and set conf->dev_sectors and
3549 * conf->stride
3550 */
3556 /* 'size' is now the number of chunks in the array */
3557 /* calculate "used chunks per device" */
3560 /* We need to round up when dividing by raid_disks to
3561 * get the stride size.
3562 */
3572 }
3573 }
3577 {
3593 * updated yet. */
3598 }
3616 * actually using this, but leave code here just in case.*/
3626 }
3630 }
3633 {
3645 }
3651 }
3658 /* FIXME calc properly */
3661 GFP_KERNEL);
3688 }
3692 else
3693 /* far_copies must be 1 */
3695 }
3713 out:
3720 }
3722 }
3725 {
3730 sector_t size;
3743 }
3757 }
3758 }
3772 else
3775 }
3796 }
3814 }
3820 else
3823 }
3824 /* need to check that every block has at least one working mirror */
3829 }
3832 /* must ensure that shape change is supported */
3839 }
3845 i++) {
3850 /* The replacement is all we have - use it */
3854 }
3863 }
3869 }
3872 }
3880 /*
3881 * Ok, everything is just fine now
3882 */
3893 /* Calculate max read-ahead size.
3894 * We need to readahead at least twice a whole stripe....
3895 * maybe...
3896 */
3900 }
3914 /* This cannot work */
3917 }
3928 }
3932 out_free_conf:
3939 out:
3941 }
3944 {
3954 }
3957 {
3962 else
3964 }
3967 {
3968 /* Resize of 'far' arrays is not supported.
3969 * For 'near' and 'offset' arrays we can set the
3970 * number of sectors used to be an appropriate multiple
3971 * of the chunk size.
3972 * For 'offset', this is far_copies*chunksize.
3973 * For 'near' the multiplier is the LCM of
3974 * near_copies and raid_disks.
3975 * So if far_copies > 1 && !far_offset, fail.
3976 * Else find LCM(raid_disks, near_copy)*far_copies and
3977 * multiply by chunk_size. Then round to this number.
3978 * This is mostly done by raid10_size()
3979 */
3998 }
4004 }
4009 }
4012 {
4020 }
4023 /* Set new parameters */
4025 /* new layout: far_copies = 1, near_copies = 2 */
4030 /* make sure it will be not marked as dirty */
4040 }
4042 }
4045 }
4048 {
4051 /* raid10 can take over:
4052 * raid0 - providing it has only two drives
4053 */
4055 /* for raid0 takeover only one zone is supported */
4061 }
4065 }
4067 }
4070 {
4071 /* Called when there is a request to change
4072 * - layout (to ->new_layout)
4073 * - chunk size (to ->new_chunk_sectors)
4074 * - raid_disks (by delta_disks)
4075 * or when trying to restart a reshape that was ongoing.
4076 *
4077 * We need to validate the request and possibly allocate
4078 * space if that might be an issue later.
4079 *
4080 * Currently we reject any reshape of a 'far' mode array,
4081 * allow chunk size to change if new is generally acceptable,
4082 * allow raid_disks to increase, and allow
4083 * a switch between 'near' mode and 'offset' mode.
4084 */
4092 /* mustn't change number of copies */
4095 /* Cannot switch to 'far' mode */
4099 /* not factor of array size */
4108 /* allocate new 'mirrors' list */
4112 GFP_KERNEL);
4115 }
4117 }
4119 /*
4120 * Need to check if array has failed when deciding whether to:
4121 * - start an array
4122 * - remove non-faulty devices
4123 * - add a spare
4124 * - allow a reshape
4125 * This determination is simple when no reshape is happening.
4126 * However if there is a reshape, we need to carefully check
4127 * both the before and after sections.
4128 * This is because some failed devices may only affect one
4129 * of the two sections, and some non-in_sync devices may
4130 * be insync in the section most affected by failed devices.
4131 */
4133 {
4139 /* 'prev' section first */
4143 degraded++;
4145 /* When we can reduce the number of devices in
4146 * an array, this might not contribute to
4147 * 'degraded'. It does now.
4148 */
4149 degraded++;
4150 }
4159 degraded2++;
4161 /* If reshape is increasing the number of devices,
4162 * this section has already been recovered, so
4163 * it doesn't contribute to degraded.
4164 * else it does.
4165 */
4167 degraded2++;
4168 }
4169 }
4174 }
4177 {
4178 /* A 'reshape' has been requested. This commits
4179 * the various 'new' fields and sets MD_RECOVER_RESHAPE
4180 * This also checks if there are enough spares and adds them
4181 * to the array.
4182 * We currently require enough spares to make the final
4183 * array non-degraded. We also require that the difference
4184 * between old and new data_offset - on each device - is
4185 * enough that we never risk over-writing.
4186 */
4211 spares++;
4222 }
4223 }
4241 }
4251 }
4270 else
4272 }
4278 }
4280 /*
4281 * some node is already performing reshape, and no need to
4282 * call md_bitmap_resize again since it should be called when
4283 * receiving BITMAP_RESIZE msg
4284 */
4297 }
4298 }
4299 out:
4308 else
4313 }
4316 /* This is a spare that was manually added */
4318 }
4319 }
4320 /* When a reshape changes the number of devices,
4321 * ->degraded is measured against the larger of the
4322 * pre and post numbers.
4323 */
4342 }
4348 abort:
4361 }
4363 /* Calculate the last device-address that could contain
4364 * any block from the chunk that includes the array-address 's'
4365 * and report the next address.
4366 * i.e. the address returned will be chunk-aligned and after
4367 * any data that is in the chunk containing 's'.
4368 */
4370 {
4378 }
4380 /* Calculate the first device-address that could contain
4381 * any block from the chunk that includes the array-address 's'.
4382 * This too will be the start of a chunk
4383 */
4385 {
4392 }
4396 {
4397 /* We simply copy at most one chunk (smallest of old and new)
4398 * at a time, possibly less if that exceeds RESYNC_PAGES,
4399 * or we hit a bad block or something.
4400 * This might mean we pause for normal IO in the middle of
4401 * a chunk, but that is not a problem as mddev->reshape_position
4402 * can record any location.
4403 *
4404 * If we will want to write to a location that isn't
4405 * yet recorded as 'safe' (i.e. in metadata on disk) then
4406 * we need to flush all reshape requests and update the metadata.
4407 *
4408 * When reshaping forwards (e.g. to more devices), we interpret
4409 * 'safe' as the earliest block which might not have been copied
4410 * down yet. We divide this by previous stripe size and multiply
4411 * by previous stripe length to get lowest device offset that we
4412 * cannot write to yet.
4413 * We interpret 'sector_nr' as an address that we want to write to.
4414 * From this we use last_device_address() to find where we might
4415 * write to, and first_device_address on the 'safe' position.
4416 * If this 'next' write position is after the 'safe' position,
4417 * we must update the metadata to increase the 'safe' position.
4418 *
4419 * When reshaping backwards, we round in the opposite direction
4420 * and perform the reverse test: next write position must not be
4421 * less than current safe position.
4422 *
4423 * In all this the minimum difference in data offsets
4424 * (conf->offset_diff - always positive) allows a bit of slack,
4425 * so next can be after 'safe', but not by more than offset_diff
4426 *
4427 * We need to prepare all the bios here before we start any IO
4428 * to ensure the size we choose is acceptable to all devices.
4429 * The means one for each copy for write-out and an extra one for
4430 * read-in.
4431 * We store the read-in bio in ->master_bio and the others in
4432 * ->devs[x].bio and ->devs[x].repl_bio.
4433 */
4448 /* If restarting in the middle, skip the initial sectors */
4461 }
4462 }
4464 /* We don't use sector_nr to track where we are up to
4465 * as that doesn't work well for ->reshape_backwards.
4466 * So just use ->reshape_progress.
4467 */
4469 /* 'next' is the earliest device address that we might
4470 * write to for this chunk in the new layout
4471 */
4475 /* 'safe' is the last device address that we might read from
4476 * in the old layout after a restart
4477 */
4490 /* 'next' is after the last device address that we
4491 * might write to for this chunk in the new layout
4492 */
4495 /* 'safe' is the earliest device address that we might
4496 * read from in the old layout after a restart
4497 */
4500 /* Need to update metadata if 'next' might be beyond 'safe'
4501 * as that would possibly corrupt data
4502 */
4512 }
4516 /* Need to update reshape_position in metadata */
4522 else
4532 }
4535 }
4538 read_more:
4539 /* Now schedule reads for blocks from sector_nr to last */
4552 /* Cannot read from here, so need to record bad blocks
4553 * on all the target devices.
4554 */
4555 // FIXME
4559 }
4576 /*
4577 * Broadcast RESYNC message to other nodes, so all nodes would not
4578 * write to the region to avoid conflict.
4579 */
4589 /*
4590 * Set cluster_sync_low again if next address for array
4591 * reshape is less than cluster_sync_low. Since we can't
4592 * update cluster_sync_low until it has finished reshape.
4593 */
4596 }
4600 }
4602 /* Now find the locations in the new layout */
4619 }
4630 }
4632 /* Now add as many pages as possible to all of these bios. */
4642 /*
4643 * won't fail because the vec table is big enough
4644 * to hold all these pages
4645 */
4647 }
4650 }
4654 /* Now submit the read */
4665 /* Now that we have done the whole section we can
4666 * update reshape_progress
4667 */
4670 else
4674 }
4680 {
4681 /* Reshape read completed. Hopefully we have a block
4682 * to write out.
4683 * If we got a read error then we do sync 1-page reads from
4684 * elsewhere until we find the data - or give up.
4685 */
4691 /* Reshape has been aborted */
4694 }
4696 /* We definitely have the data in the pages, schedule the
4697 * writes.
4698 */
4711 }
4715 }
4722 }
4724 }
4727 {
4739 /* read-ahead size must cover two whole stripes, which is
4740 * 2 * (datadisks) * chunksize where 'n' is the number of raid devices
4741 */
4748 }
4750 }
4753 {
4761 else
4763 }
4767 {
4768 /* Use sync reads to get the blocks from somewhere else */
4780 }
4782 /* reshape IOs share pages from .devs[0].bio */
4800 sector_t addr;
4810 addr,
4818 failed:
4819 slot++;
4824 }
4827 /* couldn't read this block, must give up */
4832 }
4834 idx++;
4835 }
4838 }
4841 {
4856 }
4859 /* FIXME should record badblock */
4861 }
4865 }
4868 {
4874 }
4877 {
4887 }
4894 d++) {
4901 }
4903 }
4909 }
4912 {
4934 };
4937 {
4939 }
4942 {
4944 }