From: Yue Hu <huyue2@yulong.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/edd7e1eee421972399681ee65fb8447... -------------------------------- ANBZ: #1666 commit 8137824eddd2e790c61c70c20d70a087faca95fa upstream. Currently, erofs_map_blocks() will be called only from erofs_{bmap, read_raw_page} which are all for uncompressed files. So, the compression branch in erofs_map_blocks() is pointless. Let's remove it and use erofs_map_blocks_flatmode() directly. Also update related comments. Link: https://lore.kernel.org/r/20210325071008.573-1-zbestahu@gmail.com Reviewed-by: Chao Yu <yuchao0@huawei.com> Signed-off-by: Yue Hu <huyue2@yulong.com> Signed-off-by: Gao Xiang <hsiangkao@redhat.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/data.c | 19 ++----------------- fs/erofs/internal.h | 6 ++---- 2 files changed, 4 insertions(+), 21 deletions(-) diff --git a/fs/erofs/data.c b/fs/erofs/data.c index ea4f693bee22..76c47c34b09f 100644 --- a/fs/erofs/data.c +++ b/fs/erofs/data.c @@ -109,21 +109,6 @@ static int erofs_map_blocks_flatmode(struct inode *inode, return err; } -int erofs_map_blocks(struct inode *inode, - struct erofs_map_blocks *map, int flags) -{ - if (erofs_inode_is_data_compressed(EROFS_I(inode)->datalayout)) { - int err = z_erofs_map_blocks_iter(inode, map, flags); - - if (map->mpage) { - put_page(map->mpage); - map->mpage = NULL; - } - return err; - } - return erofs_map_blocks_flatmode(inode, map, flags); -} - static inline struct bio *erofs_read_raw_page(struct bio *bio, struct address_space *mapping, struct page *page, @@ -159,7 +144,7 @@ static inline struct bio *erofs_read_raw_page(struct bio *bio, erofs_blk_t blknr; unsigned int blkoff; - err = erofs_map_blocks(inode, &map, EROFS_GET_BLOCKS_RAW); + err = erofs_map_blocks_flatmode(inode, &map, EROFS_GET_BLOCKS_RAW); if (err) goto err_out; @@ -326,7 +311,7 @@ static sector_t erofs_bmap(struct address_space *mapping, sector_t block) return 0; } - if (!erofs_map_blocks(inode, &map, EROFS_GET_BLOCKS_RAW)) + if (!erofs_map_blocks_flatmode(inode, &map, EROFS_GET_BLOCKS_RAW)) return erofs_blknr(map.m_pa); return 0; diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index 5b3a9f5c282d..c0eb1145dfde 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -258,7 +258,7 @@ extern const struct address_space_operations erofs_raw_access_aops; extern const struct address_space_operations z_erofs_aops; /* - * Logical to physical block mapping, used by erofs_map_blocks() + * Logical to physical block mapping * * Different with other file systems, it is used for 2 access modes: * @@ -305,7 +305,7 @@ struct erofs_map_blocks { struct page *mpage; }; -/* Flags used by erofs_map_blocks() */ +/* Flags used by erofs_map_blocks_flatmode() */ #define EROFS_GET_BLOCKS_RAW 0x0001 /* zmap.c */ @@ -327,8 +327,6 @@ static inline int z_erofs_map_blocks_iter(struct inode *inode, /* data.c */ struct page *erofs_get_meta_page(struct super_block *sb, erofs_blk_t blkaddr); -int erofs_map_blocks(struct inode *, struct erofs_map_blocks *, int); - /* inode.c */ static inline unsigned long erofs_inode_hash(erofs_nid_t nid) { -- 2.46.1

From: Gao Xiang <hsiangkao@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/efa097b6d8c0014a5994e4959e56eff... -------------------------------- ANBZ: #1666 commit 2a9dc7a8fec6ca287e2c038f9441e24269e10b5f upstream. Currently, uncompressed data except for tail-packing inline is consecutive on disk. In order to support chunk-based data deduplication, add a new corresponding inode data layout. In the future, the data source of chunks can be either (un)compressed. Link: https://lore.kernel.org/r/20210820100019.208490-1-hsiangkao@linux.alibaba.co... Reviewed-by: Liu Bo <bo.liu@linux.alibaba.com> Reviewed-by: Chao Yu <chao@kernel.org> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- Documentation/filesystems/erofs.rst | 16 ++++++++-- fs/erofs/erofs_fs.h | 48 +++++++++++++++++++++++++++-- 2 files changed, 60 insertions(+), 4 deletions(-) diff --git a/Documentation/filesystems/erofs.rst b/Documentation/filesystems/erofs.rst index bf145171c2bf..ed2d9b33a94f 100644 --- a/Documentation/filesystems/erofs.rst +++ b/Documentation/filesystems/erofs.rst @@ -153,13 +153,14 @@ may not. All metadatas can be now observed in two different spaces (views): Xattrs, extents, data inline are followed by the corresponding inode with proper alignment, and they could be optional for different data mappings. - _currently_ total 4 valid data mappings are supported: + _currently_ total 5 data layouts are supported: == ==================================================================== 0 flat file data without data inline (no extent); 1 fixed-sized output data compression (with non-compacted indexes); 2 flat file data with tail packing data inline (no extent); - 3 fixed-sized output data compression (with compacted indexes, v5.3+). + 3 fixed-sized output data compression (with compacted indexes, v5.3+); + 4 chunk-based file (v5.15+). == ==================================================================== The size of the optional xattrs is indicated by i_xattr_count in inode @@ -211,6 +212,17 @@ Note that apart from the offset of the first filename, nameoff0 also indicates the total number of directory entries in this block since it is no need to introduce another on-disk field at all. +Chunk-based file +---------------- +In order to support chunk-based data deduplication, a new inode data layout has +been supported since Linux v5.15: Files are split in equal-sized data chunks +with ``extents`` area of the inode metadata indicating how to get the chunk +data: these can be simply as a 4-byte block address array or in the 8-byte +chunk index form (see struct erofs_inode_chunk_index in erofs_fs.h for more +details.) + +By the way, chunk-based files are all uncompressed for now. + Compression ----------- Currently, EROFS supports 4KB fixed-sized output transparent file compression, diff --git a/fs/erofs/erofs_fs.h b/fs/erofs/erofs_fs.h index dcf463c7010c..a13f17d33da8 100644 --- a/fs/erofs/erofs_fs.h +++ b/fs/erofs/erofs_fs.h @@ -4,6 +4,7 @@ * * Copyright (C) 2017-2018 HUAWEI, Inc. * https://www.huawei.com/ + * Copyright (C) 2021, Alibaba Cloud */ #ifndef __EROFS_FS_H #define __EROFS_FS_H @@ -17,7 +18,10 @@ * be incompatible with this kernel version. */ #define EROFS_FEATURE_INCOMPAT_LZ4_0PADDING 0x00000001 -#define EROFS_ALL_FEATURE_INCOMPAT EROFS_FEATURE_INCOMPAT_LZ4_0PADDING +#define EROFS_FEATURE_INCOMPAT_CHUNKED_FILE 0x00000004 +#define EROFS_ALL_FEATURE_INCOMPAT \ + (EROFS_FEATURE_INCOMPAT_LZ4_0PADDING | \ + EROFS_FEATURE_INCOMPAT_CHUNKED_FILE) /* 128-byte erofs on-disk super block */ struct erofs_super_block { @@ -51,13 +55,16 @@ struct erofs_super_block { * inode, [xattrs], last_inline_data, ... | ... | no-holed data * 3 - inode compression D: * inode, [xattrs], map_header, extents ... | ... - * 4~7 - reserved + * 4 - inode chunk-based E: + * inode, [xattrs], chunk indexes ... | ... + * 5~7 - reserved */ enum { EROFS_INODE_FLAT_PLAIN = 0, EROFS_INODE_FLAT_COMPRESSION_LEGACY = 1, EROFS_INODE_FLAT_INLINE = 2, EROFS_INODE_FLAT_COMPRESSION = 3, + EROFS_INODE_CHUNK_BASED = 4, EROFS_INODE_DATALAYOUT_MAX }; @@ -77,6 +84,19 @@ static inline bool erofs_inode_is_data_compressed(unsigned int datamode) #define EROFS_I_ALL \ ((1 << (EROFS_I_DATALAYOUT_BIT + EROFS_I_DATALAYOUT_BITS)) - 1) +/* indicate chunk blkbits, thus 'chunksize = blocksize << chunk blkbits' */ +#define EROFS_CHUNK_FORMAT_BLKBITS_MASK 0x001F +/* with chunk indexes or just a 4-byte blkaddr array */ +#define EROFS_CHUNK_FORMAT_INDEXES 0x0020 + +#define EROFS_CHUNK_FORMAT_ALL \ + (EROFS_CHUNK_FORMAT_BLKBITS_MASK | EROFS_CHUNK_FORMAT_INDEXES) + +struct erofs_inode_chunk_info { + __le16 format; /* chunk blkbits, etc. */ + __le16 reserved; +}; + /* 32-byte reduced form of an ondisk inode */ struct erofs_inode_compact { __le16 i_format; /* inode format hints */ @@ -94,6 +114,9 @@ struct erofs_inode_compact { /* for device files, used to indicate old/new device # */ __le32 rdev; + + /* for chunk-based files, it contains the summary info */ + struct erofs_inode_chunk_info c; } i_u; __le32 i_ino; /* only used for 32-bit stat compatibility */ __le16 i_uid; @@ -122,6 +145,9 @@ struct erofs_inode_extended { /* for device files, used to indicate old/new device # */ __le32 rdev; + + /* for chunk-based files, it contains the summary info */ + struct erofs_inode_chunk_info c; } i_u; /* only used for 32-bit stat compatibility */ @@ -191,6 +217,19 @@ static inline unsigned int erofs_xattr_entry_size(struct erofs_xattr_entry *e) e->e_name_len + le16_to_cpu(e->e_value_size)); } +/* represent a zeroed chunk (hole) */ +#define EROFS_NULL_ADDR -1 + +/* 4-byte block address array */ +#define EROFS_BLOCK_MAP_ENTRY_SIZE sizeof(__le32) + +/* 8-byte inode chunk indexes */ +struct erofs_inode_chunk_index { + __le16 advise; /* always 0, don't care for now */ + __le16 device_id; /* back-end storage id, always 0 for now */ + __le32 blkaddr; /* start block address of this inode chunk */ +}; + /* available compression algorithm types (for h_algorithmtype) */ enum { Z_EROFS_COMPRESSION_LZ4 = 0, @@ -307,9 +346,14 @@ static inline void erofs_check_ondisk_layout_definitions(void) BUILD_BUG_ON(sizeof(struct erofs_inode_extended) != 64); BUILD_BUG_ON(sizeof(struct erofs_xattr_ibody_header) != 12); BUILD_BUG_ON(sizeof(struct erofs_xattr_entry) != 4); + BUILD_BUG_ON(sizeof(struct erofs_inode_chunk_info) != 4); + BUILD_BUG_ON(sizeof(struct erofs_inode_chunk_index) != 8); BUILD_BUG_ON(sizeof(struct z_erofs_map_header) != 8); BUILD_BUG_ON(sizeof(struct z_erofs_vle_decompressed_index) != 8); BUILD_BUG_ON(sizeof(struct erofs_dirent) != 12); + /* keep in sync between 2 index structures for better extendibility */ + BUILD_BUG_ON(sizeof(struct erofs_inode_chunk_index) != + sizeof(struct z_erofs_vle_decompressed_index)); BUILD_BUG_ON(BIT(Z_EROFS_VLE_DI_CLUSTER_TYPE_BITS) < Z_EROFS_VLE_CLUSTER_TYPE_MAX - 1); -- 2.46.1

From: Gao Xiang <hsiangkao@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/6dcb63ca8ce52fb63d736624f9b8e01... -------------------------------- ANBZ: #1666 commit 1266b4a7ecb679587dc4d098abe56ea53313d569 upstream. Dan reported a new smatch warning [1] "fs/erofs/inode.c:210 erofs_read_inode() error: double free of 'copied'" Due to new chunk-based format handling logic, the error path can be called after kfree(copied). Set "copied = NULL" after kfree(copied) to fix this. [1] https://lore.kernel.org/r/202108251030.bELQozR7-lkp@intel.com Link: https://lore.kernel.org/r/20210825120757.11034-1-hsiangkao@linux.alibaba.com Fixes: c5aa903a59db ("erofs: support reading chunk-based uncompressed files") Reported-by: kernel test robot <lkp@intel.com> Reported-by: Dan Carpenter <dan.carpenter@oracle.com> Reviewed-by: Chao Yu <chao@kernel.org> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/inode.c | 1 + 1 file changed, 1 insertion(+) diff --git a/fs/erofs/inode.c b/fs/erofs/inode.c index ec2f7aac1085..24b2e5da0893 100644 --- a/fs/erofs/inode.c +++ b/fs/erofs/inode.c @@ -127,6 +127,7 @@ static struct page *erofs_read_inode(struct inode *inode, /* fill chunked inode summary info */ vi->chunkformat = le16_to_cpu(die->i_u.c.format); kfree(copied); + copied = NULL; break; case EROFS_INODE_LAYOUT_COMPACT: vi->inode_isize = sizeof(struct erofs_inode_compact); -- 2.46.1

From: Gao Xiang <hsiangkao@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/88c61829ed8ca6bbb996831f2110b08... -------------------------------- ANBZ: #1666 commit e62424651f43cb37e17ca26a7ee9ee42675f24bd upstream. Previously, EROFS mount options are all in the basic types, so erofs_fs_context can be directly copied with assignment. However, when the multiple device feature is introduced, it's hard to handle multiple device information like the other basic mount options. Let's separate basic mount option usage from fs_context, thus multiple device information can be handled gracefully then. No logic changes. Link: https://lore.kernel.org/r/20211007070224.12833-1-hsiangkao@linux.alibaba.com Reviewed-by: Chao Yu <chao@kernel.org> Reviewed-by: Liu Bo <bo.liu@linux.alibaba.com> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/internal.h | 16 ++++++++++------ fs/erofs/super.c | 40 +++++++++++++++++++--------------------- fs/erofs/xattr.c | 4 ++-- fs/erofs/zdata.c | 4 ++-- 4 files changed, 33 insertions(+), 31 deletions(-) diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index 1406a897938c..eeb7adc500c5 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -46,7 +46,7 @@ typedef u64 erofs_off_t; /* data type for filesystem-wide blocks number */ typedef u32 erofs_blk_t; -struct erofs_fs_context { +struct erofs_mount_opts { #ifdef CONFIG_EROFS_FS_ZIP /* current strategy of how to use managed cache */ unsigned char cache_strategy; @@ -57,7 +57,13 @@ struct erofs_fs_context { unsigned int mount_opt; }; +struct erofs_fs_context { + struct erofs_mount_opts opt; +}; + struct erofs_sb_info { + struct erofs_mount_opts opt; /* options */ + #ifdef CONFIG_EROFS_FS_ZIP /* list for all registered superblocks, mainly for shrinker */ struct list_head list; @@ -92,8 +98,6 @@ struct erofs_sb_info { u8 volume_name[16]; /* volume name */ u32 feature_compat; u32 feature_incompat; - - struct erofs_fs_context ctx; /* options */ }; #define EROFS_SB(sb) ((struct erofs_sb_info *)(sb)->s_fs_info) @@ -103,9 +107,9 @@ struct erofs_sb_info { #define EROFS_MOUNT_XATTR_USER 0x00000010 #define EROFS_MOUNT_POSIX_ACL 0x00000020 -#define clear_opt(ctx, option) ((ctx)->mount_opt &= ~EROFS_MOUNT_##option) -#define set_opt(ctx, option) ((ctx)->mount_opt |= EROFS_MOUNT_##option) -#define test_opt(ctx, option) ((ctx)->mount_opt & EROFS_MOUNT_##option) +#define clear_opt(opt, option) ((opt)->mount_opt &= ~EROFS_MOUNT_##option) +#define set_opt(opt, option) ((opt)->mount_opt |= EROFS_MOUNT_##option) +#define test_opt(opt, option) ((opt)->mount_opt & EROFS_MOUNT_##option) enum { EROFS_ZIP_CACHE_DISABLED, diff --git a/fs/erofs/super.c b/fs/erofs/super.c index 299bd0865c6d..9747fb0d6ca2 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -198,14 +198,14 @@ static int erofs_read_superblock(struct super_block *sb) static void erofs_default_options(struct erofs_fs_context *ctx) { #ifdef CONFIG_EROFS_FS_ZIP - ctx->cache_strategy = EROFS_ZIP_CACHE_READAROUND; - ctx->max_sync_decompress_pages = 3; + ctx->opt.cache_strategy = EROFS_ZIP_CACHE_READAROUND; + ctx->opt.max_sync_decompress_pages = 3; #endif #ifdef CONFIG_EROFS_FS_XATTR - set_opt(ctx, XATTR_USER); + set_opt(&ctx->opt, XATTR_USER); #endif #ifdef CONFIG_EROFS_FS_POSIX_ACL - set_opt(ctx, POSIX_ACL); + set_opt(&ctx->opt, POSIX_ACL); #endif } @@ -246,9 +246,9 @@ static int erofs_fc_parse_param(struct fs_context *fc, case Opt_user_xattr: #ifdef CONFIG_EROFS_FS_XATTR if (result.boolean) - set_opt(ctx, XATTR_USER); + set_opt(&ctx->opt, XATTR_USER); else - clear_opt(ctx, XATTR_USER); + clear_opt(&ctx->opt, XATTR_USER); #else errorfc(fc, "{,no}user_xattr options not supported"); #endif @@ -256,16 +256,16 @@ static int erofs_fc_parse_param(struct fs_context *fc, case Opt_acl: #ifdef CONFIG_EROFS_FS_POSIX_ACL if (result.boolean) - set_opt(ctx, POSIX_ACL); + set_opt(&ctx->opt, POSIX_ACL); else - clear_opt(ctx, POSIX_ACL); + clear_opt(&ctx->opt, POSIX_ACL); #else errorfc(fc, "{,no}acl options not supported"); #endif break; case Opt_cache_strategy: #ifdef CONFIG_EROFS_FS_ZIP - ctx->cache_strategy = result.uint_32; + ctx->opt.cache_strategy = result.uint_32; #else errorfc(fc, "compression not supported, cache_strategy ignored"); #endif @@ -354,6 +354,7 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) return -ENOMEM; sb->s_fs_info = sbi; + sbi->opt = ctx->opt; err = erofs_read_superblock(sb); if (err) return err; @@ -365,13 +366,11 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) sb->s_op = &erofs_sops; sb->s_xattr = erofs_xattr_handlers; - if (test_opt(ctx, POSIX_ACL)) + if (test_opt(&sbi->opt, POSIX_ACL)) sb->s_flags |= SB_POSIXACL; else sb->s_flags &= ~SB_POSIXACL; - sbi->ctx = *ctx; - #ifdef CONFIG_EROFS_FS_ZIP xa_init(&sbi->managed_pslots); #endif @@ -415,12 +414,12 @@ static int erofs_fc_reconfigure(struct fs_context *fc) DBG_BUGON(!sb_rdonly(sb)); - if (test_opt(ctx, POSIX_ACL)) + if (test_opt(&ctx->opt, POSIX_ACL)) fc->sb_flags |= SB_POSIXACL; else fc->sb_flags &= ~SB_POSIXACL; - sbi->ctx = *ctx; + sbi->opt = ctx->opt; fc->sb_flags |= SB_RDONLY; return 0; @@ -448,7 +447,6 @@ static int erofs_init_fs_context(struct fs_context *fc) erofs_default_options(fc->fs_private); fc->ops = &erofs_context_ops; - return 0; } @@ -568,26 +566,26 @@ static int erofs_statfs(struct dentry *dentry, struct kstatfs *buf) static int erofs_show_options(struct seq_file *seq, struct dentry *root) { struct erofs_sb_info *sbi __maybe_unused = EROFS_SB(root->d_sb); - struct erofs_fs_context *ctx __maybe_unused = &sbi->ctx; + struct erofs_mount_opts *opt __maybe_unused = &sbi->opt; #ifdef CONFIG_EROFS_FS_XATTR - if (test_opt(ctx, XATTR_USER)) + if (test_opt(opt, XATTR_USER)) seq_puts(seq, ",user_xattr"); else seq_puts(seq, ",nouser_xattr"); #endif #ifdef CONFIG_EROFS_FS_POSIX_ACL - if (test_opt(ctx, POSIX_ACL)) + if (test_opt(opt, POSIX_ACL)) seq_puts(seq, ",acl"); else seq_puts(seq, ",noacl"); #endif #ifdef CONFIG_EROFS_FS_ZIP - if (ctx->cache_strategy == EROFS_ZIP_CACHE_DISABLED) + if (opt->cache_strategy == EROFS_ZIP_CACHE_DISABLED) seq_puts(seq, ",cache_strategy=disabled"); - else if (ctx->cache_strategy == EROFS_ZIP_CACHE_READAHEAD) + else if (opt->cache_strategy == EROFS_ZIP_CACHE_READAHEAD) seq_puts(seq, ",cache_strategy=readahead"); - else if (ctx->cache_strategy == EROFS_ZIP_CACHE_READAROUND) + else if (opt->cache_strategy == EROFS_ZIP_CACHE_READAROUND) seq_puts(seq, ",cache_strategy=readaround"); #endif return 0; diff --git a/fs/erofs/xattr.c b/fs/erofs/xattr.c index 8dd54b420a1d..59148ffc0c1f 100644 --- a/fs/erofs/xattr.c +++ b/fs/erofs/xattr.c @@ -429,7 +429,7 @@ static int shared_getxattr(struct inode *inode, struct getxattr_iter *it) static bool erofs_xattr_user_list(struct dentry *dentry) { - return test_opt(&EROFS_SB(dentry->d_sb)->ctx, XATTR_USER); + return test_opt(&EROFS_SB(dentry->d_sb)->opt, XATTR_USER); } static bool erofs_xattr_trusted_list(struct dentry *dentry) @@ -476,7 +476,7 @@ static int erofs_xattr_generic_get(const struct xattr_handler *handler, switch (handler->flags) { case EROFS_XATTR_INDEX_USER: - if (!test_opt(&sbi->ctx, XATTR_USER)) + if (!test_opt(&sbi->opt, XATTR_USER)) return -EOPNOTSUPP; break; case EROFS_XATTR_INDEX_TRUSTED: diff --git a/fs/erofs/zdata.c b/fs/erofs/zdata.c index 38776205cd2f..17b7c8ecf9a5 100644 --- a/fs/erofs/zdata.c +++ b/fs/erofs/zdata.c @@ -611,7 +611,7 @@ static int z_erofs_do_read_page(struct z_erofs_decompress_frontend *fe, goto err_out; /* preload all compressed pages (maybe downgrade role if necessary) */ - if (should_alloc_managed_pages(fe, sbi->ctx.cache_strategy, map->m_la)) + if (should_alloc_managed_pages(fe, sbi->opt.cache_strategy, map->m_la)) cache_strategy = DELAYEDALLOC; else cache_strategy = DONTALLOC; @@ -1307,7 +1307,7 @@ static void z_erofs_readahead(struct readahead_control *rac) struct erofs_sb_info *const sbi = EROFS_I_SB(inode); unsigned int nr_pages = readahead_count(rac); - bool sync = (nr_pages <= sbi->ctx.max_sync_decompress_pages); + bool sync = (nr_pages <= sbi->opt.max_sync_decompress_pages); struct z_erofs_decompress_frontend f = DECOMPRESS_FRONTEND_INIT(inode); struct page *page, *head = NULL; LIST_HEAD(pagepool); -- 2.46.1

From: Gao Xiang <hsiangkao@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/d5953c04b593dc0fff4807f50d3c2df... -------------------------------- ANBZ: #1666 commit 469407a3b5ed9390cfacb0363d1cc926a51f6a14 upstream. Since the new type of chunk-based files is introduced, there is no need to leave flatmode tracepoints. Rename to erofs_map_blocks instead. Link: https://lore.kernel.org/r/20211209012918.30337-1-hsiangkao@linux.alibaba.com Reviewed-by: Yue Hu <huyue2@yulong.com> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/data.c | 39 ++++++++++++++++-------------------- include/trace/events/erofs.h | 4 ++-- 2 files changed, 19 insertions(+), 24 deletions(-) diff --git a/fs/erofs/data.c b/fs/erofs/data.c index 0e897cfe96ca..125698c6f6e2 100644 --- a/fs/erofs/data.c +++ b/fs/erofs/data.c @@ -49,20 +49,16 @@ static int erofs_map_blocks_flatmode(struct inode *inode, struct erofs_map_blocks *map, int flags) { - int err = 0; erofs_blk_t nblocks, lastblk; u64 offset = map->m_la; struct erofs_inode *vi = EROFS_I(inode); bool tailendpacking = (vi->datalayout == EROFS_INODE_FLAT_INLINE); - trace_erofs_map_blocks_flatmode_enter(inode, map, flags); - nblocks = DIV_ROUND_UP(inode->i_size, PAGE_SIZE); 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; @@ -74,30 +70,23 @@ static int erofs_map_blocks_flatmode(struct inode *inode, vi->xattr_isize + erofs_blkoff(map->m_la); map->m_plen = inode->i_size - offset; - /* inline data should be located in one meta block */ - if (erofs_blkoff(map->m_pa) + map->m_plen > PAGE_SIZE) { + /* 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", vi->nid); DBG_BUGON(1); - err = -EFSCORRUPTED; - goto err_out; + return -EFSCORRUPTED; } - map->m_flags |= EROFS_MAP_META; } else { erofs_err(inode->i_sb, "internal error @ nid: %llu (size %llu), m_la 0x%llx", vi->nid, inode->i_size, map->m_la); DBG_BUGON(1); - err = -EIO; - goto err_out; + return -EIO; } - - map->m_llen = map->m_plen; -err_out: - trace_erofs_map_blocks_flatmode_exit(inode, map, flags, 0); - return err; + return 0; } static int erofs_map_blocks(struct inode *inode, @@ -112,6 +101,7 @@ static int erofs_map_blocks(struct inode *inode, erofs_off_t pos; int err = 0; + trace_erofs_map_blocks_enter(inode, map, flags); map->m_deviceid = 0; if (map->m_la >= inode->i_size) { /* leave out-of-bound access unmapped */ @@ -120,8 +110,10 @@ static int erofs_map_blocks(struct inode *inode, goto out; } - if (vi->datalayout != EROFS_INODE_CHUNK_BASED) - return erofs_map_blocks_flatmode(inode, map, flags); + if (vi->datalayout != EROFS_INODE_CHUNK_BASED) { + err = erofs_map_blocks_flatmode(inode, map, flags); + goto out; + } if (vi->chunkformat & EROFS_CHUNK_FORMAT_INDEXES) unit = sizeof(*idx); /* chunk index */ @@ -133,9 +125,10 @@ static int erofs_map_blocks(struct inode *inode, vi->xattr_isize, unit) + unit * chunknr; page = erofs_get_meta_page(inode->i_sb, erofs_blknr(pos)); - if (IS_ERR(page)) - return PTR_ERR(page); - + if (IS_ERR(page)) { + err = PTR_ERR(page); + 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)); @@ -169,7 +162,9 @@ static int erofs_map_blocks(struct inode *inode, unlock_page(page); put_page(page); out: - map->m_llen = map->m_plen; + if (!err) + map->m_llen = map->m_plen; + trace_erofs_map_blocks_exit(inode, map, flags, 0); return err; } diff --git a/include/trace/events/erofs.h b/include/trace/events/erofs.h index db4f2cec8360..717ddd17acb1 100644 --- a/include/trace/events/erofs.h +++ b/include/trace/events/erofs.h @@ -169,7 +169,7 @@ DECLARE_EVENT_CLASS(erofs__map_blocks_enter, __entry->flags ? show_map_flags(__entry->flags) : "NULL") ); -DEFINE_EVENT(erofs__map_blocks_enter, erofs_map_blocks_flatmode_enter, +DEFINE_EVENT(erofs__map_blocks_enter, erofs_map_blocks_enter, TP_PROTO(struct inode *inode, struct erofs_map_blocks *map, unsigned flags), @@ -221,7 +221,7 @@ DECLARE_EVENT_CLASS(erofs__map_blocks_exit, show_mflags(__entry->mflags), __entry->ret) ); -DEFINE_EVENT(erofs__map_blocks_exit, erofs_map_blocks_flatmode_exit, +DEFINE_EVENT(erofs__map_blocks_exit, erofs_map_blocks_exit, TP_PROTO(struct inode *inode, struct erofs_map_blocks *map, unsigned flags, int ret), -- 2.46.1

From: Gao Xiang <hsiangkao@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/961287873c84a2a80d4a38e67df32b0... -------------------------------- ANBZ: #1666 commit c521e3ad6cc980df6f3bdd2616808ecb973af880 upstream. Get rid of old erofs_get_meta_page() within inode operations by using on-stack meta buffers in order to prepare subpage and folio features. Link: https://lore.kernel.org/r/20220102040017.51352-3-hsiangkao@linux.alibaba.com Reviewed-by: Yue Hu <huyue2@yulong.com> Reviewed-by: Liu Bo <bo.liu@linux.alibaba.com> Reviewed-by: Chao Yu <chao@kernel.org> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/inode.c | 68 +++++++++++++++++++++------------------------ fs/erofs/internal.h | 3 ++ 2 files changed, 35 insertions(+), 36 deletions(-) diff --git a/fs/erofs/inode.c b/fs/erofs/inode.c index 24b2e5da0893..c1abf4c74f37 100644 --- a/fs/erofs/inode.c +++ b/fs/erofs/inode.c @@ -13,8 +13,8 @@ * the inode payload page if it's an extended inode) in order to fill * inline data if possible. */ -static struct page *erofs_read_inode(struct inode *inode, - unsigned int *ofs) +static void *erofs_read_inode(struct erofs_buf *buf, + struct inode *inode, unsigned int *ofs) { struct super_block *sb = inode->i_sb; struct erofs_sb_info *sbi = EROFS_SB(sb); @@ -22,7 +22,7 @@ static struct page *erofs_read_inode(struct inode *inode, const erofs_off_t inode_loc = iloc(sbi, vi->nid); erofs_blk_t blkaddr, nblks = 0; - struct page *page; + void *kaddr; struct erofs_inode_compact *dic; struct erofs_inode_extended *die, *copied = NULL; unsigned int ifmt; @@ -34,14 +34,14 @@ static struct page *erofs_read_inode(struct inode *inode, erofs_dbg("%s, reading inode nid %llu at %u of blkaddr %u", __func__, vi->nid, *ofs, blkaddr); - page = erofs_get_meta_page(sb, blkaddr); - if (IS_ERR(page)) { + kaddr = erofs_read_metabuf(buf, sb, blkaddr, EROFS_KMAP); + if (IS_ERR(kaddr)) { erofs_err(sb, "failed to get inode (nid: %llu) page, err %ld", - vi->nid, PTR_ERR(page)); - return page; + vi->nid, PTR_ERR(kaddr)); + return kaddr; } - dic = page_address(page) + *ofs; + dic = kaddr + *ofs; ifmt = le16_to_cpu(dic->i_format); if (ifmt & ~EROFS_I_ALL) { @@ -62,12 +62,12 @@ static struct page *erofs_read_inode(struct inode *inode, switch (erofs_inode_version(ifmt)) { case EROFS_INODE_LAYOUT_EXTENDED: vi->inode_isize = sizeof(struct erofs_inode_extended); - /* check if the inode acrosses page boundary */ - if (*ofs + vi->inode_isize <= PAGE_SIZE) { + /* check if the extended inode acrosses block boundary */ + if (*ofs + vi->inode_isize <= EROFS_BLKSIZ) { *ofs += vi->inode_isize; die = (struct erofs_inode_extended *)dic; } else { - const unsigned int gotten = PAGE_SIZE - *ofs; + const unsigned int gotten = EROFS_BLKSIZ - *ofs; copied = kmalloc(vi->inode_isize, GFP_NOFS); if (!copied) { @@ -75,18 +75,16 @@ static struct page *erofs_read_inode(struct inode *inode, goto err_out; } memcpy(copied, dic, gotten); - unlock_page(page); - put_page(page); - - page = erofs_get_meta_page(sb, blkaddr + 1); - if (IS_ERR(page)) { - erofs_err(sb, "failed to get inode payload page (nid: %llu), err %ld", - vi->nid, PTR_ERR(page)); + kaddr = erofs_read_metabuf(buf, sb, blkaddr + 1, + EROFS_KMAP); + if (IS_ERR(kaddr)) { + erofs_err(sb, "failed to get inode payload block (nid: %llu), err %ld", + vi->nid, PTR_ERR(kaddr)); kfree(copied); - return page; + return kaddr; } *ofs = vi->inode_isize - gotten; - memcpy((u8 *)copied + gotten, page_address(page), *ofs); + memcpy((u8 *)copied + gotten, kaddr, *ofs); die = copied; } vi->xattr_isize = erofs_xattr_ibody_size(die->i_xattr_icount); @@ -196,7 +194,7 @@ static struct page *erofs_read_inode(struct inode *inode, inode->i_blocks = roundup(inode->i_size, EROFS_BLKSIZ) >> 9; else inode->i_blocks = nblks << LOG_SECTORS_PER_BLOCK; - return page; + return kaddr; bogusimode: erofs_err(inode->i_sb, "bogus i_mode (%o) @ nid %llu", @@ -205,12 +203,11 @@ static struct page *erofs_read_inode(struct inode *inode, err_out: DBG_BUGON(1); kfree(copied); - unlock_page(page); - put_page(page); + erofs_put_metabuf(buf); return ERR_PTR(err); } -static int erofs_fill_symlink(struct inode *inode, void *data, +static int erofs_fill_symlink(struct inode *inode, void *kaddr, unsigned int m_pofs) { struct erofs_inode *vi = EROFS_I(inode); @@ -218,7 +215,7 @@ static int erofs_fill_symlink(struct inode *inode, void *data, /* if it cannot be handled with fast symlink scheme */ if (vi->datalayout != EROFS_INODE_FLAT_INLINE || - inode->i_size >= PAGE_SIZE) { + inode->i_size >= EROFS_BLKSIZ) { inode->i_op = &erofs_symlink_iops; return 0; } @@ -228,8 +225,8 @@ static int erofs_fill_symlink(struct inode *inode, void *data, return -ENOMEM; m_pofs += vi->xattr_isize; - /* inline symlink data shouldn't cross page boundary as well */ - if (m_pofs + inode->i_size > PAGE_SIZE) { + /* inline symlink data shouldn't cross block boundary */ + if (m_pofs + inode->i_size > EROFS_BLKSIZ) { kfree(lnk); erofs_err(inode->i_sb, "inline data cross block boundary @ nid %llu", @@ -237,8 +234,7 @@ static int erofs_fill_symlink(struct inode *inode, void *data, DBG_BUGON(1); return -EFSCORRUPTED; } - - memcpy(lnk, data + m_pofs, inode->i_size); + memcpy(lnk, kaddr + m_pofs, inode->i_size); lnk[inode->i_size] = '\0'; inode->i_link = lnk; @@ -249,16 +245,17 @@ static int erofs_fill_symlink(struct inode *inode, void *data, static int erofs_fill_inode(struct inode *inode, int isdir) { struct erofs_inode *vi = EROFS_I(inode); - struct page *page; + struct erofs_buf buf = __EROFS_BUF_INITIALIZER; + void *kaddr; unsigned int ofs; int err = 0; trace_erofs_fill_inode(inode, isdir); /* read inode base data from disk */ - page = erofs_read_inode(inode, &ofs); - if (IS_ERR(page)) - return PTR_ERR(page); + kaddr = erofs_read_inode(&buf, inode, &ofs); + if (IS_ERR(kaddr)) + return PTR_ERR(kaddr); /* setup the new inode */ switch (inode->i_mode & S_IFMT) { @@ -271,7 +268,7 @@ static int erofs_fill_inode(struct inode *inode, int isdir) inode->i_fop = &erofs_dir_fops; break; case S_IFLNK: - err = erofs_fill_symlink(inode, page_address(page), ofs); + err = erofs_fill_symlink(inode, kaddr, ofs); if (err) goto out_unlock; inode_nohighmem(inode); @@ -295,8 +292,7 @@ static int erofs_fill_inode(struct inode *inode, int isdir) inode->i_mapping->a_ops = &erofs_raw_access_aops; out_unlock: - unlock_page(page); - put_page(page); + erofs_put_metabuf(&buf); return err; } diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index ca6e127e1096..8a495bc4df1e 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -385,6 +385,9 @@ struct erofs_map_dev { /* data.c */ struct page *erofs_get_meta_page(struct super_block *sb, erofs_blk_t blkaddr); +void erofs_put_metabuf(struct erofs_buf *buf); +void *erofs_read_metabuf(struct erofs_buf *buf, struct super_block *sb, + erofs_blk_t blkaddr, enum erofs_kmap_type type); int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *dev); /* inode.c */ -- 2.46.1

