hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

netfs: Rename netfs_read_*request to netfs_io_*request 

Rename netfs_read_*request to netfs_io_*request so that the same structures
can be used for the write helpers too.

perl -p -i -e 's/netfs_read_(request|subrequest)/netfs_io_$1/g' \
   `git grep -l 'netfs_read_\(sub\|\)request'`
perl -p -i -e 's/nr_rd_ops/nr_outstanding/g' \
   `git grep -l nr_rd_ops`
perl -p -i -e 's/nr_wr_ops/nr_copy_ops/g' \
   `git grep -l nr_wr_ops`
perl -p -i -e 's/netfs_read_source/netfs_io_source/g' \
   `git grep -l 'netfs_read_source'`
perl -p -i -e 's/netfs_io_request_ops/netfs_request_ops/g' \
   `git grep -l 'netfs_io_request_ops'`
perl -p -i -e 's/init_rreq/init_request/g' \
   `git grep -l 'init_rreq'`

Signed-off-by: David Howells <dhowells@redhat.com>
Reviewed-by: Jeff Layton <jlayton@kernel.org>
cc: linux-cachefs@redhat.com

Link: https://lore.kernel.org/r/164622988070.3564931.7089670190434315183.stgit@warthog.procyon.org.uk/ # v1
Link: https://lore.kernel.org/r/164678195157.1200972.366609966927368090.stgit@warthog.procyon.org.uk/ # v2
Link: https://lore.kernel.org/r/164692891535.2099075.18435198075367420588.stgit@warthog.procyon.org.uk/ # v3
This commit is contained in:
David Howells 2022-02-17 10:01:23 +00:00
parent 5ac417d24c
commit 6a19114b8e
11 changed files with 177 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
Documentation/filesystems/netfs_library.rst
View File

