erofs: set block size to the on-disk block size

Set the block size to that specified in on-disk superblock.

Also remove the hard constraint of PAGE_SIZE block size for the
uncompressed device backend.  This constraint is temporarily remained
for compressed device and fscache backend, as there is more work needed
to handle the condition where the block size is not equal to PAGE_SIZE.

It is worth noting that the on-disk block size is read prior to
erofs_superblock_csum_verify(), as the read block size is needed in the
latter.

Besides, later we are going to make erofs refer to tar data blobs (which
is 512-byte aligned) for OCI containers, where the block size is 512
bytes.  In this case, the 512-byte block size may not be adequate for a
directory to contain enough dirents.  To fix this, we are also going to
introduce directory block size independent on the block size.

Due to we have already supported block size smaller than PAGE_SIZE now,
disable all these images with such separated directory block size until
we supported this feature later.

Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com>
Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com>
Reviewed-by: Yue Hu <huyue2@coolpad.com>
Reviewed-by: Chao Yu <chao@kernel.org>
Link: https://lore.kernel.org/r/20230313135309.75269-3-jefflexu@linux.alibaba.com
[ Gao Xiang: update documentation. ]
Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com>

diff --git a/Documentation/filesystems/erofs.rst b/Documentation/filesystems/erofs.rst
index a43aacf1494e778585aea093fb4c099dc4459be7..4654ee57c1d5e4ef5d59d9b34cea5651434c5b34 100644 (file)
--- a/Documentation/filesystems/erofs.rst
+++ b/Documentation/filesystems/erofs.rst
@@ -40,8 +40,8 @@ Here are the main features of EROFS:
  - Support multiple devices to refer to external blobs, which can be used
    for container images;
 
- - 4KiB block size and 32-bit block addresses for each device, therefore
-   16TiB address space at most for now;
+ - 32-bit block addresses for each device, therefore 16TiB address space at
+   most with 4KiB block size for now;
 
  - Two inode layouts for different requirements:
 

diff --git a/fs/erofs/erofs_fs.h b/fs/erofs/erofs_fs.h
index dbcd24371002bbebefed025ba15415e3193101ed..44876a97cabdccf2045f1f8c5e3ff39eb7a1ec7b 100644 (file)
--- a/fs/erofs/erofs_fs.h
+++ b/fs/erofs/erofs_fs.h
@@ -53,7 +53,7 @@ struct erofs_super_block {
        __le32 magic;           /* file system magic number */
        __le32 checksum;        /* crc32c(super_block) */
        __le32 feature_compat;
-       __u8 blkszbits;         /* support block_size == PAGE_SIZE only */
+       __u8 blkszbits;         /* filesystem block size in bit shift */
        __u8 sb_extslots;       /* superblock size = 128 + sb_extslots * 16 */
 
        __le16 root_nid;        /* nid of root directory */
@@ -75,7 +75,8 @@ struct erofs_super_block {
        } __packed u1;
        __le16 extra_devices;   /* # of devices besides the primary device */
        __le16 devt_slotoff;    /* startoff = devt_slotoff * devt_slotsize */
-       __u8 reserved[6];
+       __u8 dirblkbits;        /* directory block size in bit shift */
+       __u8 reserved[5];
        __le64 packed_nid;      /* nid of the special packed inode */
        __u8 reserved2[24];
 };

diff --git a/fs/erofs/inode.c b/fs/erofs/inode.c
index 3502daee8d3babda55b3554202fc241f2a9d249d..7ca9aafb7471592cb28d17d2c7ad96fd87d103b4 100644 (file)
--- a/fs/erofs/inode.c
+++ b/fs/erofs/inode.c
@@ -291,7 +291,8 @@ static int erofs_fill_inode(struct inode *inode)
        }
 
        if (erofs_inode_is_data_compressed(vi->datalayout)) {
-               if (!erofs_is_fscache_mode(inode->i_sb))
+               if (!erofs_is_fscache_mode(inode->i_sb) &&
+                   inode->i_sb->s_blocksize_bits == PAGE_SHIFT)
                        err = z_erofs_fill_inode(inode);
                else
                        err = -EOPNOTSUPP;

diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h
index 66ff0513866f32eb25ffa6ea65543ece0d36add7..9eff0c0ad2d73df93d0161f493e124d4a931ed32 100644 (file)
--- a/fs/erofs/internal.h
+++ b/fs/erofs/internal.h
@@ -148,7 +148,7 @@ struct erofs_sb_info {
        u16 device_id_mask;     /* valid bits of device id to be used */
 
        unsigned char islotbits;        /* inode slot unit size in bit shift */
-       unsigned char blkszbits;
+       unsigned char blkszbits;        /* filesystem block size in bit shift */
 
        u32 sb_size;                    /* total superblock size */
        u32 build_time_nsec;
@@ -240,14 +240,6 @@ static inline int erofs_wait_on_workgroup_freezed(struct erofs_workgroup *grp)
                                        VAL != EROFS_LOCKED_MAGIC);
 }
 