From: Gao Xiang <hsiangkao@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/93f1a84e1ec80ff5d623e3ccab57050... -------------------------------- ANBZ: #1666 commit bb88e8da00253bea0e7f0f4cdfd7910572d7799f upstream. Get rid of old erofs_get_meta_page() within xattr operations by using on-stack meta buffers in order to prepare subpage and folio features. Link: https://lore.kernel.org/r/20220102040017.51352-5-hsiangkao@linux.alibaba.com Reviewed-by: Liu Bo <bo.liu@linux.alibaba.com> Reviewed-by: Chao Yu <chao@kernel.org> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/xattr.c | 135 ++++++++++++++--------------------------------- fs/erofs/xattr.h | 1 - 2 files changed, 41 insertions(+), 95 deletions(-) diff --git a/fs/erofs/xattr.c b/fs/erofs/xattr.c index 59148ffc0c1f..7c55336959cb 100644 --- a/fs/erofs/xattr.c +++ b/fs/erofs/xattr.c @@ -2,39 +2,20 @@ /* * Copyright (C) 2017-2018 HUAWEI, Inc. * https://www.huawei.com/ + * Copyright (C) 2021-2022, Alibaba Cloud */ #include <linux/security.h> #include "xattr.h" struct xattr_iter { struct super_block *sb; - struct page *page; + struct erofs_buf buf; void *kaddr; erofs_blk_t blkaddr; unsigned int ofs; }; -static inline void xattr_iter_end(struct xattr_iter *it, bool atomic) -{ - /* the only user of kunmap() is 'init_inode_xattrs' */ - if (!atomic) - kunmap(it->page); - else - kunmap_atomic(it->kaddr); - - unlock_page(it->page); - put_page(it->page); -} - -static inline void xattr_iter_end_final(struct xattr_iter *it) -{ - if (!it->page) - return; - - xattr_iter_end(it, true); -} - static int init_inode_xattrs(struct inode *inode) { struct erofs_inode *const vi = EROFS_I(inode); @@ -43,7 +24,6 @@ static int init_inode_xattrs(struct inode *inode) struct erofs_xattr_ibody_header *ih; struct super_block *sb; struct erofs_sb_info *sbi; - bool atomic_map; int ret = 0; /* the most case is that xattrs of this inode are initialized. */ @@ -91,26 +71,23 @@ static int init_inode_xattrs(struct inode *inode) sb = inode->i_sb; sbi = EROFS_SB(sb); + it.buf = __EROFS_BUF_INITIALIZER; it.blkaddr = erofs_blknr(iloc(sbi, vi->nid) + vi->inode_isize); it.ofs = erofs_blkoff(iloc(sbi, vi->nid) + vi->inode_isize); - it.page = erofs_get_meta_page(sb, it.blkaddr); - if (IS_ERR(it.page)) { - ret = PTR_ERR(it.page); + /* read in shared xattr array (non-atomic, see kmalloc below) */ + it.kaddr = erofs_read_metabuf(&it.buf, sb, it.blkaddr, EROFS_KMAP); + if (IS_ERR(it.kaddr)) { + ret = PTR_ERR(it.kaddr); goto out_unlock; } - /* read in shared xattr array (non-atomic, see kmalloc below) */ - it.kaddr = kmap(it.page); - atomic_map = false; - ih = (struct erofs_xattr_ibody_header *)(it.kaddr + it.ofs); - vi->xattr_shared_count = ih->h_shared_count; vi->xattr_shared_xattrs = kmalloc_array(vi->xattr_shared_count, sizeof(uint), GFP_KERNEL); if (!vi->xattr_shared_xattrs) { - xattr_iter_end(&it, atomic_map); + erofs_put_metabuf(&it.buf); ret = -ENOMEM; goto out_unlock; } @@ -122,25 +99,22 @@ static int init_inode_xattrs(struct inode *inode) if (it.ofs >= EROFS_BLKSIZ) { /* cannot be unaligned */ DBG_BUGON(it.ofs != EROFS_BLKSIZ); - xattr_iter_end(&it, atomic_map); - it.page = erofs_get_meta_page(sb, ++it.blkaddr); - if (IS_ERR(it.page)) { + it.kaddr = erofs_read_metabuf(&it.buf, sb, ++it.blkaddr, + EROFS_KMAP); + if (IS_ERR(it.kaddr)) { kfree(vi->xattr_shared_xattrs); vi->xattr_shared_xattrs = NULL; - ret = PTR_ERR(it.page); + ret = PTR_ERR(it.kaddr); goto out_unlock; } - - it.kaddr = kmap_atomic(it.page); - atomic_map = true; it.ofs = 0; } vi->xattr_shared_xattrs[i] = le32_to_cpu(*(__le32 *)(it.kaddr + it.ofs)); it.ofs += sizeof(__le32); } - xattr_iter_end(&it, atomic_map); + erofs_put_metabuf(&it.buf); /* paired with smp_mb() at the beginning of the function. */ smp_mb(); @@ -172,19 +146,11 @@ static inline int xattr_iter_fixup(struct xattr_iter *it) if (it->ofs < EROFS_BLKSIZ) return 0; - xattr_iter_end(it, true); - it->blkaddr += erofs_blknr(it->ofs); - - it->page = erofs_get_meta_page(it->sb, it->blkaddr); - if (IS_ERR(it->page)) { - int err = PTR_ERR(it->page); - - it->page = NULL; - return err; - } - - it->kaddr = kmap_atomic(it->page); + it->kaddr = erofs_read_metabuf(&it->buf, it->sb, it->blkaddr, + EROFS_KMAP_ATOMIC); + if (IS_ERR(it->kaddr)) + return PTR_ERR(it->kaddr); it->ofs = erofs_blkoff(it->ofs); return 0; } @@ -207,11 +173,10 @@ static int inline_xattr_iter_begin(struct xattr_iter *it, it->blkaddr = erofs_blknr(iloc(sbi, vi->nid) + inline_xattr_ofs); it->ofs = erofs_blkoff(iloc(sbi, vi->nid) + inline_xattr_ofs); - it->page = erofs_get_meta_page(inode->i_sb, it->blkaddr); - if (IS_ERR(it->page)) - return PTR_ERR(it->page); - - it->kaddr = kmap_atomic(it->page); + it->kaddr = erofs_read_metabuf(&it->buf, inode->i_sb, it->blkaddr, + EROFS_KMAP_ATOMIC); + if (IS_ERR(it->kaddr)) + return PTR_ERR(it->kaddr); return vi->xattr_isize - xattr_header_sz; } @@ -272,7 +237,7 @@ static int xattr_foreach(struct xattr_iter *it, it->ofs = 0; } - slice = min_t(unsigned int, PAGE_SIZE - it->ofs, + slice = min_t(unsigned int, EROFS_BLKSIZ - it->ofs, entry.e_name_len - processed); /* handle name */ @@ -307,7 +272,7 @@ static int xattr_foreach(struct xattr_iter *it, it->ofs = 0; } - slice = min_t(unsigned int, PAGE_SIZE - it->ofs, + slice = min_t(unsigned int, EROFS_BLKSIZ - it->ofs, value_sz - processed); op->value(it, processed, it->kaddr + it->ofs, slice); it->ofs += slice; @@ -386,8 +351,6 @@ static int inline_getxattr(struct inode *inode, struct getxattr_iter *it) if (ret != -ENOATTR) break; } - xattr_iter_end_final(&it->it); - return ret ? ret : it->buffer_size; } @@ -404,26 +367,16 @@ static int shared_getxattr(struct inode *inode, struct getxattr_iter *it) xattrblock_addr(sbi, vi->xattr_shared_xattrs[i]); it->it.ofs = xattrblock_offset(sbi, vi->xattr_shared_xattrs[i]); - - if (!i || blkaddr != it->it.blkaddr) { - if (i) - xattr_iter_end(&it->it, true); - - it->it.page = erofs_get_meta_page(sb, blkaddr); - if (IS_ERR(it->it.page)) - return PTR_ERR(it->it.page); - - it->it.kaddr = kmap_atomic(it->it.page); - it->it.blkaddr = blkaddr; - } + it->it.kaddr = erofs_read_metabuf(&it->it.buf, sb, blkaddr, + EROFS_KMAP_ATOMIC); + if (IS_ERR(it->it.kaddr)) + return PTR_ERR(it->it.kaddr); + it->it.blkaddr = blkaddr; ret = xattr_foreach(&it->it, &find_xattr_handlers, NULL); if (ret != -ENOATTR) break; } - if (vi->xattr_shared_count) - xattr_iter_end_final(&it->it); - return ret ? ret : it->buffer_size; } @@ -452,10 +405,11 @@ int erofs_getxattr(struct inode *inode, int index, return ret; it.index = index; - it.name.len = strlen(name); if (it.name.len > EROFS_NAME_LEN) return -ERANGE; + + it.it.buf = __EROFS_BUF_INITIALIZER; it.name.name = name; it.buffer = buffer; @@ -465,6 +419,7 @@ int erofs_getxattr(struct inode *inode, int index, ret = inline_getxattr(inode, &it); if (ret == -ENOATTR) ret = shared_getxattr(inode, &it); + erofs_put_metabuf(&it.it.buf); return ret; } @@ -607,7 +562,6 @@ static int inline_listxattr(struct listxattr_iter *it) if (ret) break; } - xattr_iter_end_final(&it->it); return ret ? ret : it->buffer_ofs; } @@ -625,25 +579,16 @@ static int shared_listxattr(struct listxattr_iter *it) xattrblock_addr(sbi, vi->xattr_shared_xattrs[i]); it->it.ofs = xattrblock_offset(sbi, vi->xattr_shared_xattrs[i]); - if (!i || blkaddr != it->it.blkaddr) { - if (i) - xattr_iter_end(&it->it, true); - - it->it.page = erofs_get_meta_page(sb, blkaddr); - if (IS_ERR(it->it.page)) - return PTR_ERR(it->it.page); - - it->it.kaddr = kmap_atomic(it->it.page); - it->it.blkaddr = blkaddr; - } + it->it.kaddr = erofs_read_metabuf(&it->it.buf, sb, blkaddr, + EROFS_KMAP_ATOMIC); + if (IS_ERR(it->it.kaddr)) + return PTR_ERR(it->it.kaddr); + it->it.blkaddr = blkaddr; ret = xattr_foreach(&it->it, &list_xattr_handlers, NULL); if (ret) break; } - if (vi->xattr_shared_count) - xattr_iter_end_final(&it->it); - return ret ? ret : it->buffer_ofs; } @@ -659,6 +604,7 @@ ssize_t erofs_listxattr(struct dentry *dentry, if (ret) return ret; + it.it.buf = __EROFS_BUF_INITIALIZER; it.dentry = dentry; it.buffer = buffer; it.buffer_size = buffer_size; @@ -667,9 +613,10 @@ ssize_t erofs_listxattr(struct dentry *dentry, it.it.sb = dentry->d_sb; ret = inline_listxattr(&it); - if (ret < 0 && ret != -ENOATTR) - return ret; - return shared_listxattr(&it); + if (ret >= 0 || ret == -ENOATTR) + ret = shared_listxattr(&it); + erofs_put_metabuf(&it.it.buf); + return ret; } #ifdef CONFIG_EROFS_FS_POSIX_ACL diff --git a/fs/erofs/xattr.h b/fs/erofs/xattr.h index 366dcb400525..50e283d0526b 100644 --- a/fs/erofs/xattr.h +++ b/fs/erofs/xattr.h @@ -86,4 +86,3 @@ struct posix_acl *erofs_get_acl(struct inode *inode, int type); #endif #endif - -- 2.46.1

From: Jeffle Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/5def3ba1b8e34139e2d7bf3b872b16b... -------------------------------- ANBZ: #1666 commit ed6e0401e68bdfe08de9b44968fb235ff10ccee1 upstream. The only change is that, meta buffers read cache page without __GFP_FS flag, which shall not matter. Link: https://lore.kernel.org/r/20220209060108.43051-7-jefflexu@linux.alibaba.com Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Chao Yu <chao@kernel.org> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/super.c | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/fs/erofs/super.c b/fs/erofs/super.c index fd7c73adabca..33a223f908a2 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -185,21 +185,19 @@ static int erofs_init_devices(struct super_block *sb, static int erofs_read_superblock(struct super_block *sb) { struct erofs_sb_info *sbi; - struct page *page; + struct erofs_buf buf = __EROFS_BUF_INITIALIZER; struct erofs_super_block *dsb; unsigned int blkszbits; void *data; int ret; - page = read_mapping_page(sb->s_bdev->bd_inode->i_mapping, 0, NULL); - if (IS_ERR(page)) { + data = erofs_read_metabuf(&buf, sb, 0, EROFS_KMAP); + if (IS_ERR(data)) { erofs_err(sb, "cannot read erofs superblock"); - return PTR_ERR(page); + return PTR_ERR(data); } sbi = EROFS_SB(sb); - - data = kmap(page); dsb = (struct erofs_super_block *)(data + EROFS_SUPER_OFFSET); ret = -EINVAL; @@ -252,8 +250,7 @@ static int erofs_read_superblock(struct super_block *sb) /* handle multiple devices */ ret = erofs_init_devices(sb, dsb); out: - kunmap(page); - put_page(page); + erofs_put_metabuf(&buf); return ret; } -- 2.46.1

From: Jeffle Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/29a07ee10787 -------------------------------- ANBZ: #1666 commit c8383054506c77b814489c09877b5db83fd4abf2 upstream. Fscache/CacheFiles used to serve as a local cache for a remote networking fs. A new on-demand read mode will be introduced for CacheFiles, which can boost the scenario where on-demand read semantics are needed, e.g. container image distribution. The essential difference between these two modes is seen when a cache miss occurs: In the original mode, the netfs will fetch the data from the remote server and then write it to the cache file; in on-demand read mode, fetching the data and writing it into the cache is delegated to a user daemon. As the first step, notify the user daemon when looking up cookie. In this case, an anonymous fd is sent to the user daemon, through which the user daemon can write the fetched data to the cache file. Since the user daemon may move the anonymous fd around, e.g. through dup(), an object ID uniquely identifying the cache file is also attached. Also add one advisory flag (FSCACHE_ADV_WANT_CACHE_SIZE) suggesting that the cache file size shall be retrieved at runtime. This helps the scenario where one cache file contains multiple netfs files, e.g. for the purpose of deduplication. In this case, netfs itself has no idea the size of the cache file, whilst the user daemon should give the hint on it. Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> Link: https://lore.kernel.org/r/20220509074028.74954-3-jefflexu@linux.alibaba.com Acked-by: David Howells <dhowells@redhat.com> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/Kconfig | 12 + fs/cachefiles/Makefile | 1 + fs/cachefiles/daemon.c | 87 ++++++- fs/cachefiles/internal.h | 51 ++++ fs/cachefiles/namei.c | 10 + fs/cachefiles/ondemand.c | 388 ++++++++++++++++++++++++++++++ include/trace/events/cachefiles.h | 2 + include/uapi/linux/cachefiles.h | 68 ++++++ lib/radix-tree.c | 1 + 9 files changed, 607 insertions(+), 13 deletions(-) create mode 100644 fs/cachefiles/ondemand.c create mode 100644 include/uapi/linux/cachefiles.h diff --git a/fs/cachefiles/Kconfig b/fs/cachefiles/Kconfig index ff9ca55a9ae9..12174e2616f8 100644 --- a/fs/cachefiles/Kconfig +++ b/fs/cachefiles/Kconfig @@ -38,3 +38,15 @@ config CACHEFILES_HISTOGRAM See Documentation/filesystems/caching/cachefiles.rst for more information. + +config CACHEFILES_ONDEMAND + bool "Support for on-demand read" + depends on CACHEFILES + default n + help + This permits userspace to enable the cachefiles on-demand read mode. + In this mode, when a cache miss occurs, responsibility for fetching + the data lies with the cachefiles backend instead of with the netfs + and is delegated to userspace. + + If unsure, say N. diff --git a/fs/cachefiles/Makefile b/fs/cachefiles/Makefile index 891dedda5905..c247d8b5e4f9 100644 --- a/fs/cachefiles/Makefile +++ b/fs/cachefiles/Makefile @@ -15,5 +15,6 @@ cachefiles-y := \ xattr.o cachefiles-$(CONFIG_CACHEFILES_HISTOGRAM) += proc.o +cachefiles-$(CONFIG_CACHEFILES_ONDEMAND) += ondemand.o obj-$(CONFIG_CACHEFILES) := cachefiles.o diff --git a/fs/cachefiles/daemon.c b/fs/cachefiles/daemon.c index 752c1e43416f..1c85c8dcc0c4 100644 --- a/fs/cachefiles/daemon.c +++ b/fs/cachefiles/daemon.c @@ -73,6 +73,9 @@ static const struct cachefiles_daemon_cmd cachefiles_daemon_cmds[] = { { "inuse", cachefiles_daemon_inuse }, { "secctx", cachefiles_daemon_secctx }, { "tag", cachefiles_daemon_tag }, +#ifdef CONFIG_CACHEFILES_ONDEMAND + { "copen", cachefiles_ondemand_copen }, +#endif { "", NULL } }; @@ -106,6 +109,9 @@ static int cachefiles_daemon_open(struct inode *inode, struct file *file) rwlock_init(&cache->active_lock); init_waitqueue_head(&cache->daemon_pollwq); + INIT_RADIX_TREE(&cache->reqs, GFP_ATOMIC); + idr_init(&cache->ondemand_ids); + /* set default caching limits * - limit at 1% free space and/or free files * - cull below 5% free space and/or free files @@ -123,6 +129,44 @@ static int cachefiles_daemon_open(struct inode *inode, struct file *file) return 0; } +static void cachefiles_flush_reqs(struct cachefiles_cache *cache) +{ + void **slot; + struct radix_tree_iter iter; + struct cachefiles_req *req; + + /* + * Make sure the following two operations won't be reordered. + * 1) set CACHEFILES_DEAD bit + * 2) flush requests in the xarray + * Otherwise the request may be enqueued after xarray has been + * flushed, leaving the orphan request never being completed. + * + * CPU 1 CPU 2 + * ===== ===== + * flush requests in the xarray + * test CACHEFILES_DEAD bit + * enqueue the request + * set CACHEFILES_DEAD bit + */ + smp_mb(); + + xa_lock(&cache->reqs); + radix_tree_for_each_slot(slot, &cache->reqs, &iter, 0) { + req = radix_tree_deref_slot_protected(slot, + &cache->reqs.xa_lock); + BUG_ON(!req); + radix_tree_delete(&cache->reqs, iter.index); + req->error = -EIO; + complete(&req->done); + } + xa_unlock(&cache->reqs); + + xa_lock(&cache->ondemand_ids.idr_rt); + idr_destroy(&cache->ondemand_ids); + xa_unlock(&cache->ondemand_ids.idr_rt); +} + /* * release a cache */ @@ -136,6 +180,8 @@ static int cachefiles_daemon_release(struct inode *inode, struct file *file) set_bit(CACHEFILES_DEAD, &cache->flags); + if (cachefiles_in_ondemand_mode(cache)) + cachefiles_flush_reqs(cache); cachefiles_daemon_unbind(cache); ASSERT(!cache->active_nodes.rb_node); @@ -151,23 +197,14 @@ static int cachefiles_daemon_release(struct inode *inode, struct file *file) return 0; } -/* - * read the cache state - */ -static ssize_t cachefiles_daemon_read(struct file *file, char __user *_buffer, - size_t buflen, loff_t *pos) +static ssize_t cachefiles_do_daemon_read(struct cachefiles_cache *cache, + char __user *_buffer, size_t buflen, loff_t *pos) { - struct cachefiles_cache *cache = file->private_data; unsigned long long b_released; unsigned f_released; char buffer[256]; int n; - //_enter(",,%zu,", buflen); - - if (!test_bit(CACHEFILES_READY, &cache->flags)) - return 0; - /* check how much space the cache has */ cachefiles_has_space(cache, 0, 0); @@ -205,6 +242,25 @@ static ssize_t cachefiles_daemon_read(struct file *file, char __user *_buffer, return n; } +/* + * read the cache state + */ +static ssize_t cachefiles_daemon_read(struct file *file, + char __user *_buffer, size_t buflen, loff_t *pos) +{ + struct cachefiles_cache *cache = file->private_data; + + //_enter(",,%zu,", buflen); + + if (!test_bit(CACHEFILES_READY, &cache->flags)) + return 0; + + if (cachefiles_in_ondemand_mode(cache)) + return cachefiles_ondemand_daemon_read(cache, _buffer, buflen, pos); + else + return cachefiles_do_daemon_read(cache, _buffer, buflen, pos); +} + /* * command the cache */ @@ -296,8 +352,13 @@ static __poll_t cachefiles_daemon_poll(struct file *file, poll_wait(file, &cache->daemon_pollwq, poll); mask = 0; - if (test_bit(CACHEFILES_STATE_CHANGED, &cache->flags)) - mask |= EPOLLIN; + if (cachefiles_in_ondemand_mode(cache)) { + if (!radix_tree_empty(&cache->reqs)) + mask |= EPOLLIN; + } else { + if (test_bit(CACHEFILES_STATE_CHANGED, &cache->flags)) + mask |= EPOLLIN; + } if (test_bit(CACHEFILES_CULLING, &cache->flags)) mask |= EPOLLOUT; diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index cf9bd6401c2d..fed71ad90808 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -18,6 +18,8 @@ #include <linux/cred.h> #include <linux/workqueue.h> #include <linux/security.h> +#include <linux/cachefiles.h> +#include <linux/idr.h> struct cachefiles_cache; struct cachefiles_object; @@ -45,10 +47,15 @@ struct cachefiles_object { uint8_t new; /* T if object new */ spinlock_t work_lock; struct rb_node active_node; /* link in active tree (dentry is key) */ +#ifdef CONFIG_CACHEFILES_ONDEMAND + int ondemand_id; +#endif }; extern struct kmem_cache *cachefiles_object_jar; +#define CACHEFILES_ONDEMAND_ID_CLOSED -1 + /* * Cache files cache definition */ @@ -84,11 +91,30 @@ struct cachefiles_cache { #define CACHEFILES_DEAD 1 /* T if cache dead */ #define CACHEFILES_CULLING 2 /* T if cull engaged */ #define CACHEFILES_STATE_CHANGED 3 /* T if state changed (poll trigger) */ +#define CACHEFILES_ONDEMAND_MODE 4 /* T if in on-demand read mode */ char *rootdirname; /* name of cache root directory */ char *secctx; /* LSM security context */ char *tag; /* cache binding tag */ + struct radix_tree_root reqs; /* xarray of pending on-demand requests */ + struct idr ondemand_ids; /* xarray for ondemand_id allocation */ + u32 ondemand_id_next; }; +static inline bool cachefiles_in_ondemand_mode(struct cachefiles_cache *cache) +{ + return IS_ENABLED(CONFIG_CACHEFILES_ONDEMAND) && + test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags); +} + +struct cachefiles_req { + struct cachefiles_object *object; + struct completion done; + int error; + struct cachefiles_msg msg; +}; + +#define CACHEFILES_REQ_NEW 0 + /* * backing file read tracking */ @@ -217,6 +243,31 @@ extern int cachefiles_allocate_pages(struct fscache_retrieval *, extern int cachefiles_write_page(struct fscache_storage *, struct page *); extern void cachefiles_uncache_page(struct fscache_object *, struct page *); +/* + * ondemand.c + */ +#ifdef CONFIG_CACHEFILES_ONDEMAND +extern ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, + char __user *_buffer, size_t buflen, loff_t *pos); + +extern int cachefiles_ondemand_copen(struct cachefiles_cache *cache, + char *args); + +extern int cachefiles_ondemand_init_object(struct cachefiles_object *object); + +#else +static inline ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, + char __user *_buffer, size_t buflen, loff_t *pos) +{ + return -EOPNOTSUPP; +} + +static inline int cachefiles_ondemand_init_object(struct cachefiles_object *object) +{ + return 0; +} +#endif + /* * security.c */ diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c index ecc8ecbbfa5a..22a409669fd0 100644 --- a/fs/cachefiles/namei.c +++ b/fs/cachefiles/namei.c @@ -592,6 +592,10 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, if (ret < 0) goto no_space_error; + ret = cachefiles_ondemand_init_object(object); + if (ret < 0) + goto create_error; + path.dentry = dir; ret = security_path_mknod(&path, next, S_IFREG, 0); if (ret < 0) @@ -636,6 +640,12 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, if (!object->new) { _debug("validate '%pd'", next); + ret = cachefiles_ondemand_init_object(object); + if (ret < 0) { + object->dentry = NULL; + goto error; + } + ret = cachefiles_check_object_xattr(object, auxdata); if (ret == -ESTALE) { /* delete the object (the deleter drops the directory diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c new file mode 100644 index 000000000000..ff2f00cfa5d4 --- /dev/null +++ b/fs/cachefiles/ondemand.c @@ -0,0 +1,388 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +#include <linux/fdtable.h> +#include <linux/file.h> +#include <linux/anon_inodes.h> +#include <linux/uio.h> +#include "internal.h" + +static int cachefiles_ondemand_fd_release(struct inode *inode, + struct file *file) +{ + struct cachefiles_object *object = file->private_data; + int object_id = object->ondemand_id; + struct cachefiles_cache *cache; + + cache = container_of(object->fscache.cache, + struct cachefiles_cache, cache); + + object->ondemand_id = CACHEFILES_ONDEMAND_ID_CLOSED; + xa_lock(&cache->ondemand_ids.idr_rt); + idr_remove(&cache->ondemand_ids, object_id); + xa_unlock(&cache->ondemand_ids.idr_rt); + object->fscache.cache->ops->put_object(&object->fscache, + cachefiles_obj_put_ondemand_fd); + return 0; +} + +static ssize_t cachefiles_ondemand_fd_write_iter(struct kiocb *kiocb, + struct iov_iter *iter) +{ + struct cachefiles_object *object = kiocb->ki_filp->private_data; + struct cachefiles_cache *cache; + size_t len = iter->count; + loff_t pos = kiocb->ki_pos; + struct path path; + struct file *file; + int ret; + + if (!object->backer) + return -ENOBUFS; + + cache = container_of(object->fscache.cache, + struct cachefiles_cache, cache); + + /* write data to the backing filesystem and let it store it in its + * own time */ + path.mnt = cache->mnt; + path.dentry = object->backer; + file = dentry_open(&path, O_RDWR | O_LARGEFILE | O_DIRECT, + cache->cache_cred); + if (IS_ERR(file)) + return -ENOBUFS; + + ret = vfs_iter_write(file, iter, &pos, 0); + fput(file); + if (ret != len) + return -EIO; + return len; +} + +static const struct file_operations cachefiles_ondemand_fd_fops = { + .owner = THIS_MODULE, + .release = cachefiles_ondemand_fd_release, + .write_iter = cachefiles_ondemand_fd_write_iter, +}; + +/* + * OPEN request Completion (copen) + * - command: "copen <id>,<cache_size>" + * <cache_size> indicates the object size if >=0, error code if negative + */ +int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args) +{ + struct cachefiles_req *req; + struct fscache_cookie *cookie; + char *pid, *psize; + unsigned long id; + long size; + int ret; + + if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags)) + return -EOPNOTSUPP; + + if (!*args) { + pr_err("Empty id specified\n"); + return -EINVAL; + } + + pid = args; + psize = strchr(args, ','); + if (!psize) { + pr_err("Cache size is not specified\n"); + return -EINVAL; + } + + *psize = 0; + psize++; + + ret = kstrtoul(pid, 0, &id); + if (ret) + return ret; + + xa_lock(&cache->reqs); + req = radix_tree_delete(&cache->reqs, id); + xa_unlock(&cache->reqs); + if (!req) + return -EINVAL; + + /* fail OPEN request if copen format is invalid */ + ret = kstrtol(psize, 0, &size); + if (ret) { + req->error = ret; + goto out; + } + + /* fail OPEN request if daemon reports an error */ + if (size < 0) { + if (!IS_ERR_VALUE(size)) + size = -EINVAL; + req->error = size; + goto out; + } + + cookie = req->object->fscache.cookie; + fscache_set_store_limit(&req->object->fscache, size); + if (size) + clear_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags); + else + set_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags); + +out: + complete(&req->done); + return ret; +} + +static int cachefiles_ondemand_get_fd(struct cachefiles_req *req) +{ + struct cachefiles_object *object = req->object; + struct cachefiles_cache *cache; + struct cachefiles_open *load; + struct file *file; + u32 object_id; + int ret, fd; + + ret = object->fscache.cache->ops->grab_object(&object->fscache, + cachefiles_obj_get_ondemand_fd) ? 0 : -EAGAIN; + if (ret) + return ret; + + cache = container_of(object->fscache.cache, + struct cachefiles_cache, cache); + idr_preload(GFP_KERNEL); + xa_lock(&cache->ondemand_ids.idr_rt); + ret = idr_alloc_cyclic(&cache->ondemand_ids, NULL, + 1, INT_MAX, GFP_ATOMIC); + xa_unlock(&cache->ondemand_ids.idr_rt); + idr_preload_end(); + if (ret < 0) + goto err; + object_id = ret; + + fd = get_unused_fd_flags(O_WRONLY); + if (fd < 0) { + ret = fd; + goto err_free_id; + } + + file = anon_inode_getfile("[cachefiles]", &cachefiles_ondemand_fd_fops, + object, O_WRONLY); + if (IS_ERR(file)) { + ret = PTR_ERR(file); + goto err_put_fd; + } + + file->f_mode |= FMODE_PWRITE | FMODE_LSEEK; + fd_install(fd, file); + + load = (void *)req->msg.data; + load->fd = fd; + req->msg.object_id = object_id; + object->ondemand_id = object_id; + return 0; + +err_put_fd: + put_unused_fd(fd); +err_free_id: + xa_lock(&cache->ondemand_ids.idr_rt); + idr_remove(&cache->ondemand_ids, object_id); + xa_unlock(&cache->ondemand_ids.idr_rt); +err: + object->fscache.cache->ops->put_object(&object->fscache, + cachefiles_obj_put_ondemand_fd); + return ret; +} + +ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, + char __user *_buffer, size_t buflen, loff_t *pos) +{ + struct cachefiles_req *req; + struct cachefiles_msg *msg; + unsigned long id = 0; + size_t n; + int ret = 0; + struct radix_tree_iter iter; + void **slot; + + /* + * Search for a request that has not ever been processed, to prevent + * requests from being processed repeatedly. + */ + xa_lock(&cache->reqs); + radix_tree_for_each_tagged(slot, &cache->reqs, &iter, 0, + CACHEFILES_REQ_NEW) { + req = radix_tree_deref_slot_protected(slot, + &cache->reqs.xa_lock); + + msg = &req->msg; + n = msg->len; + + if (n > buflen) { + xa_unlock(&cache->reqs); + return -EMSGSIZE; + } + + radix_tree_iter_tag_clear(&cache->reqs, &iter, + CACHEFILES_REQ_NEW); + xa_unlock(&cache->reqs); + + id = iter.index; + msg->msg_id = id; + + if (msg->opcode == CACHEFILES_OP_OPEN) { + ret = cachefiles_ondemand_get_fd(req); + if (ret) + goto error; + } + + if (copy_to_user(_buffer, msg, n) != 0) { + ret = -EFAULT; + goto err_put_fd; + } + return n; + } + xa_unlock(&cache->reqs); + return 0; + +err_put_fd: + if (msg->opcode == CACHEFILES_OP_OPEN) + __close_fd(current->files, + ((struct cachefiles_open *)msg->data)->fd); +error: + xa_lock(&cache->reqs); + radix_tree_delete(&cache->reqs, id); + xa_unlock(&cache->reqs); + req->error = ret; + complete(&req->done); + return ret; +} + +typedef int (*init_req_fn)(struct cachefiles_req *req, void *private); + +static int cachefiles_ondemand_send_req(struct cachefiles_object *object, + enum cachefiles_opcode opcode, + size_t data_len, + init_req_fn init_req, + void *private) +{ + static atomic64_t global_index = ATOMIC64_INIT(0); + struct cachefiles_cache *cache; + struct cachefiles_req *req; + long id; + int ret; + + cache = container_of(object->fscache.cache, + struct cachefiles_cache, cache); + + if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags)) + return 0; + + if (test_bit(CACHEFILES_DEAD, &cache->flags)) + return -EIO; + + req = kzalloc(sizeof(*req) + data_len, GFP_KERNEL); + if (!req) + return -ENOMEM; + + req->object = object; + init_completion(&req->done); + req->msg.opcode = opcode; + req->msg.len = sizeof(struct cachefiles_msg) + data_len; + + ret = init_req(req, private); + if (ret) + goto out; + + /* + * Stop enqueuing the request when daemon is dying. The + * following two operations need to be atomic as a whole. + * 1) check cache state, and + * 2) enqueue request if cache is alive. + * Otherwise the request may be enqueued after xarray has been + * flushed, leaving the orphan request never being completed. + * + * CPU 1 CPU 2 + * ===== ===== + * test CACHEFILES_DEAD bit + * set CACHEFILES_DEAD bit + * flush requests in the xarray + * enqueue the request + */ + xa_lock(&cache->reqs); + + if (test_bit(CACHEFILES_DEAD, &cache->flags)) { + xa_unlock(&cache->reqs); + ret = -EIO; + goto out; + } + + /* coupled with the barrier in cachefiles_flush_reqs() */ + smp_mb(); + + while (radix_tree_insert(&cache->reqs, + id = atomic64_read(&global_index), req)) + atomic64_inc(&global_index); + + radix_tree_tag_set(&cache->reqs, id, CACHEFILES_REQ_NEW); + xa_unlock(&cache->reqs); + + wake_up_all(&cache->daemon_pollwq); + wait_for_completion(&req->done); + ret = req->error; +out: + kfree(req); + return ret; +} + +static int cachefiles_ondemand_init_open_req(struct cachefiles_req *req, + void *private) +{ + struct cachefiles_object *object = req->object; + struct fscache_cookie *cookie = object->fscache.cookie; + struct fscache_cookie *volume; + struct cachefiles_open *load = (void *)req->msg.data; + size_t volume_key_size, cookie_key_size; + char *cookie_key, *volume_key; + + /* Cookie key is binary data, which is netfs specific. */ + cookie_key_size = cookie->key_len; + if (cookie->key_len <= sizeof(cookie->inline_key)) + cookie_key = cookie->inline_key; + else + cookie_key = cookie->key; + + volume = object->fscache.parent->cookie; + volume_key_size = volume->key_len + 1; + if (volume_key_size <= sizeof(cookie->inline_key)) + volume_key = volume->inline_key; + else + volume_key = volume->key; + + load->volume_key_size = volume_key_size; + load->cookie_key_size = cookie_key_size; + memcpy(load->data, volume_key, volume->key_len); + load->data[volume_key_size - 1] = '\0'; + memcpy(load->data + volume_key_size, cookie_key, cookie_key_size); + return 0; +} + +int cachefiles_ondemand_init_object(struct cachefiles_object *object) +{ + struct fscache_cookie *cookie = object->fscache.cookie; + size_t volume_key_size, cookie_key_size, data_len; + + /* + * CacheFiles will firstly check the cache file under the root cache + * directory. If the coherency check failed, it will fallback to + * creating a new tmpfile as the cache file. Reuse the previously + * allocated object ID if any. + */ + if (object->ondemand_id > 0 || object->type == FSCACHE_COOKIE_TYPE_INDEX) + return 0; + + volume_key_size = object->fscache.parent->cookie->key_len + 1; + cookie_key_size = cookie->key_len; + data_len = sizeof(struct cachefiles_open) + volume_key_size + cookie_key_size; + + return cachefiles_ondemand_send_req(object, CACHEFILES_OP_OPEN, + data_len, cachefiles_ondemand_init_open_req, NULL); +} diff --git a/include/trace/events/cachefiles.h b/include/trace/events/cachefiles.h index 5d9de24cb9c0..d09e369e9d1e 100644 --- a/include/trace/events/cachefiles.h +++ b/include/trace/events/cachefiles.h @@ -21,6 +21,8 @@ enum cachefiles_obj_ref_trace { cachefiles_obj_put_wait_retry = fscache_obj_ref__nr_traces, cachefiles_obj_put_wait_timeo, + cachefiles_obj_get_ondemand_fd, + cachefiles_obj_put_ondemand_fd, cachefiles_obj_ref__nr_traces }; diff --git a/include/uapi/linux/cachefiles.h b/include/uapi/linux/cachefiles.h new file mode 100644 index 000000000000..78caa73e5343 --- /dev/null +++ b/include/uapi/linux/cachefiles.h @@ -0,0 +1,68 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +#ifndef _LINUX_CACHEFILES_H +#define _LINUX_CACHEFILES_H + +#include <linux/types.h> +#include <linux/ioctl.h> + +/* + * Fscache ensures that the maximum length of cookie key is 255. The volume key + * is controlled by netfs, and generally no bigger than 255. + */ +#define CACHEFILES_MSG_MAX_SIZE 1024 + +enum cachefiles_opcode { + CACHEFILES_OP_OPEN, + CACHEFILES_OP_CLOSE, + CACHEFILES_OP_READ, +}; + +/* + * Message Header + * + * @msg_id a unique ID identifying this message + * @opcode message type, CACHEFILE_OP_* + * @len message length, including message header and following data + * @object_id a unique ID identifying a cache file + * @data message type specific payload + */ +struct cachefiles_msg { + __u32 msg_id; + __u32 opcode; + __u32 len; + __u32 object_id; + __u8 data[]; +}; + +/* + * @data contains the volume_key followed directly by the cookie_key. volume_key + * is a NUL-terminated string; @volume_key_size indicates the size of the volume + * key in bytes. cookie_key is binary data, which is netfs specific; + * @cookie_key_size indicates the size of the cookie key in bytes. + * + * @fd identifies an anon_fd referring to the cache file. + */ +struct cachefiles_open { + __u32 volume_key_size; + __u32 cookie_key_size; + __u32 fd; + __u32 flags; + __u8 data[]; +}; + +/* + * @off indicates the starting offset of the requested file range + * @len indicates the length of the requested file range + */ +struct cachefiles_read { + __u64 off; + __u64 len; +}; + +/* + * Reply for READ request + * @arg for this ioctl is the @id field of READ request. + */ +#define CACHEFILES_IOC_READ_COMPLETE _IOW(0x98, 1, int) + +#endif diff --git a/lib/radix-tree.c b/lib/radix-tree.c index cbc691525236..28145bdf6f3f 100644 --- a/lib/radix-tree.c +++ b/lib/radix-tree.c @@ -1059,6 +1059,7 @@ void radix_tree_iter_tag_clear(struct radix_tree_root *root, { node_tag_clear(root, iter->node, tag, iter_offset(iter)); } +EXPORT_SYMBOL(radix_tree_iter_tag_clear); /** * radix_tree_tag_get - get a tag on a radix tree node -- 2.46.1

