Lines Matching defs:rdev

59 static int check_and_add_serial(struct md_rdev *rdev, struct r1bio *r1_bio,
66 struct serial_in_rdev *serial = &rdev->serial[idx];
82 static void wait_for_serialization(struct md_rdev *rdev, struct r1bio *r1_bio)
84 struct mddev *mddev = rdev->mddev;
87 struct serial_in_rdev *serial = &rdev->serial[idx];
93 check_and_add_serial(rdev, r1_bio, si, idx) == 0);
96 static void remove_serial(struct md_rdev *rdev, sector_t lo, sector_t hi)
101 struct mddev *mddev = rdev->mddev;
103 struct serial_in_rdev *serial = &rdev->serial[idx];
266 rdev_dec_pending(conf->mirrors[i].rdev, r1_bio->mddev);
364 struct md_rdev *rdev = conf->mirrors[r1_bio->read_disk].rdev;
373 else if (test_bit(FailFast, &rdev->flags) &&
387 test_bit(In_sync, &rdev->flags)))
394 rdev_dec_pending(rdev, conf->mddev);
402 bdevname(rdev->bdev, b),
449 struct md_rdev *rdev = conf->mirrors[mirror].rdev;
460 set_bit(WriteErrorSeen, &rdev->flags);
461 if (!test_and_set_bit(WantReplacement, &rdev->flags))
465 if (test_bit(FailFast, &rdev->flags) &&
468 !test_bit(WriteMostly, &rdev->flags)) {
469 md_error(r1_bio->mddev, rdev);
476 if (!test_bit(Faulty, &rdev->flags))
506 * before rdev->recovery_offset, but for simplicity we don't
509 if (test_bit(In_sync, &rdev->flags) &&
510 !test_bit(Faulty, &rdev->flags))
514 if (is_badblock(rdev, r1_bio->sector, r1_bio->sectors,
522 if (test_bit(CollisionCheck, &rdev->flags))
523 remove_serial(rdev, lo, hi);
524 if (test_bit(WriteMostly, &rdev->flags))
546 } else if (rdev->mddev->serialize_policy)
547 remove_serial(rdev, lo, hi);
549 rdev_dec_pending(rdev, conf->mddev);
592 * The rdev for the device selected will have nr_pending incremented.
604 struct md_rdev *rdev;
641 rdev = rcu_dereference(conf->mirrors[disk].rdev);
643 || rdev == NULL
644 || test_bit(Faulty, &rdev->flags))
646 if (!test_bit(In_sync, &rdev->flags) &&
647 rdev->recovery_offset < this_sector + sectors)
649 if (test_bit(WriteMostly, &rdev->flags)) {
653 if (is_badblock(rdev, this_sector, sectors,
669 if (is_badblock(rdev, this_sector, sectors,
705 nonrot = blk_queue_nonrot(bdev_get_queue(rdev->bdev));
707 pending = atomic_read(&rdev->nr_pending);
716 int opt_iosize = bdev_io_opt(rdev->bdev) >> 9;
772 rdev = rcu_dereference(conf->mirrors[best_disk].rdev);
773 if (!rdev)
775 atomic_inc(&rdev->nr_pending);
797 struct md_rdev *rdev = (void *)bio->bi_disk;
799 bio_set_dev(bio, rdev->bdev);
800 if (test_bit(Faulty, &rdev->flags)) {
1223 struct md_rdev *rdev;
1225 rdev = rcu_dereference(conf->mirrors[r1_bio->read_disk].rdev);
1226 if (rdev)
1227 bdevname(rdev->bdev, b);
1268 bdevname(mirror->rdev->bdev, b));
1270 if (test_bit(WriteMostly, &mirror->rdev->flags) &&
1298 mirror->rdev->data_offset;
1299 bio_set_dev(read_bio, mirror->rdev->bdev);
1302 if (test_bit(FailFast, &mirror->rdev->flags) &&
1362 * inc refcount on their rdev. Record them by setting
1378 struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
1379 if (rdev && unlikely(test_bit(Blocked, &rdev->flags))) {
1380 atomic_inc(&rdev->nr_pending);
1381 blocked_rdev = rdev;
1385 if (!rdev || test_bit(Faulty, &rdev->flags)) {
1391 atomic_inc(&rdev->nr_pending);
1392 if (test_bit(WriteErrorSeen, &rdev->flags)) {
1397 is_bad = is_badblock(rdev, r1_bio->sector, max_sectors,
1402 set_bit(BlockedBadBlocks, &rdev->flags);
1403 blocked_rdev = rdev;
1414 rdev_dec_pending(rdev, mddev);
1443 rdev_dec_pending(conf->mirrors[j].rdev, mddev);
1446 raid1_log(mddev, "wait rdev %d blocked", blocked_rdev->raid_disk);
1469 struct md_rdev *rdev = conf->mirrors[i].rdev;
1497 if (test_bit(CollisionCheck, &rdev->flags))
1498 wait_for_serialization(rdev, r1_bio);
1499 if (test_bit(WriteMostly, &rdev->flags))
1502 wait_for_serialization(rdev, r1_bio);
1507 conf->mirrors[i].rdev->data_offset);
1508 bio_set_dev(mbio, conf->mirrors[i].rdev->bdev);
1511 if (test_bit(FailFast, &conf->mirrors[i].rdev->flags) &&
1512 !test_bit(WriteMostly, &conf->mirrors[i].rdev->flags) &&
1523 /* flush_pending_writes() needs access to the rdev so...*/
1524 mbio->bi_disk = (void *)conf->mirrors[i].rdev;
1586 struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
1588 rdev && test_bit(In_sync, &rdev->flags) ? "U" : "_");
1594 static void raid1_error(struct mddev *mddev, struct md_rdev *rdev)
1607 if (test_bit(In_sync, &rdev->flags) && !mddev->fail_last_dev
1619 set_bit(Blocked, &rdev->flags);
1620 if (test_and_clear_bit(In_sync, &rdev->flags))
1622 set_bit(Faulty, &rdev->flags);
1632 mdname(mddev), bdevname(rdev->bdev, b),
1651 struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
1652 if (rdev)
1654 i, !test_bit(In_sync, &rdev->flags),
1655 !test_bit(Faulty, &rdev->flags),
1656 bdevname(rdev->bdev,b));
1689 struct md_rdev *rdev = conf->mirrors[i].rdev;
1690 struct md_rdev *repl = conf->mirrors[conf->raid_disks + i].rdev;
1697 if (!rdev ||
1698 !test_and_clear_bit(In_sync, &rdev->flags))
1700 if (rdev) {
1705 set_bit(Faulty, &rdev->flags);
1707 rdev->sysfs_state);
1710 if (rdev
1711 && rdev->recovery_offset == MaxSector
1712 && !test_bit(Faulty, &rdev->flags)
1713 && !test_and_set_bit(In_sync, &rdev->flags)) {
1715 sysfs_notify_dirent_safe(rdev->sysfs_state);
1725 static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
1737 if (md_integrity_add_rdev(rdev, mddev))
1740 if (rdev->raid_disk >= 0)
1741 first = last = rdev->raid_disk;
1744 * find the disk ... but prefer rdev->saved_raid_disk
1747 if (rdev->saved_raid_disk >= 0 &&
1748 rdev->saved_raid_disk >= first &&
1749 rdev->saved_raid_disk < conf->raid_disks &&
1750 conf->mirrors[rdev->saved_raid_disk].rdev == NULL)
1751 first = last = rdev->saved_raid_disk;
1755 if (!p->rdev) {
1757 disk_stack_limits(mddev->gendisk, rdev->bdev,
1758 rdev->data_offset << 9);
1761 rdev->raid_disk = mirror;
1766 if (rdev->saved_raid_disk < 0)
1768 rcu_assign_pointer(p->rdev, rdev);
1771 if (test_bit(WantReplacement, &p->rdev->flags) &&
1772 p[conf->raid_disks].rdev == NULL) {
1774 clear_bit(In_sync, &rdev->flags);
1775 set_bit(Replacement, &rdev->flags);
1776 rdev->raid_disk = mirror;
1779 rcu_assign_pointer(p[conf->raid_disks].rdev, rdev);
1783 if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev)))
1789 static int raid1_remove_disk(struct mddev *mddev, struct md_rdev *rdev)
1793 int number = rdev->raid_disk;
1799 if (rdev != p->rdev)
1803 if (rdev == p->rdev) {
1804 if (test_bit(In_sync, &rdev->flags) ||
1805 atomic_read(&rdev->nr_pending)) {
1812 if (!test_bit(Faulty, &rdev->flags) &&
1818 p->rdev = NULL;
1819 if (!test_bit(RemoveSynchronized, &rdev->flags)) {
1821 if (atomic_read(&rdev->nr_pending)) {
1824 p->rdev = rdev;
1828 if (conf->mirrors[conf->raid_disks + number].rdev) {
1834 conf->mirrors[conf->raid_disks + number].rdev;
1839 * as NULL, avoiding rdev NULL pointer
1848 p->rdev = repl;
1849 conf->mirrors[conf->raid_disks + number].rdev = NULL;
1853 clear_bit(WantReplacement, &rdev->flags);
1918 struct md_rdev *rdev = conf->mirrors[find_bio_disk(r1_bio, bio)].rdev;
1922 set_bit(WriteErrorSeen, &rdev->flags);
1923 if (!test_and_set_bit(WantReplacement, &rdev->flags))
1927 } else if (is_badblock(rdev, r1_bio->sector, r1_bio->sectors,
1929 !is_badblock(conf->mirrors[r1_bio->read_disk].rdev,
1939 static int r1_sync_page_io(struct md_rdev *rdev, sector_t sector,
1942 if (sync_page_io(rdev, sector, sectors << 9, page, rw, 0, false))
1946 set_bit(WriteErrorSeen, &rdev->flags);
1948 &rdev->flags))
1950 rdev->mddev->recovery);
1953 if (!rdev_set_badblocks(rdev, sector, sectors, 0))
1954 md_error(rdev->mddev, rdev);
1978 struct md_rdev *rdev;
1980 rdev = conf->mirrors[r1_bio->read_disk].rdev;
1981 if (test_bit(FailFast, &rdev->flags)) {
1984 md_error(mddev, rdev);
1985 if (test_bit(Faulty, &rdev->flags))
2006 rdev = conf->mirrors[d].rdev;
2007 if (sync_page_io(rdev, sect, s<<9,
2031 rdev = conf->mirrors[d].rdev;
2032 if (!rdev || test_bit(Faulty, &rdev->flags))
2034 if (!rdev_set_badblocks(rdev, sect, s, 0))
2060 rdev = conf->mirrors[d].rdev;
2061 if (r1_sync_page_io(rdev, sect, s,
2065 rdev_dec_pending(rdev, mddev);
2075 rdev = conf->mirrors[d].rdev;
2076 if (r1_sync_page_io(rdev, sect, s,
2079 atomic_add(s, &rdev->corrected_errors);
2118 conf->mirrors[i].rdev->data_offset;
2119 bio_set_dev(b, conf->mirrors[i].rdev->bdev);
2131 rdev_dec_pending(conf->mirrors[primary].rdev, mddev);
2169 rdev_dec_pending(conf->mirrors[i].rdev, mddev);
2203 if (test_bit(Faulty, &conf->mirrors[i].rdev->flags)) {
2209 if (test_bit(FailFast, &conf->mirrors[i].rdev->flags))
2214 md_sync_acct(conf->mirrors[i].rdev->bdev, bio_sectors(wbio));
2239 struct md_rdev *rdev;
2249 rdev = rcu_dereference(conf->mirrors[d].rdev);
2250 if (rdev &&
2251 (test_bit(In_sync, &rdev->flags) ||
2252 (!test_bit(Faulty, &rdev->flags) &&
2253 rdev->recovery_offset >= sect + s)) &&
2254 is_badblock(rdev, sect, s,
2256 atomic_inc(&rdev->nr_pending);
2258 if (sync_page_io(rdev, sect, s<<9,
2261 rdev_dec_pending(rdev, mddev);
2273 struct md_rdev *rdev = conf->mirrors[read_disk].rdev;
2274 if (!rdev_set_badblocks(rdev, sect, s, 0))
2275 md_error(mddev, rdev);
2285 rdev = rcu_dereference(conf->mirrors[d].rdev);
2286 if (rdev &&
2287 !test_bit(Faulty, &rdev->flags)) {
2288 atomic_inc(&rdev->nr_pending);
2290 r1_sync_page_io(rdev, sect, s,
2292 rdev_dec_pending(rdev, mddev);
2303 rdev = rcu_dereference(conf->mirrors[d].rdev);
2304 if (rdev &&
2305 !test_bit(Faulty, &rdev->flags)) {
2306 atomic_inc(&rdev->nr_pending);
2308 if (r1_sync_page_io(rdev, sect, s,
2310 atomic_add(s, &rdev->corrected_errors);
2314 rdev->data_offset),
2315 bdevname(rdev->bdev, b));
2317 rdev_dec_pending(rdev, mddev);
2330 struct md_rdev *rdev = conf->mirrors[i].rdev;
2340 * We currently own a reference on the rdev.
2349 if (rdev->badblocks.shift < 0)
2352 block_sectors = roundup(1 << rdev->badblocks.shift,
2353 bdev_logical_block_size(rdev->bdev) >> 9);
2379 wbio->bi_iter.bi_sector += rdev->data_offset;
2380 bio_set_dev(wbio, rdev->bdev);
2384 ok = rdev_set_badblocks(rdev, sector,
2401 struct md_rdev *rdev = conf->mirrors[m].rdev;
2407 rdev_clear_badblocks(rdev, r1_bio->sector, s, 0);
2411 if (!rdev_set_badblocks(rdev, r1_bio->sector, s, 0))
2412 md_error(conf->mddev, rdev);
2426 struct md_rdev *rdev = conf->mirrors[m].rdev;
2427 rdev_clear_badblocks(rdev,
2430 rdev_dec_pending(rdev, conf->mddev);
2439 conf->mirrors[m].rdev);
2443 rdev_dec_pending(conf->mirrors[m].rdev,
2469 struct md_rdev *rdev;
2485 rdev = conf->mirrors[r1_bio->read_disk].rdev;
2487 && !test_bit(FailFast, &rdev->flags)) {
2492 } else if (mddev->ro == 0 && test_bit(FailFast, &rdev->flags)) {
2493 md_error(mddev, rdev);
2498 rdev_dec_pending(rdev, conf->mddev);
2717 struct md_rdev *rdev;
2720 rdev = rcu_dereference(conf->mirrors[i].rdev);
2721 if (rdev == NULL ||
2722 test_bit(Faulty, &rdev->flags)) {
2725 } else if (!test_bit(In_sync, &rdev->flags)) {
2734 if (is_badblock(rdev, sector_nr, good_sectors,
2746 if (test_bit(WriteMostly, &rdev->flags)) {
2756 } else if (!test_bit(WriteErrorSeen, &rdev->flags) &&
2770 if (rdev && bio->bi_end_io) {
2771 atomic_inc(&rdev->nr_pending);
2772 bio->bi_iter.bi_sector = sector_nr + rdev->data_offset;
2773 bio_set_dev(bio, rdev->bdev);
2774 if (test_bit(FailFast, &rdev->flags))
2790 struct md_rdev *rdev = conf->mirrors[i].rdev;
2791 ok = rdev_set_badblocks(rdev, sector_nr,
2929 struct md_rdev *rdev;
2983 rdev_for_each(rdev, mddev) {
2984 int disk_idx = rdev->raid_disk;
2988 if (test_bit(Replacement, &rdev->flags))
2993 if (disk->rdev)
2995 disk->rdev = rdev;
3017 disk[conf->raid_disks].rdev) {
3019 if (!disk->rdev) {
3023 disk->rdev =
3024 disk[conf->raid_disks].rdev;
3025 disk[conf->raid_disks].rdev = NULL;
3026 } else if (!test_bit(In_sync, &disk->rdev->flags))
3031 if (!disk->rdev ||
3032 !test_bit(In_sync, &disk->rdev->flags)) {
3034 if (disk->rdev &&
3035 (disk->rdev->saved_raid_disk < 0))
3068 struct md_rdev *rdev;
3102 rdev_for_each(rdev, mddev) {
3105 disk_stack_limits(mddev->gendisk, rdev->bdev,
3106 rdev->data_offset << 9);
3107 if (blk_queue_discard(bdev_get_queue(rdev->bdev)))
3113 if (conf->mirrors[i].rdev == NULL ||
3114 !test_bit(In_sync, &conf->mirrors[i].rdev->flags) ||
3115 test_bit(Faulty, &conf->mirrors[i].rdev->flags))
3255 if (conf->mirrors[d].rdev)
3289 struct md_rdev *rdev = conf->mirrors[d].rdev;
3290 if (rdev && rdev->raid_disk != d2) {
3291 sysfs_unlink_rdev(mddev, rdev);
3292 rdev->raid_disk = d2;
3293 sysfs_unlink_rdev(mddev, rdev);
3294 if (sysfs_link_rdev(mddev, rdev))
3296 mdname(mddev), rdev->raid_disk);
3298 if (rdev)
3299 newmirrors[d2++].rdev = rdev;