Re: [PATCH v4 1/2] erofs: avoid hardcoded blocksize for subpage block support
From: Yue Hu
Date: Mon Mar 06 2023 - 02:09:59 EST
On Thu, 2 Mar 2023 22:39:14 +0800
Jingbo Xu <jefflexu@xxxxxxxxxxxxxxxxx> 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@xxxxxxxxxxxxxxxxx>
> Reviewed-by: Gao Xiang <hsiangkao@xxxxxxxxxxxxxxxxx>
> ---
> 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",