From: Jeffle Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/d665b925541c -------------------------------- ANBZ: #1666 commit 324b954ac80cff0d11ddb6bde9b6631e45e98620 upstream. Notify the user daemon that cookie is going to be withdrawn, providing a hint that the associated anonymous fd can be closed. Be noted that this is only a hint. The user daemon may close the associated anonymous fd when receiving the CLOSE request, then it will receive another anonymous fd when the cookie gets looked up. Or it may ignore the CLOSE request, and keep writing data through the anonymous fd. However the next time the cookie gets looked up, the user daemon will still receive another new anonymous fd. Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> Acked-by: David Howells <dhowells@redhat.com> Link: https://lore.kernel.org/r/20220425122143.56815-5-jefflexu@linux.alibaba.com Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/interface.c | 2 ++ fs/cachefiles/internal.h | 5 +++++ fs/cachefiles/ondemand.c | 40 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 47 insertions(+) diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c index 4cea5fbf695e..99f50bc59b3c 100644 --- a/fs/cachefiles/interface.c +++ b/fs/cachefiles/interface.c @@ -280,6 +280,8 @@ static void cachefiles_drop_object(struct fscache_object *_object) ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000); #endif + cachefiles_ondemand_clean_object(object); + /* We need to tidy the object up if we did in fact manage to open it. * It's possible for us to get here before the object is fully * initialised if the parent goes away or the object gets retired diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index 52188b42081f..c09a405ef42b 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -257,6 +257,7 @@ extern int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args); extern int cachefiles_ondemand_init_object(struct cachefiles_object *object); +extern void cachefiles_ondemand_clean_object(struct cachefiles_object *object); #else static inline ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, @@ -269,6 +270,10 @@ static inline int cachefiles_ondemand_init_object(struct cachefiles_object *obje { return 0; } + +static inline void cachefiles_ondemand_clean_object(struct cachefiles_object *object) +{ +} #endif /* diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index d134f22e3818..26bdcbba92c5 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -241,6 +241,14 @@ ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, ret = -EFAULT; goto err_put_fd; } + + /* CLOSE request has no reply */ + if (msg->opcode == CACHEFILES_OP_CLOSE) { + xa_lock(&cache->reqs); + radix_tree_delete(&cache->reqs, id); + xa_unlock(&cache->reqs); + complete(&req->done); + } return n; } xa_unlock(&cache->reqs); @@ -321,6 +329,13 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, /* coupled with the barrier in cachefiles_flush_reqs() */ smp_mb(); + if (opcode != CACHEFILES_OP_OPEN && object->ondemand_id <= 0) { + WARN_ON_ONCE(object->ondemand_id == 0); + xa_unlock(&cache->reqs); + ret = -EIO; + goto out; + } + while (radix_tree_insert(&cache->reqs, id = atomic64_read(&global_index), req)) atomic64_inc(&global_index); @@ -368,6 +383,25 @@ static int cachefiles_ondemand_init_open_req(struct cachefiles_req *req, return 0; } +static int cachefiles_ondemand_init_close_req(struct cachefiles_req *req, + void *private) +{ + struct cachefiles_object *object = req->object; + int object_id = object->ondemand_id; + + /* + * It's possible that object id is still 0 if the cookie looking up + * phase failed before OPEN request has ever been sent. Also avoid + * sending CLOSE request for CACHEFILES_ONDEMAND_ID_CLOSED, which means + * anon_fd has already been closed. + */ + if (object_id <= 0) + return -ENOENT; + + req->msg.object_id = object_id; + return 0; +} + int cachefiles_ondemand_init_object(struct cachefiles_object *object) { struct fscache_cookie *cookie = object->fscache.cookie; @@ -389,3 +423,9 @@ int cachefiles_ondemand_init_object(struct cachefiles_object *object) return cachefiles_ondemand_send_req(object, CACHEFILES_OP_OPEN, data_len, cachefiles_ondemand_init_open_req, NULL); } + +void cachefiles_ondemand_clean_object(struct cachefiles_object *object) +{ + cachefiles_ondemand_send_req(object, CACHEFILES_OP_CLOSE, 0, + cachefiles_ondemand_init_close_req, NULL); +} -- 2.46.1

From: Jeffle Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/301da8953886 -------------------------------- ANBZ: #1666 commit 4e4f1788af0e477bca079e5b1ffc42846b3bafee upstream. Enable on-demand read mode by adding an optional parameter to the "bind" command. On-demand mode will be turned on when this parameter is "ondemand", i.e. "bind ondemand". Otherwise cachefiles will work in the original mode. Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> Link: https://lore.kernel.org/r/20220509074028.74954-7-jefflexu@linux.alibaba.com Acked-by: David Howells <dhowells@redhat.com> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/bind.c | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/fs/cachefiles/bind.c b/fs/cachefiles/bind.c index 3b39552c2365..c149d5037cc1 100644 --- a/fs/cachefiles/bind.c +++ b/fs/cachefiles/bind.c @@ -46,11 +46,6 @@ int cachefiles_daemon_bind(struct cachefiles_cache *cache, char *args) cache->bcull_percent < cache->brun_percent && cache->brun_percent < 100); - if (*args) { - pr_err("'bind' command doesn't take an argument\n"); - return -EINVAL; - } - if (!cache->rootdirname) { pr_err("No cache directory specified\n"); return -EINVAL; @@ -62,6 +57,18 @@ int cachefiles_daemon_bind(struct cachefiles_cache *cache, char *args) return -EBUSY; } + if (IS_ENABLED(CONFIG_CACHEFILES_ONDEMAND)) { + if (!strcmp(args, "ondemand")) { + set_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags); + } else if (*args) { + pr_err("Invalid argument to the 'bind' command\n"); + return -EINVAL; + } + } else if (*args) { + pr_err("'bind' command doesn't take an argument\n"); + return -EINVAL; + } + /* make sure we have copies of the tag and dirname strings */ if (!cache->tag) { /* the tag string is released by the fops->release() -- 2.46.1

From: Jia Zhu <zhujia.zj@bytedance.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/7bcc5ad5e2ed -------------------------------- ANBZ: #1722 commit 65aa5f6fd8a12e0a343aaf1815949a79a49e3f35 upstream. When an anonymous fd is released, only flush the requests associated with it, rather than all of requests in xarray. Fixes: 9032b6e8589f ("cachefiles: implement on-demand read") Signed-off-by: Jia Zhu <zhujia.zj@bytedance.com> Signed-off-by: David Howells <dhowells@redhat.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Link: https://listman.redhat.com/archives/linux-cachefs/2022-June/006937.html Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/596 Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> Reviewed-by: Jingbo Xu <jefflexu@linux.alibaba.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/ondemand.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index adc257b80b8e..ad3330f9e3d1 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -29,7 +29,8 @@ static int cachefiles_ondemand_fd_release(struct inode *inode, &cache->reqs.xa_lock); BUG_ON(!req); - if (req->msg.opcode == CACHEFILES_OP_READ) { + if (req->msg.object_id == object_id && + req->msg.opcode == CACHEFILES_OP_READ) { req->error = -EIO; complete(&req->done); radix_tree_iter_delete(&cache->reqs, &iter, slot); -- 2.46.1

From: Jingbo Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/9342646eeaf7 -------------------------------- ANBZ: #3211 Prior to fscache refactoring, the volume key in fscache_volume is a string with trailing NUL; while after refactoring, the volume key in fscache_cookie is actually a string without trailing NUL. Thus the current volume key setup for cachefiles_open may cause oops since it attempts to access volume key from the bad address. This can be reproduced by specifying "fsid" with 10 characters, e.g. "-o fsid=abigdomain". Fix this by determining if volume key is stored in volume->key or volume->inline_key by checking volume->key_len, rather than volume_key_size (which is actually volume->key_len plus 1). Reported-by: Jia Zhu <zhujia.zj@bytedance.com> Fixes: 8fc28945e193 ("cachefiles: notify the user daemon when looking up cookie") Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/881 Link: https://gitee.com/anolis/cloud-kernel/pulls/884 Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/ondemand.c | 14 ++++++++++---- include/uapi/linux/cachefiles.h | 5 +++-- 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index ee0d283ac863..0ea22ae2f96a 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -407,21 +407,27 @@ static int cachefiles_ondemand_init_open_req(struct cachefiles_req *req, { struct cachefiles_object *object = req->object; struct fscache_cookie *cookie = object->fscache.cookie; - struct fscache_cookie *volume; + struct fscache_cookie *volume = object->fscache.parent->cookie; struct cachefiles_open *load = (void *)req->msg.data; size_t volume_key_size, cookie_key_size; char *cookie_key, *volume_key; - /* Cookie key is binary data, which is netfs specific. */ + /* + * cookie_key is a string without trailing '\0', while cachefiles_open + * expects cookie key a string without trailing '\0'. + */ cookie_key_size = cookie->key_len; if (cookie->key_len <= sizeof(cookie->inline_key)) cookie_key = cookie->inline_key; else cookie_key = cookie->key; - volume = object->fscache.parent->cookie; + /* + * volume_key is a string without trailing '\0', while cachefiles_open + * expects volume key a string with trailing '\0'. + */ volume_key_size = volume->key_len + 1; - if (volume_key_size <= sizeof(cookie->inline_key)) + if (volume->key_len <= sizeof(volume->inline_key)) volume_key = volume->inline_key; else volume_key = volume->key; diff --git a/include/uapi/linux/cachefiles.h b/include/uapi/linux/cachefiles.h index 78caa73e5343..b6746a2fe57c 100644 --- a/include/uapi/linux/cachefiles.h +++ b/include/uapi/linux/cachefiles.h @@ -37,8 +37,9 @@ struct cachefiles_msg { /* * @data contains the volume_key followed directly by the cookie_key. volume_key * is a NUL-terminated string; @volume_key_size indicates the size of the volume - * key in bytes. cookie_key is binary data, which is netfs specific; - * @cookie_key_size indicates the size of the cookie key in bytes. + * key in bytes (with trailing NUL). cookie_key is a string without trailing + * NUL; @cookie_key_size indicates the size of the cookie key in bytes (without + * trailing NUL). * * @fd identifies an anon_fd referring to the cache file. */ -- 2.46.1

From: Jingbo Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/732d3a3bc657 -------------------------------- ANBZ: #3211 Refactor the code arrangement of cachefiles_ondemand_daemon_read() a bit to make it more consistent with that of upstream. This is in prep for the following fix which makes on-demand request distribution fairer. Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/881 Link: https://gitee.com/anolis/cloud-kernel/pulls/884 Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/ondemand.c | 68 +++++++++++++++++++++------------------- 1 file changed, 36 insertions(+), 32 deletions(-) diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 3095519841ef..68b8c2a4e6a8 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -253,7 +253,7 @@ static int cachefiles_ondemand_get_fd(struct cachefiles_req *req) ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, char __user *_buffer, size_t buflen, loff_t *pos) { - struct cachefiles_req *req; + struct cachefiles_req *req = NULL; struct cachefiles_msg *msg; unsigned long id = 0; size_t n; @@ -268,46 +268,50 @@ ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, xa_lock(&cache->reqs); radix_tree_for_each_tagged(slot, &cache->reqs, &iter, 0, CACHEFILES_REQ_NEW) { - req = radix_tree_deref_slot_protected(slot, - &cache->reqs.xa_lock); + req = radix_tree_deref_slot_protected(slot, &cache->reqs.xa_lock); + WARN_ON(!req); + break; + } - msg = &req->msg; - n = msg->len; + /* no request tagged with CACHEFILES_REQ_NEW found */ + if (!req) { + xa_unlock(&cache->reqs); + return 0; + } - if (n > buflen) { - xa_unlock(&cache->reqs); - return -EMSGSIZE; - } + msg = &req->msg; + n = msg->len; - radix_tree_iter_tag_clear(&cache->reqs, &iter, - CACHEFILES_REQ_NEW); + if (n > buflen) { xa_unlock(&cache->reqs); + return -EMSGSIZE; + } - id = iter.index; - msg->msg_id = id; + radix_tree_iter_tag_clear(&cache->reqs, &iter, CACHEFILES_REQ_NEW); + xa_unlock(&cache->reqs); - if (msg->opcode == CACHEFILES_OP_OPEN) { - ret = cachefiles_ondemand_get_fd(req); - if (ret) - goto error; - } + id = iter.index; + msg->msg_id = id; - if (copy_to_user(_buffer, msg, n) != 0) { - ret = -EFAULT; - goto err_put_fd; - } + if (msg->opcode == CACHEFILES_OP_OPEN) { + ret = cachefiles_ondemand_get_fd(req); + if (ret) + goto error; + } - /* CLOSE request has no reply */ - if (msg->opcode == CACHEFILES_OP_CLOSE) { - xa_lock(&cache->reqs); - radix_tree_delete(&cache->reqs, id); - xa_unlock(&cache->reqs); - complete(&req->done); - } - return n; + if (copy_to_user(_buffer, msg, n) != 0) { + ret = -EFAULT; + goto err_put_fd; } - xa_unlock(&cache->reqs); - return 0; + + /* CLOSE request has no reply */ + if (msg->opcode == CACHEFILES_OP_CLOSE) { + xa_lock(&cache->reqs); + radix_tree_delete(&cache->reqs, id); + xa_unlock(&cache->reqs); + complete(&req->done); + } + return n; err_put_fd: if (msg->opcode == CACHEFILES_OP_OPEN) -- 2.46.1

From: Jeffle Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/d6d0edd3e332 -------------------------------- ANBZ: #1666 commit 94d78946704f7facd010b9dee5e158921ab37398 upstream. ... so that it can be used in the following introduced fscache mode. Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Link: https://lore.kernel.org/r/20220425122143.56815-10-jefflexu@linux.alibaba.com Acked-by: Chao Yu <chao@kernel.org> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/data.c | 4 ++-- fs/erofs/internal.h | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/fs/erofs/data.c b/fs/erofs/data.c index ac331d1c2e2f..1cfb2d510a30 100644 --- a/fs/erofs/data.c +++ b/fs/erofs/data.c @@ -135,8 +135,8 @@ static int erofs_map_blocks_flatmode(struct inode *inode, return 0; } -static int erofs_map_blocks(struct inode *inode, - struct erofs_map_blocks *map, int flags) +int erofs_map_blocks(struct inode *inode, + struct erofs_map_blocks *map, int flags) { struct super_block *sb = inode->i_sb; struct erofs_inode *vi = EROFS_I(inode); diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index efaa98a84508..7582a711e0f8 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -389,6 +389,8 @@ void erofs_put_metabuf(struct erofs_buf *buf); void *erofs_read_metabuf(struct erofs_buf *buf, struct super_block *sb, erofs_blk_t blkaddr, enum erofs_kmap_type type); int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *dev); +int erofs_map_blocks(struct inode *inode, + struct erofs_map_blocks *map, int flags); /* inode.c */ static inline unsigned long erofs_inode_hash(erofs_nid_t nid) -- 2.46.1

From: Gao Xiang <hsiangkao@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/35a08cf3d012 -------------------------------- ANBZ: #1666 commit c6be2bd0a5dd91f98d6b5d2df2c79bc32993352c upstream. A new fscache based mode is going to be introduced for erofs, in which case on-demand read semantics is implemented through fscache. As the first step, register fscache volume for each erofs filesystem. That means, data blobs can not be shared among erofs filesystems. In the following iteration, we are going to introduce the domain semantics, in which case several erofs filesystems can belong to one domain, and data blobs can be shared among these erofs filesystems of one domain. Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Link: https://lore.kernel.org/r/20220425122143.56815-12-jefflexu@linux.alibaba.com Acked-by: Chao Yu <chao@kernel.org> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/Kconfig | 10 ++++++++ fs/erofs/Makefile | 2 +- fs/erofs/fscache.c | 58 +++++++++++++++++++++++++++++++++++++++++++++ fs/erofs/internal.h | 23 ++++++++++++++++++ fs/erofs/super.c | 12 ++++++++++ 5 files changed, 104 insertions(+), 1 deletion(-) create mode 100644 fs/erofs/fscache.c diff --git a/fs/erofs/Kconfig b/fs/erofs/Kconfig index 4dc00a2320e4..f7222cba2a67 100644 --- a/fs/erofs/Kconfig +++ b/fs/erofs/Kconfig @@ -95,3 +95,13 @@ config EROFS_FS_CLUSTER_PAGE_LIMIT into 8k-unit, hard limit should not be configured less than 2. Otherwise, the image will be refused to mount on this kernel. + +config EROFS_FS_ONDEMAND + bool "EROFS fscache-based on-demand read support" + depends on CACHEFILES_ONDEMAND && (EROFS_FS=m && FSCACHE || EROFS_FS=y && FSCACHE=y) + default n + help + This permits EROFS to use fscache-backed data blobs with on-demand + read support. + + If unsure, say N. \ No newline at end of file diff --git a/fs/erofs/Makefile b/fs/erofs/Makefile index 46f2aa4ba46c..b75be64ffc0b 100644 --- a/fs/erofs/Makefile +++ b/fs/erofs/Makefile @@ -8,4 +8,4 @@ obj-$(CONFIG_EROFS_FS) += erofs.o erofs-objs := super.o inode.o data.o namei.o dir.o utils.o erofs-$(CONFIG_EROFS_FS_XATTR) += xattr.o erofs-$(CONFIG_EROFS_FS_ZIP) += decompressor.o zmap.o zdata.o - +erofs-$(CONFIG_EROFS_FS_ONDEMAND) += fscache.o \ No newline at end of file diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c new file mode 100644 index 000000000000..dbf3f1bb7588 --- /dev/null +++ b/fs/erofs/fscache.c @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2022, Alibaba Cloud + */ +#include <linux/fscache.h> +#include "internal.h" + +struct fscache_netfs erofs_fscache_netfs = { + .name = "erofs", + .version = 0, +}; + +int erofs_fscache_register(void) +{ + return fscache_register_netfs(&erofs_fscache_netfs); +} + +void erofs_fscache_unregister(void) +{ + fscache_unregister_netfs(&erofs_fscache_netfs); +} + +const struct fscache_cookie_def erofs_fscache_super_index_def = { + .name = "EROFS.super", + .type = FSCACHE_COOKIE_TYPE_INDEX, + .check_aux = NULL, +}; + +int erofs_fscache_register_fs(struct super_block *sb) +{ + struct erofs_sb_info *sbi = EROFS_SB(sb); + struct fscache_cookie *volume; + char *name; + int ret = 0; + + name = kasprintf(GFP_KERNEL, "erofs,%s", sbi->opt.fsid); + if (!name) + return -ENOMEM; + + volume = fscache_acquire_cookie(erofs_fscache_netfs.primary_index, + &erofs_fscache_super_index_def, name, strlen(name), + NULL, 0, NULL, 0, true); + if (IS_ERR_OR_NULL(volume)) { + erofs_err(sb, "failed to register volume for %s", name); + ret = volume ? PTR_ERR(volume) : -EOPNOTSUPP; + volume = NULL; + } + sbi->volume = volume; + kfree(name); + return ret; +} + +void erofs_fscache_unregister_fs(struct super_block *sb) +{ + struct erofs_sb_info *sbi = EROFS_SB(sb); + + fscache_relinquish_cookie(sbi->volume, NULL, false); + sbi->volume = NULL; +} diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index 713f120ac49d..a70f80f3b79c 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -64,6 +64,7 @@ struct erofs_mount_opts { unsigned int max_sync_decompress_pages; #endif unsigned int mount_opt; + char *fsid; }; struct erofs_dev_context { @@ -118,6 +119,9 @@ struct erofs_sb_info { u8 volume_name[16]; /* volume name */ u32 feature_compat; u32 feature_incompat; + + /* fscache support */ + struct fscache_cookie *volume; }; #define EROFS_SB(sb) ((struct erofs_sb_info *)(sb)->s_fs_info) @@ -468,6 +472,25 @@ static inline int z_erofs_init_zip_subsystem(void) { return 0; } static inline void z_erofs_exit_zip_subsystem(void) {} #endif /* !CONFIG_EROFS_FS_ZIP */ +/* fscache.c */ +#ifdef CONFIG_EROFS_FS_ONDEMAND +int erofs_fscache_register(void); +void erofs_fscache_unregister(void); +int erofs_fscache_register_fs(struct super_block *sb); +void erofs_fscache_unregister_fs(struct super_block *sb); +#else +static inline int erofs_fscache_register(void) +{ + return 0; +} +static inline void erofs_fscache_unregister(void) {} +static inline int erofs_fscache_register_fs(struct super_block *sb) +{ + return 0; +} +static inline void erofs_fscache_unregister_fs(struct super_block *sb) {} +#endif + #define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */ #endif /* __EROFS_INTERNAL_H */ diff --git a/fs/erofs/super.c b/fs/erofs/super.c index 5a891211c3f8..2b21c5efaff3 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -440,6 +440,10 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) if (erofs_is_fscache_mode(sb)) { sb->s_blocksize = EROFS_BLKSIZ; sb->s_blocksize_bits = LOG_BLOCK_SIZE; + + err = erofs_fscache_register_fs(sb); + if (err) + return err; } else { if (!sb_set_blocksize(sb, EROFS_BLKSIZ)) { erofs_err(sb, "failed to set erofs blksize"); @@ -588,6 +592,7 @@ static void erofs_kill_sb(struct super_block *sb) if (!sbi) return; erofs_free_dev_context(sbi->devs); + erofs_fscache_unregister_fs(sb); kfree(sbi); sb->s_fs_info = NULL; } @@ -638,6 +643,10 @@ static int __init erofs_module_init(void) if (err) goto zip_err; + err = erofs_fscache_register(); + if (err) + goto fscache_err; + err = register_filesystem(&erofs_fs_type); if (err) goto fs_err; @@ -645,6 +654,8 @@ static int __init erofs_module_init(void) return 0; fs_err: + erofs_fscache_unregister(); +fscache_err: z_erofs_exit_zip_subsystem(); zip_err: erofs_exit_shrinker(); @@ -657,6 +668,7 @@ static int __init erofs_module_init(void) static void __exit erofs_module_exit(void) { unregister_filesystem(&erofs_fs_type); + erofs_fscache_unregister(); z_erofs_exit_zip_subsystem(); erofs_exit_shrinker(); -- 2.46.1

From: Gao Xiang <hsiangkao@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/30d2fb2e9a8e -------------------------------- ANBZ: #1666 commit 3c265d7dcefab21a58ca5454c0f778412bde0870 upstream. Introduce one anonymous inode for data blobs so that erofs can cache metadata directly within such anonymous inode. Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Link: https://lore.kernel.org/r/20220425122143.56815-14-jefflexu@linux.alibaba.com Acked-by: Chao Yu <chao@kernel.org> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/fscache.c | 39 ++++++++++++++++++++++++++++++++++++--- fs/erofs/internal.h | 6 ++++-- 2 files changed, 40 insertions(+), 5 deletions(-) diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c index fbda7da6ced9..7659f8ae65c3 100644 --- a/fs/erofs/fscache.c +++ b/fs/erofs/fscache.c @@ -30,11 +30,16 @@ const struct fscache_cookie_def erofs_fscache_inode_object_def = { .type = FSCACHE_COOKIE_TYPE_DATAFILE, }; +static const struct address_space_operations erofs_fscache_meta_aops = { +}; + int erofs_fscache_register_cookie(struct super_block *sb, - struct erofs_fscache **fscache, char *name) + struct erofs_fscache **fscache, + char *name, bool need_inode) { struct erofs_fscache *ctx; struct fscache_cookie *cookie; + int ret; ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) @@ -46,15 +51,40 @@ int erofs_fscache_register_cookie(struct super_block *sb, NULL, 0, NULL, 0, true); if (!cookie) { erofs_err(sb, "failed to get cookie for %s", name); - kfree(ctx); - return -EINVAL; + ret = -EINVAL; + goto err; } //fscache_use_cookie(cookie, false); ctx->cookie = cookie; + if (need_inode) { + struct inode *const inode = new_inode(sb); + + if (!inode) { + erofs_err(sb, "failed to get anon inode for %s", name); + ret = -ENOMEM; + goto err_cookie; + } + + set_nlink(inode, 1); + inode->i_size = OFFSET_MAX; + inode->i_mapping->a_ops = &erofs_fscache_meta_aops; + mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS); + + ctx->inode = inode; + } + *fscache = ctx; return 0; + +err_cookie: +// fscache_unuse_cookie(ctx->cookie, NULL, NULL); + fscache_relinquish_cookie(ctx->cookie, NULL, false); + ctx->cookie = NULL; +err: + kfree(ctx); + return ret; } void erofs_fscache_unregister_cookie(struct erofs_fscache **fscache) @@ -68,6 +98,9 @@ void erofs_fscache_unregister_cookie(struct erofs_fscache **fscache) fscache_relinquish_cookie(ctx->cookie, NULL, false); ctx->cookie = NULL; + iput(ctx->inode); + ctx->inode = NULL; + kfree(ctx); *fscache = NULL; } diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index cd89fb654a11..22844d047566 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -81,6 +81,7 @@ struct erofs_fs_context { struct erofs_fscache { struct fscache_cookie *cookie; + struct inode *inode; }; struct erofs_sb_info { @@ -484,7 +485,8 @@ int erofs_fscache_register_fs(struct super_block *sb); void erofs_fscache_unregister_fs(struct super_block *sb); int erofs_fscache_register_cookie(struct super_block *sb, - struct erofs_fscache **fscache, char *name); + struct erofs_fscache **fscache, + char *name, bool need_inode); void erofs_fscache_unregister_cookie(struct erofs_fscache **fscache); #else static inline int erofs_fscache_register(void) @@ -500,7 +502,7 @@ static inline void erofs_fscache_unregister_fs(struct super_block *sb) {} static inline int erofs_fscache_register_cookie(struct super_block *sb, struct erofs_fscache **fscache, - char *name) + char *name, bool need_inode) { return -EOPNOTSUPP; } -- 2.46.1

From: Gao Xiang <hsiangkao@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/a0e45afbebb0 -------------------------------- ANBZ: #1666 commit 955b478e1b4ad5530cd10395d56d45119d3a3ff4 upstream. Similar to the multi-device mode, erofs could be mounted from one primary data blob (mandatory) and multiple extra data blobs (optional). Register fscache context for each extra data blob. Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Link: https://lore.kernel.org/r/20220425122143.56815-17-jefflexu@linux.alibaba.com Acked-by: Chao Yu <chao@kernel.org> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/data.c | 3 +++ fs/erofs/internal.h | 2 ++ fs/erofs/super.c | 8 +++++++- 3 files changed, 12 insertions(+), 1 deletion(-) diff --git a/fs/erofs/data.c b/fs/erofs/data.c index 1cfb2d510a30..8b4547dc32af 100644 --- a/fs/erofs/data.c +++ b/fs/erofs/data.c @@ -222,6 +222,7 @@ int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *map) /* primary device by default */ map->m_bdev = sb->s_bdev; + map->m_fscache = EROFS_SB(sb)->s_fscache; if (map->m_deviceid) { down_read(&devs->rwsem); @@ -231,6 +232,7 @@ int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *map) return -ENODEV; } map->m_bdev = dif->bdev; + map->m_fscache = dif->fscache; up_read(&devs->rwsem); } else if (devs->extra_devices) { down_read(&devs->rwsem); @@ -246,6 +248,7 @@ int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *map) map->m_pa < startoff + length) { map->m_pa -= startoff; map->m_bdev = dif->bdev; + map->m_fscache = dif->fscache; break; } } diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index 06aa8dc55cfc..e1d526ee5be4 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -49,6 +49,7 @@ typedef u32 erofs_blk_t; struct erofs_device_info { char *path; + struct erofs_fscache *fscache; struct block_device *bdev; u32 blocks; @@ -392,6 +393,7 @@ static inline int z_erofs_map_blocks_iter(struct inode *inode, #endif /* !CONFIG_EROFS_FS_ZIP */ struct erofs_map_dev { + struct erofs_fscache *m_fscache; struct block_device *m_bdev; erofs_off_t m_pa; diff --git a/fs/erofs/super.c b/fs/erofs/super.c index 7af2afd62c40..037369ff7081 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -163,7 +163,12 @@ static int erofs_init_devices(struct super_block *sb, } dis = ptr + erofs_blkoff(pos); - if (!erofs_is_fscache_mode(sb)) { + if (erofs_is_fscache_mode(sb)) { + err = erofs_fscache_register_cookie(sb, &dif->fscache, + dif->path, false); + if (err) + break; + } else { bdev = blkdev_get_by_path(dif->path, FMODE_READ | FMODE_EXCL, sb->s_type); @@ -530,6 +535,7 @@ static int erofs_release_device_info(int id, void *ptr, void *data) if (dif->bdev) blkdev_put(dif->bdev, FMODE_READ | FMODE_EXCL); + erofs_fscache_unregister_cookie(&dif->fscache); kfree(dif->path); kfree(dif); return 0; -- 2.46.1

From: Gao Xiang <hsiangkao@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/2379fb87ba9e -------------------------------- ANBZ: #1666 commit 1442b02b66ad2c568f9d5178b7c3c1287b37e438 upstream. Implement the data plane of reading data from data blobs over fscache for non-inline layout. Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Link: https://lore.kernel.org/r/20220425122143.56815-19-jefflexu@linux.alibaba.com Acked-by: Chao Yu <chao@kernel.org> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/fscache.c | 59 +++++++++++++++++++++++++++++++++++++++++++++ fs/erofs/inode.c | 4 +++ fs/erofs/internal.h | 1 + 3 files changed, 64 insertions(+) diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c index c922dda36bda..5c48656550f7 100644 --- a/fs/erofs/fscache.c +++ b/fs/erofs/fscache.c @@ -89,12 +89,71 @@ static void erofs_fscache_invalidate_page(struct page *page, unsigned int offset ClearPageFsCache(page); } +static int erofs_fscache_readpage(struct file *file, struct page *page) +{ + struct inode *inode = page->mapping->host; + struct super_block *sb = inode->i_sb; + struct erofs_map_blocks map; + struct erofs_map_dev mdev; + erofs_off_t pos = page_offset(page); + loff_t pstart; + int ret; + + map.m_la = pos; + ret = erofs_map_blocks(inode, &map, EROFS_GET_BLOCKS_RAW); + if (ret) + goto out_unlock; + + if (!(map.m_flags & EROFS_MAP_MAPPED)) { + zero_user_segment(page, 0, PAGE_SIZE); + SetPageUptodate(page); + goto out_unlock; + } + + mdev = (struct erofs_map_dev) { + .m_deviceid = map.m_deviceid, + .m_pa = map.m_pa, + }; + + ret = erofs_map_dev(sb, &mdev); + if (ret) + goto out_unlock; + + pstart = mdev.m_pa + (pos - map.m_la); + ret = fscache_read_or_alloc_page2(mdev.m_fscache->cookie, page, + erofs_readpage_from_fscache_complete, + NULL, + GFP_KERNEL, pstart); + switch (ret) { + case 0: /* page found in fscache, read submitted */ + erofs_dbg("%s: submitted", __func__); + return ret; + case -ENOBUFS: /* page won't be cached */ + case -ENODATA: /* page not in cache */ + erofs_err(sb, "%s: %d", __func__, ret); + ret = -EIO; + goto out_unlock; + default: + erofs_err(sb, "unknown error ret = %d", ret); + } + +out_unlock: + unlock_page(page); + return ret; +} + static const struct address_space_operations erofs_fscache_meta_aops = { .readpage = erofs_fscache_meta_readpage, .releasepage = erofs_fscache_release_page, .invalidatepage = erofs_fscache_invalidate_page, }; +const struct address_space_operations erofs_fscache_access_aops = { + .readpage = erofs_fscache_readpage, + .releasepage = erofs_fscache_release_page, + .invalidatepage = erofs_fscache_invalidate_page, +}; + int erofs_fscache_register_cookie(struct super_block *sb, struct erofs_fscache **fscache, char *name, bool need_inode) diff --git a/fs/erofs/inode.c b/fs/erofs/inode.c index b1aca34c47a6..bb6b41cd68b0 100644 --- a/fs/erofs/inode.c +++ b/fs/erofs/inode.c @@ -290,6 +290,10 @@ static int erofs_fill_inode(struct inode *inode, int isdir) goto out_unlock; } inode->i_mapping->a_ops = &erofs_raw_access_aops; +#ifdef CONFIG_EROFS_FS_ONDEMAND + if (erofs_is_fscache_mode(inode->i_sb)) + inode->i_mapping->a_ops = &erofs_fscache_access_aops; +#endif out_unlock: erofs_put_metabuf(&buf); diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index e1d526ee5be4..b9ba4627fdf3 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -491,6 +491,7 @@ int erofs_fscache_register_cookie(struct super_block *sb, struct erofs_fscache **fscache, char *name, bool need_inode); void erofs_fscache_unregister_cookie(struct erofs_fscache **fscache); +extern const struct address_space_operations erofs_fscache_access_aops; #else static inline int erofs_fscache_register(void) { -- 2.46.1