@ -71,11 +71,11 @@ Read Helper Functions
Three read helpers are provided:: Three read helpers are provided::
void netfs_readahead(struct readahead_control *ractl, void netfs_readahead(struct readahead_control *ractl,
const struct netfs_read_request_ops *ops, const struct netfs_request_ops *ops,
void *netfs_priv); void *netfs_priv);
int netfs_readpage(struct file *file, int netfs_readpage(struct file *file,
struct folio *folio, struct folio *folio,
const struct netfs_read_request_ops *ops, const struct netfs_request_ops *ops,
void *netfs_priv); void *netfs_priv);
int netfs_write_begin(struct file *file, int netfs_write_begin(struct file *file,
struct address_space *mapping, struct address_space *mapping,
@ -84,7 +84,7 @@ Three read helpers are provided::
unsigned int flags, unsigned int flags,
struct folio **_folio, struct folio **_folio,
void **_fsdata, void **_fsdata,
const struct netfs_read_request_ops *ops, const struct netfs_request_ops *ops,
void *netfs_priv); void *netfs_priv);
Each corresponds to a VM operation, with the addition of a couple of parameters Each corresponds to a VM operation, with the addition of a couple of parameters
@ -116,7 +116,7 @@ occurs, the request will get partially completed if sufficient data is read.
Additionally, there is:: Additionally, there is::
* void netfs_subreq_terminated(struct netfs_read_subrequest *subreq, * void netfs_subreq_terminated(struct netfs_io_subrequest *subreq,
ssize_t transferred_or_error, ssize_t transferred_or_error,
bool was_async); bool was_async);
@ -132,7 +132,7 @@ Read Helper Structures
The read helpers make use of a couple of structures to maintain the state of The read helpers make use of a couple of structures to maintain the state of
the read. The first is a structure that manages a read request as a whole:: the read. The first is a structure that manages a read request as a whole::
struct netfs_read_request { struct netfs_io_request {
struct inode *inode; struct inode *inode;
struct address_space *mapping; struct address_space *mapping;
struct netfs_cache_resources cache_resources; struct netfs_cache_resources cache_resources;
@ -140,7 +140,7 @@ the read. The first is a structure that manages a read request as a whole::
loff_t start; loff_t start;
size_t len; size_t len;
loff_t i_size; loff_t i_size;
const struct netfs_read_request_ops *netfs_ops; const struct netfs_request_ops *netfs_ops;
unsigned int debug_id; unsigned int debug_id;
... ...
}; };
@ -187,8 +187,8 @@ The above fields are the ones the netfs can use. They are:
The second structure is used to manage individual slices of the overall read The second structure is used to manage individual slices of the overall read
request:: request::
struct netfs_read_subrequest { struct netfs_io_subrequest {
struct netfs_read_request *rreq; struct netfs_io_request *rreq;
loff_t start; loff_t start;
size_t len; size_t len;
size_t transferred; size_t transferred;
@ -244,23 +244,23 @@ Read Helper Operations
The network filesystem must provide the read helpers with a table of operations The network filesystem must provide the read helpers with a table of operations
through which it can issue requests and negotiate:: through which it can issue requests and negotiate::
struct netfs_read_request_ops { struct netfs_request_ops {
void (*init_rreq)(struct netfs_read_request *rreq, struct file *file); void (*init_request)(struct netfs_io_request *rreq, struct file *file);
bool (*is_cache_enabled)(struct inode *inode); bool (*is_cache_enabled)(struct inode *inode);
int (*begin_cache_operation)(struct netfs_read_request *rreq); int (*begin_cache_operation)(struct netfs_io_request *rreq);
void (*expand_readahead)(struct netfs_read_request *rreq); void (*expand_readahead)(struct netfs_io_request *rreq);
bool (*clamp_length)(struct netfs_read_subrequest *subreq); bool (*clamp_length)(struct netfs_io_subrequest *subreq);
void (*issue_op)(struct netfs_read_subrequest *subreq); void (*issue_op)(struct netfs_io_subrequest *subreq);
bool (*is_still_valid)(struct netfs_read_request *rreq); bool (*is_still_valid)(struct netfs_io_request *rreq);
int (*check_write_begin)(struct file *file, loff_t pos, unsigned len, int (*check_write_begin)(struct file *file, loff_t pos, unsigned len,
struct folio *folio, void **_fsdata); struct folio *folio, void **_fsdata);
void (*done)(struct netfs_read_request *rreq); void (*done)(struct netfs_io_request *rreq);
void (*cleanup)(struct address_space *mapping, void *netfs_priv); void (*cleanup)(struct address_space *mapping, void *netfs_priv);
}; };
The operations are as follows: The operations are as follows:
* ``init_rreq()`` * ``init_request()``
[Optional] This is called to initialise the request structure. It is given [Optional] This is called to initialise the request structure. It is given
the file for reference and can modify the ->netfs_priv value. the file for reference and can modify the ->netfs_priv value.
@ -420,12 +420,12 @@ The network filesystem's ->begin_cache_operation() method is called to set up a
cache and this must call into the cache to do the work. If using fscache, for cache and this must call into the cache to do the work. If using fscache, for
example, the cache would call:: example, the cache would call::
int fscache_begin_read_operation(struct netfs_read_request *rreq, int fscache_begin_read_operation(struct netfs_io_request *rreq,
struct fscache_cookie *cookie); struct fscache_cookie *cookie);
passing in the request pointer and the cookie corresponding to the file. passing in the request pointer and the cookie corresponding to the file.
The netfs_read_request object contains a place for the cache to hang its The netfs_io_request object contains a place for the cache to hang its
state:: state::
struct netfs_cache_resources { struct netfs_cache_resources {
@ -443,7 +443,7 @@ operation table looks like the following::
void (*expand_readahead)(struct netfs_cache_resources *cres, void (*expand_readahead)(struct netfs_cache_resources *cres,
loff_t *_start, size_t *_len, loff_t i_size); loff_t *_start, size_t *_len, loff_t i_size);
enum netfs_read_source (*prepare_read)(struct netfs_read_subrequest *subreq, enum netfs_io_source (*prepare_read)(struct netfs_io_subrequest *subreq,
loff_t i_size); loff_t i_size);
int (*read)(struct netfs_cache_resources *cres, int (*read)(struct netfs_cache_resources *cres,

16
fs/9p/vfs_addr.c
View File

@ -31,9 +31,9 @@
* v9fs_req_issue_op - Issue a read from 9P * v9fs_req_issue_op - Issue a read from 9P
* @subreq: The read to make * @subreq: The read to make
*/ */
static void v9fs_req_issue_op(struct netfs_read_subrequest *subreq) static void v9fs_req_issue_op(struct netfs_io_subrequest *subreq)
{ {
struct netfs_read_request *rreq = subreq->rreq; struct netfs_io_request *rreq = subreq->rreq;
struct p9_fid *fid = rreq->netfs_priv; struct p9_fid *fid = rreq->netfs_priv;
struct iov_iter to; struct iov_iter to;
loff_t pos = subreq->start + subreq->transferred; loff_t pos = subreq->start + subreq->transferred;
@ -52,11 +52,11 @@ static void v9fs_req_issue_op(struct netfs_read_subrequest *subreq)
} }
/** /**
* v9fs_init_rreq - Initialise a read request * v9fs_init_request - Initialise a read request
* @rreq: The read request * @rreq: The read request
* @file: The file being read from * @file: The file being read from
*/ */
static void v9fs_init_rreq(struct netfs_read_request *rreq, struct file *file) static void v9fs_init_request(struct netfs_io_request *rreq, struct file *file)
{ {
struct p9_fid *fid = file->private_data; struct p9_fid *fid = file->private_data;
@ -65,7 +65,7 @@ static void v9fs_init_rreq(struct netfs_read_request *rreq, struct file *file)
} }
/** /**
* v9fs_req_cleanup - Cleanup request initialized by v9fs_init_rreq * v9fs_req_cleanup - Cleanup request initialized by v9fs_init_request
* @mapping: unused mapping of request to cleanup * @mapping: unused mapping of request to cleanup
* @priv: private data to cleanup, a fid, guaranted non-null. * @priv: private data to cleanup, a fid, guaranted non-null.
*/ */
@ -91,7 +91,7 @@ static bool v9fs_is_cache_enabled(struct inode *inode)
* v9fs_begin_cache_operation - Begin a cache operation for a read * v9fs_begin_cache_operation - Begin a cache operation for a read
* @rreq: The read request * @rreq: The read request
*/ */
static int v9fs_begin_cache_operation(struct netfs_read_request *rreq) static int v9fs_begin_cache_operation(struct netfs_io_request *rreq)
{ {
#ifdef CONFIG_9P_FSCACHE #ifdef CONFIG_9P_FSCACHE
struct fscache_cookie *cookie = v9fs_inode_cookie(V9FS_I(rreq->inode)); struct fscache_cookie *cookie = v9fs_inode_cookie(V9FS_I(rreq->inode));
@ -102,8 +102,8 @@ static int v9fs_begin_cache_operation(struct netfs_read_request *rreq)
#endif #endif
} }
static const struct netfs_read_request_ops v9fs_req_ops = { static const struct netfs_request_ops v9fs_req_ops = {
.init_rreq = v9fs_init_rreq, .init_request = v9fs_init_request,
.is_cache_enabled = v9fs_is_cache_enabled, .is_cache_enabled = v9fs_is_cache_enabled,
.begin_cache_operation = v9fs_begin_cache_operation, .begin_cache_operation = v9fs_begin_cache_operation,
.issue_op = v9fs_req_issue_op, .issue_op = v9fs_req_issue_op,

12
fs/afs/file.c
View File

@ -240,7 +240,7 @@ void afs_put_read(struct afs_read *req)
static void afs_fetch_data_notify(struct afs_operation *op) static void afs_fetch_data_notify(struct afs_operation *op)
{ {
struct afs_read *req = op->fetch.req; struct afs_read *req = op->fetch.req;
struct netfs_read_subrequest *subreq = req->subreq; struct netfs_io_subrequest *subreq = req->subreq;
int error = op->error; int error = op->error;
if (error == -ECONNABORTED) if (error == -ECONNABORTED)
@ -310,7 +310,7 @@ int afs_fetch_data(struct afs_vnode *vnode, struct afs_read *req)
return afs_do_sync_operation(op); return afs_do_sync_operation(op);
} }
static void afs_req_issue_op(struct netfs_read_subrequest *subreq) static void afs_req_issue_op(struct netfs_io_subrequest *subreq)
{ {
struct afs_vnode *vnode = AFS_FS_I(subreq->rreq->inode); struct afs_vnode *vnode = AFS_FS_I(subreq->rreq->inode);
struct afs_read *fsreq; struct afs_read *fsreq;
@ -359,7 +359,7 @@ static int afs_symlink_readpage(struct file *file, struct page *page)
return ret; return ret;
} }
static void afs_init_rreq(struct netfs_read_request *rreq, struct file *file) static void afs_init_request(struct netfs_io_request *rreq, struct file *file)
{ {
rreq->netfs_priv = key_get(afs_file_key(file)); rreq->netfs_priv = key_get(afs_file_key(file));
} }
@ -371,7 +371,7 @@ static bool afs_is_cache_enabled(struct inode *inode)
return fscache_cookie_enabled(cookie) && cookie->cache_priv; return fscache_cookie_enabled(cookie) && cookie->cache_priv;
} }
static int afs_begin_cache_operation(struct netfs_read_request *rreq) static int afs_begin_cache_operation(struct netfs_io_request *rreq)
{ {
#ifdef CONFIG_AFS_FSCACHE #ifdef CONFIG_AFS_FSCACHE
struct afs_vnode *vnode = AFS_FS_I(rreq->inode); struct afs_vnode *vnode = AFS_FS_I(rreq->inode);
@ -396,8 +396,8 @@ static void afs_priv_cleanup(struct address_space *mapping, void *netfs_priv)
key_put(netfs_priv); key_put(netfs_priv);
} }
const struct netfs_read_request_ops afs_req_ops = { const struct netfs_request_ops afs_req_ops = {
.init_rreq = afs_init_rreq, .init_request = afs_init_request,
.is_cache_enabled = afs_is_cache_enabled, .is_cache_enabled = afs_is_cache_enabled,
.begin_cache_operation = afs_begin_cache_operation, .begin_cache_operation = afs_begin_cache_operation,
.check_write_begin = afs_check_write_begin, .check_write_begin = afs_check_write_begin,

4
fs/afs/internal.h
View File

@ -207,7 +207,7 @@ struct afs_read {
loff_t file_size; /* File size returned by server */ loff_t file_size; /* File size returned by server */
struct key *key; /* The key to use to reissue the read */ struct key *key; /* The key to use to reissue the read */
struct afs_vnode *vnode; /* The file being read into. */ struct afs_vnode *vnode; /* The file being read into. */
struct netfs_read_subrequest *subreq; /* Fscache helper read request this belongs to */ struct netfs_io_subrequest *subreq; /* Fscache helper read request this belongs to */
afs_dataversion_t data_version; /* Version number returned by server */ afs_dataversion_t data_version; /* Version number returned by server */
refcount_t usage; refcount_t usage;
unsigned int call_debug_id; unsigned int call_debug_id;
@ -1063,7 +1063,7 @@ extern const struct address_space_operations afs_file_aops;
extern const struct address_space_operations afs_symlink_aops; extern const struct address_space_operations afs_symlink_aops;
extern const struct inode_operations afs_file_inode_operations; extern const struct inode_operations afs_file_inode_operations;
extern const struct file_operations afs_file_operations; extern const struct file_operations afs_file_operations;
extern const struct netfs_read_request_ops afs_req_ops; extern const struct netfs_request_ops afs_req_ops;
extern int afs_cache_wb_key(struct afs_vnode *, struct afs_file *); extern int afs_cache_wb_key(struct afs_vnode *, struct afs_file *);
extern void afs_put_wb_key(struct afs_wb_key *); extern void afs_put_wb_key(struct afs_wb_key *);

6
fs/cachefiles/io.c
View File

@ -382,18 +382,18 @@ presubmission_error:
* Prepare a read operation, shortening it to a cached/uncached * Prepare a read operation, shortening it to a cached/uncached
* boundary as appropriate. * boundary as appropriate.
*/ */
static enum netfs_read_source cachefiles_prepare_read(struct netfs_read_subrequest *subreq, static enum netfs_io_source cachefiles_prepare_read(struct netfs_io_subrequest *subreq,
loff_t i_size) loff_t i_size)
{ {
enum cachefiles_prepare_read_trace why; enum cachefiles_prepare_read_trace why;
struct netfs_read_request *rreq = subreq->rreq; struct netfs_io_request *rreq = subreq->rreq;
struct netfs_cache_resources *cres = &rreq->cache_resources; struct netfs_cache_resources *cres = &rreq->cache_resources;
struct cachefiles_object *object; struct cachefiles_object *object;
struct cachefiles_cache *cache; struct cachefiles_cache *cache;
struct fscache_cookie *cookie = fscache_cres_cookie(cres); struct fscache_cookie *cookie = fscache_cres_cookie(cres);
const struct cred *saved_cred; const struct cred *saved_cred;
struct file *file = cachefiles_cres_file(cres); struct file *file = cachefiles_cres_file(cres);
enum netfs_read_source ret = NETFS_DOWNLOAD_FROM_SERVER; enum netfs_io_source ret = NETFS_DOWNLOAD_FROM_SERVER;
loff_t off, to; loff_t off, to;
ino_t ino = file ? file_inode(file)->i_ino : 0; ino_t ino = file ? file_inode(file)->i_ino : 0;

16
fs/ceph/addr.c
View File

@ -183,7 +183,7 @@ static int ceph_releasepage(struct page *page, gfp_t gfp)
return 1; return 1;
} }
static void ceph_netfs_expand_readahead(struct netfs_read_request *rreq) static void ceph_netfs_expand_readahead(struct netfs_io_request *rreq)
{ {
struct inode *inode = rreq->inode; struct inode *inode = rreq->inode;
struct ceph_inode_info *ci = ceph_inode(inode); struct ceph_inode_info *ci = ceph_inode(inode);
@ -200,7 +200,7 @@ static void ceph_netfs_expand_readahead(struct netfs_read_request *rreq)
rreq->len = roundup(rreq->len, lo->stripe_unit); rreq->len = roundup(rreq->len, lo->stripe_unit);
} }
static bool ceph_netfs_clamp_length(struct netfs_read_subrequest *subreq) static bool ceph_netfs_clamp_length(struct netfs_io_subrequest *subreq)
{ {
struct inode *inode = subreq->rreq->inode; struct inode *inode = subreq->rreq->inode;
struct ceph_fs_client *fsc = ceph_inode_to_client(inode); struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
@ -219,7 +219,7 @@ static void finish_netfs_read(struct ceph_osd_request *req)
{ {
struct ceph_fs_client *fsc = ceph_inode_to_client(req->r_inode); struct ceph_fs_client *fsc = ceph_inode_to_client(req->r_inode);
struct ceph_osd_data *osd_data = osd_req_op_extent_osd_data(req, 0); struct ceph_osd_data *osd_data = osd_req_op_extent_osd_data(req, 0);
struct netfs_read_subrequest *subreq = req->r_priv; struct netfs_io_subrequest *subreq = req->r_priv;
int num_pages; int num_pages;
int err = req->r_result; int err = req->r_result;
@ -245,9 +245,9 @@ static void finish_netfs_read(struct ceph_osd_request *req)
iput(req->r_inode); iput(req->r_inode);
} }
static bool ceph_netfs_issue_op_inline(struct netfs_read_subrequest *subreq) static bool ceph_netfs_issue_op_inline(struct netfs_io_subrequest *subreq)
{ {
struct netfs_read_request *rreq = subreq->rreq; struct netfs_io_request *rreq = subreq->rreq;
struct inode *inode = rreq->inode; struct inode *inode = rreq->inode;
struct ceph_mds_reply_info_parsed *rinfo; struct ceph_mds_reply_info_parsed *rinfo;
struct ceph_mds_reply_info_in *iinfo; struct ceph_mds_reply_info_in *iinfo;
@ -298,9 +298,9 @@ out:
return true; return true;
} }
static void ceph_netfs_issue_op(struct netfs_read_subrequest *subreq) static void ceph_netfs_issue_op(struct netfs_io_subrequest *subreq)
{ {
struct netfs_read_request *rreq = subreq->rreq; struct netfs_io_request *rreq = subreq->rreq;
struct inode *inode = rreq->inode; struct inode *inode = rreq->inode;
struct ceph_inode_info *ci = ceph_inode(inode); struct ceph_inode_info *ci = ceph_inode(inode);
struct ceph_fs_client *fsc = ceph_inode_to_client(inode); struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
@ -364,7 +364,7 @@ static void ceph_readahead_cleanup(struct address_space *mapping, void *priv)
ceph_put_cap_refs(ci, got); ceph_put_cap_refs(ci, got);
} }
static const struct netfs_read_request_ops ceph_netfs_read_ops = { static const struct netfs_request_ops ceph_netfs_read_ops = {
.is_cache_enabled = ceph_is_cache_enabled, .is_cache_enabled = ceph_is_cache_enabled,
.begin_cache_operation = ceph_begin_cache_operation, .begin_cache_operation = ceph_begin_cache_operation,
.issue_op = ceph_netfs_issue_op, .issue_op = ceph_netfs_issue_op,

4
fs/ceph/cache.h
View File

@ -62,7 +62,7 @@ static inline int ceph_fscache_set_page_dirty(struct page *page)
return fscache_set_page_dirty(page, ceph_fscache_cookie(ci)); return fscache_set_page_dirty(page, ceph_fscache_cookie(ci));
} }
static inline int ceph_begin_cache_operation(struct netfs_read_request *rreq) static inline int ceph_begin_cache_operation(struct netfs_io_request *rreq)
{ {
struct fscache_cookie *cookie = ceph_fscache_cookie(ceph_inode(rreq->inode)); struct fscache_cookie *cookie = ceph_fscache_cookie(ceph_inode(rreq->inode));
@ -143,7 +143,7 @@ static inline bool ceph_is_cache_enabled(struct inode *inode)
return false; return false;
} }
static inline int ceph_begin_cache_operation(struct netfs_read_request *rreq) static inline int ceph_begin_cache_operation(struct netfs_io_request *rreq)
{ {
return -ENOBUFS; return -ENOBUFS;
} }

194
fs/netfs/read_helper.c
View File

@ -28,23 +28,23 @@ module_param_named(debug, netfs_debug, uint, S_IWUSR | S_IRUGO);
MODULE_PARM_DESC(netfs_debug, "Netfs support debugging mask"); MODULE_PARM_DESC(netfs_debug, "Netfs support debugging mask");
static void netfs_rreq_work(struct work_struct *); static void netfs_rreq_work(struct work_struct *);
static void __netfs_put_subrequest(struct netfs_read_subrequest *, bool); static void __netfs_put_subrequest(struct netfs_io_subrequest *, bool);
static void netfs_put_subrequest(struct netfs_read_subrequest *subreq, static void netfs_put_subrequest(struct netfs_io_subrequest *subreq,
bool was_async) bool was_async)
{ {
if (refcount_dec_and_test(&subreq->usage)) if (refcount_dec_and_test(&subreq->usage))
__netfs_put_subrequest(subreq, was_async); __netfs_put_subrequest(subreq, was_async);
} }
static struct netfs_read_request *netfs_alloc_read_request( static struct netfs_io_request *netfs_alloc_read_request(
const struct netfs_read_request_ops *ops, void *netfs_priv, const struct netfs_request_ops *ops, void *netfs_priv,
struct file *file) struct file *file)
{ {
static atomic_t debug_ids; static atomic_t debug_ids;
struct netfs_read_request *rreq; struct netfs_io_request *rreq;
rreq = kzalloc(sizeof(struct netfs_read_request), GFP_KERNEL); rreq = kzalloc(sizeof(struct netfs_io_request), GFP_KERNEL);
if (rreq) { if (rreq) {
rreq->netfs_ops = ops; rreq->netfs_ops = ops;
rreq->netfs_priv = netfs_priv; rreq->netfs_priv = netfs_priv;
@ -55,27 +55,27 @@ static struct netfs_read_request *netfs_alloc_read_request(
INIT_WORK(&rreq->work, netfs_rreq_work); INIT_WORK(&rreq->work, netfs_rreq_work);
refcount_set(&rreq->usage, 1); refcount_set(&rreq->usage, 1);
__set_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags); __set_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags);
if (ops->init_rreq) if (ops->init_request)
ops->init_rreq(rreq, file); ops->init_request(rreq, file);
netfs_stat(&netfs_n_rh_rreq); netfs_stat(&netfs_n_rh_rreq);
} }
return rreq; return rreq;
} }
static void netfs_get_read_request(struct netfs_read_request *rreq) static void netfs_get_read_request(struct netfs_io_request *rreq)
{ {
refcount_inc(&rreq->usage); refcount_inc(&rreq->usage);
} }
static void netfs_rreq_clear_subreqs(struct netfs_read_request *rreq, static void netfs_rreq_clear_subreqs(struct netfs_io_request *rreq,
bool was_async) bool was_async)
{ {
struct netfs_read_subrequest *subreq; struct netfs_io_subrequest *subreq;
while (!list_empty(&rreq->subrequests)) { while (!list_empty(&rreq->subrequests)) {
subreq = list_first_entry(&rreq->subrequests, subreq = list_first_entry(&rreq->subrequests,
struct netfs_read_subrequest, rreq_link); struct netfs_io_subrequest, rreq_link);
list_del(&subreq->rreq_link); list_del(&subreq->rreq_link);
netfs_put_subrequest(subreq, was_async); netfs_put_subrequest(subreq, was_async);
} }
@ -83,8 +83,8 @@ static void netfs_rreq_clear_subreqs(struct netfs_read_request *rreq,
static void netfs_free_read_request(struct work_struct *work) static void netfs_free_read_request(struct work_struct *work)
{ {
struct netfs_read_request *rreq = struct netfs_io_request *rreq =
container_of(work, struct netfs_read_request, work); container_of(work, struct netfs_io_request, work);
netfs_rreq_clear_subreqs(rreq, false); netfs_rreq_clear_subreqs(rreq, false);
if (rreq->netfs_priv) if (rreq->netfs_priv)
rreq->netfs_ops->cleanup(rreq->mapping, rreq->netfs_priv); rreq->netfs_ops->cleanup(rreq->mapping, rreq->netfs_priv);
@ -95,7 +95,7 @@ static void netfs_free_read_request(struct work_struct *work)
netfs_stat_d(&netfs_n_rh_rreq); netfs_stat_d(&netfs_n_rh_rreq);
} }
static void netfs_put_read_request(struct netfs_read_request *rreq, bool was_async) static void netfs_put_read_request(struct netfs_io_request *rreq, bool was_async)
{ {
if (refcount_dec_and_test(&rreq->usage)) { if (refcount_dec_and_test(&rreq->usage)) {
if (was_async) { if (was_async) {
@ -111,12 +111,12 @@ static void netfs_put_read_request(struct netfs_read_request *rreq, bool was_asy
/* /*
* Allocate and partially initialise an I/O request structure. * Allocate and partially initialise an I/O request structure.
*/ */
static struct netfs_read_subrequest *netfs_alloc_subrequest( static struct netfs_io_subrequest *netfs_alloc_subrequest(
struct netfs_read_request *rreq) struct netfs_io_request *rreq)
{ {
struct netfs_read_subrequest *subreq; struct netfs_io_subrequest *subreq;
subreq = kzalloc(sizeof(struct netfs_read_subrequest), GFP_KERNEL); subreq = kzalloc(sizeof(struct netfs_io_subrequest), GFP_KERNEL);
if (subreq) { if (subreq) {
INIT_LIST_HEAD(&subreq->rreq_link); INIT_LIST_HEAD(&subreq->rreq_link);
refcount_set(&subreq->usage, 2); refcount_set(&subreq->usage, 2);
@ -128,15 +128,15 @@ static struct netfs_read_subrequest *netfs_alloc_subrequest(
return subreq; return subreq;
} }
static void netfs_get_read_subrequest(struct netfs_read_subrequest *subreq) static void netfs_get_read_subrequest(struct netfs_io_subrequest *subreq)
{ {
refcount_inc(&subreq->usage); refcount_inc(&subreq->usage);
} }
static void __netfs_put_subrequest(struct netfs_read_subrequest *subreq, static void __netfs_put_subrequest(struct netfs_io_subrequest *subreq,
bool was_async) bool was_async)
{ {
struct netfs_read_request *rreq = subreq->rreq; struct netfs_io_request *rreq = subreq->rreq;
trace_netfs_sreq(subreq, netfs_sreq_trace_free); trace_netfs_sreq(subreq, netfs_sreq_trace_free);
kfree(subreq); kfree(subreq);
@ -147,7 +147,7 @@ static void __netfs_put_subrequest(struct netfs_read_subrequest *subreq,
/* /*
* Clear the unread part of an I/O request. * Clear the unread part of an I/O request.
*/ */
static void netfs_clear_unread(struct netfs_read_subrequest *subreq) static void netfs_clear_unread(struct netfs_io_subrequest *subreq)
{ {
struct iov_iter iter; struct iov_iter iter;
@ -160,7 +160,7 @@ static void netfs_clear_unread(struct netfs_read_subrequest *subreq)
static void netfs_cache_read_terminated(void *priv, ssize_t transferred_or_error, static void netfs_cache_read_terminated(void *priv, ssize_t transferred_or_error,
bool was_async) bool was_async)
{ {
struct netfs_read_subrequest *subreq = priv; struct netfs_io_subrequest *subreq = priv;
netfs_subreq_terminated(subreq, transferred_or_error, was_async); netfs_subreq_terminated(subreq, transferred_or_error, was_async);
} }
@ -169,8 +169,8 @@ static void netfs_cache_read_terminated(void *priv, ssize_t transferred_or_error
* Issue a read against the cache. * Issue a read against the cache.
* - Eats the caller's ref on subreq. * - Eats the caller's ref on subreq.
*/ */
static void netfs_read_from_cache(struct netfs_read_request *rreq, static void netfs_read_from_cache(struct netfs_io_request *rreq,
struct netfs_read_subrequest *subreq, struct netfs_io_subrequest *subreq,
enum netfs_read_from_hole read_hole) enum netfs_read_from_hole read_hole)
{ {
struct netfs_cache_resources *cres = &rreq->cache_resources; struct netfs_cache_resources *cres = &rreq->cache_resources;
@ -188,8 +188,8 @@ static void netfs_read_from_cache(struct netfs_read_request *rreq,
/* /*
* Fill a subrequest region with zeroes. * Fill a subrequest region with zeroes.
*/ */
static void netfs_fill_with_zeroes(struct netfs_read_request *rreq, static void netfs_fill_with_zeroes(struct netfs_io_request *rreq,
struct netfs_read_subrequest *subreq) struct netfs_io_subrequest *subreq)
{ {
netfs_stat(&netfs_n_rh_zero); netfs_stat(&netfs_n_rh_zero);
__set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags); __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
@ -212,8 +212,8 @@ static void netfs_fill_with_zeroes(struct netfs_read_request *rreq,
* - NETFS_SREQ_CLEAR_TAIL: A short read - the rest of the buffer will be * - NETFS_SREQ_CLEAR_TAIL: A short read - the rest of the buffer will be
* cleared. * cleared.
*/ */
static void netfs_read_from_server(struct netfs_read_request *rreq, static void netfs_read_from_server(struct netfs_io_request *rreq,
struct netfs_read_subrequest *subreq) struct netfs_io_subrequest *subreq)
{ {
netfs_stat(&netfs_n_rh_download); netfs_stat(&netfs_n_rh_download);
rreq->netfs_ops->issue_op(subreq); rreq->netfs_ops->issue_op(subreq);
@ -222,7 +222,7 @@ static void netfs_read_from_server(struct netfs_read_request *rreq,
/* /*
* Release those waiting. * Release those waiting.
*/ */
static void netfs_rreq_completed(struct netfs_read_request *rreq, bool was_async) static void netfs_rreq_completed(struct netfs_io_request *rreq, bool was_async)
{ {
trace_netfs_rreq(rreq, netfs_rreq_trace_done); trace_netfs_rreq(rreq, netfs_rreq_trace_done);
netfs_rreq_clear_subreqs(rreq, was_async); netfs_rreq_clear_subreqs(rreq, was_async);
@ -235,10 +235,10 @@ static void netfs_rreq_completed(struct netfs_read_request *rreq, bool was_async
* *
* May be called in softirq mode and we inherit a ref from the caller. * May be called in softirq mode and we inherit a ref from the caller.
*/ */
static void netfs_rreq_unmark_after_write(struct netfs_read_request *rreq, static void netfs_rreq_unmark_after_write(struct netfs_io_request *rreq,
bool was_async) bool was_async)
{ {
struct netfs_read_subrequest *subreq; struct netfs_io_subrequest *subreq;
struct folio *folio; struct folio *folio;
pgoff_t unlocked = 0; pgoff_t unlocked = 0;
bool have_unlocked = false; bool have_unlocked = false;
@ -267,8 +267,8 @@ static void netfs_rreq_unmark_after_write(struct netfs_read_request *rreq,
static void netfs_rreq_copy_terminated(void *priv, ssize_t transferred_or_error, static void netfs_rreq_copy_terminated(void *priv, ssize_t transferred_or_error,
bool was_async) bool was_async)
{ {
struct netfs_read_subrequest *subreq = priv; struct netfs_io_subrequest *subreq = priv;
struct netfs_read_request *rreq = subreq->rreq; struct netfs_io_request *rreq = subreq->rreq;
if (IS_ERR_VALUE(transferred_or_error)) { if (IS_ERR_VALUE(transferred_or_error)) {
netfs_stat(&netfs_n_rh_write_failed); netfs_stat(&netfs_n_rh_write_failed);
@ -280,8 +280,8 @@ static void netfs_rreq_copy_terminated(void *priv, ssize_t transferred_or_error,
trace_netfs_sreq(subreq, netfs_sreq_trace_write_term); trace_netfs_sreq(subreq, netfs_sreq_trace_write_term);
/* If we decrement nr_wr_ops to 0, the ref belongs to us. */ /* If we decrement nr_copy_ops to 0, the ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_wr_ops)) if (atomic_dec_and_test(&rreq->nr_copy_ops))
netfs_rreq_unmark_after_write(rreq, was_async); netfs_rreq_unmark_after_write(rreq, was_async);
netfs_put_subrequest(subreq, was_async); netfs_put_subrequest(subreq, was_async);
@ -291,10 +291,10 @@ static void netfs_rreq_copy_terminated(void *priv, ssize_t transferred_or_error,
* Perform any outstanding writes to the cache. We inherit a ref from the * Perform any outstanding writes to the cache. We inherit a ref from the
* caller. * caller.
*/ */
static void netfs_rreq_do_write_to_cache(struct netfs_read_request *rreq) static void netfs_rreq_do_write_to_cache(struct netfs_io_request *rreq)
{ {
struct netfs_cache_resources *cres = &rreq->cache_resources; struct netfs_cache_resources *cres = &rreq->cache_resources;
struct netfs_read_subrequest *subreq, *next, *p; struct netfs_io_subrequest *subreq, *next, *p;
struct iov_iter iter; struct iov_iter iter;
int ret; int ret;
@ -303,7 +303,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_read_request *rreq)
/* We don't want terminating writes trying to wake us up whilst we're /* We don't want terminating writes trying to wake us up whilst we're
* still going through the list. * still going through the list.
*/ */
atomic_inc(&rreq->nr_wr_ops); atomic_inc(&rreq->nr_copy_ops);
list_for_each_entry_safe(subreq, p, &rreq->subrequests, rreq_link) { list_for_each_entry_safe(subreq, p, &rreq->subrequests, rreq_link) {
if (!test_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags)) { if (!test_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags)) {
@ -334,7 +334,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_read_request *rreq)
iov_iter_xarray(&iter, WRITE, &rreq->mapping->i_pages, iov_iter_xarray(&iter, WRITE, &rreq->mapping->i_pages,
subreq->start, subreq->len); subreq->start, subreq->len);
atomic_inc(&rreq->nr_wr_ops); atomic_inc(&rreq->nr_copy_ops);
netfs_stat(&netfs_n_rh_write); netfs_stat(&netfs_n_rh_write);
netfs_get_read_subrequest(subreq); netfs_get_read_subrequest(subreq);
trace_netfs_sreq(subreq, netfs_sreq_trace_write); trace_netfs_sreq(subreq, netfs_sreq_trace_write);
@ -342,20 +342,20 @@ static void netfs_rreq_do_write_to_cache(struct netfs_read_request *rreq)
netfs_rreq_copy_terminated, subreq); netfs_rreq_copy_terminated, subreq);
} }
/* If we decrement nr_wr_ops to 0, the usage ref belongs to us. */ /* If we decrement nr_copy_ops to 0, the usage ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_wr_ops)) if (atomic_dec_and_test(&rreq->nr_copy_ops))
netfs_rreq_unmark_after_write(rreq, false); netfs_rreq_unmark_after_write(rreq, false);
} }
static void netfs_rreq_write_to_cache_work(struct work_struct *work) static void netfs_rreq_write_to_cache_work(struct work_struct *work)
{ {
struct netfs_read_request *rreq = struct netfs_io_request *rreq =
container_of(work, struct netfs_read_request, work); container_of(work, struct netfs_io_request, work);
netfs_rreq_do_write_to_cache(rreq); netfs_rreq_do_write_to_cache(rreq);
} }
static void netfs_rreq_write_to_cache(struct netfs_read_request *rreq) static void netfs_rreq_write_to_cache(struct netfs_io_request *rreq)
{ {
rreq->work.func = netfs_rreq_write_to_cache_work; rreq->work.func = netfs_rreq_write_to_cache_work;
if (!queue_work(system_unbound_wq, &rreq->work)) if (!queue_work(system_unbound_wq, &rreq->work))
@ -366,9 +366,9 @@ static void netfs_rreq_write_to_cache(struct netfs_read_request *rreq)
* Unlock the folios in a read operation. We need to set PG_fscache on any * Unlock the folios in a read operation. We need to set PG_fscache on any
* folios we're going to write back before we unlock them. * folios we're going to write back before we unlock them.
*/ */
static void netfs_rreq_unlock(struct netfs_read_request *rreq) static void netfs_rreq_unlock(struct netfs_io_request *rreq)
{ {
struct netfs_read_subrequest *subreq; struct netfs_io_subrequest *subreq;
struct folio *folio; struct folio *folio;
unsigned int iopos, account = 0; unsigned int iopos, account = 0;
pgoff_t start_page = rreq->start / PAGE_SIZE; pgoff_t start_page = rreq->start / PAGE_SIZE;
@ -391,7 +391,7 @@ static void netfs_rreq_unlock(struct netfs_read_request *rreq)
* mixture inside. * mixture inside.
*/ */
subreq = list_first_entry(&rreq->subrequests, subreq = list_first_entry(&rreq->subrequests,
struct netfs_read_subrequest, rreq_link); struct netfs_io_subrequest, rreq_link);
iopos = 0; iopos = 0;
subreq_failed = (subreq->error < 0); subreq_failed = (subreq->error < 0);
@ -450,8 +450,8 @@ static void netfs_rreq_unlock(struct netfs_read_request *rreq)
/* /*
* Handle a short read. * Handle a short read.
*/ */
static void netfs_rreq_short_read(struct netfs_read_request *rreq, static void netfs_rreq_short_read(struct netfs_io_request *rreq,
struct netfs_read_subrequest *subreq) struct netfs_io_subrequest *subreq)
{ {
__clear_bit(NETFS_SREQ_SHORT_READ, &subreq->flags); __clear_bit(NETFS_SREQ_SHORT_READ, &subreq->flags);
__set_bit(NETFS_SREQ_SEEK_DATA_READ, &subreq->flags); __set_bit(NETFS_SREQ_SEEK_DATA_READ, &subreq->flags);
@ -460,7 +460,7 @@ static void netfs_rreq_short_read(struct netfs_read_request *rreq,
trace_netfs_sreq(subreq, netfs_sreq_trace_resubmit_short); trace_netfs_sreq(subreq, netfs_sreq_trace_resubmit_short);
netfs_get_read_subrequest(subreq); netfs_get_read_subrequest(subreq);
atomic_inc(&rreq->nr_rd_ops); atomic_inc(&rreq->nr_outstanding);
if (subreq->source == NETFS_READ_FROM_CACHE) if (subreq->source == NETFS_READ_FROM_CACHE)
netfs_read_from_cache(rreq, subreq, NETFS_READ_HOLE_CLEAR); netfs_read_from_cache(rreq, subreq, NETFS_READ_HOLE_CLEAR);
else else
@ -471,9 +471,9 @@ static void netfs_rreq_short_read(struct netfs_read_request *rreq,
* Resubmit any short or failed operations. Returns true if we got the rreq * Resubmit any short or failed operations. Returns true if we got the rreq
* ref back. * ref back.
*/ */
static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq) static bool netfs_rreq_perform_resubmissions(struct netfs_io_request *rreq)
{ {
struct netfs_read_subrequest *subreq; struct netfs_io_subrequest *subreq;
WARN_ON(in_interrupt()); WARN_ON(in_interrupt());
@ -482,7 +482,7 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq)
/* We don't want terminating submissions trying to wake us up whilst /* We don't want terminating submissions trying to wake us up whilst
* we're still going through the list. * we're still going through the list.
*/ */
atomic_inc(&rreq->nr_rd_ops); atomic_inc(&rreq->nr_outstanding);
__clear_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags); __clear_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags);
list_for_each_entry(subreq, &rreq->subrequests, rreq_link) { list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
@ -494,27 +494,27 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq)
netfs_stat(&netfs_n_rh_download_instead); netfs_stat(&netfs_n_rh_download_instead);
trace_netfs_sreq(subreq, netfs_sreq_trace_download_instead); trace_netfs_sreq(subreq, netfs_sreq_trace_download_instead);
netfs_get_read_subrequest(subreq); netfs_get_read_subrequest(subreq);
atomic_inc(&rreq->nr_rd_ops); atomic_inc(&rreq->nr_outstanding);
netfs_read_from_server(rreq, subreq); netfs_read_from_server(rreq, subreq);
} else if (test_bit(NETFS_SREQ_SHORT_READ, &subreq->flags)) { } else if (test_bit(NETFS_SREQ_SHORT_READ, &subreq->flags)) {
netfs_rreq_short_read(rreq, subreq); netfs_rreq_short_read(rreq, subreq);
} }
} }
/* If we decrement nr_rd_ops to 0, the usage ref belongs to us. */ /* If we decrement nr_outstanding to 0, the usage ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_rd_ops)) if (atomic_dec_and_test(&rreq->nr_outstanding))
return true; return true;
wake_up_var(&rreq->nr_rd_ops); wake_up_var(&rreq->nr_outstanding);
return false; return false;
} }
/* /*
* Check to see if the data read is still valid. * Check to see if the data read is still valid.
*/ */
static void netfs_rreq_is_still_valid(struct netfs_read_request *rreq) static void netfs_rreq_is_still_valid(struct netfs_io_request *rreq)
{ {
struct netfs_read_subrequest *subreq; struct netfs_io_subrequest *subreq;
if (!rreq->netfs_ops->is_still_valid || if (!rreq->netfs_ops->is_still_valid ||
rreq->netfs_ops->is_still_valid(rreq)) rreq->netfs_ops->is_still_valid(rreq))
@ -534,7 +534,7 @@ static void netfs_rreq_is_still_valid(struct netfs_read_request *rreq)
* Note that we could be in an ordinary kernel thread, on a workqueue or in * Note that we could be in an ordinary kernel thread, on a workqueue or in
* softirq context at this point. We inherit a ref from the caller. * softirq context at this point. We inherit a ref from the caller.
*/ */
static void netfs_rreq_assess(struct netfs_read_request *rreq, bool was_async) static void netfs_rreq_assess(struct netfs_io_request *rreq, bool was_async)
{ {
trace_netfs_rreq(rreq, netfs_rreq_trace_assess); trace_netfs_rreq(rreq, netfs_rreq_trace_assess);
@ -561,8 +561,8 @@ again:
static void netfs_rreq_work(struct work_struct *work) static void netfs_rreq_work(struct work_struct *work)
{ {
struct netfs_read_request *rreq = struct netfs_io_request *rreq =
container_of(work, struct netfs_read_request, work); container_of(work, struct netfs_io_request, work);
netfs_rreq_assess(rreq, false); netfs_rreq_assess(rreq, false);
} }
@ -570,7 +570,7 @@ static void netfs_rreq_work(struct work_struct *work)
* Handle the completion of all outstanding I/O operations on a read request. * Handle the completion of all outstanding I/O operations on a read request.
* We inherit a ref from the caller. * We inherit a ref from the caller.
*/ */
static void netfs_rreq_terminated(struct netfs_read_request *rreq, static void netfs_rreq_terminated(struct netfs_io_request *rreq,
bool was_async) bool was_async)
{ {
if (test_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags) && if (test_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags) &&
@ -600,11 +600,11 @@ static void netfs_rreq_terminated(struct netfs_read_request *rreq,
* If @was_async is true, the caller might be running in softirq or interrupt * If @was_async is true, the caller might be running in softirq or interrupt
* context and we can't sleep. * context and we can't sleep.
*/ */
void netfs_subreq_terminated(struct netfs_read_subrequest *subreq, void netfs_subreq_terminated(struct netfs_io_subrequest *subreq,
ssize_t transferred_or_error, ssize_t transferred_or_error,
bool was_async) bool was_async)
{ {
struct netfs_read_request *rreq = subreq->rreq; struct netfs_io_request *rreq = subreq->rreq;
int u; int u;
_enter("[%u]{%llx,%lx},%zd", _enter("[%u]{%llx,%lx},%zd",
@ -648,12 +648,12 @@ complete:
out: out:
trace_netfs_sreq(subreq, netfs_sreq_trace_terminated); trace_netfs_sreq(subreq, netfs_sreq_trace_terminated);
/* If we decrement nr_rd_ops to 0, the ref belongs to us. */ /* If we decrement nr_outstanding to 0, the ref belongs to us. */
u = atomic_dec_return(&rreq->nr_rd_ops); u = atomic_dec_return(&rreq->nr_outstanding);
if (u == 0) if (u == 0)
netfs_rreq_terminated(rreq, was_async); netfs_rreq_terminated(rreq, was_async);
else if (u == 1) else if (u == 1)
wake_up_var(&rreq->nr_rd_ops); wake_up_var(&rreq->nr_outstanding);
netfs_put_subrequest(subreq, was_async); netfs_put_subrequest(subreq, was_async);
return; return;
@ -691,10 +691,10 @@ failed:
} }
EXPORT_SYMBOL(netfs_subreq_terminated); EXPORT_SYMBOL(netfs_subreq_terminated);
static enum netfs_read_source netfs_cache_prepare_read(struct netfs_read_subrequest *subreq, static enum netfs_io_source netfs_cache_prepare_read(struct netfs_io_subrequest *subreq,
loff_t i_size) loff_t i_size)
{ {
struct netfs_read_request *rreq = subreq->rreq; struct netfs_io_request *rreq = subreq->rreq;
struct netfs_cache_resources *cres = &rreq->cache_resources; struct netfs_cache_resources *cres = &rreq->cache_resources;
if (cres->ops) if (cres->ops)
@ -707,11 +707,11 @@ static enum netfs_read_source netfs_cache_prepare_read(struct netfs_read_subrequ
/* /*
* Work out what sort of subrequest the next one will be. * Work out what sort of subrequest the next one will be.
*/ */
static enum netfs_read_source static enum netfs_io_source
netfs_rreq_prepare_read(struct netfs_read_request *rreq, netfs_rreq_prepare_read(struct netfs_io_request *rreq,
struct netfs_read_subrequest *subreq) struct netfs_io_subrequest *subreq)
{ {
enum netfs_read_source source; enum netfs_io_source source;
_enter("%llx-%llx,%llx", subreq->start, subreq->start + subreq->len, rreq->i_size); _enter("%llx-%llx,%llx", subreq->start, subreq->start + subreq->len, rreq->i_size);
@ -748,11 +748,11 @@ out:
/* /*
* Slice off a piece of a read request and submit an I/O request for it. * Slice off a piece of a read request and submit an I/O request for it.
*/ */
static bool netfs_rreq_submit_slice(struct netfs_read_request *rreq, static bool netfs_rreq_submit_slice(struct netfs_io_request *rreq,
unsigned int *_debug_index) unsigned int *_debug_index)
{ {
struct netfs_read_subrequest *subreq; struct netfs_io_subrequest *subreq;
enum netfs_read_source source; enum netfs_io_source source;
subreq = netfs_alloc_subrequest(rreq); subreq = netfs_alloc_subrequest(rreq);
if (!subreq) if (!subreq)
@ -777,7 +777,7 @@ static bool netfs_rreq_submit_slice(struct netfs_read_request *rreq,
if (source == NETFS_INVALID_READ) if (source == NETFS_INVALID_READ)
goto subreq_failed; goto subreq_failed;
atomic_inc(&rreq->nr_rd_ops); atomic_inc(&rreq->nr_outstanding);
rreq->submitted += subreq->len; rreq->submitted += subreq->len;
@ -804,7 +804,7 @@ subreq_failed:
return false; return false;
} }
static void netfs_cache_expand_readahead(struct netfs_read_request *rreq, static void netfs_cache_expand_readahead(struct netfs_io_request *rreq,
loff_t *_start, size_t *_len, loff_t i_size) loff_t *_start, size_t *_len, loff_t i_size)
{ {
struct netfs_cache_resources *cres = &rreq->cache_resources; struct netfs_cache_resources *cres = &rreq->cache_resources;
@ -813,7 +813,7 @@ static void netfs_cache_expand_readahead(struct netfs_read_request *rreq,
cres->ops->expand_readahead(cres, _start, _len, i_size); cres->ops->expand_readahead(cres, _start, _len, i_size);
} }
static void netfs_rreq_expand(struct netfs_read_request *rreq, static void netfs_rreq_expand(struct netfs_io_request *rreq,
struct readahead_control *ractl) struct readahead_control *ractl)
{ {
/* Give the cache a chance to change the request parameters. The /* Give the cache a chance to change the request parameters. The
@ -866,10 +866,10 @@ static void netfs_rreq_expand(struct netfs_read_request *rreq,
* This is usable whether or not caching is enabled. * This is usable whether or not caching is enabled.
*/ */
void netfs_readahead(struct readahead_control *ractl, void netfs_readahead(struct readahead_control *ractl,
const struct netfs_read_request_ops *ops, const struct netfs_request_ops *ops,
void *netfs_priv) void *netfs_priv)
{ {
struct netfs_read_request *rreq; struct netfs_io_request *rreq;
unsigned int debug_index = 0; unsigned int debug_index = 0;
int ret; int ret;
@ -897,7 +897,7 @@ void netfs_readahead(struct readahead_control *ractl,
netfs_rreq_expand(rreq, ractl); netfs_rreq_expand(rreq, ractl);
atomic_set(&rreq->nr_rd_ops, 1); atomic_set(&rreq->nr_outstanding, 1);
do { do {
if (!netfs_rreq_submit_slice(rreq, &debug_index)) if (!netfs_rreq_submit_slice(rreq, &debug_index))
break; break;
@ -910,8 +910,8 @@ void netfs_readahead(struct readahead_control *ractl,
while (readahead_folio(ractl)) while (readahead_folio(ractl))
; ;
/* If we decrement nr_rd_ops to 0, the ref belongs to us. */ /* If we decrement nr_outstanding to 0, the ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_rd_ops)) if (atomic_dec_and_test(&rreq->nr_outstanding))
netfs_rreq_assess(rreq, false); netfs_rreq_assess(rreq, false);
return; return;
@ -944,10 +944,10 @@ EXPORT_SYMBOL(netfs_readahead);
*/ */
int netfs_readpage(struct file *file, int netfs_readpage(struct file *file,
struct folio *folio, struct folio *folio,
const struct netfs_read_request_ops *ops, const struct netfs_request_ops *ops,
void *netfs_priv) void *netfs_priv)
{ {
struct netfs_read_request *rreq; struct netfs_io_request *rreq;
unsigned int debug_index = 0; unsigned int debug_index = 0;
int ret; int ret;
@ -977,19 +977,19 @@ int netfs_readpage(struct file *file,
netfs_get_read_request(rreq); netfs_get_read_request(rreq);
atomic_set(&rreq->nr_rd_ops, 1); atomic_set(&rreq->nr_outstanding, 1);
do { do {
if (!netfs_rreq_submit_slice(rreq, &debug_index)) if (!netfs_rreq_submit_slice(rreq, &debug_index))
break; break;
} while (rreq->submitted < rreq->len); } while (rreq->submitted < rreq->len);
/* Keep nr_rd_ops incremented so that the ref always belongs to us, and /* Keep nr_outstanding incremented so that the ref always belongs to us, and
* the service code isn't punted off to a random thread pool to * the service code isn't punted off to a random thread pool to
* process. * process.
*/ */
do { do {
wait_var_event(&rreq->nr_rd_ops, atomic_read(&rreq->nr_rd_ops) == 1); wait_var_event(&rreq->nr_outstanding, atomic_read(&rreq->nr_outstanding) == 1);
netfs_rreq_assess(rreq, false); netfs_rreq_assess(rreq, false);
} while (test_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags)); } while (test_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags));
@ -1076,10 +1076,10 @@ zero_out:
int netfs_write_begin(struct file *file, struct address_space *mapping, int netfs_write_begin(struct file *file, struct address_space *mapping,
loff_t pos, unsigned int len, unsigned int aop_flags, loff_t pos, unsigned int len, unsigned int aop_flags,
struct folio **_folio, void **_fsdata, struct folio **_folio, void **_fsdata,
const struct netfs_read_request_ops *ops, const struct netfs_request_ops *ops,
void *netfs_priv) void *netfs_priv)
{ {
struct netfs_read_request *rreq; struct netfs_io_request *rreq;
struct folio *folio; struct folio *folio;
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
unsigned int debug_index = 0, fgp_flags; unsigned int debug_index = 0, fgp_flags;
@ -1153,19 +1153,19 @@ retry:
while (readahead_folio(&ractl)) while (readahead_folio(&ractl))
; ;
atomic_set(&rreq->nr_rd_ops, 1); atomic_set(&rreq->nr_outstanding, 1);
do { do {
if (!netfs_rreq_submit_slice(rreq, &debug_index)) if (!netfs_rreq_submit_slice(rreq, &debug_index))
break; break;
} while (rreq->submitted < rreq->len); } while (rreq->submitted < rreq->len);
/* Keep nr_rd_ops incremented so that the ref always belongs to us, and /* Keep nr_outstanding incremented so that the ref always belongs to us, and
* the service code isn't punted off to a random thread pool to * the service code isn't punted off to a random thread pool to
* process. * process.
*/ */
for (;;) { for (;;) {
wait_var_event(&rreq->nr_rd_ops, atomic_read(&rreq->nr_rd_ops) == 1); wait_var_event(&rreq->nr_outstanding, atomic_read(&rreq->nr_outstanding) == 1);
netfs_rreq_assess(rreq, false); netfs_rreq_assess(rreq, false);
if (!test_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags)) if (!test_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags))
break; break;

42
include/linux/netfs.h
View File

@ -106,7 +106,7 @@ static inline int wait_on_page_fscache_killable(struct page *page)
return folio_wait_private_2_killable(page_folio(page)); return folio_wait_private_2_killable(page_folio(page));
} }
enum netfs_read_source { enum netfs_io_source {
NETFS_FILL_WITH_ZEROES, NETFS_FILL_WITH_ZEROES,
NETFS_DOWNLOAD_FROM_SERVER, NETFS_DOWNLOAD_FROM_SERVER,
NETFS_READ_FROM_CACHE, NETFS_READ_FROM_CACHE,
@ -130,8 +130,8 @@ struct netfs_cache_resources {
/* /*
* Descriptor for a single component subrequest. * Descriptor for a single component subrequest.
*/ */
struct netfs_read_subrequest { struct netfs_io_subrequest {
struct netfs_read_request *rreq; /* Supervising read request */ struct netfs_io_request *rreq; /* Supervising read request */
struct list_head rreq_link; /* Link in rreq->subrequests */ struct list_head rreq_link; /* Link in rreq->subrequests */
loff_t start; /* Where to start the I/O */ loff_t start; /* Where to start the I/O */
size_t len; /* Size of the I/O */ size_t len; /* Size of the I/O */
@ -139,7 +139,7 @@ struct netfs_read_subrequest {
refcount_t usage; refcount_t usage;
short error; /* 0 or error that occurred */ short error; /* 0 or error that occurred */
unsigned short debug_index; /* Index in list (for debugging output) */ unsigned short debug_index; /* Index in list (for debugging output) */
enum netfs_read_source source; /* Where to read from */ enum netfs_io_source source; /* Where to read from */
unsigned long flags; unsigned long flags;
#define NETFS_SREQ_WRITE_TO_CACHE 0 /* Set if should write to cache */ #define NETFS_SREQ_WRITE_TO_CACHE 0 /* Set if should write to cache */
#define NETFS_SREQ_CLEAR_TAIL 1 /* Set if the rest of the read should be cleared */ #define NETFS_SREQ_CLEAR_TAIL 1 /* Set if the rest of the read should be cleared */
@ -152,7 +152,7 @@ struct netfs_read_subrequest {
* Descriptor for a read helper request. This is used to make multiple I/O * Descriptor for a read helper request. This is used to make multiple I/O
* requests on a variety of sources and then stitch the result together. * requests on a variety of sources and then stitch the result together.
*/ */
struct netfs_read_request { struct netfs_io_request {
struct work_struct work; struct work_struct work;
struct inode *inode; /* The file being accessed */ struct inode *inode; /* The file being accessed */
struct address_space *mapping; /* The mapping being accessed */ struct address_space *mapping; /* The mapping being accessed */
@ -160,8 +160,8 @@ struct netfs_read_request {
struct list_head subrequests; /* Requests to fetch I/O from disk or net */ struct list_head subrequests; /* Requests to fetch I/O from disk or net */
void *netfs_priv; /* Private data for the netfs */ void *netfs_priv; /* Private data for the netfs */
unsigned int debug_id; unsigned int debug_id;
atomic_t nr_rd_ops; /* Number of read ops in progress */ atomic_t nr_outstanding; /* Number of read ops in progress */
atomic_t nr_wr_ops; /* Number of write ops in progress */ atomic_t nr_copy_ops; /* Number of write ops in progress */
size_t submitted; /* Amount submitted for I/O so far */ size_t submitted; /* Amount submitted for I/O so far */
size_t len; /* Length of the request */ size_t len; /* Length of the request */
short error; /* 0 or error that occurred */ short error; /* 0 or error that occurred */
@ -176,23 +176,23 @@ struct netfs_read_request {
#define NETFS_RREQ_DONT_UNLOCK_FOLIOS 3 /* Don't unlock the folios on completion */ #define NETFS_RREQ_DONT_UNLOCK_FOLIOS 3 /* Don't unlock the folios on completion */
#define NETFS_RREQ_FAILED 4 /* The request failed */ #define NETFS_RREQ_FAILED 4 /* The request failed */
#define NETFS_RREQ_IN_PROGRESS 5 /* Unlocked when the request completes */ #define NETFS_RREQ_IN_PROGRESS 5 /* Unlocked when the request completes */
const struct netfs_read_request_ops *netfs_ops; const struct netfs_request_ops *netfs_ops;
}; };
/* /*
* Operations the network filesystem can/must provide to the helpers. * Operations the network filesystem can/must provide to the helpers.
*/ */
struct netfs_read_request_ops { struct netfs_request_ops {
bool (*is_cache_enabled)(struct inode *inode); bool (*is_cache_enabled)(struct inode *inode);
void (*init_rreq)(struct netfs_read_request *rreq, struct file *file); void (*init_request)(struct netfs_io_request *rreq, struct file *file);
int (*begin_cache_operation)(struct netfs_read_request *rreq); int (*begin_cache_operation)(struct netfs_io_request *rreq);
void (*expand_readahead)(struct netfs_read_request *rreq); void (*expand_readahead)(struct netfs_io_request *rreq);
bool (*clamp_length)(struct netfs_read_subrequest *subreq); bool (*clamp_length)(struct netfs_io_subrequest *subreq);
void (*issue_op)(struct netfs_read_subrequest *subreq); void (*issue_op)(struct netfs_io_subrequest *subreq);
bool (*is_still_valid)(struct netfs_read_request *rreq); bool (*is_still_valid)(struct netfs_io_request *rreq);
int (*check_write_begin)(struct file *file, loff_t pos, unsigned len, int (*check_write_begin)(struct file *file, loff_t pos, unsigned len,
struct folio *folio, void **_fsdata); struct folio *folio, void **_fsdata);
void (*done)(struct netfs_read_request *rreq); void (*done)(struct netfs_io_request *rreq);
void (*cleanup)(struct address_space *mapping, void *netfs_priv); void (*cleanup)(struct address_space *mapping, void *netfs_priv);
}; };
@ -235,7 +235,7 @@ struct netfs_cache_ops {
/* Prepare a read operation, shortening it to a cached/uncached /* Prepare a read operation, shortening it to a cached/uncached
* boundary as appropriate. * boundary as appropriate.
*/ */
enum netfs_read_source (*prepare_read)(struct netfs_read_subrequest *subreq, enum netfs_io_source (*prepare_read)(struct netfs_io_subrequest *subreq,
loff_t i_size); loff_t i_size);
/* Prepare a write operation, working out what part of the write we can /* Prepare a write operation, working out what part of the write we can
@ -255,19 +255,19 @@ struct netfs_cache_ops {
struct readahead_control; struct readahead_control;
extern void netfs_readahead(struct readahead_control *, extern void netfs_readahead(struct readahead_control *,
const struct netfs_read_request_ops *, const struct netfs_request_ops *,
void *); void *);
extern int netfs_readpage(struct file *, extern int netfs_readpage(struct file *,
struct folio *, struct folio *,
const struct netfs_read_request_ops *, const struct netfs_request_ops *,
void *); void *);
extern int netfs_write_begin(struct file *, struct address_space *, extern int netfs_write_begin(struct file *, struct address_space *,
loff_t, unsigned int, unsigned int, struct folio **, loff_t, unsigned int, unsigned int, struct folio **,
void **, void **,
const struct netfs_read_request_ops *, const struct netfs_request_ops *,
void *); void *);
extern void netfs_subreq_terminated(struct netfs_read_subrequest *, ssize_t, bool); extern void netfs_subreq_terminated(struct netfs_io_subrequest *, ssize_t, bool);
extern void netfs_stats_show(struct seq_file *); extern void netfs_stats_show(struct seq_file *);
#endif /* _LINUX_NETFS_H */ #endif /* _LINUX_NETFS_H */

6
include/trace/events/cachefiles.h
View File

@ -424,8 +424,8 @@ TRACE_EVENT(cachefiles_vol_coherency,
); );
TRACE_EVENT(cachefiles_prep_read, TRACE_EVENT(cachefiles_prep_read,
TP_PROTO(struct netfs_read_subrequest *sreq, TP_PROTO(struct netfs_io_subrequest *sreq,
enum netfs_read_source source, enum netfs_io_source source,
enum cachefiles_prepare_read_trace why, enum cachefiles_prepare_read_trace why,
ino_t cache_inode), ino_t cache_inode),
@ -435,7 +435,7 @@ TRACE_EVENT(cachefiles_prep_read,
__field(unsigned int, rreq ) __field(unsigned int, rreq )
__field(unsigned short, index ) __field(unsigned short, index )
__field(unsigned short, flags ) __field(unsigned short, flags )
__field(enum netfs_read_source, source ) __field(enum netfs_io_source, source )
__field(enum cachefiles_prepare_read_trace, why ) __field(enum cachefiles_prepare_read_trace, why )
__field(size_t, len ) __field(size_t, len )
__field(loff_t, start ) __field(loff_t, start )

14
include/trace/events/netfs.h
View File

@ -94,7 +94,7 @@ netfs_failures;
#define E_(a, b) { a, b } #define E_(a, b) { a, b }
TRACE_EVENT(netfs_read, TRACE_EVENT(netfs_read,
TP_PROTO(struct netfs_read_request *rreq, TP_PROTO(struct netfs_io_request *rreq,
loff_t start, size_t len, loff_t start, size_t len,
enum netfs_read_trace what), enum netfs_read_trace what),
@ -127,7 +127,7 @@ TRACE_EVENT(netfs_read,
); );
TRACE_EVENT(netfs_rreq, TRACE_EVENT(netfs_rreq,
TP_PROTO(struct netfs_read_request *rreq, TP_PROTO(struct netfs_io_request *rreq,
enum netfs_rreq_trace what), enum netfs_rreq_trace what),
TP_ARGS(rreq, what), TP_ARGS(rreq, what),
@ -151,7 +151,7 @@ TRACE_EVENT(netfs_rreq,
); );
TRACE_EVENT(netfs_sreq, TRACE_EVENT(netfs_sreq,
TP_PROTO(struct netfs_read_subrequest *sreq, TP_PROTO(struct netfs_io_subrequest *sreq,
enum netfs_sreq_trace what), enum netfs_sreq_trace what),
TP_ARGS(sreq, what), TP_ARGS(sreq, what),
@ -161,7 +161,7 @@ TRACE_EVENT(netfs_sreq,
__field(unsigned short, index ) __field(unsigned short, index )
__field(short, error ) __field(short, error )
__field(unsigned short, flags ) __field(unsigned short, flags )
__field(enum netfs_read_source, source ) __field(enum netfs_io_source, source )
__field(enum netfs_sreq_trace, what ) __field(enum netfs_sreq_trace, what )
__field(size_t, len ) __field(size_t, len )
__field(size_t, transferred ) __field(size_t, transferred )
@ -190,8 +190,8 @@ TRACE_EVENT(netfs_sreq,
); );
TRACE_EVENT(netfs_failure, TRACE_EVENT(netfs_failure,
TP_PROTO(struct netfs_read_request *rreq, TP_PROTO(struct netfs_io_request *rreq,
struct netfs_read_subrequest *sreq, struct netfs_io_subrequest *sreq,
int error, enum netfs_failure what), int error, enum netfs_failure what),
TP_ARGS(rreq, sreq, error, what), TP_ARGS(rreq, sreq, error, what),
@ -201,7 +201,7 @@ TRACE_EVENT(netfs_failure,
__field(unsigned short, index ) __field(unsigned short, index )
__field(short, error ) __field(short, error )
__field(unsigned short, flags ) __field(unsigned short, flags )
__field(enum netfs_read_source, source ) __field(enum netfs_io_source, source )
__field(enum netfs_failure, what ) __field(enum netfs_failure, what )
__field(size_t, len ) __field(size_t, len )
__field(size_t, transferred ) __field(size_t, transferred )