-/* we strictly follow PAGE_SIZE and no buffer head yet */
-#define LOG_BLOCK_SIZE         PAGE_SHIFT
-#define EROFS_BLKSIZ           (1 << LOG_BLOCK_SIZE)
-
-#if (EROFS_BLKSIZ % 4096 || !EROFS_BLKSIZ)
-#error erofs cannot be used in this platform
-#endif
-
 enum erofs_kmap_type {
        EROFS_NO_KMAP,          /* don't map the buffer */
        EROFS_KMAP,             /* use kmap_local_page() to map the buffer */

diff --git a/fs/erofs/super.c b/fs/erofs/super.c
index 4303b4e69e5589eb9955e306b1e90119bee85a5d..dbffcdd696dfb264b52afc2cbe07b2811521b3a3 100644 (file)
--- a/fs/erofs/super.c
+++ b/fs/erofs/super.c
@@ -333,7 +333,6 @@ static int erofs_read_superblock(struct super_block *sb)
        struct erofs_sb_info *sbi;
        struct erofs_buf buf = __EROFS_BUF_INITIALIZER;
        struct erofs_super_block *dsb;
-       unsigned int blkszbits;
        void *data;
        int ret;
 
@@ -352,6 +351,16 @@ static int erofs_read_superblock(struct super_block *sb)
                goto out;
        }
 
+       sbi->blkszbits  = dsb->blkszbits;
+       if (sbi->blkszbits < 9 || sbi->blkszbits > PAGE_SHIFT) {
+               erofs_err(sb, "blkszbits %u isn't supported", sbi->blkszbits);
+               goto out;
+       }
+       if (dsb->dirblkbits) {
+               erofs_err(sb, "dirblkbits %u isn't supported", dsb->dirblkbits);
+               goto out;
+       }
+
        sbi->feature_compat = le32_to_cpu(dsb->feature_compat);
        if (erofs_sb_has_sb_chksum(sbi)) {
                ret = erofs_superblock_csum_verify(sb, data);
@@ -360,19 +369,11 @@ static int erofs_read_superblock(struct super_block *sb)
        }
 
        ret = -EINVAL;
-       blkszbits = dsb->blkszbits;
-       /* 9(512 bytes) + LOG_SECTORS_PER_BLOCK == LOG_BLOCK_SIZE */
-       if (blkszbits != LOG_BLOCK_SIZE) {
-               erofs_err(sb, "blkszbits %u isn't supported on this platform",
-                         blkszbits);
-               goto out;
-       }
-
        if (!check_layout_compatibility(sb, dsb))
                goto out;
 
        sbi->sb_size = 128 + dsb->sb_extslots * EROFS_SB_EXTSLOT_SIZE;
-       if (sbi->sb_size > EROFS_BLKSIZ) {
+       if (sbi->sb_size > PAGE_SIZE - EROFS_SUPER_OFFSET) {
                erofs_err(sb, "invalid sb_extslots %u (more than a fs block)",
                          sbi->sb_size);
                goto out;
@@ -739,8 +740,8 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc)
 
        sbi->blkszbits = PAGE_SHIFT;
        if (erofs_is_fscache_mode(sb)) {
-               sb->s_blocksize = EROFS_BLKSIZ;
-               sb->s_blocksize_bits = LOG_BLOCK_SIZE;
+               sb->s_blocksize = PAGE_SIZE;
+               sb->s_blocksize_bits = PAGE_SHIFT;
 
                err = erofs_fscache_register_fs(sb);
                if (err)
@@ -750,8 +751,8 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc)
                if (err)
                        return err;
        } else {
-               if (!sb_set_blocksize(sb, EROFS_BLKSIZ)) {
-                       erofs_err(sb, "failed to set erofs blksize");
+               if (!sb_set_blocksize(sb, PAGE_SIZE)) {
+                       errorfc(fc, "failed to set initial blksize");
                        return -EINVAL;
                }
 
@@ -764,12 +765,24 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc)
        if (err)
                return err;
 
-       if (test_opt(&sbi->opt, DAX_ALWAYS)) {
-               BUILD_BUG_ON(EROFS_BLKSIZ != PAGE_SIZE);
+       if (sb->s_blocksize_bits != sbi->blkszbits) {
+               if (erofs_is_fscache_mode(sb)) {
+                       errorfc(fc, "unsupported blksize for fscache mode");
+                       return -EINVAL;
+               }
+               if (!sb_set_blocksize(sb, 1 << sbi->blkszbits)) {
+                       errorfc(fc, "failed to set erofs blksize");
+                       return -EINVAL;
+               }
+       }
 
+       if (test_opt(&sbi->opt, DAX_ALWAYS)) {
                if (!sbi->dax_dev) {
                        errorfc(fc, "DAX unsupported by block device. Turning off DAX.");
                        clear_opt(&sbi->opt, DAX_ALWAYS);
+               } else if (sbi->blkszbits != PAGE_SHIFT) {
+                       errorfc(fc, "unsupported blocksize for DAX");
+                       clear_opt(&sbi->opt, DAX_ALWAYS);
                }
        }