From: Gao Xiang <hsiangkao@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/15a330a92f9f -------------------------------- ANBZ: #1666 commit 9c0cc9c729657446ed001a99488a9d82f5124af4 upstream. Introduce 'fsid' mount option to enable on-demand read sementics, in which case, erofs will be mounted from data blobs. Users could specify the name of primary data blob by this mount option. Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Link: https://lore.kernel.org/r/20220425122143.56815-22-jefflexu@linux.alibaba.com Acked-by: Chao Yu <chao@kernel.org> Tested-by: Zichen Tian <tianzichen@kuaishou.com> Tested-by: Jia Zhu <zhujia.zj@bytedance.com> Tested-by: Yan Song <yansong.ys@antgroup.com> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Huang Jianan <jnhuang@linux.alibaba.com> Reviewed-by: Jeffle Xu <jefflexu@linux.alibaba.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/super.c | 30 +++++++++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/fs/erofs/super.c b/fs/erofs/super.c index 037369ff7081..5529c83d5d83 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -281,6 +281,7 @@ enum { Opt_acl, Opt_cache_strategy, Opt_device, + Opt_fsid, Opt_err }; @@ -297,6 +298,7 @@ static const struct fs_parameter_spec erofs_fs_parameters[] = { fsparam_enum("cache_strategy", Opt_cache_strategy, erofs_param_cache_strategy), fsparam_string("device", Opt_device), + fsparam_string("fsid", Opt_fsid), {} }; @@ -359,6 +361,17 @@ static int erofs_fc_parse_param(struct fs_context *fc, } ++ctx->devs->extra_devices; break; + case Opt_fsid: +#ifdef CONFIG_EROFS_FS_ONDEMAND + kfree(ctx->opt.fsid); + ctx->opt.fsid = kstrdup(param->string, GFP_KERNEL); + if (!ctx->opt.fsid) + return -ENOMEM; +#else + errorfc(fc, "fsid option not supported"); + return -EINVAL; +#endif + break; default: return -ENOPARAM; } @@ -442,6 +455,7 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) sb->s_fs_info = sbi; sbi->opt = ctx->opt; + ctx->opt.fsid = NULL; sbi->devs = ctx->devs; ctx->devs = NULL; @@ -507,6 +521,11 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) static int erofs_fc_get_tree(struct fs_context *fc) { + struct erofs_fs_context *ctx = fc->fs_private; + + if (IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && ctx->opt.fsid) + return get_tree_nodev(fc, erofs_fc_fill_super); + return get_tree_bdev(fc, erofs_fc_fill_super); } @@ -555,6 +574,7 @@ static void erofs_fc_free(struct fs_context *fc) struct erofs_fs_context *ctx = fc->fs_private; erofs_free_dev_context(ctx->devs); + kfree(ctx->opt.fsid); kfree(ctx); } @@ -595,7 +615,10 @@ static void erofs_kill_sb(struct super_block *sb) WARN_ON(sb->s_magic != EROFS_SUPER_MAGIC); - kill_block_super(sb); + if (erofs_is_fscache_mode(sb)) + generic_shutdown_super(sb); + else + kill_block_super(sb); sbi = EROFS_SB(sb); if (!sbi) @@ -603,6 +626,7 @@ static void erofs_kill_sb(struct super_block *sb) erofs_free_dev_context(sbi->devs); erofs_fscache_unregister_cookie(&sbi->s_fscache); erofs_fscache_unregister_fs(sb); + kfree(sbi->opt.fsid); kfree(sbi); sb->s_fs_info = NULL; } @@ -736,6 +760,10 @@ static int erofs_show_options(struct seq_file *seq, struct dentry *root) seq_puts(seq, ",cache_strategy=readahead"); else if (opt->cache_strategy == EROFS_ZIP_CACHE_READAROUND) seq_puts(seq, ",cache_strategy=readaround"); +#endif +#ifdef CONFIG_EROFS_FS_ONDEMAND + if (sbi->opt.fsid) + seq_printf(seq, ",fsid=%s", sbi->opt.fsid); #endif return 0; } -- 2.46.1

From: Jia Zhu <zhujia.zj@bytedance.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/d6c1b4c226b0 -------------------------------- ANBZ: #3211 commit 1015c1016c231b26d4e2c9b3da65b6c043eb97a3 upstream. Use kill_anon_super() instead of generic_shutdown_super() since the mount() in erofs fscache mode uses get_tree_nodev() and associated anon bdev needs to be freed. Fixes: 9c0cc9c729657 ("erofs: add 'fsid' mount option") Suggested-by: Jingbo Xu <jefflexu@linux.alibaba.com> Signed-off-by: Jia Zhu <zhujia.zj@bytedance.com> Reviewed-by: Jingbo Xu <jefflexu@linux.alibaba.com> Link: https://lore.kernel.org/r/20220918043456.147-2-zhujia.zj@bytedance.com Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/884 Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/super.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fs/erofs/super.c b/fs/erofs/super.c index dabcab870a2a..74c9653e6840 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -652,7 +652,7 @@ static void erofs_kill_sb(struct super_block *sb) WARN_ON(sb->s_magic != EROFS_SUPER_MAGIC); if (erofs_is_fscache_mode(sb)) - generic_shutdown_super(sb); + kill_anon_super(sb); else kill_block_super(sb); -- 2.46.1

From: Jeffle Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/56f44bed66bc -------------------------------- ANBZ: #4627 commit 0130e4e8e49f9bd0342d3fc14102470ea9e7230e upstream. erofs over fscache doesn't support the compressed layout yet. It will cause NULL crash if there are compressed inodes contained when working in fscache mode. So far in the erofs based container image distribution scenarios (RAFS v6), the compressed RAFS v6 images are downloaded and then decompressed on demand as an uncompressed erofs image. Then the erofs image is mounted in fscache mode for containers to use. IOWs, currently compressed data is decompressed on the userspace side instead and uncompressed erofs images will be finally cached. The fscache support for the compressed layout is still under development and it will be used for runtime decompression feature. Anyway, to avoid the potential crash, let's leave the compressed inodes unsupported in fscache mode until we support it later. Fixes: 1442b02b66ad ("erofs: implement fscache-based data read for non-inline layout") Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Chao Yu <chao@kernel.org> Link: https://lore.kernel.org/r/20220526010344.118493-1-jefflexu@linux.alibaba.com Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Jingbo Xu <jefflexu@linux.alibaba.com> Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/1561 Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/inode.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/fs/erofs/inode.c b/fs/erofs/inode.c index bb6b41cd68b0..fc05960e228e 100644 --- a/fs/erofs/inode.c +++ b/fs/erofs/inode.c @@ -286,7 +286,10 @@ static int erofs_fill_inode(struct inode *inode, int isdir) } if (erofs_inode_is_data_compressed(vi->datalayout)) { - err = z_erofs_fill_inode(inode); + if (!erofs_is_fscache_mode(inode->i_sb)) + err = z_erofs_fill_inode(inode); + else + err = -EOPNOTSUPP; goto out_unlock; } inode->i_mapping->a_ops = &erofs_raw_access_aops; -- 2.46.1

From: Jingbo Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/d6843be666bf -------------------------------- ANBZ: #2056 Fscache/CacheFiles offer fscache_read_or_alloc_pages() to implement the readahead routine of filesystems using fscache. The implementation of fscache_read_or_alloc_pages() will call .readpage() on each backpage, in which case each backpage will generate an IO request. The performance bottleneck is not an issue when fscache is used as the local cache for network filesystems. However it is not the case for filesystems using fscache in on-demand mode. This patch introduces a new helper fscache_prepare_read() for this use. It first checks if there's any hole inside the requested range, and triggers on-demand read if there's any. This step ensures that all the data is ready there for the requested range. Then it triggers an asynchronous readahead for the backing file. Since FMODE_RANDOM, the following page_cache_sync_readahead() will fallback to force_page_cache_readahead(). At last it will start a synchronous buffer read on the backing file. Since the asynchronous readahead, the following buffer read will find the page cache up to date most times. The buffer read is handled in the context of workers, so that the readahead routine will not be blocked in the synchronous buffer read. Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/692 Reviewed-by: Joseph Qi <joseph.qi@linux.alibaba.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/interface.c | 1 + fs/cachefiles/internal.h | 1 + fs/cachefiles/rdwr.c | 162 ++++++++++++++++++++++++++++++++++ fs/fscache/page.c | 66 ++++++++++++++ include/linux/fscache-cache.h | 5 ++ include/linux/fscache.h | 20 +++++ 6 files changed, 255 insertions(+) diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c index 60b6ca443e8e..634e7041c0f3 100644 --- a/fs/cachefiles/interface.c +++ b/fs/cachefiles/interface.c @@ -573,6 +573,7 @@ const struct fscache_cache_ops cachefiles_cache_ops = { .attr_changed = cachefiles_attr_changed, .read_or_alloc_page = cachefiles_read_or_alloc_page, .read_or_alloc_pages = cachefiles_read_or_alloc_pages, + .prepare_read = cachefiles_prepare_read, .allocate_page = cachefiles_allocate_page, .allocate_pages = cachefiles_allocate_pages, .write_page = cachefiles_write_page, diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index ab0ca3b1cd08..b8ef5be59005 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -241,6 +241,7 @@ extern int cachefiles_read_or_alloc_page(struct fscache_retrieval *, extern int cachefiles_read_or_alloc_pages(struct fscache_retrieval *, struct list_head *, unsigned *, gfp_t); +extern int cachefiles_prepare_read(struct fscache_retrieval *op, pgoff_t index); extern int cachefiles_allocate_page(struct fscache_retrieval *, struct page *, gfp_t); extern int cachefiles_allocate_pages(struct fscache_retrieval *, diff --git a/fs/cachefiles/rdwr.c b/fs/cachefiles/rdwr.c index 7cfbbeee9e87..0e1992bedf71 100644 --- a/fs/cachefiles/rdwr.c +++ b/fs/cachefiles/rdwr.c @@ -9,6 +9,8 @@ #include <linux/slab.h> #include <linux/file.h> #include <linux/swap.h> +#include <linux/backing-dev.h> +#include <linux/uio.h> #include "internal.h" /* @@ -793,6 +795,166 @@ int cachefiles_read_or_alloc_pages(struct fscache_retrieval *op, return -ENOBUFS; } +static int cachefiles_ondemand_check(struct cachefiles_object *object, + loff_t start_pos, size_t len) +{ + struct file *file = object->file; + size_t remained; + loff_t pos; + int ret; + + /* make sure there's no hole in the requested range */ + pos = start_pos; + remained = len; + + while (remained) { + bool again = true; + size_t count = remained; + loff_t off, off2, new_pos; +retry: + off = vfs_llseek(file, pos, SEEK_DATA); + if (off < 0) { + if (off == (loff_t)-ENXIO) + goto ondemand_read; + return -ENODATA; + } + + if (off >= pos + remained) + goto ondemand_read; + + if (off > pos) { + count = off - pos; + goto ondemand_read; + } + + off2 = vfs_llseek(file, pos, SEEK_HOLE); + if (off2 < 0) + return -ENODATA; + + new_pos = min_t(loff_t, off2, pos + remained); + remained -= new_pos - pos; + pos = new_pos; + continue; +ondemand_read: + if (again) { + ret = cachefiles_ondemand_read(object, pos, count); + if (!ret) { + /* recheck if the hole has been filled or not */ + again = false; + goto retry; + } + } + return -ENODATA; + } + return 0; +} + +struct cachefiles_kiocb { + struct kiocb iocb; + struct fscache_retrieval *op; + struct iov_iter iter; + struct work_struct work; + struct bio_vec bvs[]; +}; + +void cachefiles_readpages_work_func(struct work_struct *work) +{ + struct cachefiles_kiocb *ki = container_of(work, struct cachefiles_kiocb, work); + int ret; + + ret = vfs_iocb_iter_read(ki->iocb.ki_filp, &ki->iocb, &ki->iter); + /* complete the request if there's any progress or error occurred */ + if (ret != -EIOCBQUEUED) { + struct fscache_retrieval *op = ki->op; + unsigned int nr_pages = atomic_read(&op->n_pages); + unsigned int done_pages = 0; + int i, error; + + if (ret > 0) + done_pages = ret / PAGE_SIZE; + + for (i = 0; i < nr_pages; i++) { + error = i < done_pages ? 0 : -EIO; + fscache_end_io(op, ki->bvs[i].bv_page, error); + } + + fscache_retrieval_complete(op, nr_pages); + fscache_put_retrieval(op); + kfree(ki); + } +} + +int cachefiles_prepare_read(struct fscache_retrieval *op, pgoff_t index) +{ + struct cachefiles_object *object; + struct cachefiles_kiocb *ki; + loff_t start_pos = op->offset; + unsigned int n, nr_pages = atomic_read(&op->n_pages); + size_t len = nr_pages << PAGE_SHIFT; + struct page **pages; + size_t size; + int i, ret; + + object = container_of(op->op.object, struct cachefiles_object, fscache); + if (!object->backer) + goto all_enobufs; + + /* + * 1. Check if there's hole in the requested range, and trigger an + * on-demand read request if there's any. + */ + ASSERT(start_pos % PAGE_SIZE == 0); + ret = cachefiles_ondemand_check(object, start_pos, len); + if (ret) + goto all_enobufs; + + /* + * 2. Trigger readahead on the backing file in advance. Since + * FMODE_RANDOM, the following page_cache_sync_readahead() will fallback + * to force_page_cache_readahead(). + */ + page_cache_sync_readahead(d_inode(object->backer)->i_mapping, + &object->file->f_ra, object->file, + start_pos / PAGE_SIZE, nr_pages); + + size = sizeof(struct cachefiles_kiocb) + nr_pages * sizeof(struct bio_vec); + ki = kzalloc(size, GFP_KERNEL); + if (!ki) + goto all_enobufs; + + /* reuse the tailing part of ki as pages[] */ + pages = (void *)ki + size - nr_pages * sizeof(struct page *); + n = find_get_pages_contig(op->mapping, index, nr_pages, pages); + if (WARN_ON(n != nr_pages)) { + for (i = 0; i < n; i++) + put_page(pages[i]); + kfree(ki); + goto all_enobufs; + } + + for (i = 0; i < n; i++) { + put_page(pages[i]); + ki->bvs[i].bv_page = pages[i]; + ki->bvs[i].bv_offset = 0; + ki->bvs[i].bv_len = PAGE_SIZE; + } + iov_iter_bvec(&ki->iter, READ, ki->bvs, n, n * PAGE_SIZE); + + ki->iocb.ki_filp = object->file; + ki->iocb.ki_pos = start_pos; + ki->iocb.ki_ioprio = get_current_ioprio(); + ki->op = fscache_get_retrieval(op); + + /* 3. Start a buffer read in worker context */ + INIT_WORK(&ki->work, cachefiles_readpages_work_func); + queue_work(system_unbound_wq, &ki->work); + return 0; + +all_enobufs: + fscache_retrieval_complete(op, nr_pages); + return -ENOBUFS; +} + /* * allocate a block in the cache in which to store a page * - cache withdrawal is prevented by the caller diff --git a/fs/fscache/page.c b/fs/fscache/page.c index 888ace2cc6e1..39a05a43284d 100644 --- a/fs/fscache/page.c +++ b/fs/fscache/page.c @@ -666,6 +666,72 @@ int __fscache_read_or_alloc_pages(struct fscache_cookie *cookie, } EXPORT_SYMBOL(__fscache_read_or_alloc_pages); +int __fscache_prepare_read(struct fscache_cookie *cookie, + struct address_space *mapping, pgoff_t index, + unsigned int nr_pages, loff_t start_pos, + fscache_rw_complete_t term_func, void *context) +{ + struct fscache_retrieval *op; + struct fscache_object *object; + bool wake_cookie = false; + int ret; + + if (hlist_empty(&cookie->backing_objects)) + return -ENOBUFS; + + if (test_bit(FSCACHE_COOKIE_INVALIDATING, &cookie->flags)) { + _leave(" = -ENOBUFS [invalidating]"); + return -ENOBUFS; + } + + ASSERTCMP(cookie->def->type, !=, FSCACHE_COOKIE_TYPE_INDEX); + + if (fscache_wait_for_deferred_lookup(cookie) < 0) + return -ERESTARTSYS; + + op = fscache_alloc_retrieval(cookie, mapping, term_func, context); + if (!op) + return -ENOMEM; + atomic_set(&op->n_pages, nr_pages); + op->offset = start_pos; + + spin_lock(&cookie->lock); + + if (!fscache_cookie_enabled(cookie) || + hlist_empty(&cookie->backing_objects)) + goto nobufs_unlock; + + object = hlist_entry(cookie->backing_objects.first, + struct fscache_object, cookie_link); + + __fscache_use_cookie(cookie); + if (fscache_submit_op(object, &op->op) < 0) + goto nobufs_unlock_dec; + spin_unlock(&cookie->lock); + + ret = fscache_wait_for_operation_activation( + object, &op->op, + __fscache_stat(&fscache_n_retrieval_op_waits), + __fscache_stat(&fscache_n_retrievals_object_dead)); + if (ret < 0) + goto out; + + ret = object->cache->ops->prepare_read(op, index); +out: + fscache_put_retrieval(op); + return ret; + +nobufs_unlock_dec: + wake_cookie = __fscache_unuse_cookie(cookie); +nobufs_unlock: + spin_unlock(&cookie->lock); + fscache_put_retrieval(op); + if (wake_cookie) + __fscache_wake_unused_cookie(cookie); + return -ENOBUFS; +} +EXPORT_SYMBOL(__fscache_prepare_read); + /* * allocate a block in the cache on which to store a page * - we return: diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h index 71ee23f78f1d..31f2f13e2924 100644 --- a/include/linux/fscache-cache.h +++ b/include/linux/fscache-cache.h @@ -161,6 +161,9 @@ typedef int (*fscache_pages_retrieval_func_t)(struct fscache_retrieval *op, unsigned *nr_pages, gfp_t gfp); +typedef int (*fscache_prepare_read_func_t)(struct fscache_retrieval *op, + pgoff_t index); + /** * fscache_get_retrieval - Get an extra reference on a retrieval operation * @op: The retrieval operation to get a reference on @@ -285,6 +288,8 @@ struct fscache_cache_ops { * the cache */ fscache_pages_retrieval_func_t read_or_alloc_pages; + fscache_prepare_read_func_t prepare_read; + /* request a backing block for a page be allocated in the cache so that * it can be written directly */ fscache_page_retrieval_func_t allocate_page; diff --git a/include/linux/fscache.h b/include/linux/fscache.h index ce51b915ad43..f262446f3a49 100644 --- a/include/linux/fscache.h +++ b/include/linux/fscache.h @@ -212,6 +212,13 @@ extern int __fscache_read_or_alloc_pages(struct fscache_cookie *, fscache_rw_complete_t, void *, gfp_t); +extern int __fscache_prepare_read(struct fscache_cookie *cookie, + struct address_space *mapping, + pgoff_t index, + unsigned int nr_pages, + loff_t start_pos, + fscache_rw_complete_t term_func, + void *context); extern int __fscache_alloc_page(struct fscache_cookie *, struct page *, gfp_t); extern int __fscache_write_page(struct fscache_cookie *, struct page *, loff_t, gfp_t); extern void __fscache_uncache_page(struct fscache_cookie *, struct page *); @@ -616,6 +623,19 @@ int fscache_read_or_alloc_pages(struct fscache_cookie *cookie, return -ENOBUFS; } +static inline +int fscache_prepare_read(struct fscache_cookie *cookie, + struct address_space *mapping, pgoff_t index, + unsigned int nr_pages, loff_t start_pos, + fscache_rw_complete_t term_func, void *context) +{ + if (fscache_cookie_valid(cookie) && fscache_cookie_enabled(cookie)) + return __fscache_prepare_read(cookie, mapping, index, + nr_pages, start_pos, term_func, context); + else + return -ENOBUFS; +} + /** * fscache_alloc_page - Allocate a block in which to store a page * @cookie: The cookie representing the cache object -- 2.46.1

From: Jia Zhu <zhujia.zj@bytedance.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/7b8f11795342 -------------------------------- ANBZ: #3234 commit e1de2da0b7ac2dc0120c2ba8c7044788611933ea upstream. Some cleanups. No logic changes. Suggested-by: Jingbo Xu <jefflexu@linux.alibaba.com> Signed-off-by: Jia Zhu <zhujia.zj@bytedance.com> Reviewed-by: Jingbo Xu <jefflexu@linux.alibaba.com> Link: https://lore.kernel.org/r/20220918043456.147-3-zhujia.zj@bytedance.com Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> [jingbo: still use erofs_fscache_unregister_cookie in erofs_put_super] Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/893 Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/fscache.c | 39 +++++++++++++++++++-------------------- fs/erofs/internal.h | 19 +++++++++---------- fs/erofs/super.c | 21 +++++++++------------ 3 files changed, 37 insertions(+), 42 deletions(-) diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c index 95b726357bc3..ade0142d035b 100644 --- a/fs/erofs/fscache.c +++ b/fs/erofs/fscache.c @@ -268,9 +268,8 @@ const struct address_space_operations erofs_fscache_access_aops = { .invalidatepage = erofs_fscache_invalidate_page, }; -int erofs_fscache_register_cookie(struct super_block *sb, - struct erofs_fscache **fscache, - char *name, bool need_inode) +struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb, + char *name, bool need_inode) { struct erofs_fscache *ctx; struct fscache_cookie *cookie; @@ -278,7 +277,7 @@ int erofs_fscache_register_cookie(struct super_block *sb, ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) - return -ENOMEM; + return ERR_PTR(-ENOMEM); cookie = fscache_acquire_cookie(EROFS_SB(sb)->volume, &erofs_fscache_inode_object_def, @@ -310,42 +309,33 @@ int erofs_fscache_register_cookie(struct super_block *sb, ctx->inode = inode; } - *fscache = ctx; - return 0; + return ctx; err_cookie: // fscache_unuse_cookie(ctx->cookie, NULL, NULL); fscache_relinquish_cookie(ctx->cookie, NULL, false); - ctx->cookie = NULL; err: kfree(ctx); - return ret; + return ERR_PTR(ret); } -void erofs_fscache_unregister_cookie(struct erofs_fscache **fscache) +void erofs_fscache_unregister_cookie(struct erofs_fscache *ctx) { - struct erofs_fscache *ctx = *fscache; - if (!ctx) return; //fscache_unuse_cookie(ctx->cookie, NULL, NULL); fscache_relinquish_cookie(ctx->cookie, NULL, false); - ctx->cookie = NULL; - iput(ctx->inode); - ctx->inode = NULL; - kfree(ctx); - *fscache = NULL; } int erofs_fscache_register_fs(struct super_block *sb) { struct erofs_sb_info *sbi = EROFS_SB(sb); struct fscache_cookie *volume; + struct erofs_fscache *fscache; char *name; - int ret = 0; name = kasprintf(GFP_KERNEL, "erofs,%s", sbi->opt.fsid); if (!name) @@ -356,18 +346,27 @@ int erofs_fscache_register_fs(struct super_block *sb) NULL, 0, NULL, 0, true); if (IS_ERR_OR_NULL(volume)) { erofs_err(sb, "failed to register volume for %s", name); - ret = volume ? PTR_ERR(volume) : -EOPNOTSUPP; - volume = NULL; + kfree(name); + return volume ? PTR_ERR(volume) : -EOPNOTSUPP; } sbi->volume = volume; kfree(name); - return ret; + + fscache = erofs_fscache_register_cookie(sb, sbi->opt.fsid, true); + /* acquired volume will be relinquished in kill_sb() */ + if (IS_ERR(fscache)) + return PTR_ERR(fscache); + + sbi->s_fscache = fscache; + return 0; } void erofs_fscache_unregister_fs(struct super_block *sb) { struct erofs_sb_info *sbi = EROFS_SB(sb); + erofs_fscache_unregister_cookie(sbi->s_fscache); fscache_relinquish_cookie(sbi->volume, NULL, false); + sbi->s_fscache = NULL; sbi->volume = NULL; } diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index b9ba4627fdf3..d80da5460197 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -487,10 +487,9 @@ void erofs_fscache_unregister(void); int erofs_fscache_register_fs(struct super_block *sb); void erofs_fscache_unregister_fs(struct super_block *sb); -int erofs_fscache_register_cookie(struct super_block *sb, - struct erofs_fscache **fscache, - char *name, bool need_inode); -void erofs_fscache_unregister_cookie(struct erofs_fscache **fscache); +struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb, + char *name, bool need_inode); +void erofs_fscache_unregister_cookie(struct erofs_fscache *fscache); extern const struct address_space_operations erofs_fscache_access_aops; #else static inline int erofs_fscache_register(void) @@ -500,18 +499,18 @@ static inline int erofs_fscache_register(void) static inline void erofs_fscache_unregister(void) {} static inline int erofs_fscache_register_fs(struct super_block *sb) { - return 0; + return -EOPNOTSUPP; } static inline void erofs_fscache_unregister_fs(struct super_block *sb) {} -static inline int erofs_fscache_register_cookie(struct super_block *sb, - struct erofs_fscache **fscache, - char *name, bool need_inode) +static inline +struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb, + char *name, bool need_inode) { - return -EOPNOTSUPP; + return ERR_PTR(-EOPNOTSUPP); } -static inline void erofs_fscache_unregister_cookie(struct erofs_fscache **fscache) +static inline void erofs_fscache_unregister_cookie(struct erofs_fscache *fscache) { } #endif diff --git a/fs/erofs/super.c b/fs/erofs/super.c index 31ee5e56ac0e..0149e8cb44e6 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -127,10 +127,10 @@ static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb, struct erofs_device_info *dif, erofs_off_t *pos) { struct erofs_sb_info *sbi = EROFS_SB(sb); + struct erofs_fscache *fscache; struct erofs_deviceslot *dis; struct block_device *bdev; void *ptr; - int ret; ptr = erofs_read_metabuf(buf, sb, erofs_blknr(*pos), EROFS_KMAP); if (IS_ERR(ptr)) @@ -148,10 +148,10 @@ static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb, } if (erofs_is_fscache_mode(sb)) { - ret = erofs_fscache_register_cookie(sb, &dif->fscache, - dif->path, false); - if (ret) - return ret; + fscache = erofs_fscache_register_cookie(sb, dif->path, false); + if (IS_ERR(fscache)) + return PTR_ERR(fscache); + dif->fscache = fscache; } else { bdev = blkdev_get_by_path(dif->path, FMODE_READ | FMODE_EXCL, sb->s_type); @@ -502,10 +502,6 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) err = erofs_fscache_register_fs(sb); if (err) return err; - err = erofs_fscache_register_cookie(sb, &sbi->s_fscache, - sbi->opt.fsid, true); - if (err) - return err; err = super_setup_bdi(sb); if (err) @@ -594,7 +590,8 @@ static int erofs_release_device_info(int id, void *ptr, void *data) if (dif->bdev) blkdev_put(dif->bdev, FMODE_READ | FMODE_EXCL); - erofs_fscache_unregister_cookie(&dif->fscache); + erofs_fscache_unregister_cookie(dif->fscache); + dif->fscache = NULL; kfree(dif->path); kfree(dif); return 0; @@ -664,7 +661,6 @@ static void erofs_kill_sb(struct super_block *sb) if (!sbi) return; erofs_free_dev_context(sbi->devs); - erofs_fscache_unregister_cookie(&sbi->s_fscache); erofs_fscache_unregister_fs(sb); kfree(sbi->opt.fsid); kfree(sbi); @@ -683,7 +679,8 @@ static void erofs_put_super(struct super_block *sb) iput(sbi->managed_cache); sbi->managed_cache = NULL; #endif - erofs_fscache_unregister_cookie(&sbi->s_fscache); + erofs_fscache_unregister_cookie(sbi->s_fscache); + sbi->s_fscache = NULL; } static struct file_system_type erofs_fs_type = { -- 2.46.1

From: Jia Zhu <zhujia.zj@bytedance.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/f232efaaee43 -------------------------------- ANBZ: #3234 commit a9849560c55e9e4ab9c53d073363dd6e19ec06ef upstream. Use a pseudo mnt to manage shared cookies. Signed-off-by: Jia Zhu <zhujia.zj@bytedance.com> Reviewed-by: Jingbo Xu <jefflexu@linux.alibaba.com> Link: https://lore.kernel.org/r/20220918043456.147-5-zhujia.zj@bytedance.com Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/893 Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/fscache.c | 13 +++++++++++++ fs/erofs/internal.h | 1 + fs/erofs/super.c | 33 +++++++++++++++++++++++++++++++-- 3 files changed, 45 insertions(+), 2 deletions(-) diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c index e6e68436a493..f99e2fd3a146 100644 --- a/fs/erofs/fscache.c +++ b/fs/erofs/fscache.c @@ -7,6 +7,7 @@ static DEFINE_MUTEX(erofs_domain_list_lock); static LIST_HEAD(erofs_domain_list); +static struct vfsmount *erofs_pseudo_mnt; struct fscache_netfs erofs_fscache_netfs = { .name = "erofs", @@ -279,6 +280,10 @@ static void erofs_fscache_domain_put(struct erofs_domain *domain) mutex_lock(&erofs_domain_list_lock); if (refcount_dec_and_test(&domain->ref)) { list_del(&domain->list); + if (list_empty(&erofs_domain_list)) { + kern_unmount(erofs_pseudo_mnt); + erofs_pseudo_mnt = NULL; + } mutex_unlock(&erofs_domain_list_lock); fscache_relinquish_cookie(domain->volume, NULL, false); kfree(domain->domain_id); @@ -335,6 +340,14 @@ static int erofs_fscache_init_domain(struct super_block *sb) if (err) goto out; + if (!erofs_pseudo_mnt) { + erofs_pseudo_mnt = kern_mount(&erofs_fs_type); + if (IS_ERR(erofs_pseudo_mnt)) { + err = PTR_ERR(erofs_pseudo_mnt); + goto out; + } + } + domain->volume = sbi->volume; refcount_set(&domain->ref, 1); list_add(&domain->list, &erofs_domain_list); diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index 339b21fffe50..7ec852b7d59d 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -329,6 +329,7 @@ static inline unsigned int erofs_inode_datalayout(unsigned int value) } extern const struct super_operations erofs_sops; +extern struct file_system_type erofs_fs_type; extern const struct address_space_operations erofs_raw_access_aops; extern const struct address_space_operations z_erofs_aops; diff --git a/fs/erofs/super.c b/fs/erofs/super.c index 0149e8cb44e6..7b24b6952d30 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -473,6 +473,13 @@ static int erofs_init_managed_cache(struct super_block *sb) static int erofs_init_managed_cache(struct super_block *sb) { return 0; } #endif +static int erofs_fc_fill_pseudo_super(struct super_block *sb, struct fs_context *fc) +{ + static const struct tree_descr empty_descr = {""}; + + return simple_fill_super(sb, EROFS_SUPER_MAGIC, &empty_descr); +} + static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) { struct inode *inode; @@ -555,6 +562,11 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) return 0; } +static int erofs_fc_anon_get_tree(struct fs_context *fc) +{ + return get_tree_nodev(fc, erofs_fc_fill_pseudo_super); +} + static int erofs_fc_get_tree(struct fs_context *fc) { struct erofs_fs_context *ctx = fc->fs_private; @@ -622,10 +634,21 @@ static const struct fs_context_operations erofs_context_ops = { .free = erofs_fc_free, }; +static const struct fs_context_operations erofs_anon_context_ops = { + .get_tree = erofs_fc_anon_get_tree, +}; + static int erofs_init_fs_context(struct fs_context *fc) { - struct erofs_fs_context *ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); + struct erofs_fs_context *ctx; + + /* pseudo mount for anon inodes */ + if (fc->sb_flags & SB_KERNMOUNT) { + fc->ops = &erofs_anon_context_ops; + return 0; + } + ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) return -ENOMEM; ctx->devs = kzalloc(sizeof(struct erofs_dev_context), GFP_KERNEL); @@ -652,6 +675,12 @@ static void erofs_kill_sb(struct super_block *sb) WARN_ON(sb->s_magic != EROFS_SUPER_MAGIC); + /* pseudo mount for anon inodes */ + if (sb->s_flags & SB_KERNMOUNT) { + kill_anon_super(sb); + return; + } + if (erofs_is_fscache_mode(sb)) kill_anon_super(sb); else @@ -683,7 +712,7 @@ static void erofs_put_super(struct super_block *sb) sbi->s_fscache = NULL; } -static struct file_system_type erofs_fs_type = { +struct file_system_type erofs_fs_type = { .owner = THIS_MODULE, .name = "erofs", .init_fs_context = erofs_init_fs_context, -- 2.46.1

From: Jia Zhu <zhujia.zj@bytedance.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/d699a85b7a18 -------------------------------- ANBZ: #3234 commit 2ef164414123fcf574aff7a0be5f71f7e60a3fec upstream. Introduce 'domain_id' mount option to enable shared domain sementics. In which case, the related cookie is shared if two mountpoints in the same domain have the same data blob. Users could specify the name of domain by this mount option. Signed-off-by: Jia Zhu <zhujia.zj@bytedance.com> Reviewed-by: Jingbo Xu <jefflexu@linux.alibaba.com> Link: https://lore.kernel.org/r/20220918043456.147-7-zhujia.zj@bytedance.com Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/893 Conflicts: fs/erofs/super.c Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/super.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/fs/erofs/super.c b/fs/erofs/super.c index 7b24b6952d30..14902817d4e9 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -318,6 +318,7 @@ enum { Opt_cache_strategy, Opt_device, Opt_fsid, + Opt_domain_id, Opt_err }; @@ -335,6 +336,7 @@ static const struct fs_parameter_spec erofs_fs_parameters[] = { erofs_param_cache_strategy), fsparam_string("device", Opt_device), fsparam_string("fsid", Opt_fsid), + fsparam_string("domain_id", Opt_domain_id), {} }; @@ -406,6 +408,16 @@ static int erofs_fc_parse_param(struct fs_context *fc, #else errorfc(fc, "fsid option not supported"); return -EINVAL; +#endif + break; + case Opt_domain_id: +#ifdef CONFIG_EROFS_FS_ONDEMAND + kfree(ctx->opt.domain_id); + ctx->opt.domain_id = kstrdup(param->string, GFP_KERNEL); + if (!ctx->opt.domain_id) + return -ENOMEM; +#else + errorfc(fc, "domain_id option not supported"); #endif break; default: @@ -499,6 +511,7 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) sb->s_fs_info = sbi; sbi->opt = ctx->opt; ctx->opt.fsid = NULL; + ctx->opt.domain_id = NULL; sbi->devs = ctx->devs; ctx->devs = NULL; @@ -624,6 +637,7 @@ static void erofs_fc_free(struct fs_context *fc) erofs_free_dev_context(ctx->devs); kfree(ctx->opt.fsid); + kfree(ctx->opt.domain_id); kfree(ctx); } @@ -692,6 +706,7 @@ static void erofs_kill_sb(struct super_block *sb) erofs_free_dev_context(sbi->devs); erofs_fscache_unregister_fs(sb); kfree(sbi->opt.fsid); + kfree(sbi->opt.domain_id); kfree(sbi); sb->s_fs_info = NULL; } @@ -830,6 +845,8 @@ static int erofs_show_options(struct seq_file *seq, struct dentry *root) #ifdef CONFIG_EROFS_FS_ONDEMAND if (sbi->opt.fsid) seq_printf(seq, ",fsid=%s", sbi->opt.fsid); + if (opt->domain_id) + seq_printf(seq, ",domain_id=%s", opt->domain_id); #endif return 0; } -- 2.46.1

