Hi David,
This patchset is from [1], which is all fscache part related, in prep
for the newly introduced on-demand read semantics.
The previous patch 5 [2] from [1] is still under modification according
to the comments from Greg. Thus it is not included in this patchset
yet, and will be sent out later.
Whilst these four patches in this patchset are basically trivial cleanup
codes. I do appreciate if you coud give some hint on this work.
Thanks.
[1] https://lore.kernel.org/all/[email protected]/T/
[2] https://lore.kernel.org/all/[email protected]/T/#ma8898ba06bf66d815925a32d1d6689d71346e609
Jeffle Xu (4):
fscache: export fscache_end_operation()
fscache: add a method to support on-demand read semantics
cachefiles: extract generic function for daemon methods
cachefiles: detect backing file size in on-demand read mode
Documentation/filesystems/netfs_library.rst | 17 +++++
fs/cachefiles/Kconfig | 13 ++++
fs/cachefiles/daemon.c | 70 +++++++++++++--------
fs/cachefiles/internal.h | 1 +
fs/cachefiles/namei.c | 60 +++++++++++++++++-
fs/fscache/internal.h | 11 ----
fs/nfs/fscache.c | 8 ---
include/linux/fscache.h | 39 ++++++++++++
include/linux/netfs.h | 4 ++
9 files changed, 178 insertions(+), 45 deletions(-)
--
2.27.0
Export fscache_end_operation() to avoid code duplication.
Besides, considering the paired fscache_begin_read_operation() is
already exported, it shall make sense to also export
fscache_end_operation().
Signed-off-by: Jeffle Xu <[email protected]>
Reviewed-by: Liu Bo <[email protected]>
---
fs/fscache/internal.h | 11 -----------
fs/nfs/fscache.c | 8 --------
include/linux/fscache.h | 14 ++++++++++++++
3 files changed, 14 insertions(+), 19 deletions(-)
diff --git a/fs/fscache/internal.h b/fs/fscache/internal.h
index f121c21590dc..ed1c9ed737f2 100644
--- a/fs/fscache/internal.h
+++ b/fs/fscache/internal.h
@@ -70,17 +70,6 @@ static inline void fscache_see_cookie(struct fscache_cookie *cookie,
where);
}
-/*
- * io.c
- */
-static inline void fscache_end_operation(struct netfs_cache_resources *cres)
-{
- const struct netfs_cache_ops *ops = fscache_operation_valid(cres);
-
- if (ops)
- ops->end_operation(cres);
-}
-
/*
* main.c
*/
diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c
index cfe901650ab0..39654ca72d3d 100644
--- a/fs/nfs/fscache.c
+++ b/fs/nfs/fscache.c
@@ -249,14 +249,6 @@ void nfs_fscache_release_file(struct inode *inode, struct file *filp)
}
}
-static inline void fscache_end_operation(struct netfs_cache_resources *cres)
-{
- const struct netfs_cache_ops *ops = fscache_operation_valid(cres);
-
- if (ops)
- ops->end_operation(cres);
-}
-
/*
* Fallback page reading interface.
*/
diff --git a/include/linux/fscache.h b/include/linux/fscache.h
index 296c5f1d9f35..d2430da8aa67 100644
--- a/include/linux/fscache.h
+++ b/include/linux/fscache.h
@@ -456,6 +456,20 @@ int fscache_begin_read_operation(struct netfs_cache_resources *cres,
return -ENOBUFS;
}
+/**
+ * fscache_end_operation - End the read operation for the netfs lib
+ * @cres: The cache resources for the read operation
+ *
+ * Clean up the resources at the end of the read request.
+ */
+static inline void fscache_end_operation(struct netfs_cache_resources *cres)
+{
+ const struct netfs_cache_ops *ops = fscache_operation_valid(cres);
+
+ if (ops)
+ ops->end_operation(cres);
+}
+
/**
* fscache_read - Start a read from the cache.
* @cres: The cache resources to use
--
2.27.0
Add .ondemand_read() callback to netfs_cache_ops to implement on-demand
read.
The precondition for implementing on-demand read semantics is that,
all blob files have been placed under corresponding directory with
correct file size (sparse files) on the first beginning. When upper fs
starts to access the blob file, it will "cache miss" (hit the hole).
Then .ondemand_read() callback can be called to notify backend to
prepare the data.
The implementation of .ondemand_read() callback can be backend specific.
The following patch will introduce the implementation for cachefiles,
which will notify user daemon the requested file range to read. The
.ondemand_read() callback will get blocked until the user daemon has
prepared the corresponding data.
Then once .ondemand_read() callback returns with 0, it is guaranteed
that the requested data has been ready. In this case, users can retry to
read from the backing file.
Signed-off-by: Jeffle Xu <[email protected]>
---
Documentation/filesystems/netfs_library.rst | 17 ++++++++++++++
include/linux/fscache.h | 25 +++++++++++++++++++++
include/linux/netfs.h | 4 ++++
3 files changed, 46 insertions(+)
diff --git a/Documentation/filesystems/netfs_library.rst b/Documentation/filesystems/netfs_library.rst
index 4f373a8ec47b..075370d4c021 100644
--- a/Documentation/filesystems/netfs_library.rst
+++ b/Documentation/filesystems/netfs_library.rst
@@ -466,6 +466,8 @@ operation table looks like the following::
int (*query_occupancy)(struct netfs_cache_resources *cres,
loff_t start, size_t len, size_t granularity,
loff_t *_data_start, size_t *_data_len);
+ int (*ondemand_read)(struct netfs_cache_resources *cres,
+ loff_t start_pos, size_t len);
};
With a termination handler function pointer::
@@ -552,6 +554,21 @@ The methods defined in the table are:
It returns 0 if some data was found, -ENODATA if there was no usable data
within the region or -ENOBUFS if there is no caching on this file.
+ * ``ondemand_read()``
+
+ [Optional] Called to prepare cache for the requested data. It shall be called
+ only when on-demand read semantics is required. It will be called when a cache
+ miss is encountered. The function will make the backend prepare the data
+ regarding to @start_pos/@len of the cache file. It may get blocked until the
+ backend finishes getting the requested data or returns errors.
+
+ Once it returns with 0, it is guaranteed that the requested data has been
+ ready in the cache file. In this case, users can get the data with another
+ read request.
+
+ It returns 0 if data has been ready in the cache file, or other error code
+ from the cache, such as -ENOMEM.
+
Note that these methods are passed a pointer to the cache resource structure,
not the read request structure as they could be used in other situations where
there isn't a read request structure as well, such as writing dirty data to the
diff --git a/include/linux/fscache.h b/include/linux/fscache.h
index d2430da8aa67..34af865ba928 100644
--- a/include/linux/fscache.h
+++ b/include/linux/fscache.h
@@ -514,6 +514,31 @@ int fscache_read(struct netfs_cache_resources *cres,
term_func, term_func_priv);
}
+/**
+ * fscache_ondemand_read - Prepare cache for the requested data.
+ * @cres: The cache resources to use
+ * @start_pos: The beginning file offset in the cache file
+ * @len: The length of the file offset range in the cache file
+ *
+ * This shall only be called when a cache miss is encountered. It will make
+ * the backend prepare the data regarding to @start_pos/@len of the cache file.
+ * It may get blocked until the backend finishes getting the requested data or
+ * returns errors.
+ *
+ * Returns:
+ * * 0 - Success (Data is ready in the cache file)
+ * * Other error code from the cache, such as -ENOMEM.
+ */
+static inline
+int fscache_ondemand_read(struct netfs_cache_resources *cres,
+ loff_t start_pos, size_t len)
+{
+ const struct netfs_cache_ops *ops = fscache_operation_valid(cres);
+ if (ops->ondemand_read)
+ return ops->ondemand_read(cres, start_pos, len);
+ return -EOPNOTSUPP;
+}
+
/**
* fscache_begin_write_operation - Begin a write operation for the netfs lib
* @cres: The cache resources for the write being performed
diff --git a/include/linux/netfs.h b/include/linux/netfs.h
index 614f22213e21..3d5f0376a326 100644
--- a/include/linux/netfs.h
+++ b/include/linux/netfs.h
@@ -251,6 +251,10 @@ struct netfs_cache_ops {
int (*query_occupancy)(struct netfs_cache_resources *cres,
loff_t start, size_t len, size_t granularity,
loff_t *_data_start, size_t *_data_len);
+
+ /* Prepare cache for the requested data */
+ int (*ondemand_read)(struct netfs_cache_resources *cres,
+ loff_t start_pos, size_t len);
};
struct readahead_control;
--
2.27.0
Fscache/cachefiles used to serve as a local cache for remote fs. The
following patches will introduce a new use case, in which local
read-only fs could implement on-demand reading with fscache. Then in
this case, the upper read-only fs may has no idea on the size of the
backed file.
It is worth nothing that, in this scenario, user daemon is responsible
for preparing all backing files with correct file size in the first
beginning. (Backing files are all sparse files in this case). And since
it's read-only, we can get the backing file size at runtime as the
object size.
This patch also adds one flag bit to distinguish the new introduced
on-demand read mode from the original mode. The following patch will
introduce a user configures it.
Signed-off-by: Jeffle Xu <[email protected]>
---
fs/cachefiles/Kconfig | 13 +++++++++
fs/cachefiles/internal.h | 1 +
fs/cachefiles/namei.c | 60 +++++++++++++++++++++++++++++++++++++++-
3 files changed, 73 insertions(+), 1 deletion(-)
diff --git a/fs/cachefiles/Kconfig b/fs/cachefiles/Kconfig
index 719faeeda168..cef412cfd127 100644
--- a/fs/cachefiles/Kconfig
+++ b/fs/cachefiles/Kconfig
@@ -26,3 +26,16 @@ 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 reading"
+ depends on CACHEFILES
+ default n
+ help
+ This permits on-demand read mode of cachefiles. In this mode, when
+ cache miss, the cachefiles backend instead of the upper fs using
+ fscache is responsible for fetching data, e.g. through user daemon.
+ Then after the data's ready, upper fs can reinitiate a read from the
+ cache.
+
+ If unsure, say N.
diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h
index c793d33b0224..6473634c41a9 100644
--- a/fs/cachefiles/internal.h
+++ b/fs/cachefiles/internal.h
@@ -98,6 +98,7 @@ struct cachefiles_cache {
#define CACHEFILES_DEAD 1 /* T if cache dead */
#define CACHEFILES_CULLING 2 /* T if cull engaged */
#define CACHEFILES_STATE_CHANGED 3 /* T if state changed (poll trigger) */
+#define CACHEFILES_ONDEMAND_MODE 4 /* T if in on-demand read mode */
char *rootdirname; /* name of cache root directory */
char *secctx; /* LSM security context */
char *tag; /* cache binding tag */
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index f256c8aff7bb..abe75b4b955f 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -510,15 +510,69 @@ struct file *cachefiles_create_tmpfile(struct cachefiles_object *object)
return file;
}
+#ifdef CONFIG_CACHEFILES_ONDEMAND
+static inline bool cachefiles_can_create_file(struct cachefiles_cache *cache)
+{
+ /*
+ * On-demand read mode requires that backing files have been prepared
+ * with correct file size under corresponding directory in the very
+ * first begginning. We can get here when the backing file doesn't exist
+ * under corresponding directory, or the file size is unexpected 0.
+ */
+ return !test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags);
+
+}
+
+/*
+ * Fs using fscache for on-demand reading may have no idea of the file size of
+ * backing files. Thus the on-demand read mode requires that backing files shall
+ * be prepared with correct file size under corresponding directory by the user
+ * daemon in the first beginning. Then the backend is responsible for taking the
+ * file size of the backing file as the object size at runtime.
+ */
+static int cachefiles_recheck_size(struct cachefiles_object *object,
+ struct file *file)
+{
+ loff_t size;
+ struct cachefiles_cache *cache = object->volume->cache;
+
+ if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
+ return 0;
+
+ size = i_size_read(file_inode(file));
+ if (!size)
+ return -EINVAL;
+
+ object->cookie->object_size = size;
+ return 0;
+}
+#else
+static inline bool cachefiles_can_create_file(struct cachefiles_cache *cache)
+{
+ return true;
+}
+
+static inline int cachefiles_recheck_size(struct cachefiles_object *object,
+ struct file *file)
+{
+ return 0;
+}
+#endif
+
+
/*
* Create a new file.
*/
static bool cachefiles_create_file(struct cachefiles_object *object)
{
+ struct cachefiles_cache *cache = object->volume->cache;
struct file *file;
int ret;
- ret = cachefiles_has_space(object->volume->cache, 1, 0,
+ if (!cachefiles_can_create_file(cache))
+ return false;
+
+ ret = cachefiles_has_space(cache, 1, 0,
cachefiles_has_space_for_create);
if (ret < 0)
return false;
@@ -573,6 +627,10 @@ static bool cachefiles_open_file(struct cachefiles_object *object,
}
_debug("file -> %pd positive", dentry);
+ ret = cachefiles_recheck_size(object, file);
+ if (ret < 0)
+ goto check_failed;
+
ret = cachefiles_check_auxdata(object, file);
if (ret < 0)
goto check_failed;
--
2.27.0