Hi Giuseppe,
On Fri, Jul 31, 2026 at 06:08:21PM +0200, Giuseppe Scrivano wrote:
> When the same file-backed image is mounted multiple times (via path or
> fd) with the superblock_share mount option and matching domain_id, reuse
First, I still need to get vfs maintainer opinions for "the sharing
superblock feature for file-backed mounts"
I don't think it needs to be bothered with "domain_id" since
"domain_id" represents a trusted zone so a security concept for data
sourcing, and here I think you should just share the same filesystem
(with the same backing files) and the same option, so I don't think
"domain_id" is really useful.
> the existing superblock instead of creating a new one. This allows
> multiple mounts of the same image to share in-kernel data structures
> more efficiently.
>
> Superblock sharing requires both superblock_share and domain_id to be
But I think a "superblock_share" yes/no mount option may be useful.
> specified, following the same pattern as inode_share. The backing file
> is identified by its inode and fsoffset. If mount options conflict, a
> separate superblock is created transparently as a fallback. Remount is
> not allowed on shared superblocks.
>
> Tested by mounting a 177M Fedora EROFS image 20 times with full
> traversal:
>
> #!/bin/sh
> IMG=${1:-/root/fedora.erofs}
> N=20
> DIR=$(mktemp -d)
> trap "umount $DIR/m* 2>/dev/null; rm -rf $DIR" EXIT
>
> sync; echo 3 > /proc/sys/vm/drop_caches
> INODES_BEFORE=$(grep erofs_inode /proc/slabinfo | awk '{print $2}')
> MEM_BEFORE=$(grep ^Slab: /proc/meminfo | awk '{print $2}')
>
> for i in $(seq 1 $N); do
> mkdir $DIR/m$i
> mount -t erofs -o domain_id=test,superblock_share "$IMG" $DIR/m$i
> find $DIR/m$i > /dev/null
> done
>
> echo "Superblocks: $(grep $DIR /proc/self/mountinfo | \
> awk '{print $3}' | sort -u | wc -l)"
> echo "erofs_inode delta: +$(( $(grep erofs_inode /proc/slabinfo | \
> awk '{print $2}') - INODES_BEFORE ))"
> echo "Slab delta: +$(( $(grep ^Slab: /proc/meminfo | \
> awk '{print $2}') - MEM_BEFORE )) kB"
>
> unpatched kernel:
>
> Superblocks: 20
> erofs_inode delta: +46368
> Slab delta: +39952 kB
> 0.08user 0.82system 0:00.98elapsed
>
> patched kernel:
>
> Superblocks: 1
> erofs_inode delta: +2044
> Slab delta: +1088 kB
> 0.07user 0.21system 0:00.31elapsed
>
> The time difference shows that sharing the superblock also benefits
> the page cache and inode cache, as subsequent mounts of the same image
> avoid re-reading the backing file. This is particularly useful for
> container hosts running multiple containers from the same base image.
>
> Signed-off-by: Giuseppe Scrivano <[email protected]>
> ---
> v1:
> https://lore.kernel.org/linux-fsdevel/[email protected]/
> Needs:
> https://lore.kernel.org/linux-fsdevel/[email protected]/
>
> Documentation/filesystems/erofs.rst | 16 ++++++-
> fs/erofs/internal.h | 1 +
> fs/erofs/super.c | 72 +++++++++++++++++++++++++++--
> 3 files changed, 83 insertions(+), 6 deletions(-)
>
> diff --git a/Documentation/filesystems/erofs.rst
> b/Documentation/filesystems/erofs.rst
> index 774e8b236d09..517c526163e2 100644
> --- a/Documentation/filesystems/erofs.rst
> +++ b/Documentation/filesystems/erofs.rst
> @@ -131,12 +131,17 @@ device=%s Specify a path to an extra
> device to be used together.
> directio (For file-backed mounts) Use direct I/O to access
> backing
> files, and asynchronous I/O will be enabled if
> supported.
> domain_id=%s Specify a trusted domain ID. Filesystems sharing the
> same
> - domain ID can share page cache across mounts when
> inode
> - page sharing is enabled. (not shown in mountinfo
> output)
> + domain ID can share page cache across mounts when
> + inode_share is enabled, and share superblocks when
> + superblock_share is enabled. (not shown in mountinfo
> + output)
> fsoffset=%llu Specify block-aligned filesystem offset for the
> primary device.
> inode_share Enable inode page sharing for this filesystem.
> Inodes with
> identical content within the same domain ID can share
> the
> page cache.
> +superblock_share Share the superblock when the same backing file is
> mounted
> + more than once with the same domain_id and compatible
> + options. Remount is not allowed on shared
> superblocks.
As I commented above.
> ===================
> =========================================================
>
> File-backed mounts
> @@ -154,6 +159,13 @@ Only regular files are accepted as backing files; to
> mount an image that
> resides on a block device, use the traditional block device mount path
> instead.
>
> +When domain_id and superblock_share are both specified and the same
> +backing file (identified by inode and fsoffset) is mounted more than
> +once with the same domain_id and compatible mount options, the kernel
> +reuses the existing superblock instead of creating a new one.
> +
> +Remount is not allowed on shared superblocks.
> +
> Sysfs Entries
> =============
>
> diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h
> index 580f8d9f14e7..8d65cac35702 100644
> --- a/fs/erofs/internal.h
> +++ b/fs/erofs/internal.h
> @@ -156,6 +156,7 @@ struct erofs_sb_info {
> #define EROFS_MOUNT_DAX_NEVER 0x00000080
> #define EROFS_MOUNT_DIRECT_IO 0x00000100
> #define EROFS_MOUNT_INODE_SHARE 0x00000200
> +#define EROFS_MOUNT_SUPERBLOCK_SHARE 0x00000400
>
> #define clear_opt(opt, option) ((opt)->mount_opt &=
> ~EROFS_MOUNT_##option)
> #define set_opt(opt, option) ((opt)->mount_opt |= EROFS_MOUNT_##option)
> diff --git a/fs/erofs/super.c b/fs/erofs/super.c
> index 558041011398..23fee43de1d1 100644
> --- a/fs/erofs/super.c
> +++ b/fs/erofs/super.c
> @@ -386,7 +386,7 @@ static void erofs_default_options(struct erofs_sb_info
> *sbi)
> enum {
> Opt_user_xattr, Opt_acl, Opt_cache_strategy, Opt_dax, Opt_dax_enum,
> Opt_device, Opt_domain_id, Opt_directio, Opt_fsoffset, Opt_inode_share,
> - Opt_source,
> + Opt_source, Opt_superblock_share,
> };
>
> static const struct constant_table erofs_param_cache_strategy[] = {
> @@ -415,6 +415,7 @@ static const struct fs_parameter_spec
> erofs_fs_parameters[] = {
> fsparam_u64("fsoffset", Opt_fsoffset),
> fsparam_flag("inode_share", Opt_inode_share),
> fsparam_file_or_string("source", Opt_source),
> + fsparam_flag("superblock_share", Opt_superblock_share),
> {}
> };
>
> @@ -536,7 +537,8 @@ static int erofs_fc_parse_param(struct fs_context *fc,
> ++sbi->devs->extra_devices;
> break;
> case Opt_domain_id:
> - if (!IS_ENABLED(CONFIG_EROFS_FS_PAGE_CACHE_SHARE)) {
> + if (!IS_ENABLED(CONFIG_EROFS_FS_PAGE_CACHE_SHARE) &&
> + !IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE)) {
> errorfc(fc, "%s option not supported",
> erofs_fs_parameters[opt].name);
> } else {
> kfree_sensitive(sbi->domain_id);
> @@ -560,6 +562,12 @@ static int erofs_fc_parse_param(struct fs_context *fc,
> else
> set_opt(&sbi->opt, INODE_SHARE);
> break;
> + case Opt_superblock_share:
> + if (!IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE))
> + errorfc(fc, "%s option not supported",
> erofs_fs_parameters[opt].name);
> + else
> + set_opt(&sbi->opt, SUPERBLOCK_SHARE);
> + break;
> case Opt_source:
> return erofs_fc_parse_source(fc, param);
> }
> @@ -659,6 +667,10 @@ static int erofs_fc_fill_super(struct super_block *sb,
> struct fs_context *fc)
> errorfc(fc, "domain_id is needed when inode_ishare is on");
> return -EINVAL;
> }
> + if (!sbi->domain_id && test_opt(&sbi->opt, SUPERBLOCK_SHARE)) {
> + errorfc(fc, "domain_id is needed when superblock_share is on");
> + return -EINVAL;
> + }
> if (test_opt(&sbi->opt, DAX_ALWAYS) && test_opt(&sbi->opt,
> INODE_SHARE)) {
> errorfc(fc, "FSDAX is not allowed when inode_ishare is on");
> return -EINVAL;
> @@ -788,6 +800,55 @@ static int erofs_fc_fill_super(struct super_block *sb,
> struct fs_context *fc)
> return 0;
> }
>
> +static int erofs_fc_test_file_super(struct super_block *sb,
> + struct fs_context *fc)
> +{
> + struct erofs_sb_info *sbi = EROFS_SB(sb);
> + struct erofs_sb_info *new_sbi = fc->s_fs_info;
> +
> + if (sb->s_iflags & SB_I_RETIRED)
> + return 0;
> + if (!sbi->dif0.file || !new_sbi->dif0.file)
> + return 0;
> + if (!test_opt(&new_sbi->opt, SUPERBLOCK_SHARE))
> + return 0;
I think it'd be better to just memcmp(sbi->opt, new_sbi->opt, ..)
directly.
> + if (!sbi->domain_id || !new_sbi->domain_id ||
> + strcmp(sbi->domain_id, new_sbi->domain_id))
> + return 0;
And also you need to ensure the devs has the same backing files too.
> + return file_inode(sbi->dif0.file) == file_inode(new_sbi->dif0.file) &&
> + sbi->dif0.fsoff == new_sbi->dif0.fsoff &&
> + sbi->opt.mount_opt == new_sbi->opt.mount_opt &&
> + sbi->opt.cache_strategy == new_sbi->opt.cache_strategy;
> +}
> +
> +static int erofs_fc_get_tree_file(struct fs_context *fc)
> +{
> + struct erofs_sb_info *sbi = fc->s_fs_info;
> + struct super_block *sb;
> + int err;
> +
> + if (!test_opt(&sbi->opt, SUPERBLOCK_SHARE))
> + return get_tree_nodev(fc, erofs_fc_fill_super);
> +
> + sb = sget_fc(fc, erofs_fc_test_file_super, set_anon_super_fc);
Especially the usage above, I need acks from vfs maintainers first.
Thanks,
Gao Xiang
