Merge tag 'md-7.0-20260127' of git://git.kernel.org/pub/scm/linux/kernel/git/mdraid/linux into for-7.0/block

+4 -3

drivers/md/md-bitmap.c

··· 2085 2085 return; 2086 2086 2087 2087 bitmap_wait_behind_writes(mddev); 2088 - if (!mddev->serialize_policy) 2088 + if (!test_bit(MD_SERIALIZE_POLICY, &mddev->flags)) 2089 2089 mddev_destroy_serial_pool(mddev, NULL); 2090 2090 2091 2091 mutex_lock(&mddev->bitmap_info.mutex); ··· 2453 2453 memcpy(page_address(store.sb_page), 2454 2454 page_address(bitmap->storage.sb_page), 2455 2455 sizeof(bitmap_super_t)); 2456 + mutex_lock(&bitmap->mddev->bitmap_info.mutex); 2456 2457 spin_lock_irq(&bitmap->counts.lock); 2457 2458 md_bitmap_file_unmap(&bitmap->storage); 2458 2459 bitmap->storage = store; ··· 2561 2560 set_page_attr(bitmap, i, BITMAP_PAGE_DIRTY); 2562 2561 } 2563 2562 spin_unlock_irq(&bitmap->counts.lock); 2564 - 2563 + mutex_unlock(&bitmap->mddev->bitmap_info.mutex); 2565 2564 if (!init) { 2566 2565 __bitmap_unplug(bitmap); 2567 2566 bitmap->mddev->pers->quiesce(bitmap->mddev, 0); ··· 2810 2809 mddev->bitmap_info.max_write_behind = backlog; 2811 2810 if (!backlog && mddev->serial_info_pool) { 2812 2811 /* serial_info_pool is not needed if backlog is zero */ 2813 - if (!mddev->serialize_policy) 2812 + if (!test_bit(MD_SERIALIZE_POLICY, &mddev->flags)) 2814 2813 mddev_destroy_serial_pool(mddev, NULL); 2815 2814 } else if (backlog && !mddev->serial_info_pool) { 2816 2815 /* serial_info_pool is needed since backlog is not zero */

+6 -1

drivers/md/md-cluster.c

··· 549 549 550 550 dlm_lock_sync(cinfo->no_new_dev_lockres, DLM_LOCK_CR); 551 551 552 - /* daemaon thread must exist */ 553 552 thread = rcu_dereference_protected(mddev->thread, true); 553 + if (!thread) { 554 + pr_warn("md-cluster: Received metadata update but MD thread is not ready\n"); 555 + dlm_unlock_sync(cinfo->no_new_dev_lockres); 556 + return; 557 + } 558 + 554 559 wait_event(thread->wqueue, 555 560 (got_lock = mddev_trylock(mddev)) || 556 561 test_bit(MD_CLUSTER_HOLDING_MUTEX_FOR_RECVD, &cinfo->state));

+3 -1

drivers/md/md-llbitmap.c

··· 712 712 percpu_ref_kill(&pctl->active); 713 713 714 714 if (!wait_event_timeout(pctl->wait, percpu_ref_is_zero(&pctl->active), 715 - llbitmap->mddev->bitmap_info.daemon_sleep * HZ)) 715 + llbitmap->mddev->bitmap_info.daemon_sleep * HZ)) { 716 + percpu_ref_resurrect(&pctl->active); 716 717 return -ETIMEDOUT; 718 + } 717 719 718 720 return 0; 719 721 }

+99 -89

drivers/md/md.c

