Lines Matching refs:rdev
596 struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
597 if (rdev && test_bit(Faulty, &rdev->flags))
598 rdev = rcu_dereference(conf->disks[i].replacement);
599 if (!rdev || test_bit(Faulty, &rdev->flags))
601 else if (test_bit(In_sync, &rdev->flags))
622 struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
623 if (rdev && test_bit(Faulty, &rdev->flags))
624 rdev = rcu_dereference(conf->disks[i].replacement);
625 if (!rdev || test_bit(Faulty, &rdev->flags))
627 else if (test_bit(In_sync, &rdev->flags))
751 struct md_rdev *rdev, *rrdev = NULL;
775 smp_mb(); /* Ensure that if rrdev is NULL, rdev won't be */
776 rdev = rcu_dereference(conf->disks[i].rdev);
777 if (!rdev) {
778 rdev = rrdev;
783 rdev = NULL;
784 if (rdev == rrdev)
789 rdev = rrdev;
793 if (rdev && test_bit(Faulty, &rdev->flags))
794 rdev = NULL;
795 if (rdev)
796 atomic_inc(&rdev->nr_pending);
807 while ((rw & WRITE) && rdev &&
808 test_bit(WriteErrorSeen, &rdev->flags)) {
811 int bad = is_badblock(rdev, sh->sector, STRIPE_SECTORS,
817 set_bit(BlockedBadBlocks, &rdev->flags);
831 atomic_inc(&rdev->nr_pending);
832 md_wait_for_blocked_rdev(rdev, conf->mddev);
835 rdev_dec_pending(rdev, conf->mddev);
836 rdev = NULL;
840 if (rdev) {
843 md_sync_acct(rdev->bdev, STRIPE_SECTORS);
848 bi->bi_bdev = rdev->bdev;
861 + rdev->new_data_offset);
864 + rdev->data_offset);
934 if (!rdev && !rrdev) {
1978 struct md_rdev *rdev = NULL;
1995 * In that case it moved down to 'rdev'.
1996 * rdev is not removed until all requests are finished.
1998 rdev = conf->disks[i].replacement;
1999 if (!rdev)
2000 rdev = conf->disks[i].rdev;
2003 s = sh->sector + rdev->new_data_offset;
2005 s = sh->sector + rdev->data_offset;
2019 bdevname(rdev->bdev, b));
2020 atomic_add(STRIPE_SECTORS, &rdev->corrected_errors);
2026 if (atomic_read(&rdev->read_errors))
2027 atomic_set(&rdev->read_errors, 0);
2029 const char *bdn = bdevname(rdev->bdev, b);
2034 atomic_inc(&rdev->read_errors);
2062 } else if (atomic_read(&rdev->read_errors)
2069 if (set_bad && test_bit(In_sync, &rdev->flags)
2082 && test_bit(In_sync, &rdev->flags)
2084 rdev, sh->sector, STRIPE_SECTORS, 0)))
2085 md_error(conf->mddev, rdev);
2088 rdev_dec_pending(rdev, conf->mddev);
2099 struct md_rdev *uninitialized_var(rdev);
2107 rdev = conf->disks[i].rdev;
2111 rdev = conf->disks[i].replacement;
2112 if (rdev)
2115 /* rdev was removed and 'replacement'
2116 * replaced it. rdev is not removed
2119 rdev = conf->disks[i].rdev;
2133 md_error(conf->mddev, rdev);
2134 else if (is_badblock(rdev, sh->sector,
2141 set_bit(WriteErrorSeen, &rdev->flags);
2143 if (!test_and_set_bit(WantReplacement, &rdev->flags))
2145 &rdev->mddev->recovery);
2146 } else if (is_badblock(rdev, sh->sector,
2158 rdev_dec_pending(rdev, conf->mddev);
2186 static void error(struct mddev *mddev, struct md_rdev *rdev)
2194 clear_bit(In_sync, &rdev->flags);
2199 set_bit(Blocked, &rdev->flags);
2200 set_bit(Faulty, &rdev->flags);
2206 bdevname(rdev->bdev, b),
2731 struct md_rdev *rdev;
2733 rdev = rcu_dereference(conf->disks[i].rdev);
2734 if (rdev && test_bit(In_sync, &rdev->flags))
2735 atomic_inc(&rdev->nr_pending);
2737 rdev = NULL;
2739 if (rdev) {
2741 rdev,
2744 md_error(conf->mddev, rdev);
2745 rdev_dec_pending(rdev, conf->mddev);
2857 struct md_rdev *rdev = conf->disks[i].rdev;
2858 if (rdev
2859 && !test_bit(Faulty, &rdev->flags)
2860 && !test_bit(In_sync, &rdev->flags)
2861 && !rdev_set_badblocks(rdev, sh->sector,
2864 rdev = conf->disks[i].replacement;
2865 if (rdev
2866 && !test_bit(Faulty, &rdev->flags)
2867 && !test_bit(In_sync, &rdev->flags)
2868 && !rdev_set_badblocks(rdev, sh->sector,
2881 struct md_rdev *rdev;
2884 rdev = sh->raid_conf->disks[disk_idx].replacement;
2885 if (rdev
2886 && !test_bit(Faulty, &rdev->flags)
2887 && !test_bit(In_sync, &rdev->flags)
2888 && (rdev->recovery_offset <= sh->sector
2889 || rdev->mddev->recovery_cp <= sh->sector))
3549 struct md_rdev *rdev;
3592 rdev = rcu_dereference(conf->disks[i].replacement);
3593 if (rdev && !test_bit(Faulty, &rdev->flags) &&
3594 rdev->recovery_offset >= sh->sector + STRIPE_SECTORS &&
3595 !is_badblock(rdev, sh->sector, STRIPE_SECTORS,
3599 if (rdev)
3601 rdev = rcu_dereference(conf->disks[i].rdev);
3604 if (rdev && test_bit(Faulty, &rdev->flags))
3605 rdev = NULL;
3606 if (rdev) {
3607 is_bad = is_badblock(rdev, sh->sector, STRIPE_SECTORS,
3610 && (test_bit(Blocked, &rdev->flags)
3614 &rdev->flags);
3615 s->blocked_rdev = rdev;
3616 atomic_inc(&rdev->nr_pending);
3620 if (!rdev)
3624 if (!test_bit(WriteErrorSeen, &rdev->flags) &&
3632 } else if (test_bit(In_sync, &rdev->flags))
3634 else if (sh->sector + STRIPE_SECTORS <= rdev->recovery_offset)
3647 * only to .rdev, so make sure to check that*/
3649 conf->disks[i].rdev);
3650 if (rdev2 == rdev)
3660 * only to .rdev, so make sure to check that*/
3662 conf->disks[i].rdev);
3689 if (rdev && !test_bit(Faulty, &rdev->flags))
3994 struct md_rdev *rdev;
3997 /* We own a safe reference to the rdev */
3998 rdev = conf->disks[i].rdev;
3999 if (!rdev_set_badblocks(rdev, sh->sector,
4001 md_error(conf->mddev, rdev);
4002 rdev_dec_pending(rdev, conf->mddev);
4005 rdev = conf->disks[i].rdev;
4006 rdev_clear_badblocks(rdev, sh->sector,
4008 rdev_dec_pending(rdev, conf->mddev);
4011 rdev = conf->disks[i].replacement;
4012 if (!rdev)
4013 /* rdev have been moved down */
4014 rdev = conf->disks[i].rdev;
4015 rdev_clear_badblocks(rdev, sh->sector,
4017 rdev_dec_pending(rdev, conf->mddev);
4193 struct md_rdev *rdev;
4197 rdev = (void*)raid_bi->bi_next;
4199 mddev = rdev->mddev;
4202 rdev_dec_pending(rdev, conf->mddev);
4242 struct md_rdev *rdev;
4270 rdev = rcu_dereference(conf->disks[dd_idx].replacement);
4271 if (!rdev || test_bit(Faulty, &rdev->flags) ||
4272 rdev->recovery_offset < end_sector) {
4273 rdev = rcu_dereference(conf->disks[dd_idx].rdev);
4274 if (rdev &&
4275 (test_bit(Faulty, &rdev->flags) ||
4276 !(test_bit(In_sync, &rdev->flags) ||
4277 rdev->recovery_offset >= end_sector)))
4278 rdev = NULL;
4280 if (rdev) {
4284 atomic_inc(&rdev->nr_pending);
4286 raid_bio->bi_next = (void*)rdev;
4287 align_bi->bi_bdev = rdev->bdev;
4291 is_badblock(rdev, align_bi->bi_iter.bi_sector,
4296 rdev_dec_pending(rdev, mddev);
4300 /* No reshape active, so we can trust rdev->data_offset */
4301 align_bi->bi_iter.bi_sector += rdev->data_offset;
5061 if (conf->disks[i].rdev == NULL)
5712 struct md_rdev *rdev;
5813 rdev_for_each(rdev, mddev) {
5814 raid_disk = rdev->raid_disk;
5820 if (test_bit(Replacement, &rdev->flags)) {
5823 disk->replacement = rdev;
5825 if (disk->rdev)
5827 disk->rdev = rdev;
5830 if (test_bit(In_sync, &rdev->flags)) {
5834 mdname(mddev), bdevname(rdev->bdev, b), raid_disk);
5835 } else if (rdev->saved_raid_disk != raid_disk)
5915 struct md_rdev *rdev;
5926 rdev_for_each(rdev, mddev) {
5928 if (rdev->raid_disk < 0)
5930 diff = (rdev->new_data_offset - rdev->data_offset);
6044 rdev = conf->disks[i].rdev;
6045 if (!rdev && conf->disks[i].replacement) {
6047 rdev = conf->disks[i].replacement;
6049 clear_bit(Replacement, &rdev->flags);
6050 conf->disks[i].rdev = rdev;
6052 if (!rdev)
6061 if (test_bit(In_sync, &rdev->flags)) {
6076 rdev->recovery_offset = reshape_offset;
6078 if (rdev->recovery_offset < reshape_offset) {
6080 if (!only_parity(rdev->raid_disk,
6086 if (!only_parity(rdev->raid_disk,
6202 rdev_for_each(rdev, mddev) {
6203 disk_stack_limits(mddev->gendisk, rdev->bdev,
6204 rdev->data_offset << 9);
6205 disk_stack_limits(mddev->gendisk, rdev->bdev,
6206 rdev->new_data_offset << 9);
6217 if (!blk_queue_discard(bdev_get_queue(rdev->bdev)) ||
6218 !bdev_get_queue(rdev->bdev)->
6278 conf->disks[i].rdev &&
6279 test_bit(In_sync, &conf->disks[i].rdev->flags) ? "U" : "_");
6300 if (tmp->rdev)
6302 i, !test_bit(Faulty, &tmp->rdev->flags),
6303 bdevname(tmp->rdev->bdev, b));
6322 if (!tmp->rdev
6323 || !test_and_clear_bit(In_sync, &tmp->rdev->flags))
6325 if (tmp->rdev) {
6330 set_bit(Faulty, &tmp->rdev->flags);
6332 tmp->rdev->sysfs_state);
6335 } else if (tmp->rdev
6336 && tmp->rdev->recovery_offset == MaxSector
6337 && !test_bit(Faulty, &tmp->rdev->flags)
6338 && !test_and_set_bit(In_sync, &tmp->rdev->flags)) {
6340 sysfs_notify_dirent_safe(tmp->rdev->sysfs_state);
6350 static int raid5_remove_disk(struct mddev *mddev, struct md_rdev *rdev)
6354 int number = rdev->raid_disk;
6359 if (rdev == p->rdev)
6360 rdevp = &p->rdev;
6361 else if (rdev == p->replacement)
6368 clear_bit(In_sync, &rdev->flags);
6370 if (test_bit(In_sync, &rdev->flags) ||
6371 atomic_read(&rdev->nr_pending)) {
6378 if (!test_bit(Faulty, &rdev->flags) &&
6381 (!p->replacement || p->replacement == rdev) &&
6388 if (atomic_read(&rdev->nr_pending)) {
6391 *rdevp = rdev;
6393 /* We must have just cleared 'rdev' */
6394 p->rdev = p->replacement;
6400 clear_bit(WantReplacement, &rdev->flags);
6405 clear_bit(WantReplacement, &rdev->flags);
6412 static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)
6424 if (rdev->saved_raid_disk < 0 && has_failed(conf))
6428 if (rdev->raid_disk >= 0)
6429 first = last = rdev->raid_disk;
6432 * find the disk ... but prefer rdev->saved_raid_disk
6435 if (rdev->saved_raid_disk >= 0 &&
6436 rdev->saved_raid_disk >= first &&
6437 conf->disks[rdev->saved_raid_disk].rdev == NULL)
6438 first = rdev->saved_raid_disk;
6442 if (p->rdev == NULL) {
6443 clear_bit(In_sync, &rdev->flags);
6444 rdev->raid_disk = disk;
6446 if (rdev->saved_raid_disk != disk)
6448 rcu_assign_pointer(p->rdev, rdev);
6454 if (test_bit(WantReplacement, &p->rdev->flags) &&
6456 clear_bit(In_sync, &rdev->flags);
6457 set_bit(Replacement, &rdev->flags);
6458 rdev->raid_disk = disk;
6461 rcu_assign_pointer(p->replacement, rdev);
6560 struct md_rdev *rdev;
6573 rdev_for_each(rdev, mddev) {
6574 if (!test_bit(In_sync, &rdev->flags)
6575 && !test_bit(Faulty, &rdev->flags))
6633 rdev_for_each(rdev, mddev)
6634 if (rdev->raid_disk < 0 &&
6635 !test_bit(Faulty, &rdev->flags)) {
6636 if (raid5_add_disk(mddev, rdev) == 0) {
6637 if (rdev->raid_disk
6639 set_bit(In_sync, &rdev->flags);
6641 rdev->recovery_offset = 0;
6643 if (sysfs_link_rdev(mddev, rdev))
6646 } else if (rdev->raid_disk >= conf->previous_raid_disks
6647 && !test_bit(Faulty, &rdev->flags)) {
6649 set_bit(In_sync, &rdev->flags);
6678 rdev_for_each(rdev, mddev)
6679 rdev->new_data_offset = rdev->data_offset;
6701 struct md_rdev *rdev;
6705 rdev_for_each(rdev, conf->mddev)
6706 rdev->data_offset = rdev->new_data_offset;
6746 struct md_rdev *rdev = conf->disks[d].rdev;
6747 if (rdev)
6748 clear_bit(In_sync, &rdev->flags);
6749 rdev = conf->disks[d].replacement;
6750 if (rdev)
6751 clear_bit(In_sync, &rdev->flags);