From: Jingbo Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/3dd899f1ae08 -------------------------------- ANBZ: #3234 commit 39bfcb8138f6dc3375f23b1e62ccfc7c0d83295d upstream. When erofs instance is remounted with fsid or domain_id mount option specified, the original fsid and domain_id string pointer in sbi->opt is directly overridden with the fsid and domain_id string in the new fs_context, without freeing the original fsid and domain_id string. What's worse, when the new fsid and domain_id string is transferred to sbi, they are not reset to NULL in fs_context, and thus they are freed when remount finishes, while sbi is still referring to these strings. Reconfiguration for fsid and domain_id seems unusual. Thus clarify this restriction explicitly and dump a warning when users are attempting to do this. Besides, to fix the use-after-free issue, move fsid and domain_id from erofs_mount_opts to outside. Fixes: c6be2bd0a5dd ("erofs: register fscache volume") Fixes: 8b7adf1dff3d ("erofs: introduce fscache-based domain") Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Jia Zhu <zhujia.zj@bytedance.com> Reviewed-by: Chao Yu <chao@kernel.org> Link: https://lore.kernel.org/r/20221021023153.1330-1-jefflexu@linux.alibaba.com Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Reviewed-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/893 Conflicts: fs/erofs/super.c Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/fscache.c | 14 +++++++------- fs/erofs/internal.h | 6 ++++-- fs/erofs/super.c | 39 ++++++++++++++++++++++----------------- 3 files changed, 33 insertions(+), 26 deletions(-) diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c index a6302a06f1e4..5c7208418d44 100644 --- a/fs/erofs/fscache.c +++ b/fs/erofs/fscache.c @@ -298,13 +298,13 @@ static void erofs_fscache_domain_put(struct erofs_domain *domain) static int erofs_fscache_register_volume(struct super_block *sb) { struct erofs_sb_info *sbi = EROFS_SB(sb); - char *domain_id = sbi->opt.domain_id; + char *domain_id = sbi->domain_id; struct fscache_cookie *volume; char *name; int ret = 0; name = kasprintf(GFP_KERNEL, "erofs,%s", - domain_id ? domain_id : sbi->opt.fsid); + domain_id ? domain_id : sbi->fsid); if (!name) return -ENOMEM; @@ -332,7 +332,7 @@ static int erofs_fscache_init_domain(struct super_block *sb) if (!domain) return -ENOMEM; - domain->domain_id = kstrdup(sbi->opt.domain_id, GFP_KERNEL); + domain->domain_id = kstrdup(sbi->domain_id, GFP_KERNEL); if (!domain->domain_id) { kfree(domain); return -ENOMEM; @@ -369,7 +369,7 @@ static int erofs_fscache_register_domain(struct super_block *sb) mutex_lock(&erofs_domain_list_lock); list_for_each_entry(domain, &erofs_domain_list, list) { - if (!strcmp(domain->domain_id, sbi->opt.domain_id)) { + if (!strcmp(domain->domain_id, sbi->domain_id)) { sbi->domain = domain; sbi->volume = domain->volume; refcount_inc(&domain->ref); @@ -507,7 +507,7 @@ struct erofs_fscache *erofs_domain_register_cookie(struct super_block *sb, struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb, char *name, bool need_inode) { - if (EROFS_SB(sb)->opt.domain_id) + if (EROFS_SB(sb)->domain_id) return erofs_domain_register_cookie(sb, name, need_inode); return erofs_fscache_acquire_cookie(sb, name, need_inode); } @@ -539,7 +539,7 @@ int erofs_fscache_register_fs(struct super_block *sb) struct erofs_sb_info *sbi = EROFS_SB(sb); struct erofs_fscache *fscache; - if (sbi->opt.domain_id) + if (sbi->domain_id) ret = erofs_fscache_register_domain(sb); else ret = erofs_fscache_register_volume(sb); @@ -547,7 +547,7 @@ int erofs_fscache_register_fs(struct super_block *sb) return ret; /* acquired domain/volume will be relinquished in kill_sb() on error */ - fscache = erofs_fscache_register_cookie(sb, sbi->opt.fsid, true); + fscache = erofs_fscache_register_cookie(sb, sbi->fsid, true); if (IS_ERR(fscache)) return PTR_ERR(fscache); diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index 82a47b6ff9ca..59de35fec51e 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -65,8 +65,6 @@ struct erofs_mount_opts { unsigned int max_sync_decompress_pages; #endif unsigned int mount_opt; - char *fsid; - char *domain_id; }; struct erofs_dev_context { @@ -79,6 +77,8 @@ struct erofs_dev_context { struct erofs_fs_context { struct erofs_mount_opts opt; struct erofs_dev_context *devs; + char *fsid; + char *domain_id; }; struct erofs_domain { @@ -141,6 +141,8 @@ struct erofs_sb_info { struct fscache_cookie *volume; struct erofs_fscache *s_fscache; struct erofs_domain *domain; + char *fsid; + char *domain_id; }; #define EROFS_SB(sb) ((struct erofs_sb_info *)(sb)->s_fs_info) diff --git a/fs/erofs/super.c b/fs/erofs/super.c index 14902817d4e9..606d4637a795 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -401,9 +401,9 @@ static int erofs_fc_parse_param(struct fs_context *fc, break; case Opt_fsid: #ifdef CONFIG_EROFS_FS_ONDEMAND - kfree(ctx->opt.fsid); - ctx->opt.fsid = kstrdup(param->string, GFP_KERNEL); - if (!ctx->opt.fsid) + kfree(ctx->fsid); + ctx->fsid = kstrdup(param->string, GFP_KERNEL); + if (!ctx->fsid) return -ENOMEM; #else errorfc(fc, "fsid option not supported"); @@ -412,9 +412,9 @@ static int erofs_fc_parse_param(struct fs_context *fc, break; case Opt_domain_id: #ifdef CONFIG_EROFS_FS_ONDEMAND - kfree(ctx->opt.domain_id); - ctx->opt.domain_id = kstrdup(param->string, GFP_KERNEL); - if (!ctx->opt.domain_id) + kfree(ctx->domain_id); + ctx->domain_id = kstrdup(param->string, GFP_KERNEL); + if (!ctx->domain_id) return -ENOMEM; #else errorfc(fc, "domain_id option not supported"); @@ -510,10 +510,12 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) sb->s_fs_info = sbi; sbi->opt = ctx->opt; - ctx->opt.fsid = NULL; - ctx->opt.domain_id = NULL; sbi->devs = ctx->devs; ctx->devs = NULL; + sbi->fsid = ctx->fsid; + ctx->fsid = NULL; + sbi->domain_id = ctx->domain_id; + ctx->domain_id = NULL; if (erofs_is_fscache_mode(sb)) { sb->s_blocksize = EROFS_BLKSIZ; @@ -584,7 +586,7 @@ static int erofs_fc_get_tree(struct fs_context *fc) { struct erofs_fs_context *ctx = fc->fs_private; - if (IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && ctx->opt.fsid) + if (IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && ctx->fsid) return get_tree_nodev(fc, erofs_fc_fill_super); return get_tree_bdev(fc, erofs_fc_fill_super); @@ -598,6 +600,9 @@ static int erofs_fc_reconfigure(struct fs_context *fc) DBG_BUGON(!sb_rdonly(sb)); + if (ctx->fsid || ctx->domain_id) + erofs_info(sb, "ignoring reconfiguration for fsid|domain_id."); + if (test_opt(&ctx->opt, POSIX_ACL)) fc->sb_flags |= SB_POSIXACL; else @@ -636,8 +641,8 @@ static void erofs_fc_free(struct fs_context *fc) struct erofs_fs_context *ctx = fc->fs_private; erofs_free_dev_context(ctx->devs); - kfree(ctx->opt.fsid); - kfree(ctx->opt.domain_id); + kfree(ctx->fsid); + kfree(ctx->domain_id); kfree(ctx); } @@ -705,8 +710,8 @@ static void erofs_kill_sb(struct super_block *sb) return; erofs_free_dev_context(sbi->devs); erofs_fscache_unregister_fs(sb); - kfree(sbi->opt.fsid); - kfree(sbi->opt.domain_id); + kfree(sbi->fsid); + kfree(sbi->domain_id); kfree(sbi); sb->s_fs_info = NULL; } @@ -843,10 +848,10 @@ static int erofs_show_options(struct seq_file *seq, struct dentry *root) seq_puts(seq, ",cache_strategy=readaround"); #endif #ifdef CONFIG_EROFS_FS_ONDEMAND - if (sbi->opt.fsid) - seq_printf(seq, ",fsid=%s", sbi->opt.fsid); - if (opt->domain_id) - seq_printf(seq, ",domain_id=%s", opt->domain_id); + if (sbi->fsid) + seq_printf(seq, ",fsid=%s", sbi->fsid); + if (sbi->domain_id) + seq_printf(seq, ",domain_id=%s", sbi->domain_id); #endif return 0; } -- 2.46.1

From: Jingbo Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/770910348d2b -------------------------------- ANBZ: #4201 This optimization is inspired by [1]. When the on-demand routine is triggered, the user daemon will fetch data from remote and then write the fetched data to the backing file with DIRECT IO to avoid double page cache. When the on-demand routine finishes, the process requesting for IO will read data from the backing file (also with DIRECT IO). This mechanism will cause read latency since these two DIRECT IO. To optimize this, make the user daemon buffer write the backing file. Make the process requesting for IO read data from the page cache of the backing file first if there's any, and otherwise fallback to the DIRECT IO. Be noted that this patch only refactors the write routine to buffered IO, because the read routine prior to the refactoring of FsCache/Cachefiles, i.e. cachefiles_read_backing_file_one() in the normal read path and cachefiles_prepare_read() in the readahead path, has already worked in this way of trying to buffer read first. Link: [1] https://github.com/dragonflyoss/image-service/blob/master/contrib/kernel-pat... Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/1252 Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/ondemand.c | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 250b98e9820c..950dc5a71cb6 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -3,8 +3,12 @@ #include <linux/file.h> #include <linux/anon_inodes.h> #include <linux/uio.h> +#include <linux/module.h> #include "internal.h" +static bool cachefiles_buffered_ondemand = true; +module_param_named(buffered_ondemand, cachefiles_buffered_ondemand, bool, 0644); + static int cachefiles_ondemand_fd_release(struct inode *inode, struct file *file) { @@ -52,13 +56,23 @@ static ssize_t cachefiles_ondemand_fd_write_iter(struct kiocb *kiocb, { struct cachefiles_object *object = kiocb->ki_filp->private_data; size_t len = iter->count; - loff_t pos = kiocb->ki_pos; + struct kiocb iocb; int ret; if (!object->file) return -ENOBUFS; - ret = vfs_iter_write(object->file, iter, &pos, 0); + iocb = (struct kiocb) { + .ki_filp = object->file, + .ki_pos = kiocb->ki_pos, + .ki_flags = IOCB_WRITE, + .ki_ioprio = get_current_ioprio(), + }; + + if (!cachefiles_buffered_ondemand) + iocb.ki_flags |= IOCB_DIRECT; + + ret = vfs_iocb_iter_write(object->file, &iocb, iter); if (ret != len) return -EIO; return len; -- 2.46.1

From: Jia Zhu <zhujia.zj@bytedance.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/538bf7c68f81 -------------------------------- ANBZ: #3213 cherry-picked from [1] Previously, @ondemand_id field was used not only to identify ondemand state of the object, but also to represent the index of the xarray. This commit introduces @state field to decouple the role of @ondemand_id and adds helpers to access it. Reviewed-by: Xin Yin <yinxin.x@bytedance.com> Reviewed-by: Jingbo Xu <jefflexu@linux.alibaba.com> Signed-off-by: Jia Zhu <zhujia.zj@bytedance.com> Link: [1] https://lore.kernel.org/lkml/20221014080559.42108-5-zhujia.zj@bytedance.com/... Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Acked-by: Gao Xiang <hsiangkao@linux.alibaba.com> Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/894 Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/internal.h | 22 ++++++++++++++++++++++ fs/cachefiles/ondemand.c | 24 +++++++++++------------- 2 files changed, 33 insertions(+), 13 deletions(-) diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index b8ef5be59005..20d4c41bed2e 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -31,6 +31,11 @@ extern unsigned cachefiles_debug; #define cachefiles_gfp (__GFP_RECLAIM | __GFP_NORETRY | __GFP_NOMEMALLOC) +enum cachefiles_object_state { + CACHEFILES_ONDEMAND_OBJSTATE_close, /* Anonymous fd closed by daemon or initial state */ + CACHEFILES_ONDEMAND_OBJSTATE_open, /* Anonymous fd associated with object is available */ +}; + /* * node records */ @@ -50,6 +55,7 @@ struct cachefiles_object { struct rb_node active_node; /* link in active tree (dentry is key) */ #ifdef CONFIG_CACHEFILES_ONDEMAND int ondemand_id; + enum cachefiles_object_state state; #endif }; @@ -263,6 +269,22 @@ extern int cachefiles_ondemand_init_object(struct cachefiles_object *object); extern void cachefiles_ondemand_clean_object(struct cachefiles_object *object); extern int cachefiles_ondemand_read(struct cachefiles_object *object, loff_t pos, size_t len); + +#define CACHEFILES_OBJECT_STATE_FUNCS(_state) \ +static inline bool \ +cachefiles_ondemand_object_is_##_state(const struct cachefiles_object *object) \ +{ \ + return object->state == CACHEFILES_ONDEMAND_OBJSTATE_##_state; \ +} \ + \ +static inline void \ +cachefiles_ondemand_set_object_##_state(struct cachefiles_object *object) \ +{ \ + object->state = CACHEFILES_ONDEMAND_OBJSTATE_##_state; \ +} + +CACHEFILES_OBJECT_STATE_FUNCS(open); +CACHEFILES_OBJECT_STATE_FUNCS(close); #else static inline ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, char __user *_buffer, size_t buflen, loff_t *pos) diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 950dc5a71cb6..253d7e3a2bf5 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -24,6 +24,8 @@ static int cachefiles_ondemand_fd_release(struct inode *inode, xa_lock(&cache->reqs); object->ondemand_id = CACHEFILES_ONDEMAND_ID_CLOSED; + cachefiles_ondemand_set_object_close(object); + /* * Flush all pending READ requests since their completion depends on * anon_fd. @@ -181,6 +183,8 @@ int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args) else set_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags); + cachefiles_ondemand_set_object_open(req->object); + out: complete(&req->done); return ret; @@ -398,8 +402,8 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, /* coupled with the barrier in cachefiles_flush_reqs() */ smp_mb(); - - if (opcode != CACHEFILES_OP_OPEN && object->ondemand_id <= 0) { + if (opcode != CACHEFILES_OP_OPEN && + !cachefiles_ondemand_object_is_open(object)) { WARN_ON_ONCE(object->ondemand_id == 0); xa_unlock(&cache->reqs); ret = -EIO; @@ -463,18 +467,11 @@ static int cachefiles_ondemand_init_close_req(struct cachefiles_req *req, void *private) { struct cachefiles_object *object = req->object; - int object_id = object->ondemand_id; - /* - * It's possible that object id is still 0 if the cookie looking up - * phase failed before OPEN request has ever been sent. Also avoid - * sending CLOSE request for CACHEFILES_ONDEMAND_ID_CLOSED, which means - * anon_fd has already been closed. - */ - if (object_id <= 0) + if (!cachefiles_ondemand_object_is_open(object)) return -ENOENT; - req->msg.object_id = object_id; + req->msg.object_id = object->ondemand_id; return 0; } @@ -492,7 +489,7 @@ static int cachefiles_ondemand_init_read_req(struct cachefiles_req *req, int object_id = object->ondemand_id; /* Stop enqueuing requests when daemon has closed anon_fd. */ - if (object_id <= 0) { + if (!cachefiles_ondemand_object_is_open(object)) { WARN_ON_ONCE(object_id == 0); pr_info_once("READ: anonymous fd closed prematurely.\n"); return -EIO; @@ -515,7 +512,8 @@ int cachefiles_ondemand_init_object(struct cachefiles_object *object) * creating a new tmpfile as the cache file. Reuse the previously * allocated object ID if any. */ - if (object->ondemand_id > 0 || object->type == FSCACHE_COOKIE_TYPE_INDEX) + if (cachefiles_ondemand_object_is_open(object) || + object->type == FSCACHE_COOKIE_TYPE_INDEX) return 0; volume_key_size = object->fscache.parent->cookie->key_len + 1; -- 2.46.1

From: Jia Zhu <zhujia.zj@bytedance.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/5d1970fc484a -------------------------------- ANBZ: #3213 cherry-picked from [1] When an anonymous fd is closed by user daemon, if there is a new read request for this file comes up, the anonymous fd should be re-opened to handle that read request rather than fail it directly. 1. Introduce reopening state for objects that are closed but have inflight/subsequent read requests. 2. No longer flush READ requests but only CLOSE requests when anonymous fd is closed. 3. Enqueue the reopen work to workqueue, thus user daemon could get rid of daemon_read context and handle that request smoothly. Otherwise, the user daemon will send a reopen request and wait for itself to process the request. Reviewed-by: Xin Yin <yinxin.x@bytedance.com> Reviewed-by: Jingbo Xu <jefflexu@linux.alibaba.com> Signed-off-by: Jia Zhu <zhujia.zj@bytedance.com> Link: [1] https://lore.kernel.org/lkml/20221014080559.42108-5-zhujia.zj@bytedance.com/... Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Acked-by: Gao Xiang <hsiangkao@linux.alibaba.com> Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/894 Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/internal.h | 3 + fs/cachefiles/ondemand.c | 125 ++++++++++++++++++++++++--------------- 2 files changed, 79 insertions(+), 49 deletions(-) diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index c44782e12ab1..9f460188e1a8 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -34,9 +34,11 @@ extern unsigned cachefiles_debug; enum cachefiles_object_state { CACHEFILES_ONDEMAND_OBJSTATE_close, /* Anonymous fd closed by daemon or initial state */ CACHEFILES_ONDEMAND_OBJSTATE_open, /* Anonymous fd associated with object is available */ + CACHEFILES_ONDEMAND_OBJSTATE_reopening, /* Object that was closed and is being reopened. */ }; struct cachefiles_ondemand_info { + struct work_struct work; int ondemand_id; enum cachefiles_object_state state; struct cachefiles_object *object; @@ -290,6 +292,7 @@ cachefiles_ondemand_set_object_##_state(struct cachefiles_object *object) \ CACHEFILES_OBJECT_STATE_FUNCS(open); CACHEFILES_OBJECT_STATE_FUNCS(close); +CACHEFILES_OBJECT_STATE_FUNCS(reopening); #else static inline ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, char __user *_buffer, size_t buflen, loff_t *pos) diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 27da8cc76899..79a8eea88c2e 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -27,18 +27,14 @@ static int cachefiles_ondemand_fd_release(struct inode *inode, info->ondemand_id = CACHEFILES_ONDEMAND_ID_CLOSED; cachefiles_ondemand_set_object_close(object); - /* - * Flush all pending READ requests since their completion depends on - * anon_fd. - */ - radix_tree_for_each_slot(slot, &cache->reqs, &iter, 0) { + /* Only flush CACHEFILES_REQ_NEW marked req to avoid race with daemon_read */ + radix_tree_for_each_tagged(slot, &cache->reqs, &iter, 0, CACHEFILES_REQ_NEW) { req = radix_tree_deref_slot_protected(slot, &cache->reqs.xa_lock); if (WARN_ON(!req)) continue; if (req->msg.object_id == object_id && - req->msg.opcode == CACHEFILES_OP_READ) { - req->error = -EIO; + req->msg.opcode == CACHEFILES_OP_CLOSE) { complete(&req->done); radix_tree_iter_delete(&cache->reqs, &iter, slot); } @@ -185,6 +181,7 @@ int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args) set_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags); cachefiles_ondemand_set_object_open(req->object); + wake_up_all(&cache->daemon_pollwq); out: complete(&req->done); @@ -235,7 +232,6 @@ static int cachefiles_ondemand_get_fd(struct cachefiles_req *req) load = (void *)req->msg.data; load->fd = fd; - req->msg.object_id = object_id; object->private->ondemand_id = object_id; cachefiles_get_unbind_pincount(cache); @@ -253,16 +249,58 @@ static int cachefiles_ondemand_get_fd(struct cachefiles_req *req) return ret; } +static void ondemand_object_worker(struct work_struct *work) +{ + struct cachefiles_object *object; + + object = ((struct cachefiles_ondemand_info *)work)->object; + cachefiles_ondemand_init_object(object); +} + +/* + * Find a request to be handled in the range of [start, end]. If there are any + * inflight or subsequent READ requests on the closed object, reopen it. Skip + * read requests whose related object is reopening. + */ +static struct cachefiles_req *cachefiles_ondemand_select_req(struct cachefiles_cache *cache, + struct radix_tree_iter *iter, + unsigned long start, + unsigned long end) +{ + void **slot; + struct cachefiles_req *req; + struct cachefiles_ondemand_info *info; + + radix_tree_for_each_tagged(slot, &cache->reqs, iter, start, CACHEFILES_REQ_NEW) { + req = radix_tree_deref_slot_protected(slot, &cache->reqs.xa_lock); + if (WARN_ON(!req)) + return NULL; + if (iter->index > end) + return NULL; + if (req->msg.opcode != CACHEFILES_OP_READ) + return req; + info = req->object->private; + if (cachefiles_ondemand_object_is_close(req->object)) { + cachefiles_ondemand_set_object_reopening(req->object); + queue_work(fscache_object_wq, &info->work); + continue; + } else if (cachefiles_ondemand_object_is_reopening(req->object)) { + continue; + } + return req; + } + return NULL; +} + ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, char __user *_buffer, size_t buflen, loff_t *pos) { - struct cachefiles_req *req = NULL; + struct cachefiles_req *req; struct cachefiles_msg *msg; unsigned long id = 0; size_t n; int ret = 0; struct radix_tree_iter iter; - void **slot; /* * Cyclically search for a request that has not ever been processed, @@ -270,25 +308,9 @@ ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, * request distribution fair. */ xa_lock(&cache->reqs); - radix_tree_for_each_tagged(slot, &cache->reqs, &iter, cache->req_id_next, - CACHEFILES_REQ_NEW) { - req = radix_tree_deref_slot_protected(slot, &cache->reqs.xa_lock); - WARN_ON(!req); - break; - } - - if (!req && cache->req_id_next > 0) { - radix_tree_for_each_tagged(slot, &cache->reqs, &iter, 0, - CACHEFILES_REQ_NEW) { - if (iter.index >= cache->req_id_next) - break; - req = radix_tree_deref_slot_protected(slot, &cache->reqs.xa_lock); - WARN_ON(!req); - break; - } - } - - /* no request tagged with CACHEFILES_REQ_NEW found */ + req = cachefiles_ondemand_select_req(cache, &iter, cache->req_id_next, ULONG_MAX); + if (!req && cache->req_id_next > 0) + req = cachefiles_ondemand_select_req(cache, &iter, 0, cache->req_id_next - 1); if (!req) { xa_unlock(&cache->reqs); return 0; @@ -307,14 +329,18 @@ ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, xa_unlock(&cache->reqs); id = iter.index; - msg->msg_id = id; if (msg->opcode == CACHEFILES_OP_OPEN) { ret = cachefiles_ondemand_get_fd(req); - if (ret) + if (ret) { + cachefiles_ondemand_set_object_close(req->object); goto error; + } } + msg->msg_id = id; + msg->object_id = req->object->private->ondemand_id; + if (copy_to_user(_buffer, msg, n) != 0) { ret = -EFAULT; goto err_put_fd; @@ -352,7 +378,7 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, { static atomic64_t global_index = ATOMIC64_INIT(0); struct cachefiles_cache *cache; - struct cachefiles_req *req; + struct cachefiles_req *req = NULL; long id; int ret; @@ -362,12 +388,16 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags)) return 0; - if (test_bit(CACHEFILES_DEAD, &cache->flags)) - return -EIO; + if (test_bit(CACHEFILES_DEAD, &cache->flags)) { + ret = -EIO; + goto out; + } req = kzalloc(sizeof(*req) + data_len, GFP_KERNEL); - if (!req) - return -ENOMEM; + if (!req) { + ret = -ENOMEM; + goto out; + } req->object = object; init_completion(&req->done); @@ -403,7 +433,7 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, /* coupled with the barrier in cachefiles_flush_reqs() */ smp_mb(); - if (opcode != CACHEFILES_OP_OPEN && + if (opcode == CACHEFILES_OP_CLOSE && !cachefiles_ondemand_object_is_open(object)) { WARN_ON_ONCE(object->private->ondemand_id == 0); xa_unlock(&cache->reqs); @@ -421,7 +451,15 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, wake_up_all(&cache->daemon_pollwq); wait_for_completion(&req->done); ret = req->error; + kfree(req); + return ret; out: + /* Reset the object to close state in error handling path. + * If error occurs after creating the anonymous fd, + * cachefiles_ondemand_fd_release() will set object to close. + */ + if (opcode == CACHEFILES_OP_OPEN) + cachefiles_ondemand_set_object_close(req->object); kfree(req); return ret; } @@ -471,8 +509,6 @@ static int cachefiles_ondemand_init_close_req(struct cachefiles_req *req, if (!cachefiles_ondemand_object_is_open(object)) return -ENOENT; - - req->msg.object_id = object->private->ondemand_id; return 0; } @@ -484,19 +520,9 @@ struct cachefiles_read_ctx { static int cachefiles_ondemand_init_read_req(struct cachefiles_req *req, void *private) { - struct cachefiles_object *object = req->object; struct cachefiles_read *load = (void *)req->msg.data; struct cachefiles_read_ctx *read_ctx = private; - int object_id = object->private->ondemand_id; - - /* Stop enqueuing requests when daemon has closed anon_fd. */ - if (!cachefiles_ondemand_object_is_open(object)) { - WARN_ON_ONCE(object_id == 0); - pr_info_once("READ: anonymous fd closed prematurely.\n"); - return -EIO; - } - req->msg.object_id = object_id; load->off = read_ctx->off; load->len = read_ctx->len; return 0; @@ -554,5 +580,6 @@ int cachefiles_ondemand_init_obj_info(struct cachefiles_object *object) return -ENOMEM; object->private->object = object; + INIT_WORK(&object->private->work, ondemand_object_worker); return 0; } -- 2.46.1

From: Jia Zhu <zhujia.zj@bytedance.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/71001eabd791 -------------------------------- ANBZ: #3213 cherry-picked from [1] Previously, in ondemand read scenario, if the anonymous fd was closed by user daemon, inflight and subsequent read requests would return EIO. As long as the device connection is not released, user daemon can hold and restore inflight requests by setting the request flag to CACHEFILES_REQ_NEW. Suggested-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Jia Zhu <zhujia.zj@bytedance.com> Signed-off-by: Xin Yin <yinxin.x@bytedance.com> Reviewed-by: Jingbo Xu <jefflexu@linux.alibaba.com> [jingbo: use xas_for_each since radix_tree_iter_tag_set is unavailable] Link: [1] https://lore.kernel.org/lkml/20221014080559.42108-5-zhujia.zj@bytedance.com/... Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Acked-by: Gao Xiang <hsiangkao@linux.alibaba.com> Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/894 Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/daemon.c | 1 + fs/cachefiles/internal.h | 3 +++ fs/cachefiles/ondemand.c | 23 +++++++++++++++++++++++ 3 files changed, 27 insertions(+) diff --git a/fs/cachefiles/daemon.c b/fs/cachefiles/daemon.c index 075c227a336b..4bb81e003ae1 100644 --- a/fs/cachefiles/daemon.c +++ b/fs/cachefiles/daemon.c @@ -75,6 +75,7 @@ static const struct cachefiles_daemon_cmd cachefiles_daemon_cmds[] = { { "tag", cachefiles_daemon_tag }, #ifdef CONFIG_CACHEFILES_ONDEMAND { "copen", cachefiles_ondemand_copen }, + { "restore", cachefiles_ondemand_restore }, #endif { "", NULL } }; diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index 435e8168f26f..f975042c1658 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -270,6 +270,9 @@ extern ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, extern int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args); +extern int cachefiles_ondemand_restore(struct cachefiles_cache *cache, + char *args); + extern int cachefiles_ondemand_init_object(struct cachefiles_object *object); extern void cachefiles_ondemand_clean_object(struct cachefiles_object *object); extern int cachefiles_ondemand_read(struct cachefiles_object *object, diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 79a8eea88c2e..1fd1efd5a117 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -188,6 +188,29 @@ int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args) return ret; } +int cachefiles_ondemand_restore(struct cachefiles_cache *cache, char *args) +{ + struct cachefiles_req *req; + + XA_STATE(xas, &cache->reqs, 0); + + if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags)) + return -EOPNOTSUPP; + + /* + * Reset the requests to CACHEFILES_REQ_NEW state, so that the + * requests have been processed halfway before the crash of the + * user daemon could be reprocessed after the recovery. + */ + xas_lock(&xas); + xas_for_each(&xas, req, ULONG_MAX) + xas_set_mark(&xas, CACHEFILES_REQ_NEW); + xas_unlock(&xas); + + wake_up_all(&cache->daemon_pollwq); + return 0; +} + static int cachefiles_ondemand_get_fd(struct cachefiles_req *req) { struct cachefiles_object *object = req->object; -- 2.46.1

From: Jingbo Xu <jefflexu@linux.alibaba.com> anolis inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT Reference: https://gitee.com/anolis/cloud-kernel/commit/51839830d50d -------------------------------- ANBZ: #3213 Add missing lock protection in poll routine when iterating xarray, otherwise: 1. The radix_tree API itself doesn't imply RCU read lock, thus we may encounter UAF when dereferencing slot without radix_tree's lock held. 2. Even with RCU read lock held, only the slot of the radix tree is ensured to be pinned there, while the data structure (e.g. struct cachefiles_req) stored in the slot has no such guarantee. The poll routine will iterate the radix tree and dereference cachefiles_req accordingly. Thus RCU read lock is not adequate in this case and spinlock is needed here. 3. Otherwise, radix_tree_deref_slot_protected() will fail lockdep_is_held() checking. Fixes: f8ecbc39993a ("anolis: cachefiles: narrow the scope of triggering EPOLLIN events in ondemand mode") Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Joseph Qi <joseph.qi@linux.alibaba.com> Reviewed-by: Gao Xiang <hsiangkao@linux.alibaba.com> Link: https://gitee.com/anolis/cloud-kernel/pulls/1004 Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/daemon.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/fs/cachefiles/daemon.c b/fs/cachefiles/daemon.c index 4bb81e003ae1..e26ebbc89806 100644 --- a/fs/cachefiles/daemon.c +++ b/fs/cachefiles/daemon.c @@ -370,6 +370,7 @@ static __poll_t cachefiles_daemon_poll(struct file *file, if (cachefiles_in_ondemand_mode(cache)) { if (!radix_tree_empty(&cache->reqs)) { + xa_lock(&cache->reqs); radix_tree_for_each_tagged(slot, &cache->reqs, &iter, 0, CACHEFILES_REQ_NEW) { req = radix_tree_deref_slot_protected(slot, @@ -379,6 +380,7 @@ static __poll_t cachefiles_daemon_poll(struct file *file, break; } } + xa_unlock(&cache->reqs); } } else { if (test_bit(CACHEFILES_STATE_CHANGED, &cache->flags)) -- 2.46.1

hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT ---------------------------------------- To support erofs over fscache mode, the following config is enabled by default on x86 and arm64: CONFIG_CACHEFILES_ONDEMAND=y CONFIG_EROFS_FS=m CONFIG_EROFS_FS_XATTR=y CONFIG_EROFS_FS_POSIX_ACL=y CONFIG_EROFS_FS_SECURITY=y CONFIG_EROFS_FS_ONDEMAND=y Signed-off-by: Baokun Li <libaokun1@huawei.com> --- arch/arm64/configs/openeuler_defconfig | 9 ++++++++- arch/x86/configs/openeuler_defconfig | 9 ++++++++- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/arch/arm64/configs/openeuler_defconfig b/arch/arm64/configs/openeuler_defconfig index 4c117f2f55f1..9996b88ba58c 100644 --- a/arch/arm64/configs/openeuler_defconfig +++ b/arch/arm64/configs/openeuler_defconfig @@ -6407,6 +6407,7 @@ CONFIG_FSCACHE_STATS=y CONFIG_CACHEFILES=m # CONFIG_CACHEFILES_DEBUG is not set # CONFIG_CACHEFILES_HISTOGRAM is not set +CONFIG_CACHEFILES_ONDEMAND=y # end of Caches # @@ -6520,7 +6521,13 @@ CONFIG_PSTORE_COMPRESS_DEFAULT="deflate" CONFIG_PSTORE_RAM=m # CONFIG_SYSV_FS is not set # CONFIG_UFS_FS is not set -# CONFIG_EROFS_FS is not set +CONFIG_EROFS_FS=m +# CONFIG_EROFS_FS_DEBUG is not set +CONFIG_EROFS_FS_XATTR=y +CONFIG_EROFS_FS_POSIX_ACL=y +CONFIG_EROFS_FS_SECURITY=y +# CONFIG_EROFS_FS_ZIP is not set +CONFIG_EROFS_FS_ONDEMAND=y CONFIG_NETWORK_FILESYSTEMS=y CONFIG_NFS_FS=m CONFIG_NFS_V2=m diff --git a/arch/x86/configs/openeuler_defconfig b/arch/x86/configs/openeuler_defconfig index bfaadb4b298f..d5282a39d8cc 100644 --- a/arch/x86/configs/openeuler_defconfig +++ b/arch/x86/configs/openeuler_defconfig @@ -7462,6 +7462,7 @@ CONFIG_FSCACHE_STATS=y CONFIG_CACHEFILES=m # CONFIG_CACHEFILES_DEBUG is not set # CONFIG_CACHEFILES_HISTOGRAM is not set +CONFIG_CACHEFILES_ONDEMAND=y # end of Caches # @@ -7577,7 +7578,13 @@ CONFIG_PSTORE_COMPRESS_DEFAULT="deflate" CONFIG_PSTORE_RAM=m # CONFIG_SYSV_FS is not set # CONFIG_UFS_FS is not set -# CONFIG_EROFS_FS is not set +CONFIG_EROFS_FS=m +# CONFIG_EROFS_FS_DEBUG is not set +CONFIG_EROFS_FS_XATTR=y +CONFIG_EROFS_FS_POSIX_ACL=y +CONFIG_EROFS_FS_SECURITY=y +# CONFIG_EROFS_FS_ZIP is not set +CONFIG_EROFS_FS_ONDEMAND=y CONFIG_NETWORK_FILESYSTEMS=y CONFIG_NFS_FS=m # CONFIG_NFS_V2 is not set -- 2.46.1