··· 279 279 280 280 rdev_for_each(temp, mddev) { 281 281 if (!rdev) { 282 - if (!mddev->serialize_policy || 282 + if (!test_bit(MD_SERIALIZE_POLICY, 283 + &mddev->flags) || 283 284 !rdev_need_serial(temp)) 284 285 rdev_uninit_serial(temp); 285 286 else ··· 2617 2616 2618 2617 list_add_rcu(&rdev->same_set, &mddev->disks); 2619 2618 bd_link_disk_holder(rdev->bdev, mddev->gendisk); 2620 - 2621 - /* May as well allow recovery to be retried once */ 2622 - mddev->recovery_disabled++; 2623 2619 2624 2620 return 0; 2625 2621 ··· 5862 5864 5863 5865 static ssize_t fail_last_dev_show(struct mddev *mddev, char *page) 5864 5866 { 5865 - return sprintf(page, "%d\n", mddev->fail_last_dev); 5867 + return sprintf(page, "%d\n", test_bit(MD_FAILLAST_DEV, &mddev->flags)); 5866 5868 } 5867 5869 5868 5870 /* 5869 - * Setting fail_last_dev to true to allow last device to be forcibly removed 5871 + * Setting MD_FAILLAST_DEV to allow last device to be forcibly removed 5870 5872 * from RAID1/RAID10. 5871 5873 */ 5872 5874 static ssize_t ··· 5879 5881 if (ret) 5880 5882 return ret; 5881 5883 5882 - if (value != mddev->fail_last_dev) 5883 - mddev->fail_last_dev = value; 5884 + if (value) 5885 + set_bit(MD_FAILLAST_DEV, &mddev->flags); 5886 + else 5887 + clear_bit(MD_FAILLAST_DEV, &mddev->flags); 5884 5888 5885 5889 return len; 5886 5890 } ··· 5895 5895 if (mddev->pers == NULL || (mddev->pers->head.id != ID_RAID1)) 5896 5896 return sprintf(page, "n/a\n"); 5897 5897 else 5898 - return sprintf(page, "%d\n", mddev->serialize_policy); 5898 + return sprintf(page, "%d\n", 5899 + test_bit(MD_SERIALIZE_POLICY, &mddev->flags)); 5899 5900 } 5900 5901 5901 5902 /* 5902 - * Setting serialize_policy to true to enforce write IO is not reordered 5903 + * Setting MD_SERIALIZE_POLICY enforce write IO is not reordered 5903 5904 * for raid1. 5904 5905 */ 5905 5906 static ssize_t ··· 5913 5912 if (err) 5914 5913 return err; 5915 5914 5916 - if (value == mddev->serialize_policy) 5915 + if (value == test_bit(MD_SERIALIZE_POLICY, &mddev->flags)) 5917 5916 return len; 5918 5917 5919 5918 err = mddev_suspend_and_lock(mddev); ··· 5925 5924 goto unlock; 5926 5925 } 5927 5926 5928 - if (value) 5927 + if (value) { 5929 5928 mddev_create_serial_pool(mddev, NULL); 5930 - else 5929 + set_bit(MD_SERIALIZE_POLICY, &mddev->flags); 5930 + } else { 5931 5931 mddev_destroy_serial_pool(mddev, NULL); 5932 - mddev->serialize_policy = value; 5932 + clear_bit(MD_SERIALIZE_POLICY, &mddev->flags); 5933 + } 5933 5934 unlock: 5934 5935 mddev_unlock_and_resume(mddev); 5935 5936 return err ?: len; ··· 6505 6502 * the only valid external interface is through the md 6506 6503 * device. 6507 6504 */ 6508 - mddev->has_superblocks = false; 6505 + clear_bit(MD_HAS_SUPERBLOCK, &mddev->flags); 6509 6506 rdev_for_each(rdev, mddev) { 6510 6507 if (test_bit(Faulty, &rdev->flags)) 6511 6508 continue; ··· 6518 6515 } 6519 6516 6520 6517 if (rdev->sb_page) 6521 - mddev->has_superblocks = true; 6518 + set_bit(MD_HAS_SUPERBLOCK, &mddev->flags); 6522 6519 6523 6520 /* perform some consistency tests on the device. 6524 6521 * We don't want the data to overlap the metadata, ··· 6851 6848 { 6852 6849 timer_delete_sync(&mddev->safemode_timer); 6853 6850 6854 - if (mddev->pers && mddev->pers->quiesce) { 6855 - mddev->pers->quiesce(mddev, 1); 6856 - mddev->pers->quiesce(mddev, 0); 6857 - } 6851 + if (md_is_rdwr(mddev) || !mddev_is_dm(mddev)) { 6852 + if (mddev->pers && mddev->pers->quiesce) { 6853 + mddev->pers->quiesce(mddev, 1); 6854 + mddev->pers->quiesce(mddev, 0); 6855 + } 6858 6856 6859 - if (md_bitmap_enabled(mddev, true)) 6860 - mddev->bitmap_ops->flush(mddev); 6857 + if (md_bitmap_enabled(mddev, true)) 6858 + mddev->bitmap_ops->flush(mddev); 6859 + } 6861 6860 6862 6861 if (md_is_rdwr(mddev) && 6863 6862 ((!mddev->in_sync && !mddev_is_clustered(mddev)) || ··· 6870 6865 md_update_sb(mddev, 1); 6871 6866 } 6872 6867 /* disable policy to guarantee rdevs free resources for serialization */ 6873 - mddev->serialize_policy = 0; 6868 + clear_bit(MD_SERIALIZE_POLICY, &mddev->flags); 6874 6869 mddev_destroy_serial_pool(mddev, NULL); 6875 6870 } 6876 6871 ··· 9073 9068 return idle; 9074 9069 } 9075 9070 9076 - void md_done_sync(struct mddev *mddev, int blocks, int ok) 9071 + void md_done_sync(struct mddev *mddev, int blocks) 9077 9072 { 9078 9073 /* another "blocks" (512byte) blocks have been synced */ 9079 9074 atomic_sub(blocks, &mddev->recovery_active); 9080 9075 wake_up(&mddev->recovery_wait); 9081 - if (!ok) { 9082 - set_bit(MD_RECOVERY_INTR, &mddev->recovery); 9083 - set_bit(MD_RECOVERY_ERROR, &mddev->recovery); 9084 - md_wakeup_thread(mddev->thread); 9085 - // stop recovery, signal do_sync .... 9086 - } 9087 9076 } 9088 9077 EXPORT_SYMBOL(md_done_sync); 9078 + 9079 + void md_sync_error(struct mddev *mddev) 9080 + { 9081 + // stop recovery, signal do_sync .... 9082 + set_bit(MD_RECOVERY_INTR, &mddev->recovery); 9083 + md_wakeup_thread(mddev->thread); 9084 + } 9085 + EXPORT_SYMBOL(md_sync_error); 9089 9086 9090 9087 /* md_write_start(mddev, bi) 9091 9088 * If we need to update some array metadata (e.g. 'active' flag ··· 9132 9125 rcu_read_unlock(); 9133 9126 if (did_change) 9134 9127 sysfs_notify_dirent_safe(mddev->sysfs_state); 9135 - if (!mddev->has_superblocks) 9128 + if (!test_bit(MD_HAS_SUPERBLOCK, &mddev->flags)) 9136 9129 return; 9137 9130 wait_event(mddev->sb_wait, 9138 9131 !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)); ··· 9437 9430 (raid_is_456(mddev) ? 8 : 128) * sync_io_depth(mddev); 9438 9431 } 9439 9432 9433 + /* 9434 + * Update sync offset and mddev status when sync completes 9435 + */ 9436 + static void md_finish_sync(struct mddev *mddev, enum sync_action action) 9437 + { 9438 + struct md_rdev *rdev; 9439 + 9440 + switch (action) { 9441 + case ACTION_RESYNC: 9442 + case ACTION_REPAIR: 9443 + if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) 9444 + mddev->curr_resync = MaxSector; 9445 + mddev->resync_offset = mddev->curr_resync; 9446 + break; 9447 + case ACTION_RECOVER: 9448 + if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) 9449 + mddev->curr_resync = MaxSector; 9450 + rcu_read_lock(); 9451 + rdev_for_each_rcu(rdev, mddev) 9452 + if (mddev->delta_disks >= 0 && 9453 + rdev_needs_recovery(rdev, mddev->curr_resync)) 9454 + rdev->recovery_offset = mddev->curr_resync; 9455 + rcu_read_unlock(); 9456 + break; 9457 + case ACTION_RESHAPE: 9458 + if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) && 9459 + mddev->delta_disks > 0 && 9460 + mddev->pers->finish_reshape && 9461 + mddev->pers->size && 9462 + !mddev_is_dm(mddev)) { 9463 + mddev_lock_nointr(mddev); 9464 + md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0)); 9465 + mddev_unlock(mddev); 9466 + if (!mddev_is_clustered(mddev)) 9467 + set_capacity_and_notify(mddev->gendisk, 9468 + mddev->array_sectors); 9469 + } 9470 + if (mddev->pers->finish_reshape) 9471 + mddev->pers->finish_reshape(mddev); 9472 + break; 9473 + /* */ 9474 + case ACTION_CHECK: 9475 + default: 9476 + break; 9477 + } 9478 + } 9479 + 9440 9480 #define SYNC_MARKS 10 9441 9481 #define SYNC_MARK_STEP (3*HZ) 9442 9482 #define UPDATE_FREQUENCY (5*60*HZ) ··· 9499 9445 int last_mark,m; 9500 9446 sector_t last_check; 9501 9447 int skipped = 0; 9502 - struct md_rdev *rdev; 9503 9448 enum sync_action action; 9504 9449 const char *desc; 9505 9450 struct blk_plug plug; ··· 9784 9731 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active)); 9785 9732 9786 9733 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 9787 - !test_bit(MD_RECOVERY_INTR, &mddev->recovery) && 9788 9734 mddev->curr_resync >= MD_RESYNC_ACTIVE) { 9735 + /* All sync IO completes after recovery_active becomes 0 */ 9789 9736 mddev->curr_resync_completed = mddev->curr_resync; 9790 9737 sysfs_notify_dirent_safe(mddev->sysfs_completed); 9791 9738 } 9792 9739 mddev->pers->sync_request(mddev, max_sectors, max_sectors, &skipped); 9793 9740 9794 - if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) && 9795 - mddev->curr_resync > MD_RESYNC_ACTIVE) { 9796 - if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) { 9797 - if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) { 9798 - if (mddev->curr_resync >= mddev->resync_offset) { 9799 - pr_debug("md: checkpointing %s of %s.\n", 9800 - desc, mdname(mddev)); 9801 - if (test_bit(MD_RECOVERY_ERROR, 9802 - &mddev->recovery)) 9803 - mddev->resync_offset = 9804 - mddev->curr_resync_completed; 9805 - else 9806 - mddev->resync_offset = 9807 - mddev->curr_resync; 9808 - } 9809 - } else 9810 - mddev->resync_offset = MaxSector; 9811 - } else { 9812 - if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) 9813 - mddev->curr_resync = MaxSector; 9814 - if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 9815 - test_bit(MD_RECOVERY_RECOVER, &mddev->recovery)) { 9816 - rcu_read_lock(); 9817 - rdev_for_each_rcu(rdev, mddev) 9818 - if (mddev->delta_disks >= 0 && 9819 - rdev_needs_recovery(rdev, mddev->curr_resync)) 9820 - rdev->recovery_offset = mddev->curr_resync; 9821 - rcu_read_unlock(); 9822 - } 9823 - } 9824 - } 9741 + if (mddev->curr_resync > MD_RESYNC_ACTIVE) 9742 + md_finish_sync(mddev, action); 9825 9743 skip: 9826 9744 /* set CHANGE_PENDING here since maybe another update is needed, 9827 9745 * so other nodes are informed. It should be harmless for normal 9828 9746 * raid */ 9829 9747 set_mask_bits(&mddev->sb_flags, 0, 9830 9748 BIT(MD_SB_CHANGE_PENDING) | BIT(MD_SB_CHANGE_DEVS)); 9831 - 9832 - if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 9833 - !test_bit(MD_RECOVERY_INTR, &mddev->recovery) && 9834 - mddev->delta_disks > 0 && 9835 - mddev->pers->finish_reshape && 9836 - mddev->pers->size && 9837 - !mddev_is_dm(mddev)) { 9838 - mddev_lock_nointr(mddev); 9839 - md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0)); 9840 - mddev_unlock(mddev); 9841 - if (!mddev_is_clustered(mddev)) 9842 - set_capacity_and_notify(mddev->gendisk, 9843 - mddev->array_sectors); 9844 - } 9845 - 9846 9749 spin_lock(&mddev->lock); 9847 9750 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) { 9848 9751 /* We completed so min/max setting can be forgotten if used. */ ··· 10313 10304 { 10314 10305 struct md_rdev *rdev; 10315 10306 sector_t old_dev_sectors = mddev->dev_sectors; 10316 - bool is_reshaped = false; 10307 + bool is_reshaped = test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery); 10317 10308 10318 10309 /* resync has finished, collect result */ 10319 10310 md_unregister_thread(mddev, &mddev->sync_thread); ··· 10328 10319 sysfs_notify_dirent_safe(mddev->sysfs_degraded); 10329 10320 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 10330 10321 } 10331 - } 10332 - if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 10333 - mddev->pers->finish_reshape) { 10334 - mddev->pers->finish_reshape(mddev); 10335 - if (mddev_is_clustered(mddev)) 10336 - is_reshaped = true; 10337 10322 } 10338 10323 10339 10324 /* If array is no-longer degraded, then any saved_raid_disk ··· 10355 10352 * be changed by md_update_sb, and MD_RECOVERY_RESHAPE is cleared, 10356 10353 * so it is time to update size across cluster. 10357 10354 */ 10358 - if (mddev_is_clustered(mddev) && is_reshaped 10359 - && !test_bit(MD_CLOSING, &mddev->flags)) 10355 + if (mddev_is_clustered(mddev) && is_reshaped && 10356 + mddev->pers->finish_reshape && 10357 + !test_bit(MD_CLOSING, &mddev->flags)) 10360 10358 mddev->cluster_ops->update_size(mddev, old_dev_sectors); 10361 10359 /* flag recovery needed just to double check */ 10362 10360 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); ··· 10417 10413 else 10418 10414 s += rdev->data_offset; 10419 10415 10420 - if (!badblocks_set(&rdev->badblocks, s, sectors, 0)) 10416 + if (!badblocks_set(&rdev->badblocks, s, sectors, 0)) { 10417 + /* 10418 + * Mark the disk as Faulty when setting badblocks fails, 10419 + * otherwise, bad sectors may be read. 10420 + */ 10421 + md_error(mddev, rdev); 10421 10422 return false; 10423 + } 10422 10424 10423 10425 /* Make sure they get written out promptly */ 10424 10426 if (test_bit(ExternalBbl, &rdev->flags))

+12 -13

drivers/md/md.h

··· 22 22 #include <trace/events/block.h> 23 23 24 24 #define MaxSector (~(sector_t)0) 25 + /* 26 + * Number of guaranteed raid bios in case of extreme VM load: 27 + */ 28 + #define NR_RAID_BIOS 256 25 29 26 30 enum md_submodule_type { 27 31 MD_PERSONALITY = 0, ··· 344 340 * array is ready yet. 345 341 * @MD_BROKEN: This is used to stop writes and mark array as failed. 346 342 * @MD_DELETED: This device is being deleted 343 + * @MD_HAS_SUPERBLOCK: There is persistence sb in member disks. 344 + * @MD_FAILLAST_DEV: Allow last rdev to be removed. 345 + * @MD_SERIALIZE_POLICY: Enforce write IO is not reordered, just used by raid1. 347 346 * 348 347 * change UNSUPPORTED_MDDEV_FLAGS for each array type if new flag is added 349 348 */ ··· 363 356 MD_BROKEN, 364 357 MD_DO_DELETE, 365 358 MD_DELETED, 359 + MD_HAS_SUPERBLOCK, 360 + MD_FAILLAST_DEV, 361 + MD_SERIALIZE_POLICY, 366 362 }; 367 363 368 364 enum mddev_sb_flags { ··· 505 495 int ok_start_degraded; 506 496 507 497 unsigned long recovery; 508 - /* If a RAID personality determines that recovery (of a particular 509 - * device) will fail due to a read error on the source device, it 510 - * takes a copy of this number and does not attempt recovery again 511 - * until this number changes. 512 - */ 513 - int recovery_disabled; 514 498 515 499 int in_sync; /* know to not need resync */ 516 500 /* 'open_mutex' avoids races between 'md_open' and 'do_md_stop', so ··· 626 622 627 623 /* The sequence number for sync thread */ 628 624 atomic_t sync_seq; 629 - 630 - bool has_superblocks:1; 631 - bool fail_last_dev:1; 632 - bool serialize_policy:1; 633 625 }; 634 626 635 627 enum recovery_flags { ··· 646 646 MD_RECOVERY_FROZEN, 647 647 /* waiting for pers->start() to finish */ 648 648 MD_RECOVERY_WAIT, 649 - /* interrupted because io-error */ 650 - MD_RECOVERY_ERROR, 651 649 652 650 /* flags determines sync action, see details in enum sync_action */ 653 651 ··· 910 912 extern void md_write_start(struct mddev *mddev, struct bio *bi); 911 913 extern void md_write_inc(struct mddev *mddev, struct bio *bi); 912 914 extern void md_write_end(struct mddev *mddev); 913 - extern void md_done_sync(struct mddev *mddev, int blocks, int ok); 915 + extern void md_done_sync(struct mddev *mddev, int blocks); 916 + extern void md_sync_error(struct mddev *mddev); 914 917 extern void md_error(struct mddev *mddev, struct md_rdev *rdev); 915 918 extern void md_finish_reshape(struct mddev *mddev); 916 919 void md_submit_discard_bio(struct mddev *mddev, struct md_rdev *rdev,

+3 -1

drivers/md/raid0.c

··· 27 27 (1L << MD_JOURNAL_CLEAN) | \ 28 28 (1L << MD_FAILFAST_SUPPORTED) |\ 29 29 (1L << MD_HAS_PPL) | \ 30 - (1L << MD_HAS_MULTIPLE_PPLS)) 30 + (1L << MD_HAS_MULTIPLE_PPLS) | \ 31 + (1L << MD_FAILLAST_DEV) | \ 32 + (1L << MD_SERIALIZE_POLICY)) 31 33 32 34 /* 33 35 * inform the user of the raid configuration

-5

drivers/md/raid1-10.c

··· 3 3 #define RESYNC_BLOCK_SIZE (64*1024) 4 4 #define RESYNC_PAGES ((RESYNC_BLOCK_SIZE + PAGE_SIZE-1) / PAGE_SIZE) 5 5 6 - /* 7 - * Number of guaranteed raid bios in case of extreme VM load: 8 - */ 9 - #define NR_RAID_BIOS 256 10 - 11 6 /* when we get a read error on a read-only array, we redirect to another 12 7 * device without failing the first device, or trying to over-write to 13 8 * correct the read error. To keep track of bad blocks on a per-bio

