UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

netfs: Finish off rename of netfs_read_request to netfs_io_request 

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@redhat.com>
Reviewed-by: Jeff Layton <jlayton@kernel.org>
cc: linux-cachefs@redhat.com

Link: https://lore.kernel.org/r/164622992433.3564931.6684311087845150271.stgit@warthog.procyon.org.uk/ # v1
Link: https://lore.kernel.org/r/164678196111.1200972.5001114956865989528.stgit@warthog.procyon.org.uk/ # v2
Link: https://lore.kernel.org/r/164692892567.2099075.13895804222087028813.stgit@warthog.procyon.org.uk/ # v3
This commit is contained in:
David Howells 2022-02-17 10:14:32 +00:00
parent 6a19114b8e
commit f18a378580
7 changed files with 65 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Documentation/filesystems/netfs_library.rst
View File

@ -250,7 +250,7 @@ through which it can issue requests and negotiate::
int (*begin_cache_operation)(struct netfs_io_request *rreq); int (*begin_cache_operation)(struct netfs_io_request *rreq);
void (*expand_readahead)(struct netfs_io_request *rreq); void (*expand_readahead)(struct netfs_io_request *rreq);
bool (*clamp_length)(struct netfs_io_subrequest *subreq); 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); 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);
@ -305,7 +305,7 @@ The operations are as follows:
This should return 0 on success and an error code on error. 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 [Required] The helpers use this to dispatch a subrequest to the server for
reading. In the subrequest, ->start, ->len and ->transferred indicate what reading. In the subrequest, ->start, ->len and ->transferred indicate what

6
fs/9p/vfs_addr.c
View File

@ -28,10 +28,10 @@
#include "fid.h" #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 * @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 netfs_io_request *rreq = subreq->rreq;
struct p9_fid *fid = rreq->netfs_priv; 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, .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_read = v9fs_issue_read,
.cleanup = v9fs_req_cleanup, .cleanup = v9fs_req_cleanup,
}; };

4
fs/afs/file.c
View File

@ -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_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_vnode *vnode = AFS_FS_I(subreq->rreq->inode);
struct afs_read *fsreq; struct afs_read *fsreq;
@ -401,7 +401,7 @@ const struct netfs_request_ops afs_req_ops = {
.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,
.issue_op = afs_req_issue_op, .issue_read = afs_issue_read,
.cleanup = afs_priv_cleanup, .cleanup = afs_priv_cleanup,
}; };

4
fs/cachefiles/io.c
View File

@ -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)) { 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; why = cachefiles_trace_read_no_data;
goto out_no_object; goto out_no_object;
} }
@ -475,7 +475,7 @@ static enum netfs_io_source cachefiles_prepare_read(struct netfs_io_subrequest *
goto out; goto out;
download_and_store: download_and_store:
__set_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags); __set_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
out: out:
cachefiles_end_secure(cache, saved_cred); cachefiles_end_secure(cache, saved_cred);
out_no_object: out_no_object:

6
fs/ceph/addr.c
View File

