From nobody Tue Feb 10 16:21:49 2026 Received: from dggsgout12.his.huawei.com (dggsgout12.his.huawei.com [45.249.212.56]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5B0DA377576; Tue, 3 Feb 2026 06:22:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=45.249.212.56 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770099768; cv=none; b=PLHBRNmvo6hBAV7yiAiK+FefCckFyDwRoJd+qwBiLiGa2itnG21C64QWHAP4bSdGGNNFuIbp6a139qija4bUUojMMkGlNk3esdudbmvxjTQ9muhqEebFpBCuBrpMbyb9WvUQC7Un2TcjC4NF+poXA7S9cTxuSJBf1T0x9lssDck= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770099768; c=relaxed/simple; bh=945YPjqEtw6Qdu9mNIn3/ZX1xBX0kodf4jjD/Kqpxkw=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=ag8ipvgy6OV1d6Kfu6O/BQaX1Pae3YWjT5lRIEnc8X3O6ASL/0cpevVZFlNP57akh4iMYG5EJEVG4GK6o2EX7TeW9j7Q1DdwMoc8CimboYche18UCuJcEwDqqJooYOgzfVFHjPOO7LTHzkxxFLj/c36WUQ46xkIwUF5wxc9APTc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=huaweicloud.com; spf=none smtp.mailfrom=huaweicloud.com; arc=none smtp.client-ip=45.249.212.56 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=huaweicloud.com Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=huaweicloud.com Received: from mail.maildlp.com (unknown [172.19.163.170]) by dggsgout12.his.huawei.com (SkyGuard) with ESMTPS id 4f4tgd4LFnzKHMZG; Tue, 3 Feb 2026 14:22:21 +0800 (CST) Received: from mail02.huawei.com (unknown [10.116.40.128]) by mail.maildlp.com (Postfix) with ESMTP id E321A4056B; Tue, 3 Feb 2026 14:22:42 +0800 (CST) Received: from huaweicloud.com (unknown [10.50.87.129]) by APP4 (Coremail) with SMTP id gCh0CgBHp_cilIFpIQhbGA--.27054S9; Tue, 03 Feb 2026 14:22:42 +0800 (CST) From: Zheng Qixing To: song@kernel.org, yukuai@fnnas.com, linan122@huawei.com Cc: xni@redhat.com, linux-raid@vger.kernel.org, linux-kernel@vger.kernel.org, yi.zhang@huawei.com, yangerkun@huawei.com, houtao1@huawei.com, zhengqixing@huawei.com Subject: [RFC v2 5/5] md/raid1: introduce rectify action to repair badblocks Date: Tue, 3 Feb 2026 14:12:59 +0800 Message-Id: <20260203061259.609206-6-zhengqixing@huaweicloud.com> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20260203061259.609206-1-zhengqixing@huaweicloud.com> References: <20260203061259.609206-1-zhengqixing@huaweicloud.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-CM-TRANSID: gCh0CgBHp_cilIFpIQhbGA--.27054S9 X-Coremail-Antispam: 1UD129KBjvAXoW3ZF1fCry3urWxKF1fJF48Crg_yoW8CrW3uo Z7Cr129F1rJr1furyftwnxtF4fuan8J34Syw1rurZ0kr129w4Ygr4xGrW3Zr1aqrsIgrWU X3sFgr1IyFWfZr48n29KB7ZKAUJUUUU8529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UjIYCTnIWjp_UUUOY7kC6x804xWl14x267AKxVWrJVCq3wAFc2x0x2IEx4CE42xK 8VAvwI8IcIk0rVWrJVCq3wAFIxvE14AKwVWUJVWUGwA2048vs2IY020E87I2jVAFwI0_JF 0E3s1l82xGYIkIc2x26xkF7I0E14v26ryj6s0DM28lY4IEw2IIxxk0rwA2F7IY1VAKz4vE j48ve4kI8wA2z4x0Y4vE2Ix0cI8IcVAFwI0_Ar0_tr1l84ACjcxK6xIIjxv20xvEc7CjxV AFwI0_Gr1j6F4UJwA2z4x0Y4vEx4A2jsIE14v26rxl6s0DM28EF7xvwVC2z280aVCY1x02 67AKxVW0oVCq3wAS0I0E0xvYzxvE52x082IY62kv0487Mc02F40EFcxC0VAKzVAqx4xG6I 80ewAv7VC0I7IYx2IY67AKxVWUAVWUtwAv7VC2z280aVAFwI0_Gr1j6F4UJwAm72CE4IkC 6x0Yz7v_Jr0_Gr1lF7xvr2IYc2Ij64vIr41lFIxGxcIEc7CjxVA2Y2ka0xkIwI1lc7CjxV Aaw2AFwI0_Jw0_GFyl42xK82IYc2Ij64vIr41l4I8I3I0E4IkC6x0Yz7v_Jr0_Gr1lx2Iq xVAqx4xG67AKxVWUJVWUGwC20s026x8GjcxK67AKxVWUGVWUWwC2zVAF1VAY17CE14v26r 1q6r43MIIYrxkI7VAKI48JMIIF0xvE2Ix0cI8IcVAFwI0_JFI_Gr1lIxAIcVC0I7IYx2IY 6xkF7I0E14v26F4j6r4UJwCI42IY6xAIw20EY4v20xvaj40_Jr0_JF4lIxAIcVC2z280aV AFwI0_Jr0_Gr1lIxAIcVC2z280aVCY1x0267AKxVW8JVW8JrUvcSsGvfC2KfnxnUUI43ZE Xa7IU15rc3UUUUU== X-CM-SenderInfo: x2kh0wptl0x03j6k3tpzhluzxrxghudrp/ Content-Type: text/plain; charset="utf-8" From: Zheng Qixing Add support for repairing known badblocks in RAID1. When disks have known badblocks (shown in sysfs bad_blocks), data can be read from other healthy disks in the array and written to repair the badblock areas and clear it in bad_blocks. echo rectify > sync_action can trigger this action. Signed-off-by: Zheng Qixing --- drivers/md/md.c | 71 +++++++++++- drivers/md/md.h | 16 +++ drivers/md/raid1.c | 270 ++++++++++++++++++++++++++++++++++++++++++++- drivers/md/raid1.h | 1 + 4 files changed, 348 insertions(+), 10 deletions(-) diff --git a/drivers/md/md.c b/drivers/md/md.c index aebbdbaa4e0a..9b818fcef666 100644 --- a/drivers/md/md.c +++ b/drivers/md/md.c @@ -74,6 +74,7 @@ static const char *action_name[NR_SYNC_ACTIONS] =3D { [ACTION_RECOVER] =3D "recover", [ACTION_CHECK] =3D "check", [ACTION_REPAIR] =3D "repair", + [ACTION_RECTIFY] =3D "rectify", [ACTION_RESHAPE] =3D "reshape", [ACTION_FROZEN] =3D "frozen", [ACTION_IDLE] =3D "idle", @@ -665,13 +666,47 @@ void mddev_put(struct mddev *mddev) spin_unlock(&all_mddevs_lock); } =20 +static int md_badblocks_precheck(struct mddev *mddev) +{ + struct md_rdev *rdev; + int valid_disks =3D 0; + int ret =3D -EINVAL; + + /* rectify is currently supported only for RAID1 */ + if (mddev->level !=3D 1) { + pr_err("md/raid1:%s requires raid1 array\n", mdname(mddev)); + return -EINVAL; + } + + rdev_for_each(rdev, mddev) { + if (rdev->raid_disk < 0 || + test_bit(Faulty, &rdev->flags)) + continue; + valid_disks++; + } + if (valid_disks >=3D 2) + ret =3D 0; + + return ret; +} + static int handle_requested_sync_action(struct mddev *mddev, enum sync_action action) { + int ret; + if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) return -EBUSY; =20 switch (action) { + case ACTION_RECTIFY: + ret =3D md_badblocks_precheck(mddev); + if (ret) + return ret; + set_bit(MD_RECOVERY_BADBLOCKS_RECTIFY, &mddev->recovery); + set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); + set_bit(MD_RECOVERY_SYNC, &mddev->recovery); + return 0; case ACTION_CHECK: set_bit(MD_RECOVERY_CHECK, &mddev->recovery); fallthrough; @@ -686,6 +721,8 @@ static int handle_requested_sync_action(struct mddev *m= ddev, =20 static enum sync_action get_recovery_sync_action(struct mddev *mddev) { + if (test_bit(MD_RECOVERY_BADBLOCKS_RECTIFY, &mddev->recovery)) + return ACTION_RECTIFY; if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) return ACTION_CHECK; if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) @@ -695,11 +732,16 @@ static enum sync_action get_recovery_sync_action(stru= ct mddev *mddev) =20 static void set_requested_position(struct mddev *mddev, sector_t value) { - mddev->resync_min =3D value; + if (test_bit(MD_RECOVERY_BADBLOCKS_RECTIFY, &mddev->recovery)) + mddev->rectify_min =3D value; + else + mddev->resync_min =3D value; } =20 static sector_t get_requested_position(struct mddev *mddev) { + if (test_bit(MD_RECOVERY_BADBLOCKS_RECTIFY, &mddev->recovery)) + return mddev->rectify_min; return mddev->resync_min; } =20 @@ -820,6 +862,7 @@ int mddev_init(struct mddev *mddev) mddev->reshape_backwards =3D 0; mddev->last_sync_action =3D ACTION_IDLE; mddev->resync_min =3D 0; + mddev->rectify_min =3D 0; mddev->resync_max =3D MaxSector; mddev->level =3D LEVEL_NONE; =20 @@ -5139,7 +5182,10 @@ enum sync_action md_sync_action(struct mddev *mddev) if (test_bit(MD_RECOVERY_RECOVER, &recovery)) return ACTION_RECOVER; =20 - /* MD_RECOVERY_CHECK must be paired with MD_RECOVERY_REQUESTED. */ + /* + * MD_RECOVERY_CHECK / MD_RECOVERY_BADBLOCKS_RECTIFY must be + * paired with MD_RECOVERY_REQUESTED. + */ if (test_bit(MD_RECOVERY_SYNC, &recovery)) return get_recovery_sync_action(mddev); =20 @@ -5304,6 +5350,7 @@ action_store(struct mddev *mddev, const char *page, s= ize_t len) break; case ACTION_RESHAPE: case ACTION_RECOVER: + case ACTION_RECTIFY: case ACTION_CHECK: case ACTION_REPAIR: case ACTION_RESYNC: @@ -5329,6 +5376,7 @@ action_store(struct mddev *mddev, const char *page, s= ize_t len) clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); break; + case ACTION_RECTIFY: case ACTION_CHECK: case ACTION_REPAIR: ret =3D handle_requested_sync_action(mddev, action); @@ -6813,6 +6861,7 @@ static void md_clean(struct mddev *mddev) mddev->raid_disks =3D 0; mddev->resync_offset =3D 0; mddev->resync_min =3D 0; + mddev->rectify_min =3D 0; mddev->resync_max =3D MaxSector; mddev->reshape_position =3D MaxSector; /* we still need mddev->external in export_rdev, do not clear it yet */ @@ -9343,6 +9392,7 @@ static sector_t md_sync_max_sectors(struct mddev *mdd= ev, { switch (action) { case ACTION_RESYNC: + case ACTION_RECTIFY: case ACTION_CHECK: case ACTION_REPAIR: atomic64_set(&mddev->resync_mismatches, 0); @@ -9395,6 +9445,7 @@ static sector_t md_sync_position(struct mddev *mddev,= enum sync_action action) struct md_rdev *rdev; =20 switch (action) { + case ACTION_RECTIFY: case ACTION_CHECK: case ACTION_REPAIR: return get_requested_position(mddev); @@ -10020,6 +10071,7 @@ static bool md_choose_sync_action(struct mddev *mdd= ev, int *spares) clear_bit(MD_RECOVERY_SYNC, &mddev->recovery); clear_bit(MD_RECOVERY_CHECK, &mddev->recovery); clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); + clear_bit(MD_RECOVERY_BADBLOCKS_RECTIFY, &mddev->recovery); =20 /* Start new recovery. */ set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); @@ -10077,10 +10129,14 @@ static void md_start_sync(struct work_struct *ws) if (spares && md_bitmap_enabled(mddev, true)) mddev->bitmap_ops->write_all(mddev); =20 - name =3D test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ? - "reshape" : "resync"; - rcu_assign_pointer(mddev->sync_thread, - md_register_thread(md_do_sync, mddev, name)); + if (!is_badblocks_recovery_requested(mddev) || + !md_badblocks_precheck(mddev)) { + name =3D test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ? + "reshape" : "resync"; + rcu_assign_pointer(mddev->sync_thread, + md_register_thread(md_do_sync, mddev, name)); + } + if (!mddev->sync_thread) { pr_warn("%s: could not start resync thread...\n", mdname(mddev)); @@ -10108,6 +10164,7 @@ static void md_start_sync(struct work_struct *ws) clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); clear_bit(MD_RECOVERY_CHECK, &mddev->recovery); clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery); + clear_bit(MD_RECOVERY_BADBLOCKS_RECTIFY, &mddev->recovery); mddev_unlock(mddev); /* * md_start_sync was triggered by MD_RECOVERY_NEEDED, so we should @@ -10322,6 +10379,7 @@ void md_check_recovery(struct mddev *mddev) clear_bit(MD_RECOVERY_SYNC, &mddev->recovery); clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); clear_bit(MD_RECOVERY_CHECK, &mddev->recovery); + clear_bit(MD_RECOVERY_BADBLOCKS_RECTIFY, &mddev->recovery); wake_up(&resync_wait); } =20 @@ -10372,6 +10430,7 @@ void md_reap_sync_thread(struct mddev *mddev) clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery); clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); clear_bit(MD_RECOVERY_CHECK, &mddev->recovery); + clear_bit(MD_RECOVERY_BADBLOCKS_RECTIFY, &mddev->recovery); clear_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery); /* * We call mddev->cluster_ops->update_size here because sync_size could diff --git a/drivers/md/md.h b/drivers/md/md.h index 14f9db38b7c5..0b9e3487bfed 100644 --- a/drivers/md/md.h +++ b/drivers/md/md.h @@ -102,6 +102,13 @@ enum sync_action { * are inconsistent data, */ ACTION_REPAIR, + /* + * Represent by MD_RECOVERY_SYNC | MD_RECOVERY_REQUESTED | + * MD_RECOVERY_BADBLOCKS_RECTIFY, start when user echo "rectify" + * to sysfs api sync_action, used to repair the badblocks acked + * in bad table; + */ + ACTION_RECTIFY, /* * Represent by MD_RECOVERY_RESHAPE, start when new member disk is added * to the conf, notice that this is different from spares or @@ -528,6 +535,7 @@ struct mddev { sector_t resync_offset; sector_t resync_min; /* user requested sync * starts here */ + sector_t rectify_min; sector_t resync_max; /* resync should pause * when it gets here */ =20 @@ -668,6 +676,8 @@ enum recovery_flags { MD_RESYNCING_REMOTE, /* raid456 lazy initial recover */ MD_RECOVERY_LAZY_RECOVER, + /* try to repair acked badblocks*/ + MD_RECOVERY_BADBLOCKS_RECTIFY, }; =20 enum md_ro_state { @@ -1020,6 +1030,12 @@ static inline void mddev_unlock_and_resume(struct md= dev *mddev) mddev_resume(mddev); } =20 +static inline bool is_badblocks_recovery_requested(struct mddev *mddev) +{ + return test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) && + test_bit(MD_RECOVERY_BADBLOCKS_RECTIFY, &mddev->recovery); +} + struct mdu_array_info_s; struct mdu_disk_info_s; =20 diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c index 00120c86c443..90686a0ff9ca 100644 --- a/drivers/md/raid1.c +++ b/drivers/md/raid1.c @@ -176,7 +176,8 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *d= ata) * If this is a user-requested check/repair, allocate * RESYNC_PAGES for each bio. */ - if (test_bit(MD_RECOVERY_REQUESTED, &conf->mddev->recovery)) + if (test_bit(MD_RECOVERY_REQUESTED, &conf->mddev->recovery) && + !is_badblocks_recovery_requested(conf->mddev)) need_pages =3D conf->raid_disks * 2; else need_pages =3D 1; @@ -2380,6 +2381,260 @@ static void sync_request_write(struct mddev *mddev,= struct r1bio *r1_bio) put_sync_write_buf(r1_bio); } =20 +static void end_rectify_read(struct bio *bio) +{ + struct r1bio *r1_bio =3D get_resync_r1bio(bio); + struct r1conf *conf =3D r1_bio->mddev->private; + struct md_rdev *rdev; + struct bio *next_bio; + bool all_fail =3D true; + int i; + + update_head_pos(r1_bio->read_disk, r1_bio); + + if (!bio->bi_status) { + set_bit(R1BIO_Uptodate, &r1_bio->state); + goto out; + } + + for (i =3D r1_bio->read_disk + 1; i < conf->raid_disks; i++) { + rdev =3D conf->mirrors[i].rdev; + if (!rdev || test_bit(Faulty, &rdev->flags)) + continue; + + next_bio =3D r1_bio->bios[i]; + if (next_bio->bi_end_io =3D=3D end_rectify_read) { + r1_bio->read_disk =3D i; + all_fail =3D false; + break; + } + } + + if (unlikely(all_fail)) { + md_done_sync(r1_bio->mddev, r1_bio->sectors); + md_sync_error(r1_bio->mddev); + put_buf(r1_bio); + return; + } +out: + reschedule_retry(r1_bio); +} + +static void end_rectify_write(struct bio *bio) +{ + struct r1bio *r1_bio =3D get_resync_r1bio(bio); + + if (atomic_dec_and_test(&r1_bio->remaining)) { + /* + * Rectify only attempts to clear acked bad + * blocks, and it does not set bad blocks in + * cases of R1BIO_WriteError. + * Here we reuse R1BIO_MadeGood flag, which + * does not guarantee that all write I/Os + * actually succeeded. + */ + set_bit(R1BIO_MadeGood, &r1_bio->state); + reschedule_retry(r1_bio); + } +} + +static void submit_rectify_read(struct r1bio *r1_bio) +{ + struct bio *bio; + + bio =3D r1_bio->bios[r1_bio->read_disk]; + bio->bi_status =3D 0; + submit_bio_noacct(bio); +} + +static void rectify_request_write(struct mddev *mddev, struct r1bio *r1_bi= o) +{ + struct r1conf *conf =3D mddev->private; + struct bio *wbio =3D NULL; + struct md_rdev *rdev; + int wcnt =3D 0; + int i; + + if (!test_bit(R1BIO_Uptodate, &r1_bio->state)) { + submit_rectify_read(r1_bio); + return; + } + + atomic_set(&r1_bio->remaining, 0); + for (i =3D 0; i < conf->raid_disks; i++) { + rdev =3D conf->mirrors[i].rdev; + if (!rdev || test_bit(Faulty, &rdev->flags)) + continue; + wbio =3D r1_bio->bios[i]; + if (wbio->bi_end_io =3D=3D end_rectify_write) { + atomic_inc(&r1_bio->remaining); + wcnt++; + submit_bio_noacct(wbio); + } + } + + if (unlikely(!wcnt)) { + md_done_sync(r1_bio->mddev, r1_bio->sectors); + put_buf(r1_bio); + } +} + +static void handle_sync_write(struct mddev *mddev, struct r1bio *r1_bio) +{ + if (test_bit(R1BIO_BadBlocksRectify, &r1_bio->state)) + rectify_request_write(mddev, r1_bio); + else + sync_request_write(mddev, r1_bio); +} + +static sector_t get_badblocks_sync_sectors(struct mddev *mddev, sector_t s= ector_nr, + int *skipped, unsigned long *bad_disks) +{ + struct r1conf *conf =3D mddev->private; + sector_t nr_sectors =3D mddev->dev_sectors - sector_nr; + bool all_faulty =3D true; + struct md_rdev *rdev; + bool good =3D false; + int i; + + *skipped =3D 0; + for (i =3D 0; i < conf->raid_disks; i++) { + sector_t first_bad; + sector_t bad_sectors; + + rdev =3D conf->mirrors[i].rdev; + if (!rdev || test_bit(Faulty, &rdev->flags)) + continue; + + all_faulty =3D false; + if (is_badblock(rdev, sector_nr, nr_sectors, &first_bad, &bad_sectors)) { + if (first_bad <=3D sector_nr) { + set_bit(i, bad_disks); + nr_sectors =3D min(nr_sectors, first_bad + bad_sectors - sector_nr); + } else { + good =3D true; + nr_sectors =3D min(nr_sectors, first_bad - sector_nr); + } + } else { + good =3D true; + } + } + + if (all_faulty) { + *skipped =3D 1; + return 0; + } + + if (!good || !bitmap_weight(bad_disks, conf->raid_disks)) + *skipped =3D 1; + + /* make sure nr_sectors won't go across barrier unit boundary */ + return align_to_barrier_unit_end(sector_nr, nr_sectors); +} + +static sector_t get_next_sync_sector(struct mddev *mddev, sector_t sector_= nr, + int *skipped, unsigned long *bad_disks) +{ + sector_t nr_sectors; + + nr_sectors =3D get_badblocks_sync_sectors(mddev, sector_nr, + skipped, bad_disks); + if (!(*skipped) && nr_sectors > RESYNC_PAGES * (PAGE_SIZE >> 9)) + nr_sectors =3D RESYNC_PAGES * (PAGE_SIZE >> 9); + return nr_sectors; +} + +static struct r1bio *raid1_alloc_init_r1buf(struct r1conf *conf); +static struct r1bio *init_sync_badblocks_r1bio(struct mddev *mddev, + sector_t sector_nr, + sector_t nr_sectors, + unsigned long *bad_disks) +{ + struct r1conf *conf =3D mddev->private; + struct r1bio *r1_bio; + struct md_rdev *rdev; + int page_idx =3D 0; + struct bio *bio; + int i; + + r1_bio =3D raid1_alloc_init_r1buf(conf); + r1_bio->mddev =3D mddev; + r1_bio->sector =3D sector_nr; + r1_bio->sectors =3D nr_sectors; + r1_bio->state =3D 0; + r1_bio->read_disk =3D -1; + set_bit(R1BIO_IsSync, &r1_bio->state); + set_bit(R1BIO_BadBlocksRectify, &r1_bio->state); + + for (i =3D 0; i < conf->raid_disks; i++) { + rdev =3D conf->mirrors[i].rdev; + if (!rdev || test_bit(Faulty, &rdev->flags)) + continue; + + if (r1_bio->read_disk < 0 && !test_bit(i, bad_disks)) + r1_bio->read_disk =3D i; + + bio =3D r1_bio->bios[i]; + if (test_bit(i, bad_disks)) { + bio->bi_opf =3D REQ_OP_WRITE; + bio->bi_end_io =3D end_rectify_write; + } else { + bio->bi_opf =3D REQ_OP_READ; + bio->bi_end_io =3D end_rectify_read; + } + + atomic_inc(&rdev->nr_pending); + bio->bi_iter.bi_sector =3D sector_nr + rdev->data_offset; + bio_set_dev(bio, rdev->bdev); + } + + if (unlikely(r1_bio->read_disk < 0)) { + put_buf(r1_bio); + return NULL; + } + + while (nr_sectors > 0 && page_idx < RESYNC_PAGES) { + int len =3D nr_sectors << 9 < PAGE_SIZE ? + nr_sectors << 9 : PAGE_SIZE; + struct resync_pages *rp; + + for (i =3D 0; i < conf->raid_disks; i++) { + bio =3D r1_bio->bios[i]; + rp =3D get_resync_pages(bio); + __bio_add_page(bio, resync_fetch_page(rp, page_idx), len, 0); + } + + nr_sectors -=3D len >> 9; + page_idx++; + } + + return r1_bio; +} + +static sector_t do_sync_badblocks_rectify(struct mddev *mddev, + sector_t sector_nr, int *skipped) +{ + DECLARE_BITMAP(bad_disks, MAX_RAID_DISKS); + struct r1conf *conf =3D mddev->private; + struct r1bio *r1_bio; + sector_t nr_sectors; + + bitmap_zero(bad_disks, MAX_RAID_DISKS); + nr_sectors =3D get_next_sync_sector(mddev, sector_nr, skipped, bad_disks); + if (*skipped) { + lower_barrier(conf, sector_nr); + return nr_sectors; + } + + r1_bio =3D init_sync_badblocks_r1bio(mddev, sector_nr, + nr_sectors, bad_disks); + if (!r1_bio) + return 0; + + submit_rectify_read(r1_bio); + return nr_sectors; +} + /* * This is a kernel thread which: * @@ -2558,13 +2813,16 @@ static void handle_sync_write_finished(struct r1con= f *conf, struct r1bio *r1_bio { int m; int s =3D r1_bio->sectors; + bool is_rectify =3D test_bit(R1BIO_BadBlocksRectify, &r1_bio->state); + for (m =3D 0; m < conf->raid_disks * 2 ; m++) { struct md_rdev *rdev =3D conf->mirrors[m].rdev; struct bio *bio =3D r1_bio->bios[m]; if (bio->bi_end_io =3D=3D NULL) continue; if (!bio->bi_status && - test_bit(R1BIO_MadeGood, &r1_bio->state)) + test_bit(R1BIO_MadeGood, &r1_bio->state) && + (!is_rectify || bio->bi_end_io =3D=3D end_rectify_write)) rdev_clear_badblocks(rdev, r1_bio->sector, s, 0); if (bio->bi_status && test_bit(R1BIO_WriteError, &r1_bio->state)) @@ -2728,7 +2986,7 @@ static void raid1d(struct md_thread *thread) test_bit(R1BIO_WriteError, &r1_bio->state)) handle_sync_write_finished(conf, r1_bio); else - sync_request_write(mddev, r1_bio); + handle_sync_write(mddev, r1_bio); } else if (test_bit(R1BIO_MadeGood, &r1_bio->state) || test_bit(R1BIO_WriteError, &r1_bio->state)) handle_write_finished(conf, r1_bio); @@ -2837,7 +3095,8 @@ static sector_t raid1_sync_request(struct mddev *mdde= v, sector_t sector_nr, /* before building a request, check if we can skip these blocks.. * This call the bitmap_start_sync doesn't actually record anything */ - if (!md_bitmap_start_sync(mddev, sector_nr, &sync_blocks, true) && + if (!is_badblocks_recovery_requested(mddev) && + !md_bitmap_start_sync(mddev, sector_nr, &sync_blocks, true) && !conf->fullsync && !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)= ) { /* We can skip this block, and probably several more */ *skipped =3D 1; @@ -2863,6 +3122,9 @@ static sector_t raid1_sync_request(struct mddev *mdde= v, sector_t sector_nr, if (raise_barrier(conf, sector_nr)) return 0; =20 + if (is_badblocks_recovery_requested(mddev)) + return do_sync_badblocks_rectify(mddev, sector_nr, skipped); + r1_bio =3D raid1_alloc_init_r1buf(conf); =20 /* diff --git a/drivers/md/raid1.h b/drivers/md/raid1.h index c98d43a7ae99..6ca8bf808d69 100644 --- a/drivers/md/raid1.h +++ b/drivers/md/raid1.h @@ -184,6 +184,7 @@ enum r1bio_state { R1BIO_MadeGood, R1BIO_WriteError, R1BIO_FailFast, + R1BIO_BadBlocksRectify, }; =20 static inline int sector_to_idx(sector_t sector) --=20 2.39.2