+35 -53

drivers/md/raid1.c

··· 542 542 call_bio_endio(r1_bio); 543 543 } 544 544 } 545 - } else if (rdev->mddev->serialize_policy) 545 + } else if (test_bit(MD_SERIALIZE_POLICY, &rdev->mddev->flags)) 546 546 remove_serial(rdev, lo, hi); 547 547 if (r1_bio->bios[mirror] == NULL) 548 548 rdev_dec_pending(rdev, conf->mddev); ··· 1644 1644 mbio = bio_alloc_clone(rdev->bdev, bio, GFP_NOIO, 1645 1645 &mddev->bio_set); 1646 1646 1647 - if (mddev->serialize_policy) 1647 + if (test_bit(MD_SERIALIZE_POLICY, &mddev->flags)) 1648 1648 wait_for_serialization(rdev, r1_bio); 1649 1649 } 1650 1650 ··· 1746 1746 * - &mddev->degraded is bumped. 1747 1747 * 1748 1748 * @rdev is marked as &Faulty excluding case when array is failed and 1749 - * &mddev->fail_last_dev is off. 1749 + * MD_FAILLAST_DEV is not set. 1750 1750 */ 1751 1751 static void raid1_error(struct mddev *mddev, struct md_rdev *rdev) 1752 1752 { ··· 1759 1759 (conf->raid_disks - mddev->degraded) == 1) { 1760 1760 set_bit(MD_BROKEN, &mddev->flags); 1761 1761 1762 - if (!mddev->fail_last_dev) { 1763 - conf->recovery_disabled = mddev->recovery_disabled; 1762 + if (!test_bit(MD_FAILLAST_DEV, &mddev->flags)) { 1764 1763 spin_unlock_irqrestore(&conf->device_lock, flags); 1765 1764 return; 1766 1765 } ··· 1903 1904 1904 1905 /* Only remove non-faulty devices if recovery is not possible. */ 1905 1906 if (!test_bit(Faulty, &rdev->flags) && 1906 - rdev->mddev->recovery_disabled != conf->recovery_disabled && 1907 1907 rdev->mddev->degraded < conf->raid_disks) 1908 1908 return false; 1909 1909 ··· 1921 1923 struct raid1_info *p; 1922 1924 int first = 0; 1923 1925 int last = conf->raid_disks - 1; 1924 - 1925 - if (mddev->recovery_disabled == conf->recovery_disabled) 1926 - return -EBUSY; 1927 1926 1928 1927 if (rdev->raid_disk >= 0) 1929 1928 first = last = rdev->raid_disk; ··· 2057 2062 } while (sectors_to_go > 0); 2058 2063 } 2059 2064 2060 - static void put_sync_write_buf(struct r1bio *r1_bio, int uptodate) 2065 + static void put_sync_write_buf(struct r1bio *r1_bio) 2061 2066 { 2062 2067 if (atomic_dec_and_test(&r1_bio->remaining)) { 2063 2068 struct mddev *mddev = r1_bio->mddev; ··· 2068 2073 reschedule_retry(r1_bio); 2069 2074 else { 2070 2075 put_buf(r1_bio); 2071 - md_done_sync(mddev, s, uptodate); 2076 + md_done_sync(mddev, s); 2072 2077 } 2073 2078 } 2074 2079 } 2075 2080 2076 2081 static void end_sync_write(struct bio *bio) 2077 2082 { 2078 - int uptodate = !bio->bi_status; 2079 2083 struct r1bio *r1_bio = get_resync_r1bio(bio); 2080 2084 struct mddev *mddev = r1_bio->mddev; 2081 2085 struct r1conf *conf = mddev->private; 2082 2086 struct md_rdev *rdev = conf->mirrors[find_bio_disk(r1_bio, bio)].rdev; 2083 2087 2084 - if (!uptodate) { 2088 + if (bio->bi_status) { 2085 2089 abort_sync_write(mddev, r1_bio); 2086 2090 set_bit(WriteErrorSeen, &rdev->flags); 2087 2091 if (!test_and_set_bit(WantReplacement, &rdev->flags)) ··· 2093 2099 set_bit(R1BIO_MadeGood, &r1_bio->state); 2094 2100 } 2095 2101 2096 - put_sync_write_buf(r1_bio, uptodate); 2102 + put_sync_write_buf(r1_bio); 2097 2103 } 2098 2104 2099 2105 static int r1_sync_page_io(struct md_rdev *rdev, sector_t sector, ··· 2110 2116 rdev->mddev->recovery); 2111 2117 } 2112 2118 /* need to record an error - either for the block or the device */ 2113 - if (!rdev_set_badblocks(rdev, sector, sectors, 0)) 2114 - md_error(rdev->mddev, rdev); 2119 + rdev_set_badblocks(rdev, sector, sectors, 0); 2115 2120 return 0; 2116 2121 } 2117 2122 ··· 2341 2348 */ 2342 2349 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) || 2343 2350 !fix_sync_read_error(r1_bio)) { 2344 - conf->recovery_disabled = mddev->recovery_disabled; 2345 - set_bit(MD_RECOVERY_INTR, &mddev->recovery); 2346 - md_done_sync(mddev, r1_bio->sectors, 0); 2351 + md_done_sync(mddev, r1_bio->sectors); 2352 + md_sync_error(mddev); 2347 2353 put_buf(r1_bio); 2348 2354 return; 2349 2355 } ··· 2377 2385 submit_bio_noacct(wbio); 2378 2386 } 2379 2387 2380 - put_sync_write_buf(r1_bio, 1); 2388 + put_sync_write_buf(r1_bio); 2381 2389 } 2382 2390 2383 2391 /* ··· 2434 2442 if (!success) { 2435 2443 /* Cannot read from anywhere - mark it bad */ 2436 2444 struct md_rdev *rdev = conf->mirrors[read_disk].rdev; 2437 - if (!rdev_set_badblocks(rdev, sect, s, 0)) 2438 - md_error(mddev, rdev); 2445 + rdev_set_badblocks(rdev, sect, s, 0); 2439 2446 break; 2440 2447 } 2441 2448 /* write it back and re-read */ ··· 2478 2487 } 2479 2488 } 2480 2489 2481 - static bool narrow_write_error(struct r1bio *r1_bio, int i) 2490 + static void narrow_write_error(struct r1bio *r1_bio, int i) 2482 2491 { 2483 2492 struct mddev *mddev = r1_bio->mddev; 2484 2493 struct r1conf *conf = mddev->private; ··· 2495 2504 * We currently own a reference on the rdev. 2496 2505 */ 2497 2506 2498 - int block_sectors; 2507 + int block_sectors, lbs = bdev_logical_block_size(rdev->bdev) >> 9; 2499 2508 sector_t sector; 2500 2509 int sectors; 2501 2510 int sect_to_write = r1_bio->sectors; 2502 - bool ok = true; 2503 2511 2504 2512 if (rdev->badblocks.shift < 0) 2505 - return false; 2513 + block_sectors = lbs; 2514 + else 2515 + block_sectors = roundup(1 << rdev->badblocks.shift, lbs); 2506 2516 2507 - block_sectors = roundup(1 << rdev->badblocks.shift, 2508 - bdev_logical_block_size(rdev->bdev) >> 9); 2509 2517 sector = r1_bio->sector; 2510 2518 sectors = ((sector + block_sectors) 2511 2519 & ~(sector_t)(block_sectors - 1)) ··· 2532 2542 bio_trim(wbio, sector - r1_bio->sector, sectors); 2533 2543 wbio->bi_iter.bi_sector += rdev->data_offset; 2534 2544 2535 - if (submit_bio_wait(wbio) < 0) 2536 - /* failure! */ 2537 - ok = rdev_set_badblocks(rdev, sector, 2538 - sectors, 0) 2539 - && ok; 2545 + if (submit_bio_wait(wbio) && 2546 + !rdev_set_badblocks(rdev, sector, sectors, 0)) { 2547 + /* 2548 + * Badblocks set failed, disk marked Faulty. 2549 + * No further operations needed. 2550 + */ 2551 + bio_put(wbio); 2552 + break; 2553 + } 2540 2554 2541 2555 bio_put(wbio); 2542 2556 sect_to_write -= sectors; 2543 2557 sector += sectors; 2544 2558 sectors = block_sectors; 2545 2559 } 2546 - return ok; 2547 2560 } 2548 2561 2549 2562 static void handle_sync_write_finished(struct r1conf *conf, struct r1bio *r1_bio) ··· 2559 2566 if (bio->bi_end_io == NULL) 2560 2567 continue; 2561 2568 if (!bio->bi_status && 2562 - test_bit(R1BIO_MadeGood, &r1_bio->state)) { 2569 + test_bit(R1BIO_MadeGood, &r1_bio->state)) 2563 2570 rdev_clear_badblocks(rdev, r1_bio->sector, s, 0); 2564 - } 2565 2571 if (bio->bi_status && 2566 - test_bit(R1BIO_WriteError, &r1_bio->state)) { 2567 - if (!rdev_set_badblocks(rdev, r1_bio->sector, s, 0)) 2568 - md_error(conf->mddev, rdev); 2569 - } 2572 + test_bit(R1BIO_WriteError, &r1_bio->state)) 2573 + rdev_set_badblocks(rdev, r1_bio->sector, s, 0); 2570 2574 } 2571 2575 put_buf(r1_bio); 2572 - md_done_sync(conf->mddev, s, 1); 2576 + md_done_sync(conf->mddev, s); 2573 2577 } 2574 2578 2575 2579 static void handle_write_finished(struct r1conf *conf, struct r1bio *r1_bio) ··· 2587 2597 * errors. 2588 2598 */ 2589 2599 fail = true; 2590 - if (!narrow_write_error(r1_bio, m)) 2591 - md_error(conf->mddev, 2592 - conf->mirrors[m].rdev); 2593 - /* an I/O failed, we can't clear the bitmap */ 2600 + narrow_write_error(r1_bio, m); 2594 2601 rdev_dec_pending(conf->mirrors[m].rdev, 2595 2602 conf->mddev); 2596 2603 } ··· 2942 2955 *skipped = 1; 2943 2956 put_buf(r1_bio); 2944 2957 2945 - if (!ok) { 2946 - /* Cannot record the badblocks, so need to 2958 + if (!ok) 2959 + /* Cannot record the badblocks, md_error has set INTR, 2947 2960 * abort the resync. 2948 - * If there are multiple read targets, could just 2949 - * fail the really bad ones ??? 2950 2961 */ 2951 - conf->recovery_disabled = mddev->recovery_disabled; 2952 - set_bit(MD_RECOVERY_INTR, &mddev->recovery); 2953 2962 return 0; 2954 - } else 2963 + else 2955 2964 return min_bad; 2956 2965 2957 2966 } ··· 3134 3151 init_waitqueue_head(&conf->wait_barrier); 3135 3152 3136 3153 bio_list_init(&conf->pending_bio_list); 3137 - conf->recovery_disabled = mddev->recovery_disabled - 1; 3138 3154 3139 3155 err = -EIO; 3140 3156 for (i = 0; i < conf->raid_disks * 2; i++) {

-5

drivers/md/raid1.h

··· 93 93 */ 94 94 int fullsync; 95 95 96 - /* When the same as mddev->recovery_disabled we don't allow 97 - * recovery to be attempted as we expect a read error. 98 - */ 99 - int recovery_disabled; 100 - 101 96 mempool_t *r1bio_pool; 102 97 mempool_t r1buf_pool; 103 98

+56 -122

drivers/md/raid10.c

··· 1990 1990 * - &mddev->degraded is bumped. 1991 1991 * 1992 1992 * @rdev is marked as &Faulty excluding case when array is failed and 1993 - * &mddev->fail_last_dev is off. 1993 + * MD_FAILLAST_DEV is not set. 1994 1994 */ 1995 1995 static void raid10_error(struct mddev *mddev, struct md_rdev *rdev) 1996 1996 { ··· 2002 2002 if (test_bit(In_sync, &rdev->flags) && !enough(conf, rdev->raid_disk)) { 2003 2003 set_bit(MD_BROKEN, &mddev->flags); 2004 2004 2005 - if (!mddev->fail_last_dev) { 2005 + if (!test_bit(MD_FAILLAST_DEV, &mddev->flags)) { 2006 2006 spin_unlock_irqrestore(&conf->device_lock, flags); 2007 2007 return; 2008 2008 } ··· 2130 2130 mirror = first; 2131 2131 for ( ; mirror <= last ; mirror++) { 2132 2132 p = &conf->mirrors[mirror]; 2133 - if (p->recovery_disabled == mddev->recovery_disabled) 2134 - continue; 2135 2133 if (p->rdev) { 2136 2134 if (test_bit(WantReplacement, &p->rdev->flags) && 2137 2135 p->replacement == NULL && repl_slot < 0) ··· 2141 2143 if (err) 2142 2144 return err; 2143 2145 p->head_position = 0; 2144 - p->recovery_disabled = mddev->recovery_disabled - 1; 2145 2146 rdev->raid_disk = mirror; 2146 2147 err = 0; 2147 2148 if (rdev->saved_raid_disk != mirror) ··· 2193 2196 * is not possible. 2194 2197 */ 2195 2198 if (!test_bit(Faulty, &rdev->flags) && 2196 - mddev->recovery_disabled != p->recovery_disabled && 2197 2199 (!p->replacement || p->replacement == rdev) && 2198 2200 number < conf->geo.raid_disks && 2199 2201 enough(conf, -1)) { ··· 2272 2276 reschedule_retry(r10_bio); 2273 2277 else 2274 2278 put_buf(r10_bio); 2275 - md_done_sync(mddev, s, 1); 2279 + md_done_sync(mddev, s); 2276 2280 break; 2277 2281 } else { 2278 2282 struct r10bio *r10_bio2 = (struct r10bio *)r10_bio->master_bio; ··· 2448 2452 2449 2453 done: 2450 2454 if (atomic_dec_and_test(&r10_bio->remaining)) { 2451 - md_done_sync(mddev, r10_bio->sectors, 1); 2455 + md_done_sync(mddev, r10_bio->sectors); 2452 2456 put_buf(r10_bio); 2453 2457 } 2454 2458 } ··· 2531 2535 pr_notice("md/raid10:%s: recovery aborted due to read error\n", 2532 2536 mdname(mddev)); 2533 2537 2534 - conf->mirrors[dw].recovery_disabled 2535 - = mddev->recovery_disabled; 2536 2538 set_bit(MD_RECOVERY_INTR, 2537 2539 &mddev->recovery); 2538 2540 break; ··· 2598 2604 &rdev->mddev->recovery); 2599 2605 } 2600 2606 /* need to record an error - either for the block or the device */ 2601 - if (!rdev_set_badblocks(rdev, sector, sectors, 0)) 2602 - md_error(rdev->mddev, rdev); 2607 + rdev_set_badblocks(rdev, sector, sectors, 0); 2603 2608 return 0; 2604 2609 } 2605 2610 ··· 2679 2686 r10_bio->devs[slot].addr 2680 2687 + sect, 2681 2688 s, 0)) { 2682 - md_error(mddev, rdev); 2683 2689 r10_bio->devs[slot].bio 2684 2690 = IO_BLOCKED; 2685 2691 } ··· 2765 2773 } 2766 2774 } 2767 2775 2768 - static bool narrow_write_error(struct r10bio *r10_bio, int i) 2776 + static void narrow_write_error(struct r10bio *r10_bio, int i) 2769 2777 { 2770 2778 struct bio *bio = r10_bio->master_bio; 2771 2779 struct mddev *mddev = r10_bio->mddev; ··· 2782 2790 * We currently own a reference to the rdev. 2783 2791 */ 2784 2792 2785 - int block_sectors; 2793 + int block_sectors, lbs = bdev_logical_block_size(rdev->bdev) >> 9; 2786 2794 sector_t sector; 2787 2795 int sectors; 2788 2796 int sect_to_write = r10_bio->sectors; 2789 - bool ok = true; 2790 2797 2791 2798 if (rdev->badblocks.shift < 0) 2792 - return false; 2799 + block_sectors = lbs; 2800 + else 2801 + block_sectors = roundup(1 << rdev->badblocks.shift, lbs); 2793 2802 2794 - block_sectors = roundup(1 << rdev->badblocks.shift, 2795 - bdev_logical_block_size(rdev->bdev) >> 9); 2796 2803 sector = r10_bio->sector; 2797 2804 sectors = ((r10_bio->sector + block_sectors) 2798 2805 & ~(sector_t)(block_sectors - 1)) ··· 2811 2820 choose_data_offset(r10_bio, rdev); 2812 2821 wbio->bi_opf = REQ_OP_WRITE; 2813 2822 2814 - if (submit_bio_wait(wbio) < 0) 2815 - /* Failure! */ 2816 - ok = rdev_set_badblocks(rdev, wsector, 2817 - sectors, 0) 2818 - && ok; 2823 + if (submit_bio_wait(wbio) && 2824 + !rdev_set_badblocks(rdev, wsector, sectors, 0)) { 2825 + /* 2826 + * Badblocks set failed, disk marked Faulty. 2827 + * No further operations needed. 2828 + */ 2829 + bio_put(wbio); 2830 + break; 2831 + } 2819 2832 2820 2833 bio_put(wbio); 2821 2834 sect_to_write -= sectors; 2822 2835 sector += sectors; 2823 2836 sectors = block_sectors; 2824 2837 } 2825 - return ok; 2826 2838 } 2827 2839 2828 2840 static void handle_read_error(struct mddev *mddev, struct r10bio *r10_bio) ··· 2885 2891 if (r10_bio->devs[m].bio == NULL || 2886 2892 r10_bio->devs[m].bio->bi_end_io == NULL) 2887 2893 continue; 2888 - if (!r10_bio->devs[m].bio->bi_status) { 2894 + if (!r10_bio->devs[m].bio->bi_status) 2889 2895 rdev_clear_badblocks( 2890 2896 rdev, 2891 2897 r10_bio->devs[m].addr, 2892 2898 r10_bio->sectors, 0); 2893 - } else { 2894 - if (!rdev_set_badblocks( 2895 - rdev, 2896 - r10_bio->devs[m].addr, 2897 - r10_bio->sectors, 0)) 2898 - md_error(conf->mddev, rdev); 2899 - } 2899 + else 2900 + rdev_set_badblocks(rdev, 2901 + r10_bio->devs[m].addr, 2902 + r10_bio->sectors, 0); 2900 2903 rdev = conf->mirrors[dev].replacement; 2901 2904 if (r10_bio->devs[m].repl_bio == NULL || 2902 2905 r10_bio->devs[m].repl_bio->bi_end_io == NULL) 2903 2906 continue; 2904 2907 2905 - if (!r10_bio->devs[m].repl_bio->bi_status) { 2908 + if (!r10_bio->devs[m].repl_bio->bi_status) 2906 2909 rdev_clear_badblocks( 2907 2910 rdev, 2908 2911 r10_bio->devs[m].addr, 2909 2912 r10_bio->sectors, 0); 2910 - } else { 2911 - if (!rdev_set_badblocks( 2912 - rdev, 2913 - r10_bio->devs[m].addr, 2914 - r10_bio->sectors, 0)) 2915 - md_error(conf->mddev, rdev); 2916 - } 2913 + else 2914 + rdev_set_badblocks(rdev, 2915 + r10_bio->devs[m].addr, 2916 + r10_bio->sectors, 0); 2917 2917 } 2918 2918 put_buf(r10_bio); 2919 2919 } else { ··· 2924 2936 rdev_dec_pending(rdev, conf->mddev); 2925 2937 } else if (bio != NULL && bio->bi_status) { 2926 2938 fail = true; 2927 - if (!narrow_write_error(r10_bio, m)) 2928 - md_error(conf->mddev, rdev); 2939 + narrow_write_error(r10_bio, m); 2929 2940 rdev_dec_pending(rdev, conf->mddev); 2930 2941 } 2931 2942 bio = r10_bio->devs[m].repl_bio; ··· 3155 3168 int i; 3156 3169 int max_sync; 3157 3170 sector_t sync_blocks; 3158 - sector_t sectors_skipped = 0; 3159 - int chunks_skipped = 0; 3160 3171 sector_t chunk_mask = conf->geo.chunk_mask; 3161 3172 int page_idx = 0; 3162 - int error_disk = -1; 3163 3173 3164 3174 /* 3165 3175 * Allow skipping a full rebuild for incremental assembly ··· 3177 3193 if (init_resync(conf)) 3178 3194 return 0; 3179 3195 3180 - skipped: 3181 3196 if (sector_nr >= max_sector) { 3182 3197 conf->cluster_sync_low = 0; 3183 3198 conf->cluster_sync_high = 0; ··· 3228 3245 mddev->bitmap_ops->close_sync(mddev); 3229 3246 close_sync(conf); 3230 3247 *skipped = 1; 3231 - return sectors_skipped; 3248 + return 0; 3232 3249 } 3233 3250 3234 3251 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) 3235 3252 return reshape_request(mddev, sector_nr, skipped); 3236 - 3237 - if (chunks_skipped >= conf->geo.raid_disks) { 3238 - pr_err("md/raid10:%s: %s fails\n", mdname(mddev), 3239 - test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ? "resync" : "recovery"); 3240 - if (error_disk >= 0 && 3241 - !test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) { 3242 - /* 3243 - * recovery fails, set mirrors.recovery_disabled, 3244 - * device shouldn't be added to there. 3245 - */ 3246 - conf->mirrors[error_disk].recovery_disabled = 3247 - mddev->recovery_disabled; 3248 - return 0; 3249 - } 3250 - /* 3251 - * if there has been nothing to do on any drive, 3252 - * then there is nothing to do at all. 3253 - */ 3254 - *skipped = 1; 3255 - return (max_sector - sector_nr) + sectors_skipped; 3256 - } 3257 3253 3258 3254 if (max_sector > mddev->resync_max) 3259 3255 max_sector = mddev->resync_max; /* Don't do IO beyond here */ ··· 3316 3354 /* yep, skip the sync_blocks here, but don't assume 3317 3355 * that there will never be anything to do here 3318 3356 */ 3319 - chunks_skipped = -1; 3320 3357 continue; 3321 3358 } 3322 3359 if (mrdev) ··· 3363 3402 !test_bit(In_sync, &rdev->flags)) 3364 3403 continue; 3365 3404 /* This is where we read from */ 3366 - any_working = 1; 3367 3405 sector = r10_bio->devs[j].addr; 3368 3406 3369 3407 if (is_badblock(rdev, sector, max_sync, ··· 3377 3417 continue; 3378 3418 } 3379 3419 } 3420 + any_working = 1; 3380 3421 bio = r10_bio->devs[0].bio; 3381 3422 bio->bi_next = biolist; 3382 3423 biolist = bio; ··· 3446 3485 for (k = 0; k < conf->copies; k++) 3447 3486 if (r10_bio->devs[k].devnum == i) 3448 3487 break; 3449 - if (mrdev && !test_bit(In_sync, 3450 - &mrdev->flags) 3451 - && !rdev_set_badblocks( 3452 - mrdev, 3453 - r10_bio->devs[k].addr, 3454 - max_sync, 0)) 3455 - any_working = 0; 3456 - if (mreplace && 3457 - !rdev_set_badblocks( 3458 - mreplace, 3459 - r10_bio->devs[k].addr, 3460 - max_sync, 0)) 3461 - any_working = 0; 3462 - } 3463 - if (!any_working) { 3464 - if (!test_and_set_bit(MD_RECOVERY_INTR, 3465 - &mddev->recovery)) 3466 - pr_warn("md/raid10:%s: insufficient working devices for recovery.\n", 3467 - mdname(mddev)); 3468 - mirror->recovery_disabled 3469 - = mddev->recovery_disabled; 3470 - } else { 3471 - error_disk = i; 3488 + if (mrdev && 3489 + !test_bit(In_sync, &mrdev->flags)) 3490 + rdev_set_badblocks( 3491 + mrdev, 3492 + r10_bio->devs[k].addr, 3493 + max_sync, 0); 3494 + if (mreplace) 3495 + rdev_set_badblocks( 3496 + mreplace, 3497 + r10_bio->devs[k].addr, 3498 + max_sync, 0); 3499 + pr_warn("md/raid10:%s: cannot recovery sector %llu + %d.\n", 3500 + mdname(mddev), r10_bio->devs[k].addr, max_sync); 3472 3501 } 3473 3502 put_buf(r10_bio); 3474 3503 if (rb2) ··· 3499 3548 rb2->master_bio = NULL; 3500 3549 put_buf(rb2); 3501 3550 } 3502 - goto giveup; 3551 + *skipped = 1; 3552 + return max_sync; 3503 3553 } 3504 3554 } else { 3505 3555 /* resync. Schedule a read for every block at this virt offset */ ··· 3524 3572 &mddev->recovery)) { 3525 3573 /* We can skip this block */ 3526 3574 *skipped = 1; 3527 - return sync_blocks + sectors_skipped; 3575 + return sync_blocks; 3528 3576 } 3529 3577 if (sync_blocks < max_sync) 3530 3578 max_sync = sync_blocks; ··· 3616 3664 mddev); 3617 3665 } 3618 3666 put_buf(r10_bio); 3619 - biolist = NULL; 3620 - goto giveup; 3667 + *skipped = 1; 3668 + return max_sync; 3621 3669 } 3622 3670 } 3623 3671 ··· 3637 3685 if (WARN_ON(!bio_add_page(bio, page, len, 0))) { 3638 3686 bio->bi_status = BLK_STS_RESOURCE; 3639 3687 bio_endio(bio); 3640 - goto giveup; 3688 + *skipped = 1; 3689 + return max_sync; 3641 3690 } 3642 3691 } 3643 3692 nr_sectors += len>>9; ··· 3706 3753 } 3707 3754 } 3708 3755 3709 - if (sectors_skipped) 3710 - /* pretend they weren't skipped, it makes 3711 - * no important difference in this case 3712 - */ 3713 - md_done_sync(mddev, sectors_skipped, 1); 3714 - 3715 - return sectors_skipped + nr_sectors; 3716 - giveup: 3717 - /* There is nowhere to write, so all non-sync 3718 - * drives must be failed or in resync, all drives 3719 - * have a bad block, so try the next chunk... 3720 - */ 3721 - if (sector_nr + max_sync < max_sector) 3722 - max_sector = sector_nr + max_sync; 3723 - 3724 - sectors_skipped += (max_sector - sector_nr); 3725 - chunks_skipped ++; 3726 - sector_nr = max_sector; 3727 - goto skipped; 3756 + return nr_sectors; 3728 3757 } 3729 3758 3730 3759 static sector_t ··· 4069 4134 disk->replacement->saved_raid_disk < 0) { 4070 4135 conf->fullsync = 1; 4071 4136 } 4072 - 4073 - disk->recovery_disabled = mddev->recovery_disabled - 1; 4074 4137 } 4075 4138 4076 4139 if (mddev->resync_offset != MaxSector) ··· 4846 4913 if (!test_bit(R10BIO_Uptodate, &r10_bio->state)) 4847 4914 if (handle_reshape_read_error(mddev, r10_bio) < 0) { 4848 4915 /* Reshape has been aborted */ 4849 - md_done_sync(mddev, r10_bio->sectors, 0); 4916 + md_done_sync(mddev, r10_bio->sectors); 4917 + md_sync_error(mddev); 4850 4918 return; 4851 4919 } 4852 4920 ··· 5005 5071 { 5006 5072 if (!atomic_dec_and_test(&r10_bio->remaining)) 5007 5073 return; 5008 - md_done_sync(r10_bio->mddev, r10_bio->sectors, 1); 5074 + md_done_sync(r10_bio->mddev, r10_bio->sectors); 5009 5075 bio_put(r10_bio->master_bio); 5010 5076 put_buf(r10_bio); 5011 5077 }

