From: Gao Xiang Date: Mon, 22 Jun 2026 01:36:22 +0000 (+0800) Subject: erofs: remove fscache backend entirely X-Git-Url: http://git.ipfire.org/gitweb/?a=commitdiff_plain;h=c37460cd9b2fcb61ec66b7eb4fde737e65ec2a56;p=thirdparty%2Fkernel%2Flinux.git erofs: remove fscache backend entirely EROFS over fscache was introduced to provide image lazy pulling functionality. After the feature landed, the fscache subsystem made netfs a new hard dependency, which is unexpected for a local filesystem and has an kernel-defined caching hierarchy which could be inflexible compared to the fanotify pre-content hooks. Therefore, this feature has been deprecated for almost two years. As EROFS file-backed mounts and fanotify pre-content hooks both upstream for a while and already providing equivalent functionality (erofs-utils has supported fanotify pre-content hooks), let's remove the fscache backend now. The main application of this feature is Nydus [1], and they plan to move to use fanotify pre-content hooks in the near future too. I hope this patch can be merged into Linux 7.2, which is also motivated by newly found implementation issues [2][3] that are not worth investigating given the deprecation and limited development resources. The associated fscache/cachefiles cleanup patch will follow separately through the vfs tree (netfs) later: it seems fine since the codebase is isolated by CONFIG_CACHEFILES_ONDEMAND. [1] https://github.com/dragonflyoss/nydus/blob/v2.1.0/docs/nydus-fscache.md [2] https://github.com/dragonflyoss/nydus/pull/1824 [3] https://lore.kernel.org/r/20260619135800.1594811-1-michael.bommarito@gmail.com Acked-by: Jingbo Xu Signed-off-by: Gao Xiang --- diff --git a/Documentation/filesystems/erofs.rst b/Documentation/filesystems/erofs.rst index e4f84ba91052..4230884fb359 100644 --- a/Documentation/filesystems/erofs.rst +++ b/Documentation/filesystems/erofs.rst @@ -130,12 +130,9 @@ dax A legacy option which is an alias for ``dax=always``. device=%s Specify a path to an extra device to be used together. directio (For file-backed mounts) Use direct I/O to access backing files, and asynchronous I/O will be enabled if supported. -fsid=%s Specify a filesystem image ID for Fscache back-end. -domain_id=%s Specify a trusted domain ID for fscache mode so that - different images with the same blobs, identified by blob IDs, - can share storage within the same trusted domain. - Also used for different filesystems with inode page sharing - enabled to share page cache within the trusted domain. +domain_id=%s Specify a trusted domain ID. Filesystems sharing the same + domain ID can share page cache across mounts when inode + page sharing is enabled. (not shown in mountinfo output) fsoffset=%llu Specify block-aligned filesystem offset for the primary device. inode_share Enable inode page sharing for this filesystem. Inodes with identical content within the same domain ID can share the diff --git a/fs/erofs/Kconfig b/fs/erofs/Kconfig index 97c48ebe8458..4789b1077d8c 100644 --- a/fs/erofs/Kconfig +++ b/fs/erofs/Kconfig @@ -3,13 +3,11 @@ config EROFS_FS tristate "EROFS filesystem support" depends on BLOCK - select CACHEFILES if EROFS_FS_ONDEMAND select CRC32 select CRYPTO if EROFS_FS_ZIP_ACCEL select CRYPTO_DEFLATE if EROFS_FS_ZIP_ACCEL select FS_IOMAP select LZ4_DECOMPRESS if EROFS_FS_ZIP - select NETFS_SUPPORT if EROFS_FS_ONDEMAND select XXHASH if EROFS_FS_XATTR select XZ_DEC if EROFS_FS_ZIP_LZMA select XZ_DEC_MICROLZMA if EROFS_FS_ZIP_LZMA @@ -109,9 +107,6 @@ config EROFS_FS_BACKED_BY_FILE be used to simplify error-prone lifetime management of unnecessary virtual block devices. - Note that this feature, along with ongoing fanotify pre-content - hooks, will eventually replace "EROFS over fscache." - If you don't want to enable this feature, say N. config EROFS_FS_ZIP @@ -172,20 +167,6 @@ config EROFS_FS_ZIP_ACCEL If unsure, say N. -config EROFS_FS_ONDEMAND - bool "EROFS fscache-based on-demand read support (deprecated)" - depends on EROFS_FS - select FSCACHE - select CACHEFILES_ONDEMAND - help - This permits EROFS to use fscache-backed data blobs with on-demand - read support. - - It is now deprecated and scheduled to be removed from the kernel - after fanotify pre-content hooks are landed. - - If unsure, say N. - config EROFS_FS_PCPU_KTHREAD bool "EROFS per-cpu decompression kthread workers" depends on EROFS_FS_ZIP @@ -207,7 +188,7 @@ config EROFS_FS_PCPU_KTHREAD_HIPRI config EROFS_FS_PAGE_CACHE_SHARE bool "EROFS page cache share support (experimental)" - depends on EROFS_FS && EROFS_FS_XATTR && !EROFS_FS_ONDEMAND + depends on EROFS_FS && EROFS_FS_XATTR help This enables page cache sharing among inodes with identical content fingerprints on the same machine. diff --git a/fs/erofs/Makefile b/fs/erofs/Makefile index a80e1762b607..30423496786f 100644 --- a/fs/erofs/Makefile +++ b/fs/erofs/Makefile @@ -9,5 +9,4 @@ erofs-$(CONFIG_EROFS_FS_ZIP_DEFLATE) += decompressor_deflate.o erofs-$(CONFIG_EROFS_FS_ZIP_ZSTD) += decompressor_zstd.o erofs-$(CONFIG_EROFS_FS_ZIP_ACCEL) += decompressor_crypto.o erofs-$(CONFIG_EROFS_FS_BACKED_BY_FILE) += fileio.o -erofs-$(CONFIG_EROFS_FS_ONDEMAND) += fscache.o erofs-$(CONFIG_EROFS_FS_PAGE_CACHE_SHARE) += ishare.o diff --git a/fs/erofs/data.c b/fs/erofs/data.c index cdf2e2ef8ea8..9aa48c8d67d1 100644 --- a/fs/erofs/data.c +++ b/fs/erofs/data.c @@ -80,9 +80,7 @@ int erofs_init_metabuf(struct erofs_buf *buf, struct super_block *sb, if (erofs_is_fileio_mode(sbi)) { buf->file = sbi->dif0.file; /* some fs like FUSE needs it */ buf->mapping = buf->file->f_mapping; - } else if (erofs_is_fscache_mode(sb)) - buf->mapping = sbi->dif0.fscache->inode->i_mapping; - else + } else buf->mapping = sb->s_bdev->bd_mapping; return 0; } diff --git a/fs/erofs/fscache.c b/fs/erofs/fscache.c deleted file mode 100644 index 685c68774379..000000000000 --- a/fs/erofs/fscache.c +++ /dev/null @@ -1,664 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-or-later -/* - * Copyright (C) 2022, Alibaba Cloud - * Copyright (C) 2022, Bytedance Inc. All rights reserved. - */ -#include -#include "internal.h" - -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; - -struct erofs_fscache_io { - struct netfs_cache_resources cres; - struct iov_iter iter; - netfs_io_terminated_t end_io; - void *private; - refcount_t ref; -}; - -struct erofs_fscache_rq { - struct address_space *mapping; /* The mapping being accessed */ - loff_t start; /* Start position */ - size_t len; /* Length of the request */ - size_t submitted; /* Length of submitted */ - short error; /* 0 or error that occurred */ - refcount_t ref; -}; - -static bool erofs_fscache_io_put(struct erofs_fscache_io *io) -{ - if (!refcount_dec_and_test(&io->ref)) - return false; - if (io->cres.ops) - io->cres.ops->end_operation(&io->cres); - kfree(io); - return true; -} - -static void erofs_fscache_req_complete(struct erofs_fscache_rq *req) -{ - struct folio *folio; - bool failed = req->error; - pgoff_t start_page = req->start / PAGE_SIZE; - pgoff_t last_page = ((req->start + req->len) / PAGE_SIZE) - 1; - - XA_STATE(xas, &req->mapping->i_pages, start_page); - - rcu_read_lock(); - xas_for_each(&xas, folio, last_page) { - if (xas_retry(&xas, folio)) - continue; - if (!failed) - folio_mark_uptodate(folio); - folio_unlock(folio); - } - rcu_read_unlock(); -} - -static void erofs_fscache_req_put(struct erofs_fscache_rq *req) -{ - if (!refcount_dec_and_test(&req->ref)) - return; - erofs_fscache_req_complete(req); - kfree(req); -} - -static struct erofs_fscache_rq *erofs_fscache_req_alloc(struct address_space *mapping, - loff_t start, size_t len) -{ - struct erofs_fscache_rq *req = kzalloc_obj(*req); - - if (!req) - return NULL; - req->mapping = mapping; - req->start = start; - req->len = len; - refcount_set(&req->ref, 1); - return req; -} - -static void erofs_fscache_req_io_put(struct erofs_fscache_io *io) -{ - struct erofs_fscache_rq *req = io->private; - - if (erofs_fscache_io_put(io)) - erofs_fscache_req_put(req); -} - -static void erofs_fscache_req_end_io(void *priv, ssize_t transferred_or_error) -{ - struct erofs_fscache_io *io = priv; - struct erofs_fscache_rq *req = io->private; - - if (IS_ERR_VALUE(transferred_or_error)) - req->error = transferred_or_error; - erofs_fscache_req_io_put(io); -} - -static struct erofs_fscache_io *erofs_fscache_req_io_alloc(struct erofs_fscache_rq *req) -{ - struct erofs_fscache_io *io = kzalloc_obj(*io); - - if (!io) - return NULL; - io->end_io = erofs_fscache_req_end_io; - io->private = req; - refcount_inc(&req->ref); - refcount_set(&io->ref, 1); - return io; -} - -/* - * Read data from fscache described by cookie at pstart physical address - * offset, and fill the read data into buffer described by io->iter. - */ -static int erofs_fscache_read_io_async(struct fscache_cookie *cookie, - loff_t pstart, struct erofs_fscache_io *io) -{ - enum netfs_io_source source; - struct netfs_cache_resources *cres = &io->cres; - struct iov_iter *iter = &io->iter; - int ret; - - ret = fscache_begin_read_operation(cres, cookie); - if (ret) - return ret; - - while (iov_iter_count(iter)) { - size_t orig_count = iov_iter_count(iter), len = orig_count; - unsigned long flags = 1 << NETFS_SREQ_ONDEMAND; - - source = cres->ops->prepare_ondemand_read(cres, - pstart, &len, LLONG_MAX, &flags, 0); - if (WARN_ON(len == 0)) - source = NETFS_INVALID_READ; - if (source != NETFS_READ_FROM_CACHE) { - erofs_err(NULL, "prepare_ondemand_read failed (source %d)", source); - return -EIO; - } - - iov_iter_truncate(iter, len); - refcount_inc(&io->ref); - ret = fscache_read(cres, pstart, iter, NETFS_READ_HOLE_FAIL, - io->end_io, io); - if (ret == -EIOCBQUEUED) - ret = 0; - if (ret) { - erofs_err(NULL, "fscache_read failed (ret %d)", ret); - return ret; - } - if (WARN_ON(iov_iter_count(iter))) - return -EIO; - - iov_iter_reexpand(iter, orig_count - len); - pstart += len; - } - return 0; -} - -struct erofs_fscache_bio { - struct erofs_fscache_io io; - struct bio bio; /* w/o bdev to share bio_add_page/endio() */ - struct bio_vec bvecs[BIO_MAX_VECS]; -}; - -static void erofs_fscache_bio_endio(void *priv, ssize_t transferred_or_error) -{ - struct erofs_fscache_bio *io = priv; - - if (IS_ERR_VALUE(transferred_or_error)) - io->bio.bi_status = errno_to_blk_status(transferred_or_error); - bio_endio(&io->bio); - BUILD_BUG_ON(offsetof(struct erofs_fscache_bio, io) != 0); - erofs_fscache_io_put(&io->io); -} - -struct bio *erofs_fscache_bio_alloc(struct erofs_map_dev *mdev) -{ - struct erofs_fscache_bio *io; - - io = kmalloc_obj(*io, GFP_KERNEL | __GFP_NOFAIL); - bio_init(&io->bio, NULL, io->bvecs, BIO_MAX_VECS, REQ_OP_READ); - io->io.private = mdev->m_dif->fscache->cookie; - io->io.end_io = erofs_fscache_bio_endio; - refcount_set(&io->io.ref, 1); - return &io->bio; -} - -void erofs_fscache_submit_bio(struct bio *bio) -{ - struct erofs_fscache_bio *io = container_of(bio, - struct erofs_fscache_bio, bio); - int ret; - - iov_iter_bvec(&io->io.iter, ITER_DEST, io->bvecs, bio->bi_vcnt, - bio->bi_iter.bi_size); - ret = erofs_fscache_read_io_async(io->io.private, - bio->bi_iter.bi_sector << 9, &io->io); - erofs_fscache_io_put(&io->io); - if (!ret) - return; - bio->bi_status = errno_to_blk_status(ret); - bio_endio(bio); -} - -static int erofs_fscache_meta_read_folio(struct file *data, struct folio *folio) -{ - struct erofs_fscache *ctx = folio->mapping->host->i_private; - int ret = -ENOMEM; - struct erofs_fscache_rq *req; - struct erofs_fscache_io *io; - - req = erofs_fscache_req_alloc(folio->mapping, - folio_pos(folio), folio_size(folio)); - if (!req) { - folio_unlock(folio); - return ret; - } - - io = erofs_fscache_req_io_alloc(req); - if (!io) { - req->error = ret; - goto out; - } - iov_iter_xarray(&io->iter, ITER_DEST, &folio->mapping->i_pages, - folio_pos(folio), folio_size(folio)); - - ret = erofs_fscache_read_io_async(ctx->cookie, folio_pos(folio), io); - if (ret) - req->error = ret; - - erofs_fscache_req_io_put(io); -out: - erofs_fscache_req_put(req); - return ret; -} - -static int erofs_fscache_data_read_slice(struct erofs_fscache_rq *req) -{ - struct address_space *mapping = req->mapping; - struct inode *inode = mapping->host; - struct super_block *sb = inode->i_sb; - struct erofs_fscache_io *io; - struct erofs_map_blocks map; - struct erofs_map_dev mdev; - loff_t pos = req->start + req->submitted; - size_t count; - int ret; - - map.m_la = pos; - ret = erofs_map_blocks(inode, &map); - if (ret) - return ret; - - if (map.m_flags & EROFS_MAP_META) { - struct erofs_buf buf = __EROFS_BUF_INITIALIZER; - struct iov_iter iter; - size_t size = map.m_llen; - void *src; - - src = erofs_read_metabuf(&buf, sb, map.m_pa, - erofs_inode_in_metabox(inode)); - if (IS_ERR(src)) - return PTR_ERR(src); - - iov_iter_xarray(&iter, ITER_DEST, &mapping->i_pages, pos, PAGE_SIZE); - if (copy_to_iter(src, size, &iter) != size) { - erofs_put_metabuf(&buf); - return -EFAULT; - } - iov_iter_zero(PAGE_SIZE - size, &iter); - erofs_put_metabuf(&buf); - req->submitted += PAGE_SIZE; - return 0; - } - - count = req->len - req->submitted; - if (!(map.m_flags & EROFS_MAP_MAPPED)) { - struct iov_iter iter; - - iov_iter_xarray(&iter, ITER_DEST, &mapping->i_pages, pos, count); - iov_iter_zero(count, &iter); - req->submitted += count; - return 0; - } - - count = min_t(size_t, map.m_llen - (pos - map.m_la), count); - DBG_BUGON(!count || count % PAGE_SIZE); - - mdev = (struct erofs_map_dev) { - .m_deviceid = map.m_deviceid, - .m_pa = map.m_pa, - }; - ret = erofs_map_dev(sb, &mdev); - if (ret) - return ret; - - io = erofs_fscache_req_io_alloc(req); - if (!io) - return -ENOMEM; - iov_iter_xarray(&io->iter, ITER_DEST, &mapping->i_pages, pos, count); - ret = erofs_fscache_read_io_async(mdev.m_dif->fscache->cookie, - mdev.m_pa + (pos - map.m_la), io); - erofs_fscache_req_io_put(io); - - req->submitted += count; - return ret; -} - -static int erofs_fscache_data_read(struct erofs_fscache_rq *req) -{ - int ret; - - do { - ret = erofs_fscache_data_read_slice(req); - if (ret) - req->error = ret; - } while (!ret && req->submitted < req->len); - return ret; -} - -static int erofs_fscache_read_folio(struct file *file, struct folio *folio) -{ - struct erofs_fscache_rq *req; - int ret; - - req = erofs_fscache_req_alloc(folio->mapping, - folio_pos(folio), folio_size(folio)); - if (!req) { - folio_unlock(folio); - return -ENOMEM; - } - - ret = erofs_fscache_data_read(req); - erofs_fscache_req_put(req); - return ret; -} - -static void erofs_fscache_readahead(struct readahead_control *rac) -{ - struct erofs_fscache_rq *req; - - if (!readahead_count(rac)) - return; - - req = erofs_fscache_req_alloc(rac->mapping, - readahead_pos(rac), readahead_length(rac)); - if (!req) - return; - - /* The request completion will drop refs on the folios. */ - while (readahead_folio(rac)) - ; - - erofs_fscache_data_read(req); - erofs_fscache_req_put(req); -} - -static const struct address_space_operations erofs_fscache_meta_aops = { - .read_folio = erofs_fscache_meta_read_folio, -}; - -const struct address_space_operations erofs_fscache_access_aops = { - .read_folio = erofs_fscache_read_folio, - .readahead = erofs_fscache_readahead, -}; - -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; - } - fscache_relinquish_volume(domain->volume, NULL, false); - mutex_unlock(&erofs_domain_list_lock); - kfree_sensitive(domain->domain_id); - kfree(domain); - return; - } - mutex_unlock(&erofs_domain_list_lock); -} - -static int erofs_fscache_register_volume(struct super_block *sb) -{ - struct erofs_sb_info *sbi = EROFS_SB(sb); - char *domain_id = sbi->domain_id; - struct fscache_volume *volume; - char *name; - int ret = 0; - - name = kasprintf(GFP_KERNEL, "erofs,%s", - domain_id ? domain_id : sbi->fsid); - if (!name) - return -ENOMEM; - - volume = fscache_acquire_volume(name, NULL, NULL, 0); - 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; -} - -static int erofs_fscache_init_domain(struct super_block *sb) -{ - int err; - struct erofs_domain *domain; - struct erofs_sb_info *sbi = EROFS_SB(sb); - - domain = kzalloc_obj(struct erofs_domain); - if (!domain) - return -ENOMEM; - - domain->domain_id = kstrdup(sbi->domain_id, GFP_KERNEL); - if (!domain->domain_id) { - kfree(domain); - return -ENOMEM; - } - - err = erofs_fscache_register_volume(sb); - if (err) - goto out; - - if (!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; - refcount_set(&domain->ref, 1); - list_add(&domain->list, &erofs_domain_list); - sbi->domain = domain; - return 0; -out: - kfree_sensitive(domain->domain_id); - kfree(domain); - return err; -} - -static int erofs_fscache_register_domain(struct super_block *sb) -{ - int err; - struct erofs_domain *domain; - struct erofs_sb_info *sbi = EROFS_SB(sb); - - mutex_lock(&erofs_domain_list_lock); - list_for_each_entry(domain, &erofs_domain_list, list) { - if (!strcmp(domain->domain_id, sbi->domain_id)) { - sbi->domain = domain; - sbi->volume = domain->volume; - refcount_inc(&domain->ref); - mutex_unlock(&erofs_domain_list_lock); - return 0; - } - } - err = erofs_fscache_init_domain(sb); - mutex_unlock(&erofs_domain_list_lock); - return err; -} - -static struct erofs_fscache *erofs_fscache_acquire_cookie(struct super_block *sb, - char *name, unsigned int flags) -{ - struct fscache_volume *volume = EROFS_SB(sb)->volume; - struct erofs_fscache *ctx; - struct fscache_cookie *cookie; - struct super_block *isb; - struct inode *inode; - int ret; - - ctx = kzalloc_obj(*ctx); - if (!ctx) - return ERR_PTR(-ENOMEM); - INIT_LIST_HEAD(&ctx->node); - refcount_set(&ctx->ref, 1); - - cookie = fscache_acquire_cookie(volume, FSCACHE_ADV_WANT_CACHE_SIZE, - name, strlen(name), NULL, 0, 0); - if (!cookie) { - erofs_err(sb, "failed to get cookie for %s", name); - ret = -EINVAL; - goto err; - } - fscache_use_cookie(cookie, false); - - /* - * Allocate anonymous inode in global pseudo mount for shareable blobs, - * so that they are accessible among erofs fs instances. - */ - isb = flags & EROFS_REG_COOKIE_SHARE ? erofs_pseudo_mnt->mnt_sb : sb; - inode = new_inode(isb); - if (!inode) { - erofs_err(sb, "failed to get anon inode for %s", name); - ret = -ENOMEM; - goto err_cookie; - } - - inode->i_size = OFFSET_MAX; - inode->i_mapping->a_ops = &erofs_fscache_meta_aops; - mapping_set_gfp_mask(inode->i_mapping, GFP_KERNEL); - inode->i_blkbits = EROFS_SB(sb)->blkszbits; - inode->i_private = ctx; - - ctx->cookie = cookie; - ctx->inode = inode; - return ctx; - -err_cookie: - fscache_unuse_cookie(cookie, NULL, NULL); - fscache_relinquish_cookie(cookie, false); -err: - kfree(ctx); - return ERR_PTR(ret); -} - -static void erofs_fscache_relinquish_cookie(struct erofs_fscache *ctx) -{ - fscache_unuse_cookie(ctx->cookie, NULL, NULL); - fscache_relinquish_cookie(ctx->cookie, false); - iput(ctx->inode); - kfree(ctx->name); - kfree(ctx); -} - -static struct erofs_fscache *erofs_domain_init_cookie(struct super_block *sb, - char *name, unsigned int flags) -{ - struct erofs_fscache *ctx; - struct erofs_domain *domain = EROFS_SB(sb)->domain; - - ctx = erofs_fscache_acquire_cookie(sb, name, flags); - if (IS_ERR(ctx)) - return ctx; - - ctx->name = kstrdup(name, GFP_KERNEL); - if (!ctx->name) { - erofs_fscache_relinquish_cookie(ctx); - return ERR_PTR(-ENOMEM); - } - - refcount_inc(&domain->ref); - ctx->domain = domain; - list_add(&ctx->node, &erofs_domain_cookies_list); - return ctx; -} - -static struct erofs_fscache *erofs_domain_register_cookie(struct super_block *sb, - char *name, unsigned int flags) -{ - struct erofs_fscache *ctx; - struct erofs_domain *domain = EROFS_SB(sb)->domain; - - flags |= EROFS_REG_COOKIE_SHARE; - mutex_lock(&erofs_domain_cookies_lock); - 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)) { - refcount_inc(&ctx->ref); - } else { - erofs_err(sb, "%s already exists in domain %s", name, - domain->domain_id); - ctx = ERR_PTR(-EEXIST); - } - mutex_unlock(&erofs_domain_cookies_lock); - return ctx; - } - ctx = erofs_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, - unsigned int flags) -{ - if (EROFS_SB(sb)->domain_id) - 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) -{ - struct erofs_domain *domain = NULL; - - if (!ctx) - return; - if (!ctx->domain) - return erofs_fscache_relinquish_cookie(ctx); - - 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) -{ - int ret; - struct erofs_sb_info *sbi = EROFS_SB(sb); - struct erofs_fscache *fscache; - unsigned int flags = 0; - - if (sbi->domain_id) - ret = erofs_fscache_register_domain(sb); - else - ret = erofs_fscache_register_volume(sb); - if (ret) - return ret; - - /* - * 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. - */ - 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); - - sbi->dif0.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->dif0.fscache); - - if (sbi->domain) - erofs_fscache_domain_put(sbi->domain); - else - fscache_relinquish_volume(sbi->volume, NULL, false); - - sbi->dif0.fscache = NULL; - sbi->volume = NULL; - sbi->domain = NULL; -} diff --git a/fs/erofs/inode.c b/fs/erofs/inode.c index a188c570087a..1df38b7c82a7 100644 --- a/fs/erofs/inode.c +++ b/fs/erofs/inode.c @@ -255,7 +255,7 @@ static int erofs_fill_inode(struct inode *inode) } mapping_set_large_folios(inode->i_mapping); - aops = erofs_get_aops(inode, false); + aops = erofs_get_aops(inode); if (IS_ERR(aops)) return PTR_ERR(aops); inode->i_mapping->a_ops = aops; diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h index 9e2ae7b61977..580f8d9f14e7 100644 --- a/fs/erofs/internal.h +++ b/fs/erofs/internal.h @@ -43,7 +43,6 @@ typedef u64 erofs_blk_t; struct erofs_device_info { char *path; - struct erofs_fscache *fscache; struct file *file; struct dax_device *dax_dev; u64 fsoff, dax_part_off; @@ -80,24 +79,6 @@ struct erofs_sb_lz4_info { u16 max_pclusterblks; }; -struct erofs_domain { - refcount_t ref; - struct list_head list; - struct fscache_volume *volume; - char *domain_id; -}; - -struct erofs_fscache { - struct fscache_cookie *cookie; - struct inode *inode; /* anonymous inode for the blob */ - - /* used for share domain mode */ - struct erofs_domain *domain; - struct list_head node; - refcount_t ref; - char *name; -}; - struct erofs_xattr_prefix_item { struct erofs_xattr_long_prefix *prefix; u8 infix_len; @@ -162,10 +143,6 @@ struct erofs_sb_info { struct completion s_kobj_unregister; erofs_off_t dir_ra_bytes; - /* fscache support */ - struct fscache_volume *volume; - struct erofs_domain *domain; - char *fsid; char *domain_id; }; @@ -191,12 +168,6 @@ static inline bool erofs_is_fileio_mode(struct erofs_sb_info *sbi) extern struct file_system_type erofs_anon_fs_type; -static inline bool erofs_is_fscache_mode(struct super_block *sb) -{ - return IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && - !erofs_is_fileio_mode(EROFS_SB(sb)) && !sb->s_bdev; -} - enum { EROFS_ZIP_CACHE_DISABLED, EROFS_ZIP_CACHE_READAHEAD, @@ -413,11 +384,9 @@ struct erofs_map_dev { }; extern const struct super_operations erofs_sops; - extern const struct address_space_operations erofs_aops; extern const struct address_space_operations erofs_fileio_aops; extern const struct address_space_operations z_erofs_aops; -extern const struct address_space_operations erofs_fscache_access_aops; extern const struct inode_operations erofs_generic_iops; extern const struct inode_operations erofs_symlink_iops; @@ -430,10 +399,6 @@ extern const struct file_operations erofs_ishare_fops; extern const struct iomap_ops z_erofs_iomap_report_ops; -/* flags for erofs_fscache_register_cookie() */ -#define EROFS_REG_COOKIE_SHARE 0x0001 -#define EROFS_REG_COOKIE_NEED_NOEXIST 0x0002 - void *erofs_read_metadata(struct super_block *sb, struct erofs_buf *buf, erofs_off_t *offset, int *lengthp); void erofs_unmap_metabuf(struct erofs_buf *buf); @@ -473,7 +438,7 @@ static inline void *erofs_vm_map_ram(struct page **pages, unsigned int count) } static inline const struct address_space_operations * -erofs_get_aops(struct inode *realinode, bool no_fscache) +erofs_get_aops(struct inode *realinode) { if (erofs_inode_is_data_compressed(EROFS_I(realinode)->datalayout)) { if (!IS_ENABLED(CONFIG_EROFS_FS_ZIP)) @@ -483,9 +448,6 @@ erofs_get_aops(struct inode *realinode, bool no_fscache) "EXPERIMENTAL EROFS subpage compressed block support in use. Use at your own risk!"); return &z_erofs_aops; } - if (IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && !no_fscache && - erofs_is_fscache_mode(realinode->i_sb)) - return &erofs_fscache_access_aops; if (IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE) && erofs_is_fileio_mode(EROFS_SB(realinode->i_sb))) return &erofs_fileio_aops; @@ -548,36 +510,6 @@ static inline struct bio *erofs_fileio_bio_alloc(struct erofs_map_dev *mdev) { r static inline void erofs_fileio_submit_bio(struct bio *bio) {} #endif -#ifdef CONFIG_EROFS_FS_ONDEMAND -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, unsigned int flags); -void erofs_fscache_unregister_cookie(struct erofs_fscache *fscache); -struct bio *erofs_fscache_bio_alloc(struct erofs_map_dev *mdev); -void erofs_fscache_submit_bio(struct bio *bio); -#else -static inline int erofs_fscache_register_fs(struct super_block *sb) -{ - return -EOPNOTSUPP; -} -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, unsigned int flags) -{ - return ERR_PTR(-EOPNOTSUPP); -} - -static inline void erofs_fscache_unregister_cookie(struct erofs_fscache *fscache) -{ -} -static inline struct bio *erofs_fscache_bio_alloc(struct erofs_map_dev *mdev) { return NULL; } -static inline void erofs_fscache_submit_bio(struct bio *bio) {} -#endif - #ifdef CONFIG_EROFS_FS_PAGE_CACHE_SHARE int __init erofs_init_ishare(void); void erofs_exit_ishare(void); diff --git a/fs/erofs/ishare.c b/fs/erofs/ishare.c index 35cbd0bc04d7..0868c12fc15b 100644 --- a/fs/erofs/ishare.c +++ b/fs/erofs/ishare.c @@ -45,7 +45,7 @@ bool erofs_ishare_fill_inode(struct inode *inode) struct erofs_inode_fingerprint fp; struct inode *si; - aops = erofs_get_aops(inode, true); + aops = erofs_get_aops(inode); if (IS_ERR(aops)) return false; if (erofs_xattr_fill_inode_fingerprint(&fp, inode, sbi->domain_id)) diff --git a/fs/erofs/super.c b/fs/erofs/super.c index 579443e6acfe..86fa5c6a0c70 100644 --- a/fs/erofs/super.c +++ b/fs/erofs/super.c @@ -126,7 +126,6 @@ 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 file *file; bool _48bit; @@ -145,12 +144,7 @@ static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb, return -ENOMEM; } - if (erofs_is_fscache_mode(sb)) { - fscache = erofs_fscache_register_cookie(sb, dif->path, 0); - if (IS_ERR(fscache)) - return PTR_ERR(fscache); - dif->fscache = fscache; - } else if (!sbi->devs->flatdev) { + if (!sbi->devs->flatdev) { file = erofs_is_fileio_mode(sbi) ? filp_open(dif->path, O_RDONLY | O_LARGEFILE, 0) : bdev_file_open_by_path(dif->path, @@ -216,7 +210,7 @@ static int erofs_scan_devices(struct super_block *sb, if (!ondisk_extradevs) return 0; - if (!sbi->devs->extra_devices && !erofs_is_fscache_mode(sb)) + if (!sbi->devs->extra_devices) sbi->devs->flatdev = true; sbi->device_id_mask = roundup_pow_of_two(ondisk_extradevs + 1) - 1; @@ -372,8 +366,6 @@ static int erofs_read_superblock(struct super_block *sb) erofs_info(sb, "EXPERIMENTAL 48-bit layout support in use. Use at your own risk!"); if (erofs_sb_has_metabox(sbi)) erofs_info(sb, "EXPERIMENTAL metadata compression support in use. Use at your own risk!"); - if (erofs_is_fscache_mode(sb)) - erofs_info(sb, "[deprecated] fscache-based on-demand read feature in use. Use at your own risk!"); out: erofs_put_metabuf(&buf); return ret; @@ -393,8 +385,7 @@ static void erofs_default_options(struct erofs_sb_info *sbi) enum { Opt_user_xattr, Opt_acl, Opt_cache_strategy, Opt_dax, Opt_dax_enum, - Opt_device, Opt_fsid, Opt_domain_id, Opt_directio, Opt_fsoffset, - Opt_inode_share, + Opt_device, Opt_domain_id, Opt_directio, Opt_fsoffset, Opt_inode_share, }; static const struct constant_table erofs_param_cache_strategy[] = { @@ -418,7 +409,6 @@ static const struct fs_parameter_spec erofs_fs_parameters[] = { fsparam_flag("dax", Opt_dax), fsparam_enum("dax", Opt_dax_enum, erofs_dax_param_enums), fsparam_string("device", Opt_device), - fsparam_string("fsid", Opt_fsid), fsparam_string("domain_id", Opt_domain_id), fsparam_flag_no("directio", Opt_directio), fsparam_u64("fsoffset", Opt_fsoffset), @@ -509,25 +499,14 @@ static int erofs_fc_parse_param(struct fs_context *fc, } ++sbi->devs->extra_devices; break; -#ifdef CONFIG_EROFS_FS_ONDEMAND - case Opt_fsid: - kfree(sbi->fsid); - sbi->fsid = kstrdup(param->string, GFP_KERNEL); - if (!sbi->fsid) - return -ENOMEM; - break; -#endif -#if defined(CONFIG_EROFS_FS_ONDEMAND) || defined(CONFIG_EROFS_FS_PAGE_CACHE_SHARE) case Opt_domain_id: - kfree_sensitive(sbi->domain_id); - sbi->domain_id = no_free_ptr(param->string); - break; -#else - case Opt_fsid: - case Opt_domain_id: - errorfc(fc, "%s option not supported", erofs_fs_parameters[opt].name); + if (!IS_ENABLED(CONFIG_EROFS_FS_PAGE_CACHE_SHARE)) { + errorfc(fc, "%s option not supported", erofs_fs_parameters[opt].name); + } else { + kfree_sensitive(sbi->domain_id); + sbi->domain_id = no_free_ptr(param->string); + } break; -#endif case Opt_directio: if (!IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE)) errorfc(fc, "%s option not supported", erofs_fs_parameters[opt].name); @@ -620,12 +599,7 @@ static void erofs_set_sysfs_name(struct super_block *sb) { struct erofs_sb_info *sbi = EROFS_SB(sb); - if (sbi->domain_id && sbi->fsid) - super_set_sysfs_name_generic(sb, "%s,%s", sbi->domain_id, - sbi->fsid); - else if (sbi->fsid) - super_set_sysfs_name_generic(sb, "%s", sbi->fsid); - else if (erofs_is_fileio_mode(sbi)) + if (erofs_is_fileio_mode(sbi)) super_set_sysfs_name_generic(sb, "%s", bdi_dev_name(sb->s_bdi)); else @@ -680,11 +654,6 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) sb->s_blocksize = PAGE_SIZE; sb->s_blocksize_bits = PAGE_SHIFT; - if (erofs_is_fscache_mode(sb)) { - err = erofs_fscache_register_fs(sb); - if (err) - return err; - } err = super_setup_bdi(sb); if (err) return err; @@ -703,11 +672,6 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) return err; if (sb->s_blocksize_bits != sbi->blkszbits) { - if (erofs_is_fscache_mode(sb)) { - errorfc(fc, "unsupported blksize for fscache mode"); - return -EINVAL; - } - if (erofs_is_fileio_mode(sbi)) { sb->s_blocksize = 1 << sbi->blkszbits; sb->s_blocksize_bits = sbi->blkszbits; @@ -716,14 +680,9 @@ static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) return -EINVAL; } } - - if (sbi->dif0.fsoff) { - if (sbi->dif0.fsoff & (sb->s_blocksize - 1)) - return invalfc(fc, "fsoffset %llu is not aligned to block size %lu", - sbi->dif0.fsoff, sb->s_blocksize); - if (erofs_is_fscache_mode(sb)) - return invalfc(fc, "cannot use fsoffset in fscache mode"); - } + if (sbi->dif0.fsoff & (sb->s_blocksize - 1)) + return invalfc(fc, "fsoffset %llu is not aligned to block size %lu", + sbi->dif0.fsoff, sb->s_blocksize); if (test_opt(&sbi->opt, DAX_ALWAYS) && sbi->blkszbits != PAGE_SHIFT) { erofs_info(sb, "unsupported blocksize for DAX"); @@ -793,16 +752,13 @@ 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_sb_info *sbi = fc->s_fs_info; int ret; - if (IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && sbi->fsid) - return get_tree_nodev(fc, erofs_fc_fill_super); - ret = get_tree_bdev_flags(fc, erofs_fc_fill_super, IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE) ? GET_TREE_BDEV_QUIET_LOOKUP : 0); if (IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE) && ret == -ENOTBLK) { + struct erofs_sb_info *sbi = fc->s_fs_info; struct file *file; if (!fc->source) @@ -827,8 +783,8 @@ static int erofs_fc_reconfigure(struct fs_context *fc) DBG_BUGON(!sb_rdonly(sb)); - if (new_sbi->fsid || new_sbi->domain_id) - erofs_info(sb, "ignoring reconfiguration for fsid|domain_id."); + if (new_sbi->domain_id) + erofs_info(sb, "ignoring reconfiguration for domain_id."); if (test_opt(&new_sbi->opt, POSIX_ACL)) fc->sb_flags |= SB_POSIXACL; @@ -848,8 +804,6 @@ static int erofs_release_device_info(int id, void *ptr, void *data) fs_put_dax(dif->dax_dev, NULL); if (dif->file) fput(dif->file); - erofs_fscache_unregister_cookie(dif->fscache); - dif->fscache = NULL; kfree(dif->path); kfree(dif); return 0; @@ -867,7 +821,6 @@ static void erofs_free_dev_context(struct erofs_dev_context *devs) static void erofs_sb_free(struct erofs_sb_info *sbi) { erofs_free_dev_context(sbi->devs); - kfree(sbi->fsid); kfree_sensitive(sbi->domain_id); if (sbi->dif0.file) fput(sbi->dif0.file); @@ -928,14 +881,12 @@ static void erofs_kill_sb(struct super_block *sb) { struct erofs_sb_info *sbi = EROFS_SB(sb); - if ((IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && sbi->fsid) || - sbi->dif0.file) + if (sbi->dif0.file) kill_anon_super(sb); else kill_block_super(sb); erofs_drop_internal_inodes(sbi); fs_put_dax(sbi->dif0.dax_dev, NULL); - erofs_fscache_unregister_fs(sb); erofs_sb_free(sbi); sb->s_fs_info = NULL; } @@ -950,7 +901,6 @@ static void erofs_put_super(struct super_block *sb) erofs_drop_internal_inodes(sbi); erofs_free_dev_context(sbi->devs); sbi->devs = NULL; - erofs_fscache_unregister_fs(sb); } static struct file_system_type erofs_fs_type = { @@ -962,14 +912,12 @@ static struct file_system_type erofs_fs_type = { }; MODULE_ALIAS_FS("erofs"); -#if defined(CONFIG_EROFS_FS_ONDEMAND) || defined(CONFIG_EROFS_FS_PAGE_CACHE_SHARE) +#ifdef CONFIG_EROFS_FS_PAGE_CACHE_SHARE static void erofs_free_anon_inode(struct inode *inode) { struct erofs_inode *vi = EROFS_I(inode); -#ifdef CONFIG_EROFS_FS_PAGE_CACHE_SHARE kfree(vi->fingerprint.opaque); -#endif kmem_cache_free(erofs_inode_cachep, vi); } @@ -1099,12 +1047,6 @@ static int erofs_show_options(struct seq_file *seq, struct dentry *root) seq_puts(seq, ",dax=never"); if (erofs_is_fileio_mode(sbi) && test_opt(opt, DIRECT_IO)) seq_puts(seq, ",directio"); - if (IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND)) { - if (sbi->fsid) - seq_printf(seq, ",fsid=%s", sbi->fsid); - if (sbi->domain_id) - seq_printf(seq, ",domain_id=%s", sbi->domain_id); - } if (sbi->dif0.fsoff) seq_printf(seq, ",fsoffset=%llu", sbi->dif0.fsoff); if (test_opt(opt, INODE_SHARE)) diff --git a/fs/erofs/zdata.c b/fs/erofs/zdata.c index 1c65b741b288..74520e910259 100644 --- a/fs/erofs/zdata.c +++ b/fs/erofs/zdata.c @@ -1710,8 +1710,6 @@ static void z_erofs_submit_queue(struct z_erofs_frontend *f, drain_io: if (erofs_is_fileio_mode(EROFS_SB(sb))) erofs_fileio_submit_bio(bio); - else if (erofs_is_fscache_mode(sb)) - erofs_fscache_submit_bio(bio); else submit_bio(bio); @@ -1740,8 +1738,6 @@ drain_io: if (!bio) { if (erofs_is_fileio_mode(EROFS_SB(sb))) bio = erofs_fileio_bio_alloc(&mdev); - else if (erofs_is_fscache_mode(sb)) - bio = erofs_fscache_bio_alloc(&mdev); else bio = bio_alloc(mdev.m_bdev, BIO_MAX_VECS, REQ_OP_READ, GFP_NOIO); @@ -1770,8 +1766,6 @@ drain_io: if (bio) { if (erofs_is_fileio_mode(EROFS_SB(sb))) erofs_fileio_submit_bio(bio); - else if (erofs_is_fscache_mode(sb)) - erofs_fscache_submit_bio(bio); else submit_bio(bio); }