| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <8bfafadf-210b-9c3d-a03f-dc4e6f877b43@huaweicloud.com>
Date: Fri, 15 Aug 2025 09:09:57 +0800
From: Yu Kuai <yukuai1@...weicloud.com>
To: Xiao Ni <xni@...hat.com>, linan666@...weicloud.com
Cc: agk@...hat.com, snitzer@...nel.org, mpatocka@...hat.com, song@...nel.org,
dm-devel@...ts.linux.dev, linux-kernel@...r.kernel.org,
linux-raid@...r.kernel.org, yangerkun@...wei.com, yi.zhang@...wei.com,
"yukuai (C)" <yukuai3@...wei.com>
Subject: Re: [PATCH v2 md-6.17] md: rename recovery_cp to resync_offset
Hi,
在 2025/08/14 23:19, Xiao Ni 写道:
> Hi all
>
> mdadm build fails because of this change.
>
> super0.c: In function ‘update_super0’:
> super0.c:672:19: error: ‘mdp_super_t’ {aka ‘struct mdp_superblock_s’}
> has no member named ‘recovery_cp’
> 672 | sb->recovery_cp = 0;
> | ^~
>
> Because we recently handled a similar thing that the kernel change
> breaks userspace. It looks like it needs to modify mdadm too. But if
> users don't update mdadm, it can't build successfully. What's your
> suggestion? Now fedora can't update because of this failure.
> https://kojipkgs.fedoraproject.org//work/tasks/9192/136039192/build.log
>
> Regards
> Xiao
>
I think it's fine to revert the change to mdp_super_t, and keep the
change inside mddev.
Thanks,
Kuai
> On Tue, Jul 22, 2025 at 11:40 AM <linan666@...weicloud.com> wrote:
>>
>> From: Li Nan <linan122@...wei.com>
>>
>> 'recovery_cp' was used to represent the progress of sync, but its name
>> contains recovery, which can cause confusion. Replaces 'recovery_cp'
>> with 'resync_offset' for clarity.
>>
>> Signed-off-by: Li Nan <linan122@...wei.com>
>> ---
>> v2: cook on md-6.17
>>
>> drivers/md/md.h | 2 +-
>> include/uapi/linux/raid/md_p.h | 2 +-
>> drivers/md/dm-raid.c | 42 ++++++++++++++--------------
>> drivers/md/md-bitmap.c | 8 +++---
>> drivers/md/md-cluster.c | 16 +++++------
>> drivers/md/md.c | 50 +++++++++++++++++-----------------
>> drivers/md/raid0.c | 6 ++--
>> drivers/md/raid1-10.c | 2 +-
>> drivers/md/raid1.c | 10 +++----
>> drivers/md/raid10.c | 16 +++++------
>> drivers/md/raid5-ppl.c | 6 ++--
>> drivers/md/raid5.c | 30 ++++++++++----------
>> 12 files changed, 95 insertions(+), 95 deletions(-)
>>
>> diff --git a/drivers/md/md.h b/drivers/md/md.h
>> index b8ff70841fbe..edea7df579c8 100644
>> --- a/drivers/md/md.h
>> +++ b/drivers/md/md.h
>> @@ -524,7 +524,7 @@ struct mddev {
>> unsigned long normal_io_events; /* IO event timestamp */
>> atomic_t recovery_active; /* blocks scheduled, but not written */
>> wait_queue_head_t recovery_wait;
>> - sector_t recovery_cp;
>> + sector_t resync_offset;
>> sector_t resync_min; /* user requested sync
>> * starts here */
>> sector_t resync_max; /* resync should pause
>> diff --git a/include/uapi/linux/raid/md_p.h b/include/uapi/linux/raid/md_p.h
>> index ad1c84e772ba..2963c3dab57e 100644
>> --- a/include/uapi/linux/raid/md_p.h
>> +++ b/include/uapi/linux/raid/md_p.h
>> @@ -173,7 +173,7 @@ typedef struct mdp_superblock_s {
>> #else
>> #error unspecified endianness
>> #endif
>> - __u32 recovery_cp; /* 11 recovery checkpoint sector count */
>> + __u32 resync_offset; /* 11 resync checkpoint sector count */
>> /* There are only valid for minor_version > 90 */
>> __u64 reshape_position; /* 12,13 next address in array-space for reshape */
>> __u32 new_level; /* 14 new level we are reshaping to */
>> diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c
>> index e8c0a8c6fb51..9835f2fe26e9 100644
>> --- a/drivers/md/dm-raid.c
>> +++ b/drivers/md/dm-raid.c
>> @@ -439,7 +439,7 @@ static bool rs_is_reshapable(struct raid_set *rs)
>> /* Return true, if raid set in @rs is recovering */
>> static bool rs_is_recovering(struct raid_set *rs)
>> {
>> - return rs->md.recovery_cp < rs->md.dev_sectors;
>> + return rs->md.resync_offset < rs->md.dev_sectors;
>> }
>>
>> /* Return true, if raid set in @rs is reshaping */
>> @@ -769,7 +769,7 @@ static struct raid_set *raid_set_alloc(struct dm_target *ti, struct raid_type *r
>> rs->md.layout = raid_type->algorithm;
>> rs->md.new_layout = rs->md.layout;
>> rs->md.delta_disks = 0;
>> - rs->md.recovery_cp = MaxSector;
>> + rs->md.resync_offset = MaxSector;
>>
>> for (i = 0; i < raid_devs; i++)
>> md_rdev_init(&rs->dev[i].rdev);
>> @@ -913,7 +913,7 @@ static int parse_dev_params(struct raid_set *rs, struct dm_arg_set *as)
>> rs->md.external = 0;
>> rs->md.persistent = 1;
>> rs->md.major_version = 2;
>> - } else if (rebuild && !rs->md.recovery_cp) {
>> + } else if (rebuild && !rs->md.resync_offset) {
>> /*
>> * Without metadata, we will not be able to tell if the array
>> * is in-sync or not - we must assume it is not. Therefore,
>> @@ -1696,20 +1696,20 @@ static void rs_setup_recovery(struct raid_set *rs, sector_t dev_sectors)
>> {
>> /* raid0 does not recover */
>> if (rs_is_raid0(rs))
>> - rs->md.recovery_cp = MaxSector;
>> + rs->md.resync_offset = MaxSector;
>> /*
>> * A raid6 set has to be recovered either
>> * completely or for the grown part to
>> * ensure proper parity and Q-Syndrome
>> */
>> else if (rs_is_raid6(rs))
>> - rs->md.recovery_cp = dev_sectors;
>> + rs->md.resync_offset = dev_sectors;
>> /*
>> * Other raid set types may skip recovery
>> * depending on the 'nosync' flag.
>> */
>> else
>> - rs->md.recovery_cp = test_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags)
>> + rs->md.resync_offset = test_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags)
>> ? MaxSector : dev_sectors;
>> }
>>
>> @@ -2144,7 +2144,7 @@ static void super_sync(struct mddev *mddev, struct md_rdev *rdev)
>> sb->events = cpu_to_le64(mddev->events);
>>
>> sb->disk_recovery_offset = cpu_to_le64(rdev->recovery_offset);
>> - sb->array_resync_offset = cpu_to_le64(mddev->recovery_cp);
>> + sb->array_resync_offset = cpu_to_le64(mddev->resync_offset);
>>
>> sb->level = cpu_to_le32(mddev->level);
>> sb->layout = cpu_to_le32(mddev->layout);
>> @@ -2335,18 +2335,18 @@ static int super_init_validation(struct raid_set *rs, struct md_rdev *rdev)
>> }
>>
>> if (!test_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags))
>> - mddev->recovery_cp = le64_to_cpu(sb->array_resync_offset);
>> + mddev->resync_offset = le64_to_cpu(sb->array_resync_offset);
>>
>> /*
>> * During load, we set FirstUse if a new superblock was written.
>> * There are two reasons we might not have a superblock:
>> * 1) The raid set is brand new - in which case, all of the
>> * devices must have their In_sync bit set. Also,
>> - * recovery_cp must be 0, unless forced.
>> + * resync_offset must be 0, unless forced.
>> * 2) This is a new device being added to an old raid set
>> * and the new device needs to be rebuilt - in which
>> * case the In_sync bit will /not/ be set and
>> - * recovery_cp must be MaxSector.
>> + * resync_offset must be MaxSector.
>> * 3) This is/are a new device(s) being added to an old
>> * raid set during takeover to a higher raid level
>> * to provide capacity for redundancy or during reshape
>> @@ -2391,8 +2391,8 @@ static int super_init_validation(struct raid_set *rs, struct md_rdev *rdev)
>> new_devs > 1 ? "s" : "");
>> return -EINVAL;
>> } else if (!test_bit(__CTR_FLAG_REBUILD, &rs->ctr_flags) && rs_is_recovering(rs)) {
>> - DMERR("'rebuild' specified while raid set is not in-sync (recovery_cp=%llu)",
>> - (unsigned long long) mddev->recovery_cp);
>> + DMERR("'rebuild' specified while raid set is not in-sync (resync_offset=%llu)",
>> + (unsigned long long) mddev->resync_offset);
>> return -EINVAL;
>> } else if (rs_is_reshaping(rs)) {
>> DMERR("'rebuild' specified while raid set is being reshaped (reshape_position=%llu)",
>> @@ -2697,11 +2697,11 @@ static int rs_adjust_data_offsets(struct raid_set *rs)
>> }
>> out:
>> /*
>> - * Raise recovery_cp in case data_offset != 0 to
>> + * Raise resync_offset in case data_offset != 0 to
>> * avoid false recovery positives in the constructor.
>> */
>> - if (rs->md.recovery_cp < rs->md.dev_sectors)
>> - rs->md.recovery_cp += rs->dev[0].rdev.data_offset;
>> + if (rs->md.resync_offset < rs->md.dev_sectors)
>> + rs->md.resync_offset += rs->dev[0].rdev.data_offset;
>>
>> /* Adjust data offsets on all rdevs but on any raid4/5/6 journal device */
>> rdev_for_each(rdev, &rs->md) {
>> @@ -2756,7 +2756,7 @@ static int rs_setup_takeover(struct raid_set *rs)
>> }
>>
>> clear_bit(MD_ARRAY_FIRST_USE, &mddev->flags);
>> - mddev->recovery_cp = MaxSector;
>> + mddev->resync_offset = MaxSector;
>>
>> while (d--) {
>> rdev = &rs->dev[d].rdev;
>> @@ -2764,7 +2764,7 @@ static int rs_setup_takeover(struct raid_set *rs)
>> if (test_bit(d, (void *) rs->rebuild_disks)) {
>> clear_bit(In_sync, &rdev->flags);
>> clear_bit(Faulty, &rdev->flags);
>> - mddev->recovery_cp = rdev->recovery_offset = 0;
>> + mddev->resync_offset = rdev->recovery_offset = 0;
>> /* Bitmap has to be created when we do an "up" takeover */
>> set_bit(MD_ARRAY_FIRST_USE, &mddev->flags);
>> }
>> @@ -3222,7 +3222,7 @@ static int raid_ctr(struct dm_target *ti, unsigned int argc, char **argv)
>> if (r)
>> goto bad;
>>
>> - rs_setup_recovery(rs, rs->md.recovery_cp < rs->md.dev_sectors ? rs->md.recovery_cp : rs->md.dev_sectors);
>> + rs_setup_recovery(rs, rs->md.resync_offset < rs->md.dev_sectors ? rs->md.resync_offset : rs->md.dev_sectors);
>> } else {
>> /* This is no size change or it is shrinking, update size and record in superblocks */
>> r = rs_set_dev_and_array_sectors(rs, rs->ti->len, false);
>> @@ -3446,7 +3446,7 @@ static sector_t rs_get_progress(struct raid_set *rs, unsigned long recovery,
>>
>> } else {
>> if (state == st_idle && !test_bit(MD_RECOVERY_INTR, &recovery))
>> - r = mddev->recovery_cp;
>> + r = mddev->resync_offset;
>> else
>> r = mddev->curr_resync_completed;
>>
>> @@ -4074,9 +4074,9 @@ static int raid_preresume(struct dm_target *ti)
>> }
>>
>> /* Check for any resize/reshape on @rs and adjust/initiate */
>> - if (mddev->recovery_cp && mddev->recovery_cp < MaxSector) {
>> + if (mddev->resync_offset && mddev->resync_offset < MaxSector) {
>> set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
>> - mddev->resync_min = mddev->recovery_cp;
>> + mddev->resync_min = mddev->resync_offset;
>> if (test_bit(RT_FLAG_RS_GROW, &rs->runtime_flags))
>> mddev->resync_max_sectors = mddev->dev_sectors;
>> }
>> diff --git a/drivers/md/md-bitmap.c b/drivers/md/md-bitmap.c
>> index bd694910b01b..c74fe9c18658 100644
>> --- a/drivers/md/md-bitmap.c
>> +++ b/drivers/md/md-bitmap.c
>> @@ -1987,12 +1987,12 @@ static void bitmap_dirty_bits(struct mddev *mddev, unsigned long s,
>>
>> md_bitmap_set_memory_bits(bitmap, sec, 1);
>> md_bitmap_file_set_bit(bitmap, sec);
>> - if (sec < bitmap->mddev->recovery_cp)
>> + if (sec < bitmap->mddev->resync_offset)
>> /* We are asserting that the array is dirty,
>> - * so move the recovery_cp address back so
>> + * so move the resync_offset address back so
>> * that it is obvious that it is dirty
>> */
>> - bitmap->mddev->recovery_cp = sec;
>> + bitmap->mddev->resync_offset = sec;
>> }
>> }
>>
>> @@ -2258,7 +2258,7 @@ static int bitmap_load(struct mddev *mddev)
>> || bitmap->events_cleared == mddev->events)
>> /* no need to keep dirty bits to optimise a
>> * re-add of a missing device */
>> - start = mddev->recovery_cp;
>> + start = mddev->resync_offset;
>>
>> mutex_lock(&mddev->bitmap_info.mutex);
>> err = md_bitmap_init_from_disk(bitmap, start);
>> diff --git a/drivers/md/md-cluster.c b/drivers/md/md-cluster.c
>> index 94221d964d4f..5497eaee96e7 100644
>> --- a/drivers/md/md-cluster.c
>> +++ b/drivers/md/md-cluster.c
>> @@ -337,11 +337,11 @@ static void recover_bitmaps(struct md_thread *thread)
>> md_wakeup_thread(mddev->sync_thread);
>>
>> if (hi > 0) {
>> - if (lo < mddev->recovery_cp)
>> - mddev->recovery_cp = lo;
>> + if (lo < mddev->resync_offset)
>> + mddev->resync_offset = lo;
>> /* wake up thread to continue resync in case resync
>> * is not finished */
>> - if (mddev->recovery_cp != MaxSector) {
>> + if (mddev->resync_offset != MaxSector) {
>> /*
>> * clear the REMOTE flag since we will launch
>> * resync thread in current node.
>> @@ -863,9 +863,9 @@ static int gather_all_resync_info(struct mddev *mddev, int total_slots)
>> lockres_free(bm_lockres);
>> continue;
>> }
>> - if ((hi > 0) && (lo < mddev->recovery_cp)) {
>> + if ((hi > 0) && (lo < mddev->resync_offset)) {
>> set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
>> - mddev->recovery_cp = lo;
>> + mddev->resync_offset = lo;
>> md_check_recovery(mddev);
>> }
>>
>> @@ -1027,7 +1027,7 @@ static int leave(struct mddev *mddev)
>> * Also, we should send BITMAP_NEEDS_SYNC message in
>> * case reshaping is interrupted.
>> */
>> - if ((cinfo->slot_number > 0 && mddev->recovery_cp != MaxSector) ||
>> + if ((cinfo->slot_number > 0 && mddev->resync_offset != MaxSector) ||
>> (mddev->reshape_position != MaxSector &&
>> test_bit(MD_CLOSING, &mddev->flags)))
>> resync_bitmap(mddev);
>> @@ -1605,8 +1605,8 @@ static int gather_bitmaps(struct md_rdev *rdev)
>> pr_warn("md-cluster: Could not gather bitmaps from slot %d", sn);
>> goto out;
>> }
>> - if ((hi > 0) && (lo < mddev->recovery_cp))
>> - mddev->recovery_cp = lo;
>> + if ((hi > 0) && (lo < mddev->resync_offset))
>> + mddev->resync_offset = lo;
>> }
>> out:
>> return err;
>> diff --git a/drivers/md/md.c b/drivers/md/md.c
>> index 9a704ddc107a..c3723ac57775 100644
>> --- a/drivers/md/md.c
>> +++ b/drivers/md/md.c
>> @@ -1410,13 +1410,13 @@ static int super_90_validate(struct mddev *mddev, struct md_rdev *freshest, stru
>> mddev->layout = -1;
>>
>> if (sb->state & (1<<MD_SB_CLEAN))
>> - mddev->recovery_cp = MaxSector;
>> + mddev->resync_offset = MaxSector;
>> else {
>> if (sb->events_hi == sb->cp_events_hi &&
>> sb->events_lo == sb->cp_events_lo) {
>> - mddev->recovery_cp = sb->recovery_cp;
>> + mddev->resync_offset = sb->resync_offset;
>> } else
>> - mddev->recovery_cp = 0;
>> + mddev->resync_offset = 0;
>> }
>>
>> memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
>> @@ -1542,13 +1542,13 @@ static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
>> mddev->minor_version = sb->minor_version;
>> if (mddev->in_sync)
>> {
>> - sb->recovery_cp = mddev->recovery_cp;
>> + sb->resync_offset = mddev->resync_offset;
>> sb->cp_events_hi = (mddev->events>>32);
>> sb->cp_events_lo = (u32)mddev->events;
>> - if (mddev->recovery_cp == MaxSector)
>> + if (mddev->resync_offset == MaxSector)
>> sb->state = (1<< MD_SB_CLEAN);
>> } else
>> - sb->recovery_cp = 0;
>> + sb->resync_offset = 0;
>>
>> sb->layout = mddev->layout;
>> sb->chunk_size = mddev->chunk_sectors << 9;
>> @@ -1898,7 +1898,7 @@ static int super_1_validate(struct mddev *mddev, struct md_rdev *freshest, struc
>> mddev->bitmap_info.default_space = (4096-1024) >> 9;
>> mddev->reshape_backwards = 0;
>>
>> - mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
>> + mddev->resync_offset = le64_to_cpu(sb->resync_offset);
>> memcpy(mddev->uuid, sb->set_uuid, 16);
>>
>> mddev->max_disks = (4096-256)/2;
>> @@ -2084,7 +2084,7 @@ static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
>> sb->utime = cpu_to_le64((__u64)mddev->utime);
>> sb->events = cpu_to_le64(mddev->events);
>> if (mddev->in_sync)
>> - sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
>> + sb->resync_offset = cpu_to_le64(mddev->resync_offset);
>> else if (test_bit(MD_JOURNAL_CLEAN, &mddev->flags))
>> sb->resync_offset = cpu_to_le64(MaxSector);
>> else
>> @@ -2765,7 +2765,7 @@ void md_update_sb(struct mddev *mddev, int force_change)
>> /* If this is just a dirty<->clean transition, and the array is clean
>> * and 'events' is odd, we can roll back to the previous clean state */
>> if (nospares
>> - && (mddev->in_sync && mddev->recovery_cp == MaxSector)
>> + && (mddev->in_sync && mddev->resync_offset == MaxSector)
>> && mddev->can_decrease_events
>> && mddev->events != 1) {
>> mddev->events--;
>> @@ -4301,9 +4301,9 @@ __ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
>> static ssize_t
>> resync_start_show(struct mddev *mddev, char *page)
>> {
>> - if (mddev->recovery_cp == MaxSector)
>> + if (mddev->resync_offset == MaxSector)
>> return sprintf(page, "none\n");
>> - return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
>> + return sprintf(page, "%llu\n", (unsigned long long)mddev->resync_offset);
>> }
>>
>> static ssize_t
>> @@ -4329,7 +4329,7 @@ resync_start_store(struct mddev *mddev, const char *buf, size_t len)
>> err = -EBUSY;
>>
>> if (!err) {
>> - mddev->recovery_cp = n;
>> + mddev->resync_offset = n;
>> if (mddev->pers)
>> set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
>> }
>> @@ -6488,7 +6488,7 @@ static void md_clean(struct mddev *mddev)
>> mddev->external_size = 0;
>> mddev->dev_sectors = 0;
>> mddev->raid_disks = 0;
>> - mddev->recovery_cp = 0;
>> + mddev->resync_offset = 0;
>> mddev->resync_min = 0;
>> mddev->resync_max = MaxSector;
>> mddev->reshape_position = MaxSector;
>> @@ -7434,9 +7434,9 @@ int md_set_array_info(struct mddev *mddev, struct mdu_array_info_s *info)
>> * openned
>> */
>> if (info->state & (1<<MD_SB_CLEAN))
>> - mddev->recovery_cp = MaxSector;
>> + mddev->resync_offset = MaxSector;
>> else
>> - mddev->recovery_cp = 0;
>> + mddev->resync_offset = 0;
>> mddev->persistent = ! info->not_persistent;
>> mddev->external = 0;
>>
>> @@ -8375,7 +8375,7 @@ static int status_resync(struct seq_file *seq, struct mddev *mddev)
>> seq_printf(seq, "\tresync=REMOTE");
>> return 1;
>> }
>> - if (mddev->recovery_cp < MaxSector) {
>> + if (mddev->resync_offset < MaxSector) {
>> seq_printf(seq, "\tresync=PENDING");
>> return 1;
>> }
>> @@ -9018,7 +9018,7 @@ static sector_t md_sync_position(struct mddev *mddev, enum sync_action action)
>> return mddev->resync_min;
>> case ACTION_RESYNC:
>> if (!mddev->bitmap)
>> - return mddev->recovery_cp;
>> + return mddev->resync_offset;
>> return 0;
>> case ACTION_RESHAPE:
>> /*
>> @@ -9256,8 +9256,8 @@ void md_do_sync(struct md_thread *thread)
>> atomic_read(&mddev->recovery_active) == 0);
>> mddev->curr_resync_completed = j;
>> if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
>> - j > mddev->recovery_cp)
>> - mddev->recovery_cp = j;
>> + j > mddev->resync_offset)
>> + mddev->resync_offset = j;
>> update_time = jiffies;
>> set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
>> sysfs_notify_dirent_safe(mddev->sysfs_completed);
>> @@ -9377,19 +9377,19 @@ void md_do_sync(struct md_thread *thread)
>> mddev->curr_resync > MD_RESYNC_ACTIVE) {
>> if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
>> if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
>> - if (mddev->curr_resync >= mddev->recovery_cp) {
>> + if (mddev->curr_resync >= mddev->resync_offset) {
>> pr_debug("md: checkpointing %s of %s.\n",
>> desc, mdname(mddev));
>> if (test_bit(MD_RECOVERY_ERROR,
>> &mddev->recovery))
>> - mddev->recovery_cp =
>> + mddev->resync_offset =
>> mddev->curr_resync_completed;
>> else
>> - mddev->recovery_cp =
>> + mddev->resync_offset =
>> mddev->curr_resync;
>> }
>> } else
>> - mddev->recovery_cp = MaxSector;
>> + mddev->resync_offset = MaxSector;
>> } else {
>> if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
>> mddev->curr_resync = MaxSector;
>> @@ -9605,7 +9605,7 @@ static bool md_choose_sync_action(struct mddev *mddev, int *spares)
>> }
>>
>> /* Check if resync is in progress. */
>> - if (mddev->recovery_cp < MaxSector) {
>> + if (mddev->resync_offset < MaxSector) {
>> remove_spares(mddev, NULL);
>> set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
>> clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
>> @@ -9786,7 +9786,7 @@ void md_check_recovery(struct mddev *mddev)
>> test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
>> (mddev->external == 0 && mddev->safemode == 1) ||
>> (mddev->safemode == 2
>> - && !mddev->in_sync && mddev->recovery_cp == MaxSector)
>> + && !mddev->in_sync && mddev->resync_offset == MaxSector)
>> ))
>> return;
>>
>> diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
>> index c65732b330eb..d08d71e1fb41 100644
>> --- a/drivers/md/raid0.c
>> +++ b/drivers/md/raid0.c
>> @@ -674,7 +674,7 @@ static void *raid0_takeover_raid45(struct mddev *mddev)
>> mddev->raid_disks--;
>> mddev->delta_disks = -1;
>> /* make sure it will be not marked as dirty */
>> - mddev->recovery_cp = MaxSector;
>> + mddev->resync_offset = MaxSector;
>> mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
>>
>> create_strip_zones(mddev, &priv_conf);
>> @@ -717,7 +717,7 @@ static void *raid0_takeover_raid10(struct mddev *mddev)
>> mddev->raid_disks += mddev->delta_disks;
>> mddev->degraded = 0;
>> /* make sure it will be not marked as dirty */
>> - mddev->recovery_cp = MaxSector;
>> + mddev->resync_offset = MaxSector;
>> mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
>>
>> create_strip_zones(mddev, &priv_conf);
>> @@ -760,7 +760,7 @@ static void *raid0_takeover_raid1(struct mddev *mddev)
>> mddev->delta_disks = 1 - mddev->raid_disks;
>> mddev->raid_disks = 1;
>> /* make sure it will be not marked as dirty */
>> - mddev->recovery_cp = MaxSector;
>> + mddev->resync_offset = MaxSector;
>> mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
>>
>> create_strip_zones(mddev, &priv_conf);
>> diff --git a/drivers/md/raid1-10.c b/drivers/md/raid1-10.c
>> index b8b3a9069701..52881e6032da 100644
>> --- a/drivers/md/raid1-10.c
>> +++ b/drivers/md/raid1-10.c
>> @@ -283,7 +283,7 @@ static inline int raid1_check_read_range(struct md_rdev *rdev,
>> static inline bool raid1_should_read_first(struct mddev *mddev,
>> sector_t this_sector, int len)
>> {
>> - if ((mddev->recovery_cp < this_sector + len))
>> + if ((mddev->resync_offset < this_sector + len))
>> return true;
>>
>> if (mddev_is_clustered(mddev) &&
>> diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
>> index 7e37f1015646..0a0668fa148e 100644
>> --- a/drivers/md/raid1.c
>> +++ b/drivers/md/raid1.c
>> @@ -2821,7 +2821,7 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
>> }
>>
>> if (mddev->bitmap == NULL &&
>> - mddev->recovery_cp == MaxSector &&
>> + mddev->resync_offset == MaxSector &&
>> !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
>> conf->fullsync == 0) {
>> *skipped = 1;
>> @@ -3282,9 +3282,9 @@ static int raid1_run(struct mddev *mddev)
>> }
>>
>> if (conf->raid_disks - mddev->degraded == 1)
>> - mddev->recovery_cp = MaxSector;
>> + mddev->resync_offset = MaxSector;
>>
>> - if (mddev->recovery_cp != MaxSector)
>> + if (mddev->resync_offset != MaxSector)
>> pr_info("md/raid1:%s: not clean -- starting background reconstruction\n",
>> mdname(mddev));
>> pr_info("md/raid1:%s: active with %d out of %d mirrors\n",
>> @@ -3345,8 +3345,8 @@ static int raid1_resize(struct mddev *mddev, sector_t sectors)
>>
>> md_set_array_sectors(mddev, newsize);
>> if (sectors > mddev->dev_sectors &&
>> - mddev->recovery_cp > mddev->dev_sectors) {
>> - mddev->recovery_cp = mddev->dev_sectors;
>> + mddev->resync_offset > mddev->dev_sectors) {
>> + mddev->resync_offset = mddev->dev_sectors;
>> set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
>> }
>> mddev->dev_sectors = sectors;
>> diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
>> index 375543f8153f..169bc5fe2d4f 100644
>> --- a/drivers/md/raid10.c
>> +++ b/drivers/md/raid10.c
>> @@ -2109,7 +2109,7 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
>> int last = conf->geo.raid_disks - 1;
>> struct raid10_info *p;
>>
>> - if (mddev->recovery_cp < MaxSector)
>> + if (mddev->resync_offset < MaxSector)
>> /* only hot-add to in-sync arrays, as recovery is
>> * very different from resync
>> */
>> @@ -3177,7 +3177,7 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,
>> * of a clean array, like RAID1 does.
>> */
>> if (mddev->bitmap == NULL &&
>> - mddev->recovery_cp == MaxSector &&
>> + mddev->resync_offset == MaxSector &&
>> mddev->reshape_position == MaxSector &&
>> !test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
>> !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
>> @@ -4137,7 +4137,7 @@ static int raid10_run(struct mddev *mddev)
>> disk->recovery_disabled = mddev->recovery_disabled - 1;
>> }
>>
>> - if (mddev->recovery_cp != MaxSector)
>> + if (mddev->resync_offset != MaxSector)
>> pr_notice("md/raid10:%s: not clean -- starting background reconstruction\n",
>> mdname(mddev));
>> pr_info("md/raid10:%s: active with %d out of %d devices\n",
>> @@ -4237,8 +4237,8 @@ static int raid10_resize(struct mddev *mddev, sector_t sectors)
>>
>> md_set_array_sectors(mddev, size);
>> if (sectors > mddev->dev_sectors &&
>> - mddev->recovery_cp > oldsize) {
>> - mddev->recovery_cp = oldsize;
>> + mddev->resync_offset > oldsize) {
>> + mddev->resync_offset = oldsize;
>> set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
>> }
>> calc_sectors(conf, sectors);
>> @@ -4267,7 +4267,7 @@ static void *raid10_takeover_raid0(struct mddev *mddev, sector_t size, int devs)
>> mddev->delta_disks = mddev->raid_disks;
>> mddev->raid_disks *= 2;
>> /* make sure it will be not marked as dirty */
>> - mddev->recovery_cp = MaxSector;
>> + mddev->resync_offset = MaxSector;
>> mddev->dev_sectors = size;
>>
>> conf = setup_conf(mddev);
>> @@ -5079,8 +5079,8 @@ static void raid10_finish_reshape(struct mddev *mddev)
>> return;
>>
>> if (mddev->delta_disks > 0) {
>> - if (mddev->recovery_cp > mddev->resync_max_sectors) {
>> - mddev->recovery_cp = mddev->resync_max_sectors;
>> + if (mddev->resync_offset > mddev->resync_max_sectors) {
>> + mddev->resync_offset = mddev->resync_max_sectors;
>> set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
>> }
>> mddev->resync_max_sectors = mddev->array_sectors;
>> diff --git a/drivers/md/raid5-ppl.c b/drivers/md/raid5-ppl.c
>> index c0fb335311aa..56b234683ee6 100644
>> --- a/drivers/md/raid5-ppl.c
>> +++ b/drivers/md/raid5-ppl.c
>> @@ -1163,7 +1163,7 @@ static int ppl_load_distributed(struct ppl_log *log)
>> le64_to_cpu(pplhdr->generation));
>>
>> /* attempt to recover from log if we are starting a dirty array */
>> - if (pplhdr && !mddev->pers && mddev->recovery_cp != MaxSector)
>> + if (pplhdr && !mddev->pers && mddev->resync_offset != MaxSector)
>> ret = ppl_recover(log, pplhdr, pplhdr_offset);
>>
>> /* write empty header if we are starting the array */
>> @@ -1422,14 +1422,14 @@ int ppl_init_log(struct r5conf *conf)
>>
>> if (ret) {
>> goto err;
>> - } else if (!mddev->pers && mddev->recovery_cp == 0 &&
>> + } else if (!mddev->pers && mddev->resync_offset == 0 &&
>> ppl_conf->recovered_entries > 0 &&
>> ppl_conf->mismatch_count == 0) {
>> /*
>> * If we are starting a dirty array and the recovery succeeds
>> * without any issues, set the array as clean.
>> */
>> - mddev->recovery_cp = MaxSector;
>> + mddev->resync_offset = MaxSector;
>> set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
>> } else if (mddev->pers && ppl_conf->mismatch_count > 0) {
>> /* no mismatch allowed when enabling PPL for a running array */
>> diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
>> index 11307878a982..8e74cee3fb8e 100644
>> --- a/drivers/md/raid5.c
>> +++ b/drivers/md/raid5.c
>> @@ -3740,7 +3740,7 @@ static int want_replace(struct stripe_head *sh, int disk_idx)
>> && !test_bit(Faulty, &rdev->flags)
>> && !test_bit(In_sync, &rdev->flags)
>> && (rdev->recovery_offset <= sh->sector
>> - || rdev->mddev->recovery_cp <= sh->sector))
>> + || rdev->mddev->resync_offset <= sh->sector))
>> rv = 1;
>> return rv;
>> }
>> @@ -3832,7 +3832,7 @@ static int need_this_block(struct stripe_head *sh, struct stripe_head_state *s,
>> * is missing/faulty, then we need to read everything we can.
>> */
>> if (!force_rcw &&
>> - sh->sector < sh->raid_conf->mddev->recovery_cp)
>> + sh->sector < sh->raid_conf->mddev->resync_offset)
>> /* reconstruct-write isn't being forced */
>> return 0;
>> for (i = 0; i < s->failed && i < 2; i++) {
>> @@ -4097,7 +4097,7 @@ static int handle_stripe_dirtying(struct r5conf *conf,
>> int disks)
>> {
>> int rmw = 0, rcw = 0, i;
>> - sector_t recovery_cp = conf->mddev->recovery_cp;
>> + sector_t resync_offset = conf->mddev->resync_offset;
>>
>> /* Check whether resync is now happening or should start.
>> * If yes, then the array is dirty (after unclean shutdown or
>> @@ -4107,14 +4107,14 @@ static int handle_stripe_dirtying(struct r5conf *conf,
>> * generate correct data from the parity.
>> */
>> if (conf->rmw_level == PARITY_DISABLE_RMW ||
>> - (recovery_cp < MaxSector && sh->sector >= recovery_cp &&
>> + (resync_offset < MaxSector && sh->sector >= resync_offset &&
>> s->failed == 0)) {
>> /* Calculate the real rcw later - for now make it
>> * look like rcw is cheaper
>> */
>> rcw = 1; rmw = 2;
>> - pr_debug("force RCW rmw_level=%u, recovery_cp=%llu sh->sector=%llu\n",
>> - conf->rmw_level, (unsigned long long)recovery_cp,
>> + pr_debug("force RCW rmw_level=%u, resync_offset=%llu sh->sector=%llu\n",
>> + conf->rmw_level, (unsigned long long)resync_offset,
>> (unsigned long long)sh->sector);
>> } else for (i = disks; i--; ) {
>> /* would I have to read this buffer for read_modify_write */
>> @@ -4770,14 +4770,14 @@ static void analyse_stripe(struct stripe_head *sh, struct stripe_head_state *s)
>> if (test_bit(STRIPE_SYNCING, &sh->state)) {
>> /* If there is a failed device being replaced,
>> * we must be recovering.
>> - * else if we are after recovery_cp, we must be syncing
>> + * else if we are after resync_offset, we must be syncing
>> * else if MD_RECOVERY_REQUESTED is set, we also are syncing.
>> * else we can only be replacing
>> * sync and recovery both need to read all devices, and so
>> * use the same flag.
>> */
>> if (do_recovery ||
>> - sh->sector >= conf->mddev->recovery_cp ||
>> + sh->sector >= conf->mddev->resync_offset ||
>> test_bit(MD_RECOVERY_REQUESTED, &(conf->mddev->recovery)))
>> s->syncing = 1;
>> else
>> @@ -7781,7 +7781,7 @@ static int raid5_run(struct mddev *mddev)
>> int first = 1;
>> int ret = -EIO;
>>
>> - if (mddev->recovery_cp != MaxSector)
>> + if (mddev->resync_offset != MaxSector)
>> pr_notice("md/raid:%s: not clean -- starting background reconstruction\n",
>> mdname(mddev));
>>
>> @@ -7922,7 +7922,7 @@ static int raid5_run(struct mddev *mddev)
>> mdname(mddev));
>> mddev->ro = 1;
>> set_disk_ro(mddev->gendisk, 1);
>> - } else if (mddev->recovery_cp == MaxSector)
>> + } else if (mddev->resync_offset == MaxSector)
>> set_bit(MD_JOURNAL_CLEAN, &mddev->flags);
>> }
>>
>> @@ -7989,7 +7989,7 @@ static int raid5_run(struct mddev *mddev)
>> mddev->resync_max_sectors = mddev->dev_sectors;
>>
>> if (mddev->degraded > dirty_parity_disks &&
>> - mddev->recovery_cp != MaxSector) {
>> + mddev->resync_offset != MaxSector) {
>> if (test_bit(MD_HAS_PPL, &mddev->flags))
>> pr_crit("md/raid:%s: starting dirty degraded array with PPL.\n",
>> mdname(mddev));
>> @@ -8329,8 +8329,8 @@ static int raid5_resize(struct mddev *mddev, sector_t sectors)
>>
>> md_set_array_sectors(mddev, newsize);
>> if (sectors > mddev->dev_sectors &&
>> - mddev->recovery_cp > mddev->dev_sectors) {
>> - mddev->recovery_cp = mddev->dev_sectors;
>> + mddev->resync_offset > mddev->dev_sectors) {
>> + mddev->resync_offset = mddev->dev_sectors;
>> set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
>> }
>> mddev->dev_sectors = sectors;
>> @@ -8424,7 +8424,7 @@ static int raid5_start_reshape(struct mddev *mddev)
>> return -EINVAL;
>>
>> /* raid5 can't handle concurrent reshape and recovery */
>> - if (mddev->recovery_cp < MaxSector)
>> + if (mddev->resync_offset < MaxSector)
>> return -EBUSY;
>> for (i = 0; i < conf->raid_disks; i++)
>> if (conf->disks[i].replacement)
>> @@ -8649,7 +8649,7 @@ static void *raid45_takeover_raid0(struct mddev *mddev, int level)
>> mddev->raid_disks += 1;
>> mddev->delta_disks = 1;
>> /* make sure it will be not marked as dirty */
>> - mddev->recovery_cp = MaxSector;
>> + mddev->resync_offset = MaxSector;
>>
>> return setup_conf(mddev);
>> }
>> --
>> 2.39.2
>>
>>
>
>
> .
>
Powered by blists - more mailing lists