Lines Matching defs:mddev
198 md_wakeup_thread(conf->mddev->thread);
271 md_wakeup_thread(conf->mddev->thread);
277 md_wakeup_thread(conf->mddev->thread);
359 md_wakeup_thread(conf->mddev->thread);
405 if (unlikely(!conf->mddev->thread) ||
410 md_wakeup_thread(conf->mddev->thread);
748 int degraded = conf->mddev->degraded;
750 if (test_bit(MD_BROKEN, &conf->mddev->flags))
753 if (conf->mddev->reshape_position != MaxSector)
991 md_wakeup_thread(conf->mddev->thread);
1230 if (!conf->mddev->external &&
1231 conf->mddev->sb_flags) {
1236 md_check_recovery(conf->mddev);
1244 md_wait_for_blocked_rdev(rdev, conf->mddev);
1247 rdev_dec_pending(rdev, conf->mddev);
1306 if (conf->mddev->gendisk)
1308 disk_devt(conf->mddev->gendisk),
1353 if (conf->mddev->gendisk)
1355 disk_devt(conf->mddev->gendisk),
2433 if (conf->mddev->gendisk)
2435 "raid%d-%s", conf->level, mdname(conf->mddev));
2438 "raid%d-%p", conf->level, conf->mddev);
2510 mddev_suspend(conf->mddev);
2524 mddev_resume(conf->mddev);
2565 md_allow_write(conf->mddev);
2749 static struct md_rdev *rdev_mdlock_deref(struct mddev *mddev,
2753 lockdep_is_held(&mddev->reconfig_mutex));
2798 mdname(conf->mddev), RAID5_STRIPE_SECTORS(conf),
2826 mdname(conf->mddev),
2829 else if (conf->mddev->degraded >= conf->max_degraded) {
2833 mdname(conf->mddev),
2841 mdname(conf->mddev),
2848 mdname(conf->mddev),
2852 mdname(conf->mddev), rdev->bdev);
2874 md_error(conf->mddev, rdev);
2877 rdev_dec_pending(rdev, conf->mddev);
2922 md_error(conf->mddev, rdev);
2934 &rdev->mddev->recovery);
2947 rdev_dec_pending(rdev, conf->mddev);
2962 static void raid5_error(struct mddev *mddev, struct md_rdev *rdev)
2964 struct r5conf *conf = mddev->private;
2969 mdname(mddev), rdev->bdev);
2974 mddev->degraded = raid5_calc_degraded(conf);
2977 set_bit(MD_BROKEN, &conf->mddev->flags);
2978 conf->recovery_disabled = mddev->recovery_disabled;
2981 mdname(mddev), mddev->degraded, conf->raid_disks);
2984 mdname(mddev), conf->raid_disks - mddev->degraded);
2988 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
2991 set_mask_bits(&mddev->sb_flags, 0,
2993 r5c_update_on_rdev_error(mddev, rdev);
3316 mdname(conf->mddev));
3573 md_write_inc(conf->mddev, bi);
3594 if (conf->mddev->bitmap && firstwrite) {
3609 md_bitmap_startwrite(conf->mddev->bitmap, sh->sector,
3684 md_error(conf->mddev, rdev);
3685 rdev_dec_pending(rdev, conf->mddev);
3706 md_write_end(conf->mddev);
3711 md_bitmap_endwrite(conf->mddev->bitmap, sh->sector,
3727 md_write_end(conf->mddev);
3757 md_bitmap_endwrite(conf->mddev->bitmap, sh->sector,
3769 md_wakeup_thread(conf->mddev->thread);
3792 if (test_bit(MD_RECOVERY_RECOVER, &conf->mddev->recovery)) {
3816 conf->mddev->recovery_disabled;
3818 md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf), !abort);
3832 || rdev->mddev->recovery_cp <= sh->sector))
3925 sh->sector < sh->raid_conf->mddev->recovery_cp)
4105 md_write_end(conf->mddev);
4109 md_bitmap_endwrite(conf->mddev->bitmap, sh->sector,
4166 md_wakeup_thread(conf->mddev->thread);
4193 sector_t recovery_cp = conf->mddev->recovery_cp;
4244 if (conf->mddev->queue)
4245 blk_add_trace_msg(conf->mddev->queue,
4324 if (rcw && conf->mddev->queue)
4325 blk_add_trace_msg(conf->mddev->queue, "raid5 rcw %llu %d %d %d",
4413 atomic64_add(RAID5_STRIPE_SECTORS(conf), &conf->mddev->resync_mismatches);
4414 if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery)) {
4418 "%llu-%llu\n", mdname(conf->mddev),
4540 mdname(conf->mddev),
4578 atomic64_add(RAID5_STRIPE_SECTORS(conf), &conf->mddev->resync_mismatches);
4579 if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery)) {
4583 "%llu-%llu\n", mdname(conf->mddev),
4880 sh->sector >= conf->mddev->recovery_cp ||
4881 test_bit(MD_RECOVERY_REQUESTED, &(conf->mddev->recovery)))
5048 test_bit(MD_SB_CHANGE_PENDING, &conf->mddev->sb_flags)) {
5060 rdev_dec_pending(s.blocked_rdev, conf->mddev);
5248 md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf), 1);
5257 if (s.failed <= conf->max_degraded && !conf->mddev->ro)
5315 md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf), 1);
5325 if (conf->mddev->external)
5327 conf->mddev);
5334 conf->mddev);
5346 md_error(conf->mddev, rdev);
5347 rdev_dec_pending(rdev, conf->mddev);
5353 rdev_dec_pending(rdev, conf->mddev);
5362 rdev_dec_pending(rdev, conf->mddev);
5379 md_wakeup_thread(conf->mddev->thread);
5420 static int in_chunk_boundary(struct mddev *mddev, struct bio *bio)
5422 struct r5conf *conf = mddev->private;
5446 md_wakeup_thread(conf->mddev->thread);
5480 struct mddev *mddev = rdev->mddev;
5481 struct r5conf *conf = mddev->private;
5486 rdev_dec_pending(rdev, conf->mddev);
5500 static int raid5_read_one_chunk(struct mddev *mddev, struct bio *raid_bio)
5502 struct r5conf *conf = mddev->private;
5509 if (!in_chunk_boundary(mddev, raid_bio)) {
5539 rdev_dec_pending(rdev, mddev);
5543 md_account_bio(mddev, &raid_bio);
5547 &mddev->bio_set);
5574 if (mddev->gendisk)
5575 trace_block_bio_remap(align_bio, disk_devt(mddev->gendisk),
5585 static struct bio *chunk_aligned_read(struct mddev *mddev, struct bio *raid_bio)
5589 unsigned chunk_sects = mddev->chunk_sectors;
5593 struct r5conf *conf = mddev->private;
5600 if (!raid5_read_one_chunk(mddev, raid_bio))
5720 struct mddev *mddev = cb->cb.data;
5721 struct r5conf *conf = mddev->private;
5749 if (mddev->queue)
5750 trace_block_unplug(mddev->queue, cnt, !from_schedule);
5754 static void release_stripe_plug(struct mddev *mddev,
5758 raid5_unplug, mddev,
5782 static void make_discard_request(struct mddev *mddev, struct bio *bi)
5784 struct r5conf *conf = mddev->private;
5793 if (mddev->reshape_position != MaxSector)
5847 md_write_inc(mddev, bi);
5851 if (conf->mddev->bitmap) {
5855 md_bitmap_startwrite(mddev->bitmap,
5867 release_stripe_plug(mddev, sh);
5873 static bool ahead_of_reshape(struct mddev *mddev, sector_t sector,
5876 return mddev->reshape_backwards ? sector < reshape_sector :
5880 static bool range_ahead_of_reshape(struct mddev *mddev, sector_t min,
5883 return mddev->reshape_backwards ? max < reshape_sector :
5887 static bool stripe_ahead_of_reshape(struct mddev *mddev, struct r5conf *conf,
5904 if (!range_ahead_of_reshape(mddev, min_sector, max_sector,
5963 static bool reshape_inprogress(struct mddev *mddev)
5965 return test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
5966 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
5967 !test_bit(MD_RECOVERY_DONE, &mddev->recovery) &&
5968 !test_bit(MD_RECOVERY_INTR, &mddev->recovery);
5971 static bool reshape_disabled(struct mddev *mddev)
5973 return is_md_suspended(mddev) || !md_is_rdwr(mddev);
5976 static enum stripe_result make_stripe_request(struct mddev *mddev,
6000 if (ahead_of_reshape(mddev, logical_sector,
6004 if (ahead_of_reshape(mddev, logical_sector,
6031 stripe_ahead_of_reshape(mddev, conf, sh)) {
6056 md_wakeup_thread(mddev->thread);
6082 release_stripe_plug(mddev, sh);
6088 if (ret == STRIPE_SCHEDULE_AND_RETRY && !reshape_inprogress(mddev) &&
6089 reshape_disabled(mddev)) {
6093 mdname(mddev));
6131 static bool raid5_make_request(struct mddev *mddev, struct bio * bi)
6134 struct r5conf *conf = mddev->private;
6147 if (md_flush_request(mddev, bi))
6158 if (!md_write_start(mddev, bi))
6165 if (rw == READ && mddev->degraded == 0 &&
6166 mddev->reshape_position == MaxSector) {
6167 bi = chunk_aligned_read(mddev, bi);
6173 make_discard_request(mddev, bi);
6174 md_write_end(mddev);
6193 !ahead_of_reshape(mddev, logical_sector, conf->reshape_progress) &&
6194 ahead_of_reshape(mddev, logical_sector, conf->reshape_safe)) {
6197 md_write_end(mddev);
6200 md_account_bio(mddev, &bi);
6215 res = make_stripe_request(mddev, conf, &ctx, logical_sector,
6254 md_write_end(mddev);
6259 static sector_t raid5_size(struct mddev *mddev, sector_t sectors, int raid_disks);
6261 static sector_t reshape_request(struct mddev *mddev, sector_t sector_nr, int *skipped)
6272 struct r5conf *conf = mddev->private;
6289 if (mddev->reshape_backwards &&
6290 conf->reshape_progress < raid5_size(mddev, 0, 0)) {
6291 sector_nr = raid5_size(mddev, 0, 0)
6293 } else if (mddev->reshape_backwards &&
6297 } else if (!mddev->reshape_backwards &&
6302 mddev->curr_resync_completed = sector_nr;
6303 sysfs_notify_dirent_safe(mddev->sysfs_completed);
6329 if (mddev->reshape_backwards) {
6347 if (mddev->reshape_backwards) {
6350 BUG_ON((mddev->dev_sectors &
6385 if ((mddev->reshape_backwards
6392 || test_bit(MD_RECOVERY_INTR, &mddev->recovery));
6395 mddev->reshape_position = conf->reshape_progress;
6396 mddev->curr_resync_completed = sector_nr;
6397 if (!mddev->reshape_backwards)
6399 rdev_for_each(rdev, mddev)
6407 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
6408 md_wakeup_thread(mddev->thread);
6409 wait_event(mddev->sb_wait, mddev->sb_flags == 0 ||
6410 test_bit(MD_RECOVERY_INTR, &mddev->recovery));
6411 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
6414 conf->reshape_safe = mddev->reshape_position;
6417 sysfs_notify_dirent_safe(mddev->sysfs_completed);
6439 if (s < raid5_size(mddev, 0, 0)) {
6454 if (mddev->reshape_backwards)
6471 if (last_sector >= mddev->dev_sectors)
6472 last_sector = mddev->dev_sectors - 1;
6495 if (mddev->curr_resync_completed > mddev->resync_max ||
6496 (sector_nr - mddev->curr_resync_completed) * 2
6497 >= mddev->resync_max - mddev->curr_resync_completed) {
6501 || test_bit(MD_RECOVERY_INTR, &mddev->recovery));
6504 mddev->reshape_position = conf->reshape_progress;
6505 mddev->curr_resync_completed = sector_nr;
6506 if (!mddev->reshape_backwards)
6508 rdev_for_each(rdev, mddev)
6515 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
6516 md_wakeup_thread(mddev->thread);
6517 wait_event(mddev->sb_wait,
6518 !test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)
6519 || test_bit(MD_RECOVERY_INTR, &mddev->recovery));
6520 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
6523 conf->reshape_safe = mddev->reshape_position;
6526 sysfs_notify_dirent_safe(mddev->sysfs_completed);
6532 static inline sector_t raid5_sync_request(struct mddev *mddev, sector_t sector_nr,
6535 struct r5conf *conf = mddev->private;
6537 sector_t max_sector = mddev->dev_sectors;
6545 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
6550 if (mddev->curr_resync < max_sector) /* aborted */
6551 md_bitmap_end_sync(mddev->bitmap, mddev->curr_resync,
6555 md_bitmap_close_sync(mddev->bitmap);
6563 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
6564 return reshape_request(mddev, sector_nr, skipped);
6576 if (mddev->degraded >= conf->max_degraded &&
6577 test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
6578 sector_t rv = mddev->dev_sectors - sector_nr;
6582 if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
6584 !md_bitmap_start_sync(mddev->bitmap, sector_nr, &sync_blocks, 1) &&
6593 md_bitmap_cond_end_sync(mddev->bitmap, sector_nr, false);
6617 md_bitmap_start_sync(mddev->bitmap, sector_nr, &sync_blocks, still_degraded);
6745 struct mddev *mddev = conf->mddev;
6766 wait_event_lock_irq(mddev->sb_wait,
6767 !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags),
6793 struct mddev *mddev = thread->mddev;
6794 struct r5conf *conf = mddev->private;
6800 md_check_recovery(mddev);
6819 md_bitmap_unplug(mddev->bitmap);
6842 if (mddev->sb_flags & ~(1 << MD_SB_CHANGE_PENDING)) {
6844 md_check_recovery(mddev);
6855 wait_event_lock_irq(mddev->sb_wait,
6856 !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags),
6883 raid5_show_stripe_cache_size(struct mddev *mddev, char *page)
6887 spin_lock(&mddev->lock);
6888 conf = mddev->private;
6891 spin_unlock(&mddev->lock);
6896 raid5_set_cache_size(struct mddev *mddev, int size)
6899 struct r5conf *conf = mddev->private;
6911 md_allow_write(mddev);
6927 raid5_store_stripe_cache_size(struct mddev *mddev, const char *page, size_t len)
6937 err = mddev_lock(mddev);
6940 conf = mddev->private;
6944 err = raid5_set_cache_size(mddev, new);
6945 mddev_unlock(mddev);
6956 raid5_show_rmw_level(struct mddev *mddev, char *page)
6958 struct r5conf *conf = mddev->private;
6966 raid5_store_rmw_level(struct mddev *mddev, const char *page, size_t len)
6968 struct r5conf *conf = mddev->private;
6998 raid5_show_stripe_size(struct mddev *mddev, char *page)
7003 spin_lock(&mddev->lock);
7004 conf = mddev->private;
7007 spin_unlock(&mddev->lock);
7013 raid5_store_stripe_size(struct mddev *mddev, const char *page, size_t len)
7035 err = mddev_lock(mddev);
7039 conf = mddev->private;
7051 if (mddev->sync_thread ||
7052 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
7053 mddev->reshape_position != MaxSector ||
7054 mddev->sysfs_active) {
7059 mddev_suspend(mddev);
7070 mdname(mddev));
7074 mddev_resume(mddev);
7077 mddev_unlock(mddev);
7093 raid5_show_preread_threshold(struct mddev *mddev, char *page)
7097 spin_lock(&mddev->lock);
7098 conf = mddev->private;
7101 spin_unlock(&mddev->lock);
7106 raid5_store_preread_threshold(struct mddev *mddev, const char *page, size_t len)
7117 err = mddev_lock(mddev);
7120 conf = mddev->private;
7127 mddev_unlock(mddev);
7138 raid5_show_skip_copy(struct mddev *mddev, char *page)
7142 spin_lock(&mddev->lock);
7143 conf = mddev->private;
7146 spin_unlock(&mddev->lock);
7151 raid5_store_skip_copy(struct mddev *mddev, const char *page, size_t len)
7163 err = mddev_lock(mddev);
7166 conf = mddev->private;
7170 struct request_queue *q = mddev->queue;
7172 mddev_suspend(mddev);
7178 mddev_resume(mddev);
7180 mddev_unlock(mddev);
7190 stripe_cache_active_show(struct mddev *mddev, char *page)
7192 struct r5conf *conf = mddev->private;
7203 raid5_show_group_thread_cnt(struct mddev *mddev, char *page)
7207 spin_lock(&mddev->lock);
7208 conf = mddev->private;
7211 spin_unlock(&mddev->lock);
7219 raid5_store_group_thread_cnt(struct mddev *mddev, const char *page, size_t len)
7235 err = mddev_lock(mddev);
7238 conf = mddev->private;
7242 mddev_suspend(mddev);
7260 mddev_resume(mddev);
7262 mddev_unlock(mddev);
7343 raid5_size(struct mddev *mddev, sector_t sectors, int raid_disks)
7345 struct r5conf *conf = mddev->private;
7348 sectors = mddev->dev_sectors;
7490 static struct r5conf *setup_conf(struct mddev *mddev)
7502 if (mddev->new_level != 5
7503 && mddev->new_level != 4
7504 && mddev->new_level != 6) {
7506 mdname(mddev), mddev->new_level);
7509 if ((mddev->new_level == 5
7510 && !algorithm_valid_raid5(mddev->new_layout)) ||
7511 (mddev->new_level == 6
7512 && !algorithm_valid_raid6(mddev->new_layout))) {
7514 mdname(mddev), mddev->new_layout);
7517 if (mddev->new_level == 6 && mddev->raid_disks < 4) {
7519 mdname(mddev), mddev->raid_disks);
7523 if (!mddev->new_chunk_sectors ||
7524 (mddev->new_chunk_sectors << 9) % PAGE_SIZE ||
7525 !is_power_of_2(mddev->new_chunk_sectors)) {
7527 mdname(mddev), mddev->new_chunk_sectors << 9);
7574 rdev_for_each(rdev, mddev) {
7584 conf->recovery_disabled = mddev->recovery_disabled - 1;
7586 conf->raid_disks = mddev->raid_disks;
7587 if (mddev->reshape_position == MaxSector)
7588 conf->previous_raid_disks = mddev->raid_disks;
7590 conf->previous_raid_disks = mddev->raid_disks - mddev->delta_disks;
7608 conf->mddev = mddev;
7637 conf->level = mddev->new_level;
7638 conf->chunk_sectors = mddev->new_chunk_sectors;
7643 pr_debug("raid456: run(%s) called.\n", mdname(mddev));
7646 rdev_for_each(rdev, mddev) {
7665 mdname(mddev), rdev->bdev, raid_disk);
7671 conf->level = mddev->new_level;
7682 conf->algorithm = mddev->new_layout;
7683 conf->reshape_progress = mddev->reshape_position;
7685 conf->prev_chunk_sectors = mddev->chunk_sectors;
7686 conf->prev_algo = mddev->layout;
7693 if (mddev->reshape_position != MaxSector) {
7695 ((mddev->chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4,
7696 ((mddev->new_chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4);
7700 mdname(mddev), conf->min_nr_stripes);
7707 mdname(mddev), memory);
7711 pr_debug("md/raid:%s: allocated %dkB\n", mdname(mddev), memory);
7722 ret = register_shrinker(&conf->shrinker, "md-raid5:%s", mdname(mddev));
7725 mdname(mddev));
7729 sprintf(pers_name, "raid%d", mddev->new_level);
7731 md_register_thread(raid5d, mddev, pers_name));
7734 mdname(mddev));
7775 blk_queue_io_opt(conf->mddev->queue, (conf->chunk_sectors << 9) *
7779 static int raid5_run(struct mddev *mddev)
7790 if (mddev_init_writes_pending(mddev) < 0)
7793 if (mddev->recovery_cp != MaxSector)
7795 mdname(mddev));
7797 rdev_for_each(rdev, mddev) {
7810 } else if (mddev->reshape_backwards &&
7813 else if (!mddev->reshape_backwards &&
7818 if ((test_bit(MD_HAS_JOURNAL, &mddev->flags) || journal_dev) &&
7819 (mddev->bitmap_info.offset || mddev->bitmap_info.file)) {
7821 mdname(mddev));
7825 if (mddev->reshape_position != MaxSector) {
7840 int max_degraded = (mddev->level == 6 ? 2 : 1);
7846 mdname(mddev));
7850 if (mddev->new_level != mddev->level) {
7852 mdname(mddev));
7855 old_disks = mddev->raid_disks - mddev->delta_disks;
7863 here_new = mddev->reshape_position;
7864 chunk_sectors = max(mddev->chunk_sectors, mddev->new_chunk_sectors);
7865 new_data_disks = mddev->raid_disks - max_degraded;
7868 mdname(mddev));
7873 here_old = mddev->reshape_position;
7877 if (mddev->delta_disks == 0) {
7885 if (abs(min_offset_diff) >= mddev->chunk_sectors &&
7886 abs(min_offset_diff) >= mddev->new_chunk_sectors)
7888 else if (mddev->ro == 0) {
7890 mdname(mddev));
7893 } else if (mddev->reshape_backwards
7900 mdname(mddev));
7903 pr_debug("md/raid:%s: reshape will continue\n", mdname(mddev));
7906 BUG_ON(mddev->level != mddev->new_level);
7907 BUG_ON(mddev->layout != mddev->new_layout);
7908 BUG_ON(mddev->chunk_sectors != mddev->new_chunk_sectors);
7909 BUG_ON(mddev->delta_disks != 0);
7912 if (test_bit(MD_HAS_JOURNAL, &mddev->flags) &&
7913 test_bit(MD_HAS_PPL, &mddev->flags)) {
7915 mdname(mddev));
7916 clear_bit(MD_HAS_PPL, &mddev->flags);
7917 clear_bit(MD_HAS_MULTIPLE_PPLS, &mddev->flags);
7920 if (mddev->private == NULL)
7921 conf = setup_conf(mddev);
7923 conf = mddev->private;
7928 if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {
7931 mdname(mddev));
7932 mddev->ro = 1;
7933 set_disk_ro(mddev->gendisk, 1);
7934 } else if (mddev->recovery_cp == MaxSector)
7935 set_bit(MD_JOURNAL_CLEAN, &mddev->flags);
7939 rcu_assign_pointer(mddev->thread, conf->thread);
7941 mddev->private = conf;
7945 rdev = rdev_mdlock_deref(mddev, conf->disks[i].rdev);
7948 rdev = rdev_mdlock_deref(mddev,
7973 if (mddev->major_version == 0 &&
7974 mddev->minor_version > 90)
7996 mddev->degraded = raid5_calc_degraded(conf);
8000 mdname(mddev), mddev->degraded, conf->raid_disks);
8005 mddev->dev_sectors &= ~((sector_t)mddev->chunk_sectors - 1);
8006 mddev->resync_max_sectors = mddev->dev_sectors;
8008 if (mddev->degraded > dirty_parity_disks &&
8009 mddev->recovery_cp != MaxSector) {
8010 if (test_bit(MD_HAS_PPL, &mddev->flags))
8012 mdname(mddev));
8013 else if (mddev->ok_start_degraded)
8015 mdname(mddev));
8018 mdname(mddev));
8024 mdname(mddev), conf->level,
8025 mddev->raid_disks-mddev->degraded, mddev->raid_disks,
8026 mddev->new_layout);
8033 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8034 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8035 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8036 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8037 rcu_assign_pointer(mddev->sync_thread,
8038 md_register_thread(md_do_sync, mddev, "reshape"));
8039 if (!mddev->sync_thread)
8044 if (mddev->to_remove == &raid5_attrs_group)
8045 mddev->to_remove = NULL;
8046 else if (mddev->kobj.sd &&
8047 sysfs_create_group(&mddev->kobj, &raid5_attrs_group))
8049 mdname(mddev));
8050 md_set_array_sectors(mddev, raid5_size(mddev, 0, 0));
8052 if (mddev->queue) {
8060 ((mddev->chunk_sectors << 9) / PAGE_SIZE);
8062 chunk_size = mddev->chunk_sectors << 9;
8063 blk_queue_io_min(mddev->queue, chunk_size);
8065 mddev->queue->limits.raid_partial_stripes_expensive = 1;
8072 mddev->queue->limits.discard_granularity = stripe;
8074 blk_queue_max_write_zeroes_sectors(mddev->queue, 0);
8076 rdev_for_each(rdev, mddev) {
8077 disk_stack_limits(mddev->gendisk, rdev->bdev,
8079 disk_stack_limits(mddev->gendisk, rdev->bdev,
8099 mddev->queue->limits.max_discard_sectors < (stripe >> 9) ||
8100 mddev->queue->limits.discard_granularity < stripe)
8101 blk_queue_max_discard_sectors(mddev->queue, 0);
8107 blk_queue_max_hw_sectors(mddev->queue,
8111 blk_queue_max_segments(mddev->queue, USHRT_MAX);
8119 md_unregister_thread(mddev, &mddev->thread);
8122 mddev->private = NULL;
8123 pr_warn("md/raid:%s: failed to run raid set.\n", mdname(mddev));
8127 static void raid5_free(struct mddev *mddev, void *priv)
8132 mddev->to_remove = &raid5_attrs_group;
8135 static void raid5_status(struct seq_file *seq, struct mddev *mddev)
8137 struct r5conf *conf = mddev->private;
8140 seq_printf(seq, " level %d, %dk chunk, algorithm %d", mddev->level,
8141 conf->chunk_sectors / 2, mddev->layout);
8142 seq_printf (seq, " [%d/%d] [", conf->raid_disks, conf->raid_disks - mddev->degraded);
8164 conf->raid_disks - conf->mddev->degraded);
8177 static int raid5_spare_active(struct mddev *mddev)
8180 struct r5conf *conf = mddev->private;
8186 rdev = rdev_mdlock_deref(mddev, conf->disks[i].rdev);
8187 replacement = rdev_mdlock_deref(mddev,
8216 mddev->degraded = raid5_calc_degraded(conf);
8222 static int raid5_remove_disk(struct mddev *mddev, struct md_rdev *rdev)
8224 struct r5conf *conf = mddev->private;
8270 mddev->recovery_disabled != conf->recovery_disabled &&
8280 lockdep_assert_held(&mddev->reconfig_mutex);
8315 static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)
8317 struct r5conf *conf = mddev->private;
8344 if (mddev->recovery_disabled == conf->recovery_disabled)
8379 tmp = rdev_mdlock_deref(mddev, p->rdev);
8381 mddev->reshape_position == MaxSector &&
8397 static int raid5_resize(struct mddev *mddev, sector_t sectors)
8407 struct r5conf *conf = mddev->private;
8412 newsize = raid5_size(mddev, sectors, mddev->raid_disks);
8413 if (mddev->external_size &&
8414 mddev->array_sectors > newsize)
8416 if (mddev->bitmap) {
8417 int ret = md_bitmap_resize(mddev->bitmap, sectors, 0, 0);
8421 md_set_array_sectors(mddev, newsize);
8422 if (sectors > mddev->dev_sectors &&
8423 mddev->recovery_cp > mddev->dev_sectors) {
8424 mddev->recovery_cp = mddev->dev_sectors;
8425 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8427 mddev->dev_sectors = sectors;
8428 mddev->resync_max_sectors = sectors;
8432 static int check_stripe_cache(struct mddev *mddev)
8442 struct r5conf *conf = mddev->private;
8443 if (((mddev->chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4
8445 ((mddev->new_chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4
8448 mdname(mddev),
8449 ((max(mddev->chunk_sectors, mddev->new_chunk_sectors) << 9)
8456 static int check_reshape(struct mddev *mddev)
8458 struct r5conf *conf = mddev->private;
8462 if (mddev->delta_disks == 0 &&
8463 mddev->new_layout == mddev->layout &&
8464 mddev->new_chunk_sectors == mddev->chunk_sectors)
8468 if (mddev->delta_disks < 0 && mddev->reshape_position == MaxSector) {
8475 if (mddev->level == 6)
8477 if (mddev->raid_disks + mddev->delta_disks < min)
8481 if (!check_stripe_cache(mddev))
8484 if (mddev->new_chunk_sectors > mddev->chunk_sectors ||
8485 mddev->delta_disks > 0)
8488 + max(0, mddev->delta_disks),
8489 max(mddev->new_chunk_sectors,
8490 mddev->chunk_sectors)
8494 if (conf->previous_raid_disks + mddev->delta_disks <= conf->pool_size)
8497 + mddev->delta_disks));
8500 static int raid5_start_reshape(struct mddev *mddev)
8502 struct r5conf *conf = mddev->private;
8508 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
8511 if (!check_stripe_cache(mddev))
8518 if (mddev->recovery_cp < MaxSector)
8521 if (rdev_mdlock_deref(mddev, conf->disks[i].replacement))
8524 rdev_for_each(rdev, mddev) {
8530 if (spares - mddev->degraded < mddev->delta_disks - conf->max_degraded)
8540 if (raid5_size(mddev, 0, conf->raid_disks + mddev->delta_disks)
8541 < mddev->array_sectors) {
8543 mdname(mddev));
8551 conf->raid_disks += mddev->delta_disks;
8553 conf->chunk_sectors = mddev->new_chunk_sectors;
8555 conf->algorithm = mddev->new_layout;
8561 if (mddev->reshape_backwards)
8562 conf->reshape_progress = raid5_size(mddev, 0, 0);
8573 mddev_suspend(mddev);
8574 mddev_resume(mddev);
8583 if (mddev->delta_disks >= 0) {
8584 rdev_for_each(rdev, mddev)
8587 if (raid5_add_disk(mddev, rdev) == 0) {
8595 sysfs_link_rdev(mddev, rdev);
8608 mddev->degraded = raid5_calc_degraded(conf);
8611 mddev->raid_disks = conf->raid_disks;
8612 mddev->reshape_position = conf->reshape_progress;
8613 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
8615 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8616 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8617 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
8618 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8619 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8620 rcu_assign_pointer(mddev->sync_thread,
8621 md_register_thread(md_do_sync, mddev, "reshape"));
8622 if (!mddev->sync_thread) {
8623 mddev->recovery = 0;
8626 mddev->raid_disks = conf->raid_disks = conf->previous_raid_disks;
8627 mddev->new_chunk_sectors =
8629 mddev->new_layout = conf->algorithm = conf->prev_algo;
8630 rdev_for_each(rdev, mddev)
8635 mddev->reshape_position = MaxSector;
8641 md_wakeup_thread(mddev->sync_thread);
8652 if (!test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery)) {
8657 md_finish_reshape(conf->mddev);
8660 conf->mddev->reshape_position = MaxSector;
8661 rdev_for_each(rdev, conf->mddev)
8669 if (conf->mddev->queue)
8677 static void raid5_finish_reshape(struct mddev *mddev)
8679 struct r5conf *conf = mddev->private;
8682 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8684 if (mddev->delta_disks <= 0) {
8687 mddev->degraded = raid5_calc_degraded(conf);
8690 d < conf->raid_disks - mddev->delta_disks;
8692 rdev = rdev_mdlock_deref(mddev,
8696 rdev = rdev_mdlock_deref(mddev,
8702 mddev->layout = conf->algorithm;
8703 mddev->chunk_sectors = conf->chunk_sectors;
8704 mddev->reshape_position = MaxSector;
8705 mddev->delta_disks = 0;
8706 mddev->reshape_backwards = 0;
8710 static void raid5_quiesce(struct mddev *mddev, int quiesce)
8712 struct r5conf *conf = mddev->private;
8745 static void *raid45_takeover_raid0(struct mddev *mddev, int level)
8747 struct r0conf *raid0_conf = mddev->private;
8753 mdname(mddev));
8759 mddev->dev_sectors = sectors;
8760 mddev->new_level = level;
8761 mddev->new_layout = ALGORITHM_PARITY_N;
8762 mddev->new_chunk_sectors = mddev->chunk_sectors;
8763 mddev->raid_disks += 1;
8764 mddev->delta_disks = 1;
8766 mddev->recovery_cp = MaxSector;
8768 return setup_conf(mddev);
8771 static void *raid5_takeover_raid1(struct mddev *mddev)
8776 if (mddev->raid_disks != 2 ||
8777 mddev->degraded > 1)
8785 while (chunksect && (mddev->array_sectors & (chunksect-1)))
8788 if ((chunksect<<9) < RAID5_STRIPE_SIZE((struct r5conf *)mddev->private))
8792 mddev->new_level = 5;
8793 mddev->new_layout = ALGORITHM_LEFT_SYMMETRIC;
8794 mddev->new_chunk_sectors = chunksect;
8796 ret = setup_conf(mddev);
8798 mddev_clear_unsupported_flags(mddev,
8803 static void *raid5_takeover_raid6(struct mddev *mddev)
8807 switch (mddev->layout) {
8829 mddev->new_level = 5;
8830 mddev->new_layout = new_layout;
8831 mddev->delta_disks = -1;
8832 mddev->raid_disks -= 1;
8833 return setup_conf(mddev);
8836 static int raid5_check_reshape(struct mddev *mddev)
8843 struct r5conf *conf = mddev->private;
8844 int new_chunk = mddev->new_chunk_sectors;
8846 if (mddev->new_layout >= 0 && !algorithm_valid_raid5(mddev->new_layout))
8853 if (mddev->array_sectors & (new_chunk-1))
8860 if (mddev->raid_disks == 2) {
8862 if (mddev->new_layout >= 0) {
8863 conf->algorithm = mddev->new_layout;
8864 mddev->layout = mddev->new_layout;
8868 mddev->chunk_sectors = new_chunk;
8870 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
8871 md_wakeup_thread(mddev->thread);
8873 return check_reshape(mddev);
8876 static int raid6_check_reshape(struct mddev *mddev)
8878 int new_chunk = mddev->new_chunk_sectors;
8880 if (mddev->new_layout >= 0 && !algorithm_valid_raid6(mddev->new_layout))
8887 if (mddev->array_sectors & (new_chunk-1))
8893 return check_reshape(mddev);
8896 static void *raid5_takeover(struct mddev *mddev)
8904 if (mddev->level == 0)
8905 return raid45_takeover_raid0(mddev, 5);
8906 if (mddev->level == 1)
8907 return raid5_takeover_raid1(mddev);
8908 if (mddev->level == 4) {
8909 mddev->new_layout = ALGORITHM_PARITY_N;
8910 mddev->new_level = 5;
8911 return setup_conf(mddev);
8913 if (mddev->level == 6)
8914 return raid5_takeover_raid6(mddev);
8919 static void *raid4_takeover(struct mddev *mddev)
8925 if (mddev->level == 0)
8926 return raid45_takeover_raid0(mddev, 4);
8927 if (mddev->level == 5 &&
8928 mddev->layout == ALGORITHM_PARITY_N) {
8929 mddev->new_layout = 0;
8930 mddev->new_level = 4;
8931 return setup_conf(mddev);
8938 static void *raid6_takeover(struct mddev *mddev)
8946 if (mddev->pers != &raid5_personality)
8948 if (mddev->degraded > 1)
8950 if (mddev->raid_disks > 253)
8952 if (mddev->raid_disks < 3)
8955 switch (mddev->layout) {
8977 mddev->new_level = 6;
8978 mddev->new_layout = new_layout;
8979 mddev->delta_disks = 1;
8980 mddev->raid_disks += 1;
8981 return setup_conf(mddev);
8984 static int raid5_change_consistency_policy(struct mddev *mddev, const char *buf)
8989 err = mddev_lock(mddev);
8992 conf = mddev->private;
8994 mddev_unlock(mddev);
9005 mddev_suspend(mddev);
9007 mddev_resume(mddev);
9014 mddev_suspend(mddev);
9016 mddev_resume(mddev);
9018 } else if (test_bit(MD_HAS_JOURNAL, &conf->mddev->flags) &&
9023 rdev_for_each(rdev, mddev)
9030 mddev_suspend(mddev);
9031 clear_bit(MD_HAS_JOURNAL, &mddev->flags);
9032 mddev_resume(mddev);
9042 md_update_sb(mddev, 1);
9044 mddev_unlock(mddev);
9049 static int raid5_start(struct mddev *mddev)
9051 struct r5conf *conf = mddev->private;
9056 static void raid5_prepare_suspend(struct mddev *mddev)
9058 struct r5conf *conf = mddev->private;
9060 wait_event(mddev->sb_wait, !reshape_inprogress(mddev) ||
9061 percpu_ref_is_zero(&mddev->active_io));
9062 if (percpu_ref_is_zero(&mddev->active_io))