@@ -1006,6 +1006,32 @@ int netfs_readpage(struct file *file,
}
EXPORT_SYMBOL(netfs_readpage);
+void netfs_demand_read(struct netfs_read_subrequest *subreq)
+{
+ struct netfs_read_request *rreq = subreq->rreq;
+ struct netfs_cache_resources *cres = &rreq->cache_resources;
+ loff_t start_pos;
+ size_t len;
+ int ret;
+
+ start_pos = subreq->start + subreq->transferred;
+ len = subreq->len - subreq->transferred;
+
+ /*
+ * In success case (ret == 0), user daemon has downloaded data for us,
+ * thus transform to NETFS_READ_FROM_CACHE state and advertise that 0
+ * byte readed, so that the request will enter into INCOMPLETE state and
+ * retry to read from backing file.
+ */
+ ret = cres->ops->demand_read(cres, start_pos, len);
+ if (!ret) {
+ subreq->source = NETFS_READ_FROM_CACHE;
+ __clear_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags);
+ }
+
+ netfs_subreq_terminated(subreq, ret, false);
+}
+
/*
* Prepare a folio for writing without reading first
* @folio: The folio being prepared
@@ -244,6 +244,9 @@ struct netfs_cache_ops {
int (*prepare_write)(struct netfs_cache_resources *cres,
loff_t *_start, size_t *_len, loff_t i_size,
bool no_space_allocated_yet);
+
+ int (*demand_read)(struct netfs_cache_resources *cres,
+ loff_t start_pos, size_t len);
};
struct readahead_control;
@@ -259,6 +262,7 @@ extern int netfs_write_begin(struct file *, struct address_space *,
void **,
const struct netfs_read_request_ops *,
void *);
+extern void netfs_demand_read(struct netfs_read_subrequest *);
extern void netfs_subreq_terminated(struct netfs_read_subrequest *, ssize_t, bool);
extern void netfs_stats_show(struct seq_file *);
Add demand_read() callback to netfs_cache_ops to implement demand reading. The precondition for implementing demand reading semantic is that, all blob files are sparse and have been placed under corresponding directory on the first beginning. When upper fs starts to access the blob file, it will "cache miss" (hit the hole) and then .issue_op() callback will be called to prepare the data. Then the working flow is as described below. The .issue_op() callback could be implemented by netfs_demand_read() helper, which will in turn call .demand_read() callback of corresponding fscache backend to prepare the data. The implementation of .demand_read() callback can be backend specific. The following patch will introduce an implementation of .demand_read() callback for cachefiles, which will notify user daemon the requested file range to read. The .demand_read() callback will get blocked until the user daemon has prepared the corresponding data. Then once .demand_read() callback returns with 0, it is guaranteed that the requested data has been ready. In this case, transform this IO request to NETFS_READ_FROM_CACHE state, initiate an incomplete completion and then retry to read from backing file. Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> --- fs/netfs/read_helper.c | 26 ++++++++++++++++++++++++++ include/linux/netfs.h | 4 ++++ 2 files changed, 30 insertions(+)