leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

netfs: Rename netfs_read_*request to netfs_io_*request

Browse Source 
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::
void netfs_readahead(struct readahead_control *ractl,
const struct netfs_read_request_ops *ops,
const struct netfs_request_ops *ops,
void *netfs_priv);
int netfs_readpage(struct file *file,
struct folio *folio,
const struct netfs_read_request_ops *ops,
const struct netfs_request_ops *ops,
void *netfs_priv);
int netfs_write_begin(struct file *file,
struct address_space *mapping,
@ -84,7 +84,7 @@ Three read helpers are provided::
unsigned int flags,
struct folio **_folio,
void **_fsdata,
const struct netfs_read_request_ops *ops,
const struct netfs_request_ops *ops,
void *netfs_priv);
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::
* void netfs_subreq_terminated(struct netfs_read_subrequest *subreq,
* void netfs_subreq_terminated(struct netfs_io_subrequest *subreq,
ssize_t transferred_or_error,
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. 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 address_space *mapping;
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;
size_t len;
loff_t i_size;
const struct netfs_read_request_ops *netfs_ops;
const struct netfs_request_ops *netfs_ops;
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
request::
struct netfs_read_subrequest {
struct netfs_read_request *rreq;
struct netfs_io_subrequest {
struct netfs_io_request *rreq;
loff_t start;
size_t len;
size_t transferred;
@ -244,23 +244,23 @@ Read Helper Operations
The network filesystem must provide the read helpers with a table of operations
through which it can issue requests and negotiate::
struct netfs_read_request_ops {
void (*init_rreq)(struct netfs_read_request *rreq, struct file *file);
struct netfs_request_ops {
void (*init_request)(struct netfs_io_request *rreq, struct file *file);
bool (*is_cache_enabled)(struct inode *inode);
int (*begin_cache_operation)(struct netfs_read_request *rreq);
void (*expand_readahead)(struct netfs_read_request *rreq);
bool (*clamp_length)(struct netfs_read_subrequest *subreq);
void (*issue_op)(struct netfs_read_subrequest *subreq);
bool (*is_still_valid)(struct netfs_read_request *rreq);
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);
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);
void (*done)(struct netfs_read_request *rreq);
void (*done)(struct netfs_io_request *rreq);
void (*cleanup)(struct address_space *mapping, void *netfs_priv);
};
The operations are as follows:
* ``init_rreq()``
* ``init_request()``
[Optional] This is called to initialise the request structure. It is given
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
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);
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::
struct netfs_cache_resources {
@ -443,7 +443,7 @@ operation table looks like the following::
void (*expand_readahead)(struct netfs_cache_resources *cres,
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);
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
* @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 iov_iter to;
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
* @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;
@ -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
* @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
* @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
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
}
static const struct netfs_read_request_ops v9fs_req_ops = {
.init_rreq = v9fs_init_rreq,
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,

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)
{
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;
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);
}
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_read *fsreq;
@ -359,7 +359,7 @@ static int afs_symlink_readpage(struct file *file, struct page *page)
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));
}
@ -371,7 +371,7 @@ static bool afs_is_cache_enabled(struct inode *inode)
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
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);
}
const struct netfs_read_request_ops afs_req_ops = {
.init_rreq = afs_init_rreq,
const struct netfs_request_ops afs_req_ops = {
.init_request = afs_init_request,
.is_cache_enabled = afs_is_cache_enabled,
.begin_cache_operation = afs_begin_cache_operation,
.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 */
struct key *key; /* The key to use to reissue the read */
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 */
refcount_t usage;
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 inode_operations afs_file_inode_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 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
* 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)
{
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 cachefiles_object *object;
struct cachefiles_cache *cache;
struct fscache_cookie *cookie = fscache_cres_cookie(cres);
const struct cred *saved_cred;
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;
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;
}
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 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);
}
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 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_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 err = req->r_result;
@ -245,9 +245,9 @@ static void finish_netfs_read(struct ceph_osd_request *req)
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 ceph_mds_reply_info_parsed *rinfo;
struct ceph_mds_reply_info_in *iinfo;
@ -298,9 +298,9 @@ out:
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 ceph_inode_info *ci = ceph_inode(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);
}
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,
.begin_cache_operation = ceph_begin_cache_operation,
.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));
}
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));
@ -143,7 +143,7 @@ static inline bool ceph_is_cache_enabled(struct inode *inode)
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;
}

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");
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)
{
if (refcount_dec_and_test(&subreq->usage))
__netfs_put_subrequest(subreq, was_async);
}
static struct netfs_read_request *netfs_alloc_read_request(
const struct netfs_read_request_ops *ops, void *netfs_priv,
static struct netfs_io_request *netfs_alloc_read_request(
const struct netfs_request_ops *ops, void *netfs_priv,
struct file *file)
{
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) {
rreq->netfs_ops = ops;
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);
refcount_set(&rreq->usage, 1);
__set_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags);
if (ops->init_rreq)
ops->init_rreq(rreq, file);
if (ops->init_request)
ops->init_request(rreq, file);
netfs_stat(&netfs_n_rh_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);
}
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)
{
struct netfs_read_subrequest *subreq;
struct netfs_io_subrequest *subreq;
while (!list_empty(&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);
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)
{
struct netfs_read_request *rreq =
container_of(work, struct netfs_read_request, work);
struct netfs_io_request *rreq =
container_of(work, struct netfs_io_request, work);
netfs_rreq_clear_subreqs(rreq, false);
if (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);
}
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 (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.
*/
static struct netfs_read_subrequest *netfs_alloc_subrequest(
struct netfs_read_request *rreq)
static struct netfs_io_subrequest *netfs_alloc_subrequest(
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) {
INIT_LIST_HEAD(&subreq->rreq_link);
refcount_set(&subreq->usage, 2);
@ -128,15 +128,15 @@ static struct netfs_read_subrequest *netfs_alloc_subrequest(
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);
}
static void __netfs_put_subrequest(struct netfs_read_subrequest *subreq,
static void __netfs_put_subrequest(struct netfs_io_subrequest *subreq,
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);
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.
*/
static void netfs_clear_unread(struct netfs_read_subrequest *subreq)
static void netfs_clear_unread(struct netfs_io_subrequest *subreq)
{
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,
bool was_async)
{
struct netfs_read_subrequest *subreq = priv;
struct netfs_io_subrequest *subreq = priv;
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.
* - Eats the caller's ref on subreq.
*/
static void netfs_read_from_cache(struct netfs_read_request *rreq,
struct netfs_read_subrequest *subreq,
static void netfs_read_from_cache(struct netfs_io_request *rreq,
struct netfs_io_subrequest *subreq,
enum netfs_read_from_hole read_hole)
{
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.
*/
static void netfs_fill_with_zeroes(struct netfs_read_request *rreq,
struct netfs_read_subrequest *subreq)
static void netfs_fill_with_zeroes(struct netfs_io_request *rreq,
struct netfs_io_subrequest *subreq)
{
netfs_stat(&netfs_n_rh_zero);
__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
* cleared.
*/
static void netfs_read_from_server(struct netfs_read_request *rreq,
struct netfs_read_subrequest *subreq)
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);
@ -222,7 +222,7 @@ static void netfs_read_from_server(struct netfs_read_request *rreq,
/*
* 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);
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.
*/
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)
{
struct netfs_read_subrequest *subreq;
struct netfs_io_subrequest *subreq;
struct folio *folio;
pgoff_t unlocked = 0;
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,
bool was_async)
{
struct netfs_read_subrequest *subreq = priv;
struct netfs_read_request *rreq = subreq->rreq;
struct netfs_io_subrequest *subreq = priv;
struct netfs_io_request *rreq = subreq->rreq;
if (IS_ERR_VALUE(transferred_or_error)) {
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);
/* If we decrement nr_wr_ops to 0, the ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_wr_ops))
/* If we decrement nr_copy_ops to 0, the ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_copy_ops))
netfs_rreq_unmark_after_write(rreq, 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
* 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_read_subrequest *subreq, *next, *p;
struct netfs_io_subrequest *subreq, *next, *p;
struct iov_iter iter;
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
* 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) {
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,
subreq->start, subreq->len);
atomic_inc(&rreq->nr_wr_ops);
atomic_inc(&rreq->nr_copy_ops);
netfs_stat(&netfs_n_rh_write);
netfs_get_read_subrequest(subreq);
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);
}
/* If we decrement nr_wr_ops to 0, the usage ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_wr_ops))
/* If we decrement nr_copy_ops to 0, the usage ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_copy_ops))
netfs_rreq_unmark_after_write(rreq, false);
}
static void netfs_rreq_write_to_cache_work(struct work_struct *work)
{
struct netfs_read_request *rreq =
container_of(work, struct netfs_read_request, work);
struct netfs_io_request *rreq =
container_of(work, struct netfs_io_request, work);
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;
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
* 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;
unsigned int iopos, account = 0;
pgoff_t start_page = rreq->start / PAGE_SIZE;
@ -391,7 +391,7 @@ static void netfs_rreq_unlock(struct netfs_read_request *rreq)
* mixture inside.
*/
subreq = list_first_entry(&rreq->subrequests,
struct netfs_read_subrequest, rreq_link);
struct netfs_io_subrequest, rreq_link);
iopos = 0;
subreq_failed = (subreq->error < 0);
@ -450,8 +450,8 @@ static void netfs_rreq_unlock(struct netfs_read_request *rreq)
/*
* Handle a short read.
*/
static void netfs_rreq_short_read(struct netfs_read_request *rreq,
struct netfs_read_subrequest *subreq)
static void netfs_rreq_short_read(struct netfs_io_request *rreq,
struct netfs_io_subrequest *subreq)
{
__clear_bit(NETFS_SREQ_SHORT_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);
netfs_get_read_subrequest(subreq);
atomic_inc(&rreq->nr_rd_ops);
atomic_inc(&rreq->nr_outstanding);
if (subreq->source == NETFS_READ_FROM_CACHE)
netfs_read_from_cache(rreq, subreq, NETFS_READ_HOLE_CLEAR);
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
* 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());
@ -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'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);
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);
trace_netfs_sreq(subreq, netfs_sreq_trace_download_instead);
netfs_get_read_subrequest(subreq);
atomic_inc(&rreq->nr_rd_ops);
atomic_inc(&rreq->nr_outstanding);
netfs_read_from_server(rreq, subreq);
} else if (test_bit(NETFS_SREQ_SHORT_READ, &subreq->flags)) {
netfs_rreq_short_read(rreq, subreq);
}
}
/* If we decrement nr_rd_ops to 0, the usage ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_rd_ops))
/* If we decrement nr_outstanding to 0, the usage ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_outstanding))
return true;
wake_up_var(&rreq->nr_rd_ops);
wake_up_var(&rreq->nr_outstanding);
return false;
}
/*
* 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 ||
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
* 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);
@ -561,8 +561,8 @@ again:
static void netfs_rreq_work(struct work_struct *work)
{
struct netfs_read_request *rreq =
container_of(work, struct netfs_read_request, work);
struct netfs_io_request *rreq =
container_of(work, struct netfs_io_request, work);
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.
* 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)
{
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
* 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,
bool was_async)
{
struct netfs_read_request *rreq = subreq->rreq;
struct netfs_io_request *rreq = subreq->rreq;
int u;
_enter("[%u]{%llx,%lx},%zd",
@ -648,12 +648,12 @@ complete:
out:
trace_netfs_sreq(subreq, netfs_sreq_trace_terminated);
/* If we decrement nr_rd_ops to 0, the ref belongs to us. */
u = atomic_dec_return(&rreq->nr_rd_ops);
/* If we decrement nr_outstanding to 0, the ref belongs to us. */
u = atomic_dec_return(&rreq->nr_outstanding);
if (u == 0)
netfs_rreq_terminated(rreq, was_async);
else if (u == 1)
wake_up_var(&rreq->nr_rd_ops);
wake_up_var(&rreq->nr_outstanding);
netfs_put_subrequest(subreq, was_async);
return;
@ -691,10 +691,10 @@ failed:
}
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)
{
struct netfs_read_request *rreq = subreq->rreq;
struct netfs_io_request *rreq = subreq->rreq;
struct netfs_cache_resources *cres = &rreq->cache_resources;
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.
*/
static enum netfs_read_source
netfs_rreq_prepare_read(struct netfs_read_request *rreq,
struct netfs_read_subrequest *subreq)
static enum netfs_io_source
netfs_rreq_prepare_read(struct netfs_io_request *rreq,
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);
@ -748,11 +748,11 @@ out:
/*
* 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)
{
struct netfs_read_subrequest *subreq;
enum netfs_read_source source;
struct netfs_io_subrequest *subreq;
enum netfs_io_source source;
subreq = netfs_alloc_subrequest(rreq);
if (!subreq)
@ -777,7 +777,7 @@ static bool netfs_rreq_submit_slice(struct netfs_read_request *rreq,
if (source == NETFS_INVALID_READ)
goto subreq_failed;
atomic_inc(&rreq->nr_rd_ops);
atomic_inc(&rreq->nr_outstanding);
rreq->submitted += subreq->len;
@ -804,7 +804,7 @@ subreq_failed:
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)
{
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);
}
static void netfs_rreq_expand(struct netfs_read_request *rreq,
static void netfs_rreq_expand(struct netfs_io_request *rreq,
struct readahead_control *ractl)
{
/* 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.
*/
void netfs_readahead(struct readahead_control *ractl,
const struct netfs_read_request_ops *ops,
const struct netfs_request_ops *ops,
void *netfs_priv)
{
struct netfs_read_request *rreq;
struct netfs_io_request *rreq;
unsigned int debug_index = 0;
int ret;
@ -897,7 +897,7 @@ void netfs_readahead(struct readahead_control *ractl,
netfs_rreq_expand(rreq, ractl);
atomic_set(&rreq->nr_rd_ops, 1);
atomic_set(&rreq->nr_outstanding, 1);
do {
if (!netfs_rreq_submit_slice(rreq, &debug_index))
break;
@ -910,8 +910,8 @@ void netfs_readahead(struct readahead_control *ractl,
while (readahead_folio(ractl))
;
/* If we decrement nr_rd_ops to 0, the ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_rd_ops))
/* If we decrement nr_outstanding to 0, the ref belongs to us. */
if (atomic_dec_and_test(&rreq->nr_outstanding))
netfs_rreq_assess(rreq, false);
return;
@ -944,10 +944,10 @@ EXPORT_SYMBOL(netfs_readahead);
*/
int netfs_readpage(struct file *file,
struct folio *folio,
const struct netfs_read_request_ops *ops,
const struct netfs_request_ops *ops,
void *netfs_priv)
{
struct netfs_read_request *rreq;
struct netfs_io_request *rreq;
unsigned int debug_index = 0;
int ret;
@ -977,19 +977,19 @@ int netfs_readpage(struct file *file,
netfs_get_read_request(rreq);
atomic_set(&rreq->nr_rd_ops, 1);
atomic_set(&rreq->nr_outstanding, 1);
do {
if (!netfs_rreq_submit_slice(rreq, &debug_index))
break;
} 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
* process.
*/
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);
} 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,
loff_t pos, unsigned int len, unsigned int aop_flags,
struct folio **_folio, void **_fsdata,
const struct netfs_read_request_ops *ops,
const struct netfs_request_ops *ops,
void *netfs_priv)
{
struct netfs_read_request *rreq;
struct netfs_io_request *rreq;
struct folio *folio;
struct inode *inode = file_inode(file);
unsigned int debug_index = 0, fgp_flags;
@ -1153,19 +1153,19 @@ retry:
while (readahead_folio(&ractl))
;
atomic_set(&rreq->nr_rd_ops, 1);
atomic_set(&rreq->nr_outstanding, 1);
do {
if (!netfs_rreq_submit_slice(rreq, &debug_index))
break;
} 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
* process.
*/
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);
if (!test_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags))
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));
}
enum netfs_read_source {
enum netfs_io_source {
NETFS_FILL_WITH_ZEROES,
NETFS_DOWNLOAD_FROM_SERVER,
NETFS_READ_FROM_CACHE,
@ -130,8 +130,8 @@ struct netfs_cache_resources {
/*
* Descriptor for a single component subrequest.
*/
struct netfs_read_subrequest {
struct netfs_read_request *rreq; /* Supervising read request */
struct netfs_io_subrequest {
struct netfs_io_request *rreq; /* Supervising read 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,7 +139,7 @@ struct netfs_read_subrequest {
refcount_t usage;
short error; /* 0 or error that occurred */
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;
#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 */
@ -152,7 +152,7 @@ struct netfs_read_subrequest {
* 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.
*/
struct netfs_read_request {
struct netfs_io_request {
struct work_struct work;
struct inode *inode; /* The file 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 */
void *netfs_priv; /* Private data for the netfs */
unsigned int debug_id;
atomic_t nr_rd_ops; /* Number of read ops in progress */
atomic_t nr_wr_ops; /* Number of write ops in progress */
atomic_t nr_outstanding; /* Number of read 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 len; /* Length of the request */
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_FAILED 4 /* The request failed */
#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.
*/
struct netfs_read_request_ops {
struct netfs_request_ops {
bool (*is_cache_enabled)(struct inode *inode);
void (*init_rreq)(struct netfs_read_request *rreq, struct file *file);
int (*begin_cache_operation)(struct netfs_read_request *rreq);
void (*expand_readahead)(struct netfs_read_request *rreq);
bool (*clamp_length)(struct netfs_read_subrequest *subreq);
void (*issue_op)(struct netfs_read_subrequest *subreq);
bool (*is_still_valid)(struct netfs_read_request *rreq);
void (*init_request)(struct netfs_io_request *rreq, struct file *file);
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);
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);
void (*done)(struct netfs_read_request *rreq);
void (*done)(struct netfs_io_request *rreq);
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
* 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);
/* Prepare a write operation, working out what part of the write we can
@ -255,19 +255,19 @@ struct netfs_cache_ops {
struct readahead_control;
extern void netfs_readahead(struct readahead_control *,
const struct netfs_read_request_ops *,
const struct netfs_request_ops *,
void *);
extern int netfs_readpage(struct file *,
struct folio *,
const struct netfs_read_request_ops *,
const struct netfs_request_ops *,
void *);
extern int netfs_write_begin(struct file *, struct address_space *,
loff_t, unsigned int, unsigned int, struct folio **,
void **,
const struct netfs_read_request_ops *,
const struct netfs_request_ops *,
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 *);
#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,
TP_PROTO(struct netfs_read_subrequest *sreq,
enum netfs_read_source source,
TP_PROTO(struct netfs_io_subrequest *sreq,
enum netfs_io_source source,
enum cachefiles_prepare_read_trace why,
ino_t cache_inode),
@ -435,7 +435,7 @@ TRACE_EVENT(cachefiles_prep_read,
__field(unsigned int, rreq )
__field(unsigned short, index )
__field(unsigned short, flags )
__field(enum netfs_read_source, source )
__field(enum netfs_io_source, source )
__field(enum cachefiles_prepare_read_trace, why )
__field(size_t, len )
__field(loff_t, start )

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

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