From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 808773ACA7A; Mon, 6 Jul 2026 03:05:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1783307106; cv=none; b=jOyKQN6OvakN6fsuDAui0d2lCpErEg6j8WAZixO779m8ZGpFsmINAOlsb0LKTotDKBVH2c57kTbtXISvMYiNUvFvvVs0cSNGbVrb7J+Tm1ufkuaEanpWTUzgUXWaDxaaAuQU41KXWELm9dsIoz7w7OYDH8yWtjbxFTU3D+m2m+c= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1783307106; c=relaxed/simple; bh=lmHorh5fys6wGYCXK8qGoMcQ5Zc3JXkI9puvAg8BBog=; h=From:To:Cc:Subject:Date:Message-ID:MIME-Version; b=beAd7iU52mlF7PF3DHa7+qDQElWZa03ttCwKl0lSglfgZYnVDRc8yWLcXoOdExpOyB46SPGeGYuOI7yIG/8FTmvhrEY++ift4aO6L+dYdMsrqrRnZvIaPczyzMmxQVq7cP1r7813H9DXhMsGrgMYKS1SGO6/AmW0H3RcUMg3pmA= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CnNRcJVr; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="CnNRcJVr" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 547FA1F00A3A; Mon, 6 Jul 2026 03:04:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1783307099; bh=pPMoTjqR2K9JwA5etlOAOoNl7FP5vo4k0VKhDzSOEb4=; h=From:To:Cc:Subject:Date; b=CnNRcJVrdPwaeW75mgNUcXUHLbSiF1wYcJJasZxbY1QCC3IaO7JhIHGiQeLUoTolJ QX58ynpLAsWYtJ+pRq0cky8+M4GZU7wC50+qmRc7DnLcPY3JpY3A97UUJgNuJ98T1r U3fUf0He+wWK+MtIuFJSK4uBuQkfe77JquUL5TxcfsDPewya3fFKvuI2ApnzJvzhlb QatH7f/BU77bNQ41Rvlp8JtvMLaAQGBKH7ihEGlVTA7mPw7bPwBCDH9R7e9kzHaXph 3jWDTTp+0P/OHMSy6/RNHXTOZ4fq7d/w1q/ggpy47M0YtWZEs+syfRhsrw/SaSVEXT XHSqyLN33haIQ== From: Gao Xiang To: David Howells , Paulo Alcantara , Christian Brauner Cc: linux-kernel@vger.kernel.org, netfs@lists.linux.dev, linux-fsdevel@vger.kernel.org, Jingbo Xu , Gao Xiang Subject: [PATCH] cachefiles,netfs: sunset ondemand mode Date: Mon, 6 Jul 2026 11:04:39 +0800 Message-ID: <20260706030439.14212-1-xiang@kernel.org> X-Mailer: git-send-email 2.47.3 Precedence: bulk X-Mailing-List: netfs@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit It was an effort to enhance fscache as a kernel cache for lazy pulling (at least according to previous Incremental FS discussion [1]) and EROFS over fscache was the in-tree user of this mode. fscache has since evolved to be netfslib-oriented, serving network filesystem inodes via the netfs library, but EROFS never acts as a network filesystem and we need to cache golden filesystem images rather than individual EROFS inodes. Since EROFS over fscache is now removed, clean up netfs/fscache/ cachefiles upstream too. [1] https://lore.kernel.org/r/CAOQ4uxi4dzxArY24YO=+kBCK2gGoq3Ptb8WkzCqSogPgU_R3dQ@mail.gmail.com Signed-off-by: Gao Xiang --- fs/cachefiles/Kconfig | 12 - fs/cachefiles/Makefile | 1 - fs/cachefiles/daemon.c | 76 +--- fs/cachefiles/interface.c | 8 - fs/cachefiles/internal.h | 128 ------- fs/cachefiles/io.c | 25 -- fs/cachefiles/namei.c | 8 - fs/cachefiles/ondemand.c | 761 -------------------------------------- include/linux/netfs.h | 9 - 9 files changed, 4 insertions(+), 1024 deletions(-) delete mode 100644 fs/cachefiles/ondemand.c diff --git a/fs/cachefiles/Kconfig b/fs/cachefiles/Kconfig index c5a070550ee3..afb25b6af5aa 100644 --- a/fs/cachefiles/Kconfig +++ b/fs/cachefiles/Kconfig @@ -26,15 +26,3 @@ config CACHEFILES_ERROR_INJECTION help This permits error injection to be enabled in cachefiles whilst a cache is in service. - -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 c37a7a9af10b..16d811f1a2fa 100644 --- a/fs/cachefiles/Makefile +++ b/fs/cachefiles/Makefile @@ -16,6 +16,5 @@ cachefiles-y := \ xattr.o cachefiles-$(CONFIG_CACHEFILES_ERROR_INJECTION) += error_inject.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 4117b145ac94..6e0248a62c13 100644 --- a/fs/cachefiles/daemon.c +++ b/fs/cachefiles/daemon.c @@ -76,10 +76,6 @@ 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 }, - { "restore", cachefiles_ondemand_restore }, -#endif { "", NULL } }; @@ -114,8 +110,6 @@ static int cachefiles_daemon_open(struct inode *inode, struct file *file) INIT_LIST_HEAD(&cache->object_list); spin_lock_init(&cache->object_list_lock); refcount_set(&cache->unbind_pincount, 1); - xa_init_flags(&cache->reqs, XA_FLAGS_ALLOC); - xa_init_flags(&cache->ondemand_ids, XA_FLAGS_ALLOC1); /* set default caching limits * - limit at 1% free space and/or free files @@ -134,40 +128,6 @@ static int cachefiles_daemon_open(struct inode *inode, struct file *file) return 0; } -void cachefiles_flush_reqs(struct cachefiles_cache *cache) -{ - struct xarray *xa = &cache->reqs; - struct cachefiles_req *req; - unsigned long index; - - /* - * 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(xa); - xa_for_each(xa, index, req) { - req->error = -EIO; - complete(&req->done); - __xa_erase(xa, index); - } - xa_unlock(xa); - - xa_destroy(&cache->reqs); - xa_destroy(&cache->ondemand_ids); -} - void cachefiles_put_unbind_pincount(struct cachefiles_cache *cache) { if (refcount_dec_and_test(&cache->unbind_pincount)) { @@ -195,9 +155,6 @@ 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); - /* clean up the control file interface */ cache->cachefilesd = NULL; file->private_data = NULL; @@ -266,10 +223,7 @@ static ssize_t cachefiles_daemon_read(struct file *file, char __user *_buffer, if (!test_bit(CACHEFILES_READY, &cache->flags)) return 0; - if (cachefiles_in_ondemand_mode(cache)) - return cachefiles_ondemand_daemon_read(cache, _buffer, buflen); - else - return cachefiles_do_daemon_read(cache, _buffer, buflen); + return cachefiles_do_daemon_read(cache, _buffer, buflen); } /* @@ -358,28 +312,13 @@ static __poll_t cachefiles_daemon_poll(struct file *file, struct poll_table_struct *poll) { struct cachefiles_cache *cache = file->private_data; - XA_STATE(xas, &cache->reqs, 0); - struct cachefiles_req *req; __poll_t mask; poll_wait(file, &cache->daemon_pollwq, poll); mask = 0; - if (cachefiles_in_ondemand_mode(cache)) { - if (!xa_empty(&cache->reqs)) { - xas_lock(&xas); - xas_for_each_marked(&xas, req, ULONG_MAX, CACHEFILES_REQ_NEW) { - if (!cachefiles_ondemand_is_reopening_read(req)) { - mask |= EPOLLIN; - break; - } - } - xas_unlock(&xas); - } - } else { - if (test_bit(CACHEFILES_STATE_CHANGED, &cache->flags)) - mask |= EPOLLIN; - } + if (test_bit(CACHEFILES_STATE_CHANGED, &cache->flags)) + mask |= EPOLLIN; if (test_bit(CACHEFILES_CULLING, &cache->flags)) mask |= EPOLLOUT; @@ -779,14 +718,7 @@ static 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) { + if (*args) { pr_err("'bind' command doesn't take an argument\n"); return -EINVAL; } diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c index a08250d244ea..50a000310a8c 100644 --- a/fs/cachefiles/interface.c +++ b/fs/cachefiles/interface.c @@ -32,11 +32,6 @@ struct cachefiles_object *cachefiles_alloc_object(struct fscache_cookie *cookie) if (!object) return NULL; - if (cachefiles_ondemand_init_obj_info(object, volume)) { - kmem_cache_free(cachefiles_object_jar, object); - return NULL; - } - refcount_set(&object->ref, 1); spin_lock_init(&object->lock); @@ -94,7 +89,6 @@ void cachefiles_put_object(struct cachefiles_object *object, ASSERTCMP(object->file, ==, NULL); kfree(object->d_name); - cachefiles_ondemand_deinit_obj_info(object); cache = object->volume->cache->cache; fscache_put_cookie(object->cookie, fscache_cookie_put_object); object->cookie = NULL; @@ -374,8 +368,6 @@ static void cachefiles_withdraw_cookie(struct fscache_cookie *cookie) spin_unlock(&cache->object_list_lock); } - cachefiles_ondemand_clean_object(object); - if (object->file) { cachefiles_begin_secure(cache, &saved_cred); cachefiles_clean_up_object(object, cache); diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index b62cd3e9a18e..dcf5161d0bf7 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -15,7 +15,6 @@ #include #include #include -#include #include #define CACHEFILES_DIO_BLOCK_SIZE 4096 @@ -44,21 +43,6 @@ struct cachefiles_volume { struct dentry *fanout[256]; /* Fanout subdirs */ }; -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 { - struct work_struct ondemand_work; - int ondemand_id; - enum cachefiles_object_state state; - struct cachefiles_object *object; - spinlock_t lock; -}; - /* * Backing file state. */ @@ -74,13 +58,8 @@ struct cachefiles_object { enum cachefiles_content content_info:8; /* Info about content presence */ unsigned long flags; #define CACHEFILES_OBJECT_USING_TMPFILE 0 /* Have an unlinked tmpfile */ -#ifdef CONFIG_CACHEFILES_ONDEMAND - struct cachefiles_ondemand_info *ondemand; -#endif }; -#define CACHEFILES_ONDEMAND_ID_CLOSED -1 - /* * Cache files cache definition */ @@ -119,35 +98,14 @@ 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 *tag; /* cache binding tag */ refcount_t unbind_pincount;/* refcount to do daemon unbind */ - struct xarray reqs; /* xarray of pending on-demand requests */ - unsigned long req_id_next; - struct xarray ondemand_ids; /* xarray for ondemand_id allocation */ - u32 ondemand_id_next; u32 msg_id_next; u32 secid; /* LSM security id */ bool have_secid; /* whether "secid" was set */ }; -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; - refcount_t ref; - int error; - struct cachefiles_msg msg; -}; - -#define CACHEFILES_REQ_NEW XA_MARK_1 - #include static inline @@ -298,90 +256,6 @@ extern struct file *cachefiles_create_tmpfile(struct cachefiles_object *object); extern bool cachefiles_commit_tmpfile(struct cachefiles_cache *cache, struct cachefiles_object *object); -/* - * ondemand.c - */ -#ifdef CONFIG_CACHEFILES_ONDEMAND -extern ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, - char __user *_buffer, size_t buflen); - -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, - loff_t pos, size_t len); - -extern int cachefiles_ondemand_init_obj_info(struct cachefiles_object *obj, - struct cachefiles_volume *volume); -extern void cachefiles_ondemand_deinit_obj_info(struct cachefiles_object *obj); - -#define CACHEFILES_OBJECT_STATE_FUNCS(_state, _STATE) \ -static inline bool \ -cachefiles_ondemand_object_is_##_state(const struct cachefiles_object *object) \ -{ \ - return object->ondemand->state == CACHEFILES_ONDEMAND_OBJSTATE_##_STATE; \ -} \ - \ -static inline void \ -cachefiles_ondemand_set_object_##_state(struct cachefiles_object *object) \ -{ \ - object->ondemand->state = CACHEFILES_ONDEMAND_OBJSTATE_##_STATE; \ -} - -CACHEFILES_OBJECT_STATE_FUNCS(open, OPEN); -CACHEFILES_OBJECT_STATE_FUNCS(close, CLOSE); -CACHEFILES_OBJECT_STATE_FUNCS(reopening, REOPENING); -CACHEFILES_OBJECT_STATE_FUNCS(dropping, DROPPING); - -static inline bool cachefiles_ondemand_is_reopening_read(struct cachefiles_req *req) -{ - return cachefiles_ondemand_object_is_reopening(req->object) && - req->msg.opcode == CACHEFILES_OP_READ; -} - -#else -static inline ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, - char __user *_buffer, size_t buflen) -{ - return -EOPNOTSUPP; -} - -static inline int cachefiles_ondemand_init_object(struct cachefiles_object *object) -{ - return 0; -} - -static inline void cachefiles_ondemand_clean_object(struct cachefiles_object *object) -{ -} - -static inline int cachefiles_ondemand_read(struct cachefiles_object *object, - loff_t pos, size_t len) -{ - return -EOPNOTSUPP; -} - -static inline int cachefiles_ondemand_init_obj_info(struct cachefiles_object *obj, - struct cachefiles_volume *volume) -{ - return 0; -} -static inline void cachefiles_ondemand_deinit_obj_info(struct cachefiles_object *obj) -{ -} - -static inline bool cachefiles_ondemand_is_reopening_read(struct cachefiles_req *req) -{ - return false; -} -#endif - /* * security.c */ @@ -430,8 +304,6 @@ do { \ pr_err("I/O Error: " FMT"\n", ##__VA_ARGS__); \ fscache_io_error((___cache)->cache); \ set_bit(CACHEFILES_DEAD, &(___cache)->flags); \ - if (cachefiles_in_ondemand_mode(___cache)) \ - cachefiles_flush_reqs(___cache); \ } while (0) #define cachefiles_io_error_obj(object, FMT, ...) \ diff --git a/fs/cachefiles/io.c b/fs/cachefiles/io.c index d879b80a0bed..bc3a62595d10 100644 --- a/fs/cachefiles/io.c +++ b/fs/cachefiles/io.c @@ -390,7 +390,6 @@ cachefiles_do_prepare_read(struct netfs_cache_resources *cres, size_t len = *_len; loff_t off, to; ino_t ino = file ? file_inode(file)->i_ino : 0; - int rc; _enter("%zx @%llx/%llx", len, start, i_size); @@ -403,8 +402,6 @@ cachefiles_do_prepare_read(struct netfs_cache_resources *cres, if (test_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags)) { __set_bit(NETFS_SREQ_COPY_TO_CACHE, _flags); why = cachefiles_trace_read_no_data; - if (!test_bit(NETFS_SREQ_ONDEMAND, _flags)) - goto out_no_object; } /* The object and the file may be being created in the background. */ @@ -421,7 +418,6 @@ cachefiles_do_prepare_read(struct netfs_cache_resources *cres, object = cachefiles_cres_object(cres); cache = object->volume->cache; cachefiles_begin_secure(cache, &saved_cred); -retry: off = cachefiles_inject_read_error(); if (off == 0) off = vfs_llseek(file, start, SEEK_DATA); @@ -474,14 +470,6 @@ cachefiles_do_prepare_read(struct netfs_cache_resources *cres, download_and_store: __set_bit(NETFS_SREQ_COPY_TO_CACHE, _flags); - if (test_bit(NETFS_SREQ_ONDEMAND, _flags)) { - rc = cachefiles_ondemand_read(object, start, len); - if (!rc) { - __clear_bit(NETFS_SREQ_ONDEMAND, _flags); - goto retry; - } - ret = NETFS_INVALID_READ; - } out: cachefiles_end_secure(cache, saved_cred); out_no_object: @@ -501,18 +489,6 @@ static enum netfs_io_source cachefiles_prepare_read(struct netfs_io_subrequest * &subreq->flags, subreq->rreq->inode->i_ino); } -/* - * Prepare an on-demand read operation, shortening it to a cached/uncached - * boundary as appropriate. - */ -static enum netfs_io_source -cachefiles_prepare_ondemand_read(struct netfs_cache_resources *cres, - loff_t start, size_t *_len, loff_t i_size, - unsigned long *_flags, ino_t ino) -{ - return cachefiles_do_prepare_read(cres, start, _len, i_size, _flags, ino); -} - /* * Prepare for a write to occur. */ @@ -731,7 +707,6 @@ static const struct netfs_cache_ops cachefiles_netfs_cache_ops = { .prepare_read = cachefiles_prepare_read, .prepare_write = cachefiles_prepare_write, .prepare_write_subreq = cachefiles_prepare_write_subreq, - .prepare_ondemand_read = cachefiles_prepare_ondemand_read, .query_occupancy = cachefiles_query_occupancy, }; diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c index 8a9f6be15828..88955249a1a6 100644 --- a/fs/cachefiles/namei.c +++ b/fs/cachefiles/namei.c @@ -442,10 +442,6 @@ struct file *cachefiles_create_tmpfile(struct cachefiles_object *object) if (!cachefiles_mark_inode_in_use(object, file_inode(file))) WARN_ON(1); - ret = cachefiles_ondemand_init_object(object); - if (ret < 0) - goto err_unuse; - ni_size = object->cookie->object_size; ni_size = round_up(ni_size, CACHEFILES_DIO_BLOCK_SIZE); @@ -546,10 +542,6 @@ static bool cachefiles_open_file(struct cachefiles_object *object, } _debug("file -> %pd positive", dentry); - ret = cachefiles_ondemand_init_object(object); - if (ret < 0) - goto error_fput; - ret = cachefiles_check_auxdata(object, file); if (ret < 0) goto check_failed; diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c deleted file mode 100644 index 0849eaf583cd..000000000000 --- a/fs/cachefiles/ondemand.c +++ /dev/null @@ -1,761 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-or-later -#include -#include -#include "internal.h" - -struct ondemand_anon_file { - struct file *file; - int fd; -}; - -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) -{ - struct cachefiles_object *object = file->private_data; - struct cachefiles_cache *cache; - struct cachefiles_ondemand_info *info; - int object_id; - struct cachefiles_req *req; - XA_STATE(xas, NULL, 0); - - if (!object) - return 0; - - info = object->ondemand; - cache = object->volume->cache; - xas.xa = &cache->reqs; - - xa_lock(&cache->reqs); - spin_lock(&info->lock); - object_id = info->ondemand_id; - 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 */ - xas_for_each_marked(&xas, req, ULONG_MAX, CACHEFILES_REQ_NEW) { - if (req->msg.object_id == object_id && - req->msg.opcode == CACHEFILES_OP_CLOSE) { - complete(&req->done); - xas_store(&xas, NULL); - } - } - xa_unlock(&cache->reqs); - - xa_erase(&cache->ondemand_ids, object_id); - trace_cachefiles_ondemand_fd_release(object, object_id); - cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd); - cachefiles_put_unbind_pincount(cache); - 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 = object->volume->cache; - struct file *file; - size_t len = iter->count, aligned_len = len; - loff_t pos = kiocb->ki_pos; - const struct cred *saved_cred; - int ret; - - spin_lock(&object->lock); - file = object->file; - if (!file) { - spin_unlock(&object->lock); - return -ENOBUFS; - } - get_file(file); - spin_unlock(&object->lock); - - cachefiles_begin_secure(cache, &saved_cred); - ret = __cachefiles_prepare_write(object, file, &pos, &aligned_len, len, true); - cachefiles_end_secure(cache, saved_cred); - if (ret < 0) - goto out; - - trace_cachefiles_ondemand_fd_write(object, file_inode(file), pos, len); - ret = __cachefiles_write(object, file, pos, iter, NULL, NULL); - if (ret > 0) - kiocb->ki_pos += ret; - -out: - fput(file); - return ret; -} - -static loff_t cachefiles_ondemand_fd_llseek(struct file *filp, loff_t pos, - int whence) -{ - struct cachefiles_object *object = filp->private_data; - struct file *file; - loff_t ret; - - spin_lock(&object->lock); - file = object->file; - if (!file) { - spin_unlock(&object->lock); - return -ENOBUFS; - } - get_file(file); - spin_unlock(&object->lock); - - ret = vfs_llseek(file, pos, whence); - fput(file); - - return ret; -} - -static long cachefiles_ondemand_fd_ioctl(struct file *filp, unsigned int ioctl, - unsigned long id) -{ - struct cachefiles_object *object = filp->private_data; - struct cachefiles_cache *cache = object->volume->cache; - struct cachefiles_req *req; - XA_STATE(xas, &cache->reqs, id); - - if (ioctl != CACHEFILES_IOC_READ_COMPLETE) - return -EINVAL; - - if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags)) - return -EOPNOTSUPP; - - xa_lock(&cache->reqs); - req = xas_load(&xas); - if (!req || req->msg.opcode != CACHEFILES_OP_READ || - req->object != object) { - xa_unlock(&cache->reqs); - return -EINVAL; - } - xas_store(&xas, NULL); - xa_unlock(&cache->reqs); - - trace_cachefiles_ondemand_cread(object, id); - complete(&req->done); - return 0; -} - -static const struct file_operations cachefiles_ondemand_fd_fops = { - .owner = THIS_MODULE, - .release = cachefiles_ondemand_fd_release, - .write_iter = cachefiles_ondemand_fd_write_iter, - .llseek = cachefiles_ondemand_fd_llseek, - .unlocked_ioctl = cachefiles_ondemand_fd_ioctl, -}; - -/* - * OPEN request Completion (copen) - * - command: "copen ," - * 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; - struct cachefiles_ondemand_info *info; - char *pid, *psize; - unsigned long id; - long size; - int ret; - XA_STATE(xas, &cache->reqs, 0); - - 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); - xas.xa_index = id; - req = xas_load(&xas); - if (!req || req->msg.opcode != CACHEFILES_OP_OPEN || - !req->object->ondemand->ondemand_id) { - xa_unlock(&cache->reqs); - return -EINVAL; - } - xas_store(&xas, NULL); - xa_unlock(&cache->reqs); - - info = req->object->ondemand; - /* 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)) { - req->error = -EINVAL; - ret = -EINVAL; - } else { - req->error = size; - ret = 0; - } - goto out; - } - - spin_lock(&info->lock); - /* - * The anonymous fd was closed before copen ? Fail the request. - * - * 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. - */ - if (info->ondemand_id == CACHEFILES_ONDEMAND_ID_CLOSED) { - spin_unlock(&info->lock); - req->error = -EBADFD; - goto out; - } - cookie = req->object->cookie; - cookie->object_size = size; - if (size) - clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags); - else - set_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags); - trace_cachefiles_ondemand_copen(req->object, id, size); - - cachefiles_ondemand_set_object_open(req->object); - spin_unlock(&info->lock); - 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; -} - -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 ondemand_anon_file *anon_file) -{ - struct cachefiles_object *object; - struct cachefiles_cache *cache; - struct cachefiles_open *load; - u32 object_id; - int ret; - - object = cachefiles_grab_object(req->object, - cachefiles_obj_get_ondemand_fd); - cache = object->volume->cache; - - ret = xa_alloc_cyclic(&cache->ondemand_ids, &object_id, NULL, - XA_LIMIT(1, INT_MAX), - &cache->ondemand_id_next, GFP_KERNEL); - if (ret < 0) - goto err; - - anon_file->fd = get_unused_fd_flags(O_WRONLY); - if (anon_file->fd < 0) { - ret = anon_file->fd; - goto err_free_id; - } - - anon_file->file = anon_inode_getfile_fmode("[cachefiles]", - &cachefiles_ondemand_fd_fops, object, - O_WRONLY, FMODE_PWRITE | FMODE_LSEEK); - if (IS_ERR(anon_file->file)) { - ret = PTR_ERR(anon_file->file); - goto err_put_fd; - } - - spin_lock(&object->ondemand->lock); - if (object->ondemand->ondemand_id > 0) { - spin_unlock(&object->ondemand->lock); - /* Pair with check in cachefiles_ondemand_fd_release(). */ - anon_file->file->private_data = NULL; - ret = -EEXIST; - goto err_put_file; - } - - load = (void *)req->msg.data; - load->fd = anon_file->fd; - object->ondemand->ondemand_id = object_id; - spin_unlock(&object->ondemand->lock); - - cachefiles_get_unbind_pincount(cache); - trace_cachefiles_ondemand_open(object, &req->msg, load); - return 0; - -err_put_file: - fput(anon_file->file); - anon_file->file = NULL; -err_put_fd: - put_unused_fd(anon_file->fd); - anon_file->fd = ret; -err_free_id: - xa_erase(&cache->ondemand_ids, object_id); -err: - spin_lock(&object->ondemand->lock); - /* Avoid marking an opened object as closed. */ - if (object->ondemand->ondemand_id <= 0) - cachefiles_ondemand_set_object_close(object); - spin_unlock(&object->ondemand->lock); - cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd); - return ret; -} - -static void ondemand_object_worker(struct work_struct *work) -{ - struct cachefiles_ondemand_info *info = - container_of(work, struct cachefiles_ondemand_info, ondemand_work); - - cachefiles_ondemand_init_object(info->object); -} - -/* - * 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 xa_state *xas, - unsigned long xa_max) -{ - struct cachefiles_req *req; - struct cachefiles_object *object; - struct cachefiles_ondemand_info *info; - - xas_for_each_marked(xas, req, xa_max, CACHEFILES_REQ_NEW) { - if (req->msg.opcode != CACHEFILES_OP_READ) - return req; - object = req->object; - info = object->ondemand; - if (cachefiles_ondemand_object_is_close(object)) { - cachefiles_ondemand_set_object_reopening(object); - queue_work(fscache_wq, &info->ondemand_work); - continue; - } - if (cachefiles_ondemand_object_is_reopening(object)) - continue; - return req; - } - return NULL; -} - -static inline bool cachefiles_ondemand_finish_req(struct cachefiles_req *req, - struct xa_state *xas, int err) -{ - if (unlikely(!xas || !req)) - return false; - - if (xa_cmpxchg(xas->xa, xas->xa_index, req, NULL, 0) != req) - return false; - - req->error = err; - complete(&req->done); - return true; -} - -ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache, - char __user *_buffer, size_t buflen) -{ - struct cachefiles_req *req; - struct cachefiles_msg *msg; - size_t n; - int ret = 0; - struct ondemand_anon_file anon_file; - XA_STATE(xas, &cache->reqs, cache->req_id_next); - - xa_lock(&cache->reqs); - /* - * Cyclically search for a request that has not ever been processed, - * to prevent requests from being processed repeatedly, and make - * request distribution fair. - */ - req = cachefiles_ondemand_select_req(&xas, ULONG_MAX); - if (!req && cache->req_id_next > 0) { - xas_set(&xas, 0); - req = cachefiles_ondemand_select_req(&xas, cache->req_id_next - 1); - } - if (!req) { - xa_unlock(&cache->reqs); - return 0; - } - - msg = &req->msg; - n = msg->len; - - if (n > buflen) { - xa_unlock(&cache->reqs); - return -EMSGSIZE; - } - - xas_clear_mark(&xas, CACHEFILES_REQ_NEW); - cache->req_id_next = xas.xa_index + 1; - refcount_inc(&req->ref); - cachefiles_grab_object(req->object, cachefiles_obj_get_read_req); - xa_unlock(&cache->reqs); - - if (msg->opcode == CACHEFILES_OP_OPEN) { - ret = cachefiles_ondemand_get_fd(req, &anon_file); - if (ret) - goto out; - } - - msg->msg_id = xas.xa_index; - msg->object_id = req->object->ondemand->ondemand_id; - - if (copy_to_user(_buffer, msg, n) != 0) - ret = -EFAULT; - - 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: - cachefiles_put_object(req->object, cachefiles_obj_put_read_req); - /* Remove error request and CLOSE request has no reply */ - if (ret || msg->opcode == CACHEFILES_OP_CLOSE) - cachefiles_ondemand_finish_req(req, &xas, ret); - cachefiles_req_put(req); - return ret ? ret : n; -} - -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) -{ - struct cachefiles_cache *cache = object->volume->cache; - struct cachefiles_req *req = NULL; - XA_STATE(xas, &cache->reqs, 0); - int ret; - - if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags)) - return 0; - - if (test_bit(CACHEFILES_DEAD, &cache->flags)) { - ret = -EIO; - goto out; - } - - req = kzalloc(sizeof(*req) + data_len, GFP_KERNEL); - if (!req) { - ret = -ENOMEM; - goto out; - } - - refcount_set(&req->ref, 1); - 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; - - do { - /* - * 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 - */ - xas_lock(&xas); - - if (test_bit(CACHEFILES_DEAD, &cache->flags) || - cachefiles_ondemand_object_is_dropping(object)) { - xas_unlock(&xas); - ret = -EIO; - goto out; - } - - /* coupled with the barrier in cachefiles_flush_reqs() */ - smp_mb(); - - if (opcode == CACHEFILES_OP_CLOSE && - !cachefiles_ondemand_object_is_open(object)) { - WARN_ON_ONCE(object->ondemand->ondemand_id == 0); - xas_unlock(&xas); - ret = -EIO; - goto out; - } - - /* - * Cyclically find a free xas to avoid msg_id reuse that would - * cause the daemon to successfully copen a stale msg_id. - */ - xas.xa_index = cache->msg_id_next; - xas_find_marked(&xas, UINT_MAX, XA_FREE_MARK); - if (xas.xa_node == XAS_RESTART) { - xas.xa_index = 0; - xas_find_marked(&xas, cache->msg_id_next - 1, XA_FREE_MARK); - } - if (xas.xa_node == XAS_RESTART) - xas_set_err(&xas, -EBUSY); - - xas_store(&xas, req); - if (xas_valid(&xas)) { - cache->msg_id_next = xas.xa_index + 1; - xas_clear_mark(&xas, XA_FREE_MARK); - xas_set_mark(&xas, CACHEFILES_REQ_NEW); - } - xas_unlock(&xas); - } while (xas_nomem(&xas, GFP_KERNEL)); - - ret = xas_error(&xas); - if (ret) - goto out; - - wake_up_all(&cache->daemon_pollwq); -wait: - ret = wait_for_completion_killable(&req->done); - if (!ret) { - ret = req->error; - } else { - ret = -EINTR; - if (!cachefiles_ondemand_finish_req(req, &xas, ret)) { - /* Someone will complete it soon. */ - cpu_relax(); - goto wait; - } - } - cachefiles_req_put(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_object_is_dropping(object)) - cachefiles_ondemand_set_object_close(object); - 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->cookie; - struct fscache_volume *volume = object->volume->vcookie; - struct cachefiles_open *load = (void *)req->msg.data; - size_t volume_key_size, cookie_key_size; - void *volume_key, *cookie_key; - - /* - * Volume key is a NUL-terminated string. key[0] stores strlen() of the - * string, followed by the content of the string (excluding '\0'). - */ - volume_key_size = volume->key[0] + 1; - volume_key = volume->key + 1; - - /* Cookie key is binary data, which is netfs specific. */ - cookie_key_size = cookie->key_len; - cookie_key = fscache_get_key(cookie); - - if (!(object->cookie->advice & FSCACHE_ADV_WANT_CACHE_SIZE)) { - pr_err("WANT_CACHE_SIZE is needed for on-demand mode\n"); - return -EINVAL; - } - - load->volume_key_size = volume_key_size; - load->cookie_key_size = cookie_key_size; - memcpy(load->data, volume_key, volume_key_size); - memcpy(load->data + volume_key_size, cookie_key, cookie_key_size); - - return 0; -} - -static int cachefiles_ondemand_init_close_req(struct cachefiles_req *req, - void *private) -{ - struct cachefiles_object *object = req->object; - - if (!cachefiles_ondemand_object_is_open(object)) - return -ENOENT; - - trace_cachefiles_ondemand_close(object, &req->msg); - return 0; -} - -struct cachefiles_read_ctx { - loff_t off; - size_t len; -}; - -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; - - load->off = read_ctx->off; - load->len = read_ctx->len; - trace_cachefiles_ondemand_read(object, &req->msg, load); - return 0; -} - -int cachefiles_ondemand_init_object(struct cachefiles_object *object) -{ - struct fscache_cookie *cookie = object->cookie; - struct fscache_volume *volume = object->volume->vcookie; - size_t volume_key_size, cookie_key_size, data_len; - - if (!object->ondemand) - return 0; - - /* - * 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 (cachefiles_ondemand_object_is_open(object)) - return 0; - - volume_key_size = volume->key[0] + 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); -} - -void cachefiles_ondemand_clean_object(struct cachefiles_object *object) -{ - unsigned long index; - struct cachefiles_req *req; - struct cachefiles_cache *cache; - - if (!object->ondemand) - return; - - cachefiles_ondemand_send_req(object, CACHEFILES_OP_CLOSE, 0, - cachefiles_ondemand_init_close_req, NULL); - - if (!object->ondemand->ondemand_id) - return; - - /* Cancel all requests for the object that is being dropped. */ - cache = object->volume->cache; - xa_lock(&cache->reqs); - cachefiles_ondemand_set_object_dropping(object); - xa_for_each(&cache->reqs, index, req) { - if (req->object == object) { - req->error = -EIO; - complete(&req->done); - __xa_erase(&cache->reqs, index); - } - } - xa_unlock(&cache->reqs); - - /* Wait for ondemand_object_worker() to finish to avoid UAF. */ - cancel_work_sync(&object->ondemand->ondemand_work); -} - -int cachefiles_ondemand_init_obj_info(struct cachefiles_object *object, - struct cachefiles_volume *volume) -{ - if (!cachefiles_in_ondemand_mode(volume->cache)) - return 0; - - object->ondemand = kzalloc_obj(struct cachefiles_ondemand_info); - if (!object->ondemand) - return -ENOMEM; - - object->ondemand->object = object; - spin_lock_init(&object->ondemand->lock); - INIT_WORK(&object->ondemand->ondemand_work, ondemand_object_worker); - return 0; -} - -void cachefiles_ondemand_deinit_obj_info(struct cachefiles_object *object) -{ - kfree(object->ondemand); - object->ondemand = NULL; -} - -int cachefiles_ondemand_read(struct cachefiles_object *object, - loff_t pos, size_t len) -{ - struct cachefiles_read_ctx read_ctx = {pos, len}; - - return cachefiles_ondemand_send_req(object, CACHEFILES_OP_READ, - sizeof(struct cachefiles_read), - cachefiles_ondemand_init_read_req, &read_ctx); -} diff --git a/include/linux/netfs.h b/include/linux/netfs.h index 1bc120d61c5b..297638ad9abf 100644 --- a/include/linux/netfs.h +++ b/include/linux/netfs.h @@ -191,7 +191,6 @@ struct netfs_io_subrequest { #define NETFS_SREQ_COPY_TO_CACHE 0 /* Set if should copy the data to the cache */ #define NETFS_SREQ_CLEAR_TAIL 1 /* Set if the rest of the read should be cleared */ #define NETFS_SREQ_MADE_PROGRESS 4 /* Set if we transferred at least some data */ -#define NETFS_SREQ_ONDEMAND 5 /* Set if it's from on-demand read mode */ #define NETFS_SREQ_BOUNDARY 6 /* Set if ends on hard boundary (eg. ceph object) */ #define NETFS_SREQ_HIT_EOF 7 /* Set if short due to EOF */ #define NETFS_SREQ_IN_PROGRESS 8 /* Unlocked when the subrequest completes */ @@ -373,14 +372,6 @@ struct netfs_cache_ops { loff_t *_start, size_t *_len, size_t upper_len, loff_t i_size, bool no_space_allocated_yet); - /* Prepare an on-demand read operation, shortening it to a cached/uncached - * boundary as appropriate. - */ - enum netfs_io_source (*prepare_ondemand_read)(struct netfs_cache_resources *cres, - loff_t start, size_t *_len, - loff_t i_size, - unsigned long *_flags, ino_t ino); - /* Query the occupancy of the cache in a region, returning where the * next chunk of data starts and how long it is. */ -- 2.47.3