From: Zizhi Wo <wozizhi@huawei.com> hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- In order to make the user state control the characteristics of the erofs, a dynamic switch about erofs is added. The switch named erofs_enabled is closed by default, and is isolated by CONFIG_EROFS_FS. Users can open it by echo 1/on/ON/y/Y to /sys/module/fs_ctl/parameters/erofs_enabled. Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/Makefile | 2 ++ fs/erofs/super.c | 3 +++ fs/fs_ctl.c | 36 ++++++++++++++++++++++++++++++++++++ include/linux/fs.h | 4 ++++ 4 files changed, 45 insertions(+) create mode 100644 fs/fs_ctl.c diff --git a/fs/Makefile b/fs/Makefile index 29cc13ba2c08..06f000e22e06 100644 --- a/fs/Makefile +++ b/fs/Makefile @@ -15,6 +15,8 @@ obj-y := open.o read_write.o file_table.o super.o \ stack.o fs_struct.o statfs.o fs_pin.o nsfs.o \ fs_types.o fs_context.o fs_parser.o fsopen.o init.o \ kernel_read_file.o remap_range.o +obj-y += fs_ctl.o + ifdef CONFIG_CC_IS_CLANG CFLAGS_namei.o := $(call cc-disable-warning, bitwise-instead-of-logical) endif diff --git a/fs/erofs/super.c b/fs/erofs/super.c index 606d4637a795..a6cb90c4fcce 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -661,6 +661,9 @@ static int erofs_init_fs_context(struct fs_context *fc) { struct erofs_fs_context *ctx; + if (!READ_ONCE(erofs_enabled)) + return -EOPNOTSUPP; + /* pseudo mount for anon inodes */ if (fc->sb_flags & SB_KERNMOUNT) { fc->ops = &erofs_anon_context_ops; diff --git a/fs/fs_ctl.c b/fs/fs_ctl.c new file mode 100644 index 000000000000..ab6b532188d9 --- /dev/null +++ b/fs/fs_ctl.c @@ -0,0 +1,36 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (C) 2024. Huawei Technologies Co., Ltd */ + +#include <linux/moduleparam.h> +#include <linux/kernel.h> +#include <linux/fs.h> + +#if IS_ENABLED(CONFIG_EROFS_FS) +static int param_set_bool_on_only_once(const char *s, const struct kernel_param *kp) +{ + int ret; + bool value, *res = kp->arg; + + if (!s) + s = "1"; + + ret = strtobool(s, &value); + if (ret) + return ret; + + if (!value && *res) + return -EBUSY; + + if (value && !*res) + WRITE_ONCE(*res, true); + + return 0; +} +#endif + +#if IS_ENABLED(CONFIG_EROFS_FS) +bool erofs_enabled; +EXPORT_SYMBOL(erofs_enabled); +module_param_call(erofs_enabled, param_set_bool_on_only_once, param_get_bool, + &erofs_enabled, 0644); +#endif diff --git a/include/linux/fs.h b/include/linux/fs.h index 7e8684e3f05d..911c923c91bf 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -3698,4 +3698,8 @@ bool generic_atomic_write_valid(loff_t pos, size_t len, return true; } +#if IS_ENABLED(CONFIG_EROFS_FS) +extern bool erofs_enabled; +#endif + #endif /* _LINUX_FS_H */ -- 2.46.1

From: Jingbo Xu <jefflexu@linux.alibaba.com> mainline inclusion from mainline-v6.3-rc1 commit 7032809a44d752b9e2275833787e0aa88a7540af category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- Relinquish fscache volume with mutex held. Otherwise if a new domain is registered when the old domain with the same name gets removed from the list but not relinquished yet, fscache may complain the collision. Fixes: 8b7adf1dff3d ("erofs: introduce fscache-based domain") Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Jia Zhu <zhujia.zj@bytedance.com> Link: https://lore.kernel.org/r/20230209063913.46341-4-jefflexu@linux.alibaba.com Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> Conflicts: fs/erofs/fscache.c --- fs/erofs/fscache.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c index 12b0c564b7c3..d803c8716909 100644 --- a/fs/erofs/fscache.c +++ b/fs/erofs/fscache.c @@ -285,8 +285,8 @@ static void erofs_fscache_domain_put(struct erofs_domain *domain) kern_unmount(erofs_pseudo_mnt); erofs_pseudo_mnt = NULL; } - mutex_unlock(&erofs_domain_list_lock); fscache_relinquish_cookie(domain->volume, NULL, false); + mutex_unlock(&erofs_domain_list_lock); kfree(domain->domain_id); kfree(domain); return; -- 2.46.1

hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- If the parent is not ready when an object is initialized, it grabs a reference count of the object and adds it to the parent's dependents. When the parent is ready, it traverses the dependents to remove the object and reduce the reference count. However, calling fscache_dequeue_object when ABORT_INIT only removes the object from the parent's dependents without decreasing the object's reference count, thus leading to reference count leakage. When releasing /dev/cachefiles, the following softlock up is triggered because it waits for the reference count to reach 0. ================================================================== INFO: task cachefilesd2:635 blocked for more than 122 seconds. Not tainted 5.10.0-xfstests-00004-g042dc94280ce-dirty #1321 "echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message. task:cachefilesd2 state:D stack:0 pid:635 ppid:596 flags:0x00004006 Call Trace: __schedule+0x3cc/0x770 schedule+0x5b/0xd0 fscache_withdraw_cache+0x298/0x427 cachefiles_daemon_unbind.cold+0x18/0x69 [cachefiles] cachefiles_put_unbind_pincount+0x2a/0x60 [cachefiles] cachefiles_daemon_release+0x75/0x1e0 [cachefiles] __fput+0xe8/0x260 task_work_run+0x5f/0xb0 do_exit+0x381/0xbb0 [...] ================================================================== So put the reference count of the object when removing it from the parent's dependents in fscache_dequeue_object() to fix the issue. Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/fscache/object.c | 1 + include/linux/fscache-cache.h | 1 + 2 files changed, 2 insertions(+) diff --git a/fs/fscache/object.c b/fs/fscache/object.c index cb2146e02cd5..9ce3041a5d71 100644 --- a/fs/fscache/object.c +++ b/fs/fscache/object.c @@ -904,6 +904,7 @@ static void fscache_dequeue_object(struct fscache_object *object) if (!list_empty(&object->dep_link)) { spin_lock(&object->parent->lock); list_del_init(&object->dep_link); + fscache_put_object(object, fscache_obj_put_dequeue); spin_unlock(&object->parent->lock); } diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h index f3ae78d1e5f3..cb8be2d3143c 100644 --- a/include/linux/fscache-cache.h +++ b/include/linux/fscache-cache.h @@ -34,6 +34,7 @@ enum fscache_obj_ref_trace { fscache_obj_put_enq_dep, fscache_obj_put_queue, fscache_obj_put_work, + fscache_obj_put_dequeue, fscache_obj_ref__nr_traces }; -- 2.46.1

From: Hou Tao <houtao1@huawei.com> mainline inclusion from mainline-v6.2-rc1 commit 27f2a2dcc6261406b509b5022a1e5c23bf622830 category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- When shared domain is enabled, doing mount twice with the same fsid and domain_id will trigger sysfs warning as shown below: sysfs: cannot create duplicate filename '/fs/erofs/d0,meta.bin' CPU: 15 PID: 1051 Comm: mount Not tainted 6.1.0-rc6+ #1 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996) Call Trace: <TASK> dump_stack_lvl+0x38/0x49 dump_stack+0x10/0x12 sysfs_warn_dup.cold+0x17/0x27 sysfs_create_dir_ns+0xb8/0xd0 kobject_add_internal+0xb1/0x240 kobject_init_and_add+0x71/0xa0 erofs_register_sysfs+0x89/0x110 erofs_fc_fill_super+0x98c/0xaf0 vfs_get_super+0x7d/0x100 get_tree_nodev+0x16/0x20 erofs_fc_get_tree+0x20/0x30 vfs_get_tree+0x24/0xb0 path_mount+0x2fa/0xa90 do_mount+0x7c/0xa0 __x64_sys_mount+0x8b/0xe0 do_syscall_64+0x30/0x60 entry_SYSCALL_64_after_hwframe+0x46/0xb0 The reason is erofs_fscache_register_cookie() doesn't guarantee the primary data blob (aka fsid) is unique in the shared domain and erofs_register_sysfs() invoked by the second mount will fail due to the duplicated fsid in the shared domain and report warning. It would be better to check the uniqueness of fsid before doing erofs_register_sysfs(), so adding a new flags parameter for erofs_fscache_register_cookie() and doing the uniqueness check if EROFS_REG_COOKIE_NEED_NOEXIST is enabled. After the patch, the error in dmesg for the duplicated mount would be: erofs: ...: erofs_domain_register_cookie: XX already exists in domain YY Reviewed-by: Jia Zhu <zhujia.zj@bytedance.com> Reviewed-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Chao Yu <chao@kernel.org> Signed-off-by: Hou Tao <houtao1@huawei.com> Link: https://lore.kernel.org/r/20221125110822.3812942-1-houtao@huaweicloud.com Fixes: 7d41963759fe ("erofs: Support sharing cookies in the same domain") Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> Conflicts: fs/erofs/fscache.c fs/erofs/internal.h --- fs/erofs/fscache.c | 47 +++++++++++++++++++++++++++++++++------------ fs/erofs/internal.h | 10 ++++++++-- fs/erofs/super.c | 2 +- 3 files changed, 44 insertions(+), 15 deletions(-) diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c index d803c8716909..761393a4e151 100644 --- a/fs/erofs/fscache.c +++ b/fs/erofs/fscache.c @@ -383,7 +383,8 @@ static int erofs_fscache_register_domain(struct super_block *sb) static struct erofs_fscache *erofs_fscache_acquire_cookie(struct super_block *sb, - char *name, bool need_inode) + char *name, + unsigned int flags) { struct erofs_fscache *ctx; struct fscache_cookie *cookie; @@ -406,7 +407,7 @@ struct erofs_fscache *erofs_fscache_acquire_cookie(struct super_block *sb, //fscache_use_cookie(cookie, false); ctx->cookie = cookie; - if (need_inode) { + if (flags & EROFS_REG_COOKIE_NEED_INODE) { struct inode *const inode = new_inode(sb); if (!inode) { @@ -444,14 +445,15 @@ static void erofs_fscache_relinquish_cookie(struct erofs_fscache *ctx) static struct erofs_fscache *erofs_fscache_domain_init_cookie(struct super_block *sb, - char *name, bool need_inode) + char *name, + unsigned int flags) { int err; struct inode *inode; struct erofs_fscache *ctx; struct erofs_domain *domain = EROFS_SB(sb)->domain; - ctx = erofs_fscache_acquire_cookie(sb, name, need_inode); + ctx = erofs_fscache_acquire_cookie(sb, name, flags); if (IS_ERR(ctx)) return ctx; @@ -479,7 +481,8 @@ struct erofs_fscache *erofs_fscache_domain_init_cookie(struct super_block *sb, static struct erofs_fscache *erofs_domain_register_cookie(struct super_block *sb, - char *name, bool need_inode) + char *name, + unsigned int flags) { struct inode *inode; struct erofs_fscache *ctx; @@ -492,23 +495,30 @@ struct erofs_fscache *erofs_domain_register_cookie(struct super_block *sb, ctx = inode->i_private; if (!ctx || ctx->domain != domain || strcmp(ctx->name, name)) continue; - igrab(inode); + if (!(flags & EROFS_REG_COOKIE_NEED_NOEXIST)) { + igrab(inode); + } else { + erofs_err(sb, "%s already exists in domain %s", name, + domain->domain_id); + ctx = ERR_PTR(-EEXIST); + } spin_unlock(&psb->s_inode_list_lock); mutex_unlock(&erofs_domain_cookies_lock); return ctx; } spin_unlock(&psb->s_inode_list_lock); - ctx = erofs_fscache_domain_init_cookie(sb, name, need_inode); + ctx = erofs_fscache_domain_init_cookie(sb, name, flags); mutex_unlock(&erofs_domain_cookies_lock); return ctx; } struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb, - char *name, bool need_inode) + char *name, + unsigned int flags) { if (EROFS_SB(sb)->domain_id) - return erofs_domain_register_cookie(sb, name, need_inode); - return erofs_fscache_acquire_cookie(sb, name, need_inode); + return erofs_domain_register_cookie(sb, name, flags); + return erofs_fscache_acquire_cookie(sb, name, flags); } void erofs_fscache_unregister_cookie(struct erofs_fscache *ctx) @@ -537,6 +547,7 @@ int erofs_fscache_register_fs(struct super_block *sb) int ret; struct erofs_sb_info *sbi = EROFS_SB(sb); struct erofs_fscache *fscache; + unsigned int flags; if (sbi->domain_id) ret = erofs_fscache_register_domain(sb); @@ -545,8 +556,20 @@ int erofs_fscache_register_fs(struct super_block *sb) if (ret) return ret; - /* acquired domain/volume will be relinquished in kill_sb() on error */ - fscache = erofs_fscache_register_cookie(sb, sbi->fsid, true); + /* + * When shared domain is enabled, using NEED_NOEXIST to guarantee + * the primary data blob (aka fsid) is unique in the shared domain. + * + * For non-shared-domain case, fscache_acquire_volume() invoked by + * erofs_fscache_register_volume() has already guaranteed + * the uniqueness of primary data blob. + * + * Acquired domain/volume will be relinquished in kill_sb() on error. + */ + flags = EROFS_REG_COOKIE_NEED_INODE; + if (sbi->domain_id) + flags |= EROFS_REG_COOKIE_NEED_NOEXIST; + fscache = erofs_fscache_register_cookie(sb, sbi->fsid, flags); if (IS_ERR(fscache)) return PTR_ERR(fscache); diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index 16eaeee4a295..12f652e8b967 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -492,6 +492,10 @@ static inline int z_erofs_init_zip_subsystem(void) { return 0; } static inline void z_erofs_exit_zip_subsystem(void) {} #endif /* !CONFIG_EROFS_FS_ZIP */ +/* flags for erofs_fscache_register_cookie() */ +#define EROFS_REG_COOKIE_NEED_INODE 1 +#define EROFS_REG_COOKIE_NEED_NOEXIST 2 + /* fscache.c */ #ifdef CONFIG_EROFS_FS_ONDEMAND int erofs_fscache_register(void); @@ -500,7 +504,8 @@ int erofs_fscache_register_fs(struct super_block *sb); void erofs_fscache_unregister_fs(struct super_block *sb); struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb, - char *name, bool need_inode); + char *name, + unsigned int flags); void erofs_fscache_unregister_cookie(struct erofs_fscache *fscache); extern const struct address_space_operations erofs_fscache_access_aops; #else @@ -517,7 +522,8 @@ static inline void erofs_fscache_unregister_fs(struct super_block *sb) {} static inline struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb, - char *name, bool need_inode) + char *name, + unsigned int flags) { return ERR_PTR(-EOPNOTSUPP); } diff --git a/fs/erofs/super.c b/fs/erofs/super.c index 7c9a29d2d9d4..f8d6371003b0 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -148,7 +148,7 @@ static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb, } if (erofs_is_fscache_mode(sb)) { - fscache = erofs_fscache_register_cookie(sb, dif->path, false); + fscache = erofs_fscache_register_cookie(sb, dif->path, 0); if (IS_ERR(fscache)) return PTR_ERR(fscache); dif->fscache = fscache; -- 2.46.1

From: Al Viro <viro@zeniv.linux.org.uk> mainline inclusion from mainline-v6.8-rc6 commit 2c88c16dc20e88dd54d2f6f4d01ae1dce6cc9654 category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- if you have a variable that holds NULL or a pointer to live struct mount, do not shove ERR_PTR() into it - not if you later treat "not NULL" as "holds a pointer to object". Signed-off-by: Al Viro <viro@zeniv.linux.org.uk> Conflicts: fs/erofs/fscache.c [Context differences.] Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/fscache.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c index d42a583ff6b1..70b96377fcb6 100644 --- a/fs/erofs/fscache.c +++ b/fs/erofs/fscache.c @@ -355,11 +355,13 @@ static int erofs_fscache_init_domain(struct super_block *sb) goto out; if (!erofs_pseudo_mnt) { - erofs_pseudo_mnt = kern_mount(&erofs_anon_fs_type); - if (IS_ERR(erofs_pseudo_mnt)) { - err = PTR_ERR(erofs_pseudo_mnt); + struct vfsmount *mnt = kern_mount(&erofs_anon_fs_type); + + if (IS_ERR(mnt)) { + err = PTR_ERR(mnt); goto out; } + erofs_pseudo_mnt = mnt; } domain->volume = sbi->volume; -- 2.46.1

From: Jingbo Xu <jefflexu@linux.alibaba.com> mainline inclusion from mainline-6.3-rc1 commit 2dfb8c3b122fad4504a92c34ba68f2fe4444b3f6 category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- We'd better not touch sb->s_inodes list and inode->i_count directly. Let's maintain cookies of share domain in a self-contained list in erofs. Besides, relinquish cookie with the mutex held. Otherwise if a cookie is registered when the old cookie with the same name in the same domain has been removed from the list but not relinquished yet, fscache may complain "Duplicate cookie detected". Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Jia Zhu <zhujia.zj@bytedance.com> Link: https://lore.kernel.org/r/20230209063913.46341-3-jefflexu@linux.alibaba.com Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/fscache.c | 44 ++++++++++++++++++++------------------------ fs/erofs/internal.h | 4 ++++ 2 files changed, 24 insertions(+), 24 deletions(-) diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c index 70b96377fcb6..e6fa21ce686f 100644 --- a/fs/erofs/fscache.c +++ b/fs/erofs/fscache.c @@ -10,6 +10,7 @@ static DEFINE_MUTEX(erofs_domain_list_lock); static DEFINE_MUTEX(erofs_domain_cookies_lock); static LIST_HEAD(erofs_domain_list); +static LIST_HEAD(erofs_domain_cookies_list); static struct vfsmount *erofs_pseudo_mnt; static int erofs_anon_init_fs_context(struct fs_context *fc) @@ -289,8 +290,6 @@ const struct address_space_operations erofs_fscache_access_aops = { static void erofs_fscache_domain_put(struct erofs_domain *domain) { - if (!domain) - return; mutex_lock(&erofs_domain_list_lock); if (refcount_dec_and_test(&domain->ref)) { list_del(&domain->list); @@ -408,6 +407,8 @@ struct erofs_fscache *erofs_fscache_acquire_cookie(struct super_block *sb, ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) return ERR_PTR(-ENOMEM); + INIT_LIST_HEAD(&ctx->node); + refcount_set(&ctx->ref, 1); cookie = fscache_acquire_cookie(EROFS_SB(sb)->volume, &erofs_fscache_inode_object_def, @@ -454,6 +455,7 @@ static void erofs_fscache_relinquish_cookie(struct erofs_fscache *ctx) //fscache_unuse_cookie(ctx->cookie, NULL, NULL); fscache_relinquish_cookie(ctx->cookie, NULL, false); iput(ctx->inode); + iput(ctx->anon_inode); kfree(ctx->name); kfree(ctx); } @@ -486,6 +488,7 @@ struct erofs_fscache *erofs_fscache_domain_init_cookie(struct super_block *sb, ctx->domain = domain; ctx->anon_inode = inode; + list_add(&ctx->node, &erofs_domain_cookies_list); inode->i_private = ctx; refcount_inc(&domain->ref); return ctx; @@ -499,29 +502,23 @@ struct erofs_fscache *erofs_domain_register_cookie(struct super_block *sb, char *name, unsigned int flags) { - struct inode *inode; struct erofs_fscache *ctx; struct erofs_domain *domain = EROFS_SB(sb)->domain; - struct super_block *psb = erofs_pseudo_mnt->mnt_sb; mutex_lock(&erofs_domain_cookies_lock); - spin_lock(&psb->s_inode_list_lock); - list_for_each_entry(inode, &psb->s_inodes, i_sb_list) { - ctx = inode->i_private; - if (!ctx || ctx->domain != domain || strcmp(ctx->name, name)) + list_for_each_entry(ctx, &erofs_domain_cookies_list, node) { + if (ctx->domain != domain || strcmp(ctx->name, name)) continue; if (!(flags & EROFS_REG_COOKIE_NEED_NOEXIST)) { - igrab(inode); + refcount_inc(&ctx->ref); } else { erofs_err(sb, "%s already exists in domain %s", name, domain->domain_id); ctx = ERR_PTR(-EEXIST); } - spin_unlock(&psb->s_inode_list_lock); mutex_unlock(&erofs_domain_cookies_lock); return ctx; } - spin_unlock(&psb->s_inode_list_lock); ctx = erofs_fscache_domain_init_cookie(sb, name, flags); mutex_unlock(&erofs_domain_cookies_lock); return ctx; @@ -538,23 +535,22 @@ struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb, void erofs_fscache_unregister_cookie(struct erofs_fscache *ctx) { - bool drop; - struct erofs_domain *domain; + struct erofs_domain *domain = NULL; if (!ctx) return; - domain = ctx->domain; - if (domain) { - mutex_lock(&erofs_domain_cookies_lock); - drop = atomic_read(&ctx->anon_inode->i_count) == 1; - iput(ctx->anon_inode); - mutex_unlock(&erofs_domain_cookies_lock); - if (!drop) - return; - } + if (!ctx->domain) + return erofs_fscache_relinquish_cookie(ctx); - erofs_fscache_relinquish_cookie(ctx); - erofs_fscache_domain_put(domain); + mutex_lock(&erofs_domain_cookies_lock); + if (refcount_dec_and_test(&ctx->ref)) { + domain = ctx->domain; + list_del(&ctx->node); + erofs_fscache_relinquish_cookie(ctx); + } + mutex_unlock(&erofs_domain_cookies_lock); + if (domain) + erofs_fscache_domain_put(domain); } int erofs_fscache_register_fs(struct super_block *sb) diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index 905a08516cc6..f53d7042a4a7 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -93,7 +93,11 @@ struct erofs_fscache { struct fscache_cookie *cookie; struct inode *inode; struct inode *anon_inode; + + /* used for share domain mode */ struct erofs_domain *domain; + struct list_head node; + refcount_t ref; char *name; }; -- 2.46.1

From: Yu Kuai <yukuai3@huawei.com> hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- A new filed 'new_location' is added in fscache_cookie_def() to determine the behaviour, two new helpers is also added to judge if 'new_location' is set for volume or data cookie. Signed-off-by: Yu Kuai <yukuai3@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- include/linux/fscache.h | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/include/linux/fscache.h b/include/linux/fscache.h index 6931c144a2fd..40ede2ff29dc 100644 --- a/include/linux/fscache.h +++ b/include/linux/fscache.h @@ -70,6 +70,12 @@ struct fscache_cookie_def { #define FSCACHE_COOKIE_TYPE_INDEX 0 #define FSCACHE_COOKIE_TYPE_DATAFILE 1 + /* + * Used for index cookie. If set, the location of cachefile will be the + * same as mainline kernel v5.18+. + */ + bool new_location; + /* select the cache into which to insert an entry in this index * - optional * - should return a cache identifier or NULL to cause the cache to be @@ -876,4 +882,18 @@ void fscache_enable_cookie(struct fscache_cookie *cookie, can_enable, data); } +static inline bool volume_new_location(struct fscache_cookie *cookie) +{ + return cookie->def && cookie->type == FSCACHE_COOKIE_TYPE_INDEX && + cookie->def->new_location; +} + +static inline bool data_new_location(struct fscache_cookie *cookie) +{ + if (cookie->type != FSCACHE_COOKIE_TYPE_DATAFILE) + return false; + + return cookie->parent && volume_new_location(cookie->parent); +} + #endif /* _LINUX_FSCACHE_H */ -- 2.46.1

From: Yu Kuai <yukuai3@huawei.com> hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- For each cookie, cache dir/file name is combined by: type + acc + key And the member 'acc' doesn't exist in mainline. There are no functional changes for now, and prepare to keep cachefile location the same as mainline. Signed-off-by: Yu Kuai <yukuai3@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/key.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/fs/cachefiles/key.c b/fs/cachefiles/key.c index be96f5fc5cac..c43808c82de0 100644 --- a/fs/cachefiles/key.c +++ b/fs/cachefiles/key.c @@ -22,6 +22,14 @@ static const char cachefiles_filecharmap[256] = { [48 ... 127] = 1, /* '0' -> '~' */ }; +static void cachefiles_cook_acc(char *key, unsigned int acc, int *len) +{ + key[*len + 1] = cachefiles_charmap[acc & 63]; + acc >>= 6; + key[*len] = cachefiles_charmap[acc & 63]; + *len += 2; +} + /* * turn the raw key into something cooked * - the raw key should include the length in the two bytes at the front @@ -86,14 +94,8 @@ char *cachefiles_cook_key(const u8 *raw, int keylen, uint8_t type) mark = len - 1; if (print) { - acc = *(uint16_t *) raw; + cachefiles_cook_acc(key, *(uint16_t *) raw, &len); raw += 2; - - key[len + 1] = cachefiles_charmap[acc & 63]; - acc >>= 6; - key[len] = cachefiles_charmap[acc & 63]; - len += 2; - seg = 250; for (loop = keylen; loop > 0; loop--) { if (seg <= 0) { -- 2.46.1

From: Yu Kuai <yukuai3@huawei.com> hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- Currently cookie is combined with: csum + acc + key For 'key', if it contains space, then cachefiles_cook_key() will generate new charmap to replace the ascii directly. However, from mainline this is only used for data cookie, and volume is always use ascii directly. Hence is new_location is set, use ascii directly for volume cookie to keep cachefile location the same as mainline. Signed-off-by: Yu Kuai <yukuai3@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/interface.c | 2 +- fs/cachefiles/internal.h | 3 ++- fs/cachefiles/key.c | 11 ++++++++--- 3 files changed, 11 insertions(+), 5 deletions(-) diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c index 5eedd6382737..a13089d06e16 100644 --- a/fs/cachefiles/interface.c +++ b/fs/cachefiles/interface.c @@ -77,7 +77,7 @@ static struct fscache_object *cachefiles_alloc_object( ((char *)buffer)[keylen + 4] = 0; /* turn the raw key into something that can work with as a filename */ - key = cachefiles_cook_key(buffer, keylen + 2, object->type); + key = cachefiles_cook_key(object, buffer, keylen + 2); if (!key) goto nomem_key; diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index f975042c1658..510a895efe7a 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -195,7 +195,8 @@ extern const struct fscache_cache_ops cachefiles_cache_ops; /* * key.c */ -extern char *cachefiles_cook_key(const u8 *raw, int keylen, uint8_t type); +extern char *cachefiles_cook_key(struct cachefiles_object *object, + const u8 *raw, int keylen); /* * namei.c diff --git a/fs/cachefiles/key.c b/fs/cachefiles/key.c index 1e2f840dabaa..f94847a44ab5 100644 --- a/fs/cachefiles/key.c +++ b/fs/cachefiles/key.c @@ -50,19 +50,24 @@ static int cachefiles_cook_csum(const u8 *raw, int keylen, char *key) * cooked * - need to cut the cooked key into 252 char lengths (189 raw bytes) */ -char *cachefiles_cook_key(const u8 *raw, int keylen, uint8_t type) +char *cachefiles_cook_key(struct cachefiles_object *object, + const u8 *raw, int keylen) { unsigned int acc; char *key; int loop, len, max, seg, mark, print; + uint8_t type = object->type; + struct fscache_cookie *cookie = object->fscache.cookie; _enter(",%d", keylen); BUG_ON(keylen < 2 || keylen > 514); print = 1; - for (loop = 2; loop < keylen; loop++) - print &= cachefiles_filecharmap[raw[loop]]; + if (!volume_new_location(cookie)) { + for (loop = 2; loop < keylen; loop++) + print &= cachefiles_filecharmap[raw[loop]]; + } if (print) { /* if the path is usable ASCII, then we render it directly */ -- 2.46.1

From: Yu Kuai <yukuai3@huawei.com> hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- Currently cookie is combined with: csum + acc + key However csum only exist for data cookie from mainline, hence if new location is set, skip csum for volume to keep cachefile location the same as mainline. Noted that csum construction for data cookie is also different from mainline, and following patches will adapt this. Signed-off-by: Yu Kuai <yukuai3@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/key.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/fs/cachefiles/key.c b/fs/cachefiles/key.c index 53643600fd1b..89dac9b90c45 100644 --- a/fs/cachefiles/key.c +++ b/fs/cachefiles/key.c @@ -30,11 +30,15 @@ static void cachefiles_cook_acc(char *key, unsigned int acc, int *len) *len += 2; } -static int cachefiles_cook_csum(const u8 *raw, int keylen, char *key) +static int cachefiles_cook_csum(struct fscache_cookie *cookie, const u8 *raw, + int keylen, char *key) { unsigned char csum = 0; int loop; + if (volume_new_location(cookie)) + return 1; + for (loop = 0; loop < keylen; loop++) csum += raw[loop]; sprintf(key, "@%02x%c+", (unsigned int) csum, 0); @@ -98,7 +102,7 @@ char *cachefiles_cook_key(struct cachefiles_object *object, if (!key) return NULL; - len = cachefiles_cook_csum(raw, keylen, key); + len = cachefiles_cook_csum(cookie, raw, keylen, key); mark = len - 1; if (print) { -- 2.46.1

From: Yu Kuai <yukuai3@huawei.com> hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- If input keyname contain character that is unprintable, the treatment from mainline is totally different. Hence bance port the treatment from mainline for the case new_location, so that cachefile location is the same as mainline. Signed-off-by: Yu Kuai <yukuai3@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/key.c | 110 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 110 insertions(+) diff --git a/fs/cachefiles/key.c b/fs/cachefiles/key.c index 2895ab1a38da..772ad69c49ba 100644 --- a/fs/cachefiles/key.c +++ b/fs/cachefiles/key.c @@ -22,6 +22,11 @@ static const char cachefiles_filecharmap[256] = { [48 ... 127] = 1, /* '0' -> '~' */ }; +static inline unsigned int how_many_hex_digits(unsigned int x) +{ + return x ? round_up(ilog2(x) + 1, 4) / 4 : 0; +} + static void cachefiles_cook_acc(char *key, unsigned int acc, int *len) { key[*len + 1] = cachefiles_charmap[acc & 63]; @@ -50,6 +55,85 @@ static int cachefiles_cook_csum(struct fscache_cookie *cookie, const u8 *raw, return 5; } +static char *cachefiles_cook_data_key(const u8 *key, int keylen) +{ + const u8 *kend; + unsigned int acc, i, n, nle, nbe; + unsigned int b64len, len, pad; + char *name, sep; + + /* See if it makes sense to encode it as "hex,hex,hex" for each 32-bit + * chunk. We rely on the key having been padded out to a whole number + * of 32-bit words. + */ + n = round_up(keylen, 4); + nbe = nle = 0; + for (i = 0; i < n; i += 4) { + u32 be = be32_to_cpu(*(__be32 *)(key + i)); + u32 le = le32_to_cpu(*(__le32 *)(key + i)); + + nbe += 1 + how_many_hex_digits(be); + nle += 1 + how_many_hex_digits(le); + } + + b64len = DIV_ROUND_UP(keylen, 3); + pad = b64len * 3 - keylen; + b64len = 2 + b64len * 4; /* Length if we base64-encode it */ + _debug("len=%u nbe=%u nle=%u b64=%u", keylen, nbe, nle, b64len); + if (nbe < b64len || nle < b64len) { + unsigned int nlen = min(nbe, nle) + 1; + + name = kmalloc(nlen, GFP_KERNEL); + if (!name) + return NULL; + sep = (nbe <= nle) ? 'S' : 'T'; /* Encoding indicator */ + len = 0; + for (i = 0; i < n; i += 4) { + u32 x; + + if (nbe <= nle) + x = be32_to_cpu(*(__be32 *)(key + i)); + else + x = le32_to_cpu(*(__le32 *)(key + i)); + name[len++] = sep; + if (x != 0) + len += snprintf(name + len, nlen - len, "%x", x); + sep = ','; + } + name[len] = 0; + return name; + } + + /* We need to base64-encode it */ + name = kmalloc(b64len + 1, GFP_KERNEL); + if (!name) + return NULL; + + name[0] = 'E'; + name[1] = '0' + pad; + len = 2; + kend = key + keylen; + do { + acc = *key++; + if (key < kend) { + acc |= *key++ << 8; + if (key < kend) + acc |= *key++ << 16; + } + + name[len++] = cachefiles_charmap[acc & 63]; + acc >>= 6; + name[len++] = cachefiles_charmap[acc & 63]; + acc >>= 6; + name[len++] = cachefiles_charmap[acc & 63]; + acc >>= 6; + name[len++] = cachefiles_charmap[acc & 63]; + } while (key < kend); + + name[len] = 0; + return name; +} + /* * turn the raw key into something cooked * - the raw key should include the length in the two bytes at the front @@ -86,6 +170,9 @@ char *cachefiles_cook_key(struct cachefiles_object *object, * is ((514 + 251) / 252) = 3 */ max += 1; /* NUL on end */ + } else if (data_new_location(cookie)) { + max = 5; /* @checksum/M */ + max += 1; /* NUL on end */ } else { /* calculate the maximum length of the cooked key */ keylen = (keylen + 2) / 3; @@ -131,6 +218,29 @@ char *cachefiles_cook_key(struct cachefiles_object *object, case FSCACHE_COOKIE_TYPE_DATAFILE: type = 'D'; break; default: type = 'S'; break; } + } else if (data_new_location(cookie)) { + int nlen; + char *name = cachefiles_cook_data_key(raw + 2, keylen - 2); + char *new_key; + + if (!name) { + kfree(key); + return NULL; + } + + nlen = max + strlen(name) - 1; + new_key = krealloc(key, nlen, GFP_KERNEL); + if (!new_key) { + kfree(key); + kfree(name); + return NULL; + } + + key = new_key; + type = name[0]; + for (loop = 1; loop < strlen(name); loop++) + key[len++] = name[loop]; + kfree(name); } else { seg = 252; for (loop = keylen; loop > 0; loop--) { -- 2.46.1

From: Yu Kuai <yukuai3@huawei.com> hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- So that cachefile location is the same with mainline kernel, and cachefile can still be used after upgrading kernel. test 1) domain_id="domain", fsid="test.img", device="blob1.img" - hulk-5.10: ./@24/I05erofs/@cf/I0cerofs,domain/@33/D08test.img ./@24/I05erofs/@cf/I0cerofs,domain/@44/D09blob1.img - hulk-5.10 with this set: ./Ierofs,domain/@ff/Dtest.img ./Ierofs,domain/@d6/Dblob1.img - mainline: ./Ierofs,domain/@ff/Dtest.img ./Ierofs,domain/@d6/Dblob1.img test 2) fsid="test.img", device="blob1.img" - hulk-5.10: ./@24/I05erofs/@84/I0eerofs,test.img/@33/D08test.img ./@24/I05erofs/@84/I0eerofs,test.img/@44/D09blob1.img - hulk-5.10 with this set: ./Ierofs,test.img/@f7/Dtest.img ./Ierofs,test.img/@cb/Dblob1.img - mainline: ./Ierofs,test.img/@f7/Dtest.img ./Ierofs,test.img/@cb/Dblob1.img test 3) domain_id="d o m a i n", fsid="t e s t.img", device="b l o b 1.img" - hulk-5.10: ./@24/I05erofs/@74/Jh0gpOZCpPN2pwY68J1iowA68K100/@96/Eb00twk68P12tKAmrD100 ./@24/I05erofs/@74/Jh0gpOZCpPN2pwY68J1iowA68K100/@c8/Ed0wowM68L1yow4zbFRSp - hulk-5.10 with this set: ./Ierofs,d o m a i n/@9a/E1Q1ipwc78QViqJt60 ./Ierofs,d o m a i n/@e8/E2y12rwY68y1icKAmrD100 - mainline: ./Ierofs,d o m a i n/@9a/E1Q1ipwc78QViqJt60 ./Ierofs,d o m a i n/@e8/E2y12rwY68y1icKAmrD100 test 4) fsid="t e s t.img", device="b l o b 1.img" - hulk-5.10: ./@24/I05erofs/@e7/Jh0gpOZCpPN2twk68P12tKAmrD100/@96/Eb00twk68P12tKAmrD100 ./@24/I05erofs/@e7/Jh0gpOZCpPN2twk68P12tKAmrD100/@c8/Ed0wowM68L1yow4zbFRSp - hulk-5.10 with this set ./Ierofs,t e s t.img/@18/E1Q1ipwc78QViqJt60 ./Ierofs,t e s t.img/@86/E2y12rwY68y1icKAmrD100 - mainline ./Ierofs,t e s t.img/@18/E1Q1ipwc78QViqJt60 ./Ierofs,t e s t.img/@86/E2y12rwY68y1icKAmrD100 Signed-off-by: Yu Kuai <yukuai3@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/fscache.c | 1 + 1 file changed, 1 insertion(+) diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c index f0b9815f56f6..2389b50c7906 100644 --- a/fs/erofs/fscache.c +++ b/fs/erofs/fscache.c @@ -30,6 +30,7 @@ const struct fscache_cookie_def erofs_fscache_super_index_def = { .name = "EROFS.super", .type = FSCACHE_COOKIE_TYPE_INDEX, .check_aux = NULL, + .new_location = true, }; const struct fscache_cookie_def erofs_fscache_inode_object_def = { -- 2.46.1

hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- When upgrading the kernel version from 5.10 to 6.6 data that has been cached is re-downloaded due to inconsistencies between the two versions of xattr. To avoid this problem, in cachefiles ondemand mode, make 5.10 also use the mainline xatrr. Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/xattr.c | 179 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 147 insertions(+), 32 deletions(-) diff --git a/fs/cachefiles/xattr.c b/fs/cachefiles/xattr.c index 72e42438f3d7..4aadace026d2 100644 --- a/fs/cachefiles/xattr.c +++ b/fs/cachefiles/xattr.c @@ -18,6 +18,29 @@ static const char cachefiles_xattr_cache[] = XATTR_USER_PREFIX "CacheFiles.cache"; +#define CACHEFILES_COOKIE_TYPE_DATA 1 +#define CACHEFILES_CONTENT_NO_DATA 0 /* No content stored */ + +struct cachefiles_obj_xattr { + __be64 object_size; /* Actual size of the object */ + __be64 zero_point; /* always zero */ + __u8 type; /* Type of object */ + __u8 content; /* always zero */ + __u8 data[]; /* netfs coherency data, always NULL */ +} __packed; + +struct cachefiles_vol_xattr { + __be32 reserved; /* Reserved, should be 0 */ + __u8 data[]; /* netfs volume coherency data, NULL */ +} __packed; + +struct cachefiles_vol_xattr new_vol_xattr; + +static int cachefiles_set_new_vol_xattr(struct cachefiles_object *object); +static int cachefiles_check_new_vol_xattr(struct cachefiles_object *object); +static int cachefiles_set_new_obj_xattr(struct cachefiles_object *object); +static int cachefiles_check_new_obj_xattr(struct cachefiles_object *object); + /* * check the type label on an object * - done using xattrs @@ -110,9 +133,14 @@ int cachefiles_set_object_xattr(struct cachefiles_object *object, _debug("SET #%u", auxdata->len); clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags); - ret = vfs_setxattr(dentry, cachefiles_xattr_cache, - &auxdata->type, auxdata->len, - XATTR_CREATE); + if (data_new_version(object->fscache.cookie)) + ret = cachefiles_set_new_obj_xattr(object); + else if (volume_new_version(object->fscache.cookie)) + ret = cachefiles_set_new_vol_xattr(object); + else + ret = vfs_setxattr(dentry, cachefiles_xattr_cache, + &auxdata->type, auxdata->len, + XATTR_CREATE); if (ret < 0 && ret != -ENOMEM) cachefiles_io_error_obj( object, @@ -190,48 +218,30 @@ int cachefiles_check_auxdata(struct cachefiles_object *object) return ret; } -/* - * check the state xattr on a cache file - * - return -ESTALE if the object should be deleted - */ -int cachefiles_check_object_xattr(struct cachefiles_object *object, - struct cachefiles_xattr *auxdata) +int cachefiles_check_old_object_xattr(struct cachefiles_object *object, + struct cachefiles_xattr *auxdata) { struct cachefiles_xattr *auxbuf; + unsigned int len = sizeof(struct cachefiles_xattr) + 512; struct dentry *dentry = object->dentry; int ret; - _enter("%p,#%d", object, auxdata->len); - - ASSERT(dentry); - ASSERT(d_backing_inode(dentry)); - - auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, cachefiles_gfp); - if (!auxbuf) { - _leave(" = -ENOMEM"); + auxbuf = kmalloc(len, cachefiles_gfp); + if (!auxbuf) return -ENOMEM; - } /* read the current type label */ ret = vfs_getxattr(dentry, cachefiles_xattr_cache, &auxbuf->type, 512 + 1); - if (ret < 0) { - if (ret == -ENODATA) - goto stale; /* no attribute - power went off - * mid-cull? */ - - if (ret == -ERANGE) - goto bad_type_length; - - cachefiles_io_error_obj(object, - "Can't read xattr on %lu (err %d)", - d_backing_inode(dentry)->i_ino, -ret); + if (ret < 0) goto error; - } /* check the on-disk object */ - if (ret < 1) - goto bad_type_length; + if (ret < 1) { + pr_err("Cache object %lu xattr length incorrect\n", + d_backing_inode(dentry)->i_ino); + goto stale; + } if (auxbuf->type != auxdata->type) goto stale; @@ -287,6 +297,51 @@ int cachefiles_check_object_xattr(struct cachefiles_object *object, error: kfree(auxbuf); + return ret; + +stale: + ret = -ESTALE; + goto error; +} + +/* + * check the state xattr on a cache file + * - return -ESTALE if the object should be deleted + */ +int cachefiles_check_object_xattr(struct cachefiles_object *object, + struct cachefiles_xattr *auxdata) +{ + int ret; + struct dentry *dentry = object->dentry; + + _enter("%p,#%d", object, auxdata->len); + + ASSERT(dentry); + ASSERT(d_backing_inode(dentry)); + + if (data_new_version(object->fscache.cookie)) + ret = cachefiles_check_new_obj_xattr(object); + else if (volume_new_version(object->fscache.cookie)) + ret = cachefiles_check_new_vol_xattr(object); + else + ret = cachefiles_check_old_object_xattr(object, auxdata); + + if (ret < 0) { + if (ret == -ENOMEM || ret == -ESTALE) + goto error; + /* no attribute - power went off mid-cull? */ + if (ret == -ENODATA) + goto stale; + if (ret == -ERANGE) + goto bad_type_length; + + cachefiles_io_error_obj(object, + "Can't read xattr on %lu (err %d)", + d_backing_inode(dentry)->i_ino, -ret); + goto error; + } + ret = 0; +error: _leave(" = %d", ret); return ret; @@ -323,3 +378,63 @@ int cachefiles_remove_object_xattr(struct cachefiles_cache *cache, _leave(" = %d", ret); return ret; } + +static int cachefiles_set_new_vol_xattr(struct cachefiles_object *object) +{ + unsigned int len = sizeof(struct cachefiles_vol_xattr); + struct dentry *dentry = object->dentry; + + return vfs_setxattr(dentry, cachefiles_xattr_cache, &new_vol_xattr, + len, XATTR_CREATE); +} + +static int cachefiles_check_new_vol_xattr(struct cachefiles_object *object) +{ + int ret; + struct cachefiles_vol_xattr buf; + unsigned int len = sizeof(struct cachefiles_vol_xattr); + struct dentry *dentry = object->dentry; + + ret = vfs_getxattr(dentry, cachefiles_xattr_cache, &buf, len); + if (ret < 0) + return ret; + + if (ret != len || memcmp(&buf, &new_vol_xattr, len) != 0) + ret = -ESTALE; + + return ret > 0 ? 0 : ret; +} + +static int cachefiles_set_new_obj_xattr(struct cachefiles_object *object) +{ + unsigned int len = sizeof(struct cachefiles_obj_xattr); + struct dentry *dentry = object->dentry; + struct cachefiles_obj_xattr buf = { + .object_size = cpu_to_be64(object->fscache.store_limit_l), + .type = CACHEFILES_COOKIE_TYPE_DATA, + .content = CACHEFILES_CONTENT_NO_DATA, + }; + + return vfs_setxattr(dentry, cachefiles_xattr_cache, &buf, len, + XATTR_CREATE); +} + +static int cachefiles_check_new_obj_xattr(struct cachefiles_object *object) +{ + int ret; + struct cachefiles_obj_xattr buf; + unsigned int len = sizeof(struct cachefiles_obj_xattr); + struct dentry *dentry = object->dentry; + + ret = vfs_getxattr(dentry, cachefiles_xattr_cache, &buf, len); + if (ret < 0) + return ret; + + if (ret != len || + buf.type != CACHEFILES_COOKIE_TYPE_DATA || + buf.content != CACHEFILES_CONTENT_NO_DATA || + buf.object_size != cpu_to_be64(object->fscache.store_limit_l)) + ret = -ESTALE; + + return ret > 0 ? 0 : ret; +} -- 2.46.1

From: Zizhi Wo <wozizhi@huawei.com> hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- At present, the trace point of fscache_cookie_put() has the UAF problem of cookie. Following is the process that triggers the issue: process A process B fscache_cookie_put atomic_dec_return(&cookie->usage) fscache_cookie_put atomic_dec_return(&cookie->usage) trace_fscache_cookie(cookie...) fscache_free_cookie trace_fscache_cookie(cookie...) After process B has set the cookie free, process A calls trace and the cookie UAF problem occurs. Fix this by calling trace before decrement cookie->usage. Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/fscache/cookie.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/fs/fscache/cookie.c b/fs/fscache/cookie.c index bd4a6734d163..422248fa55ca 100644 --- a/fs/fscache/cookie.c +++ b/fs/fscache/cookie.c @@ -930,9 +930,8 @@ void fscache_cookie_put(struct fscache_cookie *cookie, _enter("%p", cookie); do { + trace_fscache_cookie(cookie, where, atomic_read(&cookie->usage)); usage = atomic_dec_return(&cookie->usage); - trace_fscache_cookie(cookie, where, usage); - if (usage > 0) return; BUG_ON(usage < 0); -- 2.46.1

hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- We got the following issue in a fuzz test of randomly issuing the restore command: ================================================================== BUG: KASAN: slab-use-after-free in cachefiles_ondemand_daemon_read+0x609/0xab0 Write of size 4 at addr ffff888109164a80 by task ondemand-04-dae/4962 CPU: 11 PID: 4962 Comm: ondemand-04-dae Not tainted 6.8.0-rc7-dirty #542 Call Trace: kasan_report+0x94/0xc0 cachefiles_ondemand_daemon_read+0x609/0xab0 vfs_read+0x169/0xb50 ksys_read+0xf5/0x1e0 Allocated by task 626: __kmalloc+0x1df/0x4b0 cachefiles_ondemand_send_req+0x24d/0x690 cachefiles_create_tmpfile+0x249/0xb30 cachefiles_create_file+0x6f/0x140 cachefiles_look_up_object+0x29c/0xa60 cachefiles_lookup_cookie+0x37d/0xca0 fscache_cookie_state_machine+0x43c/0x1230 [...] Freed by task 626: kfree+0xf1/0x2c0 cachefiles_ondemand_send_req+0x568/0x690 cachefiles_create_tmpfile+0x249/0xb30 cachefiles_create_file+0x6f/0x140 cachefiles_look_up_object+0x29c/0xa60 cachefiles_lookup_cookie+0x37d/0xca0 fscache_cookie_state_machine+0x43c/0x1230 [...] ================================================================== Following is the process that triggers the issue: mount | daemon_thread1 | daemon_thread2 ------------------------------------------------------------ cachefiles_ondemand_init_object cachefiles_ondemand_send_req REQ_A = kzalloc(sizeof(*req) + data_len) wait_for_completion(&REQ_A->done) cachefiles_daemon_read cachefiles_ondemand_daemon_read REQ_A = cachefiles_ondemand_select_req cachefiles_ondemand_get_fd copy_to_user(_buffer, msg, n) process_open_req(REQ_A) ------ restore ------ cachefiles_ondemand_restore xas_for_each(&xas, req, ULONG_MAX) xas_set_mark(&xas, CACHEFILES_REQ_NEW); cachefiles_daemon_read cachefiles_ondemand_daemon_read REQ_A = cachefiles_ondemand_select_req write(devfd, ("copen %u,%llu", msg->msg_id, size)); cachefiles_ondemand_copen xa_erase(&cache->reqs, id) complete(&REQ_A->done) kfree(REQ_A) cachefiles_ondemand_get_fd(REQ_A) fd = get_unused_fd_flags file = anon_inode_getfile fd_install(fd, file) load = (void *)REQ_A->msg.data; load->fd = fd; // load UAF !!! This issue is caused by issuing a restore command when the daemon is still alive, which results in a request being processed multiple times thus triggering a UAF. So to avoid this problem, add an additional reference count to cachefiles_req, which is held while waiting and reading, and then released when the waiting and reading is over. Note that since there is only one reference count for waiting, we need to avoid the same request being completed multiple times, so we can only complete the request if it is successfully removed from the xarray. Fixes: e73fa11a356c ("cachefiles: add restore command to recover inflight ondemand read requests") Suggested-by: Hou Tao <houtao1@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/internal.h | 1 + fs/cachefiles/ondemand.c | 36 ++++++++++++++++++++---------------- 2 files changed, 21 insertions(+), 16 deletions(-) diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index 510a895efe7a..e84a8a217ee3 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -123,6 +123,7 @@ static inline bool cachefiles_in_ondemand_mode(struct cachefiles_cache *cache) struct cachefiles_req { struct cachefiles_object *object; struct completion done; + refcount_t ref; int error; struct cachefiles_msg msg; }; diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 968376ea9ae6..c1f8be89afca 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -9,6 +9,12 @@ static bool cachefiles_buffered_ondemand = true; module_param_named(buffered_ondemand, cachefiles_buffered_ondemand, bool, 0644); +static inline void cachefiles_req_put(struct cachefiles_req *req) +{ + if (refcount_dec_and_test(&req->ref)) + kfree(req); +} + static int cachefiles_ondemand_fd_release(struct inode *inode, struct file *file) { @@ -349,6 +355,7 @@ ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, radix_tree_iter_tag_clear(&cache->reqs, &iter, CACHEFILES_REQ_NEW); cache->req_id_next = iter.index + 1; + refcount_inc(&req->ref); xa_unlock(&cache->reqs); id = iter.index; @@ -357,7 +364,7 @@ ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, ret = cachefiles_ondemand_get_fd(req); if (ret) { cachefiles_ondemand_set_object_close(req->object); - goto error; + goto out; } } @@ -369,25 +376,21 @@ ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, if (msg->opcode == CACHEFILES_OP_OPEN) __close_fd(current->files, ((struct cachefiles_open *)msg->data)->fd); - goto error; } - /* CLOSE request has no reply */ - if (msg->opcode == CACHEFILES_OP_CLOSE) { +out: + /* Remove error request and CLOSE request has no reply */ + if (ret || msg->opcode == CACHEFILES_OP_CLOSE) { xa_lock(&cache->reqs); - radix_tree_delete(&cache->reqs, id); + if (radix_tree_lookup(&cache->reqs, id) == req) { + req->error = ret; + complete(&req->done); + radix_tree_delete(&cache->reqs, id); + } xa_unlock(&cache->reqs); - complete(&req->done); } - return n; - -error: - xa_lock(&cache->reqs); - radix_tree_delete(&cache->reqs, id); - xa_unlock(&cache->reqs); - req->error = ret; - complete(&req->done); - return ret; + cachefiles_req_put(req); + return ret ? ret : n; } typedef int (*init_req_fn)(struct cachefiles_req *req, void *private); @@ -421,6 +424,7 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, goto out; } + refcount_set(&req->ref, 1); req->object = object; init_completion(&req->done); req->msg.opcode = opcode; @@ -473,7 +477,7 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, wake_up_all(&cache->daemon_pollwq); wait_for_completion(&req->done); ret = req->error; - kfree(req); + cachefiles_req_put(req); return ret; out: /* Reset the object to close state in error handling path. -- 2.46.1

hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- This lets us see the correct trace output. Signed-off-by: Baokun Li <libaokun1@huawei.com> --- include/trace/events/cachefiles.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/trace/events/cachefiles.h b/include/trace/events/cachefiles.h index 90d87f0cbe15..05ecaf2245b2 100644 --- a/include/trace/events/cachefiles.h +++ b/include/trace/events/cachefiles.h @@ -50,6 +50,8 @@ enum cachefiles_obj_ref_trace { EM(fscache_obj_put_work, "PUT work") \ EM(cachefiles_obj_put_wait_retry, "PUT wait_retry") \ EM(cachefiles_obj_put_wait_timeo, "PUT wait_timeo") \ + EM(cachefiles_obj_get_ondemand_fd, "GET ondemand_fd") \ + EM(cachefiles_obj_put_ondemand_fd, "PUT ondemand_fd") \ EM(cachefiles_obj_get_read_req, "GET read_req") \ E_(cachefiles_obj_put_read_req, "PUT read_req") -- 2.46.1

hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- Added CACHEFILES_ONDEMAND_OBJSTATE_dropping Indicates that the cachefiles object is being dropped, and is set after the close request for the dropped object completes, and no new requests are allowed to be sent after this state. Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/internal.h | 2 ++ fs/cachefiles/ondemand.c | 10 ++++++++-- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index e84a8a217ee3..1499548883e3 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -35,6 +35,7 @@ enum cachefiles_object_state { CACHEFILES_ONDEMAND_OBJSTATE_close, /* Anonymous fd closed by daemon or initial state */ CACHEFILES_ONDEMAND_OBJSTATE_open, /* Anonymous fd associated with object is available */ CACHEFILES_ONDEMAND_OBJSTATE_reopening, /* Object that was closed and is being reopened. */ + CACHEFILES_ONDEMAND_OBJSTATE_dropping, /* Object is being dropped. */ }; struct cachefiles_ondemand_info { @@ -298,6 +299,7 @@ cachefiles_ondemand_set_object_##_state(struct cachefiles_object *object) \ CACHEFILES_OBJECT_STATE_FUNCS(open); CACHEFILES_OBJECT_STATE_FUNCS(close); CACHEFILES_OBJECT_STATE_FUNCS(reopening); +CACHEFILES_OBJECT_STATE_FUNCS(dropping); static inline bool cachefiles_ondemand_is_reopening_read(struct cachefiles_req *req) { diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 544eba85b776..ceeff8363502 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -460,7 +460,8 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, */ xa_lock(&cache->reqs); - if (test_bit(CACHEFILES_DEAD, &cache->flags)) { + if (test_bit(CACHEFILES_DEAD, &cache->flags) || + cachefiles_ondemand_object_is_dropping(object)) { xa_unlock(&cache->reqs); ret = -EIO; goto out; @@ -493,7 +494,8 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, * If error occurs after creating the anonymous fd, * cachefiles_ondemand_fd_release() will set object to close. */ - if (opcode == CACHEFILES_OP_OPEN) + if (opcode == CACHEFILES_OP_OPEN && + !cachefiles_ondemand_object_is_dropping(object)) cachefiles_ondemand_set_object_close(object); kfree(req); return ret; @@ -591,8 +593,12 @@ int cachefiles_ondemand_init_object(struct cachefiles_object *object) void cachefiles_ondemand_clean_object(struct cachefiles_object *object) { + if (!object->private) + return; + cachefiles_ondemand_send_req(object, CACHEFILES_OP_CLOSE, 0, cachefiles_ondemand_init_close_req, NULL); + cachefiles_ondemand_set_object_dropping(object); } int cachefiles_ondemand_read(struct cachefiles_object *object, -- 2.46.1

hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- Disable setting max_active values less than lower bound through the procfs interface. This avoids that when the object_max_active is 1, the previous work in the workqueue waits for the next work to complete, resulting in a dead wait. Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/fscache/main.c | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/fs/fscache/main.c b/fs/fscache/main.c index a9f059220418..b754486e085f 100644 --- a/fs/fscache/main.c +++ b/fs/fscache/main.c @@ -45,8 +45,11 @@ struct workqueue_struct *fscache_op_wq; DEFINE_PER_CPU(wait_queue_head_t, fscache_object_cong_wait); /* these values serve as lower bounds, will be adjusted in fscache_init() */ -static unsigned fscache_object_max_active = 4; -static unsigned fscache_op_max_active = 2; +#define FSCACHE_MIN_OBJECT_MAX_ACTIVE 4 +static unsigned int fscache_object_max_active = FSCACHE_MIN_OBJECT_MAX_ACTIVE; +static unsigned int fscache_op_max_active = FSCACHE_MIN_OBJECT_MAX_ACTIVE / 2; +static unsigned int fscache_min_object_max_active = FSCACHE_MIN_OBJECT_MAX_ACTIVE; +static unsigned int fscache_min_op_max_active = FSCACHE_MIN_OBJECT_MAX_ACTIVE / 2; #ifdef CONFIG_SYSCTL static struct ctl_table_header *fscache_sysctl_header; @@ -55,12 +58,16 @@ static int fscache_max_active_sysctl(struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos) { struct workqueue_struct **wqp = table->extra1; + unsigned int *min_val = table->extra2; unsigned int *datap = table->data; int ret; ret = proc_dointvec(table, write, buffer, lenp, ppos); - if (ret == 0) + if (ret == 0) { + if (cachefiles_ondemand_is_enabled() && *datap < *min_val) + return -EINVAL; workqueue_set_max_active(*wqp, *datap); + } return ret; } @@ -72,6 +79,7 @@ static struct ctl_table fscache_sysctls[] = { .mode = 0644, .proc_handler = fscache_max_active_sysctl, .extra1 = &fscache_object_wq, + .extra2 = &fscache_min_object_max_active, }, { .procname = "operation_max_active", @@ -80,6 +88,7 @@ static struct ctl_table fscache_sysctls[] = { .mode = 0644, .proc_handler = fscache_max_active_sysctl, .extra1 = &fscache_op_wq, + .extra2 = &fscache_min_op_max_active, }, {} }; -- 2.46.1

hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- The following concurrency may cause a read request to fail to be completed and result in a hung: t1 | t2 --------------------------------------------------------- cachefiles_ondemand_copen req = xa_erase(&cache->reqs, id) // Anon fd is maliciously closed. cachefiles_ondemand_fd_release xa_lock(&cache->reqs) cachefiles_ondemand_set_object_close(object) xa_unlock(&cache->reqs) cachefiles_ondemand_set_object_open // No one will ever close it again. cachefiles_ondemand_daemon_read cachefiles_ondemand_select_req // Get a read req but its fd is already closed. // The daemon can't issue a cread ioctl with an closed fd, then hung. So add spin_lock for cachefiles_ondemand_info to protect ondemand_id and state, thus we can avoid the above problem in cachefiles_ondemand_copen() by using ondemand_id to determine if fd has been released. Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/internal.h | 1 + fs/cachefiles/ondemand.c | 13 +++++++++++++ 2 files changed, 14 insertions(+) diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index 1499548883e3..71c651b305bf 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -43,6 +43,7 @@ struct cachefiles_ondemand_info { int ondemand_id; enum cachefiles_object_state state; struct cachefiles_object *object; + spinlock_t lock; }; /* diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 6d36d3e950e8..c15433196a88 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -30,8 +30,10 @@ static int cachefiles_ondemand_fd_release(struct inode *inode, struct cachefiles_cache, cache); xa_lock(&cache->reqs); + spin_lock(&info->lock); info->ondemand_id = CACHEFILES_ONDEMAND_ID_CLOSED; cachefiles_ondemand_set_object_close(object); + spin_unlock(&info->lock); /* Only flush CACHEFILES_REQ_NEW marked req to avoid race with daemon_read */ radix_tree_for_each_tagged(slot, &cache->reqs, &iter, 0, CACHEFILES_REQ_NEW) { @@ -131,6 +133,7 @@ int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args) { struct cachefiles_req *req; struct fscache_cookie *cookie; + struct cachefiles_ondemand_info *info; char *pid, *psize; unsigned long id; long size; @@ -186,6 +189,14 @@ int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args) goto out; } + info = req->object->private; + spin_lock(&info->lock); + /* The anonymous fd was closed before copen. */ + if (info->ondemand_id == CACHEFILES_ONDEMAND_ID_CLOSED) { + spin_unlock(&info->lock); + req->error = -EBADFD; + goto out; + } cookie = req->object->fscache.cookie; fscache_set_store_limit(&req->object->fscache, size); if (size) @@ -194,6 +205,7 @@ int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args) set_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags); cachefiles_ondemand_set_object_open(req->object); + spin_unlock(&info->lock); wake_up_all(&cache->daemon_pollwq); out: @@ -652,6 +664,7 @@ int cachefiles_ondemand_init_obj_info(struct cachefiles_object *object) return -ENOMEM; object->private->object = object; + spin_lock_init(&object->private->lock); INIT_WORK(&object->private->work, ondemand_object_worker); return 0; } -- 2.46.1

hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- Replacing wait_for_completion() with wait_for_completion_killable() in cachefiles_ondemand_send_req() allows us to kill processes that might trigger a hunk_task if the daemon is abnormal. But now only CACHEFILES_OP_READ is killable, because OP_CLOSE and OP_OPEN is initiated from kworker context and the signal is prohibited in these kworker. Note that when the req in xas changes, i.e. xas_load(&xas) != req, it means that a process will complete the current request soon, so wait again for the request to be completed. Suggested-by: Hou Tao <houtao1@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/ondemand.c | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 2cbe8a1b953f..4fb5cdfde51c 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -517,8 +517,24 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, xa_unlock(&cache->reqs); wake_up_all(&cache->daemon_pollwq); - wait_for_completion(&req->done); - ret = req->error; +wait: + ret = wait_for_completion_killable(&req->done); + if (!ret) { + ret = req->error; + } else { + xa_lock(&cache->reqs); + if (radix_tree_lookup(&cache->reqs, id) == req) { + radix_tree_delete(&cache->reqs, id); + ret = -EINTR; + } + xa_unlock(&cache->reqs); + + /* Someone will complete it soon. */ + if (ret != -EINTR) { + cpu_relax(); + goto wait; + } + } cachefiles_req_put(req); return ret; out: -- 2.46.1

hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- This is in line with the default for the mainline, and then this allows us to have a smoother experience at high concurrency. Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/fscache/main.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/fs/fscache/main.c b/fs/fscache/main.c index b754486e085f..e8c6c70092e0 100644 --- a/fs/fscache/main.c +++ b/fs/fscache/main.c @@ -46,8 +46,9 @@ DEFINE_PER_CPU(wait_queue_head_t, fscache_object_cong_wait); /* these values serve as lower bounds, will be adjusted in fscache_init() */ #define FSCACHE_MIN_OBJECT_MAX_ACTIVE 4 -static unsigned int fscache_object_max_active = FSCACHE_MIN_OBJECT_MAX_ACTIVE; -static unsigned int fscache_op_max_active = FSCACHE_MIN_OBJECT_MAX_ACTIVE / 2; +#define FSCACHE_DEF_OBJECT_MAX_ACTIVE 256 +static unsigned int fscache_object_max_active = FSCACHE_DEF_OBJECT_MAX_ACTIVE; +static unsigned int fscache_op_max_active = FSCACHE_DEF_OBJECT_MAX_ACTIVE / 2; static unsigned int fscache_min_object_max_active = FSCACHE_MIN_OBJECT_MAX_ACTIVE; static unsigned int fscache_min_op_max_active = FSCACHE_MIN_OBJECT_MAX_ACTIVE / 2; -- 2.46.1

From: Zizhi Wo <wozizhi@huawei.com> hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- In the current erofs read on demand scenario, the state of back_page is determined during cachefiles reading process. If the back_page status is Uptodate, this read request is completed. If the status is Error, an error is returned. When the back_page status is neither of the above, the page has probably been truncated, and the cachefiles_read_reissue() is called. If it is not truncated, the read_page function of the back-end file system is called again for reading. When the back-end file system is ext4, if 100% fail_make_request failure is injected, it will cause the final call __read_end_io() to clear page's Uptodate and Error flags. Judging that page status is neither of the above, cachefiles_read_copier() calls the read_page function of the back-end file system again, resulting in an endless loop. The outer netfs_page waits for back_page to complete the read request, causing a kernel hung. Fix this issue by adding an additional flag to the monitor as it corresponds to back_page. This flag is placed when the read_page is called for the first time, and when the next time it needs to be called, the flag is set to determine whether the process needs to end. Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/internal.h | 2 ++ fs/cachefiles/rdwr.c | 17 ++++++++++++++++- 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index 355fb9b79741..349b1e6bb7cd 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -141,6 +141,8 @@ struct cachefiles_one_read { struct page *netfs_page; /* netfs page we're going to fill */ struct fscache_retrieval *op; /* retrieval op covering this */ struct list_head op_link; /* link in op's todo list */ + unsigned long flags; +#define CACHEFILES_MONITOR_ENTER_READ 0 /* restrict calls to read_page */ }; /* diff --git a/fs/cachefiles/rdwr.c b/fs/cachefiles/rdwr.c index 453bf7cc88b3..d95435ad5542 100644 --- a/fs/cachefiles/rdwr.c +++ b/fs/cachefiles/rdwr.c @@ -108,6 +108,13 @@ static int cachefiles_read_reissue(struct cachefiles_object *object, * need a second */ put_page(backpage2); + /* + * end the process if the page was not truncated + * and we have already read it before + */ + if (test_bit(CACHEFILES_MONITOR_ENTER_READ, &monitor->flags)) + return -EIO; + INIT_LIST_HEAD(&monitor->op_link); add_page_wait_queue(backpage, &monitor->monitor); @@ -120,6 +127,8 @@ static int cachefiles_read_reissue(struct cachefiles_object *object, goto unlock_discard; _debug("reissue read"); + if (data_new_version(object->fscache.cookie)) + set_bit(CACHEFILES_MONITOR_ENTER_READ, &monitor->flags); ret = bmapping->a_ops->readpage(NULL, backpage); if (ret < 0) goto discard; @@ -190,7 +199,11 @@ static void cachefiles_read_copier(struct fscache_operation *_op) error = cachefiles_read_reissue(object, monitor); if (error == -EINPROGRESS) goto next; - goto recheck; + if (!data_new_version(object->fscache.cookie) || !error) + goto recheck; + pr_warn("%s, read error: %d, at page %lu, flags: %lx\n", + __func__, error, monitor->back_page->index, + (unsigned long) monitor->back_page->flags); } else { cachefiles_io_error_obj( object, @@ -284,6 +297,8 @@ static int cachefiles_read_backing_file_one(struct cachefiles_object *object, newpage = NULL; read_backing_page: + if (data_new_version(object->fscache.cookie)) + set_bit(CACHEFILES_MONITOR_ENTER_READ, &monitor->flags); ret = bmapping->a_ops->readpage(NULL, backpage); if (ret < 0) goto read_error; -- 2.46.1

hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- If the daemon performs an action that acquires the parent dir inode lock (e.g., statfs/cull/inuse) while processing an open request, it will result in an AA deadlock because the lock was already captured when the open request was issued. This is avoided by issuing and processing open requests outside of the lock in advance. Although an anonymous fd has been acquired by the daemon, it cannot be used until object->file has been assigned a value, before which -ENOBUFS is returned. Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/namei.c | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c index 88afa4a80dfb..799b7671e5b1 100644 --- a/fs/cachefiles/namei.c +++ b/fs/cachefiles/namei.c @@ -522,6 +522,20 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, key = NULL; lookup_again: + + /* + * Process the open request before acquiring the dir inode lock to + * avoid AA deadlocks caused by the daemon acquiring the dir inode + * lock while processing the open request. Although the daemon gets + * an anonymous fd, it can't be used until object->file has been + * assigned a value. + */ + if (!key) { + ret = cachefiles_ondemand_init_object(object); + if (ret < 0) + goto error_out2; + } + /* search the current directory for the element name */ _debug("lookup '%s'", name); @@ -592,10 +606,6 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, if (ret < 0) goto no_space_error; - ret = cachefiles_ondemand_init_object(object); - if (ret < 0) - goto create_error; - path.dentry = dir; ret = security_path_mknod(&path, next, S_IFREG, 0); if (ret < 0) @@ -640,12 +650,6 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, if (!object->new) { _debug("validate '%pd'", next); - ret = cachefiles_ondemand_init_object(object); - if (ret < 0) { - object->dentry = NULL; - goto error; - } - ret = cachefiles_check_object_xattr(object, auxdata); if (ret == -ESTALE) { /* delete the object (the deleter drops the directory -- 2.46.1

hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- After installing the anonymous fd, we can now see it in userland and close it. However, at this point we may not have gotten the reference count of the cache, but we will put it in the close fd, so this may cause a cache UAF. To avoid this, we will make the anonymous fd accessible to the userland by executing fd_install() after copy_to_user() has succeeded, and by this point we will have already grabbed the reference count of the cache. Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/ondemand.c | 54 ++++++++++++++++++++++++---------------- 1 file changed, 33 insertions(+), 21 deletions(-) diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index da5afd162f64..cf996eadd1af 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -6,6 +6,11 @@ #include <linux/module.h> #include "internal.h" +struct anon_file { + struct file *file; + int fd; +}; + static bool cachefiles_buffered_ondemand = true; module_param_named(buffered_ondemand, cachefiles_buffered_ondemand, bool, 0644); @@ -249,14 +254,14 @@ int cachefiles_ondemand_restore(struct cachefiles_cache *cache, char *args) return 0; } -static int cachefiles_ondemand_get_fd(struct cachefiles_req *req) +static int cachefiles_ondemand_get_fd(struct cachefiles_req *req, + struct anon_file *anon_file) { struct cachefiles_object *object = req->object; struct cachefiles_cache *cache; struct cachefiles_open *load; - struct file *file; u32 object_id; - int ret, fd; + int ret; object->fscache.cache->ops->grab_object(&object->fscache, cachefiles_obj_get_ondemand_fd); @@ -273,16 +278,16 @@ static int cachefiles_ondemand_get_fd(struct cachefiles_req *req) goto err; object_id = ret; - fd = get_unused_fd_flags(O_WRONLY); - if (fd < 0) { - ret = fd; + anon_file->fd = get_unused_fd_flags(O_WRONLY); + if (anon_file->fd < 0) { + ret = anon_file->fd; goto err_free_id; } - file = anon_inode_getfile("[cachefiles]", &cachefiles_ondemand_fd_fops, - object, O_WRONLY); - if (IS_ERR(file)) { - ret = PTR_ERR(file); + anon_file->file = anon_inode_getfile("[cachefiles]", + &cachefiles_ondemand_fd_fops, object, O_WRONLY); + if (IS_ERR(anon_file->file)) { + ret = PTR_ERR(anon_file->file); goto err_put_fd; } @@ -290,15 +295,14 @@ static int cachefiles_ondemand_get_fd(struct cachefiles_req *req) if (object->private->ondemand_id > 0) { spin_unlock(&object->private->lock); ret = -EEXIST; - file->private_data = NULL; + anon_file->file->private_data = NULL; goto err_put_file; } - file->f_mode |= FMODE_PWRITE | FMODE_LSEEK; - fd_install(fd, file); + anon_file->file->f_mode |= FMODE_PWRITE | FMODE_LSEEK; load = (void *)req->msg.data; - load->fd = fd; + load->fd = anon_file->fd; object->private->ondemand_id = object_id; spin_unlock(&object->private->lock); @@ -306,9 +310,11 @@ static int cachefiles_ondemand_get_fd(struct cachefiles_req *req) return 0; err_put_file: - fput(file); + fput(anon_file->file); + anon_file->file = NULL; err_put_fd: - put_unused_fd(fd); + put_unused_fd(anon_file->fd); + anon_file->fd = ret; err_free_id: xa_lock(&cache->ondemand_ids.idr_rt); idr_remove(&cache->ondemand_ids, object_id); @@ -377,6 +383,7 @@ ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, size_t n; int ret = 0; struct radix_tree_iter iter; + struct anon_file anon_file; /* * Cyclically search for a request that has not ever been processed, @@ -410,7 +417,7 @@ ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, id = iter.index; if (msg->opcode == CACHEFILES_OP_OPEN) { - ret = cachefiles_ondemand_get_fd(req); + ret = cachefiles_ondemand_get_fd(req, &anon_file); if (ret) goto out; } @@ -418,11 +425,16 @@ ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, msg->msg_id = id; msg->object_id = req->object->private->ondemand_id; - if (copy_to_user(_buffer, msg, n) != 0) { + if (copy_to_user(_buffer, msg, n) != 0) ret = -EFAULT; - if (msg->opcode == CACHEFILES_OP_OPEN) - __close_fd(current->files, - ((struct cachefiles_open *)msg->data)->fd); + + if (msg->opcode == CACHEFILES_OP_OPEN) { + if (ret < 0) { + fput(anon_file.file); + put_unused_fd(anon_file.fd); + goto out; + } + fd_install(anon_file.fd, anon_file.file); } out: -- 2.46.1

From: Zizhi Wo <wozizhi@huawei.com> hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- When an erofs file system is mounted with ondemand mode, if the cache root directory bound to cachefiles named rootdir, the resulting directory structure is seen as follows, where different directories corresponded to the objects of different levels: rootdir ____|____ | | cache(obj0) graveyard | domain_dir(obj1) | hash_dir | back_data.img(obj2) In the current logic, if cull is executed on the cache directory, it first determines whether the object corresponding to the directory is the active node of cache. If yes, it cannot be executed. If the fscache_object lookup successfully, it is set to avtive node; and if the lookup fails or the object state machine goes into drop, it is set to inactive. Currently cachefiles_daemon_cull() can execute on any directory or file which have not been called cachefiles_mark_object_active(), and we want to reduce the scope of this function. On the one hand, the user state needs to add relevant constraints; on the other hand, kernel mode also needs modified. This patch adds the restriction of filesystem-level isolation. In addition, the top-level cache dir can be culled directly because obj0 is not added as active_node. This causes the entire cache directory to be renamed graveyard, even though the underlying objects are inuse state, and cannot be resolved by mounting it again. Fix it by marking it as active in cachefiles_daemon_add_cache(). Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/bind.c | 6 ++++++ fs/cachefiles/daemon.c | 6 ++++++ fs/cachefiles/internal.h | 2 ++ fs/cachefiles/namei.c | 4 ++-- 4 files changed, 16 insertions(+), 2 deletions(-) diff --git a/fs/cachefiles/bind.c b/fs/cachefiles/bind.c index 50ac68b0ad81..3a88bef9ed4b 100644 --- a/fs/cachefiles/bind.c +++ b/fs/cachefiles/bind.c @@ -232,6 +232,12 @@ static int cachefiles_daemon_add_cache(struct cachefiles_cache *cache) if (ret < 0) goto error_add_cache; + /* + * As the cache->daemon_mutex lock hold and the cache is set to + * CACHEFILES_READY, this function must not return an error. + */ + cachefiles_mark_object_active(cache, fsdef); + /* done */ set_bit(CACHEFILES_READY, &cache->flags); dput(root); diff --git a/fs/cachefiles/daemon.c b/fs/cachefiles/daemon.c index 50433c6024dd..c94b512da4b5 100644 --- a/fs/cachefiles/daemon.c +++ b/fs/cachefiles/daemon.c @@ -662,6 +662,12 @@ static int cachefiles_daemon_cull(struct cachefiles_cache *cache, char *args) if (!d_can_lookup(path.dentry)) goto notdir; + /* limit the scope of cull */ + if (cache->mnt != path.mnt) { + path_put(&path); + return -EOPNOTSUPP; + } + cachefiles_begin_secure(cache, &saved_cred); ret = cachefiles_cull(cache, path.dentry, args); cachefiles_end_secure(cache, saved_cred); diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index 349b1e6bb7cd..97c4b4c639b4 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -210,6 +210,8 @@ extern char *cachefiles_cook_key(struct cachefiles_object *object, extern void cachefiles_mark_object_inactive(struct cachefiles_cache *cache, struct cachefiles_object *object, blkcnt_t i_blocks); +extern int cachefiles_mark_object_active(struct cachefiles_cache *cache, + struct cachefiles_object *object); extern int cachefiles_delete_object(struct cachefiles_cache *cache, struct cachefiles_object *object); extern int cachefiles_walk_to_object(struct cachefiles_object *parent, diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c index 799b7671e5b1..281e53d63972 100644 --- a/fs/cachefiles/namei.c +++ b/fs/cachefiles/namei.c @@ -133,8 +133,8 @@ static void cachefiles_mark_object_buried(struct cachefiles_cache *cache, /* * record the fact that an object is now active */ -static int cachefiles_mark_object_active(struct cachefiles_cache *cache, - struct cachefiles_object *object) +int cachefiles_mark_object_active(struct cachefiles_cache *cache, + struct cachefiles_object *object) { struct cachefiles_object *xobject; struct rb_node **_p, *_parent = NULL; -- 2.46.1

From: Zizhi Wo <wozizhi@huawei.com> hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- In the current erofs ondemand loading mode, after erofs is umounted and object->fd is closed, run the inuse() command and it may reveal that the corresponding object is still busy. This is because non-busy depends on the cachefiles_mark_object_inactive() called, but it comes after send close req. Fix this issue by moving cachefiles_mark_object_inactive() before send close request in erofs ondemand mode, as erofs ondemand mode will not set retired flag, there is no extra impact. Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/interface.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c index abbf0033459e..fa131db764c4 100644 --- a/fs/cachefiles/interface.c +++ b/fs/cachefiles/interface.c @@ -288,6 +288,11 @@ static void cachefiles_drop_object(struct fscache_object *_object) ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000); #endif + if (test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags) && + (volume_new_version(object->fscache.cookie) || + data_new_version(object->fscache.cookie))) + cachefiles_mark_object_inactive(cache, object, 0); + cachefiles_ondemand_clean_object(object); /* We need to tidy the object up if we did in fact manage to open it. -- 2.46.1

From: Zizhi Wo <wozizhi@huawei.com> hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- Commit 27756c07db81 ("cachefiles: add consistency check for copen/cread") added some validation to prevent malicious commands. But there is another case: if copen is maliciously called in the user mode, it may delete the request corresponding to the random id. And the request may have not been read yet. Note that when the object is set to reopen, the open request will be done with the still reopen state in above case. As a result, the request corresponding to this object is always skipped in select_req function, so the read request is never completed and blocks other process. Fix this issue by simply set object to close if its id < 0 in copen. In addition, the "ret != 0" condition is no need in get_fd function as it always meet, remove it. Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/ondemand.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 9f3e7d994aed..528da20e1119 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -189,6 +189,7 @@ int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args) radix_tree_delete(&cache->reqs, id); xa_unlock(&cache->reqs); + info = req->object->private; /* fail OPEN request if copen format is invalid */ ret = kstrtol(psize, 0, &size); if (ret) { @@ -208,7 +209,6 @@ int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args) goto out; } - info = req->object->private; spin_lock(&info->lock); /* The anonymous fd was closed before copen. */ if (info->ondemand_id == CACHEFILES_ONDEMAND_ID_CLOSED) { @@ -228,6 +228,11 @@ int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args) wake_up_all(&cache->daemon_pollwq); out: + spin_lock(&info->lock); + /* Need to set object close to avoid reopen status continuing */ + if (info->ondemand_id == CACHEFILES_ONDEMAND_ID_CLOSED) + cachefiles_ondemand_set_object_close(req->object); + spin_unlock(&info->lock); complete(&req->done); return ret; } @@ -323,7 +328,7 @@ static int cachefiles_ondemand_get_fd(struct cachefiles_req *req, err: spin_lock(&req->object->private->lock); /* Avoid marking an opened object as closed. */ - if (ret && object->private->ondemand_id <= 0) + if (object->private->ondemand_id <= 0) cachefiles_ondemand_set_object_close(req->object); spin_unlock(&req->object->private->lock); -- 2.46.1

hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- Reusing the msg_id after a maliciously completed reopen request may cause a read request to remain unprocessed and result in a hung, as shown below: t1 | t2 | t3 ------------------------------------------------- cachefiles_ondemand_select_req cachefiles_ondemand_object_is_close(A) cachefiles_ondemand_set_object_reopening(A) queue_work(fscache_object_wq, &info->work) ondemand_object_worker cachefiles_ondemand_init_object(A) cachefiles_ondemand_send_req(OPEN) // get msg_id 6 wait_for_completion(&req_A->done) cachefiles_ondemand_daemon_read // read msg_id 6 req_A cachefiles_ondemand_get_fd copy_to_user // Malicious completion msg_id 6 copen 6,-1 // reopen fails, want daemon to close fd, // then set object to close, retrigger reopen cachefiles_ondemand_init_object(B) cachefiles_ondemand_send_req(OPEN) // new open req_B reuse msg_id 6 // daemon successfully copen msg_id 6, so it won't close the fd. // object is always reopening, so read requests are not processed // resulting in a hung Therefore allocate the msg_id cyclically to avoid reusing the msg_id for a very short duration of time causing the above problem. Fixes: c8383054506c ("cachefiles: notify the user daemon when looking up cookie") Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/ondemand.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 528da20e1119..76c936fc9a68 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -535,9 +535,11 @@ static int cachefiles_ondemand_send_req(struct cachefiles_object *object, goto out; } - while (radix_tree_insert(&cache->reqs, - id = atomic64_read(&global_index), req)) - atomic64_inc(&global_index); + do { + id = atomic64_inc_return(&global_index); + if (unlikely(id == UINT_MAX)) + atomic64_set(&global_index, 0); + } while (radix_tree_insert(&cache->reqs, id, req)); radix_tree_tag_set(&cache->reqs, id, CACHEFILES_REQ_NEW); xa_unlock(&cache->reqs); -- 2.46.1

From: Jingbo Xu <jefflexu@linux.alibaba.com> mainline inclusion from mainline-v6.3-rc1 commit bdfa90142eb1f1272d2efc00dda6c0f35814e36a category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- Currently metadata is always on bootstrap, and thus device mapping is not needed so far. Remove the redundant device mapping in the meta routine. Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com> Reviewed-by: Jia Zhu <zhujia.zj@bytedance.com> Reviewed-by: Chao Yu <chao@kernel.org> Link: https://lore.kernel.org/r/20230209063913.46341-2-jefflexu@linux.alibaba.com Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com> Conflicts: fs/erofs/fscache.c [ Because it hasn't been switched to folio yet. ] Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/erofs/fscache.c | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c index 17640adf574d..23b55a67feb5 100644 --- a/fs/erofs/fscache.c +++ b/fs/erofs/fscache.c @@ -57,16 +57,9 @@ static int erofs_fscache_meta_readpage(struct file *data, struct page *page) { int ret; struct super_block *sb = page->mapping->host->i_sb; - struct erofs_map_dev mdev = { - .m_deviceid = 0, - .m_pa = page_offset(page), - }; - - ret = erofs_map_dev(sb, &mdev); - if (ret) - goto out; + struct erofs_fscache *ctx = page->mapping->host->i_private; - ret = fscache_read_or_alloc_page(mdev.m_fscache->cookie, page, + ret = fscache_read_or_alloc_page(ctx->cookie, page, erofs_readpage_from_fscache_complete, NULL, GFP_KERNEL); @@ -423,6 +416,7 @@ 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_private = ctx; ctx->inode = inode; } -- 2.46.1

From: Mikulas Patocka <mpatocka@redhat.com> mainline inclusion from mainline-v6.0-rc3 commit 8238b4579866b7c1bb99883cfe102a43db5506ff category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- There are several places in the kernel where wait_on_bit is not followed by a memory barrier (for example, in drivers/md/dm-bufio.c:new_read). On architectures with weak memory ordering, it may happen that memory accesses that follow wait_on_bit are reordered before wait_on_bit and they may return invalid data. Fix this class of bugs by introducing a new function "test_bit_acquire" that works like test_bit, but has acquire memory ordering semantics. Signed-off-by: Mikulas Patocka <mpatocka@redhat.com> Acked-by: Will Deacon <will@kernel.org> Cc: stable@vger.kernel.org Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Conflicts: arch/x86/include/asm/bitops.h include/asm-generic/bitops/non-atomic.h include/asm-generic/bitops/instrumented-non-atomic.h include/asm-generic/bitops/non-instrumented-non-atomic.h include/linux/bitops.h include/linux/buffer_head.h include/asm-generic/bitops/generic-non-atomic.h Documentation/atomic_bitops.txt [Due to the large number of patch modifications and conflicts, patch adaptation is performed in the original contexts] Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- Documentation/atomic_bitops.txt | 10 ++++----- arch/x86/include/asm/bitops.h | 21 +++++++++++++++++++ .../bitops/instrumented-non-atomic.h | 12 +++++++++++ include/asm-generic/bitops/non-atomic.h | 14 +++++++++++++ include/linux/wait_bit.h | 8 +++---- kernel/sched/wait_bit.c | 2 +- 6 files changed, 56 insertions(+), 11 deletions(-) diff --git a/Documentation/atomic_bitops.txt b/Documentation/atomic_bitops.txt index 093cdaefdb37..edea4656c5c0 100644 --- a/Documentation/atomic_bitops.txt +++ b/Documentation/atomic_bitops.txt @@ -58,13 +58,11 @@ Like with atomic_t, the rule of thumb is: - RMW operations that have a return value are fully ordered. - - RMW operations that are conditional are unordered on FAILURE, - otherwise the above rules apply. In the case of test_and_{}_bit() operations, - if the bit in memory is unchanged by the operation then it is deemed to have - failed. + - RMW operations that are conditional are fully ordered. -Except for a successful test_and_set_bit_lock() which has ACQUIRE semantics and -clear_bit_unlock() which has RELEASE semantics. +Except for a successful test_and_set_bit_lock() which has ACQUIRE semantics, +clear_bit_unlock() which has RELEASE semantics and test_bit_acquire which has +ACQUIRE semantics. Since a platform only has a single means of achieving atomic operations the same barriers as for atomic_t are used, see atomic_t.txt. diff --git a/arch/x86/include/asm/bitops.h b/arch/x86/include/asm/bitops.h index 0367efdc5b7a..c14e861f9956 100644 --- a/arch/x86/include/asm/bitops.h +++ b/arch/x86/include/asm/bitops.h @@ -207,6 +207,20 @@ static __always_inline bool constant_test_bit(long nr, const volatile unsigned l (addr[nr >> _BITOPS_LONG_SHIFT])) != 0; } +static __always_inline bool constant_test_bit_acquire(long nr, const volatile unsigned long *addr) +{ + bool oldbit; + + asm volatile("testb %2,%1" + CC_SET(nz) + : CC_OUT(nz) (oldbit) + : "m" (((unsigned char *)addr)[nr >> 3]), + "i" (1 << (nr & 7)) + : "memory"); + + return oldbit; +} + static __always_inline bool variable_test_bit(long nr, volatile const unsigned long *addr) { bool oldbit; @@ -224,6 +238,13 @@ static __always_inline bool variable_test_bit(long nr, volatile const unsigned l ? constant_test_bit((nr), (addr)) \ : variable_test_bit((nr), (addr))) +static __always_inline bool +arch_test_bit_acquire(unsigned long nr, const volatile unsigned long *addr) +{ + return __builtin_constant_p(nr) ? constant_test_bit_acquire(nr, addr) : + variable_test_bit(nr, addr); +} + /** * __ffs - find first set bit in word * @word: The word to search diff --git a/include/asm-generic/bitops/instrumented-non-atomic.h b/include/asm-generic/bitops/instrumented-non-atomic.h index 37363d570b9b..da7f0d0a707c 100644 --- a/include/asm-generic/bitops/instrumented-non-atomic.h +++ b/include/asm-generic/bitops/instrumented-non-atomic.h @@ -135,4 +135,16 @@ static inline bool test_bit(long nr, const volatile unsigned long *addr) return arch_test_bit(nr, addr); } +/** + * test_bit_acquire - Determine, with acquire semantics, whether a bit is set + * @nr: bit number to test + * @addr: Address to start counting from + */ +static __always_inline bool +test_bit_acquire(unsigned long nr, const volatile unsigned long *addr) +{ + instrument_atomic_read(addr + BIT_WORD(nr), sizeof(long)); + return arch_test_bit_acquire(nr, addr); +} + #endif /* _ASM_GENERIC_BITOPS_INSTRUMENTED_NON_ATOMIC_H */ diff --git a/include/asm-generic/bitops/non-atomic.h b/include/asm-generic/bitops/non-atomic.h index 7e10c4b50c5d..46437282d6d0 100644 --- a/include/asm-generic/bitops/non-atomic.h +++ b/include/asm-generic/bitops/non-atomic.h @@ -3,6 +3,7 @@ #define _ASM_GENERIC_BITOPS_NON_ATOMIC_H_ #include <asm/types.h> +#include <asm/barrier.h> /** * __set_bit - Set a bit in memory @@ -106,4 +107,17 @@ static inline int test_bit(int nr, const volatile unsigned long *addr) return 1UL & (addr[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG-1))); } +/** + * arch_test_bit_acquire - Determine, with acquire semantics, whether a bit is set + * @nr: bit number to test + * @addr: Address to start counting from + */ +static __always_inline bool +arch_test_bit_acquire(unsigned long nr, const volatile unsigned long *addr) +{ + unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr); + return 1UL & (smp_load_acquire(p) >> (nr & (BITS_PER_LONG-1))); +} +#define test_bit_acquire arch_test_bit_acquire + #endif /* _ASM_GENERIC_BITOPS_NON_ATOMIC_H_ */ diff --git a/include/linux/wait_bit.h b/include/linux/wait_bit.h index 7dec36aecbd9..7725b7579b78 100644 --- a/include/linux/wait_bit.h +++ b/include/linux/wait_bit.h @@ -71,7 +71,7 @@ static inline int wait_on_bit(unsigned long *word, int bit, unsigned mode) { might_sleep(); - if (!test_bit(bit, word)) + if (!test_bit_acquire(bit, word)) return 0; return out_of_line_wait_on_bit(word, bit, bit_wait, @@ -96,7 +96,7 @@ static inline int wait_on_bit_io(unsigned long *word, int bit, unsigned mode) { might_sleep(); - if (!test_bit(bit, word)) + if (!test_bit_acquire(bit, word)) return 0; return out_of_line_wait_on_bit(word, bit, bit_wait_io, @@ -123,7 +123,7 @@ wait_on_bit_timeout(unsigned long *word, int bit, unsigned mode, unsigned long timeout) { might_sleep(); - if (!test_bit(bit, word)) + if (!test_bit_acquire(bit, word)) return 0; return out_of_line_wait_on_bit_timeout(word, bit, bit_wait_timeout, @@ -151,7 +151,7 @@ wait_on_bit_action(unsigned long *word, int bit, wait_bit_action_f *action, unsigned mode) { might_sleep(); - if (!test_bit(bit, word)) + if (!test_bit_acquire(bit, word)) return 0; return out_of_line_wait_on_bit(word, bit, action, mode); } diff --git a/kernel/sched/wait_bit.c b/kernel/sched/wait_bit.c index 02ce292b9bc0..99be72732ee0 100644 --- a/kernel/sched/wait_bit.c +++ b/kernel/sched/wait_bit.c @@ -47,7 +47,7 @@ __wait_on_bit(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_ prepare_to_wait(wq_head, &wbq_entry->wq_entry, mode); if (test_bit(wbq_entry->key.bit_nr, wbq_entry->key.flags)) ret = (*action)(&wbq_entry->key, mode); - } while (test_bit(wbq_entry->key.bit_nr, wbq_entry->key.flags) && !ret); + } while (test_bit_acquire(wbq_entry->key.bit_nr, wbq_entry->key.flags) && !ret); finish_wait(wq_head, &wbq_entry->wq_entry); -- 2.46.1

From: Zizhi Wo <wozizhi@huawei.com> hulk inclusion category: other bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- For the previously combined 8238b4579866 ("wait_on_bit: add an acquire memory barrier") mainline patch, in order to avoid additional effects, revert the test_bit_acquire() in the wait_on_bit_xx function to the original test_bit(). In addition, define wait_on_bit_acquire() to narrow down the scope, which contains test_bit_acquire() that provide memory barrier. Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- include/linux/wait_bit.h | 33 +++++++++++++++++++++++++++---- kernel/sched/wait_bit.c | 42 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 70 insertions(+), 5 deletions(-) diff --git a/include/linux/wait_bit.h b/include/linux/wait_bit.h index 7725b7579b78..d31d256ce885 100644 --- a/include/linux/wait_bit.h +++ b/include/linux/wait_bit.h @@ -28,7 +28,9 @@ int __wait_on_bit(struct wait_queue_head *wq_head, struct wait_bit_queue_entry * int __wait_on_bit_lock(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry, wait_bit_action_f *action, unsigned int mode); void wake_up_bit(void *word, int bit); int out_of_line_wait_on_bit(void *word, int, wait_bit_action_f *action, unsigned int mode); +int out_of_line_wait_on_bit_acquire(void *word, int, wait_bit_action_f *action, unsigned int mode); int out_of_line_wait_on_bit_timeout(void *word, int, wait_bit_action_f *action, unsigned int mode, unsigned long timeout); +int out_of_line_wait_on_bit_timeout_acquire(void *word, int, wait_bit_action_f *action, unsigned int mode, unsigned long timeout); int out_of_line_wait_on_bit_lock(void *word, int, wait_bit_action_f *action, unsigned int mode); struct wait_queue_head *bit_waitqueue(void *word, int bit); extern void __init wait_bit_init(void); @@ -71,7 +73,7 @@ static inline int wait_on_bit(unsigned long *word, int bit, unsigned mode) { might_sleep(); - if (!test_bit_acquire(bit, word)) + if (!test_bit(bit, word)) return 0; return out_of_line_wait_on_bit(word, bit, bit_wait, @@ -96,7 +98,7 @@ static inline int wait_on_bit_io(unsigned long *word, int bit, unsigned mode) { might_sleep(); - if (!test_bit_acquire(bit, word)) + if (!test_bit(bit, word)) return 0; return out_of_line_wait_on_bit(word, bit, bit_wait_io, @@ -123,7 +125,7 @@ wait_on_bit_timeout(unsigned long *word, int bit, unsigned mode, unsigned long timeout) { might_sleep(); - if (!test_bit_acquire(bit, word)) + if (!test_bit(bit, word)) return 0; return out_of_line_wait_on_bit_timeout(word, bit, bit_wait_timeout, @@ -151,7 +153,7 @@ wait_on_bit_action(unsigned long *word, int bit, wait_bit_action_f *action, unsigned mode) { might_sleep(); - if (!test_bit_acquire(bit, word)) + if (!test_bit(bit, word)) return 0; return out_of_line_wait_on_bit(word, bit, action, mode); } @@ -235,6 +237,29 @@ wait_on_bit_lock_action(unsigned long *word, int bit, wait_bit_action_f *action, return out_of_line_wait_on_bit_lock(word, bit, action, mode); } +static inline int +wait_on_bit_acquire(unsigned long *word, int bit, unsigned mode) +{ + might_sleep(); + if (!test_bit_acquire(bit, word)) + return 0; + return out_of_line_wait_on_bit_acquire(word, bit, + bit_wait, + mode); +} + +static inline int +wait_on_bit_timeout_acquire(unsigned long *word, int bit, unsigned mode, + unsigned long timeout) +{ + might_sleep(); + if (!test_bit_acquire(bit, word)) + return 0; + return out_of_line_wait_on_bit_timeout_acquire(word, bit, + bit_wait_timeout, + mode, timeout); +} + extern void init_wait_var_entry(struct wait_bit_queue_entry *wbq_entry, void *var, int flags); extern void wake_up_var(void *var); extern wait_queue_head_t *__var_waitqueue(void *p); diff --git a/kernel/sched/wait_bit.c b/kernel/sched/wait_bit.c index 99be72732ee0..b795085b0b84 100644 --- a/kernel/sched/wait_bit.c +++ b/kernel/sched/wait_bit.c @@ -47,7 +47,7 @@ __wait_on_bit(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_ prepare_to_wait(wq_head, &wbq_entry->wq_entry, mode); if (test_bit(wbq_entry->key.bit_nr, wbq_entry->key.flags)) ret = (*action)(&wbq_entry->key, mode); - } while (test_bit_acquire(wbq_entry->key.bit_nr, wbq_entry->key.flags) && !ret); + } while (test_bit(wbq_entry->key.bit_nr, wbq_entry->key.flags) && !ret); finish_wait(wq_head, &wbq_entry->wq_entry); @@ -55,6 +55,23 @@ __wait_on_bit(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_ } EXPORT_SYMBOL(__wait_on_bit); +static int __sched +__wait_on_bit_acquire(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry, + wait_bit_action_f *action, unsigned mode) +{ + int ret = 0; + + do { + prepare_to_wait(wq_head, &wbq_entry->wq_entry, mode); + if (test_bit(wbq_entry->key.bit_nr, wbq_entry->key.flags)) + ret = (*action)(&wbq_entry->key, mode); + } while (test_bit_acquire(wbq_entry->key.bit_nr, wbq_entry->key.flags) && !ret); + + finish_wait(wq_head, &wbq_entry->wq_entry); + + return ret; +} + int __sched out_of_line_wait_on_bit(void *word, int bit, wait_bit_action_f *action, unsigned mode) { @@ -65,6 +82,29 @@ int __sched out_of_line_wait_on_bit(void *word, int bit, } EXPORT_SYMBOL(out_of_line_wait_on_bit); +int __sched out_of_line_wait_on_bit_acquire(void *word, int bit, + wait_bit_action_f *action, unsigned mode) +{ + struct wait_queue_head *wq_head = bit_waitqueue(word, bit); + DEFINE_WAIT_BIT(wq_entry, word, bit); + + return __wait_on_bit_acquire(wq_head, &wq_entry, action, mode); +} +EXPORT_SYMBOL(out_of_line_wait_on_bit_acquire); + +int __sched out_of_line_wait_on_bit_timeout_acquire( + void *word, int bit, wait_bit_action_f *action, + unsigned mode, unsigned long timeout) +{ + struct wait_queue_head *wq_head = bit_waitqueue(word, bit); + DEFINE_WAIT_BIT(wq_entry, word, bit); + + wq_entry.key.timeout = jiffies + timeout; + + return __wait_on_bit_acquire(wq_head, &wq_entry, action, mode); +} +EXPORT_SYMBOL_GPL(out_of_line_wait_on_bit_timeout_acquire); + int __sched out_of_line_wait_on_bit_timeout( void *word, int bit, wait_bit_action_f *action, unsigned mode, unsigned long timeout) -- 2.46.1

From: Zizhi Wo <wozizhi@huawei.com> hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- This patch modifies some functions, adds barriers in fscache/cachefiles to both wake and wait processes that may be problematic due to out-of-order memory. Fixes: ef778e7ae67c ("FS-Cache: Provide proper invalidation") Fixes: da9803bc8812 ("FS-Cache: Add interface to check consistency of a cached object") Fixes: 94d30ae90a00 ("FS-Cache: Provide the ability to enable/disable cookies") Fixes: b73608d715eb ("fscache: add a waiting mechanism when duplicate cookies are detected") Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/namei.c | 4 +--- fs/fscache/cookie.c | 16 +++++++--------- fs/fscache/page.c | 8 ++++---- 3 files changed, 12 insertions(+), 16 deletions(-) diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c index 93c511d1fff3..6eeef666c609 100644 --- a/fs/cachefiles/namei.c +++ b/fs/cachefiles/namei.c @@ -264,11 +264,9 @@ void cachefiles_mark_object_inactive(struct cachefiles_cache *cache, write_lock(&cache->active_lock); rb_erase(&object->active_node, &cache->active_nodes); - clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags); + clear_and_wake_up_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags); write_unlock(&cache->active_lock); - wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE); - /* This object can now be culled, so we need to let the daemon know * that there is something it can remove if it needs to. */ diff --git a/fs/fscache/cookie.c b/fs/fscache/cookie.c index c2b1637eaa03..ea1beed4df11 100644 --- a/fs/fscache/cookie.c +++ b/fs/fscache/cookie.c @@ -223,14 +223,14 @@ static int fscache_wait_on_cookie_collision(struct fscache_cookie *candidate) { int ret; - ret = wait_on_bit_timeout(&candidate->flags, FSCACHE_COOKIE_ACQUIRE_PENDING, - TASK_INTERRUPTIBLE, 20 * HZ); + ret = wait_on_bit_timeout_acquire(&candidate->flags, FSCACHE_COOKIE_ACQUIRE_PENDING, + TASK_INTERRUPTIBLE, 20 * HZ); if (ret == -EINTR) return ret; if (fscache_is_acquire_pending(candidate)) { pr_notice("Potential cookie collision!"); - return wait_on_bit(&candidate->flags, FSCACHE_COOKIE_ACQUIRE_PENDING, - TASK_INTERRUPTIBLE); + return wait_on_bit_acquire(&candidate->flags, FSCACHE_COOKIE_ACQUIRE_PENDING, + TASK_INTERRUPTIBLE); } return 0; } @@ -445,8 +445,7 @@ void __fscache_enable_cookie(struct fscache_cookie *cookie, } out_unlock: - clear_bit_unlock(FSCACHE_COOKIE_ENABLEMENT_LOCK, &cookie->flags); - wake_up_bit(&cookie->flags, FSCACHE_COOKIE_ENABLEMENT_LOCK); + clear_and_wake_up_bit(FSCACHE_COOKIE_ENABLEMENT_LOCK, &cookie->flags); } EXPORT_SYMBOL(__fscache_enable_cookie); @@ -725,7 +724,7 @@ void __fscache_wait_on_invalidate(struct fscache_cookie *cookie) { _enter("%p", cookie); - wait_on_bit(&cookie->flags, FSCACHE_COOKIE_INVALIDATING, + wait_on_bit_acquire(&cookie->flags, FSCACHE_COOKIE_INVALIDATING, TASK_UNINTERRUPTIBLE); _leave(""); @@ -842,8 +841,7 @@ void __fscache_disable_cookie(struct fscache_cookie *cookie, } out_unlock_enable: - clear_bit_unlock(FSCACHE_COOKIE_ENABLEMENT_LOCK, &cookie->flags); - wake_up_bit(&cookie->flags, FSCACHE_COOKIE_ENABLEMENT_LOCK); + clear_and_wake_up_bit(FSCACHE_COOKIE_ENABLEMENT_LOCK, &cookie->flags); _leave(""); } EXPORT_SYMBOL(__fscache_disable_cookie); diff --git a/fs/fscache/page.c b/fs/fscache/page.c index 3ff3799e42ef..95490d809b5e 100644 --- a/fs/fscache/page.c +++ b/fs/fscache/page.c @@ -383,8 +383,8 @@ int fscache_wait_for_operation_activation(struct fscache_object *object, _debug(">>> WT"); if (stat_op_waits) fscache_stat(stat_op_waits); - if (wait_on_bit(&op->flags, FSCACHE_OP_WAITING, - TASK_INTERRUPTIBLE) != 0) { + if (wait_on_bit_acquire(&op->flags, FSCACHE_OP_WAITING, + TASK_INTERRUPTIBLE) != 0) { trace_fscache_op(object->cookie, op, fscache_op_signal); ret = fscache_cancel_op(op, false); if (ret == 0) @@ -392,8 +392,8 @@ int fscache_wait_for_operation_activation(struct fscache_object *object, /* it's been removed from the pending queue by another party, * so we should get to run shortly */ - wait_on_bit(&op->flags, FSCACHE_OP_WAITING, - TASK_UNINTERRUPTIBLE); + wait_on_bit_acquire(&op->flags, FSCACHE_OP_WAITING, + TASK_UNINTERRUPTIBLE); } _debug("<<< GO"); -- 2.46.1

hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- ABBA deadlocks may be triggered during the following concurrency: write(2) | page fault | mmap(2) ------------------------------------------------------------------ asm_exc_page_fault exc_page_fault handle_page_fault do_user_addr_fault mmap_read_lock(mm) ---> read lock B vfs_write vm_mmap_pgoff() new_sync_write mmap_write_lock_killable(mm) cachefiles_ondemand_fd_write_iter ---> try write lock B vfs_iocb_iter_write ext4_file_write_iter ext4_buffered_write_iter inode_lock(inode) ----------> write lock A handle_mm_fault __handle_mm_fault handle_pte_fault do_fault do_read_fault __do_fault filemap_fault erofs_fscache_readpage __fscache_read_or_alloc_page cachefiles_read_or_alloc_page bmap ext4_bmap inode_lock_shared(inode) -> try read lock A generic_perform_write | iov_iter_fault_in_readable | __get_user_nocheck_1 | asm_exc_page_fault | exc_page_fault | handle_page_fault ABBA deadlcok do_user_addr_fault | mmap_read_lock(mm) | down_read(&mm->mmap_lock) -----------------> try read lock B This is due to the fact that inode lock cannot be used anywhere in the page fault path, whereas in ondemand mode erofs call bmap when triggering a page fault, and bmap may try to lock the inode and trigger the above issue. There's no good way to fix this completely, so bring in the user pages early in cachefiles_ondemand_fd_write_iter() to avoid triggering a page fault in generic_perform_write() to circumvent the problem. Fixes: 9ae326a69004 ("CacheFiles: A cache that backs onto a mounted filesystem") Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/ondemand.c | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c index 76c936fc9a68..ed3b49a4fd4e 100644 --- a/fs/cachefiles/ondemand.c +++ b/fs/cachefiles/ondemand.c @@ -72,10 +72,11 @@ static ssize_t cachefiles_ondemand_fd_write_iter(struct kiocb *kiocb, struct iov_iter *iter) { struct cachefiles_object *object = kiocb->ki_filp->private_data; - size_t len = iter->count; struct kiocb iocb; struct file *file; - int ret; + ssize_t ret = 0; + ssize_t written = 0; + size_t bytes; rcu_read_lock(); file = rcu_dereference(object->file); @@ -95,12 +96,29 @@ static ssize_t cachefiles_ondemand_fd_write_iter(struct kiocb *kiocb, if (!cachefiles_buffered_ondemand) iocb.ki_flags |= IOCB_DIRECT; +retry: + bytes = iov_iter_count(iter); + if (unlikely(!bytes)) + goto out; + + ret = iov_iter_fault_in_readable(iter, bytes); + if (unlikely(ret)) + goto out; + pagefault_disable(); ret = vfs_iocb_iter_write(file, &iocb, iter); + pagefault_enable(); + if (ret > 0) { + written += ret; + goto retry; + } else if (ret == -EFAULT) { + goto retry; + } +out: fput(file); - if (ret != len) + if (!ret && iov_iter_count(iter)) return -EIO; - return len; + return ret < 0 ? ret : written; } static long cachefiles_ondemand_fd_ioctl(struct file *filp, unsigned int ioctl, -- 2.46.1

From: Zizhi Wo <wozizhi@huawei.com> hulk inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/IB5UKT -------------------------------- In cachefiles_daemon_secctx(), if it is detected that secctx has been written to the cache, the error code returned is -EINVAL, which is inappropriate and does not distinguish the situation well. Like cachefiles_daemon_dir(), fix this issue by return -EEXIST to the user if it has already been defined once. Fixes: 9ae326a69004 ("CacheFiles: A cache that backs onto a mounted filesystem") Signed-off-by: Zizhi Wo <wozizhi@huawei.com> Signed-off-by: Baokun Li <libaokun1@huawei.com> --- fs/cachefiles/daemon.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fs/cachefiles/daemon.c b/fs/cachefiles/daemon.c index c94b512da4b5..3128cbc733ea 100644 --- a/fs/cachefiles/daemon.c +++ b/fs/cachefiles/daemon.c @@ -594,7 +594,7 @@ static int cachefiles_daemon_secctx(struct cachefiles_cache *cache, char *args) if (cache->secctx) { pr_err("Second security context specified\n"); - return -EINVAL; + return -EEXIST; } secctx = kstrdup(args, GFP_KERNEL); -- 2.46.1