Lines Matching defs:rdev
698 struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
699 if (rdev && test_bit(Faulty, &rdev->flags))
700 rdev = rcu_dereference(conf->disks[i].replacement);
701 if (!rdev || test_bit(Faulty, &rdev->flags))
703 else if (test_bit(In_sync, &rdev->flags))
724 struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
725 if (rdev && test_bit(Faulty, &rdev->flags))
726 rdev = rcu_dereference(conf->disks[i].replacement);
727 if (!rdev || test_bit(Faulty, &rdev->flags))
729 else if (test_bit(In_sync, &rdev->flags))
1160 struct md_rdev *rdev, *rrdev = NULL;
1187 smp_mb(); /* Ensure that if rrdev is NULL, rdev won't be */
1188 rdev = rcu_dereference(conf->disks[i].rdev);
1189 if (!rdev) {
1190 rdev = rrdev;
1195 rdev = NULL;
1196 if (rdev == rrdev)
1201 rdev = rrdev;
1205 if (rdev && test_bit(Faulty, &rdev->flags))
1206 rdev = NULL;
1207 if (rdev)
1208 atomic_inc(&rdev->nr_pending);
1219 while (op_is_write(op) && rdev &&
1220 test_bit(WriteErrorSeen, &rdev->flags)) {
1223 int bad = is_badblock(rdev, sh->sector, RAID5_STRIPE_SECTORS(conf),
1229 set_bit(BlockedBadBlocks, &rdev->flags);
1243 atomic_inc(&rdev->nr_pending);
1244 md_wait_for_blocked_rdev(rdev, conf->mddev);
1247 rdev_dec_pending(rdev, conf->mddev);
1248 rdev = NULL;
1252 if (rdev) {
1255 md_sync_acct(rdev->bdev, RAID5_STRIPE_SECTORS(conf));
1259 bio_init(bi, rdev->bdev, &dev->vec, 1, op | op_flags);
1273 + rdev->new_data_offset);
1276 + rdev->data_offset);
1362 if (!rdev && !rrdev) {
2736 * it is known that the nr_pending of the rdev is elevated.
2738 static struct md_rdev *rdev_pend_deref(struct md_rdev __rcu *rdev)
2740 return rcu_dereference_protected(rdev,
2741 atomic_read(&rcu_access_pointer(rdev)->nr_pending));
2750 struct md_rdev __rcu *rdev)
2752 return rcu_dereference_protected(rdev,
2761 struct md_rdev *rdev = NULL;
2778 * In that case it moved down to 'rdev'.
2779 * rdev is not removed until all requests are finished.
2781 rdev = rdev_pend_deref(conf->disks[i].replacement);
2782 if (!rdev)
2783 rdev = rdev_pend_deref(conf->disks[i].rdev);
2786 s = sh->sector + rdev->new_data_offset;
2788 s = sh->sector + rdev->data_offset;
2800 rdev->bdev);
2801 atomic_add(RAID5_STRIPE_SECTORS(conf), &rdev->corrected_errors);
2814 if (atomic_read(&rdev->read_errors))
2815 atomic_set(&rdev->read_errors, 0);
2822 atomic_inc(&rdev->read_errors);
2828 rdev->bdev);
2835 rdev->bdev);
2843 rdev->bdev);
2844 } else if (atomic_read(&rdev->read_errors)
2846 if (!test_bit(Faulty, &rdev->flags)) {
2849 atomic_read(&rdev->read_errors),
2852 mdname(conf->mddev), rdev->bdev);
2856 if (set_bad && test_bit(In_sync, &rdev->flags)
2871 && test_bit(In_sync, &rdev->flags)
2873 rdev, sh->sector, RAID5_STRIPE_SECTORS(conf), 0)))
2874 md_error(conf->mddev, rdev);
2877 rdev_dec_pending(rdev, conf->mddev);
2889 struct md_rdev *rdev;
2896 rdev = rdev_pend_deref(conf->disks[i].rdev);
2900 rdev = rdev_pend_deref(conf->disks[i].replacement);
2901 if (rdev)
2904 /* rdev was removed and 'replacement'
2905 * replaced it. rdev is not removed
2908 rdev = rdev_pend_deref(conf->disks[i].rdev);
2922 md_error(conf->mddev, rdev);
2923 else if (is_badblock(rdev, sh->sector,
2930 set_bit(WriteErrorSeen, &rdev->flags);
2932 if (!test_and_set_bit(WantReplacement, &rdev->flags))
2934 &rdev->mddev->recovery);
2935 } else if (is_badblock(rdev, sh->sector,
2947 rdev_dec_pending(rdev, conf->mddev);
2962 static void raid5_error(struct mddev *mddev, struct md_rdev *rdev)
2969 mdname(mddev), rdev->bdev);
2972 set_bit(Faulty, &rdev->flags);
2973 clear_bit(In_sync, &rdev->flags);
2990 set_bit(Blocked, &rdev->flags);
2993 r5c_update_on_rdev_error(mddev, rdev);
3670 struct md_rdev *rdev;
3672 rdev = rcu_dereference(conf->disks[i].rdev);
3673 if (rdev && test_bit(In_sync, &rdev->flags) &&
3674 !test_bit(Faulty, &rdev->flags))
3675 atomic_inc(&rdev->nr_pending);
3677 rdev = NULL;
3679 if (rdev) {
3681 rdev,
3684 md_error(conf->mddev, rdev);
3685 rdev_dec_pending(rdev, conf->mddev);
3798 struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
3799 if (rdev
3800 && !test_bit(Faulty, &rdev->flags)
3801 && !test_bit(In_sync, &rdev->flags)
3802 && !rdev_set_badblocks(rdev, sh->sector,
3805 rdev = rcu_dereference(conf->disks[i].replacement);
3806 if (rdev
3807 && !test_bit(Faulty, &rdev->flags)
3808 && !test_bit(In_sync, &rdev->flags)
3809 && !rdev_set_badblocks(rdev, sh->sector,
3823 struct md_rdev *rdev;
3827 rdev = rcu_dereference(sh->raid_conf->disks[disk_idx].replacement);
3828 if (rdev
3829 && !test_bit(Faulty, &rdev->flags)
3830 && !test_bit(In_sync, &rdev->flags)
3831 && (rdev->recovery_offset <= sh->sector
3832 || rdev->mddev->recovery_cp <= sh->sector))
4713 struct md_rdev *rdev;
4756 rdev = rcu_dereference(conf->disks[i].replacement);
4757 if (rdev && !test_bit(Faulty, &rdev->flags) &&
4758 rdev->recovery_offset >= sh->sector + RAID5_STRIPE_SECTORS(conf) &&
4759 !is_badblock(rdev, sh->sector, RAID5_STRIPE_SECTORS(conf),
4763 if (rdev && !test_bit(Faulty, &rdev->flags))
4767 rdev = rcu_dereference(conf->disks[i].rdev);
4770 if (rdev && test_bit(Faulty, &rdev->flags))
4771 rdev = NULL;
4772 if (rdev) {
4773 is_bad = is_badblock(rdev, sh->sector, RAID5_STRIPE_SECTORS(conf),
4776 && (test_bit(Blocked, &rdev->flags)
4780 &rdev->flags);
4781 s->blocked_rdev = rdev;
4782 atomic_inc(&rdev->nr_pending);
4786 if (!rdev)
4790 if (!test_bit(WriteErrorSeen, &rdev->flags) &&
4798 } else if (test_bit(In_sync, &rdev->flags))
4800 else if (sh->sector + RAID5_STRIPE_SECTORS(conf) <= rdev->recovery_offset)
4813 * only to .rdev, so make sure to check that*/
4815 conf->disks[i].rdev);
4816 if (rdev2 == rdev)
4826 * only to .rdev, so make sure to check that*/
4828 conf->disks[i].rdev);
4855 if (rdev && !test_bit(Faulty, &rdev->flags))
4857 else if (!rdev) {
4858 rdev = rcu_dereference(
4860 if (rdev && !test_bit(Faulty, &rdev->flags))
5339 struct md_rdev *rdev;
5342 /* We own a safe reference to the rdev */
5343 rdev = rdev_pend_deref(conf->disks[i].rdev);
5344 if (!rdev_set_badblocks(rdev, sh->sector,
5346 md_error(conf->mddev, rdev);
5347 rdev_dec_pending(rdev, conf->mddev);
5350 rdev = rdev_pend_deref(conf->disks[i].rdev);
5351 rdev_clear_badblocks(rdev, sh->sector,
5353 rdev_dec_pending(rdev, conf->mddev);
5356 rdev = rdev_pend_deref(conf->disks[i].replacement);
5357 if (!rdev)
5358 /* rdev have been moved down */
5359 rdev = rdev_pend_deref(conf->disks[i].rdev);
5360 rdev_clear_badblocks(rdev, sh->sector,
5362 rdev_dec_pending(rdev, conf->mddev);
5479 struct md_rdev *rdev = (void *)raid_bi->bi_next;
5480 struct mddev *mddev = rdev->mddev;
5486 rdev_dec_pending(rdev, conf->mddev);
5504 struct md_rdev *rdev;
5522 rdev = rcu_dereference(conf->disks[dd_idx].replacement);
5523 if (!rdev || test_bit(Faulty, &rdev->flags) ||
5524 rdev->recovery_offset < end_sector) {
5525 rdev = rcu_dereference(conf->disks[dd_idx].rdev);
5526 if (!rdev)
5528 if (test_bit(Faulty, &rdev->flags) ||
5529 !(test_bit(In_sync, &rdev->flags) ||
5530 rdev->recovery_offset >= end_sector))
5534 atomic_inc(&rdev->nr_pending);
5537 if (is_badblock(rdev, sector, bio_sectors(raid_bio), &first_bad,
5539 rdev_dec_pending(rdev, mddev);
5544 raid_bio->bi_next = (void *)rdev;
5546 align_bio = bio_alloc_clone(rdev->bdev, raid_bio, GFP_NOIO,
5552 /* No reshape active, so we can trust rdev->data_offset */
5553 align_bio->bi_iter.bi_sector += rdev->data_offset;
6274 struct md_rdev *rdev;
6399 rdev_for_each(rdev, mddev)
6400 if (rdev->raid_disk >= 0 &&
6401 !test_bit(Journal, &rdev->flags) &&
6402 !test_bit(In_sync, &rdev->flags) &&
6403 rdev->recovery_offset < sector_nr)
6404 rdev->recovery_offset = sector_nr;
6508 rdev_for_each(rdev, mddev)
6509 if (rdev->raid_disk >= 0 &&
6510 !test_bit(Journal, &rdev->flags) &&
6511 !test_bit(In_sync, &rdev->flags) &&
6512 rdev->recovery_offset < sector_nr)
6513 rdev->recovery_offset = sector_nr;
6610 struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
6612 if (rdev == NULL || test_bit(Faulty, &rdev->flags))
7494 struct md_rdev *rdev;
7574 rdev_for_each(rdev, mddev) {
7575 if (test_bit(Journal, &rdev->flags))
7577 if (bdev_nonrot(rdev->bdev)) {
7646 rdev_for_each(rdev, mddev) {
7647 raid_disk = rdev->raid_disk;
7649 || raid_disk < 0 || test_bit(Journal, &rdev->flags))
7653 if (test_bit(Replacement, &rdev->flags)) {
7656 RCU_INIT_POINTER(disk->replacement, rdev);
7658 if (disk->rdev)
7660 RCU_INIT_POINTER(disk->rdev, rdev);
7663 if (test_bit(In_sync, &rdev->flags)) {
7665 mdname(mddev), rdev->bdev, raid_disk);
7666 } else if (rdev->saved_raid_disk != raid_disk)
7783 struct md_rdev *rdev;
7797 rdev_for_each(rdev, mddev) {
7800 if (test_bit(Journal, &rdev->flags)) {
7801 journal_dev = rdev;
7804 if (rdev->raid_disk < 0)
7806 diff = (rdev->new_data_offset - rdev->data_offset);
7945 rdev = rdev_mdlock_deref(mddev, conf->disks[i].rdev);
7946 if (!rdev && conf->disks[i].replacement) {
7948 rdev = rdev_mdlock_deref(mddev,
7951 clear_bit(Replacement, &rdev->flags);
7952 rcu_assign_pointer(conf->disks[i].rdev, rdev);
7954 if (!rdev)
7962 if (test_bit(In_sync, &rdev->flags))
7975 rdev->recovery_offset = reshape_offset;
7977 if (rdev->recovery_offset < reshape_offset) {
7979 if (!only_parity(rdev->raid_disk,
7985 if (!only_parity(rdev->raid_disk,
8076 rdev_for_each(rdev, mddev) {
8077 disk_stack_limits(mddev->gendisk, rdev->bdev,
8078 rdev->data_offset << 9);
8079 disk_stack_limits(mddev->gendisk, rdev->bdev,
8080 rdev->new_data_offset << 9);
8145 struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
8146 seq_printf (seq, "%s", rdev && test_bit(In_sync, &rdev->flags) ? "U" : "_");
8154 struct md_rdev *rdev;
8168 rdev = rcu_dereference(conf->disks[i].rdev);
8169 if (rdev)
8171 i, !test_bit(Faulty, &rdev->flags),
8172 rdev->bdev);
8181 struct md_rdev *rdev, *replacement;
8186 rdev = rdev_mdlock_deref(mddev, conf->disks[i].rdev);
8194 if (!rdev
8195 || !test_and_clear_bit(In_sync, &rdev->flags))
8197 if (rdev) {
8202 set_bit(Faulty, &rdev->flags);
8204 rdev->sysfs_state);
8207 } else if (rdev
8208 && rdev->recovery_offset == MaxSector
8209 && !test_bit(Faulty, &rdev->flags)
8210 && !test_and_set_bit(In_sync, &rdev->flags)) {
8212 sysfs_notify_dirent_safe(rdev->sysfs_state);
8222 static int raid5_remove_disk(struct mddev *mddev, struct md_rdev *rdev)
8226 int number = rdev->raid_disk;
8232 if (test_bit(Journal, &rdev->flags) && conf->log) {
8250 if (rdev == rcu_access_pointer(p->rdev))
8251 rdevp = &p->rdev;
8252 else if (rdev == rcu_access_pointer(p->replacement))
8259 clear_bit(In_sync, &rdev->flags);
8261 if (test_bit(In_sync, &rdev->flags) ||
8262 atomic_read(&rdev->nr_pending)) {
8269 if (!test_bit(Faulty, &rdev->flags) &&
8273 rcu_access_pointer(p->replacement) == rdev) &&
8279 if (!test_bit(RemoveSynchronized, &rdev->flags)) {
8282 if (atomic_read(&rdev->nr_pending)) {
8285 rcu_assign_pointer(*rdevp, rdev);
8289 err = log_modify(conf, rdev, false);
8296 /* We must have just cleared 'rdev' */
8297 rcu_assign_pointer(p->rdev, tmp);
8308 clear_bit(WantReplacement, &rdev->flags);
8315 static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)
8325 if (test_bit(Journal, &rdev->flags)) {
8329 rdev->raid_disk = 0;
8334 ret = log_init(conf, rdev, false);
8347 if (rdev->saved_raid_disk < 0 && has_failed(conf))
8351 if (rdev->raid_disk >= 0)
8352 first = last = rdev->raid_disk;
8355 * find the disk ... but prefer rdev->saved_raid_disk
8358 if (rdev->saved_raid_disk >= first &&
8359 rdev->saved_raid_disk <= last &&
8360 conf->disks[rdev->saved_raid_disk].rdev == NULL)
8361 first = rdev->saved_raid_disk;
8365 if (p->rdev == NULL) {
8366 clear_bit(In_sync, &rdev->flags);
8367 rdev->raid_disk = disk;
8368 if (rdev->saved_raid_disk != disk)
8370 rcu_assign_pointer(p->rdev, rdev);
8372 err = log_modify(conf, rdev, true);
8379 tmp = rdev_mdlock_deref(mddev, p->rdev);
8383 clear_bit(In_sync, &rdev->flags);
8384 set_bit(Replacement, &rdev->flags);
8385 rdev->raid_disk = disk;
8388 rcu_assign_pointer(p->replacement, rdev);
8503 struct md_rdev *rdev;
8524 rdev_for_each(rdev, mddev) {
8525 if (!test_bit(In_sync, &rdev->flags)
8526 && !test_bit(Faulty, &rdev->flags))
8584 rdev_for_each(rdev, mddev)
8585 if (rdev->raid_disk < 0 &&
8586 !test_bit(Faulty, &rdev->flags)) {
8587 if (raid5_add_disk(mddev, rdev) == 0) {
8588 if (rdev->raid_disk
8590 set_bit(In_sync, &rdev->flags);
8592 rdev->recovery_offset = 0;
8595 sysfs_link_rdev(mddev, rdev);
8597 } else if (rdev->raid_disk >= conf->previous_raid_disks
8598 && !test_bit(Faulty, &rdev->flags)) {
8600 set_bit(In_sync, &rdev->flags);
8630 rdev_for_each(rdev, mddev)
8631 rdev->new_data_offset = rdev->data_offset;
8653 struct md_rdev *rdev;
8661 rdev_for_each(rdev, conf->mddev)
8662 if (rdev->raid_disk >= 0 &&
8663 !test_bit(Journal, &rdev->flags) &&
8664 !test_bit(In_sync, &rdev->flags))
8665 rdev->recovery_offset = MaxSector;
8680 struct md_rdev *rdev;
8692 rdev = rdev_mdlock_deref(mddev,
8693 conf->disks[d].rdev);
8694 if (rdev)
8695 clear_bit(In_sync, &rdev->flags);
8696 rdev = rdev_mdlock_deref(mddev,
8698 if (rdev)
8699 clear_bit(In_sync, &rdev->flags);
9021 struct md_rdev *rdev;
9023 rdev_for_each(rdev, mddev)
9024 if (test_bit(Journal, &rdev->flags)) {