Re: Patch "erofs: remove fscache backend entirely" has been added to the 6.18-stable tree

[Gao Xiang <xiang@kernel.org>]

Hi Sasha,

I'm not sure why we need to backport this into stable kernels, as there
are users who use EROFS over fscache on these stable kernels.

The functionality works and it's a breaking change.  Could you please
kindly tell why?

Thanks,
Gao Xiang

On Mon, Oct 12, 2026 at 10:00:42PM -0400, Sasha Levin wrote:
> This is a note to let you know that I've just added the patch titled
> 
>     erofs: remove fscache backend entirely
> 
> to the 6.18-stable tree which can be found at:
>     http://www.kernel.org/git/?p=linux/kernel/git/stable/stable-queue.git;a=summary
> 
> The filename of the patch is:
>      erofs-remove-fscache-backend-entirely.patch
> and it can be found in the queue-6.18 subdirectory.
> 
> If you, or anyone else, feels it should not be added to the stable tree,
> please let <stable@vger.kernel.org> know about it.
> 
> 
> 
> commit abe569fd895a5260615eb4e7092f110543705bb7
> Author: Gao Xiang <xiang@kernel.org>
> Date:   Mon Jun 22 09:36:22 2026 +0800
> 
>     erofs: remove fscache backend entirely
>     
>     [ Upstream commit c37460cd9b2fcb61ec66b7eb4fde737e65ec2a56 ]
>     
>     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 <jefflexu@linux.alibaba.com>
>     Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com>
>     Signed-off-by: Sasha Levin <sashal@kernel.org>
> 
> diff --git a/Documentation/filesystems/erofs.rst b/Documentation/filesystems/erofs.rst
> index 08194f194b942..8c96104e91df5 100644
> --- a/Documentation/filesystems/erofs.rst
> +++ b/Documentation/filesystems/erofs.rst
> @@ -125,9 +125,6 @@ dax={always,never}     Use direct access (no page cache).  See
>                         Documentation/filesystems/dax.rst.
>  dax                    A legacy option which is an alias for ``dax=always``.
>  device=%s              Specify a path to an extra device to be used together.
> -fsid=%s                Specify a filesystem image ID for Fscache back-end.
> -domain_id=%s           Specify a domain ID in fscache mode so that different images
> -                       with the same blobs under a given domain ID can share storage.
>  fsoffset=%llu          Specify block-aligned filesystem offset for the primary device.
>  ===================    =========================================================
>  
> diff --git a/fs/erofs/Kconfig b/fs/erofs/Kconfig
> index 473a22167c154..3e08d7b174678 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
> @@ -95,9 +93,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
> @@ -179,20 +174,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
> diff --git a/fs/erofs/Makefile b/fs/erofs/Makefile
> index 549abc4247632..a980f760a673e 100644
> --- a/fs/erofs/Makefile
> +++ b/fs/erofs/Makefile
> @@ -9,4 +9,3 @@ 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
> diff --git a/fs/erofs/data.c b/fs/erofs/data.c
> index 3e6b512efe21c..0574384eca18c 100644
> --- a/fs/erofs/data.c
> +++ b/fs/erofs/data.c
> @@ -65,9 +65,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 754f7d04488da..0000000000000
> --- a/fs/erofs/fscache.c
> +++ /dev/null
> @@ -1,679 +0,0 @@
> -// SPDX-License-Identifier: GPL-2.0-or-later
> -/*
> - * Copyright (C) 2022, Alibaba Cloud
> - * Copyright (C) 2022, Bytedance Inc. All rights reserved.
> - */
> -#include <linux/pseudo_fs.h>
> -#include <linux/fscache.h>
> -#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;
> -
> -static int erofs_anon_init_fs_context(struct fs_context *fc)
> -{
> -	return init_pseudo(fc, EROFS_SUPER_MAGIC) ? 0 : -ENOMEM;
> -}
> -
> -static struct file_system_type erofs_anon_fs_type = {
> -	.owner		= THIS_MODULE,
> -	.name           = "pseudo_erofs",
> -	.init_fs_context = erofs_anon_init_fs_context,
> -	.kill_sb        = kill_anon_super,
> -};
> -
> -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);
> -		/* Skip the entire folio before unlocking allows it to be split. */
> -		xas_advance(&xas, folio_next_index(folio) - 1);
> -		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(sizeof(*req), GFP_KERNEL);
> -
> -	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(sizeof(*io), GFP_KERNEL);
> -
> -	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(sizeof(*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(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(sizeof(struct erofs_domain), GFP_KERNEL);
> -	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(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(sizeof(*ctx), GFP_KERNEL);
> -	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 218ab22589228..07fab8d159292 100644
> --- a/fs/erofs/inode.c
> +++ b/fs/erofs/inode.c
> @@ -246,10 +246,6 @@ static int erofs_fill_inode(struct inode *inode)
>  #endif
>  	} else {
>  		inode->i_mapping->a_ops = &erofs_aops;
> -#ifdef CONFIG_EROFS_FS_ONDEMAND
> -		if (erofs_is_fscache_mode(inode->i_sb))
> -			inode->i_mapping->a_ops = &erofs_fscache_access_aops;
> -#endif
>  #ifdef CONFIG_EROFS_FS_BACKED_BY_FILE
>  		if (erofs_is_fileio_mode(EROFS_SB(inode->i_sb)))
>  			inode->i_mapping->a_ops = &erofs_fileio_aops;
> diff --git a/fs/erofs/internal.h b/fs/erofs/internal.h
> index 845c71afb58d5..62f0d05e30393 100644
> --- a/fs/erofs/internal.h
> +++ b/fs/erofs/internal.h
> @@ -41,7 +41,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;
> @@ -74,24 +73,6 @@ struct erofs_sb_lz4_info {
>  	u16 max_pclusterblks;	/* maximum physical blocks for LZ4 pclusters */
>  };
>  
> -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;
> @@ -154,12 +135,6 @@ struct erofs_sb_info {
>  	struct kobject s_kobj;		/* /sys/fs/erofs/<devname> */
>  	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;
>  };
>  
>  #define EROFS_SB(sb) ((struct erofs_sb_info *)(sb)->s_fs_info)
> @@ -181,12 +156,6 @@ static inline bool erofs_is_fileio_mode(struct erofs_sb_info *sbi)
>  	return IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE) && sbi->dif0.file;
>  }
>  
> -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,
> @@ -385,11 +354,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;
> @@ -401,10 +368,6 @@ extern const struct file_operations erofs_dir_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);
> @@ -499,36 +462,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
> -
>  long erofs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
>  long erofs_compat_ioctl(struct file *filp, unsigned int cmd,
>  			unsigned long arg);
> diff --git a/fs/erofs/super.c b/fs/erofs/super.c
> index e6725e9847bed..18048719aab58 100644
> --- a/fs/erofs/super.c
> +++ b/fs/erofs/super.c
> @@ -137,7 +137,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;
> @@ -156,12 +155,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,
> @@ -227,7 +221,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;
> @@ -368,8 +362,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;
> @@ -391,7 +383,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_device, Opt_domain_id, Opt_directio, Opt_fsoffset,
>  };
>  
>  static const struct constant_table erofs_param_cache_strategy[] = {
> @@ -415,7 +407,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),
> @@ -513,25 +504,9 @@ 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;
> -	case Opt_domain_id:
> -		kfree(sbi->domain_id);
> -		sbi->domain_id = kstrdup(param->string, GFP_KERNEL);
> -		if (!sbi->domain_id)
> -			return -ENOMEM;
> -		break;
> -#else
> -	case Opt_fsid:
>  	case Opt_domain_id:
>  		errorfc(fc, "%s option not supported", erofs_fs_parameters[opt].name);
>  		break;
> -#endif
>  	case Opt_directio:
>  #ifdef CONFIG_EROFS_FS_BACKED_BY_FILE
>  		if (result.boolean)
> @@ -620,12 +595,7 @@ static void erofs_set_sysfs_name(struct super_block *sb)
>  {
>  	struct erofs_sb_info *sbi = EROFS_SB(sb);
>  
> -	if (sbi->domain_id)
> -		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
> @@ -671,11 +641,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;
> @@ -694,11 +659,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;
> @@ -707,14 +667,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");
> @@ -778,17 +733,14 @@ 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);
>  #ifdef CONFIG_EROFS_FS_BACKED_BY_FILE
>  	if (ret == -ENOTBLK) {
> +		struct erofs_sb_info *sbi = fc->s_fs_info;
>  		struct file *file;
>  
>  		if (!fc->source)
> @@ -814,9 +766,6 @@ 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 (test_opt(&new_sbi->opt, POSIX_ACL))
>  		fc->sb_flags |= SB_POSIXACL;
>  	else
> @@ -835,8 +784,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;
> @@ -854,8 +801,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(sbi->domain_id);
>  	if (sbi->dif0.file)
>  		fput(sbi->dif0.file);
>  	kfree(sbi->volume_name);
> @@ -915,14 +860,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;
>  }
> @@ -937,7 +880,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 = {
> @@ -1044,12 +986,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");
> -#ifdef 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);
> -#endif
>  	if (sbi->dif0.fsoff)
>  		seq_printf(seq, ",fsoffset=%llu", sbi->dif0.fsoff);
>  	return 0;
> diff --git a/fs/erofs/zdata.c b/fs/erofs/zdata.c
> index 0af259e22026f..9214f3c0e851e 100644
> --- a/fs/erofs/zdata.c
> +++ b/fs/erofs/zdata.c
> @@ -1699,8 +1699,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);
>  
> @@ -1729,8 +1727,6 @@ static void z_erofs_submit_queue(struct z_erofs_frontend *f,
>  			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);
> @@ -1759,8 +1755,6 @@ static void z_erofs_submit_queue(struct z_erofs_frontend *f,
>  	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);
>  	}