Date:   Mon, 6 Mar 2023 15:16:06 +0800
From:   Yue Hu <zbestahu@gmail.com>
To:     Jingbo Xu <jefflexu@linux.alibaba.com>
Cc:     xiang@kernel.org, chao@kernel.org, linux-erofs@lists.ozlabs.org,
        linux-kernel@vger.kernel.org, huyue2@coolpad.com,
        zhangwen@coolpad.com
Subject: Re: [PATCH v4 1/2] erofs: avoid hardcoded blocksize for subpage
 block support
Message-ID: <20230306151606.00000ebd.zbestahu@gmail.com>
In-Reply-To: <20230302143915.111739-2-jefflexu@linux.alibaba.com>
References: <20230302143915.111739-1-jefflexu@linux.alibaba.com>
        <20230302143915.111739-2-jefflexu@linux.alibaba.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Precedence: bulk

On Thu,  2 Mar 2023 22:39:14 +0800
Jingbo Xu <jefflexu@linux.alibaba.com> wrote:

> As the first step of converting hardcoded blocksize to that specified in
> on-disk superblock, convert all call sites of hardcoded blocksize to
> sb->s_blocksize except for:
> 
> 1) use sbi->blkszbits instead of sb->s_blocksize in
> erofs_superblock_csum_verify() since sb->s_blocksize has not been
> updated with the on-disk blocksize yet when the function is called.
> 
> 2) use inode->i_blkbits instead of sb->s_blocksize in erofs_bread(),
> since the inode operated on may be an anonymous inode in fscache mode.
> Currently the anonymous inode is allocated from an anonymous mount
> maintained in erofs, while in the near future we may allocate anonymous
> inodes from a generic API directly and thus have no access to the
> anonymous inode's i_sb.  Thus we keep the block size in i_blkbits for
> anonymous inodes in fscache mode.
> 
> Be noted that this patch only gets rid of the hardcoded blocksize, in
> preparation for actually setting the on-disk block size in the following
> patch.  The hard limit of constraining the block size to PAGE_SIZE still
> exists until the next patch.
> 
> Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com>
> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com>
> ---
>  fs/erofs/data.c              | 50 +++++++++++++++++++-----------------
>  fs/erofs/decompressor.c      |  6 ++---
>  fs/erofs/decompressor_lzma.c |  4 +--
>  fs/erofs/dir.c               | 22 ++++++++--------
>  fs/erofs/fscache.c           |  5 ++--
>  fs/erofs/inode.c             | 20 ++++++++-------
>  fs/erofs/internal.h          | 20 +++++----------
>  fs/erofs/namei.c             | 14 +++++-----
>  fs/erofs/super.c             | 24 +++++++++--------
>  fs/erofs/xattr.c             | 40 ++++++++++++++---------------
>  fs/erofs/xattr.h             | 10 ++++----
>  fs/erofs/zdata.c             | 18 +++++++------
>  fs/erofs/zmap.c              | 29 +++++++++++----------
>  include/trace/events/erofs.h |  4 +--
>  14 files changed, 134 insertions(+), 132 deletions(-)
> 
> diff --git a/fs/erofs/data.c b/fs/erofs/data.c
> index 032e12dccb84..01a0a59feac9 100644
> --- a/fs/erofs/data.c
> +++ b/fs/erofs/data.c
> @@ -27,11 +27,15 @@ void erofs_put_metabuf(struct erofs_buf *buf)
>  	buf->page = NULL;
>  }
>  
> +/*
> + * Derive the block size from inode->i_blkbits to make compatible with
> + * anonymous inode in fscache mode.
> + */
>  void *erofs_bread(struct erofs_buf *buf, struct inode *inode,
>  		  erofs_blk_t blkaddr, enum erofs_kmap_type type)
>  {
> +	erofs_off_t offset = blkaddr << inode->i_blkbits;
>  	struct address_space *const mapping = inode->i_mapping;
> -	erofs_off_t offset = blknr_to_addr(blkaddr);
>  	pgoff_t index = offset >> PAGE_SHIFT;
>  	struct page *page = buf->page;
>  	struct folio *folio;
> @@ -79,33 +83,32 @@ static int erofs_map_blocks_flatmode(struct inode *inode,
>  	erofs_blk_t nblocks, lastblk;
>  	u64 offset = map->m_la;
>  	struct erofs_inode *vi = EROFS_I(inode);
> +	struct super_block *sb = inode->i_sb;
>  	bool tailendpacking = (vi->datalayout == EROFS_INODE_FLAT_INLINE);
>  
> -	nblocks = DIV_ROUND_UP(inode->i_size, EROFS_BLKSIZ);
> +	nblocks = erofs_iblks(inode);
>  	lastblk = nblocks - tailendpacking;
>  
>  	/* there is no hole in flatmode */
>  	map->m_flags = EROFS_MAP_MAPPED;
> -	if (offset < blknr_to_addr(lastblk)) {
> -		map->m_pa = blknr_to_addr(vi->raw_blkaddr) + map->m_la;
> -		map->m_plen = blknr_to_addr(lastblk) - offset;
> +	if (offset < erofs_pos(sb, lastblk)) {
> +		map->m_pa = erofs_pos(sb, vi->raw_blkaddr) + map->m_la;
> +		map->m_plen = erofs_pos(sb, lastblk) - offset;
>  	} else if (tailendpacking) {
>  		map->m_pa = erofs_iloc(inode) + vi->inode_isize +
> -			vi->xattr_isize + erofs_blkoff(offset);
> +			vi->xattr_isize + erofs_blkoff(sb, offset);
>  		map->m_plen = inode->i_size - offset;
>  
>  		/* inline data should be located in the same meta block */
> -		if (erofs_blkoff(map->m_pa) + map->m_plen > EROFS_BLKSIZ) {
> -			erofs_err(inode->i_sb,
> -				  "inline data cross block boundary @ nid %llu",
> +		if (erofs_blkoff(sb, map->m_pa) + map->m_plen > sb->s_blocksize) {
> +			erofs_err(sb, "inline data cross block boundary @ nid %llu",
>  				  vi->nid);
>  			DBG_BUGON(1);
>  			return -EFSCORRUPTED;
>  		}
>  		map->m_flags |= EROFS_MAP_META;
>  	} else {
> -		erofs_err(inode->i_sb,
> -			  "internal error @ nid: %llu (size %llu), m_la 0x%llx",
> +		erofs_err(sb, "internal error @ nid: %llu (size %llu), m_la 0x%llx",
>  			  vi->nid, inode->i_size, map->m_la);
>  		DBG_BUGON(1);
>  		return -EIO;
> @@ -148,29 +151,29 @@ int erofs_map_blocks(struct inode *inode, struct erofs_map_blocks *map)
>  	pos = ALIGN(erofs_iloc(inode) + vi->inode_isize +
>  		    vi->xattr_isize, unit) + unit * chunknr;
>  
> -	kaddr = erofs_read_metabuf(&buf, sb, erofs_blknr(pos), EROFS_KMAP);
> +	kaddr = erofs_read_metabuf(&buf, sb, erofs_blknr(sb, pos), EROFS_KMAP);
>  	if (IS_ERR(kaddr)) {
>  		err = PTR_ERR(kaddr);
>  		goto out;
>  	}
>  	map->m_la = chunknr << vi->chunkbits;
>  	map->m_plen = min_t(erofs_off_t, 1UL << vi->chunkbits,
> -			    roundup(inode->i_size - map->m_la, EROFS_BLKSIZ));
> +			round_up(inode->i_size - map->m_la, sb->s_blocksize));
>  
>  	/* handle block map */
>  	if (!(vi->chunkformat & EROFS_CHUNK_FORMAT_INDEXES)) {
> -		__le32 *blkaddr = kaddr + erofs_blkoff(pos);
> +		__le32 *blkaddr = kaddr + erofs_blkoff(sb, pos);
>  
>  		if (le32_to_cpu(*blkaddr) == EROFS_NULL_ADDR) {
>  			map->m_flags = 0;
>  		} else {
> -			map->m_pa = blknr_to_addr(le32_to_cpu(*blkaddr));
> +			map->m_pa = erofs_pos(sb, le32_to_cpu(*blkaddr));
>  			map->m_flags = EROFS_MAP_MAPPED;
>  		}
>  		goto out_unlock;
>  	}
>  	/* parse chunk indexes */
> -	idx = kaddr + erofs_blkoff(pos);
> +	idx = kaddr + erofs_blkoff(sb, pos);
>  	switch (le32_to_cpu(idx->blkaddr)) {
>  	case EROFS_NULL_ADDR:
>  		map->m_flags = 0;
> @@ -178,7 +181,7 @@ int erofs_map_blocks(struct inode *inode, struct erofs_map_blocks *map)
>  	default:
>  		map->m_deviceid = le16_to_cpu(idx->device_id) &
>  			EROFS_SB(sb)->device_id_mask;
> -		map->m_pa = blknr_to_addr(le32_to_cpu(idx->blkaddr));
> +		map->m_pa = erofs_pos(sb, le32_to_cpu(idx->blkaddr));
>  		map->m_flags = EROFS_MAP_MAPPED;
>  		break;
>  	}
> @@ -222,8 +225,8 @@ int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *map)
>  
>  			if (!dif->mapped_blkaddr)
>  				continue;
> -			startoff = blknr_to_addr(dif->mapped_blkaddr);
> -			length = blknr_to_addr(dif->blocks);
> +			startoff = erofs_pos(sb, dif->mapped_blkaddr);
> +			length = erofs_pos(sb, dif->blocks);
>  
>  			if (map->m_pa >= startoff &&
>  			    map->m_pa < startoff + length) {
> @@ -244,6 +247,7 @@ static int erofs_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
>  		unsigned int flags, struct iomap *iomap, struct iomap *srcmap)
>  {
>  	int ret;
> +	struct super_block *sb = inode->i_sb;
>  	struct erofs_map_blocks map;
>  	struct erofs_map_dev mdev;
>  
> @@ -258,7 +262,7 @@ static int erofs_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
>  		.m_deviceid = map.m_deviceid,
>  		.m_pa = map.m_pa,
>  	};
> -	ret = erofs_map_dev(inode->i_sb, &mdev);
> +	ret = erofs_map_dev(sb, &mdev);
>  	if (ret)
>  		return ret;
>  
> @@ -284,11 +288,11 @@ static int erofs_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
>  		struct erofs_buf buf = __EROFS_BUF_INITIALIZER;
>  
>  		iomap->type = IOMAP_INLINE;
> -		ptr = erofs_read_metabuf(&buf, inode->i_sb,
> -					 erofs_blknr(mdev.m_pa), EROFS_KMAP);
> +		ptr = erofs_read_metabuf(&buf, sb,
> +				erofs_blknr(sb, mdev.m_pa), EROFS_KMAP);
>  		if (IS_ERR(ptr))
>  			return PTR_ERR(ptr);
> -		iomap->inline_data = ptr + erofs_blkoff(mdev.m_pa);
> +		iomap->inline_data = ptr + erofs_blkoff(sb, mdev.m_pa);
>  		iomap->private = buf.base;
>  	} else {
>  		iomap->type = IOMAP_MAPPED;
> diff --git a/fs/erofs/decompressor.c b/fs/erofs/decompressor.c
> index 51b7ac7166d9..21fc6897d225 100644
> --- a/fs/erofs/decompressor.c
> +++ b/fs/erofs/decompressor.c
> @@ -42,7 +42,7 @@ int z_erofs_load_lz4_config(struct super_block *sb,
>  		if (!sbi->lz4.max_pclusterblks) {
>  			sbi->lz4.max_pclusterblks = 1;	/* reserved case */
>  		} else if (sbi->lz4.max_pclusterblks >
> -			   Z_EROFS_PCLUSTER_MAX_SIZE / EROFS_BLKSIZ) {
> +			   Z_EROFS_PCLUSTER_MAX_SIZE >> sb->s_blocksize_bits) {

erofs_blknr(sb, Z_EROFS_PCLUSTER_MAX_SIZE)?

>  			erofs_err(sb, "too large lz4 pclusterblks %u",
>  				  sbi->lz4.max_pclusterblks);
>  			return -EINVAL;
> @@ -221,13 +221,13 @@ static int z_erofs_lz4_decompress_mem(struct z_erofs_lz4_decompress_ctx *ctx,
>  		support_0padding = true;
>  		ret = z_erofs_fixup_insize(rq, headpage + rq->pageofs_in,
>  				min_t(unsigned int, rq->inputsize,
> -				      EROFS_BLKSIZ - rq->pageofs_in));
> +				      rq->sb->s_blocksize - rq->pageofs_in));
>  		if (ret) {
>  			kunmap_atomic(headpage);
>  			return ret;
>  		}
>  		may_inplace = !((rq->pageofs_in + rq->inputsize) &
> -				(EROFS_BLKSIZ - 1));
> +				(rq->sb->s_blocksize - 1));
>  	}
>  
>  	inputmargin = rq->pageofs_in;
> diff --git a/fs/erofs/decompressor_lzma.c b/fs/erofs/decompressor_lzma.c
> index 091fd5adf818..d44c377c5b69 100644
> --- a/fs/erofs/decompressor_lzma.c
> +++ b/fs/erofs/decompressor_lzma.c
> @@ -166,8 +166,8 @@ int z_erofs_lzma_decompress(struct z_erofs_decompress_req *rq,
>  	/* 1. get the exact LZMA compressed size */
>  	kin = kmap(*rq->in);
>  	err = z_erofs_fixup_insize(rq, kin + rq->pageofs_in,
> -				   min_t(unsigned int, rq->inputsize,
> -					 EROFS_BLKSIZ - rq->pageofs_in));
> +			min_t(unsigned int, rq->inputsize,
> +			      rq->sb->s_blocksize - rq->pageofs_in));
>  	if (err) {
>  		kunmap(*rq->in);
>  		return err;
> diff --git a/fs/erofs/dir.c b/fs/erofs/dir.c
> index 6970b09b8307..963bbed0b699 100644
> --- a/fs/erofs/dir.c
> +++ b/fs/erofs/dir.c
> @@ -50,9 +50,11 @@ static int erofs_readdir(struct file *f, struct dir_context *ctx)
>  {
>  	struct inode *dir = file_inode(f);
>  	struct erofs_buf buf = __EROFS_BUF_INITIALIZER;
> +	struct super_block *sb = dir->i_sb;
> +	unsigned long bsz = sb->s_blocksize;
>  	const size_t dirsize = i_size_read(dir);
> -	unsigned int i = ctx->pos / EROFS_BLKSIZ;
> -	unsigned int ofs = ctx->pos % EROFS_BLKSIZ;
> +	unsigned int i = erofs_blknr(sb, ctx->pos);
> +	unsigned int ofs = erofs_blkoff(sb, ctx->pos);
>  	int err = 0;
>  	bool initial = true;
>  
> @@ -62,32 +64,28 @@ static int erofs_readdir(struct file *f, struct dir_context *ctx)
>  
>  		de = erofs_bread(&buf, dir, i, EROFS_KMAP);
>  		if (IS_ERR(de)) {
> -			erofs_err(dir->i_sb,
> -				  "fail to readdir of logical block %u of nid %llu",
> +			erofs_err(sb, "fail to readdir of logical block %u of nid %llu",
>  				  i, EROFS_I(dir)->nid);
>  			err = PTR_ERR(de);
>  			break;
>  		}
>  
>  		nameoff = le16_to_cpu(de->nameoff);
> -		if (nameoff < sizeof(struct erofs_dirent) ||
> -		    nameoff >= EROFS_BLKSIZ) {
> -			erofs_err(dir->i_sb,
> -				  "invalid de[0].nameoff %u @ nid %llu",
> +		if (nameoff < sizeof(struct erofs_dirent) || nameoff >= bsz) {
> +			erofs_err(sb, "invalid de[0].nameoff %u @ nid %llu",
>  				  nameoff, EROFS_I(dir)->nid);
>  			err = -EFSCORRUPTED;
>  			break;
>  		}
>  
> -		maxsize = min_t(unsigned int,
> -				dirsize - ctx->pos + ofs, EROFS_BLKSIZ);
> +		maxsize = min_t(unsigned int, dirsize - ctx->pos + ofs, bsz);
>  
>  		/* search dirents at the arbitrary position */
>  		if (initial) {
>  			initial = false;
>  
>  			ofs = roundup(ofs, sizeof(struct erofs_dirent));
> -			ctx->pos = blknr_to_addr(i) + ofs;
> +			ctx->pos = erofs_pos(sb, i) + ofs;
>  			if (ofs >= nameoff)
>  				goto skip_this;
>  		}
> @@ -97,7 +95,7 @@ static int erofs_readdir(struct file *f, struct dir_context *ctx)
>  		if (err)
>  			break;
>  skip_this:
> -		ctx->pos = blknr_to_addr(i) + maxsize;
> +		ctx->pos = erofs_pos(sb, i) + maxsize;
>  		++i;
>  		ofs = 0;
>  	}
> diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c
> index 8e9170c777d8..f7a1e147d0f4 100644
> --- a/fs/erofs/fscache.c
> +++ b/fs/erofs/fscache.c
> @@ -218,8 +218,8 @@ static int erofs_fscache_data_read_slice(struct erofs_fscache_request *primary)
>  		void *src;
>  
>  		/* For tail packing layout, the offset may be non-zero. */
> -		offset = erofs_blkoff(map.m_pa);
> -		blknr = erofs_blknr(map.m_pa);
> +		offset = erofs_blkoff(sb, map.m_pa);
> +		blknr = erofs_blknr(sb, map.m_pa);
>  		size = map.m_llen;
>  
>  		src = erofs_read_metabuf(&buf, sb, blknr, EROFS_KMAP);
> @@ -469,6 +469,7 @@ static struct erofs_fscache *erofs_fscache_acquire_cookie(struct super_block *sb
>  	inode->i_size = OFFSET_MAX;
>  	inode->i_mapping->a_ops = &erofs_fscache_meta_aops;
>  	mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
> +	inode->i_blkbits = EROFS_SB(sb)->blkszbits;
>  	inode->i_private = ctx;
>  
>  	ctx->cookie = cookie;
> diff --git a/fs/erofs/inode.c b/fs/erofs/inode.c
> index d7e87d41f7bf..de26dac4e07e 100644
> --- a/fs/erofs/inode.c
> +++ b/fs/erofs/inode.c
> @@ -23,8 +23,8 @@ static void *erofs_read_inode(struct erofs_buf *buf,
>  	unsigned int ifmt;
>  	int err;
>  
> -	blkaddr = erofs_blknr(inode_loc);
> -	*ofs = erofs_blkoff(inode_loc);
> +	blkaddr = erofs_blknr(sb, inode_loc);
> +	*ofs = erofs_blkoff(sb, inode_loc);
>  
>  	erofs_dbg("%s, reading inode nid %llu at %u of blkaddr %u",
>  		  __func__, vi->nid, *ofs, blkaddr);
> @@ -58,11 +58,11 @@ static void *erofs_read_inode(struct erofs_buf *buf,
>  	case EROFS_INODE_LAYOUT_EXTENDED:
>  		vi->inode_isize = sizeof(struct erofs_inode_extended);
>  		/* check if the extended inode acrosses block boundary */
> -		if (*ofs + vi->inode_isize <= EROFS_BLKSIZ) {
> +		if (*ofs + vi->inode_isize <= sb->s_blocksize) {
>  			*ofs += vi->inode_isize;
>  			die = (struct erofs_inode_extended *)dic;
>  		} else {
> -			const unsigned int gotten = EROFS_BLKSIZ - *ofs;
> +			const unsigned int gotten = sb->s_blocksize - *ofs;
>  
>  			copied = kmalloc(vi->inode_isize, GFP_NOFS);
>  			if (!copied) {
> @@ -176,7 +176,7 @@ static void *erofs_read_inode(struct erofs_buf *buf,
>  			err = -EOPNOTSUPP;
>  			goto err_out;
>  		}
> -		vi->chunkbits = LOG_BLOCK_SIZE +
> +		vi->chunkbits = sb->s_blocksize_bits +
>  			(vi->chunkformat & EROFS_CHUNK_FORMAT_BLKBITS_MASK);
>  	}
>  	inode->i_mtime.tv_sec = inode->i_ctime.tv_sec;
> @@ -188,11 +188,12 @@ static void *erofs_read_inode(struct erofs_buf *buf,
>  	if (test_opt(&sbi->opt, DAX_ALWAYS) && S_ISREG(inode->i_mode) &&
>  	    vi->datalayout == EROFS_INODE_FLAT_PLAIN)
>  		inode->i_flags |= S_DAX;
> +
>  	if (!nblks)
>  		/* measure inode.i_blocks as generic filesystems */
> -		inode->i_blocks = roundup(inode->i_size, EROFS_BLKSIZ) >> 9;
> +		inode->i_blocks = round_up(inode->i_size, sb->s_blocksize) >> 9;
>  	else
> -		inode->i_blocks = nblks << LOG_SECTORS_PER_BLOCK;
> +		inode->i_blocks = nblks << (sb->s_blocksize_bits - 9);
>  	return kaddr;
>  
>  bogusimode:
> @@ -210,11 +211,12 @@ static int erofs_fill_symlink(struct inode *inode, void *kaddr,
>  			      unsigned int m_pofs)
>  {
>  	struct erofs_inode *vi = EROFS_I(inode);
> +	unsigned int bsz = i_blocksize(inode);
>  	char *lnk;
>  
>  	/* if it cannot be handled with fast symlink scheme */
>  	if (vi->datalayout != EROFS_INODE_FLAT_INLINE ||
> -	    inode->i_size >= EROFS_BLKSIZ || inode->i_size < 0) {
> +	    inode->i_size >= bsz || inode->i_size < 0) {
>  		inode->i_op = &erofs_symlink_iops;
>  		return 0;
>  	}
> @@ -225,7 +227,7 @@ static int erofs_fill_symlink(struct inode *inode, void *kaddr,
>  
>  	m_pofs += vi->xattr_isize;
>  	/* inline symlink data shouldn't cross block boundary */
> -	if (m_pofs + inode->i_size > EROFS_BLKSIZ) {
> +	if (m_pofs + inode->i_size > bsz) {
>  		kfree(lnk);
>  		erofs_err(inode->i_sb,
>  			  "inline data cross block boundary @ nid %llu",
> diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h
> index 39f259acf887..d8019d835405 100644
> --- a/fs/erofs/internal.h
> +++ b/fs/erofs/internal.h
> @@ -147,8 +147,8 @@ struct erofs_sb_info {
>  #endif
>  	u16 device_id_mask;	/* valid bits of device id to be used */
>  
> -	/* inode slot unit size in bit shift */
> -	unsigned char islotbits;
> +	unsigned char islotbits;	/* inode slot unit size in bit shift */
> +	unsigned char blkszbits;
>  
>  	u32 sb_size;			/* total superblock size */
>  	u32 build_time_nsec;
> @@ -242,13 +242,6 @@ static inline int erofs_wait_on_workgroup_freezed(struct erofs_workgroup *grp)
>  
>  /* we strictly follow PAGE_SIZE and no buffer head yet */
>  #define LOG_BLOCK_SIZE		PAGE_SHIFT
> -
> -#undef LOG_SECTORS_PER_BLOCK
> -#define LOG_SECTORS_PER_BLOCK	(PAGE_SHIFT - 9)
> -
> -#undef SECTORS_PER_BLOCK
> -#define SECTORS_PER_BLOCK	(1 << SECTORS_PER_BLOCK)
> -
>  #define EROFS_BLKSIZ		(1 << LOG_BLOCK_SIZE)
>  
>  #if (EROFS_BLKSIZ % 4096 || !EROFS_BLKSIZ)
> @@ -269,9 +262,10 @@ struct erofs_buf {
>  
>  #define ROOT_NID(sb)		((sb)->root_nid)
>  
> -#define erofs_blknr(addr)       ((addr) / EROFS_BLKSIZ)
> -#define erofs_blkoff(addr)      ((addr) % EROFS_BLKSIZ)
> -#define blknr_to_addr(nr)       ((erofs_off_t)(nr) * EROFS_BLKSIZ)
> +#define erofs_blknr(sb, addr)	((addr) >> (sb)->s_blocksize_bits)
> +#define erofs_blkoff(sb, addr)	((addr) & ((sb)->s_blocksize - 1))
> +#define erofs_pos(sb, blk)	((erofs_off_t)(blk) << (sb)->s_blocksize_bits)
> +#define erofs_iblks(i)	(round_up((i)->i_size, i_blocksize(i)) >> (i)->i_blkbits)
>  
>  #define EROFS_FEATURE_FUNCS(name, compat, feature) \
>  static inline bool erofs_sb_has_##name(struct erofs_sb_info *sbi) \
> @@ -343,7 +337,7 @@ static inline erofs_off_t erofs_iloc(struct inode *inode)
>  {
>  	struct erofs_sb_info *sbi = EROFS_I_SB(inode);
>  
> -	return blknr_to_addr(sbi->meta_blkaddr) +
> +	return erofs_pos(inode->i_sb, sbi->meta_blkaddr) +
>  		(EROFS_I(inode)->nid << sbi->islotbits);
>  }
>  
> diff --git a/fs/erofs/namei.c b/fs/erofs/namei.c
> index 966eabc61c13..f091e9a0f0a1 100644
> --- a/fs/erofs/namei.c
> +++ b/fs/erofs/namei.c
> @@ -89,7 +89,8 @@ static struct erofs_dirent *find_target_dirent(struct erofs_qstr *name,
>  static void *erofs_find_target_block(struct erofs_buf *target,
>  		struct inode *dir, struct erofs_qstr *name, int *_ndirents)
>  {
> -	int head = 0, back = DIV_ROUND_UP(dir->i_size, EROFS_BLKSIZ) - 1;
> +	unsigned int bsz = i_blocksize(dir);
> +	int head = 0, back = erofs_iblks(dir) - 1;
>  	unsigned int startprfx = 0, endprfx = 0;
>  	void *candidate = ERR_PTR(-ENOENT);
>  
> @@ -100,8 +101,7 @@ static void *erofs_find_target_block(struct erofs_buf *target,
>  
>  		de = erofs_bread(&buf, dir, mid, EROFS_KMAP);
>  		if (!IS_ERR(de)) {
> -			const int nameoff = nameoff_from_disk(de->nameoff,
> -							      EROFS_BLKSIZ);
> +			const int nameoff = nameoff_from_disk(de->nameoff, bsz);
>  			const int ndirents = nameoff / sizeof(*de);
>  			int diff;
>  			unsigned int matched;
> @@ -121,11 +121,10 @@ static void *erofs_find_target_block(struct erofs_buf *target,
>  
>  			dname.name = (u8 *)de + nameoff;
>  			if (ndirents == 1)
> -				dname.end = (u8 *)de + EROFS_BLKSIZ;
> +				dname.end = (u8 *)de + bsz;
>  			else
>  				dname.end = (u8 *)de +
> -					nameoff_from_disk(de[1].nameoff,
> -							  EROFS_BLKSIZ);
> +					nameoff_from_disk(de[1].nameoff, bsz);
>  
>  			/* string comparison without already matched prefix */
>  			diff = erofs_dirnamecmp(name, &dname, &matched);
> @@ -178,7 +177,8 @@ int erofs_namei(struct inode *dir, const struct qstr *name, erofs_nid_t *nid,
>  		return PTR_ERR(de);
>  
>  	if (ndirents)
> -		de = find_target_dirent(&qn, (u8 *)de, EROFS_BLKSIZ, ndirents);
> +		de = find_target_dirent(&qn, (u8 *)de, i_blocksize(dir),
> +					ndirents);
>  
>  	if (!IS_ERR(de)) {
>  		*nid = le64_to_cpu(de->nid);
> diff --git a/fs/erofs/super.c b/fs/erofs/super.c
> index 19b1ae79cec4..c97615c96ef8 100644
> --- a/fs/erofs/super.c
> +++ b/fs/erofs/super.c
> @@ -52,18 +52,18 @@ void _erofs_info(struct super_block *sb, const char *function,
>  
>  static int erofs_superblock_csum_verify(struct super_block *sb, void *sbdata)
>  {
> +	size_t len = (1 << EROFS_SB(sb)->blkszbits) - EROFS_SUPER_OFFSET;
>  	struct erofs_super_block *dsb;
>  	u32 expected_crc, crc;
>  
> -	dsb = kmemdup(sbdata + EROFS_SUPER_OFFSET,
> -		      EROFS_BLKSIZ - EROFS_SUPER_OFFSET, GFP_KERNEL);
> +	dsb = kmemdup(sbdata + EROFS_SUPER_OFFSET, len, GFP_KERNEL);
>  	if (!dsb)
>  		return -ENOMEM;
>  
>  	expected_crc = le32_to_cpu(dsb->checksum);
>  	dsb->checksum = 0;
>  	/* to allow for x86 boot sectors and other oddities. */
> -	crc = crc32c(~0, dsb, EROFS_BLKSIZ - EROFS_SUPER_OFFSET);
> +	crc = crc32c(~0, dsb, len);
>  	kfree(dsb);
>  
>  	if (crc != expected_crc) {
> @@ -132,11 +132,11 @@ static void *erofs_read_metadata(struct super_block *sb, struct erofs_buf *buf,
>  	int len, i, cnt;
>  
>  	*offset = round_up(*offset, 4);
> -	ptr = erofs_read_metabuf(buf, sb, erofs_blknr(*offset), EROFS_KMAP);
> +	ptr = erofs_read_metabuf(buf, sb, erofs_blknr(sb, *offset), EROFS_KMAP);
>  	if (IS_ERR(ptr))
>  		return ptr;
>  
> -	len = le16_to_cpu(*(__le16 *)&ptr[erofs_blkoff(*offset)]);
> +	len = le16_to_cpu(*(__le16 *)&ptr[erofs_blkoff(sb, *offset)]);
>  	if (!len)
>  		len = U16_MAX + 1;
>  	buffer = kmalloc(len, GFP_KERNEL);
> @@ -146,14 +146,15 @@ static void *erofs_read_metadata(struct super_block *sb, struct erofs_buf *buf,
>  	*lengthp = len;
>  
>  	for (i = 0; i < len; i += cnt) {
> -		cnt = min(EROFS_BLKSIZ - (int)erofs_blkoff(*offset), len - i);
> -		ptr = erofs_read_metabuf(buf, sb, erofs_blknr(*offset),
> +		cnt = min_t(int, sb->s_blocksize - erofs_blkoff(sb, *offset),
> +			    len - i);
> +		ptr = erofs_read_metabuf(buf, sb, erofs_blknr(sb, *offset),
>  					 EROFS_KMAP);
>  		if (IS_ERR(ptr)) {
>  			kfree(buffer);
>  			return ptr;
>  		}
> -		memcpy(buffer + i, ptr + erofs_blkoff(*offset), cnt);
> +		memcpy(buffer + i, ptr + erofs_blkoff(sb, *offset), cnt);
>  		*offset += cnt;
>  	}
>  	return buffer;
> @@ -228,10 +229,10 @@ static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb,
>  	struct block_device *bdev;
>  	void *ptr;
>  
> -	ptr = erofs_read_metabuf(buf, sb, erofs_blknr(*pos), EROFS_KMAP);
> +	ptr = erofs_read_metabuf(buf, sb, erofs_blknr(sb, *pos), EROFS_KMAP);
>  	if (IS_ERR(ptr))
>  		return PTR_ERR(ptr);
> -	dis = ptr + erofs_blkoff(*pos);
> +	dis = ptr + erofs_blkoff(sb, *pos);
>  
>  	if (!dif->path) {
>  		if (!dis->tag[0]) {
> @@ -733,6 +734,7 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc)
>  	sbi->domain_id = ctx->domain_id;
>  	ctx->domain_id = NULL;
>  
> +	sbi->blkszbits = PAGE_SHIFT;
>  	if (erofs_is_fscache_mode(sb)) {
>  		sb->s_blocksize = EROFS_BLKSIZ;
>  		sb->s_blocksize_bits = LOG_BLOCK_SIZE;
> @@ -1060,7 +1062,7 @@ static int erofs_statfs(struct dentry *dentry, struct kstatfs *buf)
>  		id = huge_encode_dev(sb->s_bdev->bd_dev);
>  
>  	buf->f_type = sb->s_magic;
> -	buf->f_bsize = EROFS_BLKSIZ;
> +	buf->f_bsize = sb->s_blocksize;
>  	buf->f_blocks = sbi->total_blocks;
>  	buf->f_bfree = buf->f_bavail = 0;
>  
> diff --git a/fs/erofs/xattr.c b/fs/erofs/xattr.c
> index 60729b1220b6..459caa3cd65d 100644
> --- a/fs/erofs/xattr.c
> +++ b/fs/erofs/xattr.c
> @@ -68,8 +68,8 @@ static int init_inode_xattrs(struct inode *inode)
>  	}
>  
>  	it.buf = __EROFS_BUF_INITIALIZER;
> -	it.blkaddr = erofs_blknr(erofs_iloc(inode) + vi->inode_isize);
> -	it.ofs = erofs_blkoff(erofs_iloc(inode) + vi->inode_isize);
> +	it.blkaddr = erofs_blknr(sb, erofs_iloc(inode) + vi->inode_isize);
> +	it.ofs = erofs_blkoff(sb, erofs_iloc(inode) + vi->inode_isize);
>  
>  	/* read in shared xattr array (non-atomic, see kmalloc below) */
>  	it.kaddr = erofs_read_metabuf(&it.buf, sb, it.blkaddr, EROFS_KMAP);
> @@ -92,9 +92,9 @@ static int init_inode_xattrs(struct inode *inode)
>  	it.ofs += sizeof(struct erofs_xattr_ibody_header);
>  
>  	for (i = 0; i < vi->xattr_shared_count; ++i) {
> -		if (it.ofs >= EROFS_BLKSIZ) {
> +		if (it.ofs >= sb->s_blocksize) {
>  			/* cannot be unaligned */
> -			DBG_BUGON(it.ofs != EROFS_BLKSIZ);
> +			DBG_BUGON(it.ofs != sb->s_blocksize);
>  
>  			it.kaddr = erofs_read_metabuf(&it.buf, sb, ++it.blkaddr,
>  						      EROFS_KMAP);
> @@ -139,15 +139,15 @@ struct xattr_iter_handlers {
>  
>  static inline int xattr_iter_fixup(struct xattr_iter *it)
>  {
> -	if (it->ofs < EROFS_BLKSIZ)
> +	if (it->ofs < it->sb->s_blocksize)
>  		return 0;
>  
> -	it->blkaddr += erofs_blknr(it->ofs);
> +	it->blkaddr += erofs_blknr(it->sb, it->ofs);
>  	it->kaddr = erofs_read_metabuf(&it->buf, it->sb, it->blkaddr,
>  				       EROFS_KMAP);
>  	if (IS_ERR(it->kaddr))
>  		return PTR_ERR(it->kaddr);
> -	it->ofs = erofs_blkoff(it->ofs);
> +	it->ofs = erofs_blkoff(it->sb, it->ofs);
>  	return 0;
>  }
>  
> @@ -165,8 +165,8 @@ static int inline_xattr_iter_begin(struct xattr_iter *it,
>  
>  	inline_xattr_ofs = vi->inode_isize + xattr_header_sz;
>  
> -	it->blkaddr = erofs_blknr(erofs_iloc(inode) + inline_xattr_ofs);
> -	it->ofs = erofs_blkoff(erofs_iloc(inode) + inline_xattr_ofs);
> +	it->blkaddr = erofs_blknr(it->sb, erofs_iloc(inode) + inline_xattr_ofs);
> +	it->ofs = erofs_blkoff(it->sb, erofs_iloc(inode) + inline_xattr_ofs);
>  	it->kaddr = erofs_read_metabuf(&it->buf, inode->i_sb, it->blkaddr,
>  				       EROFS_KMAP);
>  	if (IS_ERR(it->kaddr))
> @@ -222,8 +222,8 @@ static int xattr_foreach(struct xattr_iter *it,
>  	processed = 0;
>  
>  	while (processed < entry.e_name_len) {
> -		if (it->ofs >= EROFS_BLKSIZ) {
> -			DBG_BUGON(it->ofs > EROFS_BLKSIZ);
> +		if (it->ofs >= it->sb->s_blocksize) {
> +			DBG_BUGON(it->ofs > it->sb->s_blocksize);
>  
>  			err = xattr_iter_fixup(it);
>  			if (err)
> @@ -231,7 +231,7 @@ static int xattr_foreach(struct xattr_iter *it,
>  			it->ofs = 0;
>  		}
>  
> -		slice = min_t(unsigned int, EROFS_BLKSIZ - it->ofs,
> +		slice = min_t(unsigned int, it->sb->s_blocksize - it->ofs,
>  			      entry.e_name_len - processed);
>  
>  		/* handle name */
> @@ -257,8 +257,8 @@ static int xattr_foreach(struct xattr_iter *it,
>  	}
>  
>  	while (processed < value_sz) {
> -		if (it->ofs >= EROFS_BLKSIZ) {
> -			DBG_BUGON(it->ofs > EROFS_BLKSIZ);
> +		if (it->ofs >= it->sb->s_blocksize) {
> +			DBG_BUGON(it->ofs > it->sb->s_blocksize);
>  
>  			err = xattr_iter_fixup(it);
>  			if (err)
> @@ -266,7 +266,7 @@ static int xattr_foreach(struct xattr_iter *it,
>  			it->ofs = 0;
>  		}
>  
> -		slice = min_t(unsigned int, EROFS_BLKSIZ - it->ofs,
> +		slice = min_t(unsigned int, it->sb->s_blocksize - it->ofs,
>  			      value_sz - processed);
>  		op->value(it, processed, it->kaddr + it->ofs, slice);
>  		it->ofs += slice;
> @@ -352,15 +352,14 @@ static int shared_getxattr(struct inode *inode, struct getxattr_iter *it)
>  {
>  	struct erofs_inode *const vi = EROFS_I(inode);
>  	struct super_block *const sb = inode->i_sb;
> -	struct erofs_sb_info *const sbi = EROFS_SB(sb);
>  	unsigned int i;
>  	int ret = -ENOATTR;
>  
>  	for (i = 0; i < vi->xattr_shared_count; ++i) {
>  		erofs_blk_t blkaddr =
> -			xattrblock_addr(sbi, vi->xattr_shared_xattrs[i]);
> +			xattrblock_addr(sb, vi->xattr_shared_xattrs[i]);
>  
> -		it->it.ofs = xattrblock_offset(sbi, vi->xattr_shared_xattrs[i]);
> +		it->it.ofs = xattrblock_offset(sb, vi->xattr_shared_xattrs[i]);
>  		it->it.kaddr = erofs_read_metabuf(&it->it.buf, sb, blkaddr,
>  						  EROFS_KMAP);
>  		if (IS_ERR(it->it.kaddr))
> @@ -564,15 +563,14 @@ static int shared_listxattr(struct listxattr_iter *it)
>  	struct inode *const inode = d_inode(it->dentry);
>  	struct erofs_inode *const vi = EROFS_I(inode);
>  	struct super_block *const sb = inode->i_sb;
> -	struct erofs_sb_info *const sbi = EROFS_SB(sb);
>  	unsigned int i;
>  	int ret = 0;
>  
>  	for (i = 0; i < vi->xattr_shared_count; ++i) {
>  		erofs_blk_t blkaddr =
> -			xattrblock_addr(sbi, vi->xattr_shared_xattrs[i]);
> +			xattrblock_addr(sb, vi->xattr_shared_xattrs[i]);
>  
> -		it->it.ofs = xattrblock_offset(sbi, vi->xattr_shared_xattrs[i]);
> +		it->it.ofs = xattrblock_offset(sb, vi->xattr_shared_xattrs[i]);
>  		it->it.kaddr = erofs_read_metabuf(&it->it.buf, sb, blkaddr,
>  						  EROFS_KMAP);
>  		if (IS_ERR(it->it.kaddr))
> diff --git a/fs/erofs/xattr.h b/fs/erofs/xattr.h
> index 0a43c9ee9f8f..f7a21aaa9755 100644
> --- a/fs/erofs/xattr.h
> +++ b/fs/erofs/xattr.h
> @@ -19,21 +19,21 @@ static inline unsigned int inlinexattr_header_size(struct inode *inode)
>  		sizeof(u32) * EROFS_I(inode)->xattr_shared_count;
>  }
>  
> -static inline erofs_blk_t xattrblock_addr(struct erofs_sb_info *sbi,
> +static inline erofs_blk_t xattrblock_addr(struct super_block *sb,
>  					  unsigned int xattr_id)
>  {
>  #ifdef CONFIG_EROFS_FS_XATTR
> -	return sbi->xattr_blkaddr +
> -		xattr_id * sizeof(__u32) / EROFS_BLKSIZ;
> +	return EROFS_SB(sb)->xattr_blkaddr +
> +		xattr_id * sizeof(__u32) / sb->s_blocksize;
>  #else
>  	return 0;
>  #endif
>  }
>  
> -static inline unsigned int xattrblock_offset(struct erofs_sb_info *sbi,
> +static inline unsigned int xattrblock_offset(struct super_block *sb,
>  					     unsigned int xattr_id)
>  {
> -	return (xattr_id * sizeof(__u32)) % EROFS_BLKSIZ;
> +	return (xattr_id * sizeof(__u32)) % sb->s_blocksize;
>  }
>  
>  #ifdef CONFIG_EROFS_FS_XATTR
> diff --git a/fs/erofs/zdata.c b/fs/erofs/zdata.c
> index 3247d2422bea..f759152feffa 100644
> --- a/fs/erofs/zdata.c
> +++ b/fs/erofs/zdata.c
> @@ -807,7 +807,7 @@ static int z_erofs_register_pcluster(struct z_erofs_decompress_frontend *fe)
>  
>  	if (ztailpacking) {
>  		pcl->obj.index = 0;	/* which indicates ztailpacking */
> -		pcl->pageofs_in = erofs_blkoff(map->m_pa);
> +		pcl->pageofs_in = erofs_blkoff(fe->inode->i_sb, map->m_pa);
>  		pcl->tailpacking_size = map->m_plen;
>  	} else {
>  		pcl->obj.index = map->m_pa >> PAGE_SHIFT;
> @@ -930,6 +930,7 @@ static int z_erofs_read_fragment(struct inode *inode, erofs_off_t pos,
>  				 struct page *page, unsigned int pageofs,
>  				 unsigned int len)
>  {
> +	struct super_block *sb = inode->i_sb;
>  	struct inode *packed_inode = EROFS_I_SB(inode)->packed_inode;
>  	struct erofs_buf buf = __EROFS_BUF_INITIALIZER;
>  	u8 *src, *dst;
> @@ -941,16 +942,16 @@ static int z_erofs_read_fragment(struct inode *inode, erofs_off_t pos,
>  	pos += EROFS_I(inode)->z_fragmentoff;
>  	for (i = 0; i < len; i += cnt) {
>  		cnt = min_t(unsigned int, len - i,
> -			    EROFS_BLKSIZ - erofs_blkoff(pos));
> +			    sb->s_blocksize - erofs_blkoff(sb, pos));
>  		src = erofs_bread(&buf, packed_inode,
> -				  erofs_blknr(pos), EROFS_KMAP);
> +				  erofs_blknr(sb, pos), EROFS_KMAP);
>  		if (IS_ERR(src)) {
>  			erofs_put_metabuf(&buf);
>  			return PTR_ERR(src);
>  		}
>  
>  		dst = kmap_local_page(page);
> -		memcpy(dst + pageofs + i, src + erofs_blkoff(pos), cnt);
> +		memcpy(dst + pageofs + i, src + erofs_blkoff(sb, pos), cnt);
>  		kunmap_local(dst);
>  		pos += cnt;
>  	}
> @@ -1005,7 +1006,8 @@ static int z_erofs_do_read_page(struct z_erofs_decompress_frontend *fe,
>  		void *mp;
>  
>  		mp = erofs_read_metabuf(&fe->map.buf, inode->i_sb,
> -					erofs_blknr(map->m_pa), EROFS_NO_KMAP);
> +					erofs_blknr(inode->i_sb, map->m_pa),
> +					EROFS_NO_KMAP);
>  		if (IS_ERR(mp)) {
>  			err = PTR_ERR(mp);
>  			erofs_err(inode->i_sb,
> @@ -1726,11 +1728,11 @@ static void z_erofs_submit_queue(struct z_erofs_decompress_frontend *f,
>  
>  		/* no device id here, thus it will always succeed */
>  		mdev = (struct erofs_map_dev) {
> -			.m_pa = blknr_to_addr(pcl->obj.index),
> +			.m_pa = erofs_pos(sb, pcl->obj.index),
>  		};
>  		(void)erofs_map_dev(sb, &mdev);
>  
> -		cur = erofs_blknr(mdev.m_pa);
> +		cur = erofs_blknr(sb, mdev.m_pa);
>  		end = cur + pcl->pclusterpages;
>  
>  		do {
> @@ -1764,7 +1766,7 @@ static void z_erofs_submit_queue(struct z_erofs_decompress_frontend *f,
>  
>  				last_bdev = mdev.m_bdev;
>  				bio->bi_iter.bi_sector = (sector_t)cur <<
> -					LOG_SECTORS_PER_BLOCK;
> +					(sb->s_blocksize_bits - 9);
>  				bio->bi_private = q[JQ_SUBMIT];
>  				if (f->readahead)
>  					bio->bi_opf |= REQ_RAHEAD;
> diff --git a/fs/erofs/zmap.c b/fs/erofs/zmap.c
> index 8bf6d30518b6..d066c4da87a5 100644
> --- a/fs/erofs/zmap.c
> +++ b/fs/erofs/zmap.c
> @@ -18,7 +18,7 @@ int z_erofs_fill_inode(struct inode *inode)
>  		vi->z_advise = 0;
>  		vi->z_algorithmtype[0] = 0;
>  		vi->z_algorithmtype[1] = 0;
> -		vi->z_logical_clusterbits = LOG_BLOCK_SIZE;
> +		vi->z_logical_clusterbits = inode->i_sb->s_blocksize_bits;
>  		set_bit(EROFS_I_Z_INITED_BIT, &vi->flags);
>  	}
>  	inode->i_mapping->a_ops = &z_erofs_aops;
> @@ -53,13 +53,13 @@ static int legacy_load_cluster_from_disk(struct z_erofs_maprecorder *m,
>  	unsigned int advise, type;
>  
>  	m->kaddr = erofs_read_metabuf(&m->map->buf, inode->i_sb,
> -				      erofs_blknr(pos), EROFS_KMAP);
> +				      erofs_blknr(inode->i_sb, pos), EROFS_KMAP);
>  	if (IS_ERR(m->kaddr))
>  		return PTR_ERR(m->kaddr);
>  
>  	m->nextpackoff = pos + sizeof(struct z_erofs_vle_decompressed_index);
>  	m->lcn = lcn;
> -	di = m->kaddr + erofs_blkoff(pos);
> +	di = m->kaddr + erofs_blkoff(inode->i_sb, pos);
>  
>  	advise = le16_to_cpu(di->di_advise);
>  	type = (advise >> Z_EROFS_VLE_DI_CLUSTER_TYPE_BIT) &
> @@ -156,7 +156,7 @@ static int unpack_compacted_index(struct z_erofs_maprecorder *m,
>  			 (vcnt << amortizedshift);
>  	big_pcluster = vi->z_advise & Z_EROFS_ADVISE_BIG_PCLUSTER_1;
>  	encodebits = ((vcnt << amortizedshift) - sizeof(__le32)) * 8 / vcnt;
> -	eofs = erofs_blkoff(pos);
> +	eofs = erofs_blkoff(m->inode->i_sb, pos);
>  	base = round_down(eofs, vcnt << amortizedshift);
>  	in = m->kaddr + base;
>  
> @@ -249,7 +249,7 @@ static int compacted_load_cluster_from_disk(struct z_erofs_maprecorder *m,
>  	const unsigned int lclusterbits = vi->z_logical_clusterbits;
>  	const erofs_off_t ebase = sizeof(struct z_erofs_map_header) +
>  		ALIGN(erofs_iloc(inode) + vi->inode_isize + vi->xattr_isize, 8);
> -	const unsigned int totalidx = DIV_ROUND_UP(inode->i_size, EROFS_BLKSIZ);
> +	unsigned int totalidx = erofs_iblks(inode);
>  	unsigned int compacted_4b_initial, compacted_2b;
>  	unsigned int amortizedshift;
>  	erofs_off_t pos;
> @@ -290,7 +290,7 @@ static int compacted_load_cluster_from_disk(struct z_erofs_maprecorder *m,
>  out:
>  	pos += lcn * (1 << amortizedshift);
>  	m->kaddr = erofs_read_metabuf(&m->map->buf, inode->i_sb,
> -				      erofs_blknr(pos), EROFS_KMAP);
> +				      erofs_blknr(inode->i_sb, pos), EROFS_KMAP);
>  	if (IS_ERR(m->kaddr))
>  		return PTR_ERR(m->kaddr);
>  	return unpack_compacted_index(m, amortizedshift, pos, lookahead);
> @@ -360,6 +360,7 @@ static int z_erofs_extent_lookback(struct z_erofs_maprecorder *m,
>  static int z_erofs_get_extent_compressedlen(struct z_erofs_maprecorder *m,
>  					    unsigned int initial_lcn)
>  {
> +	struct super_block *sb = m->inode->i_sb;
>  	struct erofs_inode *const vi = EROFS_I(m->inode);
>  	struct erofs_map_blocks *const map = m->map;
>  	const unsigned int lclusterbits = vi->z_logical_clusterbits;
> @@ -406,7 +407,7 @@ static int z_erofs_get_extent_compressedlen(struct z_erofs_maprecorder *m,
>  		 * if the 1st NONHEAD lcluster is actually PLAIN or HEAD type
>  		 * rather than CBLKCNT, it's a 1 lcluster-sized pcluster.
>  		 */
> -		m->compressedblks = 1 << (lclusterbits - LOG_BLOCK_SIZE);
> +		m->compressedblks = 1 << (lclusterbits - sb->s_blocksize_bits);
>  		break;
>  	case Z_EROFS_VLE_CLUSTER_TYPE_NONHEAD:
>  		if (m->delta[0] != 1)
> @@ -422,7 +423,7 @@ static int z_erofs_get_extent_compressedlen(struct z_erofs_maprecorder *m,
>  		return -EFSCORRUPTED;
>  	}
>  out:
> -	map->m_plen = (u64)m->compressedblks << LOG_BLOCK_SIZE;
> +	map->m_plen = (u64)m->compressedblks << sb->s_blocksize_bits;

erofs_pos(sb, m->compressedblks)?

>  	return 0;
>  err_bonus_cblkcnt:
>  	erofs_err(m->inode->i_sb,
> @@ -565,7 +566,7 @@ static int z_erofs_do_map_blocks(struct inode *inode,
>  	} else if (fragment && m.lcn == vi->z_tailextent_headlcn) {
>  		map->m_flags |= EROFS_MAP_FRAGMENT;
>  	} else {
> -		map->m_pa = blknr_to_addr(m.pblk);
> +		map->m_pa = erofs_pos(inode->i_sb, m.pblk);
>  		err = z_erofs_get_extent_compressedlen(&m, initial_lcn);
>  		if (err)
>  			goto unmap_out;
> @@ -592,7 +593,7 @@ static int z_erofs_do_map_blocks(struct inode *inode,
>  	if ((flags & EROFS_GET_BLOCKS_FIEMAP) ||
>  	    ((flags & EROFS_GET_BLOCKS_READMORE) &&
>  	     map->m_algorithmformat == Z_EROFS_COMPRESSION_LZMA &&
> -	     map->m_llen >= EROFS_BLKSIZ)) {
> +	     map->m_llen >= i_blocksize(inode))) {
>  		err = z_erofs_get_extent_decompressedlen(&m);
>  		if (!err)
>  			map->m_flags |= EROFS_MAP_FULL_MAPPED;
> @@ -633,13 +634,13 @@ static int z_erofs_fill_inode_lazy(struct inode *inode)
>  		goto out_unlock;
>  
>  	pos = ALIGN(erofs_iloc(inode) + vi->inode_isize + vi->xattr_isize, 8);
> -	kaddr = erofs_read_metabuf(&buf, sb, erofs_blknr(pos), EROFS_KMAP);
> +	kaddr = erofs_read_metabuf(&buf, sb, erofs_blknr(sb, pos), EROFS_KMAP);
>  	if (IS_ERR(kaddr)) {
>  		err = PTR_ERR(kaddr);
>  		goto out_unlock;
>  	}
>  
> -	h = kaddr + erofs_blkoff(pos);
> +	h = kaddr + erofs_blkoff(sb, pos);
>  	/*
>  	 * if the highest bit of the 8-byte map header is set, the whole file
>  	 * is stored in the packed inode. The rest bits keeps z_fragmentoff.
> @@ -663,7 +664,7 @@ static int z_erofs_fill_inode_lazy(struct inode *inode)
>  		goto out_put_metabuf;
>  	}
>  
> -	vi->z_logical_clusterbits = LOG_BLOCK_SIZE + (h->h_clusterbits & 7);
> +	vi->z_logical_clusterbits = sb->s_blocksize_bits + (h->h_clusterbits & 7);
>  	if (!erofs_sb_has_big_pcluster(EROFS_SB(sb)) &&
>  	    vi->z_advise & (Z_EROFS_ADVISE_BIG_PCLUSTER_1 |
>  			    Z_EROFS_ADVISE_BIG_PCLUSTER_2)) {
> @@ -692,7 +693,7 @@ static int z_erofs_fill_inode_lazy(struct inode *inode)
>  		erofs_put_metabuf(&map.buf);
>  
>  		if (!map.m_plen ||
> -		    erofs_blkoff(map.m_pa) + map.m_plen > EROFS_BLKSIZ) {
> +		    erofs_blkoff(sb, map.m_pa) + map.m_plen > sb->s_blocksize) {
>  			erofs_err(sb, "invalid tail-packing pclustersize %llu",
>  				  map.m_plen);
>  			err = -EFSCORRUPTED;
> diff --git a/include/trace/events/erofs.h b/include/trace/events/erofs.h
> index cf4a0d28b178..71dbe8bfa7db 100644
> --- a/include/trace/events/erofs.h
> +++ b/include/trace/events/erofs.h
> @@ -71,8 +71,8 @@ TRACE_EVENT(erofs_fill_inode,
>  	TP_fast_assign(
>  		__entry->dev		= inode->i_sb->s_dev;
>  		__entry->nid		= EROFS_I(inode)->nid;
> -		__entry->blkaddr	= erofs_blknr(erofs_iloc(inode));
> -		__entry->ofs		= erofs_blkoff(erofs_iloc(inode));
> +		__entry->blkaddr	= erofs_blknr(inode->i_sb, erofs_iloc(inode));
> +		__entry->ofs		= erofs_blkoff(inode->i_sb, erofs_iloc(inode));
>  	),
>  
>  	TP_printk("dev = (%d,%d), nid = %llu, blkaddr %u ofs %u",