From nobody Mon Feb 9 19:08:45 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 5B1693783B0; 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=1770099767; cv=none; b=XTo1/gJGBY9Oc7VF1Z2Y+tqW9OmvKOYnnSH0jYvVgfKmT6ixQFMiYnZH8u2MMVwfU6hSXadJ1PV0wnvAqKNC2+mqtF3jzm5RqREAZhEaSh7BV+UC8/tXwCndc7Epjh9T/wrt/krHKFUQDJ6XsqfWRjndqFGnOOTNQtuQzvx/qVc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770099767; c=relaxed/simple; bh=YWTQEVWKxGAi++g7pj6QJGY6kPUUsf8XdiRUDEk4cEE=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Q0YFgKn9S6/aJvCRvictAf8KNBn+OXWC7PmCDMgvaohLb2FQcuDqO0UAst6QO1REohgxgAx8l1yvRJ4CSVhhYus0foyObTG6weefQKj+G3jHpQVyU/u0uR12HKHmUvWzZT5bjgwb68IYREz0S6U7uQcRAlv8fzd1czxXmJ0s2gg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=huaweicloud.com; spf=pass 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=pass smtp.mailfrom=huaweicloud.com Received: from mail.maildlp.com (unknown [172.19.163.198]) by dggsgout12.his.huawei.com (SkyGuard) with ESMTPS id 4f4tgd20VRzKHMYm; 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 9223440577; 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--.27054S5; 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 1/5] md: add helpers for requested sync action Date: Tue, 3 Feb 2026 14:12:55 +0800 Message-Id: <20260203061259.609206-2-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--.27054S5 X-Coremail-Antispam: 1UD129KBjvJXoWxZF4fXr47KFyrZFW5WrWfKrg_yoWrXr13pF WSy3Z8Cr4UZFyfXFW7ta4DZayfZr1IqrZrtrW7W34kJFnxKr4rAF15W3ZrtFZ5ta4kZw45 Xa4UGF47uF13uw7anT9S1TB71UUUUU7qnTZGkaVYY2UrUUUUjbIjqfuFe4nvWSU5nxnvy2 9KBjDU0xBIdaVrnRJUUUPIb4IE77IF4wAFF20E14v26ryj6rWUM7CY07I20VC2zVCF04k2 6cxKx2IYs7xG6rWj6s0DM7CIcVAFz4kK6r1j6r18M28IrcIa0xkI8VA2jI8067AKxVWUGw A2048vs2IY020Ec7CjxVAFwI0_JFI_Gr1l8cAvFVAK0II2c7xJM28CjxkF64kEwVA0rcxS w2x7M28EF7xvwVC0I7IYx2IY67AKxVW7JVWDJwA2z4x0Y4vE2Ix0cI8IcVCY1x0267AKxV W8Jr0_Cr1UM28EF7xvwVC2z280aVAFwI0_GcCE3s1l84ACjcxK6I8E87Iv6xkF7I0E14v2 6rxl6s0DM2AIxVAIcxkEcVAq07x20xvEncxIr21l5I8CrVACY4xI64kE6c02F40Ex7xfMc Ij6xIIjxv20xvE14v26r126r1DMcIj6I8E87Iv67AKxVW8Jr0_Cr1UMcvjeVCFs4IE7xkE bVWUJVW8JwACjcxG0xvY0x0EwIxGrwACI402YVCY1x02628vn2kIc2xKxwCY1x0262kKe7 AKxVWUtVW8ZwCF04k20xvY0x0EwIxGrwCFx2IqxVCFs4IE7xkEbVWUJVW8JwC20s026c02 F40E14v26r1j6r18MI8I3I0E7480Y4vE14v26r106r1rMI8E67AF67kF1VAFwI0_Jw0_GF ylIxkGc2Ij64vIr41lIxAIcVC0I7IYx2IY67AKxVWUJVWUCwCI42IY6xIIjxv20xvEc7Cj xVAFwI0_Gr0_Cr1lIxAIcVCF04k26cxKx2IYs7xG6r1j6r1xMIIF0xvEx4A2jsIE14v26r 1j6r4UMIIF0xvEx4A2jsIEc7CjxVAFwI0_Gr0_Gr1UYxBIdaVFxhVjvjDU0xZFpf9x07UN dbbUUUUU= X-CM-SenderInfo: x2kh0wptl0x03j6k3tpzhluzxrxghudrp/ Content-Type: text/plain; charset="utf-8" From: Zheng Qixing Add helpers for handling requested sync action. No functional change. Signed-off-by: Zheng Qixing --- drivers/md/md.c | 65 ++++++++++++++++++++++++++++++++++--------------- 1 file changed, 46 insertions(+), 19 deletions(-) diff --git a/drivers/md/md.c b/drivers/md/md.c index 5df2220b1bd1..84af578876e2 100644 --- a/drivers/md/md.c +++ b/drivers/md/md.c @@ -665,6 +665,41 @@ void mddev_put(struct mddev *mddev) spin_unlock(&all_mddevs_lock); } =20 +static int handle_requested_sync_action(struct mddev *mddev, + enum sync_action action) +{ + switch (action) { + case ACTION_CHECK: + set_bit(MD_RECOVERY_CHECK, &mddev->recovery); + fallthrough; + case ACTION_REPAIR: + set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); + set_bit(MD_RECOVERY_SYNC, &mddev->recovery); + return 0; + default: + return -EINVAL; + } +} + +static enum sync_action get_recovery_sync_action(struct mddev *mddev) +{ + if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) + return ACTION_CHECK; + if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) + return ACTION_REPAIR; + return ACTION_RESYNC; +} + +static void set_requested_position(struct mddev *mddev, sector_t value) +{ + mddev->resync_min =3D value; +} + +static sector_t get_requested_position(struct mddev *mddev) +{ + return mddev->resync_min; +} + static void md_safemode_timeout(struct timer_list *t); static void md_start_sync(struct work_struct *ws); =20 @@ -5101,17 +5136,9 @@ enum sync_action md_sync_action(struct mddev *mddev) if (test_bit(MD_RECOVERY_RECOVER, &recovery)) return ACTION_RECOVER; =20 - if (test_bit(MD_RECOVERY_SYNC, &recovery)) { - /* - * MD_RECOVERY_CHECK must be paired with - * MD_RECOVERY_REQUESTED. - */ - if (test_bit(MD_RECOVERY_CHECK, &recovery)) - return ACTION_CHECK; - if (test_bit(MD_RECOVERY_REQUESTED, &recovery)) - return ACTION_REPAIR; - return ACTION_RESYNC; - } + /* MD_RECOVERY_CHECK must be paired with MD_RECOVERY_REQUESTED. */ + if (test_bit(MD_RECOVERY_SYNC, &recovery)) + return get_recovery_sync_action(mddev); =20 /* * MD_RECOVERY_NEEDED or MD_RECOVERY_RUNNING is set, however, no @@ -5300,11 +5327,10 @@ action_store(struct mddev *mddev, const char *page,= size_t len) set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); break; case ACTION_CHECK: - set_bit(MD_RECOVERY_CHECK, &mddev->recovery); - fallthrough; case ACTION_REPAIR: - set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); - set_bit(MD_RECOVERY_SYNC, &mddev->recovery); + ret =3D handle_requested_sync_action(mddev, action); + if (ret) + goto out; fallthrough; case ACTION_RESYNC: case ACTION_IDLE: @@ -9370,7 +9396,7 @@ static sector_t md_sync_position(struct mddev *mddev,= enum sync_action action) switch (action) { case ACTION_CHECK: case ACTION_REPAIR: - return mddev->resync_min; + return get_requested_position(mddev); case ACTION_RESYNC: if (!mddev->bitmap) return mddev->resync_offset; @@ -9795,10 +9821,11 @@ void md_do_sync(struct md_thread *thread) if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) { /* We completed so min/max setting can be forgotten if used. */ if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) - mddev->resync_min =3D 0; + set_requested_position(mddev, 0); mddev->resync_max =3D MaxSector; - } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) - mddev->resync_min =3D mddev->curr_resync_completed; + } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) { + set_requested_position(mddev, mddev->curr_resync_completed); + } set_bit(MD_RECOVERY_DONE, &mddev->recovery); mddev->curr_resync =3D MD_RESYNC_NONE; spin_unlock(&mddev->lock); --=20 2.39.2 From nobody Mon Feb 9 19:08:45 2026 Received: from dggsgout11.his.huawei.com (dggsgout11.his.huawei.com [45.249.212.51]) (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 56F51377547; Tue, 3 Feb 2026 06:22:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=45.249.212.51 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770099769; cv=none; b=hcZEx0Paklph2TVUVmKJt3mx2E4VsTA3rtirYyq9NSBxMzUkBEByuCj4qUAWPuvoiG5IA3SbvWySOBhLMEBCZ0oDvbWZOoTr1dD9Q1LaVphYINufKg4Loh8z3kgg0w5uIDg2MbNAoYXM0/QTPjkylz+MkRIRkewSSCuF7wzg3Kk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770099769; c=relaxed/simple; bh=N8cMkYEkZql+f7mnQFaQl25S9gxCUSplDyNWjboiG7k=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=riNKxGK/wtR3j79s7YHeU/kyTPoA+MigFj6+OIWGhwZ/uD6vvIfsplMObS5rEZcvodfXzlvPRGNXRsO/32mEyWWD5OScxYvIZnyqPJZhCaq7yXveSmF+gQwGbi8gGnM/A25jJCg97SA6dCccCivECJLT/+oOs4i5WfxOepuybnc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=huaweicloud.com; spf=pass smtp.mailfrom=huaweicloud.com; arc=none smtp.client-ip=45.249.212.51 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=huaweicloud.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=huaweicloud.com Received: from mail.maildlp.com (unknown [172.19.163.198]) by dggsgout11.his.huawei.com (SkyGuard) with ESMTPS id 4f4tg755FSzYQtxT; Tue, 3 Feb 2026 14:21:55 +0800 (CST) Received: from mail02.huawei.com (unknown [10.116.40.128]) by mail.maildlp.com (Postfix) with ESMTP id A377640574; 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--.27054S6; 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 2/5] md: serialize requested sync actions and clear stale request state Date: Tue, 3 Feb 2026 14:12:56 +0800 Message-Id: <20260203061259.609206-3-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--.27054S6 X-Coremail-Antispam: 1UD129KBjvJXoW7KF48uFW5Wr13WFy5KF4kWFg_yoW8ArW3pa yxJFn0krWrJFWfX348ta4DZ34rXw1j9rZrtrW7uas3JF98Ka1kAFs0gasrXrWkJayrZa1Y vw45GFsrZFy0kw7anT9S1TB71UUUUU7qnTZGkaVYY2UrUUUUjbIjqfuFe4nvWSU5nxnvy2 9KBjDU0xBIdaVrnRJUUUPIb4IE77IF4wAFF20E14v26rWj6s0DM7CY07I20VC2zVCF04k2 6cxKx2IYs7xG6rWj6s0DM7CIcVAFz4kK6r1j6r18M28IrcIa0xkI8VA2jI8067AKxVWUXw A2048vs2IY020Ec7CjxVAFwI0_Gr0_Xr1l8cAvFVAK0II2c7xJM28CjxkF64kEwVA0rcxS w2x7M28EF7xvwVC0I7IYx2IY67AKxVW7JVWDJwA2z4x0Y4vE2Ix0cI8IcVCY1x0267AKxV W8Jr0_Cr1UM28EF7xvwVC2z280aVAFwI0_GcCE3s1l84ACjcxK6I8E87Iv6xkF7I0E14v2 6rxl6s0DM2AIxVAIcxkEcVAq07x20xvEncxIr21l5I8CrVACY4xI64kE6c02F40Ex7xfMc Ij6xIIjxv20xvE14v26r126r1DMcIj6I8E87Iv67AKxVW8Jr0_Cr1UMcvjeVCFs4IE7xkE bVWUJVW8JwACjcxG0xvY0x0EwIxGrwACI402YVCY1x02628vn2kIc2xKxwCY1x0262kKe7 AKxVWUtVW8ZwCF04k20xvY0x0EwIxGrwCFx2IqxVCFs4IE7xkEbVWUJVW8JwC20s026c02 F40E14v26r1j6r18MI8I3I0E7480Y4vE14v26r106r1rMI8E67AF67kF1VAFwI0_Jw0_GF ylIxkGc2Ij64vIr41lIxAIcVC0I7IYx2IY67AKxVWUJVWUCwCI42IY6xIIjxv20xvEc7Cj xVAFwI0_Gr0_Cr1lIxAIcVCF04k26cxKx2IYs7xG6r1j6r1xMIIF0xvEx4A2jsIE14v26r 1j6r4UMIIF0xvEx4A2jsIEc7CjxVAFwI0_Gr0_Gr1UYxBIdaVFxhVjvjDU0xZFpf9x07j0 UDXUUUUU= X-CM-SenderInfo: x2kh0wptl0x03j6k3tpzhluzxrxghudrp/ Content-Type: text/plain; charset="utf-8" From: Zheng Qixing In handle_requested_sync_action(), return -EBUSY when MD_RECOVERY_REQUESTED is already set. This serializes requested sync actions (such as check or repair) and avoids a race window where a second sync request can be issued before MD_RECOVERY_RUNNING is set, resulting in the later request being neither rejected nor executed. Additionally, in md_check_recovery(), clear requested-sync related state bits when no recovery operation is running. This prevents stale request state from persisting in cases where a sync action is queued and 'frozen' is written before MD_RECOVERY_RUNNING is set, which would cause subsequent sync requests to spuriously fail with -EBUSY. Signed-off-by: Zheng Qixing --- drivers/md/md.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/drivers/md/md.c b/drivers/md/md.c index 84af578876e2..7fe02ee21d3e 100644 --- a/drivers/md/md.c +++ b/drivers/md/md.c @@ -668,6 +668,9 @@ void mddev_put(struct mddev *mddev) static int handle_requested_sync_action(struct mddev *mddev, enum sync_action action) { + if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) + return -EBUSY; + switch (action) { case ACTION_CHECK: set_bit(MD_RECOVERY_CHECK, &mddev->recovery); @@ -10318,6 +10321,9 @@ void md_check_recovery(struct mddev *mddev) queue_work(md_misc_wq, &mddev->sync_work); } else { clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery); + clear_bit(MD_RECOVERY_SYNC, &mddev->recovery); + clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); + clear_bit(MD_RECOVERY_CHECK, &mddev->recovery); wake_up(&resync_wait); } =20 --=20 2.39.2 From nobody Mon Feb 9 19:08:45 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 3EA2B3783DB; Tue, 3 Feb 2026 06:22:46 +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=a2hLtzKJN1+jjAyxitLSqFr7L4ujHjOnFwEBmyZuN7AKMCQF2LtDzglNgk8voeFb1l3Vgquh1BBwk1Ml+/CKIoP5udBLL3XTZgievi1o7TxUl8N7VH6DrHScyLfn8wj7Xkj4Ji3+qzcdI78QjbivlLVw4rLdvKSYFNOS5iNbywY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770099768; c=relaxed/simple; bh=zxlIu14Ik1sW76tjkzKObQVlNXq145ag6SjJFl5FFzA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=q4aS5evTczBDWcRmDUNhPpXzBznIIETBKBmo92GmRmby30aRUi/K+ZoHVIhuark71EJpOo8lcMApqR4E1hzwqKfKwREpA5q7q6PN3fCqF7YZEYwccXEGBfSkQ73VqHDic/kYPEQLqIKkUDsicniLWi5ShutWrReyJ4uR9U/EloY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=huaweicloud.com; spf=pass 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=pass smtp.mailfrom=huaweicloud.com Received: from mail.maildlp.com (unknown [172.19.163.198]) by dggsgout12.his.huawei.com (SkyGuard) with ESMTPS id 4f4tgd3F0qzKHMYm; 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 BB0C540573; 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--.27054S7; 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 3/5] md: rename mdstat action "recovery" to "recover" Date: Tue, 3 Feb 2026 14:12:57 +0800 Message-Id: <20260203061259.609206-4-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--.27054S7 X-Coremail-Antispam: 1UD129KBjvJXoW7ArWxGw17JFW3Zw4fCw17ZFb_yoW8WF48pa yfAF90krWkJFyfJ3y5Aa4kuFyrGF1Ut347tF9xu3yfJF1ag3WvkFyq9a1DXryDGry0qan8 Xa4kGr1UAFWYkw7anT9S1TB71UUUUU7qnTZGkaVYY2UrUUUUjbIjqfuFe4nvWSU5nxnvy2 9KBjDU0xBIdaVrnRJUUUPIb4IE77IF4wAFF20E14v26rWj6s0DM7CY07I20VC2zVCF04k2 6cxKx2IYs7xG6rWj6s0DM7CIcVAFz4kK6r1j6r18M28IrcIa0xkI8VA2jI8067AKxVWUWw A2048vs2IY020Ec7CjxVAFwI0_Xr0E3s1l8cAvFVAK0II2c7xJM28CjxkF64kEwVA0rcxS w2x7M28EF7xvwVC0I7IYx2IY67AKxVW7JVWDJwA2z4x0Y4vE2Ix0cI8IcVCY1x0267AKxV W8Jr0_Cr1UM28EF7xvwVC2z280aVAFwI0_GcCE3s1l84ACjcxK6I8E87Iv6xkF7I0E14v2 6rxl6s0DM2AIxVAIcxkEcVAq07x20xvEncxIr21l5I8CrVACY4xI64kE6c02F40Ex7xfMc Ij6xIIjxv20xvE14v26r126r1DMcIj6I8E87Iv67AKxVW8Jr0_Cr1UMcvjeVCFs4IE7xkE bVWUJVW8JwACjcxG0xvY0x0EwIxGrwACI402YVCY1x02628vn2kIc2xKxwCY1x0262kKe7 AKxVWUtVW8ZwCF04k20xvY0x0EwIxGrwCFx2IqxVCFs4IE7xkEbVWUJVW8JwC20s026c02 F40E14v26r1j6r18MI8I3I0E7480Y4vE14v26r106r1rMI8E67AF67kF1VAFwI0_Jw0_GF ylIxkGc2Ij64vIr41lIxAIcVC0I7IYx2IY67AKxVWUJVWUCwCI42IY6xIIjxv20xvEc7Cj xVAFwI0_Gr0_Cr1lIxAIcVCF04k26cxKx2IYs7xG6r1j6r1xMIIF0xvEx4A2jsIE14v26r 1j6r4UMIIF0xvEx4A2jsIEc7CjxVAFwI0_Gr0_Gr1UYxBIdaVFxhVjvjDU0xZFpf9x07UJ fHUUUUUU= X-CM-SenderInfo: x2kh0wptl0x03j6k3tpzhluzxrxghudrp/ Content-Type: text/plain; charset="utf-8" From: Zheng Qixing Simplify the code in status_resync() that prints the progress of sync actions. Also rename the /proc/mdstat action from "recovery" to "recover" to match the naming used by action_store() and action_show(). Note: The md-raid-utilities/mdadm test suite will need to be updated to expect "recover" instead of "recovery" in /proc/mdstat. Signed-off-by: Zheng Qixing --- drivers/md/md.c | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/drivers/md/md.c b/drivers/md/md.c index 7fe02ee21d3e..f319621c6832 100644 --- a/drivers/md/md.c +++ b/drivers/md/md.c @@ -8669,6 +8669,7 @@ static int status_resync(struct seq_file *seq, struct= mddev *mddev) sector_t rt, curr_mark_cnt, resync_mark_cnt; int scale, recovery_active; unsigned int per_milli; + enum sync_action action; =20 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) || test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) @@ -8750,13 +8751,10 @@ static int status_resync(struct seq_file *seq, stru= ct mddev *mddev) seq_printf(seq, "."); seq_printf(seq, "] "); } + + action =3D md_sync_action(mddev); seq_printf(seq, " %s =3D%3u.%u%% (%llu/%llu)", - (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)? - "reshape" : - (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)? - "check" : - (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ? - "resync" : "recovery"))), + md_sync_action_name(action), per_milli/10, per_milli % 10, (unsigned long long) resync/2, (unsigned long long) max_sectors/2); --=20 2.39.2 From nobody Mon Feb 9 19:08:45 2026 Received: from dggsgout11.his.huawei.com (dggsgout11.his.huawei.com [45.249.212.51]) (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 933FC3783DA; Tue, 3 Feb 2026 06:22:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=45.249.212.51 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770099768; cv=none; b=L7k5Sl5Aw3mqKo6mxcV7T+ikf+LHRiRYsYh7xZreFtQgN/u+OQWUJU6HCvRZICQhQOS1fvTVroLxdXPxeFxIcXWwjmRhlSggYwZ8edjO77ENJP8ebSjVAsH+ncoAeWuqid3lcjUm9U83/KtoGObRXwPurX+u4jsKO3QXEgk7oDw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770099768; c=relaxed/simple; bh=+srh8IiFzbZjZLF0lmTKeUvcZo51QNWddbClixoALwA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=CpopkaEIZc5qSL0uXZQUw6oy4uWsiRpHfqtQEPJTl6GDI/DfQ7LSzpPJ2DR1hBs7rYWOyV5Jrpq1RNjLLVKcHRI7un6WYqHgtmwwVkLWBmI+EPzYLBhMpI1ca0OBxeVuQYWskyAGYne5+VXNyqg05/iRTyT+N2AtqvZBprYyIpc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=huaweicloud.com; spf=pass smtp.mailfrom=huaweicloud.com; arc=none smtp.client-ip=45.249.212.51 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=huaweicloud.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=huaweicloud.com Received: from mail.maildlp.com (unknown [172.19.163.177]) by dggsgout11.his.huawei.com (SkyGuard) with ESMTPS id 4f4tg76SS1zYQtxN; Tue, 3 Feb 2026 14:21:55 +0800 (CST) Received: from mail02.huawei.com (unknown [10.116.40.128]) by mail.maildlp.com (Postfix) with ESMTP id D16F540593; 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--.27054S8; 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 4/5] md: introduce MAX_RAID_DISKS macro to replace magic number Date: Tue, 3 Feb 2026 14:12:58 +0800 Message-Id: <20260203061259.609206-5-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--.27054S8 X-Coremail-Antispam: 1UD129KBjvJXoW7CFW5XFWrWF45Jw45WF47CFg_yoW8Zr13pa 9ruFy5Zw1rXr1UKwn7XrykCFy5Zw17GrWUKrWY939avas0yr1UArWDJa98Jr95WFn5AFnr Zrs8WrW5Was2qw7anT9S1TB71UUUUU7qnTZGkaVYY2UrUUUUjbIjqfuFe4nvWSU5nxnvy2 9KBjDU0xBIdaVrnRJUUUPqb4IE77IF4wAFF20E14v26rWj6s0DM7CY07I20VC2zVCF04k2 6cxKx2IYs7xG6rWj6s0DM7CIcVAFz4kK6r1j6r18M28IrcIa0xkI8VA2jI8067AKxVWUAV Cq3wA2048vs2IY020Ec7CjxVAFwI0_Xr0E3s1l8cAvFVAK0II2c7xJM28CjxkF64kEwVA0 rcxSw2x7M28EF7xvwVC0I7IYx2IY67AKxVW7JVWDJwA2z4x0Y4vE2Ix0cI8IcVCY1x0267 AKxVW8Jr0_Cr1UM28EF7xvwVC2z280aVAFwI0_GcCE3s1l84ACjcxK6I8E87Iv6xkF7I0E 14v26rxl6s0DM2AIxVAIcxkEcVAq07x20xvEncxIr21l5I8CrVACY4xI64kE6c02F40Ex7 xfMcIj6xIIjxv20xvE14v26r126r1DMcIj6I8E87Iv67AKxVW8Jr0_Cr1UMcvjeVCFs4IE 7xkEbVWUJVW8JwACjcxG0xvY0x0EwIxGrwACI402YVCY1x02628vn2kIc2xKxwCY1x0262 kKe7AKxVWUtVW8ZwCF04k20xvY0x0EwIxGrwCFx2IqxVCFs4IE7xkEbVWUJVW8JwC20s02 6c02F40E14v26r1j6r18MI8I3I0E7480Y4vE14v26r106r1rMI8E67AF67kF1VAFwI0_Jw 0_GFylIxkGc2Ij64vIr41lIxAIcVC0I7IYx2IY67AKxVWUJVWUCwCI42IY6xIIjxv20xvE c7CjxVAFwI0_Gr0_Cr1lIxAIcVCF04k26cxKx2IYs7xG6r1j6r1xMIIF0xvEx4A2jsIE14 v26r1j6r4UMIIF0xvEx4A2jsIEc7CjxVAFwI0_Gr0_Gr1UYxBIdaVFxhVjvjDU0xZFpf9x 07UX189UUUUU= X-CM-SenderInfo: x2kh0wptl0x03j6k3tpzhluzxrxghudrp/ Content-Type: text/plain; charset="utf-8" From: Zheng Qixing Per-device state is stored as a __le16 dev_roles[] array (2 bytes per device) plus a fixed 256-byte header, still within a 4 KiB superblock. Therefore the theoretical maximum is (4096 - 256) / 2 =3D 1920 entries. Define MAX_RAID_DISKS macro for the maximum number of RAID disks. No functional change. Signed-off-by: Zheng Qixing --- drivers/md/md.c | 4 ++-- drivers/md/md.h | 5 +++++ 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/drivers/md/md.c b/drivers/md/md.c index f319621c6832..aebbdbaa4e0a 100644 --- a/drivers/md/md.c +++ b/drivers/md/md.c @@ -1873,7 +1873,7 @@ static int super_1_load(struct md_rdev *rdev, struct = md_rdev *refdev, int minor_ =20 if (sb->magic !=3D cpu_to_le32(MD_SB_MAGIC) || sb->major_version !=3D cpu_to_le32(1) || - le32_to_cpu(sb->max_dev) > (4096-256)/2 || + le32_to_cpu(sb->max_dev) > MAX_RAID_DISKS || le64_to_cpu(sb->super_offset) !=3D rdev->sb_start || (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) !=3D 0) return -EINVAL; @@ -2050,7 +2050,7 @@ static int super_1_validate(struct mddev *mddev, stru= ct md_rdev *freshest, struc mddev->resync_offset =3D le64_to_cpu(sb->resync_offset); memcpy(mddev->uuid, sb->set_uuid, 16); =20 - mddev->max_disks =3D (4096-256)/2; + mddev->max_disks =3D MAX_RAID_DISKS; =20 if (!mddev->logical_block_size) mddev->logical_block_size =3D le32_to_cpu(sb->logical_block_size); diff --git a/drivers/md/md.h b/drivers/md/md.h index a083f37374d0..14f9db38b7c5 100644 --- a/drivers/md/md.h +++ b/drivers/md/md.h @@ -21,6 +21,11 @@ #include #include =20 +/* + * v1.x superblock occupies one 4 KiB block: 256B header + 2B per device + * in dev_roles[]. + */ +#define MAX_RAID_DISKS ((4096-256)/2) #define MaxSector (~(sector_t)0) =20 enum md_submodule_type { --=20 2.39.2 From nobody Mon Feb 9 19:08:45 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