-5

drivers/md/raid10.h

··· 18 18 struct raid10_info { 19 19 struct md_rdev *rdev, *replacement; 20 20 sector_t head_position; 21 - int recovery_disabled; /* matches 22 - * mddev->recovery_disabled 23 - * when we shouldn't try 24 - * recovering this device. 25 - */ 26 21 }; 27 22 28 23 struct r10conf {

+89 -54

drivers/md/raid5.c

··· 56 56 #include "md-bitmap.h" 57 57 #include "raid5-log.h" 58 58 59 - #define UNSUPPORTED_MDDEV_FLAGS (1L << MD_FAILFAST_SUPPORTED) 59 + #define UNSUPPORTED_MDDEV_FLAGS \ 60 + ((1L << MD_FAILFAST_SUPPORTED) | \ 61 + (1L << MD_FAILLAST_DEV) | \ 62 + (1L << MD_SERIALIZE_POLICY)) 63 + 60 64 61 65 #define cpu_to_group(cpu) cpu_to_node(cpu) 62 66 #define ANY_GROUP NUMA_NO_NODE ··· 777 773 /* last sector in the request */ 778 774 sector_t last_sector; 779 775 776 + /* the request had REQ_PREFLUSH, cleared after the first stripe_head */ 777 + bool do_flush; 778 + 780 779 /* 781 780 * bitmap to track stripe sectors that have been added to stripes 782 781 * add one to account for unaligned requests 783 782 */ 784 - DECLARE_BITMAP(sectors_to_do, RAID5_MAX_REQ_STRIPES + 1); 785 - 786 - /* the request had REQ_PREFLUSH, cleared after the first stripe_head */ 787 - bool do_flush; 783 + unsigned long sectors_to_do[]; 788 784 }; 789 785 790 786 /* ··· 2821 2817 else { 2822 2818 clear_bit(R5_ReadError, &sh->dev[i].flags); 2823 2819 clear_bit(R5_ReWrite, &sh->dev[i].flags); 2824 - if (!(set_bad 2825 - && test_bit(In_sync, &rdev->flags) 2826 - && rdev_set_badblocks( 2827 - rdev, sh->sector, RAID5_STRIPE_SECTORS(conf), 0))) 2828 - md_error(conf->mddev, rdev); 2820 + if (!(set_bad && test_bit(In_sync, &rdev->flags))) 2821 + rdev_set_badblocks(rdev, sh->sector, 2822 + RAID5_STRIPE_SECTORS(conf), 0); 2829 2823 } 2830 2824 } 2831 2825 rdev_dec_pending(rdev, conf->mddev); ··· 2922 2920 2923 2921 if (has_failed(conf)) { 2924 2922 set_bit(MD_BROKEN, &conf->mddev->flags); 2925 - conf->recovery_disabled = mddev->recovery_disabled; 2926 2923 2927 2924 pr_crit("md/raid:%s: Cannot continue operation (%d/%d failed).\n", 2928 2925 mdname(mddev), mddev->degraded, conf->raid_disks); ··· 3600 3599 else 3601 3600 rdev = NULL; 3602 3601 if (rdev) { 3603 - if (!rdev_set_badblocks( 3604 - rdev, 3605 - sh->sector, 3606 - RAID5_STRIPE_SECTORS(conf), 0)) 3607 - md_error(conf->mddev, rdev); 3602 + rdev_set_badblocks(rdev, 3603 + sh->sector, 3604 + RAID5_STRIPE_SECTORS(conf), 3605 + 0); 3608 3606 rdev_dec_pending(rdev, conf->mddev); 3609 3607 } 3610 3608 } ··· 3723 3723 RAID5_STRIPE_SECTORS(conf), 0)) 3724 3724 abort = 1; 3725 3725 } 3726 - if (abort) 3727 - conf->recovery_disabled = 3728 - conf->mddev->recovery_disabled; 3729 3726 } 3730 - md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf), !abort); 3727 + md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf)); 3728 + 3729 + if (abort) 3730 + md_sync_error(conf->mddev); 3731 3731 } 3732 3732 3733 3733 static int want_replace(struct stripe_head *sh, int disk_idx) ··· 3751 3751 struct r5dev *dev = &sh->dev[disk_idx]; 3752 3752 struct r5dev *fdev[2] = { &sh->dev[s->failed_num[0]], 3753 3753 &sh->dev[s->failed_num[1]] }; 3754 + struct mddev *mddev = sh->raid_conf->mddev; 3755 + bool force_rcw = false; 3754 3756 int i; 3755 - bool force_rcw = (sh->raid_conf->rmw_level == PARITY_DISABLE_RMW); 3756 3757 3758 + if (sh->raid_conf->rmw_level == PARITY_DISABLE_RMW || 3759 + (mddev->bitmap_ops && mddev->bitmap_ops->blocks_synced && 3760 + !mddev->bitmap_ops->blocks_synced(mddev, sh->sector))) 3761 + force_rcw = true; 3757 3762 3758 3763 if (test_bit(R5_LOCKED, &dev->flags) || 3759 3764 test_bit(R5_UPTODATE, &dev->flags)) ··· 5162 5157 if ((s.syncing || s.replacing) && s.locked == 0 && 5163 5158 !test_bit(STRIPE_COMPUTE_RUN, &sh->state) && 5164 5159 test_bit(STRIPE_INSYNC, &sh->state)) { 5165 - md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf), 1); 5160 + md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf)); 5166 5161 clear_bit(STRIPE_SYNCING, &sh->state); 5167 5162 if (test_and_clear_bit(R5_Overlap, &sh->dev[sh->pd_idx].flags)) 5168 5163 wake_up_bit(&sh->dev[sh->pd_idx].flags, R5_Overlap); ··· 5229 5224 clear_bit(STRIPE_EXPAND_READY, &sh->state); 5230 5225 atomic_dec(&conf->reshape_stripes); 5231 5226 wake_up(&conf->wait_for_reshape); 5232 - md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf), 1); 5227 + md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf)); 5233 5228 } 5234 5229 5235 5230 if (s.expanding && s.locked == 0 && ··· 5258 5253 if (test_and_clear_bit(R5_WriteError, &dev->flags)) { 5259 5254 /* We own a safe reference to the rdev */ 5260 5255 rdev = conf->disks[i].rdev; 5261 - if (!rdev_set_badblocks(rdev, sh->sector, 5262 - RAID5_STRIPE_SECTORS(conf), 0)) 5263 - md_error(conf->mddev, rdev); 5256 + rdev_set_badblocks(rdev, sh->sector, 5257 + RAID5_STRIPE_SECTORS(conf), 0); 5264 5258 rdev_dec_pending(rdev, conf->mddev); 5265 5259 } 5266 5260 if (test_and_clear_bit(R5_MadeGood, &dev->flags)) { ··· 6084 6080 static bool raid5_make_request(struct mddev *mddev, struct bio * bi) 6085 6081 { 6086 6082 DEFINE_WAIT_FUNC(wait, woken_wake_function); 6087 - bool on_wq; 6088 6083 struct r5conf *conf = mddev->private; 6089 - sector_t logical_sector; 6090 - struct stripe_request_ctx ctx = {}; 6091 6084 const int rw = bio_data_dir(bi); 6085 + struct stripe_request_ctx *ctx; 6086 + sector_t logical_sector; 6092 6087 enum stripe_result res; 6093 6088 int s, stripe_cnt; 6089 + bool on_wq; 6094 6090 6095 6091 if (unlikely(bi->bi_opf & REQ_PREFLUSH)) { 6096 6092 int ret = log_handle_flush_request(conf, bi); ··· 6102 6098 return true; 6103 6099 } 6104 6100 /* ret == -EAGAIN, fallback */ 6105 - /* 6106 - * if r5l_handle_flush_request() didn't clear REQ_PREFLUSH, 6107 - * we need to flush journal device 6108 - */ 6109 - ctx.do_flush = bi->bi_opf & REQ_PREFLUSH; 6110 6101 } 6111 6102 6112 6103 md_write_start(mddev, bi); ··· 6124 6125 } 6125 6126 6126 6127 logical_sector = bi->bi_iter.bi_sector & ~((sector_t)RAID5_STRIPE_SECTORS(conf)-1); 6127 - ctx.first_sector = logical_sector; 6128 - ctx.last_sector = bio_end_sector(bi); 6129 6128 bi->bi_next = NULL; 6130 6129 6131 - stripe_cnt = DIV_ROUND_UP_SECTOR_T(ctx.last_sector - logical_sector, 6130 + ctx = mempool_alloc(conf->ctx_pool, GFP_NOIO); 6131 + memset(ctx, 0, conf->ctx_size); 6132 + ctx->first_sector = logical_sector; 6133 + ctx->last_sector = bio_end_sector(bi); 6134 + /* 6135 + * if r5l_handle_flush_request() didn't clear REQ_PREFLUSH, 6136 + * we need to flush journal device 6137 + */ 6138 + if (unlikely(bi->bi_opf & REQ_PREFLUSH)) 6139 + ctx->do_flush = true; 6140 + 6141 + stripe_cnt = DIV_ROUND_UP_SECTOR_T(ctx->last_sector - logical_sector, 6132 6142 RAID5_STRIPE_SECTORS(conf)); 6133 - bitmap_set(ctx.sectors_to_do, 0, stripe_cnt); 6143 + bitmap_set(ctx->sectors_to_do, 0, stripe_cnt); 6134 6144 6135 6145 pr_debug("raid456: %s, logical %llu to %llu\n", __func__, 6136 - bi->bi_iter.bi_sector, ctx.last_sector); 6146 + bi->bi_iter.bi_sector, ctx->last_sector); 6137 6147 6138 6148 /* Bail out if conflicts with reshape and REQ_NOWAIT is set */ 6139 6149 if ((bi->bi_opf & REQ_NOWAIT) && ··· 6150 6142 bio_wouldblock_error(bi); 6151 6143 if (rw == WRITE) 6152 6144 md_write_end(mddev); 6145 + mempool_free(ctx, conf->ctx_pool); 6153 6146 return true; 6154 6147 } 6155 6148 md_account_bio(mddev, &bi); ··· 6169 6160 add_wait_queue(&conf->wait_for_reshape, &wait); 6170 6161 on_wq = true; 6171 6162 } 6172 - s = (logical_sector - ctx.first_sector) >> RAID5_STRIPE_SHIFT(conf); 6163 + s = (logical_sector - ctx->first_sector) >> RAID5_STRIPE_SHIFT(conf); 6173 6164 6174 6165 while (1) { 6175 - res = make_stripe_request(mddev, conf, &ctx, logical_sector, 6166 + res = make_stripe_request(mddev, conf, ctx, logical_sector, 6176 6167 bi); 6177 6168 if (res == STRIPE_FAIL || res == STRIPE_WAIT_RESHAPE) 6178 6169 break; ··· 6189 6180 * raid5_activate_delayed() from making progress 6190 6181 * and thus deadlocking. 6191 6182 */ 6192 - if (ctx.batch_last) { 6193 - raid5_release_stripe(ctx.batch_last); 6194 - ctx.batch_last = NULL; 6183 + if (ctx->batch_last) { 6184 + raid5_release_stripe(ctx->batch_last); 6185 + ctx->batch_last = NULL; 6195 6186 } 6196 6187 6197 6188 wait_woken(&wait, TASK_UNINTERRUPTIBLE, ··· 6199 6190 continue; 6200 6191 } 6201 6192 6202 - s = find_next_bit_wrap(ctx.sectors_to_do, stripe_cnt, s); 6193 + s = find_next_bit_wrap(ctx->sectors_to_do, stripe_cnt, s); 6203 6194 if (s == stripe_cnt) 6204 6195 break; 6205 6196 6206 - logical_sector = ctx.first_sector + 6197 + logical_sector = ctx->first_sector + 6207 6198 (s << RAID5_STRIPE_SHIFT(conf)); 6208 6199 } 6209 6200 if (unlikely(on_wq)) 6210 6201 remove_wait_queue(&conf->wait_for_reshape, &wait); 6211 6202 6212 - if (ctx.batch_last) 6213 - raid5_release_stripe(ctx.batch_last); 6203 + if (ctx->batch_last) 6204 + raid5_release_stripe(ctx->batch_last); 6214 6205 6215 6206 if (rw == WRITE) 6216 6207 md_write_end(mddev); 6208 + 6209 + mempool_free(ctx, conf->ctx_pool); 6217 6210 if (res == STRIPE_WAIT_RESHAPE) { 6218 6211 md_free_cloned_bio(bi); 6219 6212 return false; ··· 7385 7374 bioset_exit(&conf->bio_split); 7386 7375 kfree(conf->stripe_hashtbl); 7387 7376 kfree(conf->pending_data); 7377 + 7378 + mempool_destroy(conf->ctx_pool); 7379 + 7388 7380 kfree(conf); 7389 7381 } 7390 7382 ··· 7550 7536 } 7551 7537 7552 7538 conf->bypass_threshold = BYPASS_THRESHOLD; 7553 - conf->recovery_disabled = mddev->recovery_disabled - 1; 7554 - 7555 7539 conf->raid_disks = mddev->raid_disks; 7556 7540 if (mddev->reshape_position == MaxSector) 7557 7541 conf->previous_raid_disks = mddev->raid_disks; ··· 7741 7729 return 0; 7742 7730 } 7743 7731 7732 + static int raid5_create_ctx_pool(struct r5conf *conf) 7733 + { 7734 + struct stripe_request_ctx *ctx; 7735 + int size; 7736 + 7737 + if (mddev_is_dm(conf->mddev)) 7738 + size = BITS_TO_LONGS(RAID5_MAX_REQ_STRIPES); 7739 + else 7740 + size = BITS_TO_LONGS( 7741 + queue_max_hw_sectors(conf->mddev->gendisk->queue) >> 7742 + RAID5_STRIPE_SHIFT(conf)); 7743 + 7744 + conf->ctx_size = struct_size(ctx, sectors_to_do, size); 7745 + conf->ctx_pool = mempool_create_kmalloc_pool(NR_RAID_BIOS, 7746 + conf->ctx_size); 7747 + 7748 + return conf->ctx_pool ? 0 : -ENOMEM; 7749 + } 7750 + 7744 7751 static int raid5_set_limits(struct mddev *mddev) 7745 7752 { 7746 7753 struct r5conf *conf = mddev->private; ··· 7816 7785 * Limit the max sectors based on this. 7817 7786 */ 7818 7787 lim.max_hw_sectors = RAID5_MAX_REQ_STRIPES << RAID5_STRIPE_SHIFT(conf); 7788 + if ((lim.max_hw_sectors << 9) < lim.io_opt) 7789 + lim.max_hw_sectors = lim.io_opt >> 9; 7819 7790 7820 7791 /* No restrictions on the number of segments in the request */ 7821 7792 lim.max_segments = USHRT_MAX; ··· 8090 8057 goto abort; 8091 8058 } 8092 8059 8093 - if (log_init(conf, journal_dev, raid5_has_ppl(conf))) 8060 + ret = raid5_create_ctx_pool(conf); 8061 + if (ret) 8062 + goto abort; 8063 + 8064 + ret = log_init(conf, journal_dev, raid5_has_ppl(conf)); 8065 + if (ret) 8094 8066 goto abort; 8095 8067 8096 8068 return 0; ··· 8249 8211 * isn't possible. 8250 8212 */ 8251 8213 if (!test_bit(Faulty, &rdev->flags) && 8252 - mddev->recovery_disabled != conf->recovery_disabled && 8253 8214 !has_failed(conf) && 8254 8215 (!p->replacement || p->replacement == rdev) && 8255 8216 number < conf->raid_disks) { ··· 8309 8272 8310 8273 return 0; 8311 8274 } 8312 - if (mddev->recovery_disabled == conf->recovery_disabled) 8313 - return -EBUSY; 8314 8275 8315 8276 if (rdev->saved_raid_disk < 0 && has_failed(conf)) 8316 8277 /* no point adding a device */

+3 -1

drivers/md/raid5.h

··· 640 640 * (fresh device added). 641 641 * Cleared when a sync completes. 642 642 */ 643 - int recovery_disabled; 644 643 /* per cpu variables */ 645 644 struct raid5_percpu __percpu *percpu; 646 645 int scribble_disks; ··· 689 690 struct list_head pending_list; 690 691 int pending_data_cnt; 691 692 struct r5pending_data *next_pending_data; 693 + 694 + mempool_t *ctx_pool; 695 + int ctx_size; 692 696 }; 693 697 694 698 #if PAGE_SIZE == DEFAULT_STRIPE_SIZE

Configure Feed

Configure Feed