Re: [PATCH v2 04/19] netfs: Finish off rename of netfs_read_request to netfs_io_request
From: Jeff Layton
Date: Wed Mar 09 2022 - 10:34:28 EST
On Tue, 2022-03-08 at 23:26 +0000, David Howells wrote:
> Adjust helper function names and comments after mass rename of
> struct netfs_read_*request to struct netfs_io_*request.
>
> Changes
> =======
> ver #2)
> - Make the changes in the docs also.
>
> Signed-off-by: David Howells <dhowells@xxxxxxxxxx>
> cc: linux-cachefs@xxxxxxxxxx
>
> Link: https://lore.kernel.org/r/164622992433.3564931.6684311087845150271.stgit@xxxxxxxxxxxxxxxxxxxxxx/ # v1
> ---
>
> Documentation/filesystems/netfs_library.rst | 4 +
> fs/9p/vfs_addr.c | 6 +-
> fs/afs/file.c | 4 +
> fs/cachefiles/io.c | 4 +
> fs/ceph/addr.c | 6 +-
> fs/netfs/read_helper.c | 83 ++++++++++++++-------------
> include/linux/netfs.h | 22 ++++---
> 7 files changed, 65 insertions(+), 64 deletions(-)
>
> diff --git a/Documentation/filesystems/netfs_library.rst b/Documentation/filesystems/netfs_library.rst
> index a997e2d4321d..4eb7e7b7b0fc 100644
> --- a/Documentation/filesystems/netfs_library.rst
> +++ b/Documentation/filesystems/netfs_library.rst
> @@ -250,7 +250,7 @@ through which it can issue requests and negotiate::
> int (*begin_cache_operation)(struct netfs_io_request *rreq);
> void (*expand_readahead)(struct netfs_io_request *rreq);
> bool (*clamp_length)(struct netfs_io_subrequest *subreq);
> - void (*issue_op)(struct netfs_io_subrequest *subreq);
> + void (*issue_read)(struct netfs_io_subrequest *subreq);
> bool (*is_still_valid)(struct netfs_io_request *rreq);
> int (*check_write_begin)(struct file *file, loff_t pos, unsigned len,
> struct folio *folio, void **_fsdata);
> @@ -305,7 +305,7 @@ The operations are as follows:
>
> This should return 0 on success and an error code on error.
>
> - * ``issue_op()``
> + * ``issue_read()``
>
> [Required] The helpers use this to dispatch a subrequest to the server for
> reading. In the subrequest, ->start, ->len and ->transferred indicate what
> diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
> index 7b79fabe7593..fdc1033a1546 100644
> --- a/fs/9p/vfs_addr.c
> +++ b/fs/9p/vfs_addr.c
> @@ -28,10 +28,10 @@
> #include "fid.h"
>
> /**
> - * v9fs_req_issue_op - Issue a read from 9P
> + * v9fs_issue_read - Issue a read from 9P
> * @subreq: The read to make
> */
> -static void v9fs_req_issue_op(struct netfs_io_subrequest *subreq)
> +static void v9fs_issue_read(struct netfs_io_subrequest *subreq)
> {
> struct netfs_io_request *rreq = subreq->rreq;
> struct p9_fid *fid = rreq->netfs_priv;
> @@ -106,7 +106,7 @@ static const struct netfs_request_ops v9fs_req_ops = {
> .init_request = v9fs_init_request,
> .is_cache_enabled = v9fs_is_cache_enabled,
> .begin_cache_operation = v9fs_begin_cache_operation,
> - .issue_op = v9fs_req_issue_op,
> + .issue_read = v9fs_issue_read,
> .cleanup = v9fs_req_cleanup,
> };
>
> diff --git a/fs/afs/file.c b/fs/afs/file.c
> index e55761f8858c..b19d635eed12 100644
> --- a/fs/afs/file.c
> +++ b/fs/afs/file.c
> @@ -310,7 +310,7 @@ int afs_fetch_data(struct afs_vnode *vnode, struct afs_read *req)
> return afs_do_sync_operation(op);
> }
>
> -static void afs_req_issue_op(struct netfs_io_subrequest *subreq)
> +static void afs_issue_read(struct netfs_io_subrequest *subreq)
> {
> struct afs_vnode *vnode = AFS_FS_I(subreq->rreq->inode);
> struct afs_read *fsreq;
> @@ -401,7 +401,7 @@ const struct netfs_request_ops afs_req_ops = {
> .is_cache_enabled = afs_is_cache_enabled,
> .begin_cache_operation = afs_begin_cache_operation,
> .check_write_begin = afs_check_write_begin,
> - .issue_op = afs_req_issue_op,
> + .issue_read = afs_issue_read,
> .cleanup = afs_priv_cleanup,
> };
>
> diff --git a/fs/cachefiles/io.c b/fs/cachefiles/io.c
> index 6ac6fdbc70d3..b19f496db9ad 100644
> --- a/fs/cachefiles/io.c
> +++ b/fs/cachefiles/io.c
> @@ -406,7 +406,7 @@ static enum netfs_io_source cachefiles_prepare_read(struct netfs_io_subrequest *
> }
>
> if (test_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags)) {
> - __set_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags);
> + __set_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
> why = cachefiles_trace_read_no_data;
> goto out_no_object;
> }
> @@ -475,7 +475,7 @@ static enum netfs_io_source cachefiles_prepare_read(struct netfs_io_subrequest *
> goto out;
>
> download_and_store:
> - __set_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags);
> + __set_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
> out:
> cachefiles_end_secure(cache, saved_cred);
> out_no_object:
> diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
> index 9d995f351079..9189257476f8 100644
> --- a/fs/ceph/addr.c
> +++ b/fs/ceph/addr.c
> @@ -259,7 +259,7 @@ static bool ceph_netfs_issue_op_inline(struct netfs_io_subrequest *subreq)
> size_t len;
>
> __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
> - __clear_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags);
> + __clear_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
>
> if (subreq->start >= inode->i_size)
> goto out;
> @@ -298,7 +298,7 @@ static bool ceph_netfs_issue_op_inline(struct netfs_io_subrequest *subreq)
> return true;
> }
>
> -static void ceph_netfs_issue_op(struct netfs_io_subrequest *subreq)
> +static void ceph_netfs_issue_read(struct netfs_io_subrequest *subreq)
> {
> struct netfs_io_request *rreq = subreq->rreq;
> struct inode *inode = rreq->inode;
> @@ -367,7 +367,7 @@ static void ceph_readahead_cleanup(struct address_space *mapping, void *priv)
> static const struct netfs_request_ops ceph_netfs_read_ops = {
> .is_cache_enabled = ceph_is_cache_enabled,
> .begin_cache_operation = ceph_begin_cache_operation,
> - .issue_op = ceph_netfs_issue_op,
> + .issue_read = ceph_netfs_issue_read,
> .expand_readahead = ceph_netfs_expand_readahead,
> .clamp_length = ceph_netfs_clamp_length,
> .check_write_begin = ceph_netfs_check_write_begin,
> diff --git a/fs/netfs/read_helper.c b/fs/netfs/read_helper.c
> index 50035d93f1dc..26d54055b17e 100644
> --- a/fs/netfs/read_helper.c
> +++ b/fs/netfs/read_helper.c
> @@ -37,7 +37,7 @@ static void netfs_put_subrequest(struct netfs_io_subrequest *subreq,
> __netfs_put_subrequest(subreq, was_async);
> }
>
> -static struct netfs_io_request *netfs_alloc_read_request(
> +static struct netfs_io_request *netfs_alloc_request(
> const struct netfs_request_ops *ops, void *netfs_priv,
> struct file *file)
> {
> @@ -63,13 +63,12 @@ static struct netfs_io_request *netfs_alloc_read_request(
> return rreq;
> }
>
> -static void netfs_get_read_request(struct netfs_io_request *rreq)
> +static void netfs_get_request(struct netfs_io_request *rreq)
> {
> refcount_inc(&rreq->usage);
> }
>
> -static void netfs_rreq_clear_subreqs(struct netfs_io_request *rreq,
> - bool was_async)
> +static void netfs_clear_subrequests(struct netfs_io_request *rreq, bool was_async)
> {
> struct netfs_io_subrequest *subreq;
>
> @@ -81,11 +80,11 @@ static void netfs_rreq_clear_subreqs(struct netfs_io_request *rreq,
> }
> }
>
> -static void netfs_free_read_request(struct work_struct *work)
> +static void netfs_free_request(struct work_struct *work)
> {
> struct netfs_io_request *rreq =
> container_of(work, struct netfs_io_request, work);
> - netfs_rreq_clear_subreqs(rreq, false);
> + netfs_clear_subrequests(rreq, false);
> if (rreq->netfs_priv)
> rreq->netfs_ops->cleanup(rreq->mapping, rreq->netfs_priv);
> trace_netfs_rreq(rreq, netfs_rreq_trace_free);
> @@ -95,15 +94,15 @@ static void netfs_free_read_request(struct work_struct *work)
> netfs_stat_d(&netfs_n_rh_rreq);
> }
>
> -static void netfs_put_read_request(struct netfs_io_request *rreq, bool was_async)
> +static void netfs_put_request(struct netfs_io_request *rreq, bool was_async)
> {
> if (refcount_dec_and_test(&rreq->usage)) {
> if (was_async) {
> - rreq->work.func = netfs_free_read_request;
> + rreq->work.func = netfs_free_request;
> if (!queue_work(system_unbound_wq, &rreq->work))
> BUG();
> } else {
> - netfs_free_read_request(&rreq->work);
> + netfs_free_request(&rreq->work);
> }
> }
> }
> @@ -121,14 +120,14 @@ static struct netfs_io_subrequest *netfs_alloc_subrequest(
> INIT_LIST_HEAD(&subreq->rreq_link);
> refcount_set(&subreq->usage, 2);
> subreq->rreq = rreq;
> - netfs_get_read_request(rreq);
> + netfs_get_request(rreq);
> netfs_stat(&netfs_n_rh_sreq);
> }
>
> return subreq;
> }
>
> -static void netfs_get_read_subrequest(struct netfs_io_subrequest *subreq)
> +static void netfs_get_subrequest(struct netfs_io_subrequest *subreq)
> {
> refcount_inc(&subreq->usage);
> }
> @@ -141,7 +140,7 @@ static void __netfs_put_subrequest(struct netfs_io_subrequest *subreq,
> trace_netfs_sreq(subreq, netfs_sreq_trace_free);
> kfree(subreq);
> netfs_stat_d(&netfs_n_rh_sreq);
> - netfs_put_read_request(rreq, was_async);
> + netfs_put_request(rreq, was_async);
> }
>
> /*
> @@ -216,7 +215,7 @@ static void netfs_read_from_server(struct netfs_io_request *rreq,
> struct netfs_io_subrequest *subreq)
> {
> netfs_stat(&netfs_n_rh_download);
> - rreq->netfs_ops->issue_op(subreq);
> + rreq->netfs_ops->issue_read(subreq);
> }
>
> /*
> @@ -225,8 +224,8 @@ static void netfs_read_from_server(struct netfs_io_request *rreq,
> static void netfs_rreq_completed(struct netfs_io_request *rreq, bool was_async)
> {
> trace_netfs_rreq(rreq, netfs_rreq_trace_done);
> - netfs_rreq_clear_subreqs(rreq, was_async);
> - netfs_put_read_request(rreq, was_async);
> + netfs_clear_subrequests(rreq, was_async);
> + netfs_put_request(rreq, was_async);
> }
>
> /*
> @@ -306,7 +305,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_io_request *rreq)
> atomic_inc(&rreq->nr_copy_ops);
>
> 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_COPY_TO_CACHE, &subreq->flags)) {
> list_del_init(&subreq->rreq_link);
> netfs_put_subrequest(subreq, false);
> }
> @@ -336,7 +335,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_io_request *rreq)
>
> atomic_inc(&rreq->nr_copy_ops);
> netfs_stat(&netfs_n_rh_write);
> - netfs_get_read_subrequest(subreq);
> + netfs_get_subrequest(subreq);
> trace_netfs_sreq(subreq, netfs_sreq_trace_write);
> cres->ops->write(cres, subreq->start, &iter,
> netfs_rreq_copy_terminated, subreq);
> @@ -378,9 +377,9 @@ static void netfs_rreq_unlock(struct netfs_io_request *rreq)
> XA_STATE(xas, &rreq->mapping->i_pages, start_page);
>
> if (test_bit(NETFS_RREQ_FAILED, &rreq->flags)) {
> - __clear_bit(NETFS_RREQ_WRITE_TO_CACHE, &rreq->flags);
> + __clear_bit(NETFS_RREQ_COPY_TO_CACHE, &rreq->flags);
> list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
> - __clear_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags);
> + __clear_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
> }
> }
>
> @@ -408,7 +407,7 @@ static void netfs_rreq_unlock(struct netfs_io_request *rreq)
> pg_failed = true;
> break;
> }
> - if (test_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags))
> + if (test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags))
> folio_start_fscache(folio);
> pg_failed |= subreq_failed;
> if (pgend < iopos + subreq->len)
> @@ -453,13 +452,13 @@ static void netfs_rreq_unlock(struct netfs_io_request *rreq)
> static void netfs_rreq_short_read(struct netfs_io_request *rreq,
> struct netfs_io_subrequest *subreq)
> {
> - __clear_bit(NETFS_SREQ_SHORT_READ, &subreq->flags);
> + __clear_bit(NETFS_SREQ_SHORT_IO, &subreq->flags);
> __set_bit(NETFS_SREQ_SEEK_DATA_READ, &subreq->flags);
>
> netfs_stat(&netfs_n_rh_short_read);
> trace_netfs_sreq(subreq, netfs_sreq_trace_resubmit_short);
>
> - netfs_get_read_subrequest(subreq);
> + netfs_get_subrequest(subreq);
> atomic_inc(&rreq->nr_outstanding);
> if (subreq->source == NETFS_READ_FROM_CACHE)
> netfs_read_from_cache(rreq, subreq, NETFS_READ_HOLE_CLEAR);
> @@ -493,10 +492,10 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_io_request *rreq)
> subreq->error = 0;
> netfs_stat(&netfs_n_rh_download_instead);
> trace_netfs_sreq(subreq, netfs_sreq_trace_download_instead);
> - netfs_get_read_subrequest(subreq);
> + netfs_get_subrequest(subreq);
> atomic_inc(&rreq->nr_outstanding);
> netfs_read_from_server(rreq, subreq);
> - } else if (test_bit(NETFS_SREQ_SHORT_READ, &subreq->flags)) {
> + } else if (test_bit(NETFS_SREQ_SHORT_IO, &subreq->flags)) {
> netfs_rreq_short_read(rreq, subreq);
> }
> }
> @@ -553,7 +552,7 @@ static void netfs_rreq_assess(struct netfs_io_request *rreq, bool was_async)
> clear_bit_unlock(NETFS_RREQ_IN_PROGRESS, &rreq->flags);
> wake_up_bit(&rreq->flags, NETFS_RREQ_IN_PROGRESS);
>
> - if (test_bit(NETFS_RREQ_WRITE_TO_CACHE, &rreq->flags))
> + if (test_bit(NETFS_RREQ_COPY_TO_CACHE, &rreq->flags))
> return netfs_rreq_write_to_cache(rreq);
>
> netfs_rreq_completed(rreq, was_async);
> @@ -642,8 +641,8 @@ void netfs_subreq_terminated(struct netfs_io_subrequest *subreq,
>
> complete:
> __clear_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags);
> - if (test_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags))
> - set_bit(NETFS_RREQ_WRITE_TO_CACHE, &rreq->flags);
> + if (test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags))
> + set_bit(NETFS_RREQ_COPY_TO_CACHE, &rreq->flags);
>
> out:
> trace_netfs_sreq(subreq, netfs_sreq_trace_terminated);
> @@ -674,7 +673,7 @@ void netfs_subreq_terminated(struct netfs_io_subrequest *subreq,
> __clear_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags);
> }
>
> - __set_bit(NETFS_SREQ_SHORT_READ, &subreq->flags);
> + __set_bit(NETFS_SREQ_SHORT_IO, &subreq->flags);
> set_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags);
> goto out;
>
> @@ -878,7 +877,7 @@ void netfs_readahead(struct readahead_control *ractl,
> if (readahead_count(ractl) == 0)
> goto cleanup;
>
> - rreq = netfs_alloc_read_request(ops, netfs_priv, ractl->file);
> + rreq = netfs_alloc_request(ops, netfs_priv, ractl->file);
> if (!rreq)
> goto cleanup;
> rreq->mapping = ractl->mapping;
> @@ -916,7 +915,7 @@ void netfs_readahead(struct readahead_control *ractl,
> return;
>
> cleanup_free:
> - netfs_put_read_request(rreq, false);
> + netfs_put_request(rreq, false);
> return;
> cleanup:
> if (netfs_priv)
> @@ -953,7 +952,7 @@ int netfs_readpage(struct file *file,
>
> _enter("%lx", folio_index(folio));
>
> - rreq = netfs_alloc_read_request(ops, netfs_priv, file);
> + rreq = netfs_alloc_request(ops, netfs_priv, file);
> if (!rreq) {
> if (netfs_priv)
> ops->cleanup(folio_file_mapping(folio), netfs_priv);
> @@ -975,7 +974,7 @@ int netfs_readpage(struct file *file,
> netfs_stat(&netfs_n_rh_readpage);
> trace_netfs_read(rreq, rreq->start, rreq->len, netfs_read_trace_readpage);
>
> - netfs_get_read_request(rreq);
> + netfs_get_request(rreq);
>
> atomic_set(&rreq->nr_outstanding, 1);
> do {
> @@ -989,7 +988,8 @@ int netfs_readpage(struct file *file,
> * process.
> */
> do {
> - wait_var_event(&rreq->nr_outstanding, atomic_read(&rreq->nr_outstanding) == 1);
> + wait_var_event(&rreq->nr_outstanding,
> + atomic_read(&rreq->nr_outstanding) == 1);
> netfs_rreq_assess(rreq, false);
> } while (test_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags));
>
> @@ -999,7 +999,7 @@ int netfs_readpage(struct file *file,
> ret = -EIO;
> }
> out:
> - netfs_put_read_request(rreq, false);
> + netfs_put_request(rreq, false);
> return ret;
> }
> EXPORT_SYMBOL(netfs_readpage);
> @@ -1122,7 +1122,7 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,
> }
>
> ret = -ENOMEM;
> - rreq = netfs_alloc_read_request(ops, netfs_priv, file);
> + rreq = netfs_alloc_request(ops, netfs_priv, file);
> if (!rreq)
> goto error;
> rreq->mapping = folio_file_mapping(folio);
> @@ -1146,7 +1146,7 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,
> */
> ractl._nr_pages = folio_nr_pages(folio);
> netfs_rreq_expand(rreq, &ractl);
> - netfs_get_read_request(rreq);
> + netfs_get_request(rreq);
>
> /* We hold the folio locks, so we can drop the references */
> folio_get(folio);
> @@ -1160,12 +1160,13 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,
>
> } while (rreq->submitted < rreq->len);
>
> - /* 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
> + /* 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
> * process.
> */
> for (;;) {
> - wait_var_event(&rreq->nr_outstanding, atomic_read(&rreq->nr_outstanding) == 1);
> + wait_var_event(&rreq->nr_outstanding,
> + atomic_read(&rreq->nr_outstanding) == 1);
> netfs_rreq_assess(rreq, false);
> if (!test_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags))
> break;
> @@ -1177,7 +1178,7 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,
> trace_netfs_failure(rreq, NULL, ret, netfs_fail_short_write_begin);
> ret = -EIO;
> }
> - netfs_put_read_request(rreq, false);
> + netfs_put_request(rreq, false);
> if (ret < 0)
> goto error;
>
> @@ -1193,7 +1194,7 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,
> return 0;
>
> error_put:
> - netfs_put_read_request(rreq, false);
> + netfs_put_request(rreq, false);
> error:
> folio_unlock(folio);
> folio_put(folio);
> diff --git a/include/linux/netfs.h b/include/linux/netfs.h
> index a2ca91cb7a68..f63de27d6f29 100644
> --- a/include/linux/netfs.h
> +++ b/include/linux/netfs.h
> @@ -131,7 +131,7 @@ struct netfs_cache_resources {
> * Descriptor for a single component subrequest.
> */
> struct netfs_io_subrequest {
> - struct netfs_io_request *rreq; /* Supervising read request */
> + struct netfs_io_request *rreq; /* Supervising I/O request */
> struct list_head rreq_link; /* Link in rreq->subrequests */
> loff_t start; /* Where to start the I/O */
> size_t len; /* Size of the I/O */
> @@ -139,29 +139,29 @@ struct netfs_io_subrequest {
> refcount_t usage;
> short error; /* 0 or error that occurred */
> unsigned short debug_index; /* Index in list (for debugging output) */
> - enum netfs_io_source source; /* Where to read from */
> + enum netfs_io_source source; /* Where to read from/write to */
> unsigned long flags;
> -#define NETFS_SREQ_WRITE_TO_CACHE 0 /* Set if should write to cache */
> +#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_SHORT_READ 2 /* Set if there was a short read from the cache */
> +#define NETFS_SREQ_SHORT_IO 2 /* Set if the I/O was short */
> #define NETFS_SREQ_SEEK_DATA_READ 3 /* Set if ->read() should SEEK_DATA first */
> #define NETFS_SREQ_NO_PROGRESS 4 /* Set if we didn't manage to read any data */
> };
>
> /*
> - * 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.
> + * Descriptor for an I/O helper request. This is used to make multiple I/O
> + * operations to a variety of data stores and then stitch the result together.
> */
> struct netfs_io_request {
> struct work_struct work;
> struct inode *inode; /* The file being accessed */
> struct address_space *mapping; /* The mapping being accessed */
> struct netfs_cache_resources cache_resources;
> - struct list_head subrequests; /* Requests to fetch I/O from disk or net */
> + struct list_head subrequests; /* Contributory I/O operations */
> void *netfs_priv; /* Private data for the netfs */
> unsigned int debug_id;
> - atomic_t nr_outstanding; /* Number of read ops in progress */
> - atomic_t nr_copy_ops; /* Number of write ops in progress */
> + atomic_t nr_outstanding; /* Number of ops in progress */
> + atomic_t nr_copy_ops; /* Number of copy-to-cache ops in progress */
> size_t submitted; /* Amount submitted for I/O so far */
> size_t len; /* Length of the request */
> short error; /* 0 or error that occurred */
> @@ -171,7 +171,7 @@ struct netfs_io_request {
> refcount_t usage;
> unsigned long flags;
> #define NETFS_RREQ_INCOMPLETE_IO 0 /* Some ioreqs terminated short or with error */
> -#define NETFS_RREQ_WRITE_TO_CACHE 1 /* Need to write to the cache */
> +#define NETFS_RREQ_COPY_TO_CACHE 1 /* Need to write to the cache */
> #define NETFS_RREQ_NO_UNLOCK_FOLIO 2 /* Don't unlock no_unlock_folio on completion */
> #define NETFS_RREQ_DONT_UNLOCK_FOLIOS 3 /* Don't unlock the folios on completion */
> #define NETFS_RREQ_FAILED 4 /* The request failed */
> @@ -188,7 +188,7 @@ struct netfs_request_ops {
> int (*begin_cache_operation)(struct netfs_io_request *rreq);
> void (*expand_readahead)(struct netfs_io_request *rreq);
> bool (*clamp_length)(struct netfs_io_subrequest *subreq);
> - void (*issue_op)(struct netfs_io_subrequest *subreq);
> + void (*issue_read)(struct netfs_io_subrequest *subreq);
> bool (*is_still_valid)(struct netfs_io_request *rreq);
> int (*check_write_begin)(struct file *file, loff_t pos, unsigned len,
> struct folio *folio, void **_fsdata);
>
>
Another (mostly) mechanical change...
Reviewed-by: Jeff Layton <jlayton@xxxxxxxxxx>