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>