@ -259,7 +259,7 @@ static bool ceph_netfs_issue_op_inline(struct netfs_io_subrequest *subreq)
size_t len; size_t len;
__set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags); __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) if (subreq->start >= inode->i_size)
goto out; goto out;
@ -298,7 +298,7 @@ out:
return true; 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 netfs_io_request *rreq = subreq->rreq;
struct inode *inode = rreq->inode; 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 = { 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_read = ceph_netfs_issue_read,
.expand_readahead = ceph_netfs_expand_readahead, .expand_readahead = ceph_netfs_expand_readahead,
.clamp_length = ceph_netfs_clamp_length, .clamp_length = ceph_netfs_clamp_length,
.check_write_begin = ceph_netfs_check_write_begin, .check_write_begin = ceph_netfs_check_write_begin,

83
fs/netfs/read_helper.c
View File

@ -37,7 +37,7 @@ static void netfs_put_subrequest(struct netfs_io_subrequest *subreq,
__netfs_put_subrequest(subreq, was_async); __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, const struct netfs_request_ops *ops, void *netfs_priv,
struct file *file) struct file *file)
{ {
@ -63,13 +63,12 @@ static struct netfs_io_request *netfs_alloc_read_request(
return rreq; 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); refcount_inc(&rreq->usage);
} }
static void netfs_rreq_clear_subreqs(struct netfs_io_request *rreq, static void netfs_clear_subrequests(struct netfs_io_request *rreq, bool was_async)
bool was_async)
{ {
struct netfs_io_subrequest *subreq; 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 = struct netfs_io_request *rreq =
container_of(work, struct netfs_io_request, work); container_of(work, struct netfs_io_request, work);
netfs_rreq_clear_subreqs(rreq, false); netfs_clear_subrequests(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);
trace_netfs_rreq(rreq, netfs_rreq_trace_free); 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); 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 (refcount_dec_and_test(&rreq->usage)) {
if (was_async) { if (was_async) {
rreq->work.func = netfs_free_read_request; rreq->work.func = netfs_free_request;
if (!queue_work(system_unbound_wq, &rreq->work)) if (!queue_work(system_unbound_wq, &rreq->work))
BUG(); BUG();
} else { } 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); INIT_LIST_HEAD(&subreq->rreq_link);
refcount_set(&subreq->usage, 2); refcount_set(&subreq->usage, 2);
subreq->rreq = rreq; subreq->rreq = rreq;
netfs_get_read_request(rreq); netfs_get_request(rreq);
netfs_stat(&netfs_n_rh_sreq); netfs_stat(&netfs_n_rh_sreq);
} }
return subreq; 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); 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); trace_netfs_sreq(subreq, netfs_sreq_trace_free);
kfree(subreq); kfree(subreq);
netfs_stat_d(&netfs_n_rh_sreq); 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) 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_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) 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_clear_subrequests(rreq, was_async);
netfs_put_read_request(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); 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_COPY_TO_CACHE, &subreq->flags)) {
list_del_init(&subreq->rreq_link); list_del_init(&subreq->rreq_link);
netfs_put_subrequest(subreq, false); 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); 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_subrequest(subreq);
trace_netfs_sreq(subreq, netfs_sreq_trace_write); trace_netfs_sreq(subreq, netfs_sreq_trace_write);
cres->ops->write(cres, subreq->start, &iter, cres->ops->write(cres, subreq->start, &iter,
netfs_rreq_copy_terminated, subreq); 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); XA_STATE(xas, &rreq->mapping->i_pages, start_page);
if (test_bit(NETFS_RREQ_FAILED, &rreq->flags)) { 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) { 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; pg_failed = true;
break; 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); folio_start_fscache(folio);
pg_failed |= subreq_failed; pg_failed |= subreq_failed;
if (pgend < iopos + subreq->len) 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, static void netfs_rreq_short_read(struct netfs_io_request *rreq,
struct netfs_io_subrequest *subreq) 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); __set_bit(NETFS_SREQ_SEEK_DATA_READ, &subreq->flags);
netfs_stat(&netfs_n_rh_short_read); netfs_stat(&netfs_n_rh_short_read);
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_subrequest(subreq);
atomic_inc(&rreq->nr_outstanding); 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);
@ -493,10 +492,10 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_io_request *rreq)
subreq->error = 0; subreq->error = 0;
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_subrequest(subreq);
atomic_inc(&rreq->nr_outstanding); 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_IO, &subreq->flags)) {
netfs_rreq_short_read(rreq, subreq); netfs_rreq_short_read(rreq, subreq);
} }
} }
@ -553,7 +552,7 @@ again:
clear_bit_unlock(NETFS_RREQ_IN_PROGRESS, &rreq->flags); clear_bit_unlock(NETFS_RREQ_IN_PROGRESS, &rreq->flags);
wake_up_bit(&rreq->flags, NETFS_RREQ_IN_PROGRESS); 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); return netfs_rreq_write_to_cache(rreq);
netfs_rreq_completed(rreq, was_async); netfs_rreq_completed(rreq, was_async);
@ -642,8 +641,8 @@ void netfs_subreq_terminated(struct netfs_io_subrequest *subreq,
complete: complete:
__clear_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags); __clear_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags);
if (test_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags)) if (test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags))
set_bit(NETFS_RREQ_WRITE_TO_CACHE, &rreq->flags); set_bit(NETFS_RREQ_COPY_TO_CACHE, &rreq->flags);
out: out:
trace_netfs_sreq(subreq, netfs_sreq_trace_terminated); trace_netfs_sreq(subreq, netfs_sreq_trace_terminated);
@ -674,7 +673,7 @@ incomplete:
__clear_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags); __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); set_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags);
goto out; goto out;
@ -878,7 +877,7 @@ void netfs_readahead(struct readahead_control *ractl,
if (readahead_count(ractl) == 0) if (readahead_count(ractl) == 0)
goto cleanup; goto cleanup;
rreq = netfs_alloc_read_request(ops, netfs_priv, ractl->file); rreq = netfs_alloc_request(ops, netfs_priv, ractl->file);
if (!rreq) if (!rreq)
goto cleanup; goto cleanup;
rreq->mapping = ractl->mapping; rreq->mapping = ractl->mapping;
@ -916,7 +915,7 @@ void netfs_readahead(struct readahead_control *ractl,
return; return;
cleanup_free: cleanup_free:
netfs_put_read_request(rreq, false); netfs_put_request(rreq, false);
return; return;
cleanup: cleanup:
if (netfs_priv) if (netfs_priv)
@ -953,7 +952,7 @@ int netfs_readpage(struct file *file,
_enter("%lx", folio_index(folio)); _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 (!rreq) {
if (netfs_priv) if (netfs_priv)
ops->cleanup(folio_file_mapping(folio), 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); netfs_stat(&netfs_n_rh_readpage);
trace_netfs_read(rreq, rreq->start, rreq->len, netfs_read_trace_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); atomic_set(&rreq->nr_outstanding, 1);
do { do {
@ -989,7 +988,8 @@ int netfs_readpage(struct file *file,
* process. * process.
*/ */
do { 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); netfs_rreq_assess(rreq, false);
} while (test_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags)); } while (test_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags));
@ -999,7 +999,7 @@ int netfs_readpage(struct file *file,
ret = -EIO; ret = -EIO;
} }
out: out:
netfs_put_read_request(rreq, false); netfs_put_request(rreq, false);
return ret; return ret;
} }
EXPORT_SYMBOL(netfs_readpage); EXPORT_SYMBOL(netfs_readpage);
@ -1122,7 +1122,7 @@ retry:
} }
ret = -ENOMEM; ret = -ENOMEM;
rreq = netfs_alloc_read_request(ops, netfs_priv, file); rreq = netfs_alloc_request(ops, netfs_priv, file);
if (!rreq) if (!rreq)
goto error; goto error;
rreq->mapping = folio_file_mapping(folio); rreq->mapping = folio_file_mapping(folio);
@ -1146,7 +1146,7 @@ retry:
*/ */
ractl._nr_pages = folio_nr_pages(folio); ractl._nr_pages = folio_nr_pages(folio);
netfs_rreq_expand(rreq, &ractl); 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 */ /* We hold the folio locks, so we can drop the references */
folio_get(folio); folio_get(folio);
@ -1160,12 +1160,13 @@ retry:
} while (rreq->submitted < rreq->len); } while (rreq->submitted < rreq->len);
/* Keep nr_outstanding incremented so that the ref always belongs to us, and /* Keep nr_outstanding incremented so that the ref always belongs to
* the service code isn't punted off to a random thread pool to * us, and the service code isn't punted off to a random thread pool to
* process. * process.
*/ */
for (;;) { 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); 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;
@ -1177,7 +1178,7 @@ retry:
trace_netfs_failure(rreq, NULL, ret, netfs_fail_short_write_begin); trace_netfs_failure(rreq, NULL, ret, netfs_fail_short_write_begin);
ret = -EIO; ret = -EIO;
} }
netfs_put_read_request(rreq, false); netfs_put_request(rreq, false);
if (ret < 0) if (ret < 0)
goto error; goto error;
@ -1193,7 +1194,7 @@ have_folio_no_wait:
return 0; return 0;
error_put: error_put:
netfs_put_read_request(rreq, false); netfs_put_request(rreq, false);
error: error:
folio_unlock(folio); folio_unlock(folio);
folio_put(folio); folio_put(folio);

