Re: [PATCH v2 1/3] btrfs: scrub: rename members related to scrub_block::pagev

[David Sterba <dsterba@suse.cz>]

On Fri, Mar 11, 2022 at 03:34:18PM +0800, Qu Wenruo wrote:
> The following will be renamed in this patch:
> 
> - scrub_block::pagev -> sectorv

I think you can come up with a different naming scheme and not copy the
original, eg. something closer what we've been using elsewhere. Here the
'pagev' is a page vector, but 'sectors' is IMHO fine and also
understandable.

> 
> - scrub_block::page_count -> sector_count
> 
> - SCRUB_MAX_PAGES_PER_BLOCK -> SCRUB_MAX_SECTORS_PER_BLOCK
> 
> - page_num -> sector_num to iterate scrub_block::sectorv
> 
> For now scrub_page is not yet renamed, as the current changeset is
> already large enough.
> 
> The rename for scrub_page will come in a separate patch.
> 
> Signed-off-by: Qu Wenruo <wqu@suse.com>
> ---
>  fs/btrfs/scrub.c | 220 +++++++++++++++++++++++------------------------
>  1 file changed, 110 insertions(+), 110 deletions(-)
> 
> diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
> index 11089568b287..fd67e1acdba6 100644
> --- a/fs/btrfs/scrub.c
> +++ b/fs/btrfs/scrub.c
> @@ -52,7 +52,7 @@ struct scrub_ctx;
>   * The following value times PAGE_SIZE needs to be large enough to match the
>   * largest node/leaf/sector size that shall be supported.
>   */
> -#define SCRUB_MAX_PAGES_PER_BLOCK	(BTRFS_MAX_METADATA_BLOCKSIZE / SZ_4K)
> +#define SCRUB_MAX_SECTORS_PER_BLOCK	(BTRFS_MAX_METADATA_BLOCKSIZE / SZ_4K)
>  
>  struct scrub_recover {
>  	refcount_t		refs;
> @@ -94,8 +94,8 @@ struct scrub_bio {
>  };
>  
>  struct scrub_block {
> -	struct scrub_page	*pagev[SCRUB_MAX_PAGES_PER_BLOCK];
> -	int			page_count;
> +	struct scrub_page	*sectorv[SCRUB_MAX_SECTORS_PER_BLOCK];
> +	int			sector_count;
>  	atomic_t		outstanding_pages;
>  	refcount_t		refs; /* free mem on transition to zero */
>  	struct scrub_ctx	*sctx;
> @@ -728,16 +728,16 @@ static void scrub_print_warning(const char *errstr, struct scrub_block *sblock)
>  	u8 ref_level = 0;
>  	int ret;
>  
> -	WARN_ON(sblock->page_count < 1);
> -	dev = sblock->pagev[0]->dev;
> +	WARN_ON(sblock->sector_count < 1);
> +	dev = sblock->sectorv[0]->dev;
>  	fs_info = sblock->sctx->fs_info;
>  
>  	path = btrfs_alloc_path();
>  	if (!path)
>  		return;
>  
> -	swarn.physical = sblock->pagev[0]->physical;
> -	swarn.logical = sblock->pagev[0]->logical;
> +	swarn.physical = sblock->sectorv[0]->physical;
> +	swarn.logical = sblock->sectorv[0]->logical;
>  	swarn.errstr = errstr;
>  	swarn.dev = NULL;
>  
> @@ -817,16 +817,16 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
>  	struct scrub_block *sblock_bad;
>  	int ret;
>  	int mirror_index;
> -	int page_num;
> +	int sector_num;
>  	int success;
>  	bool full_stripe_locked;
>  	unsigned int nofs_flag;
>  	static DEFINE_RATELIMIT_STATE(rs, DEFAULT_RATELIMIT_INTERVAL,
>  				      DEFAULT_RATELIMIT_BURST);
>  
> -	BUG_ON(sblock_to_check->page_count < 1);
> +	BUG_ON(sblock_to_check->sector_count < 1);
>  	fs_info = sctx->fs_info;
> -	if (sblock_to_check->pagev[0]->flags & BTRFS_EXTENT_FLAG_SUPER) {
> +	if (sblock_to_check->sectorv[0]->flags & BTRFS_EXTENT_FLAG_SUPER) {
>  		/*
>  		 * if we find an error in a super block, we just report it.
>  		 * They will get written with the next transaction commit
> @@ -837,13 +837,13 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
>  		spin_unlock(&sctx->stat_lock);
>  		return 0;
>  	}
> -	logical = sblock_to_check->pagev[0]->logical;
> -	BUG_ON(sblock_to_check->pagev[0]->mirror_num < 1);
> -	failed_mirror_index = sblock_to_check->pagev[0]->mirror_num - 1;
> -	is_metadata = !(sblock_to_check->pagev[0]->flags &
> +	logical = sblock_to_check->sectorv[0]->logical;
> +	BUG_ON(sblock_to_check->sectorv[0]->mirror_num < 1);
> +	failed_mirror_index = sblock_to_check->sectorv[0]->mirror_num - 1;
> +	is_metadata = !(sblock_to_check->sectorv[0]->flags &
>  			BTRFS_EXTENT_FLAG_DATA);
> -	have_csum = sblock_to_check->pagev[0]->have_csum;
> -	dev = sblock_to_check->pagev[0]->dev;
> +	have_csum = sblock_to_check->sectorv[0]->have_csum;
> +	dev = sblock_to_check->sectorv[0]->dev;
>  
>  	if (!sctx->is_dev_replace && btrfs_repair_one_zone(fs_info, logical))
>  		return 0;
> @@ -1011,25 +1011,25 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
>  			continue;
>  
>  		/* raid56's mirror can be more than BTRFS_MAX_MIRRORS */
> -		if (!scrub_is_page_on_raid56(sblock_bad->pagev[0])) {
> +		if (!scrub_is_page_on_raid56(sblock_bad->sectorv[0])) {
>  			if (mirror_index >= BTRFS_MAX_MIRRORS)
>  				break;
> -			if (!sblocks_for_recheck[mirror_index].page_count)
> +			if (!sblocks_for_recheck[mirror_index].sector_count)
>  				break;
>  
>  			sblock_other = sblocks_for_recheck + mirror_index;
>  		} else {
> -			struct scrub_recover *r = sblock_bad->pagev[0]->recover;
> +			struct scrub_recover *r = sblock_bad->sectorv[0]->recover;
>  			int max_allowed = r->bioc->num_stripes - r->bioc->num_tgtdevs;
>  
>  			if (mirror_index >= max_allowed)
>  				break;
> -			if (!sblocks_for_recheck[1].page_count)
> +			if (!sblocks_for_recheck[1].sector_count)
>  				break;
>  
>  			ASSERT(failed_mirror_index == 0);
>  			sblock_other = sblocks_for_recheck + 1;
> -			sblock_other->pagev[0]->mirror_num = 1 + mirror_index;
> +			sblock_other->sectorv[0]->mirror_num = 1 + mirror_index;
>  		}
>  
>  		/* build and submit the bios, check checksums */
> @@ -1078,16 +1078,16 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
>  	 * area are unreadable.
>  	 */
>  	success = 1;
> -	for (page_num = 0; page_num < sblock_bad->page_count;
> -	     page_num++) {
> -		struct scrub_page *spage_bad = sblock_bad->pagev[page_num];
> +	for (sector_num = 0; sector_num < sblock_bad->sector_count;

This is a simple indexing, so while sector_num is accurate a plain 'i'
would work too. It would also make some lines shorter.

> +	     sector_num++) {
> +		struct scrub_page *spage_bad = sblock_bad->sectorv[sector_num];
>  		struct scrub_block *sblock_other = NULL;
>  
>  		/* skip no-io-error page in scrub */
>  		if (!spage_bad->io_error && !sctx->is_dev_replace)
>  			continue;
>  
> -		if (scrub_is_page_on_raid56(sblock_bad->pagev[0])) {
> +		if (scrub_is_page_on_raid56(sblock_bad->sectorv[0])) {
>  			/*
>  			 * In case of dev replace, if raid56 rebuild process
>  			 * didn't work out correct data, then copy the content
> @@ -1100,10 +1100,10 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
>  			/* try to find no-io-error page in mirrors */
>  			for (mirror_index = 0;
>  			     mirror_index < BTRFS_MAX_MIRRORS &&
> -			     sblocks_for_recheck[mirror_index].page_count > 0;
> +			     sblocks_for_recheck[mirror_index].sector_count > 0;
>  			     mirror_index++) {
>  				if (!sblocks_for_recheck[mirror_index].
> -				    pagev[page_num]->io_error) {
> +				    sectorv[sector_num]->io_error) {
>  					sblock_other = sblocks_for_recheck +
>  						       mirror_index;
>  					break;
> @@ -1125,7 +1125,7 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
>  				sblock_other = sblock_bad;
>  
>  			if (scrub_write_page_to_dev_replace(sblock_other,
> -							    page_num) != 0) {
> +							    sector_num) != 0) {
>  				atomic64_inc(
>  					&fs_info->dev_replace.num_write_errors);
>  				success = 0;
> @@ -1133,7 +1133,7 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
>  		} else if (sblock_other) {
>  			ret = scrub_repair_page_from_good_copy(sblock_bad,
>  							       sblock_other,
> -							       page_num, 0);
> +							       sector_num, 0);
>  			if (0 == ret)
>  				spage_bad->io_error = 0;
>  			else
> @@ -1186,18 +1186,18 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
>  			struct scrub_block *sblock = sblocks_for_recheck +
>  						     mirror_index;
>  			struct scrub_recover *recover;
> -			int page_index;
> +			int sector_index;
>  
> -			for (page_index = 0; page_index < sblock->page_count;
> -			     page_index++) {
> -				sblock->pagev[page_index]->sblock = NULL;
> -				recover = sblock->pagev[page_index]->recover;
> +			for (sector_index = 0; sector_index < sblock->sector_count;
> +			     sector_index++) {
> +				sblock->sectorv[sector_index]->sblock = NULL;
> +				recover = sblock->sectorv[sector_index]->recover;
>  				if (recover) {
>  					scrub_put_recover(fs_info, recover);
> -					sblock->pagev[page_index]->recover =
> +					sblock->sectorv[sector_index]->recover =
>  									NULL;
>  				}
> -				scrub_page_put(sblock->pagev[page_index]);
> +				scrub_page_put(sblock->sectorv[sector_index]);
>  			}
>  		}
>  		kfree(sblocks_for_recheck);
> @@ -1255,18 +1255,18 @@ static int scrub_setup_recheck_block(struct scrub_block *original_sblock,
>  {
>  	struct scrub_ctx *sctx = original_sblock->sctx;
>  	struct btrfs_fs_info *fs_info = sctx->fs_info;
> -	u64 length = original_sblock->page_count * fs_info->sectorsize;
> -	u64 logical = original_sblock->pagev[0]->logical;
> -	u64 generation = original_sblock->pagev[0]->generation;
> -	u64 flags = original_sblock->pagev[0]->flags;
> -	u64 have_csum = original_sblock->pagev[0]->have_csum;
> +	u64 length = original_sblock->sector_count * fs_info->sectorsize;

						>> fs_info->sectorsize_bits

> +	u64 logical = original_sblock->sectorv[0]->logical;
> +	u64 generation = original_sblock->sectorv[0]->generation;
> +	u64 flags = original_sblock->sectorv[0]->flags;
> +	u64 have_csum = original_sblock->sectorv[0]->have_csum;
>  	struct scrub_recover *recover;
>  	struct btrfs_io_context *bioc;
>  	u64 sublen;
>  	u64 mapped_length;
>  	u64 stripe_offset;
>  	int stripe_index;
> -	int page_index = 0;
> +	int sector_index = 0;
>  	int mirror_index;
>  	int nmirrors;
>  	int ret;
> @@ -1306,7 +1306,7 @@ static int scrub_setup_recheck_block(struct scrub_block *original_sblock,
>  		recover->bioc = bioc;
>  		recover->map_length = mapped_length;
>  
> -		ASSERT(page_index < SCRUB_MAX_PAGES_PER_BLOCK);
> +		ASSERT(sector_index < SCRUB_MAX_SECTORS_PER_BLOCK);
>  
>  		nmirrors = min(scrub_nr_raid_mirrors(bioc), BTRFS_MAX_MIRRORS);
>  
> @@ -1328,7 +1328,7 @@ static int scrub_setup_recheck_block(struct scrub_block *original_sblock,
>  				return -ENOMEM;
>  			}
>  			scrub_page_get(spage);
> -			sblock->pagev[page_index] = spage;
> +			sblock->sectorv[sector_index] = spage;
>  			spage->sblock = sblock;
>  			spage->flags = flags;
>  			spage->generation = generation;
> @@ -1336,7 +1336,7 @@ static int scrub_setup_recheck_block(struct scrub_block *original_sblock,
>  			spage->have_csum = have_csum;
>  			if (have_csum)
>  				memcpy(spage->csum,
> -				       original_sblock->pagev[0]->csum,
> +				       original_sblock->sectorv[0]->csum,
>  				       sctx->fs_info->csum_size);
>  
>  			scrub_stripe_index_and_offset(logical,
> @@ -1352,13 +1352,13 @@ static int scrub_setup_recheck_block(struct scrub_block *original_sblock,
>  					 stripe_offset;
>  			spage->dev = bioc->stripes[stripe_index].dev;
>  
> -			BUG_ON(page_index >= original_sblock->page_count);
> +			BUG_ON(sector_index >= original_sblock->sector_count);
>  			spage->physical_for_dev_replace =
> -				original_sblock->pagev[page_index]->
> +				original_sblock->sectorv[sector_index]->
>  				physical_for_dev_replace;
>  			/* for missing devices, dev->bdev is NULL */
>  			spage->mirror_num = mirror_index + 1;
> -			sblock->page_count++;
> +			sblock->sector_count++;
>  			spage->page = alloc_page(GFP_NOFS);
>  			if (!spage->page)
>  				goto leave_nomem;
> @@ -1369,7 +1369,7 @@ static int scrub_setup_recheck_block(struct scrub_block *original_sblock,
>  		scrub_put_recover(fs_info, recover);
>  		length -= sublen;
>  		logical += sublen;
> -		page_index++;
> +		sector_index++;
>  	}
>  
>  	return 0;
> @@ -1392,7 +1392,7 @@ static int scrub_submit_raid56_bio_wait(struct btrfs_fs_info *fs_info,
>  	bio->bi_private = &done;
>  	bio->bi_end_io = scrub_bio_wait_endio;
>  
> -	mirror_num = spage->sblock->pagev[0]->mirror_num;
> +	mirror_num = spage->sblock->sectorv[0]->mirror_num;
>  	ret = raid56_parity_recover(bio, spage->recover->bioc,
>  				    spage->recover->map_length,
>  				    mirror_num, 0);
> @@ -1406,9 +1406,9 @@ static int scrub_submit_raid56_bio_wait(struct btrfs_fs_info *fs_info,
>  static void scrub_recheck_block_on_raid56(struct btrfs_fs_info *fs_info,
>  					  struct scrub_block *sblock)
>  {
> -	struct scrub_page *first_page = sblock->pagev[0];
> +	struct scrub_page *first_page = sblock->sectorv[0];
>  	struct bio *bio;
> -	int page_num;
> +	int sector_num;

Also 'i'

>  	/* All pages in sblock belong to the same stripe on the same device. */
>  	ASSERT(first_page->dev);
> @@ -1418,8 +1418,8 @@ static void scrub_recheck_block_on_raid56(struct btrfs_fs_info *fs_info,
>  	bio = btrfs_bio_alloc(BIO_MAX_VECS);
>  	bio_set_dev(bio, first_page->dev->bdev);
>  
> -	for (page_num = 0; page_num < sblock->page_count; page_num++) {
> -		struct scrub_page *spage = sblock->pagev[page_num];
> +	for (sector_num = 0; sector_num < sblock->sector_count; sector_num++) {
> +		struct scrub_page *spage = sblock->sectorv[sector_num];
>  
>  		WARN_ON(!spage->page);
>  		bio_add_page(bio, spage->page, PAGE_SIZE, 0);
> @@ -1436,8 +1436,8 @@ static void scrub_recheck_block_on_raid56(struct btrfs_fs_info *fs_info,
>  
>  	return;
>  out:
> -	for (page_num = 0; page_num < sblock->page_count; page_num++)
> -		sblock->pagev[page_num]->io_error = 1;
> +	for (sector_num = 0; sector_num < sblock->sector_count; sector_num++)
> +		sblock->sectorv[sector_num]->io_error = 1;
>  
>  	sblock->no_io_error_seen = 0;
>  }
> @@ -1453,17 +1453,17 @@ static void scrub_recheck_block(struct btrfs_fs_info *fs_info,
>  				struct scrub_block *sblock,
>  				int retry_failed_mirror)
>  {
> -	int page_num;
> +	int sector_num;

And here too

>  	sblock->no_io_error_seen = 1;
>  
>  	/* short cut for raid56 */
> -	if (!retry_failed_mirror && scrub_is_page_on_raid56(sblock->pagev[0]))
> +	if (!retry_failed_mirror && scrub_is_page_on_raid56(sblock->sectorv[0]))
>  		return scrub_recheck_block_on_raid56(fs_info, sblock);
>  
> -	for (page_num = 0; page_num < sblock->page_count; page_num++) {
> +	for (sector_num = 0; sector_num < sblock->sector_count; sector_num++) {
>  		struct bio *bio;
> -		struct scrub_page *spage = sblock->pagev[page_num];
> +		struct scrub_page *spage = sblock->sectorv[sector_num];
>  
>  		if (spage->dev->bdev == NULL) {
>  			spage->io_error = 1;
> @@ -1507,7 +1507,7 @@ static void scrub_recheck_block_checksum(struct scrub_block *sblock)
>  	sblock->checksum_error = 0;
>  	sblock->generation_error = 0;
>  
> -	if (sblock->pagev[0]->flags & BTRFS_EXTENT_FLAG_DATA)
> +	if (sblock->sectorv[0]->flags & BTRFS_EXTENT_FLAG_DATA)
>  		scrub_checksum_data(sblock);
>  	else
>  		scrub_checksum_tree_block(sblock);
> @@ -1516,15 +1516,15 @@ static void scrub_recheck_block_checksum(struct scrub_block *sblock)
>  static int scrub_repair_block_from_good_copy(struct scrub_block *sblock_bad,
>  					     struct scrub_block *sblock_good)
>  {
> -	int page_num;
> +	int sector_num;

i

>  	int ret = 0;
>  
> -	for (page_num = 0; page_num < sblock_bad->page_count; page_num++) {
> +	for (sector_num = 0; sector_num < sblock_bad->sector_count; sector_num++) {
>  		int ret_sub;
>  
>  		ret_sub = scrub_repair_page_from_good_copy(sblock_bad,
>  							   sblock_good,
> -							   page_num, 1);
> +							   sector_num, 1);
>  		if (ret_sub)
>  			ret = ret_sub;
>  	}
> @@ -1534,10 +1534,10 @@ static int scrub_repair_block_from_good_copy(struct scrub_block *sblock_bad,
>  
>  static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,
>  					    struct scrub_block *sblock_good,
> -					    int page_num, int force_write)
> +					    int sector_num, int force_write)
>  {
> -	struct scrub_page *spage_bad = sblock_bad->pagev[page_num];
> -	struct scrub_page *spage_good = sblock_good->pagev[page_num];
> +	struct scrub_page *spage_bad = sblock_bad->sectorv[sector_num];
> +	struct scrub_page *spage_good = sblock_good->sectorv[sector_num];
>  	struct btrfs_fs_info *fs_info = sblock_bad->sctx->fs_info;
>  	const u32 sectorsize = fs_info->sectorsize;
>  
> @@ -1581,7 +1581,7 @@ static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,
>  static void scrub_write_block_to_dev_replace(struct scrub_block *sblock)
>  {
>  	struct btrfs_fs_info *fs_info = sblock->sctx->fs_info;
> -	int page_num;
> +	int sector_num;

i

>  	/*
>  	 * This block is used for the check of the parity on the source device,
> @@ -1590,19 +1590,19 @@ static void scrub_write_block_to_dev_replace(struct scrub_block *sblock)
>  	if (sblock->sparity)
>  		return;
>  
> -	for (page_num = 0; page_num < sblock->page_count; page_num++) {
> +	for (sector_num = 0; sector_num < sblock->sector_count; sector_num++) {
>  		int ret;
>  
> -		ret = scrub_write_page_to_dev_replace(sblock, page_num);
> +		ret = scrub_write_page_to_dev_replace(sblock, sector_num);
>  		if (ret)
>  			atomic64_inc(&fs_info->dev_replace.num_write_errors);
>  	}
>  }
>  
>  static int scrub_write_page_to_dev_replace(struct scrub_block *sblock,
> -					   int page_num)
> +					   int sector_num)
>  {
> -	struct scrub_page *spage = sblock->pagev[page_num];
> +	struct scrub_page *spage = sblock->sectorv[sector_num];
>  
>  	BUG_ON(spage->page == NULL);
>  	if (spage->io_error)
> @@ -1786,8 +1786,8 @@ static int scrub_checksum(struct scrub_block *sblock)
>  	sblock->generation_error = 0;
>  	sblock->checksum_error = 0;
>  
> -	WARN_ON(sblock->page_count < 1);
> -	flags = sblock->pagev[0]->flags;
> +	WARN_ON(sblock->sector_count < 1);
> +	flags = sblock->sectorv[0]->flags;
>  	ret = 0;
>  	if (flags & BTRFS_EXTENT_FLAG_DATA)
>  		ret = scrub_checksum_data(sblock);
> @@ -1812,8 +1812,8 @@ static int scrub_checksum_data(struct scrub_block *sblock)
>  	struct scrub_page *spage;
>  	char *kaddr;
>  
> -	BUG_ON(sblock->page_count < 1);
> -	spage = sblock->pagev[0];
> +	BUG_ON(sblock->sector_count < 1);
> +	spage = sblock->sectorv[0];
>  	if (!spage->have_csum)
>  		return 0;
>  
> @@ -1852,12 +1852,12 @@ static int scrub_checksum_tree_block(struct scrub_block *sblock)
>  	struct scrub_page *spage;
>  	char *kaddr;
>  
> -	BUG_ON(sblock->page_count < 1);
> +	BUG_ON(sblock->sector_count < 1);
>  
> -	/* Each member in pagev is just one block, not a full page */
> -	ASSERT(sblock->page_count == num_sectors);
> +	/* Each member in pagev is just one sector , not a full page */
> +	ASSERT(sblock->sector_count == num_sectors);
>  
> -	spage = sblock->pagev[0];
> +	spage = sblock->sectorv[0];
>  	kaddr = page_address(spage->page);
>  	h = (struct btrfs_header *)kaddr;
>  	memcpy(on_disk_csum, h->csum, sctx->fs_info->csum_size);
> @@ -1888,7 +1888,7 @@ static int scrub_checksum_tree_block(struct scrub_block *sblock)
>  			    sectorsize - BTRFS_CSUM_SIZE);
>  
>  	for (i = 1; i < num_sectors; i++) {
> -		kaddr = page_address(sblock->pagev[i]->page);
> +		kaddr = page_address(sblock->sectorv[i]->page);
>  		crypto_shash_update(shash, kaddr, sectorsize);
>  	}
>  
> @@ -1911,8 +1911,8 @@ static int scrub_checksum_super(struct scrub_block *sblock)
>  	int fail_gen = 0;
>  	int fail_cor = 0;
>  
> -	BUG_ON(sblock->page_count < 1);
> -	spage = sblock->pagev[0];
> +	BUG_ON(sblock->sector_count < 1);
> +	spage = sblock->sectorv[0];
>  	kaddr = page_address(spage->page);
>  	s = (struct btrfs_super_block *)kaddr;
>  
> @@ -1966,8 +1966,8 @@ static void scrub_block_put(struct scrub_block *sblock)
>  		if (sblock->sparity)
>  			scrub_parity_put(sblock->sparity);
>  
> -		for (i = 0; i < sblock->page_count; i++)
> -			scrub_page_put(sblock->pagev[i]);
> +		for (i = 0; i < sblock->sector_count; i++)
> +			scrub_page_put(sblock->sectorv[i]);
>  		kfree(sblock);
>  	}
>  }
> @@ -2155,8 +2155,8 @@ static void scrub_missing_raid56_worker(struct btrfs_work *work)
>  	u64 logical;
>  	struct btrfs_device *dev;
>  
> -	logical = sblock->pagev[0]->logical;
> -	dev = sblock->pagev[0]->dev;
> +	logical = sblock->sectorv[0]->logical;
> +	dev = sblock->sectorv[0]->dev;
>  
>  	if (sblock->no_io_error_seen)
>  		scrub_recheck_block_checksum(sblock);
> @@ -2193,8 +2193,8 @@ static void scrub_missing_raid56_pages(struct scrub_block *sblock)
>  {
>  	struct scrub_ctx *sctx = sblock->sctx;
>  	struct btrfs_fs_info *fs_info = sctx->fs_info;
> -	u64 length = sblock->page_count * PAGE_SIZE;
> -	u64 logical = sblock->pagev[0]->logical;
> +	u64 length = sblock->sector_count * fs_info->sectorsize;
> +	u64 logical = sblock->sectorv[0]->logical;
>  	struct btrfs_io_context *bioc = NULL;
>  	struct bio *bio;
>  	struct btrfs_raid_bio *rbio;
> @@ -2227,8 +2227,8 @@ static void scrub_missing_raid56_pages(struct scrub_block *sblock)
>  	if (!rbio)
>  		goto rbio_out;
>  
> -	for (i = 0; i < sblock->page_count; i++) {
> -		struct scrub_page *spage = sblock->pagev[i];
> +	for (i = 0; i < sblock->sector_count; i++) {
> +		struct scrub_page *spage = sblock->sectorv[i];
>  
>  		raid56_add_scrub_pages(rbio, spage->page, spage->logical);
>  	}
> @@ -2290,9 +2290,9 @@ static int scrub_pages(struct scrub_ctx *sctx, u64 logical, u32 len,
>  			scrub_block_put(sblock);
>  			return -ENOMEM;
>  		}
> -		ASSERT(index < SCRUB_MAX_PAGES_PER_BLOCK);
> +		ASSERT(index < SCRUB_MAX_SECTORS_PER_BLOCK);
>  		scrub_page_get(spage);
> -		sblock->pagev[index] = spage;
> +		sblock->sectorv[index] = spage;
>  		spage->sblock = sblock;
>  		spage->dev = dev;
>  		spage->flags = flags;
> @@ -2307,7 +2307,7 @@ static int scrub_pages(struct scrub_ctx *sctx, u64 logical, u32 len,
>  		} else {
>  			spage->have_csum = 0;
>  		}
> -		sblock->page_count++;
> +		sblock->sector_count++;
>  		spage->page = alloc_page(GFP_KERNEL);
>  		if (!spage->page)
>  			goto leave_nomem;
> @@ -2317,7 +2317,7 @@ static int scrub_pages(struct scrub_ctx *sctx, u64 logical, u32 len,
>  		physical_for_dev_replace += l;
>  	}
>  
> -	WARN_ON(sblock->page_count == 0);
> +	WARN_ON(sblock->sector_count == 0);
>  	if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state)) {
>  		/*
>  		 * This case should only be hit for RAID 5/6 device replace. See
> @@ -2325,8 +2325,8 @@ static int scrub_pages(struct scrub_ctx *sctx, u64 logical, u32 len,
>  		 */
>  		scrub_missing_raid56_pages(sblock);
>  	} else {
> -		for (index = 0; index < sblock->page_count; index++) {
> -			struct scrub_page *spage = sblock->pagev[index];
> +		for (index = 0; index < sblock->sector_count; index++) {
> +			struct scrub_page *spage = sblock->sectorv[index];
>  			int ret;
>  
>  			ret = scrub_add_page_to_rd_bio(sctx, spage);
> @@ -2456,8 +2456,8 @@ static void scrub_block_complete(struct scrub_block *sblock)
>  	}
>  
>  	if (sblock->sparity && corrupted && !sblock->data_corrected) {
> -		u64 start = sblock->pagev[0]->logical;
> -		u64 end = sblock->pagev[sblock->page_count - 1]->logical +
> +		u64 start = sblock->sectorv[0]->logical;
> +		u64 end = sblock->sectorv[sblock->sector_count - 1]->logical +
>  			  sblock->sctx->fs_info->sectorsize;
>  
>  		ASSERT(end - start <= U32_MAX);
> @@ -2624,10 +2624,10 @@ static int scrub_pages_for_parity(struct scrub_parity *sparity,
>  			scrub_block_put(sblock);
>  			return -ENOMEM;
>  		}
> -		ASSERT(index < SCRUB_MAX_PAGES_PER_BLOCK);
> +		ASSERT(index < SCRUB_MAX_SECTORS_PER_BLOCK);
>  		/* For scrub block */
>  		scrub_page_get(spage);
> -		sblock->pagev[index] = spage;
> +		sblock->sectorv[index] = spage;
>  		/* For scrub parity */
>  		scrub_page_get(spage);
>  		list_add_tail(&spage->list, &sparity->spages);
> @@ -2644,7 +2644,7 @@ static int scrub_pages_for_parity(struct scrub_parity *sparity,
>  		} else {
>  			spage->have_csum = 0;
>  		}
> -		sblock->page_count++;
> +		sblock->sector_count++;
>  		spage->page = alloc_page(GFP_KERNEL);
>  		if (!spage->page)
>  			goto leave_nomem;
> @@ -2656,9 +2656,9 @@ static int scrub_pages_for_parity(struct scrub_parity *sparity,
>  		physical += sectorsize;
>  	}
>  
> -	WARN_ON(sblock->page_count == 0);
> -	for (index = 0; index < sblock->page_count; index++) {
> -		struct scrub_page *spage = sblock->pagev[index];
> +	WARN_ON(sblock->sector_count == 0);
> +	for (index = 0; index < sblock->sector_count; index++) {
> +		struct scrub_page *spage = sblock->sectorv[index];
>  		int ret;
>  
>  		ret = scrub_add_page_to_rd_bio(sctx, spage);
> @@ -4058,18 +4058,18 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
>  	}
>  
>  	if (fs_info->nodesize >
> -	    PAGE_SIZE * SCRUB_MAX_PAGES_PER_BLOCK ||
> -	    fs_info->sectorsize > PAGE_SIZE * SCRUB_MAX_PAGES_PER_BLOCK) {
> +	    SCRUB_MAX_SECTORS_PER_BLOCK * fs_info->sectorsize ||
> +	    fs_info->sectorsize > PAGE_SIZE * SCRUB_MAX_SECTORS_PER_BLOCK) {
>  		/*
>  		 * would exhaust the array bounds of pagev member in
>  		 * struct scrub_block
>  		 */
>  		btrfs_err(fs_info,
> -			  "scrub: size assumption nodesize and sectorsize <= SCRUB_MAX_PAGES_PER_BLOCK (%d <= %d && %d <= %d) fails",
> +			  "scrub: size assumption nodesize and sectorsize <= SCRUB_MAX_SECTORS_PER_BLOCK (%d <= %d && %d <= %d) fails",
>  		       fs_info->nodesize,
> -		       SCRUB_MAX_PAGES_PER_BLOCK,
> +		       SCRUB_MAX_SECTORS_PER_BLOCK,
>  		       fs_info->sectorsize,
> -		       SCRUB_MAX_PAGES_PER_BLOCK);
> +		       SCRUB_MAX_SECTORS_PER_BLOCK);
>  		return -EINVAL;
>  	}
>  
> -- 
> 2.35.1