22
include/linux/netfs.h
View File

@ -131,7 +131,7 @@ struct netfs_cache_resources {
* Descriptor for a single component subrequest. * Descriptor for a single component subrequest.
*/ */
struct netfs_io_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 */ 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,29 +139,29 @@ struct netfs_io_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_io_source source; /* Where to read from */ enum netfs_io_source source; /* Where to read from/write to */
unsigned long flags; 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_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_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 */ #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 * Descriptor for an I/O helper request. This is used to make multiple I/O
* requests on a variety of sources and then stitch the result together. * operations to a variety of data stores and then stitch the result together.
*/ */
struct netfs_io_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 */
struct netfs_cache_resources cache_resources; 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 */ void *netfs_priv; /* Private data for the netfs */
unsigned int debug_id; unsigned int debug_id;
atomic_t nr_outstanding; /* Number of read ops in progress */ atomic_t nr_outstanding; /* Number of ops in progress */
atomic_t nr_copy_ops; /* Number of write 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 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 */
@ -171,7 +171,7 @@ struct netfs_io_request {
refcount_t usage; refcount_t usage;
unsigned long flags; unsigned long flags;
#define NETFS_RREQ_INCOMPLETE_IO 0 /* Some ioreqs terminated short or with error */ #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_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_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 */
@ -188,7 +188,7 @@ struct netfs_request_ops {
int (*begin_cache_operation)(struct netfs_io_request *rreq); int (*begin_cache_operation)(struct netfs_io_request *rreq);
void (*expand_readahead)(struct netfs_io_request *rreq); void (*expand_readahead)(struct netfs_io_request *rreq);
bool (*clamp_length)(struct netfs_io_subrequest *subreq); 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); 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);