netfs, afs, cifs: Delegate high-level I/O to netfslib
Subsystems (13)
David Howells
maintainercover netfs, afs, cifs: Delegate high-level I/O to netfslib
Hi Jeff, Steve,
I have been working on my netfslib helpers to the point that I can run xfstests on AFS to completion (both with write-back buffering and, with a small patch, write-through buffering in the pagecache). I can also run a certain amount of xfstests on CIFS, though that requires some more debugging. However, this seems like a good time to post a preview of the patches.
The patches remove a little over 800 lines from AFS and over 2000 from CIFS, albeit with around 3000 lines added to netfs. Hopefully, I will be able to remove a bunch of lines from 9P and Ceph too.
The main aims of these patches are to get high-level I/O and knowledge of the pagecache out of the filesystem drivers as much as possible and to get rid, as much of possible, of the knowledge that pages/folios exist.
Further, I would like to see ->write_begin, ->write_end and ->launder_folio go away.
Features that are added by these patches to that which is already there in netfslib:
(1) NFS-style (and Ceph-style) locking around DIO vs buffered I/O calls to prevent these from happening at the same time. mmap'd I/O can, of necessity, happen at any time ignoring these locks.
(2) Support for unbuffered I/O. The data is kept in the bounce buffer and the pagecache is not used. This can be turned on with an inode flag.
(3) Support for direct I/O. This is basically unbuffered I/O with some extra restrictions and no RMW.
(4) Support for using a bounce buffer in an operation. The bounce buffer may be bigger than the target data/buffer, allowing for crypto rounding.
(5) Support for content encryption. This isn't supported yet by AFS/CIFS but is aimed initially at Ceph.
(6) ->write_begin() and ->write_end() are ignored in favour of merging all of that into one function, netfs_perform_write(), thereby avoiding the function pointer traversals.
(7) Support for write-through caching in the pagecache. netfs_perform_write() adds the pages is modifies to an I/O operation as it goes and directly marks them writeback rather than dirty. When writing back from write-through, it limits the range written back. This should allow CIFS to deal with byte-range mandatory locks correctly.
(8) O_*SYNC and RWF_*SYNC writes use write-through rather than writing to the pagecache and then flushing afterwards. An AIO O_*SYNC write will notify of completion when the sub-writes all complete.
(9) Support for write-streaming where modifed data is held in !uptodate folios, with a private struct attached indicating the range that is valid.
(10) Support for write grouping, multiplexing a pointer to a group in the folio private data with the write-streaming data. The writepages algorithm only writes stuff back that's in the nominated group. This is intended for use by Ceph to write is snaps in order.
(11) Skipping reads for which we know the server could only supply zeros or EOF (for instance if we've done a local write that leaves a hole in the file and extends the local inode size).
General notes:
(1) netfslib now makes use of folio->private, which means the filesystem can't use it.
(2) Use of fscache is not yet tested. I'm not sure whether to allow a cache to be used with a write-through write.
(3) The filesystem provides wrappers to call the write helpers, allowing it to do pre-validation, oplock/capability fetching and the passing in of write group info.
(4) I want to try flushing the data when tearing down an inode before invalidating it to try and render launder_folio unnecessary.
(5) Write-through caching will generate and dispatch write subrequests as it gathers enough data to hit wsize and has whole pages that at least span that size. This needs to be a bit more flexible, allowing for a filesystem such as CIFS to have a variable wsize.
(6) The filesystem driver is just given read and write calls with an iov_iter describing the data/buffer to use. Ideally, they don't see pages or folios at all. A function, extract_iter_to_sg(), is already available to decant part of an iterator into a scatterlist for crypto purposes.
CIFS notes:
(1) CIFS is made to use unbuffered I/O for unbuffered caching modes and write-through caching for cache=strict.
(2) cifs_init_request() occasionally throws an error that it can't get a writable file when trying to do writeback.
(3) Apparent file corruption frequently appears in the target file when cifs_copy_file_range(), even though it doesn't use any netfslib helpers and even if it doesn't overlap with any pages in the pagecache.
(4) I should be able to turn multipage folio support on in CIFS now.
(5) The then-unused CIFS code is removed in three patches, not one, to avoid the git patch generator from producing confusing patches in which it thinks code is being moved around rather than just being removed.
David
David Howells (53):
netfs: Add a procfile to list in-progress requests
netfs: Track the fpos above which the server has no data
netfs: Note nonblockingness in the netfs_io_request struct
netfs: Allow the netfs to make the io (sub)request alloc larger
netfs: Add a ->free_subrequest() op
afs: Don't use folio->private to record partial modification
netfs: Provide invalidate_folio and release_folio calls
netfs: Add rsize to netfs_io_request
netfs: Implement unbuffered/DIO vs buffered I/O locking
netfs: Add iov_iters to (sub)requests to describe various buffers
netfs: Add support for DIO buffering
netfs: Provide tools to create a buffer in an xarray
netfs: Add bounce buffering support
netfs: Add func to calculate pagecount/size-limited span of an
iterator
netfs: Limit subrequest by size or number of segments
netfs: Export netfs_put_subrequest() and some tracepoints
netfs: Extend the netfs_io_*request structs to handle writes
netfs: Add a hook to allow tell the netfs to update its i_size
netfs: Make netfs_put_request() handle a NULL pointer
fscache: Add a function to begin an cache op from a netfslib request
netfs: Make the refcounting of netfs_begin_read() easier to use
netfs: Prep to use folio->private for write grouping and streaming
write
netfs: Dispatch write requests to process a writeback slice
netfs: Provide func to copy data to pagecache for buffered write
netfs: Make netfs_read_folio() handle streaming-write pages
netfs: Allocate multipage folios in the writepath
netfs: Implement support for unbuffered/DIO read
netfs: Implement unbuffered/DIO write support
netfs: Implement buffered write API
netfs: Allow buffered shared-writeable mmap through
netfs_page_mkwrite()
netfs: Provide netfs_file_read_iter()
netfs: Provide a writepages implementation
netfs: Provide minimum blocksize parameter
netfs: Make netfs_skip_folio_read() take account of blocksize
netfs: Perform content encryption
netfs: Decrypt encrypted content
netfs: Support decryption on ubuffered/DIO read
netfs: Support encryption on Unbuffered/DIO write
netfs: Provide a launder_folio implementation
netfs: Implement a write-through caching option
netfs: Rearrange netfs_io_subrequest to put request pointer first
afs: Use the netfs write helpers
cifs: Replace cifs_readdata with a wrapper around netfs_io_subrequest
cifs: Share server EOF pos with netfslib
cifs: Replace cifs_writedata with a wrapper around netfs_io_subrequest
cifs: Use more fields from netfs_io_subrequest
cifs: Make wait_mtu_credits take size_t args
cifs: Implement netfslib hooks
cifs: Move cifs_loose_read_iter() and cifs_file_write_iter() to file.c
cifs: Cut over to using netfslib
cifs: Remove some code that's no longer used, part 1
cifs: Remove some code that's no longer used, part 2
cifs: Remove some code that's no longer used, part 3
fs/9p/vfs_addr.c | 51 +- fs/afs/file.c | 206 +-- fs/afs/inode.c | 15 +- fs/afs/internal.h | 66 +- fs/afs/write.c | 816 +--------- fs/ceph/addr.c | 28 +- fs/ceph/cache.h | 12 - fs/fscache/io.c | 42 + fs/netfs/Makefile | 9 +- fs/netfs/buffered_read.c | 245 ++- fs/netfs/buffered_write.c | 1223 ++++++++++++++ fs/netfs/crypto.c | 148 ++ fs/netfs/direct_read.c | 263 +++ fs/netfs/direct_write.c | 359 +++++ fs/netfs/internal.h | 121 ++ fs/netfs/io.c | 325 +++- fs/netfs/iterator.c | 97 ++ fs/netfs/locking.c | 209 +++ fs/netfs/main.c | 101 ++ fs/netfs/misc.c | 237 +++ fs/netfs/objects.c | 64 +- fs/netfs/output.c | 485 ++++++ fs/netfs/stats.c | 22 +- fs/smb/client/Kconfig | 1 + fs/smb/client/cifsfs.c | 65 +- fs/smb/client/cifsfs.h | 10 +- fs/smb/client/cifsglob.h | 59 +- fs/smb/client/cifsproto.h | 10 +- fs/smb/client/cifssmb.c | 111 +- fs/smb/client/file.c | 2905 ++++++---------------------------- fs/smb/client/fscache.c | 109 -- fs/smb/client/fscache.h | 54 - fs/smb/client/inode.c | 25 +- fs/smb/client/smb2ops.c | 20 +- fs/smb/client/smb2pdu.c | 168 +- fs/smb/client/smb2proto.h | 5 +- fs/smb/client/trace.h | 144 +- fs/smb/client/transport.c | 17 +- include/linux/fscache.h | 6 + include/linux/netfs.h | 173 +- include/trace/events/afs.h | 31 - include/trace/events/netfs.h | 158 +- 42 files changed, 5136 insertions(+), 4079 deletions(-) create mode 100644 fs/netfs/buffered_write.c create mode 100644 fs/netfs/crypto.c create mode 100644 fs/netfs/direct_read.c create mode 100644 fs/netfs/direct_write.c create mode 100644 fs/netfs/locking.c create mode 100644 fs/netfs/misc.c create mode 100644 fs/netfs/output.c
David Howells
maintainerRFC PATCH 1/53 netfs: Add a procfile to list in-progress requests
Add a procfile, /proc/fs/netfs/requests, to list in-progress netfslib I/O requests.
--- fs/netfs/internal.h | 22 +++++++++++ fs/netfs/main.c | 91 +++++++++++++++++++++++++++++++++++++++++++ fs/netfs/objects.c | 4 +- include/linux/netfs.h | 6 ++- 4 files changed, 121 insertions(+), 2 deletions(-)
fs/netfs/internal.h +22 -0
@@ -29,6 +29,28 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync);* main.c */ extern unsigned int netfs_debug; +extern struct list_head netfs_io_requests; +extern spinlock_t netfs_proc_lock; + +#ifdef CONFIG_PROC_FS +static inline void netfs_proc_add_rreq (struct netfs_io_request *rreq) +{ +spin_lock (&netfs_proc_lock); +list_add_tail_rcu (&rreq->proc_link, &netfs_io_requests); +spin_unlock (&netfs_proc_lock); +} +static inline void netfs_proc_del_rreq (struct netfs_io_request *rreq) +{ +if (!list_empty (&rreq->proc_link)) { +spin_lock (&netfs_proc_lock); +list_del_rcu (&rreq->proc_link); +spin_unlock (&netfs_proc_lock); + } +} +#else +static inline void netfs_proc_add_rreq (struct netfs_io_request *rreq) {} +static inline void netfs_proc_del_rreq (struct netfs_io_request *rreq) {} +#endif /* * objects.c
fs/netfs/main.c +91 -0
100 lines not on this page · raw message
fs/netfs/objects.c +3 -1
@@ -45,6 +45,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, } } +netfs_proc_add_rreq (rreq);netfs_stat (&netfs_n_rh_rreq);return rreq; }
@@ -76,12 +77,13 @@ static void netfs_free_request(struct work_struct *work) container_of(work, struct netfs_io_request, work);trace_netfs_rreq (rreq, netfs_rreq_trace_free); +netfs_proc_del_rreq (rreq);netfs_clear_subrequests (rreq, false);if (rreq->netfs_ops->free_request) rreq->netfs_ops->free_request (rreq);if (rreq->cache_resources.ops) rreq->cache_resources.ops->end_operation (&rreq->cache_resources); -kfree (rreq); +kfree_rcu (rreq, rcu);netfs_stat_d (&netfs_n_rh_rreq); }
include/linux/netfs.h +5 -1
@@ -175,10 +175,14 @@ enum netfs_io_origin {* operations to a variety of data stores and then stitch the result together. */ struct netfs_io_request { -struct work_struct work; +union { +struct work_struct work; +struct rcu_head rcu; + };struct inode *inode;/* The file being accessed */ struct address_space *mapping;/* The mapping being accessed */ struct netfs_cache_resources cache_resources; +struct list_head proc_link;/* Link in netfs_iorequests */ struct list_head subrequests;/* Contributory I/O operations */ void *netfs_priv;/* Private data for the netfs */ unsigned int debug_id;
David Howells
maintainerRFC PATCH 2/53 netfs: Track the fpos above which the server has no data
In reply to David HowellsTrack the file position above which the server is not expected to have any data and preemptively assume that we can simply fill blocks with zeroes locally rather than attempting to download them - even if we've written data back to the server. Assume that any data that was written back above that position is held in the local cache. Call this the "zero point".
Make use of this to optimise away some reads from the server. We need to set the zero point in the following circumstances:
(1) When we see an extant remote inode and have no cache for it, we set the zero_point to i_size.
(2) On local inode creation, we set zero_point to 0.
(3) On local truncation down, we reduce zero_point to the new i_size if the new i_size is lower.
(4) On local truncation up, we don't change zero_point.
(5) On local modification, we don't change zero_point.
(6) On remote invalidation, we set zero_point to the new i_size.
(7) If stored data is culled from the local cache, we must set zero_point above that if the data also got written to the server.
(8) If dirty data is written back to the server, but not the local cache, we must set zero_point above that.
Assuming the above, any read from the server at or above the zero_point position will return all zeroes.
The zero_point value can be stored in the cache, provided the above rules are applied to it by any code that culls part of the local cache.
--- fs/afs/inode.c | 13 +++++++------ fs/netfs/buffered_read.c | 40 +++++++++++++++++++++++++--------------- include/linux/netfs.h | 5 +++++ 3 files changed, 37 insertions(+), 21 deletions(-)
fs/afs/inode.c +7 -6
@@ -252,6 +252,7 @@ static void afs_apply_status(struct afs_operation *op, vnode->netfs.remote_i_size = status->size;if (change_size) {afs_set_i_size (vnode, status->size); + vnode->netfs.zero_point = status->size;inode_set_ctime_to_ts (inode, t); inode->i_atime = t; }
@@ -865,17 +866,17 @@ static void afs_setattr_success(struct afs_operation *op)static void afs_setattr_edit_file (struct afs_operation *op) {struct afs_vnode_param *vp = &op->file[0 ]; -struct inode *inode = &vp->vnode->netfs.inode; +struct afs_vnode *vnode = vp->vnode;if (op->setattr.attr->ia_valid &ATTR_SIZE ) {loff_t size = op->setattr.attr->ia_size;loff_t i_size = op->setattr.old_i_size; -if (size < i_size) -truncate_pagecache (inode, size); -if (size != i_size) -fscache_resize_cookie (afs_vnode_cache (vp->vnode), - vp->scb.status.size); +if (size != i_size) { +truncate_pagecache (&vnode->netfs.inode, size); +netfs_resize_file (&vnode->netfs, size); +fscache_resize_cookie (afs_vnode_cache (vnode), size); + } } }
fs/netfs/buffered_read.c +25 -15
@@ -147,6 +147,22 @@ static void netfs_rreq_expand(struct netfs_io_request *rreq, } } +/* +* Begin an operation, and fetch the stored zero point value from the cookie if +* available. +*/ +static int netfs_begin_cache_operation (struct netfs_io_request *rreq, +struct netfs_inode *ctx) +{ +int ret = -ENOBUFS ; + +if (ctx->ops->begin_cache_operation) { + ret = ctx->ops->begin_cache_operation (rreq); +/* TODO: Get the zero point value from the cache */ + } +return ret; +} +/** * netfs_readahead - Helper to manage a read request * @ractl: The description of the readahead request
@@ -180,11 +196,9 @@ void netfs_readahead(struct readahead_control *ractl)if (IS_ERR (rreq))return ; -if (ctx->ops->begin_cache_operation) { - ret = ctx->ops->begin_cache_operation (rreq); -if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) - goto cleanup_free; - } + ret =netfs_begin_cache_operation (rreq, ctx); +if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) + goto cleanup_free;netfs_stat (&netfs_n_rh_readahead); trace_netfs_read(rreq, readahead_pos(ractl), readahead_length(ractl),
@@ -238,11 +252,9 @@ int netfs_read_folio(struct file *file, struct folio *folio) goto alloc_error; } -if (ctx->ops->begin_cache_operation) { - ret = ctx->ops->begin_cache_operation (rreq); -if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) - goto discard; - } + ret =netfs_begin_cache_operation (rreq, ctx); +if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) + goto discard;netfs_stat (&netfs_n_rh_readpage);trace_netfs_read (rreq, rreq->start, rreq->len, netfs_read_trace_readpage);
@@ -390,11 +402,9 @@ int netfs_write_begin(struct netfs_inode *ctx, rreq->no_unlock_folio =folio_index (folio);__set_bit (NETFS_RREQ_NO_UNLOCK_FOLIO , &rreq->flags); -if (ctx->ops->begin_cache_operation) { - ret = ctx->ops->begin_cache_operation (rreq); -if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) - goto error_put; - } + ret =netfs_begin_cache_operation (rreq, ctx); +if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) + goto error_put;netfs_stat (&netfs_n_rh_write_begin);trace_netfs_read (rreq, pos, len, netfs_read_trace_write_begin);
include/linux/netfs.h +5 -0
@@ -129,6 +129,8 @@ struct netfs_inode {struct fscache_cookie *cache;#endif loff_t remote_i_size;/* Size of the remote file */ +loff_t zero_point;/* Size after which we assume there's no data +* on the server */ };/*
@@ -330,6 +332,7 @@ static inline void netfs_inode_init(struct netfs_inode *ctx, { ctx->ops = ops; ctx->remote_i_size =i_size_read (&ctx->inode); + ctx->zero_point = ctx->remote_i_size;#if IS_ENABLED (CONFIG_FSCACHE ) ctx->cache =NULL ;#endif
@@ -345,6 +348,8 @@ static inline void netfs_inode_init(struct netfs_inode *ctx,static inline void netfs_resize_file (struct netfs_inode *ctx,loff_t new_i_size) { ctx->remote_i_size = new_i_size; +if (new_i_size < ctx->zero_point) + ctx->zero_point = new_i_size; }/**
David Howells
maintainerRFC PATCH 3/53 netfs: Note nonblockingness in the netfs_io_request struct
In reply to David HowellsAllow O_NONBLOCK to be noted in the netfs_io_request struct. Also add a flag, NETFS_RREQ_BLOCKED to record if we did block.
--- fs/netfs/objects.c | 2 ++ include/linux/netfs.h | 2 ++ 2 files changed, 4 insertions(+)
fs/netfs/objects.c +2 -0
@@ -37,6 +37,8 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,INIT_LIST_HEAD (&rreq->subrequests);refcount_set (&rreq->ref,1 );__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags); +if (file && file->f_flags &O_NONBLOCK ) +__set_bit (NETFS_RREQ_NONBLOCK , &rreq->flags);if (rreq->netfs_ops->init_request) { ret = rreq->netfs_ops->init_request (rreq, file);if (ret <0 ) {
include/linux/netfs.h +2 -0
@@ -205,6 +205,8 @@ struct netfs_io_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 */ +#define NETFS_RREQ_NONBLOCK 6/* Don't block if possible (O_NONBLOCK) */ +#define NETFS_RREQ_BLOCKED 7/* We blocked */ const struct netfs_request_ops *netfs_ops; };
David Howells
maintainerRFC PATCH 4/53 netfs: Allow the netfs to make the io (sub)request alloc larger
In reply to David HowellsAllow the network filesystem to specify extra space to be allocated on the end of the io (sub)request. This allows cifs, for example, to use this space rather than allocating its own cifs_readdata struct.
--- fs/netfs/objects.c | 7 +++++-- include/linux/netfs.h | 2 ++ 2 files changed, 7 insertions(+), 2 deletions(-)
fs/netfs/objects.c +5 -2
@@ -22,7 +22,8 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,struct netfs_io_request *rreq;int ret; - rreq =kzalloc (sizeof (struct netfs_io_request ),GFP_KERNEL ); + rreq =kzalloc (ctx->ops->io_request_size ?:sizeof (struct netfs_io_request ), +GFP_KERNEL );if (!rreq)return ERR_PTR (-ENOMEM );
@@ -116,7 +117,9 @@ struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreq {struct netfs_io_subrequest *subreq; - subreq =kzalloc (sizeof (struct netfs_io_subrequest ),GFP_KERNEL ); + subreq =kzalloc (rreq->netfs_ops->io_subrequest_size ?: +sizeof (struct netfs_io_subrequest ), +GFP_KERNEL );if (subreq) {INIT_LIST_HEAD (&subreq->rreq_link);refcount_set (&subreq->ref,2 );
include/linux/netfs.h +2 -0
@@ -214,6 +214,8 @@ struct netfs_io_request {* Operations the network filesystem can/must provide to the helpers. */ struct netfs_request_ops { +unsigned int io_request_size;/* Alloc size for netfs_io_request struct */ +unsigned int io_subrequest_size;/* Alloc size for netfs_io_subrequest struct */ int (*init_request)(struct netfs_io_request *rreq,struct file *file);void (*free_request)(struct netfs_io_request *rreq);int (*begin_cache_operation)(struct netfs_io_request *rreq);
David Howells
maintainerRFC PATCH 5/53 netfs: Add a ->free_subrequest() op
In reply to David HowellsAdd a ->free_subrequest() op so that the netfs can clean up data attached to a subrequest.
--- fs/netfs/objects.c | 2 ++ include/linux/netfs.h | 1 + 2 files changed, 3 insertions(+)
fs/netfs/objects.c +2 -0
@@ -147,6 +147,8 @@ static void netfs_free_subrequest(struct netfs_io_subrequest *subreq,struct netfs_io_request *rreq = subreq->rreq;trace_netfs_sreq (subreq, netfs_sreq_trace_free); +if (rreq->netfs_ops->free_subrequest) + rreq->netfs_ops->free_subrequest (subreq);kfree (subreq);netfs_stat_d (&netfs_n_rh_sreq);netfs_put_request (rreq, was_async, netfs_rreq_trace_put_subreq);
include/linux/netfs.h +1 -0
@@ -218,6 +218,7 @@ struct netfs_request_ops {unsigned int io_subrequest_size;/* Alloc size for netfs_io_subrequest struct */ int (*init_request)(struct netfs_io_request *rreq,struct file *file);void (*free_request)(struct netfs_io_request *rreq); +void (*free_subrequest)(struct netfs_io_subrequest *rreq);int (*begin_cache_operation)(struct netfs_io_request *rreq);void (*expand_readahead)(struct netfs_io_request *rreq);
David Howells
maintainerRFC PATCH 6/53 afs: Don't use folio->private to record partial modification
In reply to David HowellsAFS currently uses folio->private to store the range of bytes within a folio that have been modified - the idea being that if we have, say, a 2MiB folio and someone writes a single byte, we only have to write back that single page and not the whole 2MiB folio - thereby saving on network bandwidth.
Remove this, at least for now, and accept the extra network load (which doesn't matter in the common case of writing a whole file at a time from beginning to end).
This makes folio->private available for netfslib to use.
--- fs/afs/file.c | 67 ------------- fs/afs/internal.h | 56 ----------- fs/afs/write.c | 188 ++++++++----------------------------- include/trace/events/afs.h | 16 +--- 4 files changed, 42 insertions(+), 285 deletions(-)
fs/afs/file.c +0 -67
@@ -405,63 +405,6 @@ int afs_write_inode(struct inode *inode, struct writeback_control *wbc)return 0 ; } -/* -* Adjust the dirty region of the page on truncation or full invalidation, -* getting rid of the markers altogether if the region is entirely invalidated. -*/ -static void afs_invalidate_dirty (struct folio *folio,size_t offset, -size_t length) -{ -struct afs_vnode *vnode =AFS_FS_I (folio_inode (folio)); -unsigned long priv; -unsigned int f, t, end = offset + length; - - priv = (unsigned long )folio_get_private (folio); - -/* we clean up only if the entire page is being invalidated */ -if (offset ==0 && length ==folio_size (folio)) - goto full_invalidate; - -/* If the page was dirtied by page_mkwrite(), the PTE stays writable -* and we don't get another notification to tell us to expand it -* again. -*/ -if (afs_is_folio_dirty_mmapped (priv)) -return ; - -/* We may need to shorten the dirty region */ - f =afs_folio_dirty_from (folio, priv); - t =afs_folio_dirty_to (folio, priv); - -if (t <= offset || f >= end) -return ;/* Doesn't overlap */ - -if (f < offset && t > end) -return ;/* Splits the dirty region - just absorb it */ - -if (f >= offset && t <= end) - goto undirty; - -if (f < offset) - t = offset; -else - f = end; -if (f == t) - goto undirty; - - priv =afs_folio_dirty (folio, f, t); -folio_change_private (folio, (void *)priv); -trace_afs_folio_dirty (vnode,tracepoint_string ("trunc" ), folio); -return ; - -undirty: -trace_afs_folio_dirty (vnode,tracepoint_string ("undirty" ), folio); -folio_clear_dirty_for_io (folio); -full_invalidate: -trace_afs_folio_dirty (vnode,tracepoint_string ("inval" ), folio); -folio_detach_private (folio); -} -/* * invalidate part or all of a page * - release a page and clean up its private data if offset is 0 (indicating
@@ -472,11 +415,6 @@ static void afs_invalidate_folio(struct folio *folio, size_t offset, {_enter ("{%lu},%zu,%zu" , folio->index, offset, length); -BUG_ON (!folio_test_locked (folio)); - -if (folio_get_private (folio)) -afs_invalidate_dirty (folio, offset, length); -folio_wait_fscache (folio);_leave ("" ); }
@@ -504,11 +442,6 @@ static bool afs_release_folio(struct folio *folio, gfp_t gfp)fscache_note_page_release (afs_vnode_cache (vnode));#endif -if (folio_test_private (folio)) { -trace_afs_folio_dirty (vnode,tracepoint_string ("rel" ), folio); -folio_detach_private (folio); - } -/* Indicate that the folio can be released */ _leave (" = T" );return true;
fs/afs/internal.h +0 -56
62 lines not on this page · raw message
fs/afs/write.c +38 -150
353 lines not on this page · raw message
include/trace/events/afs.h +4 -12
@@ -846,26 +846,18 @@ TRACE_EVENT(afs_folio_dirty, __field(struct afs_vnode *, vnode) __field(const char *, where) __field(pgoff_t, index) - __field(unsigned long, from) - __field(unsigned long, to) + __field(size_t, size) ),TP_fast_assign ( - unsigned long priv = (unsigned long)folio_get_private(folio); __entry->vnode = vnode; __entry->where = where; __entry->index =folio_index (folio); - __entry->from =afs_folio_dirty_from (folio, priv); - __entry->to =afs_folio_dirty_to (folio, priv); - __entry->to |= (afs_is_folio_dirty_mmapped (priv) ? - (1UL << (BITS_PER_LONG -1 )) :0 ); + __entry->size =folio_size (folio); ), -TP_printk ("vn=%p %lx %s %lx-%lx%s" , - __entry->vnode, __entry->index, __entry->where, - __entry->from, - __entry->to & ~(1UL << (BITS_PER_LONG -1 )), - __entry->to & (1UL << (BITS_PER_LONG -1 )) ?" M" :"" ) +TP_printk ("vn=%p ix=%05lx s=%05lx %s" , + __entry->vnode, __entry->index, __entry->size, __entry->where) ); TRACE_EVENT(afs_call_state,
David Howells
maintainerRFC PATCH 7/53 netfs: Provide invalidate_folio and release_folio calls
In reply to David HowellsProvide default invalidate_folio and release_folio calls. These will need to interact with invalidation correctly at some point. They will be needed if netfslib is to make use of folio->private for its own purposes.
--- fs/9p/vfs_addr.c | 33 ++------------------------- fs/afs/file.c | 53 ++++--------------------------------------- fs/ceph/addr.c | 24 ++------------------ fs/netfs/Makefile | 1 + fs/netfs/misc.c | 51 +++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 6 +++-- 6 files changed, 64 insertions(+), 104 deletions(-) create mode 100644 fs/netfs/misc.c
fs/9p/vfs_addr.c +2 -31
@@ -104,35 +104,6 @@ const struct netfs_request_ops v9fs_req_ops = { .issue_read = v9fs_issue_read, }; -/** -* v9fs_release_folio - release the private state associated with a folio -* @folio: The folio to be released -* @gfp: The caller's allocation restrictions -* -* Returns true if the page can be released, false otherwise. -*/ - -static bool v9fs_release_folio (struct folio *folio,gfp_t gfp) -{ -if (folio_test_private (folio)) -return false; -#ifdef CONFIG_9P_FSCACHE -if (folio_test_fscache (folio)) { -if (current_is_kswapd () || !(gfp & __GFP_FS)) -return false; -folio_wait_fscache (folio); - } -fscache_note_page_release (v9fs_inode_cookie (V9FS_I (folio_inode (folio)))); -#endif -return true; -} - -static void v9fs_invalidate_folio (struct folio *folio,size_t offset, -size_t length) -{ -folio_wait_fscache (folio); -} -#ifdef CONFIG_9P_FSCACHE static void v9fs_write_to_cache_done (void *priv,ssize_t transferred_or_error,bool was_async)
@@ -355,8 +326,8 @@ const struct address_space_operations v9fs_addr_operations = { .writepage = v9fs_vfs_writepage, .write_begin = v9fs_write_begin, .write_end = v9fs_write_end, - .release_folio = v9fs_release_folio, - .invalidate_folio = v9fs_invalidate_folio, + .release_folio = netfs_release_folio, + .invalidate_folio = netfs_invalidate_folio, .launder_folio = v9fs_launder_folio, .direct_IO = v9fs_direct_IO, };
fs/afs/file.c +4 -49
77 lines not on this page · raw message
fs/ceph/addr.c +2 -22
@@ -160,27 +160,7 @@ static void ceph_invalidate_folio(struct folio *folio, size_t offset,ceph_put_snap_context (snapc); } -folio_wait_fscache (folio); -} - -static bool ceph_release_folio (struct folio *folio,gfp_t gfp) -{ -struct inode *inode = folio->mapping->host; - -dout ("%llx:%llx release_folio idx %lu (%sdirty)\n" , -ceph_vinop (inode), - folio->index,folio_test_dirty (folio) ?"" :"not " ); - -if (folio_test_private (folio)) -return false; - -if (folio_test_fscache (folio)) { -if (current_is_kswapd () || !(gfp & __GFP_FS)) -return false; -folio_wait_fscache (folio); - } -ceph_fscache_note_page_release (inode); -return true; +netfs_invalidate_folio (folio, offset, length); }static void ceph_netfs_expand_readahead (struct netfs_io_request *rreq)
@@ -1563,7 +1543,7 @@ const struct address_space_operations ceph_aops = { .write_end = ceph_write_end, .dirty_folio = ceph_dirty_folio, .invalidate_folio = ceph_invalidate_folio, - .release_folio = ceph_release_folio, + .release_folio = netfs_release_folio, .direct_IO = noop_direct_IO, };
fs/netfs/Makefile +1 -0
@@ -5,6 +5,7 @@ netfs-y := \ io.o \ iterator.o \ main.o \ + misc.o \ objects.o netfs-$(CONFIG_NETFS_STATS) += stats.o
fs/netfs/misc.c new file +51 -0
51 lines not on this page · raw message
include/linux/netfs.h +4 -2
@@ -299,8 +299,10 @@ struct readahead_control;void netfs_readahead (struct readahead_control *);int netfs_read_folio (struct file *,struct folio *);int netfs_write_begin (struct netfs_inode *,struct file *, -struct address_space *,loff_t pos,unsigned int len, -struct folio **,void **fsdata); +struct address_space *,loff_t pos,unsigned int len, +struct folio **,void **fsdata); +void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length); +bool netfs_release_folio (struct folio *folio,gfp_t gfp);void netfs_subreq_terminated (struct netfs_io_subrequest *,ssize_t ,bool ); void netfs_get_subrequest(struct netfs_io_subrequest *subreq,
Re: [RFC PATCH 07/53] netfs: Provide invalidate_folio and release_folio calls
Quoted 274 lines · David Howells
Provide default
invalidate_folioandrelease_foliocalls. These will need to interact with invalidation correctly at some point. They will be needed if netfslib is to make use offolio->privatefor its own purposes.Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/9p/vfs_addr.c | 33 ++------------------------- fs/afs/file.c | 53 ++++--------------------------------------- fs/ceph/addr.c | 24 ++------------------ fs/netfs/Makefile | 1 + fs/netfs/misc.c | 51 +++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 6 +++-- 6 files changed, 64 insertions(+), 104 deletions(-) create mode 100644 fs/netfs/misc.cfs/9p/vfs_addr.c +2
-31@@ -104,35 +104,6 @@ const struct netfs_request_ops v9fs_req_ops = { .issue_read = v9fs_issue_read, }; -/** -* v9fs_release_folio - release the private state associated with a folio -* @folio: The folio to be released -* @gfp: The caller's allocation restrictions -* -* Returns true if the page can be released, false otherwise. -*/ - -static bool v9fs_release_folio (struct folio *folio,gfp_t gfp) -{ -if (folio_test_private (folio)) -return false; -#ifdef CONFIG_9P_FSCACHE -if (folio_test_fscache (folio)) { -if (current_is_kswapd () || !(gfp & __GFP_FS)) -return false; -folio_wait_fscache (folio); - } -fscache_note_page_release (v9fs_inode_cookie (V9FS_I (folio_inode (folio)))); -#endif -return true; -} - -static void v9fs_invalidate_folio (struct folio *folio,size_t offset, -size_t length) -{ -folio_wait_fscache (folio); -} -#ifdef CONFIG_9P_FSCACHE static void v9fs_write_to_cache_done (void *priv,ssize_t transferred_or_error,bool was_async)@@ -355,8 +326,8 @@ const struct address_space_operations v9fs_addr_operations = { .writepage = v9fs_vfs_writepage, .write_begin = v9fs_write_begin, .write_end = v9fs_write_end, - .release_folio = v9fs_release_folio, - .invalidate_folio = v9fs_invalidate_folio, + .release_folio = netfs_release_folio, + .invalidate_folio = netfs_invalidate_folio, .launder_folio = v9fs_launder_folio, .direct_IO = v9fs_direct_IO, };fs/afs/file.c +4
-49@@ -20,9 +20,6 @@static int afs_file_mmap (struct file *file,struct vm_area_struct *vma);static int afs_symlink_read_folio (struct file *file,struct folio *folio); -static void afs_invalidate_folio (struct folio *folio,size_t offset, -size_t length); -static bool afs_release_folio (struct folio *folio,gfp_t gfp_flags);static ssize_t afs_file_read_iter (struct kiocb *iocb,struct iov_iter *iter); static ssize_t afs_file_splice_read(struct file *in, loff_t *ppos,@@ -57,8 +54,8 @@ const struct address_space_operations afs_file_aops = { .readahead = netfs_readahead, .dirty_folio = afs_dirty_folio, .launder_folio = afs_launder_folio, - .release_folio = afs_release_folio, - .invalidate_folio = afs_invalidate_folio, + .release_folio = netfs_release_folio, + .invalidate_folio = netfs_invalidate_folio, .write_begin = afs_write_begin, .write_end = afs_write_end, .writepages = afs_writepages,@@ -67,8 +64,8 @@ const struct address_space_operations afs_file_aops = {const struct address_space_operations afs_symlink_aops = { .read_folio = afs_symlink_read_folio, - .release_folio = afs_release_folio, - .invalidate_folio = afs_invalidate_folio, + .release_folio = netfs_release_folio, + .invalidate_folio = netfs_invalidate_folio, .migrate_folio = filemap_migrate_folio, };@@ -405,48 +402,6 @@ int afs_write_inode(struct inode *inode, struct writeback_control *wbc)return 0 ; } -/* -* invalidate part or all of a page -* - release a page and clean up its private data if offset is 0 (indicating -* the entire page) -*/ -static void afs_invalidate_folio (struct folio *folio,size_t offset, -size_t length) -{ -_enter ("{%lu},%zu,%zu" , folio->index, offset, length); - -folio_wait_fscache (folio); -_leave ("" ); -} - -/* -* release a page and clean up its private state if it's not busy -* - return true if the page can now be released, false if not -*/ -static bool afs_release_folio (struct folio *folio,gfp_t gfp) -{ -struct afs_vnode *vnode =AFS_FS_I (folio_inode (folio)); - -_enter ("{{%llx:%llu}[%lu],%lx},%x" , - vnode->fid.vid, vnode->fid.vnode,folio_index (folio), folio->flags, - gfp); - -/* deny if folio is being written to the cache and the caller hasn't -* elected to wait */ -#ifdef CONFIG_AFS_FSCACHE -if (folio_test_fscache (folio)) { -if (current_is_kswapd () || !(gfp & __GFP_FS)) -return false; -folio_wait_fscache (folio); - } -fscache_note_page_release (afs_vnode_cache (vnode)); -#endif - -/* Indicate that the folio can be released */ -_leave (" = T" ); -return true; -} -static void afs_add_open_mmap (struct afs_vnode *vnode) {if (atomic_inc_return (&vnode->cb_nr_mmap) ==1 ) {fs/ceph/addr.c +2
-22@@ -160,27 +160,7 @@ static void ceph_invalidate_folio(struct folio *folio, size_t offset,ceph_put_snap_context (snapc); } -folio_wait_fscache (folio); -} - -static bool ceph_release_folio (struct folio *folio,gfp_t gfp) -{ -struct inode *inode = folio->mapping->host; - -dout ("%llx:%llx release_folio idx %lu (%sdirty)\n" , -ceph_vinop (inode), - folio->index,folio_test_dirty (folio) ?"" :"not " ); - -if (folio_test_private (folio)) -return false; - -if (folio_test_fscache (folio)) { -if (current_is_kswapd () || !(gfp & __GFP_FS)) -return false; -folio_wait_fscache (folio); - } -ceph_fscache_note_page_release (inode); -return true; +netfs_invalidate_folio (folio, offset, length); }static void ceph_netfs_expand_readahead (struct netfs_io_request *rreq)@@ -1563,7 +1543,7 @@ const struct address_space_operations ceph_aops = { .write_end = ceph_write_end, .dirty_folio = ceph_dirty_folio, .invalidate_folio = ceph_invalidate_folio, - .release_folio = ceph_release_folio, + .release_folio = netfs_release_folio, .direct_IO = noop_direct_IO, };fs/netfs/Makefile +1
-0@@ -5,6 +5,7 @@ netfs-y := \ io.o \ iterator.o \ main.o \ + misc.o \ objects.o netfs-$(CONFIG_NETFS_STATS) += stats.ofs/netfs/misc.c new file +51
-0@@ -0,0 +1,51 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Miscellaneous routines. +* +* Copyright (C) 2022 Red Hat, Inc. All Rights Reserved. +* Written by David Howells ([email protected]) +*/ + +#include <linux/swap.h> +#include "internal.h" + +/** +* netfs_invalidate_folio - Invalidate or partially invalidate a folio +* @folio: Folio proposed for release +* @offset: Offset of the invalidated region +* @length: Length of the invalidated region +* +* Invalidate part or all of a folio for a network filesystem. The folio will +* be removed afterwards if the invalidated region covers the entire folio. +*/ +void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length) +{ +_enter ("{%lx},%zx,%zx" ,folio_index (folio), offset, length); + +folio_wait_fscache (folio); +} +EXPORT_SYMBOL (netfs_invalidate_folio); + +/** +* netfs_release_folio - Try to release a folio +* @folio: Folio proposed for release +* @gfp: Flags qualifying the release +* +* Request release of a folio and clean up its private state if it's not busy. +* Returns true if the folio can now be released, false if not +*/ +bool netfs_release_folio (struct folio *folio,gfp_t gfp) +{ +struct netfs_inode *ctx =netfs_inode (folio_inode (folio)); + +if (folio_test_private (folio)) +return false; +if (folio_test_fscache (folio)) { +if (current_is_kswapd () || !(gfp & __GFP_FS)) +return false; +folio_wait_fscache (folio); + } + +fscache_note_page_release (netfs_i_cookie (ctx)); +return true; +} +EXPORT_SYMBOL (netfs_release_folio);include/linux/netfs.h +0
-0@@ -299,8 +299,10 @@ struct readahead_control;void netfs_readahead (struct readahead_control *);int netfs_read_folio (struct file *,struct folio *);
include/linux/netfs.h struct readahead_control; · line 308
Quoted 10 lines
include/linux/netfs.h +4
-2int netfs_write_begin (struct netfs_inode *,struct file *, -struct address_space *,loff_t pos,unsigned int len, -struct folio **,void **fsdata); +struct address_space *,loff_t pos,unsigned int len, +struct folio **,void **fsdata); +void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length); +bool netfs_release_folio (struct folio *folio,gfp_t gfp);void netfs_subreq_terminated (struct netfs_io_subrequest *,ssize_t ,bool ); void netfs_get_subrequest(struct netfs_io_subrequest *subreq,
Nice cleanup. Might can merge this in advance of the rest of the series.
David Howells
maintainerRFC PATCH 8/53 netfs: Add rsize to netfs_io_request
In reply to David HowellsAdd an rsize parameter to netfs_io_request to be filled in by the network filesystem when the request is initialised. This indicates the maximum size of a read request that the netfs will honour in that region.
--- fs/afs/file.c | 1 + fs/ceph/addr.c | 2 ++ include/linux/netfs.h | 1 + 3 files changed, 4 insertions(+)
fs/afs/file.c +1 -0
@@ -360,6 +360,7 @@ static int afs_symlink_read_folio(struct file *file, struct folio *folio)static int afs_init_request (struct netfs_io_request *rreq,struct file *file) { rreq->netfs_priv =key_get (afs_file_key (file)); + rreq->rsize =4 *1024 *1024 ;return 0 ; }
fs/ceph/addr.c +2 -0
@@ -419,6 +419,8 @@ static int ceph_init_request(struct netfs_io_request *rreq, struct file *file)struct ceph_netfs_request_data *priv;int ret =0 ; + rreq->rsize =1024 *1024 ; +if (rreq->origin !=NETFS_READAHEAD )return 0 ;
include/linux/netfs.h +1 -0
@@ -188,6 +188,7 @@ struct netfs_io_request {struct list_head subrequests;/* Contributory I/O operations */ void *netfs_priv;/* Private data for the netfs */ unsigned int debug_id; +unsigned int rsize;/* Maximum read size (0 for none) */ 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 */
Jeff Layton
maintainerRe: [RFC PATCH 08/53] netfs: Add rsize to netfs_io_request
Quoted 32 lines · David Howells
Add an rsize parameter to
netfs_io_requestto be filled in by the network filesystem when the request is initialised. This indicates the maximum size of a read request that the netfs will honour in that region.Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/afs/file.c | 1 + fs/ceph/addr.c | 2 ++ include/linux/netfs.h | 1 + 3 files changed, 4 insertions(+)fs/afs/file.c +1
-0@@ -360,6 +360,7 @@ static int afs_symlink_read_folio(struct file *file, struct folio *folio)static int afs_init_request (struct netfs_io_request *rreq,struct file *file) { rreq->netfs_priv =key_get (afs_file_key (file)); + rreq->rsize =4 *1024 *1024 ;return 0 ; }fs/ceph/addr.c +0
-0
fs/ceph/addr.c static int ceph_init_request(struct netfs_io_request *rreq, struct file *file) · line 423
Quoted 5 lines
fs/ceph/addr.c +2
-0@@ -419,6 +419,8 @@ static int ceph_init_request(struct netfs_io_request *rreq, struct file *file)struct ceph_netfs_request_data *priv;int ret =0 ; + rreq->rsize =1024 *1024 ; +
Holy magic numbers, batman! I think this deserves a comment that explains how you came up with these values.
Also, do 9p and cifs not need this for some reason?
Quoted 16 lines
fs/ceph/addr.c +0
-0if (rreq->origin !=NETFS_READAHEAD )return 0 ;include/linux/netfs.h +1
-0@@ -188,6 +188,7 @@ struct netfs_io_request {struct list_head subrequests;/* Contributory I/O operations */ void *netfs_priv;/* Private data for the netfs */ unsigned int debug_id; +unsigned int rsize;/* Maximum read size (0 for none) */ 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 */
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerRe: [RFC PATCH 08/53] netfs: Add rsize to netfs_io_request
Quoted 8 lines · Jeff Layton
Quoted 2 lines
fs/afs/file.c +1
-0+ rreq->rsize =4 *1024 *1024 ;return 0 ;...
fs/ceph/addr.c static int ceph_init_request(struct netfs_io_request *rreq, struct file *file) · line 423
Quoted 2 lines
fs/ceph/addr.c +2
-0+ rreq->rsize =1024 *1024 ; +Holy magic numbers, batman! I think this deserves a comment that explains how you came up with these values.
Actually, that should be set to something like the object size for ceph.
Quoted 1 line
Also, do 9p and cifs not need this for some reason?
At this point, cifs doesn't use netfslib, so that's implemented in a later patch in this series.
9p does need setting, but I haven't tested that yet. It probably needs setting to 1MiB as I think that's the maximum the 9p transport can handle.
But in the case of cifs, this is actually dynamic, depending on how many credits we can obtain. The same may be true of ceph, though I'm not entirely clear on that as yet.
For afs, the maximum [rw]size the protocol supports is actually something like 281350422593565 (ie. (65535-28) * (2^32-1)) minus a few bytes, but that's probably not a good idea. I might be best setting it at something like 256KiB as that's what OpenAFS uses.
David
David Howells
maintainerRFC PATCH 9/53 netfs: Implement unbuffered/DIO vs buffered I/O locking
In reply to David HowellsBorrow NFS's direct-vs-buffered I/O locking into netfslib. Similar code is also used in ceph.
Modify it to have the correct checker annotations for i_rwsem lock acquisition/release and to return -ERESTARTSYS if waits are interrupted.
--- fs/netfs/Makefile | 1 + fs/netfs/locking.c | 209 ++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 10 ++ 3 files changed, 220 insertions(+) create mode 100644 fs/netfs/locking.c
fs/netfs/Makefile +1 -0
@@ -4,6 +4,7 @@ netfs-y := \ buffered_read.o \ io.o \ iterator.o \ + locking.o \ main.o \ misc.o \ objects.o
fs/netfs/locking.c new file +209 -0
209 lines not on this page · raw message
include/linux/netfs.h +10 -0
@@ -131,6 +131,8 @@ struct netfs_inode {loff_t remote_i_size;/* Size of the remote file */ loff_t zero_point;/* Size after which we assume there's no data * on the server */ +unsigned long flags; +#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ };/*
@@ -315,6 +317,13 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len,struct iov_iter *new, iov_iter_extraction_t extraction_flags); +int netfs_start_io_read (struct inode *inode); +void netfs_end_io_read (struct inode *inode); +int netfs_start_io_write (struct inode *inode); +void netfs_end_io_write (struct inode *inode); +int netfs_start_io_direct (struct inode *inode); +void netfs_end_io_direct (struct inode *inode); +/** * netfs_inode - Get the netfs inode context from the inode * @inode: The inode to query
@@ -341,6 +350,7 @@ static inline void netfs_inode_init(struct netfs_inode *ctx, ctx->ops = ops; ctx->remote_i_size =i_size_read (&ctx->inode); ctx->zero_point = ctx->remote_i_size; + ctx->flags =0 ;#if IS_ENABLED (CONFIG_FSCACHE ) ctx->cache =NULL ;#endif
Jeff Layton
maintainerRe: [RFC PATCH 09/53] netfs: Implement unbuffered/DIO vs buffered I/O locking
Quoted 274 lines · David Howells
Borrow NFS's direct-vs-buffered I/O locking into netfslib. Similar code is also used in ceph.
Modify it to have the correct checker annotations for
i_rwsemlock acquisition/release and to return-ERESTARTSYSif waits are interrupted.Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/netfs/Makefile | 1 + fs/netfs/locking.c | 209 ++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 10 ++ 3 files changed, 220 insertions(+) create mode 100644 fs/netfs/locking.cfs/netfs/Makefile +1
-0@@ -4,6 +4,7 @@ netfs-y := \ buffered_read.o \ io.o \ iterator.o \ + locking.o \ main.o \ misc.o \ objects.ofs/netfs/locking.c new file +209
-0@@ -0,0 +1,209 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* I/O and data path helper functionality. +* +* Borrowed from NFS Copyright (c) 2016 Trond Myklebust +*/ + +#include <linux/kernel.h> +#include <linux/netfs.h> + +/* +* inode_dio_wait_interruptible - wait for outstanding DIO requests to finish +* @inode: inode to wait for +* +* Waits for all pending direct I/O requests to finish so that we can +* proceed with a truncate or equivalent operation. +* +* Must be called under a lock that serializes taking new references +* to i_dio_count, usually by inode->i_mutex. +*/ +static int inode_dio_wait_interruptible (struct inode *inode) +{ +if (!atomic_read (&inode->i_dio_count)) +return 0 ; + +wait_queue_head_t *wq =bit_waitqueue (&inode->i_state, __I_DIO_WAKEUP); +DEFINE_WAIT_BIT (q, &inode->i_state, __I_DIO_WAKEUP); + +for (;;) { +prepare_to_wait (wq, &q.wq_entry,TASK_INTERRUPTIBLE ); +if (!atomic_read (&inode->i_dio_count)) +break ; +if (signal_pending (current)) +break ; +schedule (); + } +finish_wait (wq, &q.wq_entry); + +return atomic_read (&inode->i_dio_count) ? -ERESTARTSYS :0 ; +} + +/* Call with exclusively locked inode->i_rwsem */ +static int netfs_block_o_direct (struct netfs_inode *ictx) +{ +if (!test_bit (NETFS_ICTX_ODIRECT , &ictx->flags)) +return 0 ; +clear_bit (NETFS_ICTX_ODIRECT , &ictx->flags); +return inode_dio_wait_interruptible (&ictx->inode); +} + +/** +* netfs_start_io_read - declare the file is being used for buffered reads +* @inode: file inode +* +* Declare that a buffered read operation is about to start, and ensure +* that we block all direct I/O. +* On exit, the function ensures that the NETFS_ICTX_ODIRECT flag is unset, +* and holds a shared lock on inode->i_rwsem to ensure that the flag +* cannot be changed. +* In practice, this means that buffered read operations are allowed to +* execute in parallel, thanks to the shared lock, whereas direct I/O +* operations need to wait to grab an exclusive lock in order to set +* NETFS_ICTX_ODIRECT. +* Note that buffered writes and truncates both take a write lock on +* inode->i_rwsem, meaning that those are serialised w.r.t. the reads. +*/ +int netfs_start_io_read (struct inode *inode) + __acquires(inode->i_rwsem) +{ +struct netfs_inode *ictx =netfs_inode (inode); + +/* Be an optimist! */ +if (down_read_interruptible (&inode->i_rwsem) <0 ) +return -ERESTARTSYS ; +if (test_bit (NETFS_ICTX_ODIRECT , &ictx->flags) ==0 ) +return 0 ; +up_read (&inode->i_rwsem); + +/* Slow path.... */ +if (down_write_killable (&inode->i_rwsem) <0 ) +return -ERESTARTSYS ; +if (netfs_block_o_direct (ictx) <0 ) { +up_write (&inode->i_rwsem); +return -ERESTARTSYS ; + } +downgrade_write (&inode->i_rwsem); +return 0 ; +} + +/** +* netfs_end_io_read - declare that the buffered read operation is done +* @inode: file inode +* +* Declare that a buffered read operation is done, and release the shared +* lock on inode->i_rwsem. +*/ +void netfs_end_io_read (struct inode *inode) + __releases(inode->i_rwsem) +{ +up_read (&inode->i_rwsem); +} + +/** +* netfs_start_io_write - declare the file is being used for buffered writes +* @inode: file inode +* +* Declare that a buffered read operation is about to start, and ensure +* that we block all direct I/O. +*/ +int netfs_start_io_write (struct inode *inode) + __acquires(inode->i_rwsem) +{ +struct netfs_inode *ictx =netfs_inode (inode); + +if (down_write_killable (&inode->i_rwsem) <0 ) +return -ERESTARTSYS ; +if (netfs_block_o_direct (ictx) <0 ) { +up_write (&inode->i_rwsem); +return -ERESTARTSYS ; + } +return 0 ; +} + +/** +* netfs_end_io_write - declare that the buffered write operation is done +* @inode: file inode +* +* Declare that a buffered write operation is done, and release the +* lock on inode->i_rwsem. +*/ +void netfs_end_io_write (struct inode *inode) + __releases(inode->i_rwsem) +{ +up_write (&inode->i_rwsem); +} + +/* Call with exclusively locked inode->i_rwsem */ +static int netfs_block_buffered (struct inode *inode) +{ +struct netfs_inode *ictx =netfs_inode (inode); +int ret; + +if (!test_bit (NETFS_ICTX_ODIRECT , &ictx->flags)) { +set_bit (NETFS_ICTX_ODIRECT , &ictx->flags); +if (inode->i_mapping->nrpages !=0 ) { +unmap_mapping_range (inode->i_mapping,0 ,0 ,0 ); + ret =filemap_fdatawait (inode->i_mapping); +if (ret <0 ) { +clear_bit (NETFS_ICTX_ODIRECT , &ictx->flags); +return ret; + } + } + } +return 0 ; +} + +/** +* netfs_start_io_direct - declare the file is being used for direct i/o +* @inode: file inode +* +* Declare that a direct I/O operation is about to start, and ensure +* that we block all buffered I/O. +* On exit, the function ensures that the NETFS_ICTX_ODIRECT flag is set, +* and holds a shared lock on inode->i_rwsem to ensure that the flag +* cannot be changed. +* In practice, this means that direct I/O operations are allowed to +* execute in parallel, thanks to the shared lock, whereas buffered I/O +* operations need to wait to grab an exclusive lock in order to clear +* NETFS_ICTX_ODIRECT. +* Note that buffered writes and truncates both take a write lock on +* inode->i_rwsem, meaning that those are serialised w.r.t. O_DIRECT. +*/ +int netfs_start_io_direct (struct inode *inode) + __acquires(inode->i_rwsem) +{ +struct netfs_inode *ictx =netfs_inode (inode); +int ret; + +/* Be an optimist! */ +if (down_read_interruptible (&inode->i_rwsem) <0 ) +return -ERESTARTSYS ; +if (test_bit (NETFS_ICTX_ODIRECT , &ictx->flags) !=0 ) +return 0 ; +up_read (&inode->i_rwsem); + +/* Slow path.... */ +if (down_write_killable (&inode->i_rwsem) <0 ) +return -ERESTARTSYS ; + ret =netfs_block_buffered (inode); +if (ret <0 ) { +up_write (&inode->i_rwsem); +return ret; + } +downgrade_write (&inode->i_rwsem); +return 0 ; +} + +/** +* netfs_end_io_direct - declare that the direct i/o operation is done +* @inode: file inode +* +* Declare that a direct I/O operation is done, and release the shared +* lock on inode->i_rwsem. +*/ +void netfs_end_io_direct (struct inode *inode) + __releases(inode->i_rwsem) +{ +up_read (&inode->i_rwsem); +}include/linux/netfs.h +9
-0@@ -131,6 +131,8 @@ struct netfs_inode {loff_t remote_i_size;/* Size of the remote file */ loff_t zero_point;/* Size after which we assume there's no data * on the server */ +unsigned long flags; +#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ };/* @@ -315,6 +317,13 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len,struct iov_iter *new, iov_iter_extraction_t extraction_flags); +int netfs_start_io_read (struct inode *inode); +void netfs_end_io_read (struct inode *inode); +int netfs_start_io_write (struct inode *inode); +void netfs_end_io_write (struct inode *inode); +int netfs_start_io_direct (struct inode *inode); +void netfs_end_io_direct (struct inode *inode); +/** * netfs_inode - Get the netfs inode context from the inode * @inode: The inode to query
include/linux/netfs.h static inline void netfs_inode_init(struct netfs_inode *ctx, · line 356
Quoted 7 lines
include/linux/netfs.h +1
-0@@ -341,6 +350,7 @@ static inline void netfs_inode_init(struct netfs_inode *ctx, ctx->ops = ops; ctx->remote_i_size =i_size_read (&ctx->inode); ctx->zero_point = ctx->remote_i_size; + ctx->flags =0 ;#if IS_ENABLED (CONFIG_FSCACHE ) ctx->cache =NULL ;#endif
It's nice to see this go into common code, but why not go ahead and convert ceph (and possibly NFS) to use this? Is there any reason not to?
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerRe: [RFC PATCH 09/53] netfs: Implement unbuffered/DIO vs buffered I/O locking
Quoted 2 lines · Jeff Layton
It's nice to see this go into common code, but why not go ahead and convert ceph (and possibly NFS) to use this? Is there any reason not to?
I'm converting ceph on a follow-on branch and for ceph this will be dealt with there.
I could do NFS round about here, I suppose.
David
David Howells
maintainerRFC PATCH 10/53 netfs: Add iov_iters to (sub)requests to describe various buffers
In reply to David HowellsAdd three iov_iter structs:
(1) Add an iov_iter (->iter) to the I/O request to describe the unencrypted-side buffer.
(2) Add an iov_iter (->io_iter) to the I/O request to describe the encrypted-side I/O buffer. This may be a different size to the buffer in (1).
(3) Add an iov_iter (->io_iter) to the I/O subrequest to describe the part of the I/O buffer for that subrequest.
This will allow future patches to point to a bounce buffer instead for purposes of handling oversize writes, decryption (where we want to save the encrypted data to the cache) and decompression.
These iov_iters persist for the lifetime of the (sub)request, and so can be accessed multiple times without worrying about them being deallocated upon return to the caller.
The network filesystem must appropriately advance the iterator before terminating the request.
--- fs/afs/file.c | 6 +--- fs/netfs/buffered_read.c | 13 ++++++++ fs/netfs/io.c | 69 +++++++++++++++++++++++++++++----------- include/linux/netfs.h | 3 ++ 4 files changed, 67 insertions(+), 24 deletions(-)
fs/afs/file.c +1 -5
@@ -323,11 +323,7 @@ static void afs_issue_read(struct netfs_io_subrequest *subreq) fsreq->len = subreq->len - subreq->transferred; fsreq->key =key_get (subreq->rreq->netfs_priv); fsreq->vnode = vnode; - fsreq->iter = &fsreq->def_iter; - -iov_iter_xarray (&fsreq->def_iter,ITER_DEST , - &fsreq->vnode->netfs.inode.i_mapping->i_pages, - fsreq->pos, fsreq->len); + fsreq->iter = &subreq->io_iter;afs_fetch_data (fsreq->vnode, fsreq);afs_put_read (fsreq);
fs/netfs/buffered_read.c +13 -0
@@ -206,6 +206,10 @@ void netfs_readahead(struct readahead_control *ractl)netfs_rreq_expand (rreq, ractl); +/* Set up the output buffer */ +iov_iter_xarray (&rreq->iter,ITER_DEST , &ractl->mapping->i_pages, + rreq->start, rreq->len); +/* Drop the refs on the folios here rather than in the cache or * filesystem. The locks will be dropped in netfs_rreq_unlock(). */
@@ -258,6 +262,11 @@ int netfs_read_folio(struct file *file, struct folio *folio)netfs_stat (&netfs_n_rh_readpage);trace_netfs_read (rreq, rreq->start, rreq->len, netfs_read_trace_readpage); + +/* Set up the output buffer */ +iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, + rreq->start, rreq->len); +return netfs_begin_read (rreq, true); discard:
@@ -415,6 +424,10 @@ int netfs_write_begin(struct netfs_inode *ctx, ractl._nr_pages =folio_nr_pages (folio);netfs_rreq_expand (rreq, &ractl); +/* Set up the output buffer */ +iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, + rreq->start, rreq->len); +/* We hold the folio locks, so we can drop the references */ folio_get (folio);while (readahead_folio (&ractl))
fs/netfs/io.c +50 -19
152 lines not on this page · raw message
include/linux/netfs.h +3 -0
@@ -152,6 +152,7 @@ struct netfs_cache_resources {struct netfs_io_subrequest {struct netfs_io_request *rreq;/* Supervising I/O request */ struct list_head rreq_link;/* Link in rreq->subrequests */ +struct iov_iter io_iter;/* Iterator for this subrequest */ loff_t start;/* Where to start the I/O */ size_t len;/* Size of the I/O */ size_t transferred;/* Amount of data transferred */
@@ -188,6 +189,8 @@ struct netfs_io_request {struct netfs_cache_resources cache_resources;struct list_head proc_link;/* Link in netfs_iorequests */ struct list_head subrequests;/* Contributory I/O operations */ +struct iov_iter iter;/* Unencrypted-side iterator */ +struct iov_iter io_iter;/* I/O (Encrypted-side) iterator */ void *netfs_priv;/* Private data for the netfs */ unsigned int debug_id;unsigned int rsize;/* Maximum read size (0 for none) */
David Howells
maintainerRFC PATCH 11/53 netfs: Add support for DIO buffering
In reply to David HowellsAdd a bvec array pointer and an iterator to netfs_io_request for either holding a copy of a DIO iterator or a list of all the bits of buffer pointed to by a DIO iterator.
There are two problems: Firstly, if an iovec-class iov_iter is passed to ->read_iter() or ->write_iter(), this cannot be passed directly to kernel_sendmsg() or kernel_recvmsg() as that may cause locking recursion if a fault is generated, so we need to keep track of the pages involved separately.
Secondly, if the I/O is asynchronous, we must copy the iov_iter describing the buffer before returning to the caller as it may be immediately deallocated.
--- fs/netfs/objects.c | 10 ++++++++++ include/linux/netfs.h | 3 +++ 2 files changed, 13 insertions(+)
fs/netfs/objects.c +10 -0
@@ -78,6 +78,7 @@ static void netfs_free_request(struct work_struct *work) {struct netfs_io_request *rreq = container_of(work, struct netfs_io_request, work); +unsigned int i;trace_netfs_rreq (rreq, netfs_rreq_trace_free);netfs_proc_del_rreq (rreq);
@@ -86,6 +87,15 @@ static void netfs_free_request(struct work_struct *work) rreq->netfs_ops->free_request (rreq);if (rreq->cache_resources.ops) rreq->cache_resources.ops->end_operation (&rreq->cache_resources); +if (rreq->direct_bv) { +for (i =0 ; i < rreq->direct_bv_count; i++) { +if (rreq->direct_bv[i].bv_page) { +if (rreq->direct_bv_unpin) +unpin_user_page (rreq->direct_bv[i].bv_page); + } + } +kvfree (rreq->direct_bv); + }kfree_rcu (rreq, rcu);netfs_stat_d (&netfs_n_rh_rreq); }
include/linux/netfs.h +3 -0
@@ -191,7 +191,9 @@ struct netfs_io_request {struct list_head subrequests;/* Contributory I/O operations */ struct iov_iter iter;/* Unencrypted-side iterator */ struct iov_iter io_iter;/* I/O (Encrypted-side) iterator */ +struct bio_vec *direct_bv;/* DIO buffer list (when handling iovec-iter) */ void *netfs_priv;/* Private data for the netfs */ +unsigned int direct_bv_count;/* Number of elements in bv[] */ unsigned int debug_id;unsigned int rsize;/* Maximum read size (0 for none) */ atomic_t nr_outstanding;/* Number of ops in progress */
@@ -200,6 +202,7 @@ struct netfs_io_request {size_t len;/* Length of the request */ short error;/* 0 or error that occurred */ enum netfs_io_origin origin;/* Origin of the request */ +bool direct_bv_unpin;/* T if direct_bv[] must be unpinned */ loff_t i_size;/* Size of the file */ loff_t start;/* Start position */ pgoff_t no_unlock_folio;/* Don't unlock this folio after read */
Jeff Layton
maintainerRe: [RFC PATCH 11/53] netfs: Add support for DIO buffering
Quoted 57 lines · David Howells
Add a bvec array pointer and an iterator to
netfs_io_requestfor either holding a copy of a DIO iterator or a list of all the bits of buffer pointed to by a DIO iterator.There are two problems: Firstly, if an iovec-class
iov_iteris passed to ->read_iter() or ->write_iter(), this cannot be passed directly tokernel_sendmsg()orkernel_recvmsg()as that may cause locking recursion if a fault is generated, so we need to keep track of the pages involved separately.Secondly, if the I/O is asynchronous, we must copy the
iov_iterdescribing the buffer before returning to the caller as it may be immediately deallocated.Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/netfs/objects.c | 10 ++++++++++ include/linux/netfs.h | 3 +++ 2 files changed, 13 insertions(+)fs/netfs/objects.c +10
-0@@ -78,6 +78,7 @@ static void netfs_free_request(struct work_struct *work) {struct netfs_io_request *rreq = container_of(work, struct netfs_io_request, work); +unsigned int i;trace_netfs_rreq (rreq, netfs_rreq_trace_free);netfs_proc_del_rreq (rreq);@@ -86,6 +87,15 @@ static void netfs_free_request(struct work_struct *work) rreq->netfs_ops->free_request (rreq);if (rreq->cache_resources.ops) rreq->cache_resources.ops->end_operation (&rreq->cache_resources); +if (rreq->direct_bv) { +for (i =0 ; i < rreq->direct_bv_count; i++) { +if (rreq->direct_bv[i].bv_page) { +if (rreq->direct_bv_unpin) +unpin_user_page (rreq->direct_bv[i].bv_page); + } + } +kvfree (rreq->direct_bv); + }kfree_rcu (rreq, rcu);netfs_stat_d (&netfs_n_rh_rreq); }include/linux/netfs.h +0
-0
include/linux/netfs.h struct netfs_io_request { · line 196
Quoted 6 lines
include/linux/netfs.h +2
-0@@ -191,7 +191,9 @@ struct netfs_io_request {struct list_head subrequests;/* Contributory I/O operations */ struct iov_iter iter;/* Unencrypted-side iterator */ struct iov_iter io_iter;/* I/O (Encrypted-side) iterator */ +struct bio_vec *direct_bv;/* DIO buffer list (when handling iovec-iter) */ void *netfs_priv;/* Private data for the netfs */ +unsigned int direct_bv_count;/* Number of elements in bv[] */
nit: "number of elements in direct_bv[]"
Also, just for better readability, can you swap direct_bv and netfs_priv? Then at least the array and count are together.
Quoted 12 lines
include/linux/netfs.h +1
-0unsigned int debug_id;unsigned int rsize;/* Maximum read size (0 for none) */ atomic_t nr_outstanding;/* Number of ops in progress */ @@ -200,6 +202,7 @@ struct netfs_io_request {size_t len;/* Length of the request */ short error;/* 0 or error that occurred */ enum netfs_io_origin origin;/* Origin of the request */ +bool direct_bv_unpin;/* T if direct_bv[] must be unpinned */ loff_t i_size;/* Size of the file */ loff_t start;/* Start position */ pgoff_t no_unlock_folio;/* Don't unlock this folio after read */
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerRe: [RFC PATCH 11/53] netfs: Add support for DIO buffering
Quoted 8 lines · Jeff Layton
include/linux/netfs.h struct netfs_io_request { · line 196
Quoted 3 lines
include/linux/netfs.h +2
-0+struct bio_vec *direct_bv;/* DIO buffer list (when handling iovec-iter) */ void *netfs_priv;/* Private data for the netfs */ +unsigned int direct_bv_count;/* Number of elements in bv[] */ nit: "number of elements in direct_bv[]"
Also, just for better readability, can you swap
direct_bvandnetfs_priv? Then at least the array and count are together.
Yeah - and stick a __counted_by() on too.
David
David Howells
maintainerRFC PATCH 12/53 netfs: Provide tools to create a buffer in an xarray
In reply to David HowellsProvide tools to create a buffer in an xarray, with a function to add new folios with a mark. This will be used to create bounce buffer and can be used more easily to create a list of folios the span of which would require more than a page's worth of bio_vec structs.
--- fs/netfs/internal.h | 16 +++++ fs/netfs/misc.c | 140 ++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 4 ++ 3 files changed, 160 insertions(+)
fs/netfs/internal.h +16 -0
@@ -52,6 +52,22 @@ static inline void netfs_proc_add_rreq(struct netfs_io_request *rreq) {}static inline void netfs_proc_del_rreq (struct netfs_io_request *rreq) {}#endif +/* +* misc.c +*/ +int netfs_xa_store_and_mark (struct xarray *xa,unsigned long index, +struct folio *folio,bool put_mark, +bool pagecache_mark,gfp_t gfp_mask); +int netfs_add_folios_to_buffer (struct xarray *buffer, +struct address_space *mapping, +pgoff_t index,pgoff_t to,gfp_t gfp_mask); +int netfs_set_up_buffer (struct xarray *buffer, +struct address_space *mapping, +struct readahead_control *ractl, +struct folio *keep, +pgoff_t have_index,unsigned int have_folios); +void netfs_clear_buffer (struct xarray *buffer); +/* * objects.c */
fs/netfs/misc.c +140 -0
146 lines not on this page · raw message
include/linux/netfs.h +4 -0
@@ -109,6 +109,10 @@ static inline int wait_on_page_fscache_killable(struct page *page)return folio_wait_private_2_killable (page_folio (page)); } +/* Marks used on xarray-based buffers */ +#define NETFS_BUF_PUT_MARK XA_MARK_0/* - Page needs putting */ +#define NETFS_BUF_PAGECACHE_MARK XA_MARK_1/* - Page needs wb/dirty flag wrangling */ +enum netfs_io_source {NETFS_FILL_WITH_ZEROES ,NETFS_DOWNLOAD_FROM_SERVER ,
Re: [RFC PATCH 12/53] netfs: Provide tools to create a buffer in an xarray
fs/netfs/internal.h static inline void netfs_proc_add_rreq(struct netfs_io_request *rreq) {} · line 60
Quoted 3 lines · David Howells
fs/netfs/internal.h +3
-0+int netfs_xa_store_and_mark (struct xarray *xa,unsigned long index, +struct folio *folio,bool put_mark, +bool pagecache_mark,gfp_t gfp_mask);
Linus has been unhappy recently with functions that take two bools. When you're reading the caller, you see:
netfs_xa_store_and_mark(xa, index, true, false, GFP_FOO);
and you don't know instantly what true and false mean. He prefers
#define NETFS_FLAG_PUT (1 << 0)
#define NETFS_FLAG_PAGECACHE (1 << 1)
and then the caller looks like:
netfs_xa_store_and_mark(xa, index, NETFS_FLAG_PUT, GFP_FOO);
and you know exactly what it's doing.
Jeff Layton
maintainerRe: [RFC PATCH 12/53] netfs: Provide tools to create a buffer in an xarray
In reply to David HowellsQuoted 76 lines · David Howells
Provide tools to create a buffer in an xarray, with a function to add new folios with a mark. This will be used to create bounce buffer and can be used more easily to create a list of folios the span of which would require more than a page's worth of
bio_vecstructs.Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/netfs/internal.h | 16 +++++ fs/netfs/misc.c | 140 ++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 4 ++ 3 files changed, 160 insertions(+)fs/netfs/internal.h +16
-0@@ -52,6 +52,22 @@ static inline void netfs_proc_add_rreq(struct netfs_io_request *rreq) {}static inline void netfs_proc_del_rreq (struct netfs_io_request *rreq) {}#endif +/* +* misc.c +*/ +int netfs_xa_store_and_mark (struct xarray *xa,unsigned long index, +struct folio *folio,bool put_mark, +bool pagecache_mark,gfp_t gfp_mask); +int netfs_add_folios_to_buffer (struct xarray *buffer, +struct address_space *mapping, +pgoff_t index,pgoff_t to,gfp_t gfp_mask); +int netfs_set_up_buffer (struct xarray *buffer, +struct address_space *mapping, +struct readahead_control *ractl, +struct folio *keep, +pgoff_t have_index,unsigned int have_folios); +void netfs_clear_buffer (struct xarray *buffer); +/* * objects.c */ fs/netfs/misc.c +25
-0@@ -8,6 +8,146 @@#include <linux/swap.h> #include "internal.h" +/* +* Attach a folio to the buffer and maybe set marks on it to say that we need +* to put the folio later and twiddle the pagecache flags. +*/ +int netfs_xa_store_and_mark (struct xarray *xa,unsigned long index, +struct folio *folio,bool put_mark, +bool pagecache_mark,gfp_t gfp_mask) +{ +XA_STATE_ORDER (xas, xa, index,folio_order (folio)); + +retry: +xas_lock (&xas); +for (;;) { +xas_store (&xas, folio); +if (!xas_error (&xas)) +break ; +xas_unlock (&xas); +if (!xas_nomem (&xas, gfp_mask)) +return xas_error (&xas); + goto retry; + } + +if (put_mark) +xas_set_mark (&xas,NETFS_BUF_PUT_MARK ); +if (pagecache_mark)
fs/netfs/misc.c line 45
Quoted 10 lines
fs/netfs/misc.c +10
-0+xas_set_mark (&xas,NETFS_BUF_PAGECACHE_MARK ); +xas_unlock (&xas); +return xas_error (&xas); +} + +/* +* Create the specified range of folios in the buffer attached to the read +* request. The folios are marked with NETFS_BUF_PUT_MARK so that we know that +* these need freeing later. +*/
Some kerneldoc comments on these new helpers would be nice. I assume that "index" and "to" are "start" and "end" for this, but it'd be nice to make that explicit.
Quoted 46 lines
fs/netfs/misc.c +46
-0+int netfs_add_folios_to_buffer (struct xarray *buffer, +struct address_space *mapping, +pgoff_t index,pgoff_t to,gfp_t gfp_mask) +{ +struct folio *folio; +int ret; + +if (to +1 == index)/* Page range is inclusive */ +return 0 ; + +do { +/* TODO: Figure out what order folio can be allocated here */ + folio =filemap_alloc_folio (readahead_gfp_mask (mapping),0 ); +if (!folio) +return -ENOMEM ; + folio->index = index; + ret =netfs_xa_store_and_mark (buffer, index, folio, + true, false, gfp_mask); +if (ret <0 ) { +folio_put (folio); +return ret; + } + + index +=folio_nr_pages (folio); + }while (index <= to && index !=0 ); + +return 0 ; +} + +/* +* Set up a buffer into which to data will be read or decrypted/decompressed. +* The folios to be read into are attached to this buffer and the gaps filled +* in to form a continuous region. +*/ +int netfs_set_up_buffer (struct xarray *buffer, +struct address_space *mapping, +struct readahead_control *ractl, +struct folio *keep, +pgoff_t have_index,unsigned int have_folios) +{ +struct folio *folio; +gfp_t gfp_mask =readahead_gfp_mask (mapping); +unsigned int want_folios = have_folios; +pgoff_t want_index = have_index; +int ret; +
fs/netfs/misc.c line 101
Quoted 10 lines
fs/netfs/misc.c +10
-0+ ret =netfs_add_folios_to_buffer (buffer, mapping, want_index, + have_index -1 , gfp_mask); +if (ret <0 ) +return ret; + have_folios += have_index - want_index; + + ret =netfs_add_folios_to_buffer (buffer, mapping, + have_index + have_folios, + want_index + want_folios -1 , + gfp_mask);
I don't get it. Why are you calling netfs_add_folios_to_buffer twice here? Why not just make one call? Either way, a comment here explaining that would also be nice.
Quoted 68 lines
fs/netfs/misc.c +49
-0+if (ret <0 ) +return ret; + +/* Transfer the folios proposed by the VM into the buffer and take refs +* on them. The locks will be dropped in netfs_rreq_unlock(). +*/ +if (ractl) { +while ((folio =readahead_folio (ractl))) { +folio_get (folio); +if (folio == keep) +folio_get (folio); + ret =netfs_xa_store_and_mark (buffer, folio->index, folio, + true, true, gfp_mask); +if (ret <0 ) { +if (folio != keep) +folio_unlock (folio); +folio_put (folio); +return ret; + } + } + }else { +folio_get (keep); + ret =netfs_xa_store_and_mark (buffer, keep->index, keep, + true, true, gfp_mask); +if (ret <0 ) { +folio_put (keep); +return ret; + } + } +return 0 ; +} + +/* +* Clear an xarray buffer, putting a ref on the folios that have +* NETFS_BUF_PUT_MARK set. +*/ +void netfs_clear_buffer (struct xarray *buffer) +{ +struct folio *folio; +XA_STATE (xas, buffer,0 ); + +rcu_read_lock (); +xas_for_each_marked (&xas, folio,ULONG_MAX ,NETFS_BUF_PUT_MARK ) { +folio_put (folio); + } +rcu_read_unlock (); +xa_destroy (buffer); +} +/** * netfs_invalidate_folio - Invalidate or partially invalidate a folio * @folio: Folio proposed for release include/linux/netfs.h +4
-0@@ -109,6 +109,10 @@ static inline int wait_on_page_fscache_killable(struct page *page)return folio_wait_private_2_killable (page_folio (page)); } +/* Marks used on xarray-based buffers */ +#define NETFS_BUF_PUT_MARK XA_MARK_0/* - Page needs putting */ +#define NETFS_BUF_PAGECACHE_MARK XA_MARK_1/* - Page needs wb/dirty flag wrangling */ +enum netfs_io_source {NETFS_FILL_WITH_ZEROES ,NETFS_DOWNLOAD_FROM_SERVER ,
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerRe: [RFC PATCH 12/53] netfs: Provide tools to create a buffer in an xarray
Quoted 3 lines · Jeff Layton
Some kerneldoc comments on these new helpers would be nice. I assume that "index" and "to" are "start" and "end" for this, but it'd be nice to make that explicit.
These are internal to netfs not API functions, so they shouldn't appear in the API docs. That's why the declaration is in internal.h, not netfs.h.
That said, I could describe them better.
Quoted 6 lines
Quoted 6 lines
fs/netfs/misc.c +6
-0+ ret =netfs_add_folios_to_buffer (buffer, mapping, want_index, + have_index -1 , gfp_mask); +if (ret <0 ) +return ret; + have_folios += have_index - want_index; +
Quoted 8 lines
fs/netfs/misc.c line 101
Quoted 4 lines
fs/netfs/misc.c +4
-0+ ret =netfs_add_folios_to_buffer (buffer, mapping, + have_index + have_folios, + want_index + want_folios -1 , + gfp_mask);I don't get it. Why are you calling
netfs_add_folios_to_buffertwice here? Why not just make one call? Either way, a comment here explaining that would also be nice.
The ranges aren't contiguous. They bracket the folios spliced from the mapping. That being said, I seem to have lost a bit of maths somewhere.
Further, I'm not now using netfs_add_folios_to_buffer(), so I'll remove it.
David
David Howells
maintainerRFC PATCH 13/53 netfs: Add bounce buffering support
In reply to David HowellsAdd a second xarray struct to netfs_io_request for the purposes of holding a bounce buffer for when we have to deal with encrypted/compressed data or if we have to up/download data in blocks larger than we were asked for.
--- fs/netfs/io.c | 6 +++++- fs/netfs/objects.c | 3 +++ include/linux/netfs.h | 2 ++ 3 files changed, 10 insertions(+), 1 deletion(-)
fs/netfs/io.c +5 -1
@@ -643,7 +643,11 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)return -EIO ; } - rreq->io_iter = rreq->iter; +if (test_bit (NETFS_RREQ_USE_BOUNCE_BUFFER , &rreq->flags)) +iov_iter_xarray (&rreq->io_iter,ITER_DEST , &rreq->bounce, + rreq->start, rreq->len); +else + rreq->io_iter = rreq->iter;INIT_WORK (&rreq->work, netfs_rreq_work);
fs/netfs/objects.c +3 -0
@@ -35,6 +35,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, rreq->inode = inode; rreq->i_size =i_size_read (inode); rreq->debug_id =atomic_inc_return (&debug_ids); +xa_init (&rreq->bounce);INIT_LIST_HEAD (&rreq->subrequests);refcount_set (&rreq->ref,1 );__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags);
@@ -43,6 +44,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,if (rreq->netfs_ops->init_request) { ret = rreq->netfs_ops->init_request (rreq, file);if (ret <0 ) { +xa_destroy (&rreq->bounce);kfree (rreq);return ERR_PTR (ret); }
@@ -96,6 +98,7 @@ static void netfs_free_request(struct work_struct *work) }kvfree (rreq->direct_bv); } +netfs_clear_buffer (&rreq->bounce);kfree_rcu (rreq, rcu);netfs_stat_d (&netfs_n_rh_rreq); }
include/linux/netfs.h +2 -0
@@ -196,6 +196,7 @@ struct netfs_io_request {struct iov_iter iter;/* Unencrypted-side iterator */ struct iov_iter io_iter;/* I/O (Encrypted-side) iterator */ struct bio_vec *direct_bv;/* DIO buffer list (when handling iovec-iter) */ +struct xarray bounce;/* Bounce buffer (eg. for crypto/compression) */ void *netfs_priv;/* Private data for the netfs */ unsigned int direct_bv_count;/* Number of elements in bv[] */ unsigned int debug_id;
@@ -220,6 +221,7 @@ struct netfs_io_request {#define NETFS_RREQ_IN_PROGRESS 5/* Unlocked when the request completes */ #define NETFS_RREQ_NONBLOCK 6/* Don't block if possible (O_NONBLOCK) */ #define NETFS_RREQ_BLOCKED 7/* We blocked */ +#define NETFS_RREQ_USE_BOUNCE_BUFFER 8/* Use bounce buffer */ const struct netfs_request_ops *netfs_ops; };
David Howells
maintainerRFC PATCH 14/53 netfs: Add func to calculate pagecount/size-limited span of an iterator
In reply to David HowellsAdd a function to work out how much of an ITER_BVEC or ITER_XARRAY iterator we can use in a pagecount-limited and size-limited span. This will be used, for example, to limit the number of segments in a subrequest to the maximum number of elements that an RDMA transfer can handle.
--- fs/netfs/iterator.c | 97 +++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 2 + 2 files changed, 99 insertions(+)
fs/netfs/iterator.c +97 -0
@@ -101,3 +101,100 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len,return npages; }EXPORT_SYMBOL_GPL (netfs_extract_user_iter); + +/* +* Select the span of a bvec iterator we're going to use. Limit it by both maximum +* size and maximum number of segments. Returns the size of the span in bytes. +*/ +static size_t netfs_limit_bvec (const struct iov_iter *iter,size_t start_offset, +size_t max_size,size_t max_segs) +{ +const struct bio_vec *bvecs = iter->bvec; +unsigned int nbv = iter->nr_segs, ix =0 , nsegs =0 ; +size_t len, span =0 , n = iter->count; +size_t skip = iter->iov_offset + start_offset; + +if (WARN_ON (!iov_iter_is_bvec (iter)) || +WARN_ON (start_offset > n) || + n ==0 ) +return 0 ; + +while (n && ix < nbv && skip) { + len = bvecs[ix].bv_len; +if (skip < len) +break ; + skip -= len; + n -= len; + ix++; + } + +while (n && ix < nbv) { + len =min3 (n, bvecs[ix].bv_len - skip, max_size); + span += len; + nsegs++; + ix++; +if (span >= max_size || nsegs >= max_segs) +break ; + skip =0 ; + n -= len; + } + +return min (span, max_size); +} + +/* +* Select the span of an xarray iterator we're going to use. Limit it by both +* maximum size and maximum number of segments. It is assumed that segments +* can be larger than a page in size, provided they're physically contiguous. +* Returns the size of the span in bytes. +*/ +static size_t netfs_limit_xarray (const struct iov_iter *iter,size_t start_offset, +size_t max_size,size_t max_segs) +{ +struct folio *folio; +unsigned int nsegs =0 ; +loff_t pos = iter->xarray_start + iter->iov_offset; +pgoff_t index = pos /PAGE_SIZE ; +size_t span =0 , n = iter->count; + +XA_STATE (xas, iter->xarray, index); + +if (WARN_ON (!iov_iter_is_xarray (iter)) || +WARN_ON (start_offset > n) || + n ==0 ) +return 0 ; + max_size =min (max_size, n - start_offset); + +rcu_read_lock (); +xas_for_each (&xas, folio,ULONG_MAX ) { +size_t offset, flen, len; +if (xas_retry (&xas, folio)) +continue ; +if (WARN_ON (xa_is_value (folio))) +break ; +if (WARN_ON (folio_test_hugetlb (folio))) +break ; + + flen =folio_size (folio); + offset =offset_in_folio (folio, pos); + len =min (max_size, flen - offset); + span += len; + nsegs++; +if (span >= max_size || nsegs >= max_segs) +break ; + } + +rcu_read_unlock (); +return min (span, max_size); +} + +size_t netfs_limit_iter (const struct iov_iter *iter,size_t start_offset, +size_t max_size,size_t max_segs) +{ +if (iov_iter_is_bvec (iter)) +return netfs_limit_bvec (iter, start_offset, max_size, max_segs); +if (iov_iter_is_xarray (iter)) +return netfs_limit_xarray (iter, start_offset, max_size, max_segs); +BUG (); +} +EXPORT_SYMBOL (netfs_limit_iter);
include/linux/netfs.h +2 -0
@@ -328,6 +328,8 @@ void netfs_stats_show(struct seq_file *);ssize_t netfs_extract_user_iter (struct iov_iter *orig,size_t orig_len,struct iov_iter *new,iov_iter_extraction_t extraction_flags); +size_t netfs_limit_iter (const struct iov_iter *iter,size_t start_offset, +size_t max_size,size_t max_segs);int netfs_start_io_read (struct inode *inode);void netfs_end_io_read (struct inode *inode);
David Howells
maintainerRFC PATCH 15/53 netfs: Limit subrequest by size or number of segments
In reply to David HowellsLimit a subrequest to a maximum size and/or a maximum number of contiguous physical regions. This permits, for instance, an subreq's iterator to be limited to the number of DMA'able segments that a large RDMA request can handle.
--- fs/netfs/io.c | 18 ++++++++++++++++++ include/linux/netfs.h | 1 + include/trace/events/netfs.h | 1 + 3 files changed, 20 insertions(+)
fs/netfs/io.c +18 -0
@@ -525,6 +525,7 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq, struct iov_iter *io_iter) {enum netfs_io_source source; +size_t lsize;_enter ("%llx-%llx,%llx" , subreq->start, subreq->start + subreq->len, rreq->i_size);
@@ -547,13 +548,30 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq, source =NETFS_INVALID_READ ; goto out; } + +if (subreq->max_nr_segs) { + lsize =netfs_limit_iter (io_iter,0 , subreq->len, + subreq->max_nr_segs); +if (subreq->len > lsize) { + subreq->len = lsize; +trace_netfs_sreq (subreq, netfs_sreq_trace_limited); + } + } } +if (subreq->len > rreq->len) +pr_warn ("R=%08x[%u] SREQ>RREQ %zx > %zx\n" , + rreq->debug_id, subreq->debug_index, + subreq->len, rreq->len); +if (WARN_ON (subreq->len ==0 )) { source =NETFS_INVALID_READ ; goto out; } + subreq->source = source; +trace_netfs_sreq (subreq, netfs_sreq_trace_prepare); + subreq->io_iter = *io_iter;iov_iter_truncate (&subreq->io_iter, subreq->len);iov_iter_advance (io_iter, subreq->len);
include/linux/netfs.h +1 -0
@@ -163,6 +163,7 @@ struct netfs_io_subrequest {refcount_t ref;short error;/* 0 or error that occurred */ unsigned short debug_index;/* Index in list (for debugging output) */ +unsigned int max_nr_segs;/* 0 or max number of segments in an iterator */ enum netfs_io_source source;/* Where to read from/write to */ unsigned long flags;#define NETFS_SREQ_COPY_TO_CACHE 0/* Set if should copy the data to the cache */
include/trace/events/netfs.h +1 -0
@@ -44,6 +44,7 @@#define netfs_sreq_traces \ EM(netfs_sreq_trace_download_instead, "RDOWN") \ EM(netfs_sreq_trace_free, "FREE ") \ + EM(netfs_sreq_trace_limited, "LIMIT") \ EM(netfs_sreq_trace_prepare, "PREP ") \ EM(netfs_sreq_trace_resubmit_short, "SHORT") \ EM(netfs_sreq_trace_submit, "SUBMT") \
David Howells
maintainerRFC PATCH 16/53 netfs: Export netfs_put_subrequest() and some tracepoints
In reply to David HowellsExport netfs_put_subrequest() and the netfs_rreq and netfs_sreq tracepoints.
--- fs/netfs/main.c | 3 +++ fs/netfs/objects.c | 1 + 2 files changed, 4 insertions(+)
fs/netfs/main.c +3 -0
@@ -17,6 +17,9 @@ MODULE_DESCRIPTION("Network fs support");MODULE_AUTHOR ("Red Hat, Inc." );MODULE_LICENSE ("GPL" ); +EXPORT_TRACEPOINT_SYMBOL (netfs_rreq); +EXPORT_TRACEPOINT_SYMBOL (netfs_sreq); +unsigned netfs_debug;module_param_named (debug, netfs_debug, uint,S_IWUSR |S_IRUGO );MODULE_PARM_DESC (netfs_debug,"Netfs support debugging mask" );
fs/netfs/objects.c +1 -0
@@ -180,3 +180,4 @@ void netfs_put_subrequest(struct netfs_io_subrequest *subreq, bool was_async,if (dead)netfs_free_subrequest (subreq, was_async); } +EXPORT_SYMBOL (netfs_put_subrequest);
David Howells
maintainerRFC PATCH 17/53 netfs: Extend the netfs_io_*request structs to handle writes
In reply to David HowellsModify the netfs_io_request struct to act as a point around which writes can be coordinated. It represents and pins a range of pages that need writing and a list of regions of dirty data in that range of pages.
If RMW is required, the original data can be downloaded into the bounce buffer, decrypted if necessary, the modifications made, then the modified data can be reencrypted/recompressed and sent back to the server.
--- fs/netfs/internal.h | 6 ++++++ fs/netfs/main.c | 3 ++- fs/netfs/objects.c | 6 ++++++ fs/netfs/stats.c | 18 ++++++++++++++---- include/linux/netfs.h | 15 ++++++++++++++- include/trace/events/netfs.h | 8 ++++++-- 6 files changed, 48 insertions(+), 8 deletions(-)
fs/netfs/internal.h +6 -0
@@ -109,6 +109,12 @@ extern atomic_t netfs_n_rh_write_begin;extern atomic_t netfs_n_rh_write_done;extern atomic_t netfs_n_rh_write_failed;extern atomic_t netfs_n_rh_write_zskip; +extern atomic_t netfs_n_wh_upload; +extern atomic_t netfs_n_wh_upload_done; +extern atomic_t netfs_n_wh_upload_failed; +extern atomic_t netfs_n_wh_write; +extern atomic_t netfs_n_wh_write_done; +extern atomic_t netfs_n_wh_write_failed;static inline void netfs_stat (atomic_t *stat)
fs/netfs/main.c +2 -1
@@ -28,10 +28,11 @@ MODULE_PARM_DESC(netfs_debug, "Netfs support debugging mask");LIST_HEAD (netfs_io_requests);DEFINE_SPINLOCK (netfs_proc_lock); -static const char *netfs_origins[] = { +static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READAHEAD ] ="RA" , [NETFS_READPAGE ] ="RP" , [NETFS_READ_FOR_WRITE ] ="RW" , + [NETFS_WRITEBACK ] ="WB" , };/*
fs/netfs/objects.c +6 -0
@@ -20,6 +20,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,struct inode *inode = file ?file_inode (file) : mapping->host;struct netfs_inode *ctx =netfs_inode (inode);struct netfs_io_request *rreq; +bool cached =netfs_is_cache_enabled (ctx);int ret; rreq = kzalloc(ctx->ops->io_request_size ?: sizeof(struct netfs_io_request),
@@ -38,7 +39,10 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,xa_init (&rreq->bounce);INIT_LIST_HEAD (&rreq->subrequests);refcount_set (&rreq->ref,1 ); +__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags); +if (cached) +__set_bit (NETFS_RREQ_WRITE_TO_CACHE , &rreq->flags);if (file && file->f_flags &O_NONBLOCK )__set_bit (NETFS_RREQ_NONBLOCK , &rreq->flags);if (rreq->netfs_ops->init_request) {
@@ -50,6 +54,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, } } +trace_netfs_rreq_ref (rreq->debug_id,1 , netfs_rreq_trace_new);netfs_proc_add_rreq (rreq);netfs_stat (&netfs_n_rh_rreq);return rreq;
@@ -134,6 +139,7 @@ struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreqsizeof (struct netfs_io_subrequest ), GFP_KERNEL);if (subreq) { +INIT_WORK (&subreq->work,NULL );INIT_LIST_HEAD (&subreq->rreq_link);refcount_set (&subreq->ref,2 ); subreq->rreq = rreq;
fs/netfs/stats.c +14 -4
@@ -27,6 +27,12 @@ atomic_t netfs_n_rh_write_begin;atomic_t netfs_n_rh_write_done;atomic_t netfs_n_rh_write_failed;atomic_t netfs_n_rh_write_zskip; +atomic_t netfs_n_wh_upload; +atomic_t netfs_n_wh_upload_done; +atomic_t netfs_n_wh_upload_failed; +atomic_t netfs_n_wh_write; +atomic_t netfs_n_wh_write_done; +atomic_t netfs_n_wh_write_failed;void netfs_stats_show (struct seq_file *m) {
@@ -50,9 +56,13 @@ void netfs_stats_show(struct seq_file *m)atomic_read (&netfs_n_rh_read),atomic_read (&netfs_n_rh_read_done), atomic_read(&netfs_n_rh_read_failed)); -seq_printf (m,"RdHelp : WR=%u ws=%u wf=%u\n" , -atomic_read (&netfs_n_rh_write), -atomic_read (&netfs_n_rh_write_done), -atomic_read (&netfs_n_rh_write_failed)); +seq_printf (m,"WrHelp : UL=%u us=%u uf=%u\n" , +atomic_read (&netfs_n_wh_upload), +atomic_read (&netfs_n_wh_upload_done), +atomic_read (&netfs_n_wh_upload_failed)); +seq_printf (m,"WrHelp : WR=%u ws=%u wf=%u\n" , +atomic_read (&netfs_n_wh_write), +atomic_read (&netfs_n_wh_write_done), +atomic_read (&netfs_n_wh_write_failed)); }EXPORT_SYMBOL (netfs_stats_show);
include/linux/netfs.h +14 -1
@@ -118,6 +118,9 @@ enum netfs_io_source {NETFS_DOWNLOAD_FROM_SERVER ,NETFS_READ_FROM_CACHE ,NETFS_INVALID_READ , +NETFS_UPLOAD_TO_SERVER , +NETFS_WRITE_TO_CACHE , +NETFS_INVALID_WRITE , } __mode(byte); typedef void (*netfs_io_terminated_t)(void *priv, ssize_t transferred_or_error,
@@ -151,9 +154,14 @@ struct netfs_cache_resources { };/* -* Descriptor for a single component subrequest. +* Descriptor for a single component subrequest. Each operation represents an +* individual read/write from/to a server, a cache, a journal, etc.. +* +* The buffer iterator is persistent for the life of the subrequest struct and +* the pages it points to can be relied on to exist for the duration. */ struct netfs_io_subrequest { +struct work_struct work;struct netfs_io_request *rreq;/* Supervising I/O request */ struct list_head rreq_link;/* Link in rreq->subrequests */ struct iov_iter io_iter;/* Iterator for this subrequest */
@@ -178,6 +186,8 @@ enum netfs_io_origin {NETFS_READAHEAD ,/* This read was triggered by readahead */ NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ +NETFS_WRITEBACK ,/* This write was triggered by writepages */ + nr__netfs_io_origin }__mode (byte);/*
@@ -202,6 +212,7 @@ struct netfs_io_request {unsigned int direct_bv_count;/* Number of elements in bv[] */ unsigned int debug_id;unsigned int rsize;/* Maximum read size (0 for none) */ +unsigned int subreq_counter;/* Next subreq->debug_index */ 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 */
@@ -223,6 +234,8 @@ struct netfs_io_request {#define NETFS_RREQ_NONBLOCK 6/* Don't block if possible (O_NONBLOCK) */ #define NETFS_RREQ_BLOCKED 7/* We blocked */ #define NETFS_RREQ_USE_BOUNCE_BUFFER 8/* Use bounce buffer */ +#define NETFS_RREQ_WRITE_TO_CACHE 9/* Need to write to the cache */ +#define NETFS_RREQ_UPLOAD_TO_SERVER 10/* Need to write to the server */ const struct netfs_request_ops *netfs_ops; };
include/trace/events/netfs.h +6 -2
@@ -24,7 +24,8 @@#define netfs_rreq_origins \ EM(NETFS_READAHEAD, "RA") \ EM(NETFS_READPAGE, "RP") \ - E_(NETFS_READ_FOR_WRITE, "RW") + EM(NETFS_READ_FOR_WRITE, "RW") \ + E_(NETFS_WRITEBACK, "WB")#define netfs_rreq_traces \ EM(netfs_rreq_trace_assess, "ASSESS ") \
@@ -39,7 +40,10 @@ EM(NETFS_FILL_WITH_ZEROES, "ZERO") \ EM(NETFS_DOWNLOAD_FROM_SERVER, "DOWN") \ EM(NETFS_READ_FROM_CACHE, "READ") \ - E_(NETFS_INVALID_READ, "INVL") \ + EM(NETFS_INVALID_READ, "INVL") \ + EM(NETFS_UPLOAD_TO_SERVER, "UPLD") \ + EM(NETFS_WRITE_TO_CACHE, "WRIT") \ + E_(NETFS_INVALID_WRITE, "INVL")#define netfs_sreq_traces \ EM(netfs_sreq_trace_download_instead, "RDOWN") \
David Howells
maintainerRFC PATCH 18/53 netfs: Add a hook to allow tell the netfs to update its i_size
In reply to David HowellsAdd a hook for netfslib's write helpers to call to tell the network filesystem that it should update its i_size.
--- include/linux/netfs.h | 4 ++++ 1 file changed, 4 insertions(+)
include/linux/netfs.h +4 -0
@@ -250,6 +250,7 @@ struct netfs_request_ops {void (*free_subrequest)(struct netfs_io_subrequest *rreq);int (*begin_cache_operation)(struct netfs_io_request *rreq); +/* Read request handling */ void (*expand_readahead)(struct netfs_io_request *rreq);bool (*clamp_length)(struct netfs_io_subrequest *subreq);void (*issue_read)(struct netfs_io_subrequest *subreq);
@@ -257,6 +258,9 @@ struct netfs_request_ops {int (*check_write_begin)(struct file *file,loff_t pos,unsigned len,struct folio **foliop,void **_fsdata);void (*done)(struct netfs_io_request *rreq); + +/* Modification handling */ +void (*update_i_size)(struct inode *inode,loff_t i_size); };/*
David Howells
maintainerRFC PATCH 19/53 netfs: Make netfs_put_request() handle a NULL pointer
In reply to David HowellsMake netfs_put_request() just return if given a NULL request pointer.
--- fs/netfs/objects.c | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-)
fs/netfs/objects.c +13 -10
@@ -111,19 +111,22 @@ static void netfs_free_request(struct work_struct *work)void netfs_put_request (struct netfs_io_request *rreq,bool was_async,enum netfs_rreq_ref_trace what) { -unsigned int debug_id = rreq->debug_id; +unsigned int debug_id;bool dead;int r; - dead =__refcount_dec_and_test (&rreq->ref, &r); -trace_netfs_rreq_ref (debug_id, r -1 , what); -if (dead) { -if (was_async) { - rreq->work.func = netfs_free_request; -if (!queue_work (system_unbound_wq, &rreq->work)) -BUG (); - }else { -netfs_free_request (&rreq->work); +if (rreq) { + debug_id = rreq->debug_id; + dead =__refcount_dec_and_test (&rreq->ref, &r); +trace_netfs_rreq_ref (debug_id, r -1 , what); +if (dead) { +if (was_async) { + rreq->work.func = netfs_free_request; +if (!queue_work (system_unbound_wq, &rreq->work)) +BUG (); + }else { +netfs_free_request (&rreq->work); + } } } }
David Howells
maintainerRFC PATCH 20/53 fscache: Add a function to begin an cache op from a netfslib request
In reply to David HowellsAdd a function to begin an cache read or write operation from a netfslib I/O request. This function can then be pointed to directly by the network filesystem's netfs_request_ops::begin_cache_operation op pointer.
Ideally, netfslib would just call into fscache directly, but that would cause dependency cycles as fscache calls into netfslib directly.
--- fs/9p/vfs_addr.c | 18 ++---------------- fs/afs/file.c | 14 +------------- fs/ceph/addr.c | 2 +- fs/ceph/cache.h | 12 ------------ fs/fscache/io.c | 42 +++++++++++++++++++++++++++++++++++++++++ include/linux/fscache.h | 6 ++++++ 6 files changed, 52 insertions(+), 42 deletions(-)
fs/9p/vfs_addr.c +2 -16
@@ -17,6 +17,7 @@#include <linux/swap.h> #include <linux/uio.h> #include <linux/netfs.h> +#include <linux/fscache.h> #include <net/9p/9p.h> #include <net/9p/client.h>
@@ -82,25 +83,10 @@ static void v9fs_free_request(struct netfs_io_request *rreq)p9_fid_put (fid); } -/** -* v9fs_begin_cache_operation - Begin a cache operation for a read -* @rreq: The read request -*/ -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)); - -return fscache_begin_read_operation (&rreq->cache_resources, cookie); -#else -return -ENOBUFS ; -#endif -} -const struct netfs_request_ops v9fs_req_ops = { .init_request = v9fs_init_request, .free_request = v9fs_free_request, - .begin_cache_operation = v9fs_begin_cache_operation, + .begin_cache_operation = fscache_begin_cache_operation, .issue_read = v9fs_issue_read, };
fs/afs/file.c +1 -13
@@ -360,18 +360,6 @@ static int afs_init_request(struct netfs_io_request *rreq, struct file *file)return 0 ; } -static int afs_begin_cache_operation (struct netfs_io_request *rreq) -{ -#ifdef CONFIG_AFS_FSCACHE -struct afs_vnode *vnode =AFS_FS_I (rreq->inode); - -return fscache_begin_read_operation (&rreq->cache_resources, -afs_vnode_cache (vnode)); -#else -return -ENOBUFS ; -#endif -} -static int afs_check_write_begin (struct file *file,loff_t pos,unsigned len,struct folio **foliop,void **_fsdata) {
@@ -388,7 +376,7 @@ static void afs_free_request(struct netfs_io_request *rreq)const struct netfs_request_ops afs_req_ops = { .init_request = afs_init_request, .free_request = afs_free_request, - .begin_cache_operation = afs_begin_cache_operation, + .begin_cache_operation = fscache_begin_cache_operation, .check_write_begin = afs_check_write_begin, .issue_read = afs_issue_read, };
fs/ceph/addr.c +1 -1
@@ -488,7 +488,7 @@ static void ceph_netfs_free_request(struct netfs_io_request *rreq)const struct netfs_request_ops ceph_netfs_ops = { .init_request = ceph_init_request, .free_request = ceph_netfs_free_request, - .begin_cache_operation = ceph_begin_cache_operation, + .begin_cache_operation = fscache_begin_cache_operation, .issue_read = ceph_netfs_issue_read, .expand_readahead = ceph_netfs_expand_readahead, .clamp_length = ceph_netfs_clamp_length,
fs/ceph/cache.h +0 -12
@@ -57,13 +57,6 @@ static inline int ceph_fscache_dirty_folio(struct address_space *mapping,return fscache_dirty_folio (mapping, folio,ceph_fscache_cookie (ci)); } -static inline int ceph_begin_cache_operation (struct netfs_io_request *rreq) -{ -struct fscache_cookie *cookie =ceph_fscache_cookie (ceph_inode (rreq->inode)); - -return fscache_begin_read_operation (&rreq->cache_resources, cookie); -} -static inline bool ceph_is_cache_enabled (struct inode *inode) {return fscache_cookie_enabled (ceph_fscache_cookie (ceph_inode (inode)));
@@ -135,11 +128,6 @@ static inline bool ceph_is_cache_enabled(struct inode *inode)return false; } -static inline int ceph_begin_cache_operation (struct netfs_io_request *rreq) -{ -return -ENOBUFS ; -} -static inline void ceph_fscache_note_page_release (struct inode *inode) { }
fs/fscache/io.c +42 -0
48 lines not on this page · raw message
include/linux/fscache.h +6 -0
@@ -177,6 +177,12 @@ extern void __fscache_write_to_cache(struct fscache_cookie *, struct address_spa bool);extern void __fscache_clear_page_bits (struct address_space *,loff_t ,size_t ); +#if __fscache_available +extern int fscache_begin_cache_operation (struct netfs_io_request *rreq); +#else +#define fscache_begin_cache_operation NULL +#endif +/** * fscache_acquire_volume - Register a volume as desiring caching services * @volume_key: An identification string for the volume
David Howells
maintainerRFC PATCH 21/53 netfs: Make the refcounting of netfs_begin_read() easier to use
In reply to David HowellsMake the refcounting of netfs_begin_read() easier to use by not eating the caller's ref on the netfs_io_request it's given. This makes it easier to use when we need to look in the request struct after.
--- fs/netfs/buffered_read.c | 6 +++++- fs/netfs/io.c | 28 +++++++++++++--------------- include/trace/events/netfs.h | 9 +++++---- 3 files changed, 23 insertions(+), 20 deletions(-)
fs/netfs/buffered_read.c +5 -1
@@ -217,6 +217,7 @@ void netfs_readahead(struct readahead_control *ractl) ;netfs_begin_read (rreq, false); +netfs_put_request (rreq, false, netfs_rreq_trace_put_return);return ; cleanup_free:
@@ -267,7 +268,9 @@ int netfs_read_folio(struct file *file, struct folio *folio)iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, rreq->start, rreq->len); -return netfs_begin_read (rreq, true); + ret =netfs_begin_read (rreq, true); +netfs_put_request (rreq, false, netfs_rreq_trace_put_return); +return ret; discard:netfs_put_request (rreq, false, netfs_rreq_trace_put_discard);
@@ -436,6 +439,7 @@ int netfs_write_begin(struct netfs_inode *ctx, ret =netfs_begin_read (rreq, true);if (ret <0 ) goto error; +netfs_put_request (rreq, false, netfs_rreq_trace_put_return); have_folio: ret =folio_wait_fscache_killable (folio);
fs/netfs/io.c +13 -15
@@ -362,6 +362,7 @@ static void netfs_rreq_assess(struct netfs_io_request *rreq, bool was_async)netfs_rreq_unlock_folios (rreq); +trace_netfs_rreq (rreq, netfs_rreq_trace_wake_ip);clear_bit_unlock (NETFS_RREQ_IN_PROGRESS , &rreq->flags);wake_up_bit (&rreq->flags,NETFS_RREQ_IN_PROGRESS );
@@ -657,7 +658,6 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)if (rreq->len ==0 ) {pr_err ("Zero-sized read [R=%x]\n" , rreq->debug_id); -netfs_put_request (rreq, false, netfs_rreq_trace_put_zero_len);return -EIO ; }
@@ -669,12 +669,10 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)INIT_WORK (&rreq->work, netfs_rreq_work); -if (sync) -netfs_get_request (rreq, netfs_rreq_trace_get_hold); -/* Chop the read into slices according to what the cache and the netfs * want and submit each one. */ +netfs_get_request (rreq, netfs_rreq_trace_get_for_outstanding);atomic_set (&rreq->nr_outstanding,1 ); io_iter = rreq->io_iter; do {
@@ -684,25 +682,25 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync) }while (rreq->submitted < rreq->len);if (sync) { -/* 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. +/* 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. Note that this might start +* further work, such as writing to the cache. */ -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 ); +if (atomic_dec_and_test (&rreq->nr_outstanding))netfs_rreq_assess (rreq, false); -if (!test_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags)) -break ; -cond_resched (); - } + +trace_netfs_rreq (rreq, netfs_rreq_trace_wait_ip); +wait_on_bit (&rreq->flags,NETFS_RREQ_IN_PROGRESS , +TASK_UNINTERRUPTIBLE ); ret = rreq->error;if (ret ==0 && rreq->submitted < rreq->len) {trace_netfs_failure (rreq,NULL , ret, netfs_fail_short_read); ret = -EIO ; } -netfs_put_request (rreq, false, netfs_rreq_trace_put_hold); }else {/* If we decrement nr_outstanding to 0, the ref belongs to us. */ if (atomic_dec_and_test (&rreq->nr_outstanding))
include/trace/events/netfs.h +5 -4
@@ -34,7 +34,9 @@ EM(netfs_rreq_trace_free, "FREE ") \ EM(netfs_rreq_trace_resubmit, "RESUBMT") \ EM(netfs_rreq_trace_unlock, "UNLOCK ") \ - E_(netfs_rreq_trace_unmark, "UNMARK ") + EM(netfs_rreq_trace_unmark, "UNMARK ") \ + EM(netfs_rreq_trace_wait_ip, "WAIT-IP") \ + E_(netfs_rreq_trace_wake_ip, "WAKE-IP")#define netfs_sreq_sources \ EM(NETFS_FILL_WITH_ZEROES, "ZERO") \
@@ -65,14 +67,13 @@ E_(netfs_fail_prepare_write, "prep-write")#define netfs_rreq_ref_traces \ - EM(netfs_rreq_trace_get_hold, "GET HOLD ") \ + EM(netfs_rreq_trace_get_for_outstanding,"GET OUTSTND") \ EM(netfs_rreq_trace_get_subreq, "GET SUBREQ ") \ EM(netfs_rreq_trace_put_complete, "PUT COMPLT ") \ EM(netfs_rreq_trace_put_discard, "PUT DISCARD") \ EM(netfs_rreq_trace_put_failed, "PUT FAILED ") \ - EM(netfs_rreq_trace_put_hold, "PUT HOLD ") \ + EM(netfs_rreq_trace_put_return, "PUT RETURN ") \ EM(netfs_rreq_trace_put_subreq, "PUT SUBREQ ") \ - EM(netfs_rreq_trace_put_zero_len, "PUT ZEROLEN") \ E_(netfs_rreq_trace_new, "NEW ")#define netfs_sreq_ref_traces \
David Howells
maintainerRFC PATCH 22/53 netfs: Prep to use folio->private for write grouping and streaming write
In reply to David HowellsPrepare to use folio->private to hold information write grouping and streaming write. These are implemented in the same commit as they both make use of folio->private and will be both checked at the same time in several places.
"Write grouping" involves ordering the writeback of groups of writes, such as is needed for ceph snaps. A group is represented by a filesystem-supplied object which must contain a netfs_group struct. This contains just a refcount and a pointer to a destructor.
"Streaming write" is the storage of data in folios that are marked dirty, but not uptodate, to avoid unnecessary reads of data. This is represented by a netfs_folio struct. This contains the offset and length of the modified region plus the otherwise displaced write grouping pointer.
The way folio->private is multiplexed is:
(1) If private is NULL then neither is in operation on a dirty folio.
(2) If private is set, with bit 0 clear, then this points to a group.
(3) If private is set, with bit 0 set, then this points to a netfs_folio struct (with bit 0 AND'ed out).
--- fs/netfs/internal.h | 28 ++++++++++++++++++++++++++ fs/netfs/misc.c | 46 +++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 41 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 115 insertions(+)
fs/netfs/internal.h +28 -0
@@ -147,6 +147,34 @@ static inline bool netfs_is_cache_enabled(struct netfs_inode *ctx)#endif } +/* +* Get a ref on a netfs group attached to a dirty page (e.g. a ceph snap). +*/ +static inline struct netfs_group *netfs_get_group (struct netfs_group *netfs_group) +{ +if (netfs_group) +refcount_inc (&netfs_group->ref); +return netfs_group; +} + +/* +* Dispose of a netfs group attached to a dirty page (e.g. a ceph snap). +*/ +static inline void netfs_put_group (struct netfs_group *netfs_group) +{ +if (netfs_group &&refcount_dec_and_test (&netfs_group->ref)) + netfs_group->free (netfs_group); +} + +/* +* Dispose of a netfs group attached to a dirty page (e.g. a ceph snap). +*/ +static inline void netfs_put_group_many (struct netfs_group *netfs_group,int nr) +{ +if (netfs_group &&refcount_sub_and_test (nr, &netfs_group->ref)) + netfs_group->free (netfs_group); +} +/*****************************************************************************/ /* * debug tracing
fs/netfs/misc.c +46 -0
55 lines not on this page · raw message
include/linux/netfs.h +41 -0
47 lines not on this page · raw message
David Howells
maintainerRFC PATCH 23/53 netfs: Dispatch write requests to process a writeback slice
In reply to David HowellsDispatch one or more write reqeusts to process a writeback slice, where a slice is tailored more to logical block divisions within the file (such as crypto blocks, an object layout or cache granules) than the protocol RPC maximum capacity.
The dispatch doesn't happen until throttling allows, at which point the entire writeback slice is processed and queued. A slice may be written to multiple destinations (one or more servers and the local cache) and the writes to each destination might be split up along different lines.
The writeback slice holds the required folios pinned. An iov_iter is provided in netfs_write_request that describes the buffer to be used. This may be part of the pagecache, may have auxiliary padding pages attached or may be a bounce buffer resulting from crypto or compression. Consequently, the filesystem must not twiddle the folio markings directly.
The following API is available to the filesystem:
(1) The ->create_write_requests() method is called to ask the filesystem to create the requests it needs. This is passed the writeback slice to be processed.
(2) The filesystem should then call netfs_create_write_request() to create the requests it needs.
(3) Once a request is initialised, netfs_queue_write_request() can be called to dispatch it asynchronously, if not completed immediately.
(4) netfs_write_request_completed() should be called to note the completion of a request.
(5) netfs_get_write_request() and netfs_put_write_request() are provided to refcount a request. These take constants from the netfs_wreq_trace enum for logging into ftrace.
(6) The ->free_write_request is method is called to ask the filesystem to clean up a request.
--- fs/netfs/Makefile | 3 +- fs/netfs/internal.h | 6 + fs/netfs/output.c | 366 +++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 13 ++ include/trace/events/netfs.h | 50 ++++- 5 files changed, 435 insertions(+), 3 deletions(-) create mode 100644 fs/netfs/output.c
fs/netfs/Makefile +2 -1
@@ -7,7 +7,8 @@ netfs-y := \ locking.o \ main.o \ misc.o \ - objects.o + objects.o \ + output.o netfs-$(CONFIG_NETFS_STATS) += stats.o
fs/netfs/internal.h +6 -0
@@ -87,6 +87,12 @@ static inline void netfs_see_request(struct netfs_io_request *rreq,trace_netfs_rreq_ref (rreq->debug_id,refcount_read (&rreq->ref), what); } +/* +* output.c +*/ +int netfs_begin_write (struct netfs_io_request *wreq,bool may_wait, +enum netfs_write_trace what); +/* * stats.c */
fs/netfs/output.c new file +366 -0
366 lines not on this page · raw message
include/linux/netfs.h +13 -0
@@ -253,6 +253,7 @@ struct netfs_io_request {unsigned int direct_bv_count;/* Number of elements in bv[] */ unsigned int debug_id;unsigned int rsize;/* Maximum read size (0 for none) */ +unsigned int wsize;/* Maximum write size (0 for none) */ unsigned int subreq_counter;/* Next subreq->debug_index */ atomic_t nr_outstanding;/* Number of ops in progress */ atomic_t nr_copy_ops;/* Number of copy-to-cache ops in progress */
@@ -278,6 +279,7 @@ struct netfs_io_request {#define NETFS_RREQ_WRITE_TO_CACHE 9/* Need to write to the cache */ #define NETFS_RREQ_UPLOAD_TO_SERVER 10/* Need to write to the server */ const struct netfs_request_ops *netfs_ops; +void (*cleanup)(struct netfs_io_request *req); };/*
@@ -302,6 +304,11 @@ struct netfs_request_ops {/* Modification handling */ void (*update_i_size)(struct inode *inode,loff_t i_size); + +/* Write request handling */ +void (*create_write_requests)(struct netfs_io_request *wreq, +loff_t start,size_t len); +void (*invalidate_cache)(struct netfs_io_request *wreq); };/*
@@ -389,6 +396,12 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len, iov_iter_extraction_t extraction_flags);size_t netfs_limit_iter (const struct iov_iter *iter,size_t start_offset,size_t max_size,size_t max_segs); +struct netfs_io_subrequest *netfs_create_write_request ( +struct netfs_io_request *wreq,enum netfs_io_source dest, +loff_t start,size_t len,work_func_t worker); +void netfs_write_subrequest_terminated (void *_op,ssize_t transferred_or_error, +bool was_async); +void netfs_queue_write_request (struct netfs_io_subrequest *subreq);int netfs_start_io_read (struct inode *inode);void netfs_end_io_read (struct inode *inode);
include/trace/events/netfs.h +48 -2
105 lines not on this page · raw message
David Howells
maintainerRFC PATCH 24/53 netfs: Provide func to copy data to pagecache for buffered write
In reply to David HowellsProvide a netfs write helper, netfs_perform_write() to buffer data to be written in the pagecache and mark the modified folios dirty.
It will perform "streaming writes" for folios that aren't currently resident, if possible, storing data in partially modified folios that are marked dirty, but not uptodate. It will also tag pages as belonging to fs-specific write groups if so directed by the filesystem.
This is derived from generic_perform_write(), but doesn't use ->write_begin() and ->write_end(), having that logic rolled in instead.
--- fs/netfs/Makefile | 2 + fs/netfs/buffered_read.c | 48 +++++ fs/netfs/buffered_write.c | 327 +++++++++++++++++++++++++++++++++++ fs/netfs/internal.h | 2 + include/linux/netfs.h | 5 + include/trace/events/netfs.h | 70 ++++++++ 6 files changed, 454 insertions(+) create mode 100644 fs/netfs/buffered_write.c
fs/netfs/Makefile +2 -0
@@ -2,6 +2,8 @@ netfs-y := \ buffered_read.o \ + buffered_write.o \ + crypto.o \ io.o \ iterator.o \ locking.o \
fs/netfs/buffered_read.c +48 -0
51 lines not on this page · raw message
fs/netfs/buffered_write.c new file +327 -0
327 lines not on this page · raw message
fs/netfs/internal.h +2 -0
@@ -19,6 +19,8 @@* buffered_read.c */ void netfs_rreq_unlock_folios (struct netfs_io_request *rreq); +int netfs_prefetch_for_write (struct file *file,struct folio *folio, +size_t offset,size_t len);/* * io.c
include/linux/netfs.h +5 -0
@@ -376,6 +376,11 @@ struct netfs_cache_ops { loff_t *_data_start, size_t *_data_len); }; +/* High-level write API */ +ssize_t netfs_perform_write (struct kiocb *iocb,struct iov_iter *iter, +struct netfs_group *netfs_group); + +/* Address operations API */ struct readahead_control ;void netfs_readahead (struct readahead_control *);int netfs_read_folio (struct file *,struct folio *);
include/trace/events/netfs.h +70 -0
100 lines not on this page · raw message
David Howells
maintainerRFC PATCH 25/53 netfs: Make netfs_read_folio() handle streaming-write pages
In reply to David Howellsnetfs_read_folio() needs to handle partially-valid pages that are marked dirty, but not uptodate in the event that someone tries to read a page was used to cache data by a streaming write.
In such a case, make netfs_read_folio() set up a bvec iterator that points to the parts of the folio that need filling and to a sink page for the data that should be discarded and use that instead of i_pages as the iterator to be written to.
This requires netfs_rreq_unlock_folios() to convert the page into a normal dirty uptodate page, getting rid of the partial write record and bumping the group pointer over to folio->private.
--- fs/netfs/buffered_read.c | 61 ++++++++++++++++++++++++++++++++++-- include/trace/events/netfs.h | 2 ++ 2 files changed, 60 insertions(+), 3 deletions(-)
fs/netfs/buffered_read.c +58 -3
@@ -16,6 +16,7 @@void netfs_rreq_unlock_folios (struct netfs_io_request *rreq) {struct netfs_io_subrequest *subreq; +struct netfs_folio *finfo;struct folio *folio;pgoff_t start_page = rreq->start /PAGE_SIZE ;pgoff_t last_page = ((rreq->start + rreq->len) /PAGE_SIZE ) -1 ;
@@ -86,6 +87,15 @@ void netfs_rreq_unlock_folios(struct netfs_io_request *rreq)if (!pg_failed) {flush_dcache_folio (folio); + finfo =netfs_folio_info (folio); +if (finfo) { +trace_netfs_folio (folio, netfs_folio_trace_filled_gaps); +if (finfo->netfs_group) +folio_change_private (folio, finfo->netfs_group); +else +folio_detach_private (folio); +kfree (finfo); + }folio_mark_uptodate (folio); }
@@ -245,6 +255,7 @@ int netfs_read_folio(struct file *file, struct folio *folio)struct address_space *mapping =folio_file_mapping (folio);struct netfs_io_request *rreq;struct netfs_inode *ctx =netfs_inode (mapping->host); +struct folio *sink =NULL ;int ret;_enter ("%lx" ,folio_index (folio));
@@ -265,12 +276,56 @@ int netfs_read_folio(struct file *file, struct folio *folio)trace_netfs_read (rreq, rreq->start, rreq->len, netfs_read_trace_readpage);/* Set up the output buffer */ -iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, - rreq->start, rreq->len); +if (folio_test_dirty (folio)) { +/* Handle someone trying to read from an unflushed streaming +* write. We fiddle the buffer so that a gap at the beginning +* and/or a gap at the end get copied to, but the middle is +* discarded. +*/ +struct netfs_folio *finfo =netfs_folio_info (folio); +struct bio_vec *bvec; +unsigned int from = finfo->dirty_offset; +unsigned int to = from + finfo->dirty_len; +unsigned int off =0 , i =0 ; +size_t flen =folio_size (folio); +size_t nr_bvec = flen /PAGE_SIZE +2 ; +size_t part; + + ret = -ENOMEM ; + bvec =kmalloc_array (nr_bvec,sizeof (*bvec),GFP_KERNEL ); +if (!bvec) + goto discard; + + sink =folio_alloc (GFP_KERNEL ,0 ); +if (!sink) + goto discard; + +trace_netfs_folio (folio, netfs_folio_trace_read_gaps); + + rreq->direct_bv = bvec; + rreq->direct_bv_count = nr_bvec; +if (from >0 ) { +bvec_set_folio (&bvec[i++], folio, from,0 ); + off = from; + } +while (off < to) { + part =min_t (size_t, to - off,PAGE_SIZE ); +bvec_set_folio (&bvec[i++], sink, part,0 ); + off += part; + } +if (to < flen) +bvec_set_folio (&bvec[i++], folio, flen - to, to); +iov_iter_bvec (&rreq->iter,ITER_DEST , bvec, i, rreq->len); + }else { +iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, + rreq->start, rreq->len); + } ret =netfs_begin_read (rreq, true); +if (sink) +folio_put (sink);netfs_put_request (rreq, false, netfs_rreq_trace_put_return); -return ret; +return ret <0 ? ret :0 ; discard:netfs_put_request (rreq, false, netfs_rreq_trace_put_discard);
include/trace/events/netfs.h +2 -0
@@ -115,9 +115,11 @@ EM(netfs_folio_trace_clear, "clear") \ EM(netfs_folio_trace_clear_s, "clear-s") \ EM(netfs_folio_trace_clear_g, "clear-g") \ + EM(netfs_folio_trace_filled_gaps, "filled-gaps") \ EM(netfs_folio_trace_kill, "kill") \ EM(netfs_folio_trace_mkwrite, "mkwrite") \ EM(netfs_folio_trace_mkwrite_plus, "mkwrite+") \ + EM(netfs_folio_trace_read_gaps, "read-gaps") \ EM(netfs_folio_trace_redirty, "redirty") \ EM(netfs_folio_trace_redirtied, "redirtied") \EM (netfs_folio_trace_store,"store" ) \
David Howells
maintainerRFC PATCH 26/53 netfs: Allocate multipage folios in the writepath
In reply to David HowellsAllocate a multipage folio when copying data into the pagecache if possible if there's sufficient data to warrant it.
--- fs/netfs/buffered_write.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
fs/netfs/buffered_write.c +7 -2
@@ -84,14 +84,19 @@ static enum netfs_how_to_modify netfs_how_to_modify(struct netfs_inode *ctx, }/* -* Grab a folio for writing and lock it. +* Grab a folio for writing and lock it. Attempt to allocate as large a folio +* as possible to hold as much of the remaining length as possible in one go. */ static struct folio *netfs_grab_folio_for_write (struct address_space *mapping,loff_t pos,size_t part) {pgoff_t index = pos /PAGE_SIZE ; +fgf_t fgp_flags =FGP_WRITEBEGIN ; -return __filemap_get_folio (mapping, index,FGP_WRITEBEGIN , +if (mapping_large_folio_support (mapping)) + fgp_flags |=fgf_set_order (pos %PAGE_SIZE + part); + +return __filemap_get_folio (mapping, index, fgp_flags,mapping_gfp_mask (mapping)); }
David Howells
maintainerRFC PATCH 27/53 netfs: Implement support for unbuffered/DIO read
In reply to David HowellsImplement support for unbuffered and DIO reads in the netfs library, utilising the existing read helper code to do block splitting and individual queuing. The code also handles extraction of the destination buffer from the supplied iterator, allowing async unbuffered reads to take place.
The read will be split up according to the rsize setting and, if supplied, the ->clamp_length() method. Note that the next subrequest will be issued as soon as issue_op returns, without waiting for previous ones to finish. The network filesystem needs to pause or handle queuing them if it doesn't want to fire them all at the server simultaneously.
Once all the subrequests have finished, the state will be assessed and the amount of data to be indicated as having being obtained will be determined. As the subrequests may finish in any order, if an intermediate subrequest is short, any further subrequests may be copied into the buffer and then abandoned.
In the future, this will also take care of doing an unbuffered read from encrypted content, with the decryption being done by the library.
--- fs/netfs/Makefile | 2 +- fs/netfs/direct_read.c | 252 +++++++++++++++++++++++++++++++++++ fs/netfs/internal.h | 1 + fs/netfs/io.c | 78 +++++++++-- fs/netfs/main.c | 1 + fs/netfs/objects.c | 3 +- fs/netfs/stats.c | 4 +- include/linux/netfs.h | 6 + include/trace/events/netfs.h | 7 +- 9 files changed, 342 insertions(+), 12 deletions(-) create mode 100644 fs/netfs/direct_read.c
fs/netfs/Makefile +1 -1
@@ -3,7 +3,7 @@ netfs-y := \ buffered_read.o \ buffered_write.o \ - crypto.o \ + direct_read.o \ io.o \ iterator.o \ locking.o \
fs/netfs/direct_read.c new file +252 -0
252 lines not on this page · raw message
fs/netfs/internal.h +1 -0
@@ -99,6 +99,7 @@ int netfs_begin_write(struct netfs_io_request *wreq, bool may_wait,* stats.c */ #ifdef CONFIG_NETFS_STATS +extern atomic_t netfs_n_rh_dio_read;extern atomic_t netfs_n_rh_readahead;extern atomic_t netfs_n_rh_readpage;extern atomic_t netfs_n_rh_rreq;
fs/netfs/io.c +70 -8
135 lines not on this page · raw message
fs/netfs/main.c +1 -0
@@ -33,6 +33,7 @@ static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READPAGE] = "RP", [NETFS_READ_FOR_WRITE] = "RW", [NETFS_WRITEBACK] = "WB", + [NETFS_DIO_READ] = "DR", };/*
fs/netfs/objects.c +2 -1
@@ -20,7 +20,8 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,struct inode *inode = file ?file_inode (file) : mapping->host;struct netfs_inode *ctx =netfs_inode (inode);struct netfs_io_request *rreq; -bool cached =netfs_is_cache_enabled (ctx); +bool is_dio = (origin ==NETFS_DIO_READ ); +bool cached = is_dio &&netfs_is_cache_enabled (ctx);int ret; rreq = kzalloc(ctx->ops->io_request_size ?: sizeof(struct netfs_io_request),
fs/netfs/stats.c +3 -1
@@ -9,6 +9,7 @@#include <linux/seq_file.h> #include "internal.h" +atomic_t netfs_n_rh_dio_read;atomic_t netfs_n_rh_readahead;atomic_t netfs_n_rh_readpage;atomic_t netfs_n_rh_rreq;
@@ -36,7 +37,8 @@ atomic_t netfs_n_wh_write_failed;void netfs_stats_show (struct seq_file *m) { - seq_printf(m, "RdHelp : RA=%u RP=%u WB=%u WBZ=%u rr=%u sr=%u\n", + seq_printf(m, "RdHelp : DR=%u RA=%u RP=%u WB=%u WBZ=%u rr=%u sr=%u\n", + atomic_read(&netfs_n_rh_dio_read), atomic_read(&netfs_n_rh_readahead), atomic_read(&netfs_n_rh_readpage), atomic_read(&netfs_n_rh_write_begin),
include/linux/netfs.h +6 -0
@@ -228,6 +228,7 @@ enum netfs_io_origin {NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ +NETFS_DIO_READ ,/* This is a direct I/O read */ nr__netfs_io_origin }__mode (byte);
@@ -242,6 +243,7 @@ struct netfs_io_request { };struct inode *inode;/* The file being accessed */ struct address_space *mapping;/* The mapping being accessed */ +struct kiocb *iocb;/* AIO completion vector */ struct netfs_cache_resources cache_resources;struct list_head proc_link;/* Link in netfs_iorequests */ struct list_head subrequests;/* Contributory I/O operations */
@@ -259,6 +261,7 @@ struct netfs_io_request {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 */ +size_t transferred;/* Amount to be indicated as transferred */ short error;/* 0 or error that occurred */ enum netfs_io_origin origin;/* Origin of the request */ bool direct_bv_unpin;/* T if direct_bv[] must be unpinned */
@@ -376,6 +379,9 @@ struct netfs_cache_ops { loff_t *_data_start, size_t *_data_len); }; +/* High-level read API. */ +ssize_t netfs_unbuffered_read_iter (struct kiocb *iocb,struct iov_iter *iter); +/* High-level write API */ ssize_t netfs_perform_write (struct kiocb *iocb,struct iov_iter *iter,struct netfs_group *netfs_group);
include/trace/events/netfs.h +6 -1
@@ -16,6 +16,7 @@* Define enums for tracing information. */ #define netfs_read_traces \ + EM(netfs_read_trace_dio_read, "DIO-READ ") \ EM(netfs_read_trace_expanded, "EXPANDED ") \ EM(netfs_read_trace_readahead, "READAHEAD") \ EM(netfs_read_trace_readpage, "READPAGE ") \
@@ -31,7 +32,8 @@ EM(NETFS_READAHEAD, "RA") \ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ - E_(NETFS_WRITEBACK, "WB") + EM(NETFS_WRITEBACK, "WB") \ + E_(NETFS_DIO_READ, "DR")#define netfs_rreq_traces \ EM(netfs_rreq_trace_assess, "ASSESS ") \
@@ -70,6 +72,8 @@#define netfs_failures \ EM(netfs_fail_check_write_begin, "check-write-begin") \ EM(netfs_fail_copy_to_cache, "copy-to-cache") \ + EM(netfs_fail_dio_read_short, "dio-read-short") \ + EM(netfs_fail_dio_read_zero, "dio-read-zero") \ EM(netfs_fail_read, "read") \ EM(netfs_fail_short_read, "short-read") \ EM(netfs_fail_prepare_write, "prep-write") \
@@ -81,6 +85,7 @@ EM(netfs_rreq_trace_put_complete, "PUT COMPLT ") \ EM(netfs_rreq_trace_put_discard, "PUT DISCARD") \ EM(netfs_rreq_trace_put_failed, "PUT FAILED ") \ + EM(netfs_rreq_trace_put_no_submit, "PUT NO-SUBM") \ EM(netfs_rreq_trace_put_return, "PUT RETURN ") \ EM(netfs_rreq_trace_put_subreq, "PUT SUBREQ ") \EM (netfs_rreq_trace_put_work,"PUT WORK " ) \
David Howells
maintainerRFC PATCH 28/53 netfs: Implement unbuffered/DIO write support
In reply to David HowellsImplement support for unbuffered writes and direct I/O writes. If the write is misaligned with respect to the fscrypt block size, then RMW cycles are performed if necessary. DIO writes are a special case of unbuffered writes with extra restriction imposed, such as block size alignment requirements.
Also provide a field that can tell the code to add some extra space onto the bounce buffer for use by the filesystem in the case of a content-encrypted file.
--- fs/afs/inode.c | 2 +- fs/netfs/Makefile | 1 + fs/netfs/direct_write.c | 159 +++++++++++++++++++++++++++++++++++ fs/netfs/internal.h | 6 ++ fs/netfs/io.c | 2 +- fs/netfs/main.c | 12 +-- fs/netfs/objects.c | 6 +- fs/netfs/output.c | 24 ++++++ include/linux/netfs.h | 4 + include/trace/events/netfs.h | 4 +- 10 files changed, 210 insertions(+), 10 deletions(-) create mode 100644 fs/netfs/direct_write.c
fs/afs/inode.c +1 -1
@@ -250,7 +250,7 @@ static void afs_apply_status(struct afs_operation *op,* what's on the server. */ vnode->netfs.remote_i_size = status->size; -if (change_size) { +if (change_size || status->size >i_size_read (inode)) {afs_set_i_size (vnode, status->size); vnode->netfs.zero_point = status->size;inode_set_ctime_to_ts (inode, t);
fs/netfs/Makefile +1 -0
@@ -4,6 +4,7 @@ netfs-y := \ buffered_read.o \ buffered_write.o \ direct_read.o \ + direct_write.o \ io.o \ iterator.o \ locking.o \
fs/netfs/direct_write.c new file +159 -0
159 lines not on this page · raw message
fs/netfs/internal.h +6 -0
@@ -22,6 +22,12 @@ void netfs_rreq_unlock_folios(struct netfs_io_request *rreq);int netfs_prefetch_for_write (struct file *file,struct folio *folio,size_t offset,size_t len); +/* +* direct_write.c +*/ +ssize_t netfs_unbuffered_write_iter_locked (struct kiocb *iocb,struct iov_iter *iter, +struct netfs_group *netfs_group); +/* * io.c */
fs/netfs/io.c +1 -1
@@ -643,7 +643,7 @@ static bool netfs_rreq_submit_slice(struct netfs_io_request *rreq, subreq->debug_index = (*_debug_index)++; subreq->start = rreq->start + rreq->submitted; - subreq->len = rreq->len - rreq->submitted; + subreq->len = io_iter->count;_debug ("slice %llx,%zx,%zx" , subreq->start, subreq->len, rreq->submitted);list_add_tail (&subreq->rreq_link, &rreq->subrequests);
fs/netfs/main.c +7 -5
@@ -29,11 +29,13 @@ LIST_HEAD(netfs_io_requests);DEFINE_SPINLOCK (netfs_proc_lock);static const char *netfs_origins[nr__netfs_io_origin] = { - [NETFS_READAHEAD ] ="RA" , - [NETFS_READPAGE ] ="RP" , - [NETFS_READ_FOR_WRITE ] ="RW" , - [NETFS_WRITEBACK ] ="WB" , - [NETFS_DIO_READ ] ="DR" , + [NETFS_READAHEAD ] ="RA" , + [NETFS_READPAGE ] ="RP" , + [NETFS_READ_FOR_WRITE ] ="RW" , + [NETFS_WRITEBACK ] ="WB" , + [NETFS_UNBUFFERED_WRITE ] ="UW" , + [NETFS_DIO_READ ] ="DR" , + [NETFS_DIO_WRITE ] ="DW" , };/*
fs/netfs/objects.c +4 -2
@@ -20,8 +20,10 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,struct inode *inode = file ?file_inode (file) : mapping->host;struct netfs_inode *ctx =netfs_inode (inode);struct netfs_io_request *rreq; -bool is_dio = (origin ==NETFS_DIO_READ ); -bool cached = is_dio &&netfs_is_cache_enabled (ctx); +bool is_unbuffered = (origin ==NETFS_UNBUFFERED_WRITE || + origin ==NETFS_DIO_READ || + origin ==NETFS_DIO_WRITE ); +bool cached = !is_unbuffered &&netfs_is_cache_enabled (ctx);int ret; rreq = kzalloc(ctx->ops->io_request_size ?: sizeof(struct netfs_io_request),
fs/netfs/output.c +24 -0
@@ -74,11 +74,21 @@ static void netfs_write_terminated(struct netfs_io_request *wreq, bool was_async {struct netfs_io_subrequest *subreq;struct netfs_inode *ctx =netfs_inode (wreq->inode); +size_t transferred =0 ;_enter ("R=%x[]" , wreq->debug_id);trace_netfs_rreq (wreq, netfs_rreq_trace_write_done); +list_for_each_entry (subreq, &wreq->subrequests, rreq_link) { +if (subreq->error || subreq->transferred ==0 ) +break ; + transferred += subreq->transferred; +if (subreq->transferred < subreq->len) +break ; + } + wreq->transferred = transferred; +list_for_each_entry (subreq, &wreq->subrequests, rreq_link) {if (!subreq->error)continue ;
@@ -110,11 +120,25 @@ static void netfs_write_terminated(struct netfs_io_request *wreq, bool was_async wreq->cleanup (wreq); +if (wreq->origin ==NETFS_DIO_WRITE && + wreq->mapping->nrpages) { +pgoff_t first = wreq->start >>PAGE_SHIFT ; +pgoff_t last = (wreq->start + wreq->transferred -1 ) >>PAGE_SHIFT ; +invalidate_inode_pages2_range (wreq->mapping, first, last); + } +_debug ("finished" );trace_netfs_rreq (wreq, netfs_rreq_trace_wake_ip);clear_bit_unlock (NETFS_RREQ_IN_PROGRESS , &wreq->flags);wake_up_bit (&wreq->flags,NETFS_RREQ_IN_PROGRESS ); +if (wreq->iocb) { + wreq->iocb->ki_pos += transferred; +if (wreq->iocb->ki_complete) + wreq->iocb->ki_complete ( + wreq->iocb, wreq->error ? wreq->error : transferred); + } +netfs_clear_subrequests (wreq, was_async);netfs_put_request (wreq, was_async, netfs_rreq_trace_put_complete); }
include/linux/netfs.h +4 -0
@@ -140,6 +140,7 @@ struct netfs_inode {* on the server */ unsigned long flags;#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ +#define NETFS_ICTX_UNBUFFERED 1/* I/O should not use the pagecache */ };/*
@@ -228,7 +229,9 @@ enum netfs_io_origin {NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ +NETFS_UNBUFFERED_WRITE ,/* This is an unbuffered write */ NETFS_DIO_READ ,/* This is a direct I/O read */ +NETFS_DIO_WRITE ,/* This is a direct I/O write */ nr__netfs_io_origin }__mode (byte);
@@ -385,6 +388,7 @@ ssize_t netfs_unbuffered_read_iter(struct kiocb *iocb, struct iov_iter *iter);/* High-level write API */ ssize_t netfs_perform_write (struct kiocb *iocb,struct iov_iter *iter,struct netfs_group *netfs_group); +ssize_t netfs_unbuffered_write_iter (struct kiocb *iocb,struct iov_iter *from);/* Address operations API */ struct readahead_control ;
include/trace/events/netfs.h +3 -1
@@ -33,7 +33,9 @@ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ EM(NETFS_WRITEBACK, "WB") \ - E_(NETFS_DIO_READ, "DR") + EM(NETFS_UNBUFFERED_WRITE, "UW") \ + EM(NETFS_DIO_READ, "DR") \ + E_(NETFS_DIO_WRITE, "DW")#define netfs_rreq_traces \ EM(netfs_rreq_trace_assess, "ASSESS ") \
David Howells
maintainerRFC PATCH 29/53 netfs: Implement buffered write API
In reply to David HowellsInstitute a netfs write helper, netfs_file_write_iter(), to be pointed at by the network filesystem ->write_iter() call. Make it handled buffered writes by calling the previously defined netfs_perform_write() to copy the source data into the pagecache.
--- fs/netfs/buffered_write.c | 83 +++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 3 ++ 2 files changed, 86 insertions(+)
fs/netfs/buffered_write.c +83 -0
@@ -330,3 +330,86 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, goto out; }EXPORT_SYMBOL (netfs_perform_write); + +/** +* netfs_buffered_write_iter_locked - write data to a file +* @iocb: IO state structure (file, offset, etc.) +* @from: iov_iter with data to write +* @netfs_group: Grouping for dirty pages (eg. ceph snaps). +* +* This function does all the work needed for actually writing data to a +* file. It does all basic checks, removes SUID from the file, updates +* modification times and calls proper subroutines depending on whether we +* do direct IO or a standard buffered write. +* +* The caller must hold appropriate locks around this function and have called +* generic_write_checks() already. The caller is also responsible for doing +* any necessary syncing afterwards. +* +* This function does *not* take care of syncing data in case of O_SYNC write. +* A caller has to handle it. This is mainly due to the fact that we want to +* avoid syncing under i_rwsem. +* +* Return: +* * number of bytes written, even for truncated writes +* * negative error code if no data has been written at all +*/ +ssize_t netfs_buffered_write_iter_locked (struct kiocb *iocb,struct iov_iter *from, +struct netfs_group *netfs_group) +{ +struct file *file = iocb->ki_filp; +ssize_t ret; + +trace_netfs_write_iter (iocb, from); + + ret =file_remove_privs (file); +if (ret) +return ret; + + ret =file_update_time (file); +if (ret) +return ret; + +return netfs_perform_write (iocb, from, netfs_group); +} +EXPORT_SYMBOL (netfs_buffered_write_iter_locked); + +/** +* netfs_file_write_iter - write data to a file +* @iocb: IO state structure +* @from: iov_iter with data to write +* +* Perform a write to a file, writing into the pagecache if possible and doing +* an unbuffered write instead if not. +* +* Return: +* * Negative error code if no data has been written at all of +* vfs_fsync_range() failed for a synchronous write +* * Number of bytes written, even for truncated writes +*/ +ssize_t netfs_file_write_iter (struct kiocb *iocb,struct iov_iter *from) +{ +struct file *file = iocb->ki_filp; +struct inode *inode = file->f_mapping->host; +struct netfs_inode *ictx =netfs_inode (inode); +ssize_t ret; + +_enter ("%llx,%zx,%llx" , iocb->ki_pos,iov_iter_count (from),i_size_read (inode)); + +if ((iocb->ki_flags &IOCB_DIRECT ) || +test_bit (NETFS_ICTX_UNBUFFERED , &ictx->flags)) +return netfs_unbuffered_write_iter (iocb, from); + + ret =netfs_start_io_write (inode); +if (ret <0 ) +return ret; + + ret =generic_write_checks (iocb, from); +if (ret >0 ) + ret =netfs_buffered_write_iter_locked (iocb, from,NULL ); +netfs_end_io_write (inode); +if (ret >0 ) + ret =generic_write_sync (iocb, ret); +return ret; +} +EXPORT_SYMBOL (netfs_file_write_iter);
include/linux/netfs.h +3 -0
@@ -388,7 +388,10 @@ ssize_t netfs_unbuffered_read_iter(struct kiocb *iocb, struct iov_iter *iter);/* High-level write API */ ssize_t netfs_perform_write (struct kiocb *iocb,struct iov_iter *iter,struct netfs_group *netfs_group); +ssize_t netfs_buffered_write_iter_locked (struct kiocb *iocb,struct iov_iter *from, +struct netfs_group *netfs_group);ssize_t netfs_unbuffered_write_iter (struct kiocb *iocb,struct iov_iter *from); +ssize_t netfs_file_write_iter (struct kiocb *iocb,struct iov_iter *from);/* Address operations API */ struct readahead_control ;
David Howells
maintainerRFC PATCH 30/53 netfs: Allow buffered shared-writeable mmap through netfs_page_mkwrite()
In reply to David HowellsProvide an entry point to delegate a filesystem's ->page_mkwrite() to. This checks for conflicting writes, then attached any netfs-specific group marking (e.g. ceph snap) to the page to be considered dirty.
--- fs/netfs/buffered_write.c | 59 +++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 4 +++ 2 files changed, 63 insertions(+)
fs/netfs/buffered_write.c +59 -0
@@ -413,3 +413,62 @@ ssize_t netfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)return ret; }EXPORT_SYMBOL (netfs_file_write_iter); + +/* +* Notification that a previously read-only page is about to become writable. +* Note that the caller indicates a single page of a multipage folio. +*/ +vm_fault_t netfs_page_mkwrite (struct vm_fault *vmf,struct netfs_group *netfs_group) +{ +struct folio *folio =page_folio (vmf->page); +struct file *file = vmf->vma->vm_file; +struct inode *inode =file_inode (file); +vm_fault_t ret =VM_FAULT_RETRY ; +int err; + +_enter ("%lx" , folio->index); + +sb_start_pagefault (inode->i_sb); + +if (folio_wait_writeback_killable (folio)) + goto out; + +if (folio_lock_killable (folio) <0 ) + goto out; + +/* Can we see a streaming write here? */ +if (WARN_ON (!folio_test_uptodate (folio))) { + ret =VM_FAULT_SIGBUS |VM_FAULT_LOCKED ; + goto out; + } + +if (netfs_folio_group (folio) != netfs_group) { +folio_unlock (folio); + err =filemap_fdatawait_range (inode->i_mapping, +folio_pos (folio), +folio_pos (folio) +folio_size (folio)); +switch (err) { +case 0 : + ret =VM_FAULT_RETRY ; + goto out; +case -ENOMEM : + ret =VM_FAULT_OOM ; + goto out; +default : + ret =VM_FAULT_SIGBUS ; + goto out; + } + } + +if (folio_test_dirty (folio)) +trace_netfs_folio (folio, netfs_folio_trace_mkwrite_plus); +else +trace_netfs_folio (folio, netfs_folio_trace_mkwrite); +netfs_set_group (folio, netfs_group); +file_update_time (file); + ret =VM_FAULT_LOCKED ; +out: +sb_end_pagefault (inode->i_sb); +return ret; +} +EXPORT_SYMBOL (netfs_page_mkwrite);
include/linux/netfs.h +4 -0
@@ -403,6 +403,10 @@ int netfs_write_begin(struct netfs_inode *, struct file *,void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length);bool netfs_release_folio (struct folio *folio,gfp_t gfp); +/* VMA operations API. */ +vm_fault_t netfs_page_mkwrite (struct vm_fault *vmf,struct netfs_group *netfs_group); + +/* (Sub)request management API. */ void netfs_subreq_terminated (struct netfs_io_subrequest *,ssize_t ,bool );void netfs_get_subrequest (struct netfs_io_subrequest *subreq,enum netfs_sreq_ref_trace what);
David Howells
maintainerRFC PATCH 31/53 netfs: Provide netfs_file_read_iter()
In reply to David HowellsProvide a top-level-ish function that can be pointed to directly by ->read_iter file op.
--- fs/netfs/buffered_read.c | 33 +++++++++++++++++++++++++++++++++ include/linux/netfs.h | 1 + 2 files changed, 34 insertions(+)
fs/netfs/buffered_read.c +33 -0
@@ -564,3 +564,36 @@ int netfs_prefetch_for_write(struct file *file, struct folio *folio,_leave (" = %d" , ret);return ret; } + +/** +* netfs_file_read_iter - Generic filesystem read routine +* @iocb: kernel I/O control block +* @iter: destination for the data read +* +* This is the ->read_iter() routine for all filesystems that can use the page +* cache directly. +* +* The IOCB_NOWAIT flag in iocb->ki_flags indicates that -EAGAIN shall be +* returned when no data can be read without waiting for I/O requests to +* complete; it doesn't prevent readahead. +* +* The IOCB_NOIO flag in iocb->ki_flags indicates that no new I/O requests +* shall be made for the read or for readahead. When no data can be read, +* -EAGAIN shall be returned. When readahead would be triggered, a partial, +* possibly empty read shall be returned. +* +* Return: +* * number of bytes copied, even for partial reads +* * negative error code (or 0 if IOCB_NOIO) if nothing was read +*/ +ssize_t netfs_file_read_iter (struct kiocb *iocb,struct iov_iter *iter) +{ +struct netfs_inode *ictx =netfs_inode (iocb->ki_filp->f_mapping->host); + +if ((iocb->ki_flags &IOCB_DIRECT ) || +test_bit (NETFS_ICTX_UNBUFFERED , &ictx->flags)) +return netfs_unbuffered_read_iter (iocb, iter); + +return filemap_read (iocb, iter,0 ); +} +EXPORT_SYMBOL (netfs_file_read_iter);
include/linux/netfs.h +1 -0
@@ -384,6 +384,7 @@ struct netfs_cache_ops {/* High-level read API. */ ssize_t netfs_unbuffered_read_iter (struct kiocb *iocb,struct iov_iter *iter); +ssize_t netfs_file_read_iter (struct kiocb *iocb,struct iov_iter *iter);/* High-level write API */ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,
David Howells
maintainerRFC PATCH 32/53 netfs: Provide a writepages implementation
In reply to David HowellsProvide an implementation of writepages for network filesystems to delegate to.
--- fs/netfs/buffered_write.c | 627 ++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 2 + 2 files changed, 629 insertions(+)
fs/netfs/buffered_write.c +627 -0
@@ -32,6 +32,18 @@ static void netfs_set_group(struct folio *folio, struct netfs_group *netfs_groupfolio_attach_private (folio,netfs_get_group (netfs_group)); } +#if IS_ENABLED (CONFIG_FSCACHE ) +static void netfs_folio_start_fscache (bool caching,struct folio *folio) +{ +if (caching) +folio_start_fscache (folio); +} +#else +static void netfs_folio_start_fscache (bool caching,struct folio *folio) +{ +} +#endif +/* * Decide how we should modify a folio. We might be attempting to do * write-streaming, in which case we don't want to a local RMW cycle if we can
@@ -472,3 +484,618 @@ vm_fault_t netfs_page_mkwrite(struct vm_fault *vmf, struct netfs_group *netfs_grreturn ret; }EXPORT_SYMBOL (netfs_page_mkwrite); + +/* +* Kill all the pages in the given range +*/ +static void netfs_kill_pages (struct address_space *mapping, +loff_t start,loff_t len) +{ +struct folio *folio; +pgoff_t index = start /PAGE_SIZE ; +pgoff_t last = (start + len -1 ) /PAGE_SIZE , next; + +_enter ("%llx-%llx" , start, start + len -1 ); + +do { +_debug ("kill %lx (to %lx)" , index, last); + + folio =filemap_get_folio (mapping, index); +if (IS_ERR (folio)) { + next = index +1 ; +continue ; + } + + next =folio_next_index (folio); + +folio_clear_uptodate (folio); +folio_end_writeback (folio); +folio_lock (folio); +trace_netfs_folio (folio, netfs_folio_trace_kill); +generic_error_remove_page (mapping, &folio->page); +folio_unlock (folio); +folio_put (folio); + + }while (index = next, index <= last); + +_leave ("" ); +} + +/* +* Redirty all the pages in a given range. +*/ +static void netfs_redirty_pages (struct address_space *mapping, +loff_t start,loff_t len) +{ +struct folio *folio; +pgoff_t index = start /PAGE_SIZE ; +pgoff_t last = (start + len -1 ) /PAGE_SIZE , next; + +_enter ("%llx-%llx" , start, start + len -1 ); + +do { +_debug ("redirty %llx @%llx" , len, start); + + folio =filemap_get_folio (mapping, index); +if (IS_ERR (folio)) { + next = index +1 ; +continue ; + } + + next =folio_next_index (folio); +trace_netfs_folio (folio, netfs_folio_trace_redirty); +filemap_dirty_folio (mapping, folio); +folio_end_writeback (folio); +folio_put (folio); + }while (index = next, index <= last); + +balance_dirty_pages_ratelimited (mapping); + +_leave ("" ); +} + +/* +* Completion of write to server +*/ +static void netfs_pages_written_back (struct netfs_io_request *wreq) +{ +struct address_space *mapping = wreq->mapping; +struct netfs_folio *finfo; +struct netfs_group *group =NULL ; +struct folio *folio; +pgoff_t last; +int gcount =0 ; + +XA_STATE (xas, &mapping->i_pages, wreq->start /PAGE_SIZE ); + +_enter ("%llx-%llx" , wreq->start, wreq->start + wreq->len); + +rcu_read_lock (); + + last = (wreq->start + wreq->len -1 ) /PAGE_SIZE ; +xas_for_each (&xas, folio, last) { +WARN (!folio_test_writeback (folio), +"bad %zx @%llx page %lx %lx\n" , + wreq->len, wreq->start,folio_index (folio), last); + +if ((finfo =netfs_folio_info (folio))) { +/* Streaming writes cannot be redirtied whilst under +* writeback, so discard the streaming record. +*/ +folio_detach_private (folio); + group = finfo->netfs_group; + gcount++; +trace_netfs_folio (folio, netfs_folio_trace_clear_s); + }else if ((group =netfs_folio_group (folio))) { +/* Need to detach the group pointer if the page didn't +* get redirtied. If it has been redirtied, then it +* must be within the same group. +*/ +if (folio_test_dirty (folio)) { +trace_netfs_folio (folio, netfs_folio_trace_redirtied); + goto end_wb; + } +if (folio_trylock (folio)) { +if (!folio_test_dirty (folio)) { +folio_detach_private (folio); + gcount++; +trace_netfs_folio (folio, netfs_folio_trace_clear_g); + }else { +trace_netfs_folio (folio, netfs_folio_trace_redirtied); + } +folio_unlock (folio); + goto end_wb; + } + +xas_pause (&xas); +rcu_read_unlock (); +folio_lock (folio); +if (!folio_test_dirty (folio)) { +folio_detach_private (folio); + gcount++; +trace_netfs_folio (folio, netfs_folio_trace_clear_g); + }else { +trace_netfs_folio (folio, netfs_folio_trace_redirtied); + } +folio_unlock (folio); +rcu_read_lock (); + }else { +trace_netfs_folio (folio, netfs_folio_trace_clear); + } + end_wb: +folio_end_writeback (folio); + } + +rcu_read_unlock (); +netfs_put_group_many (group, gcount); +_leave ("" ); +} + +/* +* Deal with the disposition of the folios that are under writeback to close +* out the operation. +*/ +static void netfs_cleanup_buffered_write (struct netfs_io_request *wreq) +{ +struct address_space *mapping = wreq->mapping; + +_enter ("" ); + +switch (wreq->error) { +case 0 : +netfs_pages_written_back (wreq); +break ; + +default : +pr_notice ("R=%08x Unexpected error %d\n" , wreq->debug_id, wreq->error); + fallthrough; +case -EACCES : +case -EPERM : +case -ENOKEY : +case -EKEYEXPIRED : +case -EKEYREJECTED : +case -EKEYREVOKED : +case -ENETRESET : +case -EDQUOT : +case -ENOSPC : +netfs_redirty_pages (mapping, wreq->start, wreq->len); +break ; + +case -EROFS : +case -EIO : +case -EREMOTEIO : +case -EFBIG : +case -ENOENT : +case -ENOMEDIUM : +case -ENXIO : +netfs_kill_pages (mapping, wreq->start, wreq->len); +break ; + } + +if (wreq->error) +mapping_set_error (mapping, wreq->error); +if (wreq->netfs_ops->done) + wreq->netfs_ops->done (wreq); +} + +/* +* Extend the region to be written back to include subsequent contiguously +* dirty pages if possible, but don't sleep while doing so. +* +* If this page holds new content, then we can include filler zeros in the +* writeback. +*/ +static void netfs_extend_writeback (struct address_space *mapping, +struct netfs_group *group, +struct xa_state *xas, +long *_count, +loff_t start, +loff_t max_len, +bool caching, +size_t *_len) +{ +struct netfs_folio *finfo; +struct folio_batch fbatch; +struct folio *folio; +unsigned int i; +pgoff_t index = (start + *_len) /PAGE_SIZE ; +size_t len; +void *priv; +bool stop = true; + +folio_batch_init (&fbatch); + +do { +/* Firstly, we gather up a batch of contiguous dirty pages +* under the RCU read lock - but we can't clear the dirty flags +* there if any of those pages are mapped. +*/ +rcu_read_lock (); + +xas_for_each (xas, folio,ULONG_MAX ) { + stop = true; +if (xas_retry (xas, folio)) +continue ; +if (xa_is_value (folio)) +break ; +if (folio_index (folio) != index) +break ; + + priv =rcu_dereference (*(__force void __rcu **)&folio->private); +if ((const struct netfs_group *)priv != group) { + finfo = (void *)((unsigned long )priv & ~NETFS_FOLIO_INFO ); +if (finfo->netfs_group != group) +break ; +if (finfo->dirty_offset >0 ) +break ; + } + +if (!folio_try_get_rcu (folio)) { +xas_reset (xas); +continue ; + } + +/* Has the folio moved or been split? */ +if (unlikely (folio !=xas_reload (xas))) { +folio_put (folio); +break ; + } + +if (!folio_trylock (folio)) { +folio_put (folio); +break ; + } +if (!folio_test_dirty (folio) || +folio_test_writeback (folio) || +folio_test_fscache (folio)) { +folio_unlock (folio); +folio_put (folio); +break ; + } + + stop = false; + len =folio_size (folio); + priv = folio->private; +if ((const struct netfs_group *)priv != group) { + stop = true; + finfo = (void *)((unsigned long )priv & ~NETFS_FOLIO_INFO ); +if (finfo->netfs_group != group || + finfo->dirty_offset >0 ) { +folio_unlock (folio); +folio_put (folio); +break ; + } + len = finfo->dirty_len; + } + + index +=folio_nr_pages (folio); + *_count -=folio_nr_pages (folio); + *_len += len; +if (*_len >= max_len || *_count <=0 ) + stop = true; + +if (!folio_batch_add (&fbatch, folio)) +break ; +if (stop) +break ; + } + +xas_pause (xas); +rcu_read_unlock (); + +/* Now, if we obtained any folios, we can shift them to being +* writable and mark them for caching. +*/ +if (!folio_batch_count (&fbatch)) +break ; + +for (i =0 ; i <folio_batch_count (&fbatch); i++) { + folio = fbatch.folios[i]; +trace_netfs_folio (folio, netfs_folio_trace_store_plus); + +if (!folio_clear_dirty_for_io (folio)) +BUG (); +if (folio_start_writeback (folio)) +BUG (); +netfs_folio_start_fscache (caching, folio); +folio_unlock (folio); + } + +folio_batch_release (&fbatch); +cond_resched (); + }while (!stop); +} + +/* +* Synchronously write back the locked page and any subsequent non-locked dirty +* pages. +*/ +static ssize_t netfs_write_back_from_locked_folio (struct address_space *mapping, +struct writeback_control *wbc, +struct netfs_group *group, +struct xa_state *xas, +struct folio *folio, +unsigned long long start, +unsigned long long end) +{ +struct netfs_io_request *wreq; +struct netfs_folio *finfo; +struct netfs_inode *ctx =netfs_inode (mapping->host); +unsigned long long i_size =i_size_read (&ctx->inode); +size_t len, max_len; +bool caching =netfs_is_cache_enabled (ctx); +long count = wbc->nr_to_write; +int ret; + +_enter (",%lx,%llx-%llx,%u" ,folio_index (folio), start, end, caching); + + wreq =netfs_alloc_request (mapping,NULL , start,folio_size (folio), +NETFS_WRITEBACK ); +if (IS_ERR (wreq)) +return PTR_ERR (wreq); + +if (!folio_clear_dirty_for_io (folio)) +BUG (); +if (folio_start_writeback (folio)) +BUG (); +netfs_folio_start_fscache (caching, folio); + + count -=folio_nr_pages (folio); + +/* Find all consecutive lockable dirty pages that have contiguous +* written regions, stopping when we find a page that is not +* immediately lockable, is not dirty or is missing, or we reach the +* end of the range. +*/ +trace_netfs_folio (folio, netfs_folio_trace_store); + + len =folio_size (folio); + finfo =netfs_folio_info (folio); +if (finfo) { + start += finfo->dirty_offset; +if (finfo->dirty_offset + finfo->dirty_len != len) { + len = finfo->dirty_len; + goto cant_expand; + } + len = finfo->dirty_len; + } + +if (start < i_size) { +/* Trim the write to the EOF; the extra data is ignored. Also +* put an upper limit on the size of a single storedata op. +*/ + max_len =65536 *4096 ; + max_len = min_t(unsigned long long, max_len, end - start + 1); + max_len = min_t(unsigned long long, max_len, i_size - start); + +if (len < max_len) +netfs_extend_writeback (mapping, group, xas, &count, + start, max_len, caching, &len); + } + +cant_expand: + len = min_t(unsigned long long, len, i_size - start); + +/* We now have a contiguous set of dirty pages, each with writeback +* set; the first page is still locked at this point, but all the rest +* have been unlocked. +*/ +folio_unlock (folio); + wreq->start = start; + wreq->len = len; + +if (start < i_size) { +_debug ("write back %zx @%llx [%llx]" , len, start, i_size); + +/* Speculatively write to the cache. We have to fix this up +* later if the store fails. +*/ + wreq->cleanup = netfs_cleanup_buffered_write; + +iov_iter_xarray (&wreq->iter,ITER_SOURCE , &mapping->i_pages, start, len); +__set_bit (NETFS_RREQ_UPLOAD_TO_SERVER , &wreq->flags); + ret =netfs_begin_write (wreq, true, netfs_write_trace_writeback); +if (ret ==0 || ret == -EIOCBQUEUED ) + wbc->nr_to_write -= len /PAGE_SIZE ; + }else { +_debug ("write discard %zx @%llx [%llx]" , len, start, i_size); + +/* The dirty region was entirely beyond the EOF. */ +fscache_clear_page_bits (mapping, start, len, caching); +netfs_pages_written_back (wreq); + ret =0 ; + } + +netfs_put_request (wreq, false, netfs_rreq_trace_put_return); +_leave (" = 0" ); +return 0 ; +} + +/* +* Write a region of pages back to the server +*/ +static ssize_t netfs_writepages_begin (struct address_space *mapping, +struct writeback_control *wbc, +struct netfs_group *group, +struct xa_state *xas, +unsigned long long *_start, +unsigned long long end) +{ +const struct netfs_folio *finfo; +struct folio *folio; +unsigned long long start = *_start; +ssize_t ret; +void *priv; +int skips =0 ; + +_enter ("%llx,%llx," , start, end); + +search_again: +/* Find the first dirty page in the group. */ +rcu_read_lock (); + +for (;;) { + folio =xas_find_marked (xas, end /PAGE_SIZE ,PAGECACHE_TAG_DIRTY ); +if (xas_retry (xas, folio) ||xa_is_value (folio)) +continue ; +if (!folio) +break ; + +/* Skip any dirty folio that's not in the group of interest. */ + priv =rcu_dereference (*(__force void __rcu **)&folio->private); +if ((const struct netfs_group *)priv != group) { + finfo = (void *)((unsigned long )priv & ~NETFS_FOLIO_INFO ); +if (finfo->netfs_group != group) +continue ; + } + +if (!folio_try_get_rcu (folio)) { +xas_reset (xas); +continue ; + } + +if (unlikely (folio !=xas_reload (xas))) { +folio_put (folio); +xas_reset (xas); +continue ; + } + +xas_pause (xas); +break ; + } +rcu_read_unlock (); +if (!folio) +return 0 ; + + start =folio_pos (folio);/* May regress with THPs */ + +_debug ("wback %lx" ,folio_index (folio)); + +/* At this point we hold neither the i_pages lock nor the page lock: +* the page may be truncated or invalidated (changing page->mapping to +* NULL), or even swizzled back from swapper_space to tmpfs file +* mapping +*/ +lock_again: +if (wbc->sync_mode !=WB_SYNC_NONE ) { + ret =folio_lock_killable (folio); +if (ret <0 ) +return ret; + }else { +if (!folio_trylock (folio)) + goto search_again; + } + +if (folio->mapping != mapping || + !folio_test_dirty (folio)) { + start +=folio_size (folio); +folio_unlock (folio); + goto search_again; + } + +if (folio_test_writeback (folio) || +folio_test_fscache (folio)) { +folio_unlock (folio); +if (wbc->sync_mode !=WB_SYNC_NONE ) { +folio_wait_writeback (folio); +#ifdef CONFIG_NETFS_FSCACHE +folio_wait_fscache (folio); +#endif + goto lock_again; + } + + start +=folio_size (folio); +if (wbc->sync_mode ==WB_SYNC_NONE ) { +if (skips >=5 ||need_resched ()) { + ret =0 ; + goto out; + } + skips++; + } + goto search_again; + } + + ret =netfs_write_back_from_locked_folio (mapping, wbc, group, xas, + folio, start, end); +out: +if (ret >0 ) + *_start = start + ret; +_leave (" = %zd [%llx]" , ret, *_start); +return ret; +} + +/* +* Write a region of pages back to the server +*/ +static int netfs_writepages_region (struct address_space *mapping, +struct writeback_control *wbc, +struct netfs_group *group, +unsigned long long *_start, +unsigned long long end) +{ +ssize_t ret; + +XA_STATE (xas, &mapping->i_pages, *_start /PAGE_SIZE ); + +do { + ret =netfs_writepages_begin (mapping, wbc, group, &xas, + _start, end); +if (ret >0 && wbc->nr_to_write >0 ) +cond_resched (); + }while (ret >0 && wbc->nr_to_write >0 ); + +return ret >0 ?0 : ret; +} + +/* +* write some of the pending data back to the server +*/ +int netfs_writepages (struct address_space *mapping, +struct writeback_control *wbc) +{ +struct netfs_group *group =NULL ; +loff_t start, end; +int ret; + +_enter ("" ); + +/* We have to be careful as we can end up racing with setattr() +* truncating the pagecache since the caller doesn't take a lock here +* to prevent it. +*/ + +if (wbc->range_cyclic && mapping->writeback_index) { + start = mapping->writeback_index *PAGE_SIZE ; + ret =netfs_writepages_region (mapping, wbc, group, + &start,LLONG_MAX ); +if (ret <0 ) + goto out; + +if (wbc->nr_to_write <=0 ) { + mapping->writeback_index = start /PAGE_SIZE ; + goto out; + } + + start =0 ; + end = mapping->writeback_index *PAGE_SIZE ; + mapping->writeback_index =0 ; + ret =netfs_writepages_region (mapping, wbc, group, &start, end); +if (ret ==0 ) + mapping->writeback_index = start /PAGE_SIZE ; + }else if (wbc->range_start ==0 && wbc->range_end ==LLONG_MAX ) { + start =0 ; + ret =netfs_writepages_region (mapping, wbc, group, + &start,LLONG_MAX ); +if (wbc->nr_to_write >0 && ret ==0 ) + mapping->writeback_index = start /PAGE_SIZE ; + }else { + start = wbc->range_start; + ret =netfs_writepages_region (mapping, wbc, group, + &start, wbc->range_end); + } + +out: +_leave (" = %d" , ret); +return ret; +} +EXPORT_SYMBOL (netfs_writepages);
include/linux/netfs.h +2 -0
@@ -401,6 +401,8 @@ int netfs_read_folio(struct file *, struct folio *);int netfs_write_begin (struct netfs_inode *,struct file *,struct address_space *,loff_t pos,unsigned int len,struct folio **,void **fsdata); +int netfs_writepages (struct address_space *mapping, +struct writeback_control *wbc);void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length);bool netfs_release_folio (struct folio *folio,gfp_t gfp);
David Howells
maintainerRFC PATCH 33/53 netfs: Provide minimum blocksize parameter
In reply to David HowellsAdd a parameter for minimum blocksize in the netfs_i_context struct. This can be used, for instance, to force I/O alignment for content encryption. It also requires the use of an RMW cycle if a write we want to do doesn't meet the block alignment requirements.
--- fs/netfs/buffered_read.c | 26 ++++++++++++++++++++++---- fs/netfs/buffered_write.c | 3 ++- fs/netfs/direct_read.c | 3 ++- include/linux/netfs.h | 2 ++ 4 files changed, 28 insertions(+), 6 deletions(-)
fs/netfs/buffered_read.c +22 -4
@@ -527,14 +527,26 @@ int netfs_prefetch_for_write(struct file *file, struct folio *folio,struct address_space *mapping =folio_file_mapping (folio);struct netfs_inode *ctx =netfs_inode (mapping->host);unsigned long long start =folio_pos (folio); -size_t flen =folio_size (folio); +unsigned long long i_size, rstart, end; +size_t rlen;int ret; -_enter ("%zx @%llx" , flen, start); +DEFINE_READAHEAD (ractl, file,NULL , mapping,folio_index (folio)); + +_enter ("%zx @%llx" , len, start); ret = -ENOMEM ; - rreq =netfs_alloc_request (mapping, file, start, flen, + i_size =i_size_read (mapping->host); + end =round_up (start + len,1U << ctx->min_bshift); +if (end > i_size) { +unsigned long long limit =round_up (start + len,PAGE_SIZE ); + end =max (limit,round_up (i_size,PAGE_SIZE )); + } + rstart =round_down (start,1U << ctx->min_bshift); + rlen = end - rstart; + + rreq =netfs_alloc_request (mapping, file, rstart, rlen,NETFS_READ_FOR_WRITE );if (IS_ERR (rreq)) { ret =PTR_ERR (rreq);
@@ -548,7 +560,13 @@ int netfs_prefetch_for_write(struct file *file, struct folio *folio, goto error_put;netfs_stat (&netfs_n_rh_write_begin); -trace_netfs_read (rreq, start, flen, netfs_read_trace_prefetch_for_write); +trace_netfs_read (rreq, rstart, rlen, netfs_read_trace_prefetch_for_write); + +/* Expand the request to meet caching requirements and download +* preferences. +*/ + ractl._nr_pages =folio_nr_pages (folio); +netfs_rreq_expand (rreq, &ractl);/* Set up the output buffer */ iov_iter_xarray(&rreq->iter, ITER_DEST, &mapping->i_pages,
fs/netfs/buffered_write.c +2 -1
@@ -80,7 +80,8 @@ static enum netfs_how_to_modify netfs_how_to_modify(struct netfs_inode *ctx,if (file->f_mode &FMODE_READ )return NETFS_JUST_PREFETCH ; -if (netfs_is_cache_enabled (ctx)) +if (netfs_is_cache_enabled (ctx) || + ctx->min_bshift >0 )return NETFS_JUST_PREFETCH ;if (!finfo)
fs/netfs/direct_read.c +2 -1
@@ -185,7 +185,8 @@ static ssize_t netfs_unbuffered_read_iter_locked(struct kiocb *iocb, struct iov_* will then need to pad the request out to the minimum block size. */ if (test_bit (NETFS_RREQ_USE_BOUNCE_BUFFER , &rreq->flags)) { - start = rreq->start; + min_bsize =1ULL << ctx->min_bshift; + start =round_down (rreq->start, min_bsize); end = min_t(unsigned long long,round_up (rreq->start + rreq->len, min_bsize), ctx->remote_i_size);
include/linux/netfs.h +2 -0
@@ -141,6 +141,7 @@ struct netfs_inode {unsigned long flags;#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ #define NETFS_ICTX_UNBUFFERED 1/* I/O should not use the pagecache */ +unsigned char min_bshift;/* log2 min block size for bounding box or 0 */ };/*
@@ -462,6 +463,7 @@ static inline void netfs_inode_init(struct netfs_inode *ctx, ctx->remote_i_size =i_size_read (&ctx->inode); ctx->zero_point = ctx->remote_i_size; ctx->flags =0 ; + ctx->min_bshift =0 ;#if IS_ENABLED (CONFIG_FSCACHE ) ctx->cache =NULL ;#endif
David Howells
maintainerRFC PATCH 34/53 netfs: Make netfs_skip_folio_read() take account of blocksize
In reply to David HowellsMake netfs_skip_folio_read() take account of blocksize such as crypto blocksize.
--- fs/netfs/buffered_read.c | 32 +++++++++++++++++++++----------- 1 file changed, 21 insertions(+), 11 deletions(-)
fs/netfs/buffered_read.c +21 -11
@@ -337,6 +337,7 @@ EXPORT_SYMBOL(netfs_read_folio);/* * Prepare a folio for writing without reading first +* @ctx: File context * @folio: The folio being prepared * @pos: starting position for the write * @len: length of write
@@ -350,32 +351,41 @@ EXPORT_SYMBOL(netfs_read_folio);* If any of these criteria are met, then zero out the unwritten parts * of the folio and return true. Otherwise, return false. */ -static bool netfs_skip_folio_read (struct folio *folio,loff_t pos,size_t len, -bool always_fill) +static bool netfs_skip_folio_read (struct netfs_inode *ctx,struct folio *folio, +loff_t pos,size_t len,bool always_fill) {struct inode *inode =folio_inode (folio); -loff_t i_size =i_size_read (inode); +loff_t i_size =i_size_read (inode), low, high;size_t offset =offset_in_folio (folio, pos);size_t plen =folio_size (folio); +size_t min_bsize =1UL << ctx->min_bshift; + +if (likely (min_bsize ==1 )) { + low =folio_file_pos (folio); + high = low + plen; + }else { + low =round_down (pos, min_bsize); + high =round_up (pos + len, min_bsize); + }if (unlikely (always_fill)) { -if (pos - offset + len <= i_size) -return false;/* Page entirely before EOF */ +if (low < i_size) +return false;/* Some part of the block before EOF */ zero_user_segment (&folio->page,0 , plen);folio_mark_uptodate (folio);return true; } -/* Full folio write */ -if (offset ==0 && len >= plen) +/* Full page write */ +if (pos == low && high == pos + len)return true; -/* Page entirely beyond the end of the file */ -if (pos - offset >= i_size) +/* pos beyond last page in the file */ +if (low >= i_size) goto zero_out;/* Write that covers from the start of the folio to EOF or beyond */ -if (offset ==0 && (pos + len) >= i_size) +if (pos == low && (pos + len) >= i_size) goto zero_out;return false;
@@ -454,7 +464,7 @@ int netfs_write_begin(struct netfs_inode *ctx,* to preload the granule. */ if (!netfs_is_cache_enabled (ctx) && -netfs_skip_folio_read (folio, pos, len, false)) { +netfs_skip_folio_read (ctx, folio, pos, len, false)) {netfs_stat (&netfs_n_rh_write_zskip); goto have_folio_no_wait; }
David Howells
maintainerRFC PATCH 35/53 netfs: Perform content encryption
In reply to David HowellsWhen dealing with an encrypted file, we gather together sufficient pages from the pagecache to constitute a logical crypto block, allocate a bounce buffer and then ask the filesystem to encrypt between the buffers. The bounce buffer is then passed to the filesystem to upload.
The network filesystem must set a flag to indicate what service is desired and what the logical blocksize will be.
The netfs library iterates through each block to be processed, providing a pair of scatterlists to describe the start and end buffers.
Note that it should be possible in future to encrypt DIO writes also by this same mechanism.
--- fs/netfs/Makefile | 1 + fs/netfs/buffered_write.c | 3 +- fs/netfs/crypto.c | 89 ++++++++++++++++++++++++++++++++++++ fs/netfs/internal.h | 5 ++ fs/netfs/objects.c | 2 + fs/netfs/output.c | 7 ++- include/linux/netfs.h | 11 +++++ include/trace/events/netfs.h | 2 + 8 files changed, 118 insertions(+), 2 deletions(-) create mode 100644 fs/netfs/crypto.c
fs/netfs/Makefile +1 -0
@@ -3,6 +3,7 @@ netfs-y := \ buffered_read.o \ buffered_write.o \ + crypto.o \ direct_read.o \ direct_write.o \ io.o \
fs/netfs/buffered_write.c +2 -1
@@ -77,7 +77,8 @@ static enum netfs_how_to_modify netfs_how_to_modify(struct netfs_inode *ctx,if (!maybe_trouble && offset ==0 && len >= flen)return NETFS_WHOLE_FOLIO_MODIFY ; -if (file->f_mode &FMODE_READ ) +if (file->f_mode &FMODE_READ || +test_bit (NETFS_ICTX_ENCRYPTED , &ctx->flags))return NETFS_JUST_PREFETCH ; if (netfs_is_cache_enabled(ctx) ||
fs/netfs/crypto.c new file +89 -0
89 lines not on this page · raw message
fs/netfs/internal.h +5 -0
@@ -22,6 +22,11 @@ void netfs_rreq_unlock_folios(struct netfs_io_request *rreq);int netfs_prefetch_for_write (struct file *file,struct folio *folio,size_t offset,size_t len); +/* +* crypto.c +*/ +bool netfs_encrypt (struct netfs_io_request *wreq); +/* * direct_write.c */
fs/netfs/objects.c +2 -0
@@ -44,6 +44,8 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,refcount_set (&rreq->ref,1 );__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags); +if (test_bit (NETFS_ICTX_ENCRYPTED , &ctx->flags)) +__set_bit (NETFS_RREQ_CONTENT_ENCRYPTION , &rreq->flags);if (cached)__set_bit (NETFS_RREQ_WRITE_TO_CACHE , &rreq->flags);if (file && file->f_flags &O_NONBLOCK )
fs/netfs/output.c +6 -1
@@ -366,7 +366,11 @@ int netfs_begin_write(struct netfs_io_request *wreq, bool may_wait,* background whilst we generate a list of write ops that we want to * perform. */ -// TODO: Encrypt or compress the region as appropriate +if (test_bit (NETFS_RREQ_CONTENT_ENCRYPTION , &wreq->flags) && + !netfs_encrypt (wreq)) { + may_wait = true; + goto out; + }/* We need to write all of the region to the cache */ if (test_bit (NETFS_RREQ_WRITE_TO_CACHE , &wreq->flags))
@@ -378,6 +382,7 @@ int netfs_begin_write(struct netfs_io_request *wreq, bool may_wait,if (test_bit (NETFS_RREQ_UPLOAD_TO_SERVER , &wreq->flags)) ctx->ops->create_write_requests (wreq, wreq->start, wreq->len); +out:if (atomic_dec_and_test (&wreq->nr_outstanding))netfs_write_terminated (wreq, false);
include/linux/netfs.h +11 -0
@@ -19,6 +19,7 @@#include <linux/pagemap.h> #include <linux/uio.h> +struct scatterlist ;enum netfs_sreq_ref_trace ;/*
@@ -141,7 +142,9 @@ struct netfs_inode {unsigned long flags;#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ #define NETFS_ICTX_UNBUFFERED 1/* I/O should not use the pagecache */ +#define NETFS_ICTX_ENCRYPTED 2/* The file contents are encrypted */ unsigned char min_bshift;/* log2 min block size for bounding box or 0 */ +unsigned char crypto_bshift;/* log2 of crypto block size */ };/*
@@ -285,6 +288,8 @@ struct netfs_io_request {#define NETFS_RREQ_USE_BOUNCE_BUFFER 8/* Use bounce buffer */ #define NETFS_RREQ_WRITE_TO_CACHE 9/* Need to write to the cache */ #define NETFS_RREQ_UPLOAD_TO_SERVER 10/* Need to write to the server */ +#define NETFS_RREQ_CONTENT_ENCRYPTION 11/* Content encryption is in use */ +#define NETFS_RREQ_CRYPT_IN_PLACE 12/* Enc/dec in place in ->io_iter */ const struct netfs_request_ops *netfs_ops;void (*cleanup)(struct netfs_io_request *req); };
@@ -316,6 +321,11 @@ struct netfs_request_ops {void (*create_write_requests)(struct netfs_io_request *wreq,loff_t start,size_t len);void (*invalidate_cache)(struct netfs_io_request *wreq); + +/* Content encryption */ +int (*encrypt_block)(struct netfs_io_request *wreq,loff_t pos,size_t len, +struct scatterlist *source_sg,unsigned int n_source, +struct scatterlist *dest_sg,unsigned int n_dest); };/*
@@ -464,6 +474,7 @@ static inline void netfs_inode_init(struct netfs_inode *ctx, ctx->zero_point = ctx->remote_i_size; ctx->flags =0 ; ctx->min_bshift =0 ; + ctx->crypto_bshift =0 ;#if IS_ENABLED (CONFIG_FSCACHE ) ctx->cache =NULL ;#endif
include/trace/events/netfs.h +2 -0
@@ -41,6 +41,7 @@ EM(netfs_rreq_trace_assess, "ASSESS ") \ EM(netfs_rreq_trace_copy, "COPY ") \ EM(netfs_rreq_trace_done, "DONE ") \ + EM(netfs_rreq_trace_encrypt, "ENCRYPT") \ EM(netfs_rreq_trace_free, "FREE ") \ EM(netfs_rreq_trace_redirty, "REDIRTY") \EM (netfs_rreq_trace_resubmit,"RESUBMT" ) \
@@ -76,6 +77,7 @@ EM(netfs_fail_copy_to_cache, "copy-to-cache") \ EM(netfs_fail_dio_read_short, "dio-read-short") \ EM(netfs_fail_dio_read_zero, "dio-read-zero") \ + EM(netfs_fail_encryption, "encryption") \ EM(netfs_fail_read, "read") \ EM(netfs_fail_short_read, "short-read") \EM (netfs_fail_prepare_write,"prep-write" ) \
David Howells
maintainerRFC PATCH 36/53 netfs: Decrypt encrypted content
In reply to David HowellsImplement a facility to provide decryption for encrypted content to a whole read-request in one go (which might have been stitched together from disparate sources with divisions that don't match page boundaries).
Note that this doesn't necessarily gain the best throughput if the crypto block size is equal to or less than the size of a page (in which case we might be better doing it as pages become read), but it will handle crypto blocks larger than the size of a page.
--- fs/netfs/crypto.c | 59 ++++++++++++++++++++++++++++++++++++ fs/netfs/internal.h | 1 + fs/netfs/io.c | 6 +++- include/linux/netfs.h | 3 ++ include/trace/events/netfs.h | 2 ++ 5 files changed, 70 insertions(+), 1 deletion(-)
fs/netfs/crypto.c +59 -0
@@ -87,3 +87,62 @@ bool netfs_encrypt(struct netfs_io_request *wreq) wreq->error = ret;return false; } + +/* +* Decrypt the result of a read request. +*/ +void netfs_decrypt (struct netfs_io_request *rreq) +{ +struct netfs_inode *ctx =netfs_inode (rreq->inode); +struct scatterlist source_sg[16 ], dest_sg[16 ]; +unsigned int n_source; +size_t n, chunk, bsize =1UL << ctx->crypto_bshift; +loff_t pos; +int ret; + +trace_netfs_rreq (rreq, netfs_rreq_trace_decrypt); +if (rreq->start >= rreq->i_size) +return ; + + n = min_t(unsigned long long, rreq->len, rreq->i_size - rreq->start); + +_debug ("DECRYPT %llx-%llx f=%lx" , + rreq->start, rreq->start + n, rreq->flags); + + pos = rreq->start; +for (; n >0 ; n -= chunk, pos += chunk) { + chunk =min (n, bsize); + + ret =netfs_iter_to_sglist (&rreq->io_iter, chunk, + source_sg,ARRAY_SIZE (source_sg)); +if (ret <0 ) + goto error; + n_source = ret; + +if (test_bit (NETFS_RREQ_CRYPT_IN_PLACE , &rreq->flags)) { + ret = ctx->ops->decrypt_block (rreq, pos, chunk, + source_sg, n_source, + source_sg, n_source); + }else { + ret =netfs_iter_to_sglist (&rreq->iter, chunk, + dest_sg,ARRAY_SIZE (dest_sg)); +if (ret <0 ) + goto error; + ret = ctx->ops->decrypt_block (rreq, pos, chunk, + source_sg, n_source, + dest_sg, ret); + } + +if (ret <0 ) + goto error_failed; + } + +return ; + +error_failed: +trace_netfs_failure (rreq,NULL , ret, netfs_fail_decryption); +error: + rreq->error = ret; +set_bit (NETFS_RREQ_FAILED , &rreq->flags); +return ; +}
fs/netfs/internal.h +1 -0
@@ -26,6 +26,7 @@ int netfs_prefetch_for_write(struct file *file, struct folio *folio,* crypto.c */ bool netfs_encrypt (struct netfs_io_request *wreq); +void netfs_decrypt (struct netfs_io_request *rreq);/* * direct_write.c
fs/netfs/io.c +5 -1
@@ -398,6 +398,9 @@ static void netfs_rreq_assess(struct netfs_io_request *rreq, bool was_async)return ; } +if (!test_bit (NETFS_RREQ_FAILED , &rreq->flags) && +test_bit (NETFS_RREQ_CONTENT_ENCRYPTION , &rreq->flags)) +netfs_decrypt (rreq);if (rreq->origin !=NETFS_DIO_READ )netfs_rreq_unlock_folios (rreq);else
@@ -427,7 +430,8 @@ static void netfs_rreq_work(struct work_struct *work)static void netfs_rreq_terminated (struct netfs_io_request *rreq,bool was_async) { -if (test_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags) && +if ((test_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags) || +test_bit (NETFS_RREQ_CONTENT_ENCRYPTION , &rreq->flags)) && was_async) {if (!queue_work (system_unbound_wq, &rreq->work))BUG ();
include/linux/netfs.h +3 -0
@@ -326,6 +326,9 @@ struct netfs_request_ops {int (*encrypt_block)(struct netfs_io_request *wreq,loff_t pos,size_t len,struct scatterlist *source_sg,unsigned int n_source,struct scatterlist *dest_sg,unsigned int n_dest); +int (*decrypt_block)(struct netfs_io_request *rreq,loff_t pos,size_t len, +struct scatterlist *source_sg,unsigned int n_source, +struct scatterlist *dest_sg,unsigned int n_dest); };/*
include/trace/events/netfs.h +2 -0
@@ -40,6 +40,7 @@#define netfs_rreq_traces \ EM(netfs_rreq_trace_assess, "ASSESS ") \ EM(netfs_rreq_trace_copy, "COPY ") \ + EM(netfs_rreq_trace_decrypt, "DECRYPT") \ EM(netfs_rreq_trace_done, "DONE ") \ EM(netfs_rreq_trace_encrypt, "ENCRYPT") \ EM(netfs_rreq_trace_free, "FREE ") \
@@ -75,6 +76,7 @@#define netfs_failures \ EM(netfs_fail_check_write_begin, "check-write-begin") \ EM(netfs_fail_copy_to_cache, "copy-to-cache") \ + EM(netfs_fail_decryption, "decryption") \ EM(netfs_fail_dio_read_short, "dio-read-short") \ EM(netfs_fail_dio_read_zero, "dio-read-zero") \ EM(netfs_fail_encryption, "encryption") \
David Howells
maintainerRFC PATCH 37/53 netfs: Support decryption on ubuffered/DIO read
In reply to David HowellsSupport unbuffered and direct I/O reads from an encrypted file. This may require making a larger read than is required into a bounce buffer and copying out the required bits. We don't decrypt in-place in the user buffer lest userspace interfere and muck up the decryption.
--- fs/netfs/direct_read.c | 10 ++++++++++ fs/netfs/internal.h | 17 +++++++++++++++++ 2 files changed, 27 insertions(+)
fs/netfs/direct_read.c +10 -0
@@ -181,6 +181,16 @@ static ssize_t netfs_unbuffered_read_iter_locked(struct kiocb *iocb, struct iov_iov_iter_advance (iter, orig_count); } +/* If we're going to do decryption or decompression, we're going to +* need a bounce buffer - and if the data is misaligned for the crypto +* algorithm, we decrypt in place and then copy. +*/ +if (test_bit (NETFS_RREQ_CONTENT_ENCRYPTION , &rreq->flags)) { +if (!netfs_is_crypto_aligned (rreq, iter)) +__set_bit (NETFS_RREQ_CRYPT_IN_PLACE , &rreq->flags); +__set_bit (NETFS_RREQ_USE_BOUNCE_BUFFER , &rreq->flags); + } +/* If we're going to use a bounce buffer, we need to set it up. We * will then need to pad the request out to the minimum block size. */
fs/netfs/internal.h +17 -0
@@ -196,6 +196,23 @@ static inline void netfs_put_group_many(struct netfs_group *netfs_group, int nr) netfs_group->free (netfs_group); } +/* +* Check to see if a buffer aligns with the crypto unit block size. If it +* doesn't the crypto layer is going to copy all the data - in which case +* relying on the crypto op for a free copy is pointless. +*/ +static inline bool netfs_is_crypto_aligned (struct netfs_io_request *rreq, +struct iov_iter *iter) +{ +struct netfs_inode *ctx =netfs_inode (rreq->inode); +unsigned long align, mask = (1UL << ctx->min_bshift) -1 ; + +if (!ctx->min_bshift) +return true; + align =iov_iter_alignment (iter); +return (align & mask) ==0 ; +} +/*****************************************************************************/ /* * debug tracing
David Howells
maintainerRFC PATCH 38/53 netfs: Support encryption on Unbuffered/DIO write
In reply to David HowellsSupport unbuffered and direct I/O writes to an encrypted file. This may require making an RMW cycle if the write is not appropriately aligned with respect to the crypto blocks.
--- fs/netfs/direct_read.c | 2 +- fs/netfs/direct_write.c | 210 ++++++++++++++++++++++++++++++++++- fs/netfs/internal.h | 8 ++ fs/netfs/io.c | 117 +++++++++++++++++++ fs/netfs/main.c | 1 + include/linux/netfs.h | 4 + include/trace/events/netfs.h | 1 + 7 files changed, 337 insertions(+), 6 deletions(-)
fs/netfs/direct_read.c +1 -1
@@ -88,7 +88,7 @@ static int netfs_copy_xarray_to_iter(struct netfs_io_request *rreq,* If we did a direct read to a bounce buffer (say we needed to decrypt it), * copy the data obtained to the destination iterator. */ -static int netfs_dio_copy_bounce_to_dest (struct netfs_io_request *rreq) +int netfs_dio_copy_bounce_to_dest (struct netfs_io_request *rreq) {struct iov_iter *dest_iter = &rreq->iter;struct kiocb *iocb = rreq->iocb;
fs/netfs/direct_write.c +205 -5
254 lines not on this page · raw message
fs/netfs/internal.h +8 -0
@@ -28,6 +28,11 @@ int netfs_prefetch_for_write(struct file *file, struct folio *folio,bool netfs_encrypt (struct netfs_io_request *wreq);void netfs_decrypt (struct netfs_io_request *rreq); +/* +* direct_read.c +*/ +int netfs_dio_copy_bounce_to_dest (struct netfs_io_request *rreq); +/* * direct_write.c */
@@ -38,6 +43,9 @@ ssize_t netfs_unbuffered_write_iter_locked(struct kiocb *iocb, struct iov_iter ** io.c */ int netfs_begin_read (struct netfs_io_request *rreq,bool sync); +ssize_t netfs_rmw_read (struct netfs_io_request *wreq,struct file *file, +unsigned long long start1,size_t len1, +unsigned long long start2,size_t len2);/* * main.c
fs/netfs/io.c +117 -0
120 lines not on this page · raw message
fs/netfs/main.c +1 -0
@@ -33,6 +33,7 @@ static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READPAGE] = "RP", [NETFS_READ_FOR_WRITE] = "RW", [NETFS_WRITEBACK] = "WB", + [NETFS_RMW_READ] = "RM", [NETFS_UNBUFFERED_WRITE] = "UW", [NETFS_DIO_READ] = "DR", [NETFS_DIO_WRITE] = "DW",
include/linux/netfs.h +4 -0
@@ -145,6 +145,7 @@ struct netfs_inode {#define NETFS_ICTX_ENCRYPTED 2/* The file contents are encrypted */ unsigned char min_bshift;/* log2 min block size for bounding box or 0 */ unsigned char crypto_bshift;/* log2 of crypto block size */ +unsigned char crypto_trailer;/* Size of crypto trailer */ };/*
@@ -233,6 +234,7 @@ enum netfs_io_origin {NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ +NETFS_RMW_READ ,/* This is an unbuffered read for RMW */ NETFS_UNBUFFERED_WRITE ,/* This is an unbuffered write */ NETFS_DIO_READ ,/* This is a direct I/O read */ NETFS_DIO_WRITE, /* This is a direct I/O write */
@@ -290,6 +292,7 @@ struct netfs_io_request {#define NETFS_RREQ_UPLOAD_TO_SERVER 10/* Need to write to the server */ #define NETFS_RREQ_CONTENT_ENCRYPTION 11/* Content encryption is in use */ #define NETFS_RREQ_CRYPT_IN_PLACE 12/* Enc/dec in place in ->io_iter */ +#define NETFS_RREQ_REPEAT_RMW 13/* Need to repeat RMW cycle */ const struct netfs_request_ops *netfs_ops;void (*cleanup)(struct netfs_io_request *req); };
@@ -478,6 +481,7 @@ static inline void netfs_inode_init(struct netfs_inode *ctx, ctx->flags =0 ; ctx->min_bshift =0 ; ctx->crypto_bshift =0 ; + ctx->crypto_trailer =0 ;#if IS_ENABLED (CONFIG_FSCACHE ) ctx->cache =NULL ;#endif
include/trace/events/netfs.h +1 -0
@@ -33,6 +33,7 @@ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ EM(NETFS_WRITEBACK, "WB") \ + EM(NETFS_RMW_READ, "RM") \ EM(NETFS_UNBUFFERED_WRITE, "UW") \ EM(NETFS_DIO_READ, "DR") \E_ (NETFS_DIO_WRITE ,"DW" )
David Howells
maintainerRFC PATCH 39/53 netfs: Provide a launder_folio implementation
In reply to David HowellsProvide a launder_folio implementation for netfslib.
--- fs/netfs/buffered_write.c | 71 ++++++++++++++++++++++++++++++++++++ fs/netfs/main.c | 1 + include/linux/netfs.h | 2 + include/trace/events/netfs.h | 3 ++ 4 files changed, 77 insertions(+)
fs/netfs/buffered_write.c +71 -0
@@ -1101,3 +1101,74 @@ int netfs_writepages(struct address_space *mapping,return ret; }EXPORT_SYMBOL (netfs_writepages); + +/* +* Deal with the disposition of a laundered folio. +*/ +static void netfs_cleanup_launder_folio (struct netfs_io_request *wreq) +{ +if (wreq->error) { +pr_notice ("R=%08x Laundering error %d\n" , wreq->debug_id, wreq->error); +mapping_set_error (wreq->mapping, wreq->error); + } +} + +/** +* netfs_launder_folio - Clean up a dirty folio that's being invalidated +* @folio: The folio to clean +* +* This is called to write back a folio that's being invalidated when an inode +* is getting torn down. Ideally, writepages would be used instead. +*/ +int netfs_launder_folio (struct folio *folio) +{ +struct netfs_io_request *wreq; +struct address_space *mapping = folio->mapping; +struct netfs_folio *finfo; +struct bio_vec bvec; +unsigned long long i_size =i_size_read (mapping->host); +unsigned long long start =folio_pos (folio); +size_t offset =0 , len; +int ret =0 ; + + finfo =netfs_folio_info (folio); +if (finfo) { + offset = finfo->dirty_offset; + start += offset; + len = finfo->dirty_len; + }else { + len =folio_size (folio); + } + len = min_t(unsigned long long, len, i_size - start); + + wreq =netfs_alloc_request (mapping,NULL , start, len,NETFS_LAUNDER_WRITE ); +if (IS_ERR (wreq)) { + ret =PTR_ERR (wreq); + goto out; + } + +if (!folio_clear_dirty_for_io (folio)) + goto out_put; + +trace_netfs_folio (folio, netfs_folio_trace_launder); + +_debug ("launder %llx-%llx" , start, start + len -1 ); + +/* Speculatively write to the cache. We have to fix this up later if +* the store fails. +*/ + wreq->cleanup = netfs_cleanup_launder_folio; + +bvec_set_folio (&bvec, folio, len, offset); +iov_iter_bvec (&wreq->iter,ITER_SOURCE , &bvec,1 , len); +__set_bit (NETFS_RREQ_UPLOAD_TO_SERVER , &wreq->flags); + ret =netfs_begin_write (wreq, true, netfs_write_trace_launder); + +out_put: +netfs_put_request (wreq, false, netfs_rreq_trace_put_return); +out: +folio_wait_fscache (folio); +_leave (" = %d" , ret); +return ret; +} +EXPORT_SYMBOL (netfs_launder_folio);
fs/netfs/main.c +1 -0
@@ -33,6 +33,7 @@ static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READPAGE] = "RP", [NETFS_READ_FOR_WRITE] = "RW", [NETFS_WRITEBACK] = "WB", + [NETFS_LAUNDER_WRITE] = "LW", [NETFS_RMW_READ] = "RM", [NETFS_UNBUFFERED_WRITE] = "UW", [NETFS_DIO_READ] = "DR",
include/linux/netfs.h +2 -0
@@ -234,6 +234,7 @@ enum netfs_io_origin {NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ +NETFS_LAUNDER_WRITE ,/* This is triggered by ->launder_folio() */ NETFS_RMW_READ ,/* This is an unbuffered read for RMW */ NETFS_UNBUFFERED_WRITE ,/* This is an unbuffered write */ NETFS_DIO_READ, /* This is a direct I/O read */
@@ -422,6 +423,7 @@ int netfs_writepages(struct address_space *mapping, struct writeback_control *wbc);void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length);bool netfs_release_folio (struct folio *folio,gfp_t gfp); +int netfs_launder_folio (struct folio *folio);/* VMA operations API. */ vm_fault_t netfs_page_mkwrite (struct vm_fault *vmf,struct netfs_group *netfs_group);
include/trace/events/netfs.h +3 -0
@@ -25,6 +25,7 @@#define netfs_write_traces \ EM(netfs_write_trace_dio_write, "DIO-WRITE") \ + EM(netfs_write_trace_launder, "LAUNDER ") \ EM(netfs_write_trace_unbuffered_write, "UNB-WRITE") \ E_(netfs_write_trace_writeback, "WRITEBACK")
@@ -33,6 +34,7 @@ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ EM(NETFS_WRITEBACK, "WB") \ + EM(NETFS_LAUNDER_WRITE, "LW") \ EM(NETFS_RMW_READ, "RM") \ EM(NETFS_UNBUFFERED_WRITE, "UW") \EM (NETFS_DIO_READ ,"DR" ) \
@@ -129,6 +131,7 @@ EM(netfs_folio_trace_clear_g, "clear-g") \ EM(netfs_folio_trace_filled_gaps, "filled-gaps") \ EM(netfs_folio_trace_kill, "kill") \ + EM(netfs_folio_trace_launder, "launder") \ EM(netfs_folio_trace_mkwrite, "mkwrite") \ EM(netfs_folio_trace_mkwrite_plus, "mkwrite+") \EM (netfs_folio_trace_read_gaps,"read-gaps" ) \
David Howells
maintainerRFC PATCH 40/53 netfs: Implement a write-through caching option
In reply to David HowellsProvide a flag whereby a filesystem may request that cifs_perform_write() perform write-through caching. This involves putting pages directly into writeback rather than dirty and attaching them to a write operation as we go.
Further, the writes being made are limited to the byte range being written rather than whole folios being written. This can be used by cifs, for example, to deal with strict byte-range locking.
This can't be used with content encryption as that may require expansion of the write RPC beyond the write being made.
This doesn't affect writes via mmap - those are written back in the normal way; similarly failed writethrough writes are marked dirty and left to writeback to retry. Another option would be to simply invalidate them, but the contents can be simultaneously accessed by read() and through mmap.
--- fs/netfs/buffered_write.c | 66 ++++++++++++++++++++++---- fs/netfs/internal.h | 3 ++ fs/netfs/main.c | 1 + fs/netfs/objects.c | 1 + fs/netfs/output.c | 90 ++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 2 + include/trace/events/netfs.h | 8 +++- 7 files changed, 159 insertions(+), 12 deletions(-)
fs/netfs/buffered_write.c +56 -10
@@ -26,6 +26,8 @@ enum netfs_how_to_modify { NETFS_FLUSH_CONTENT, /* Flush incompatible content. */ }; +static void netfs_cleanup_buffered_write (struct netfs_io_request *wreq); +static void netfs_set_group (struct folio *folio,struct netfs_group *netfs_group) {if (netfs_group && !folio_get_private (folio))
@@ -135,6 +137,14 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,struct inode *inode =file_inode (file);struct address_space *mapping = inode->i_mapping;struct netfs_inode *ctx =netfs_inode (inode); +struct writeback_control wbc = { + .sync_mode =WB_SYNC_NONE , + .for_sync = true, + .nr_to_write =LONG_MAX , + .range_start = iocb->ki_pos, + .range_end = iocb->ki_pos + iter->count, + }; +struct netfs_io_request *wreq =NULL ;struct netfs_folio *finfo;struct folio *folio;enum netfs_how_to_modify howto;
@@ -145,6 +155,30 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,size_t max_chunk =PAGE_SIZE <<MAX_PAGECACHE_ORDER ;bool maybe_trouble = false; +if (unlikely (test_bit (NETFS_ICTX_WRITETHROUGH , &ctx->flags) || + iocb->ki_flags & (IOCB_DSYNC |IOCB_SYNC )) + ) { +if (pos <i_size_read (inode)) { + ret =filemap_write_and_wait_range (mapping, pos, pos + iter->count); +if (ret <0 ) { + goto out; + } + } + +wbc_attach_fdatawrite_inode (&wbc, mapping->host); + + wreq =netfs_begin_writethrough (iocb, iter->count); +if (IS_ERR (wreq)) { +wbc_detach_inode (&wbc); + ret =PTR_ERR (wreq); + wreq =NULL ; + goto out; + } +if (!is_sync_kiocb (iocb)) + wreq->iocb = iocb; + wreq->cleanup = netfs_cleanup_buffered_write; + } + do { size_t flen; size_t offset; /* Offset into pagecache folio */
@@ -314,7 +348,22 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, } written += copied; -folio_mark_dirty (folio); +if (likely (!wreq)) { +folio_mark_dirty (folio); + }else { +if (folio_test_dirty (folio)) +/* Sigh. mmap. */ +folio_clear_dirty_for_io (folio); +/* We make multiple writes to the folio... */ +if (!folio_start_writeback (folio)) { +if (wreq->iter.count ==0 ) +trace_netfs_folio (folio, netfs_folio_trace_wthru); +else +trace_netfs_folio (folio, netfs_folio_trace_wthru_plus); + } +netfs_advance_writethrough (wreq, copied, + offset + copied == flen); + } retry:folio_unlock (folio);folio_put (folio);
@@ -324,17 +373,14 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, }while (iov_iter_count (iter)); out: -if (likely (written)) { -/* Flush and wait for a write that requires immediate synchronisation. */ -if (iocb->ki_flags & (IOCB_DSYNC |IOCB_SYNC )) { -_debug ("dsync" ); - ret =filemap_fdatawait_range (mapping, iocb->ki_pos, - iocb->ki_pos + written); - } - - iocb->ki_pos += written; +if (unlikely (wreq)) { + ret =netfs_end_writethrough (wreq, iocb); +wbc_detach_inode (&wbc); +if (ret == -EIOCBQUEUED ) +return ret; } + iocb->ki_pos += written;_leave (" = %zd [%zd]" , written, ret);return written ? written : ret;
fs/netfs/internal.h +3 -0
@@ -114,6 +114,9 @@ static inline void netfs_see_request(struct netfs_io_request *rreq,*/ int netfs_begin_write (struct netfs_io_request *wreq,bool may_wait,enum netfs_write_trace what); +struct netfs_io_request *netfs_begin_writethrough (struct kiocb *iocb,size_t len); +int netfs_advance_writethrough (struct netfs_io_request *wreq,size_t copied,bool to_page_end); +int netfs_end_writethrough (struct netfs_io_request *wreq,struct kiocb *iocb);/* * stats.c
fs/netfs/main.c +1 -0
@@ -33,6 +33,7 @@ static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READPAGE] = "RP", [NETFS_READ_FOR_WRITE] = "RW", [NETFS_WRITEBACK] = "WB", + [NETFS_WRITETHROUGH] = "WT", [NETFS_LAUNDER_WRITE] = "LW", [NETFS_RMW_READ] = "RM", [NETFS_UNBUFFERED_WRITE] = "UW",
fs/netfs/objects.c +1 -0
@@ -41,6 +41,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, rreq->debug_id =atomic_inc_return (&debug_ids);xa_init (&rreq->bounce);INIT_LIST_HEAD (&rreq->subrequests); +INIT_WORK (&rreq->work,NULL );refcount_set (&rreq->ref,1 );__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags);
fs/netfs/output.c +90 -0
93 lines not on this page · raw message
include/linux/netfs.h +2 -0
@@ -143,6 +143,7 @@ struct netfs_inode {#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ #define NETFS_ICTX_UNBUFFERED 1/* I/O should not use the pagecache */ #define NETFS_ICTX_ENCRYPTED 2/* The file contents are encrypted */ +#define NETFS_ICTX_WRITETHROUGH 3/* Write-through caching */ unsigned char min_bshift;/* log2 min block size for bounding box or 0 */ unsigned char crypto_bshift;/* log2 of crypto block size */ unsigned char crypto_trailer;/* Size of crypto trailer */
@@ -234,6 +235,7 @@ enum netfs_io_origin {NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ +NETFS_WRITETHROUGH ,/* This write was made by netfs_perform_write() */ NETFS_LAUNDER_WRITE ,/* This is triggered by ->launder_folio() */ NETFS_RMW_READ ,/* This is an unbuffered read for RMW */ NETFS_UNBUFFERED_WRITE, /* This is an unbuffered write */
include/trace/events/netfs.h +6 -2
@@ -27,13 +27,15 @@ EM(netfs_write_trace_dio_write, "DIO-WRITE") \ EM(netfs_write_trace_launder, "LAUNDER ") \ EM(netfs_write_trace_unbuffered_write, "UNB-WRITE") \ - E_(netfs_write_trace_writeback, "WRITEBACK") + EM(netfs_write_trace_writeback, "WRITEBACK") \ + E_(netfs_write_trace_writethrough, "WRITETHRU")#define netfs_rreq_origins \ EM(NETFS_READAHEAD, "RA") \ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ EM(NETFS_WRITEBACK, "WB") \ + EM(NETFS_WRITETHROUGH, "WT") \ EM(NETFS_LAUNDER_WRITE, "LW") \ EM(NETFS_RMW_READ, "RM") \ EM(NETFS_UNBUFFERED_WRITE, "UW") \
@@ -138,7 +140,9 @@ EM(netfs_folio_trace_redirty, "redirty") \ EM(netfs_folio_trace_redirtied, "redirtied") \ EM(netfs_folio_trace_store, "store") \ - E_(netfs_folio_trace_store_plus, "store+") + EM(netfs_folio_trace_store_plus, "store+") \ + EM(netfs_folio_trace_wthru, "wthru") \ + E_(netfs_folio_trace_wthru_plus, "wthru+")#ifndef __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY#define __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
David Howells
maintainerRFC PATCH 41/53 netfs: Rearrange netfs_io_subrequest to put request pointer first
In reply to David HowellsRearrange the netfs_io_subrequest struct to put the netfs_io_request pointer (rreq) first. This then allows netfs_io_subrequest to be put in a union with a pointer to a wrapper around netfs_io_request for cifs.
--- include/linux/netfs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
include/linux/netfs.h +1 -1
@@ -209,8 +209,8 @@ struct netfs_cache_resources {* the pages it points to can be relied on to exist for the duration. */ struct netfs_io_subrequest { -struct work_struct work;struct netfs_io_request *rreq;/* Supervising I/O request */ +struct work_struct work;struct list_head rreq_link;/* Link in rreq->subrequests */ struct iov_iter io_iter;/* Iterator for this subrequest */ loff_t start;/* Where to start the I/O */
David Howells
maintainerRFC PATCH 42/53 afs: Use the netfs write helpers
In reply to David HowellsMake afs use the netfs write helpers.
--- fs/afs/file.c | 65 +++- fs/afs/internal.h | 10 +- fs/afs/write.c | 704 ++----------------------------------- include/trace/events/afs.h | 23 -- 4 files changed, 81 insertions(+), 721 deletions(-)
fs/afs/file.c +51 -14
@@ -34,7 +34,7 @@ const struct file_operations afs_file_operations = { .release = afs_release, .llseek = generic_file_llseek, .read_iter = afs_file_read_iter, - .write_iter = afs_file_write, + .write_iter = netfs_file_write_iter, .mmap = afs_file_mmap, .splice_read = afs_file_splice_read, .splice_write = iter_file_splice_write,
@@ -50,16 +50,15 @@ const struct inode_operations afs_file_inode_operations = { };const struct address_space_operations afs_file_aops = { + .direct_IO = noop_direct_IO, .read_folio = netfs_read_folio, .readahead = netfs_readahead, .dirty_folio = afs_dirty_folio, - .launder_folio = afs_launder_folio, + .launder_folio = netfs_launder_folio, .release_folio = netfs_release_folio, .invalidate_folio = netfs_invalidate_folio, - .write_begin = afs_write_begin, - .write_end = afs_write_end, - .writepages = afs_writepages, .migrate_folio = filemap_migrate_folio, + .writepages = afs_writepages, };const struct address_space_operations afs_symlink_aops = {
@@ -355,8 +354,10 @@ static int afs_symlink_read_folio(struct file *file, struct folio *folio)static int afs_init_request (struct netfs_io_request *rreq,struct file *file) { - rreq->netfs_priv =key_get (afs_file_key (file)); +if (file) + rreq->netfs_priv =key_get (afs_file_key (file)); rreq->rsize =4 *1024 *1024 ; + rreq->wsize =16 *1024 ;return 0 ; }
@@ -373,12 +374,37 @@ static void afs_free_request(struct netfs_io_request *rreq)key_put (rreq->netfs_priv); } +static void afs_update_i_size (struct inode *inode,loff_t new_i_size) +{ +struct afs_vnode *vnode =AFS_FS_I (inode); +loff_t i_size; + +write_seqlock (&vnode->cb_lock); + i_size =i_size_read (&vnode->netfs.inode); +if (new_i_size > i_size) { +i_size_write (&vnode->netfs.inode, new_i_size); +inode_set_bytes (&vnode->netfs.inode, new_i_size); + } +write_sequnlock (&vnode->cb_lock); +fscache_update_cookie (afs_vnode_cache (vnode),NULL , &new_i_size); +} + +static void afs_netfs_invalidate_cache (struct netfs_io_request *wreq) +{ +struct afs_vnode *vnode =AFS_FS_I (wreq->inode); + +afs_invalidate_cache (vnode,0 ); +} +const struct netfs_request_ops afs_req_ops = { .init_request = afs_init_request, .free_request = afs_free_request, .begin_cache_operation = fscache_begin_cache_operation, .check_write_begin = afs_check_write_begin, .issue_read = afs_issue_read, + .update_i_size = afs_update_i_size, + .invalidate_cache = afs_netfs_invalidate_cache, + .create_write_requests = afs_create_write_requests, };int afs_write_inode (struct inode *inode,struct writeback_control *wbc)
@@ -453,28 +479,39 @@ static vm_fault_t afs_vm_map_pages(struct vm_fault *vmf, pgoff_t start_pgoff, pgstatic ssize_t afs_file_read_iter (struct kiocb *iocb,struct iov_iter *iter) { -struct afs_vnode *vnode =AFS_FS_I (file_inode (iocb->ki_filp)); +struct inode *inode =file_inode (iocb->ki_filp); +struct afs_vnode *vnode =AFS_FS_I (inode);struct afs_file *af = iocb->ki_filp->private_data;int ret; - ret =afs_validate (vnode, af->key); +if (iocb->ki_flags &IOCB_DIRECT ) +return netfs_unbuffered_read_iter (iocb, iter); + + ret =netfs_start_io_read (inode);if (ret <0 )return ret; - -return generic_file_read_iter (iocb, iter); + ret =afs_validate (vnode, af->key); +if (ret ==0 ) + ret =netfs_file_read_iter (iocb, iter); +netfs_end_io_read (inode); +return ret; }static ssize_t afs_file_splice_read (struct file *in,loff_t *ppos,struct pipe_inode_info *pipe,size_t len,unsigned int flags) { -struct afs_vnode *vnode =AFS_FS_I (file_inode (in)); +struct inode *inode =file_inode (in); +struct afs_vnode *vnode =AFS_FS_I (inode);struct afs_file *af = in->private_data;int ret; - ret =afs_validate (vnode, af->key); + ret =netfs_start_io_read (inode);if (ret <0 )return ret; - -return filemap_splice_read (in, ppos, pipe, len, flags); + ret =afs_validate (vnode, af->key); +if (ret ==0 ) + ret =filemap_splice_read (in, ppos, pipe, len, flags); +netfs_end_io_read (inode); +return ret; }
fs/afs/internal.h +1 -9
@@ -1468,19 +1468,11 @@ bool afs_dirty_folio(struct address_space *, struct folio *);#else #define afs_dirty_folio filemap_dirty_folio#endif -extern int afs_write_begin (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len, -struct page **pagep,void **fsdata); -extern int afs_write_end (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata); -extern int afs_writepage (struct page *,struct writeback_control *);extern int afs_writepages (struct address_space *,struct writeback_control *); -extern ssize_t afs_file_write (struct kiocb *,struct iov_iter *);extern int afs_fsync (struct file *,loff_t ,loff_t ,int );extern vm_fault_t afs_page_mkwrite (struct vm_fault *vmf);extern void afs_prune_wb_keys (struct afs_vnode *); -int afs_launder_folio (struct folio *); +void afs_create_write_requests (struct netfs_io_request *wreq,loff_t start,size_t len);/* * xattr.c
fs/afs/write.c +29 -675
778 lines not on this page · raw message
include/trace/events/afs.h +0 -23
@@ -837,29 +837,6 @@ TRACE_EVENT(afs_dir_check_failed, __entry->vnode, __entry->off, __entry->i_size) ); -TRACE_EVENT (afs_folio_dirty, - TP_PROTO(struct afs_vnode *vnode, const char *where, struct folio *folio), - -TP_ARGS (vnode, where, folio), - -TP_STRUCT__entry ( - __field(struct afs_vnode *, vnode) - __field(const char *, where) - __field(pgoff_t, index) -__field (size_t, size) - ), - -TP_fast_assign ( - __entry->vnode = vnode; - __entry->where = where; - __entry->index = folio_index(folio); - __entry->size = folio_size(folio); - ), - -TP_printk ("vn=%p ix=%05lx s=%05lx %s" , - __entry->vnode, __entry->index, __entry->size, __entry->where) - ); - TRACE_EVENT(afs_call_state, TP_PROTO(struct afs_call *call, enum afs_call_state from,
David Howells
maintainerRFC PATCH 43/53 cifs: Replace cifs_readdata with a wrapper around netfs_io_subrequest
In reply to David HowellsNetfslib has a facility whereby the allocation for netfs_io_subrequest can be increased to so that filesystem-specific data can be tagged on the end.
Prepare to use this by making a struct, cifs_io_subrequest, that wraps netfs_io_subrequest, and absorb struct cifs_readdata into it.
--- fs/smb/client/cifsglob.h | 22 ++++++++++-------- fs/smb/client/cifsproto.h | 9 ++++++-- fs/smb/client/cifssmb.c | 11 ++++----- fs/smb/client/file.c | 48 ++++++++++++++++++--------------------- fs/smb/client/smb2ops.c | 2 +- fs/smb/client/smb2pdu.c | 13 ++++++----- fs/smb/client/smb2proto.h | 2 +- fs/smb/client/transport.c | 4 ++-- 8 files changed, 56 insertions(+), 55 deletions(-)
fs/smb/client/cifsglob.h +12 -10
@@ -237,7 +237,7 @@ struct dfs_info3_param;struct cifs_fattr ;struct smb3_fs_context ;struct cifs_fid ; -struct cifs_readdata ; +struct cifs_io_subrequest ;struct cifs_writedata ;struct cifs_io_parms ;struct cifs_search_info ;
@@ -411,7 +411,7 @@ struct smb_version_operations {/* send a flush request to the server */ int (*flush)(const unsigned int ,struct cifs_tcon *,struct cifs_fid *);/* async read from the server */ -int (*async_readv)(struct cifs_readdata *); +int (*async_readv)(struct cifs_io_subrequest *);/* async write to the server */ int (*async_writev)(struct cifs_writedata *,void (*release)(struct kref *));
@@ -1423,26 +1423,28 @@ struct cifs_aio_ctx { };/* asynchronous read support */ -struct cifs_readdata { -struct kref refcount; -struct list_head list; -struct completion done; +struct cifs_io_subrequest { +struct netfs_io_subrequest subreq;struct cifsFileInfo *cfile;struct address_space *mapping;struct cifs_aio_ctx *ctx; -__u64 offset;ssize_t got_bytes; -unsigned int bytes;pid_t pid;int result; -struct work_struct work; -struct iov_iter iter;struct kvec iov[2 ];struct TCP_Server_Info *server;#ifdef CONFIG_CIFS_SMB_DIRECT struct smbd_mr *mr;#endif struct cifs_credits credits; + +// TODO: Remove following elements +struct list_head list; +struct completion done; +struct work_struct work; +struct iov_iter iter; +__u64 offset; +unsigned int bytes; };/* asynchronous write support */
fs/smb/client/cifsproto.h +7 -2
@@ -580,8 +580,13 @@ void __cifs_put_smb_ses(struct cifs_ses *ses);extern struct cifs_ses *cifs_get_smb_ses (struct TCP_Server_Info *server,struct smb3_fs_context *ctx); -void cifs_readdata_release (struct kref *refcount); -int cifs_async_readv (struct cifs_readdata *rdata); +void cifs_readdata_release (struct cifs_io_subrequest *rdata); +static inline void cifs_put_readdata (struct cifs_io_subrequest *rdata) +{ +if (refcount_dec_and_test (&rdata->subreq.ref)) +cifs_readdata_release (rdata); +} +int cifs_async_readv (struct cifs_io_subrequest *rdata);int cifs_readv_receive (struct TCP_Server_Info *server,struct mid_q_entry *mid); int cifs_async_writev(struct cifs_writedata *wdata,
fs/smb/client/cifssmb.c +4 -7
@@ -24,6 +24,8 @@#include <linux/swap.h> #include <linux/task_io_accounting_ops.h> #include <linux/uaccess.h> +#include <linux/netfs.h> +#include <trace/events/netfs.h> #include "cifspdu.h" #include "cifsfs.h" #include "cifsglob.h"
@@ -1260,12 +1262,11 @@ CIFS_open(const unsigned int xid, struct cifs_open_parms *oparms, int *oplock,static void cifs_readv_callback (struct mid_q_entry *mid) { -struct cifs_readdata *rdata = mid->callback_data; +struct cifs_io_subrequest *rdata = mid->callback_data;struct cifs_tcon *tcon =tlink_tcon (rdata->cfile->tlink);struct TCP_Server_Info *server = tcon->ses->server;struct smb_rqst rqst = { .rq_iov = rdata->iov, .rq_nvec =2 , - .rq_iter_size =iov_iter_count (&rdata->iter), .rq_iter = rdata->iter };struct cifs_credits credits = { .value =1 , .instance =0 };
@@ -1310,7 +1311,7 @@ cifs_readv_callback(struct mid_q_entry *mid)/* cifs_async_readv - send an async write, and set up mid to handle result */ int -cifs_async_readv (struct cifs_readdata *rdata) +cifs_async_readv (struct cifs_io_subrequest *rdata) {int rc;READ_REQ *smb =NULL ;
@@ -1362,15 +1363,11 @@ cifs_async_readv(struct cifs_readdata *rdata) rdata->iov[1 ].iov_base = (char *)smb +4 ; rdata->iov[1 ].iov_len =get_rfc1002_length (smb); -kref_get (&rdata->refcount); rc =cifs_call_async (tcon->ses->server, &rqst, cifs_readv_receive, cifs_readv_callback,NULL , rdata,0 ,NULL );if (rc ==0 )cifs_stats_inc (&tcon->stats.cifs_stats.num_reads); -else -kref_put (&rdata->refcount, cifs_readdata_release); -cifs_small_buf_release (smb);return rc; }
fs/smb/client/file.c +22 -26
152 lines not on this page · raw message
fs/smb/client/smb2ops.c +1 -1
@@ -4584,7 +4584,7 @@ handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,unsigned int cur_off;unsigned int cur_page_idx;unsigned int pad_len; -struct cifs_readdata *rdata = mid->callback_data; +struct cifs_io_subrequest *rdata = mid->callback_data;struct smb2_hdr *shdr = (struct smb2_hdr *)buf;int length;bool use_rdma_mr = false;
fs/smb/client/smb2pdu.c +7 -6
@@ -23,6 +23,8 @@#include <linux/uuid.h> #include <linux/pagemap.h> #include <linux/xattr.h> +#include <linux/netfs.h> +#include <trace/events/netfs.h> #include "cifsglob.h" #include "cifsacl.h" #include "cifsproto.h"
@@ -4070,7 +4072,7 @@ static inline bool smb3_use_rdma_offload(struct cifs_io_parms *io_parms)*/ static int smb2_new_read_req (void **buf,unsigned int *total_len, -struct cifs_io_parms *io_parms,struct cifs_readdata *rdata, +struct cifs_io_parms *io_parms,struct cifs_io_subrequest *rdata,unsigned int remaining_bytes,int request_type) {int rc = -EACCES ;
@@ -4162,13 +4164,14 @@ smb2_new_read_req(void **buf, unsigned int *total_len,static void smb2_readv_callback (struct mid_q_entry *mid) { -struct cifs_readdata *rdata = mid->callback_data; +struct cifs_io_subrequest *rdata = mid->callback_data;struct cifs_tcon *tcon =tlink_tcon (rdata->cfile->tlink);struct TCP_Server_Info *server = rdata->server;struct smb2_hdr *shdr = (struct smb2_hdr *)rdata->iov[0 ].iov_base;struct cifs_credits credits = { .value =0 , .instance =0 }; -struct smb_rqst rqst = { .rq_iov = &rdata->iov[1 ], .rq_nvec =1 }; +struct smb_rqst rqst = { .rq_iov = &rdata->iov[1 ], + .rq_nvec =1 };if (rdata->got_bytes) { rqst.rq_iter = rdata->iter;
@@ -4249,7 +4252,7 @@ smb2_readv_callback(struct mid_q_entry *mid)/* smb2_async_readv - send an async read, and set up mid to handle result */ int -smb2_async_readv (struct cifs_readdata *rdata) +smb2_async_readv (struct cifs_io_subrequest *rdata) {int rc, flags =0 ;char *buf;
@@ -4307,13 +4310,11 @@ smb2_async_readv(struct cifs_readdata *rdata) flags |=CIFS_HAS_CREDITS ; } -kref_get (&rdata->refcount); rc =cifs_call_async (server, &rqst, cifs_readv_receive, smb2_readv_callback, smb3_handle_read_data, rdata, flags, &rdata->credits);if (rc) { -kref_put (&rdata->refcount, cifs_readdata_release);cifs_stats_fail_inc (io_parms.tcon,SMB2_READ_HE ); trace_smb3_read_err(0 /* xid */, io_parms.persistent_fid, io_parms.tcon->tid,
fs/smb/client/smb2proto.h +1 -1
@@ -186,7 +186,7 @@ extern int SMB2_query_acl(const unsigned int xid, struct cifs_tcon *tcon,extern int SMB2_get_srv_num (const unsigned int xid,struct cifs_tcon *tcon,u64 persistent_fid,u64 volatile_fid,__le64 *uniqueid); -extern int smb2_async_readv (struct cifs_readdata *rdata); +extern int smb2_async_readv (struct cifs_io_subrequest *rdata);extern int SMB2_read (const unsigned int xid,struct cifs_io_parms *io_parms,unsigned int *nbytes,char **buf,int *buf_type); extern int smb2_async_writev(struct cifs_writedata *wdata,
fs/smb/client/transport.c +2 -2
@@ -1686,7 +1686,7 @@ __cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid,static int cifs_readv_discard (struct TCP_Server_Info *server,struct mid_q_entry *mid) { -struct cifs_readdata *rdata = mid->callback_data; +struct cifs_io_subrequest *rdata = mid->callback_data;return __cifs_readv_discard (server, mid, rdata->result); }
@@ -1696,7 +1696,7 @@ cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid) {int length, len;unsigned int data_offset, data_len; -struct cifs_readdata *rdata = mid->callback_data; +struct cifs_io_subrequest *rdata = mid->callback_data;char *buf = server->smallbuf;unsigned int buflen = server->pdu_size +HEADER_PREAMBLE_SIZE (server);bool use_rdma_mr = false;
David Howells
maintainerRFC PATCH 44/53 cifs: Share server EOF pos with netfslib
In reply to David HowellsUse cifsi->netfs_ctx.remote_i_size instead of cifsi->server_eof so that netfslib can refer to it to.
--- fs/smb/client/cifsfs.c | 2 +- fs/smb/client/cifsglob.h | 1 - fs/smb/client/file.c | 8 ++++---- fs/smb/client/inode.c | 6 +++--- fs/smb/client/smb2ops.c | 10 +++++----- 5 files changed, 13 insertions(+), 14 deletions(-)
fs/smb/client/cifsfs.c +1 -1
@@ -395,7 +395,7 @@ cifs_alloc_inode(struct super_block *sb)spin_lock_init (&cifs_inode->writers_lock); cifs_inode->writers =0 ; cifs_inode->netfs.inode.i_blkbits =14 ;/* 2**14 = CIFS_MAX_MSGSIZE */ - cifs_inode->server_eof =0 ; + cifs_inode->netfs.remote_i_size =0 ; cifs_inode->uniqueid =0 ; cifs_inode->createtime =0 ; cifs_inode->epoch =0 ;
fs/smb/client/cifsglob.h +0 -1
@@ -1527,7 +1527,6 @@ struct cifsInodeInfo {spinlock_t writers_lock;unsigned int writers;/* Number of writers on this inode */ unsigned long time;/* jiffies of last update of inode */ -u64 server_eof;/* current file size on server -- protected by i_lock */ u64 uniqueid;/* server inode number */ u64 createtime;/* creation time on server */ __u8 lease_key[SMB2_LEASE_KEY_SIZE ];/* lease key for this inode */
fs/smb/client/file.c +4 -4
@@ -2117,8 +2117,8 @@ cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset, {loff_t end_of_write = offset + bytes_written; -if (end_of_write > cifsi->server_eof) - cifsi->server_eof = end_of_write; +if (end_of_write > cifsi->netfs.remote_i_size) +netfs_resize_file (&cifsi->netfs, end_of_write); } static ssize_t
@@ -3246,8 +3246,8 @@ cifs_uncached_writev_complete(struct work_struct *work)spin_lock (&inode->i_lock);cifs_update_eof (cifsi, wdata->offset, wdata->bytes); -if (cifsi->server_eof > inode->i_size) -i_size_write (inode, cifsi->server_eof); +if (cifsi->netfs.remote_i_size > inode->i_size) +i_size_write (inode, cifsi->netfs.remote_i_size);spin_unlock (&inode->i_lock);complete (&wdata->done);
fs/smb/client/inode.c +3 -3
@@ -102,7 +102,7 @@ cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)/* revalidate if mtime or size have changed */ fattr->cf_mtime =timestamp_truncate (fattr->cf_mtime, inode);if (timespec64_equal (&inode->i_mtime, &fattr->cf_mtime) && - cifs_i->server_eof == fattr->cf_eof) { + cifs_i->netfs.remote_i_size == fattr->cf_eof) {cifs_dbg (FYI ,"%s: inode %llu is unchanged\n" , __func__, cifs_i->uniqueid);return ;
@@ -191,7 +191,7 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)else clear_bit (CIFS_INO_DELETE_PENDING , &cifs_i->flags); - cifs_i->server_eof = fattr->cf_eof; + cifs_i->netfs.remote_i_size = fattr->cf_eof;/* * Can't safely change the file size here if the client is writing to * it due to potential races.
@@ -2776,7 +2776,7 @@ cifs_set_file_size(struct inode *inode, struct iattr *attrs, set_size_out:if (rc ==0 ) { - cifsInode->server_eof = attrs->ia_size; +netfs_resize_file (&cifsInode->netfs, attrs->ia_size);cifs_setsize (inode, attrs->ia_size);/* * i_blocks is not related to (i_size / i_blksize), but instead
fs/smb/client/smb2ops.c +5 -5
@@ -3554,7 +3554,7 @@ static long smb3_simple_falloc(struct file *file, struct cifs_tcon *tcon, rc =SMB2_set_eof (xid, tcon, cfile->fid.persistent_fid, cfile->fid.volatile_fid, cfile->pid, &eof);if (rc ==0 ) { - cifsi->server_eof = off + len; +netfs_resize_file (&cifsi->netfs, off + len);cifs_setsize (inode, off + len);cifs_truncate_page (inode->i_mapping, inode->i_size);truncate_setsize (inode, off + len);
@@ -3646,8 +3646,8 @@ static long smb3_collapse_range(struct file *file, struct cifs_tcon *tcon,int rc;unsigned int xid;struct inode *inode =file_inode (file); -struct cifsFileInfo *cfile = file->private_data;struct cifsInodeInfo *cifsi =CIFS_I (inode); +struct cifsFileInfo *cfile = file->private_data;__le64 eof;loff_t old_eof;
@@ -3682,9 +3682,9 @@ static long smb3_collapse_range(struct file *file, struct cifs_tcon *tcon, rc =0 ; - cifsi->server_eof =i_size_read (inode) - len; -truncate_setsize (inode, cifsi->server_eof); -fscache_resize_cookie (cifs_inode_cookie (inode), cifsi->server_eof); +netfs_resize_file (&cifsi->netfs, eof); +truncate_setsize (inode, eof); +fscache_resize_cookie (cifs_inode_cookie (inode), eof); out_2:filemap_invalidate_unlock (inode->i_mapping); out:
David Howells
maintainerRFC PATCH 45/53 cifs: Replace cifs_writedata with a wrapper around netfs_io_subrequest
In reply to David HowellsReplace the cifs_writedata struct with the same wrapper around netfs_io_subrequest that was used to replace cifs_readdata.
--- fs/smb/client/cifsglob.h | 30 +++------------ fs/smb/client/cifsproto.h | 16 ++++++-- fs/smb/client/cifssmb.c | 9 ++--- fs/smb/client/file.c | 79 ++++++++++++++++----------------------- fs/smb/client/smb2pdu.c | 9 ++--- fs/smb/client/smb2proto.h | 3 +- 6 files changed, 58 insertions(+), 88 deletions(-)
fs/smb/client/cifsglob.h +5 -25
@@ -238,7 +238,6 @@ struct cifs_fattr;struct smb3_fs_context ;struct cifs_fid ;struct cifs_io_subrequest ; -struct cifs_writedata ;struct cifs_io_parms ;struct cifs_search_info ;struct cifsInodeInfo ;
@@ -413,8 +412,7 @@ struct smb_version_operations {/* async read from the server */ int (*async_readv)(struct cifs_io_subrequest *);/* async write to the server */ -int (*async_writev)(struct cifs_writedata *, -void (*release)(struct kref *)); +int (*async_writev)(struct cifs_io_subrequest *);/* sync read from the server */ int (*sync_read)(const unsigned int, struct cifs_fid *, struct cifs_io_parms *, unsigned int *, char **,
@@ -1438,35 +1436,17 @@ struct cifs_io_subrequest {#endif struct cifs_credits credits; -// TODO: Remove following elements -struct list_head list; -struct completion done; -struct work_struct work; -struct iov_iter iter; -__u64 offset; -unsigned int bytes; -}; +enum writeback_sync_modes sync_mode; +bool uncached; +struct bio_vec *bv; -/* asynchronous write support */ -struct cifs_writedata { -struct kref refcount; +// TODO: Remove following elements struct list_head list;struct completion done; -enum writeback_sync_modes sync_mode;struct work_struct work; -struct cifsFileInfo *cfile; -struct cifs_aio_ctx *ctx;struct iov_iter iter; -struct bio_vec *bv;__u64 offset; -pid_t pid;unsigned int bytes; -int result; -struct TCP_Server_Info *server; -#ifdef CONFIG_CIFS_SMB_DIRECT -struct smbd_mr *mr; -#endif -struct cifs_credits credits; };/*
fs/smb/client/cifsproto.h +12 -4
@@ -589,11 +589,19 @@ static inline void cifs_put_readdata(struct cifs_io_subrequest *rdata)int cifs_async_readv (struct cifs_io_subrequest *rdata);int cifs_readv_receive (struct TCP_Server_Info *server,struct mid_q_entry *mid); -int cifs_async_writev (struct cifs_writedata *wdata, -void (*release)(struct kref *kref)); +int cifs_async_writev (struct cifs_io_subrequest *wdata);void cifs_writev_complete (struct work_struct *work); -struct cifs_writedata *cifs_writedata_alloc (work_func_t complete); -void cifs_writedata_release (struct kref *refcount); +struct cifs_io_subrequest *cifs_writedata_alloc (work_func_t complete); +void cifs_writedata_release (struct cifs_io_subrequest *rdata); +static inline void cifs_get_writedata (struct cifs_io_subrequest *wdata) +{ +refcount_inc (&wdata->subreq.ref); +} +static inline void cifs_put_writedata (struct cifs_io_subrequest *wdata) +{ +if (refcount_dec_and_test (&wdata->subreq.ref)) +cifs_writedata_release (wdata); +} int cifs_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon, struct cifs_sb_info *cifs_sb, const unsigned char *path, char *pbuf,
fs/smb/client/cifssmb.c +4 -5
@@ -1610,7 +1610,7 @@ CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,static void cifs_writev_callback (struct mid_q_entry *mid) { -struct cifs_writedata *wdata = mid->callback_data; +struct cifs_io_subrequest *wdata = mid->callback_data;struct cifs_tcon *tcon =tlink_tcon (wdata->cfile->tlink);unsigned int written;WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
@@ -1655,8 +1655,7 @@ cifs_writev_callback(struct mid_q_entry *mid)/* cifs_async_writev - send an async write, and set up mid to handle result */ int -cifs_async_writev (struct cifs_writedata *wdata, -void (*release)(struct kref *kref)) +cifs_async_writev (struct cifs_io_subrequest *wdata) {int rc = -EACCES ;WRITE_REQ *smb =NULL ;
@@ -1723,14 +1722,14 @@ cifs_async_writev(struct cifs_writedata *wdata, iov[1 ].iov_len +=4 ;/* pad bigger by four bytes */ } -kref_get (&wdata->refcount); +cifs_get_writedata (wdata); rc =cifs_call_async (tcon->ses->server, &rqst,NULL , cifs_writev_callback,NULL , wdata,0 ,NULL );if (rc ==0 )cifs_stats_inc (&tcon->stats.cifs_stats.num_writes);else -kref_put (&wdata->refcount, release); +cifs_put_writedata (wdata); async_writev_out:cifs_small_buf_release (smb);
fs/smb/client/file.c +32 -47
226 lines not on this page · raw message
fs/smb/client/smb2pdu.c +4 -5
@@ -4415,7 +4415,7 @@ SMB2_read(const unsigned int xid, struct cifs_io_parms *io_parms,static void smb2_writev_callback (struct mid_q_entry *mid) { -struct cifs_writedata *wdata = mid->callback_data; +struct cifs_io_subrequest *wdata = mid->callback_data;struct cifs_tcon *tcon =tlink_tcon (wdata->cfile->tlink);struct TCP_Server_Info *server = wdata->server;unsigned int written;
@@ -4496,8 +4496,7 @@ smb2_writev_callback(struct mid_q_entry *mid)/* smb2_async_writev - send an async write, and set up mid to handle result */ int -smb2_async_writev (struct cifs_writedata *wdata, -void (*release)(struct kref *kref)) +smb2_async_writev (struct cifs_io_subrequest *wdata) {int rc = -EACCES , flags =0 ;struct smb2_write_req *req =NULL ;
@@ -4629,7 +4628,7 @@ smb2_async_writev(struct cifs_writedata *wdata, flags |=CIFS_HAS_CREDITS ; } -kref_get (&wdata->refcount); +cifs_get_writedata (wdata); rc =cifs_call_async (server, &rqst,NULL , smb2_writev_callback,NULL , wdata, flags, &wdata->credits);
@@ -4641,7 +4640,7 @@ smb2_async_writev(struct cifs_writedata *wdata, io_parms->offset, io_parms->length, rc); -kref_put (&wdata->refcount, release); +cifs_put_writedata (wdata);cifs_stats_fail_inc (tcon,SMB2_WRITE_HE ); }
fs/smb/client/smb2proto.h +1 -2
@@ -189,8 +189,7 @@ extern int SMB2_get_srv_num(const unsigned int xid, struct cifs_tcon *tcon,extern int smb2_async_readv (struct cifs_io_subrequest *rdata);extern int SMB2_read (const unsigned int xid,struct cifs_io_parms *io_parms,unsigned int *nbytes,char **buf,int *buf_type); -extern int smb2_async_writev (struct cifs_writedata *wdata, -void (*release)(struct kref *kref)); +extern int smb2_async_writev (struct cifs_io_subrequest *wdata);extern int SMB2_write (const unsigned int xid,struct cifs_io_parms *io_parms,unsigned int *nbytes,struct kvec *iov,int n_vec);extern int SMB2_echo (struct TCP_Server_Info *server);
David Howells
maintainerRFC PATCH 46/53 cifs: Use more fields from netfs_io_subrequest
In reply to David HowellsUse more fields from netfs_io_subrequest instead of those incorporated into cifs_io_subrequest from cifs_readdata and cifs_writedata.
--- fs/smb/client/cifsglob.h | 3 - fs/smb/client/cifssmb.c | 52 +++++++++--------- fs/smb/client/file.c | 112 +++++++++++++++++++------------------- fs/smb/client/smb2ops.c | 4 +- fs/smb/client/smb2pdu.c | 52 +++++++++--------- fs/smb/client/transport.c | 6 +- 6 files changed, 113 insertions(+), 116 deletions(-)
fs/smb/client/cifsglob.h +0 -3
@@ -1444,9 +1444,6 @@ struct cifs_io_subrequest {struct list_head list;struct completion done;struct work_struct work; -struct iov_iter iter; -__u64 offset; -unsigned int bytes; };/*
fs/smb/client/cifssmb.c +26 -26
117 lines not on this page · raw message
fs/smb/client/file.c +56 -56
284 lines not on this page · raw message
fs/smb/client/smb2ops.c +2 -2
@@ -4686,7 +4686,7 @@ handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,/* Copy the data to the output I/O iterator. */ rdata->result =cifs_copy_pages_to_iter (pages, pages_len, - cur_off, &rdata->iter); + cur_off, &rdata->subreq.io_iter);if (rdata->result !=0 ) {if (is_offloaded) mid->mid_state =MID_RESPONSE_MALFORMED ;
@@ -4700,7 +4700,7 @@ handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,/* read response payload is in buf */ WARN_ONCE (pages && !xa_empty (pages),"read data can be either in buf or in pages" ); - length =copy_to_iter (buf + data_offset, data_len, &rdata->iter); + length =copy_to_iter (buf + data_offset, data_len, &rdata->subreq.io_iter);if (length <0 )return length; rdata->got_bytes = data_len;
fs/smb/client/smb2pdu.c +26 -26
153 lines not on this page · raw message
fs/smb/client/transport.c +3 -3
@@ -1701,8 +1701,8 @@ cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)unsigned int buflen = server->pdu_size +HEADER_PREAMBLE_SIZE (server);bool use_rdma_mr = false; -cifs_dbg (FYI ,"%s: mid=%llu offset=%llu bytes=%u\n" , - __func__, mid->mid, rdata->offset, rdata->bytes); +cifs_dbg (FYI ,"%s: mid=%llu offset=%llu bytes=%zu\n" , + __func__, mid->mid, rdata->subreq.start, rdata->subreq.len);/* * read the rest of READ_RSP header (sans Data array), or whatever we
@@ -1807,7 +1807,7 @@ cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid) length = data_len;/* An RDMA read is already done. */ else#endif - length =cifs_read_iter_from_socket (server, &rdata->iter, + length =cifs_read_iter_from_socket (server, &rdata->subreq.io_iter, data_len);if (length >0 ) rdata->got_bytes += length;
David Howells
maintainerRFC PATCH 47/53 cifs: Make wait_mtu_credits take size_t args
In reply to David HowellsMake the wait_mtu_credits functions use size_t for the size and num arguments rather than unsigned int as netfslib uses size_t/ssize_t for arguments and return values to allow for extra capacity.
--- fs/smb/client/cifsglob.h | 4 ++-- fs/smb/client/cifsproto.h | 2 +- fs/smb/client/file.c | 18 ++++++++++-------- fs/smb/client/smb2ops.c | 4 ++-- fs/smb/client/transport.c | 4 ++-- 5 files changed, 17 insertions(+), 15 deletions(-)
fs/smb/client/cifsglob.h +2 -2
@@ -507,8 +507,8 @@ struct smb_version_operations {/* writepages retry size */ unsigned int (*wp_retry_size)(struct inode *);/* get mtu credits */ -int (*wait_mtu_credits)(struct TCP_Server_Info *,unsigned int , -unsigned int *,struct cifs_credits *); +int (*wait_mtu_credits)(struct TCP_Server_Info *,size_t , +size_t *,struct cifs_credits *);/* adjust previously taken mtu credits to request size */ int (*adjust_credits)(struct TCP_Server_Info *server, struct cifs_credits *credits,
fs/smb/client/cifsproto.h +1 -1
@@ -121,7 +121,7 @@ extern struct mid_q_entry *cifs_setup_async_request(struct TCP_Server_Info *,extern int cifs_check_receive (struct mid_q_entry *mid,struct TCP_Server_Info *server,bool log_error);extern int cifs_wait_mtu_credits (struct TCP_Server_Info *server, -unsigned int size,unsigned int *num, +size_t size,size_t *num,struct cifs_credits *credits); extern int SendReceive2(const unsigned int /* xid */ , struct cifs_ses *, struct kvec *, int /* nvec to send */,
fs/smb/client/file.c +10 -8
@@ -2733,9 +2733,9 @@ static ssize_t cifs_write_back_from_locked_folio(struct address_space *mapping,struct cifs_credits credits_on_stack;struct cifs_credits *credits = &credits_on_stack;struct cifsFileInfo *cfile =NULL ; -unsigned int xid, wsize, len; +unsigned int xid, len;loff_t i_size =i_size_read (inode); -size_t max_len; +size_t max_len, wsize;long count = wbc->nr_to_write;int rc;
@@ -3248,7 +3248,7 @@ static int cifs_resend_wdata(struct cifs_io_subrequest *wdata, struct list_head *wdata_list, struct cifs_aio_ctx *ctx) { - unsigned int wsize; + size_t wsize;struct cifs_credits credits;int rc;struct TCP_Server_Info *server = wdata->server;
@@ -3382,7 +3382,8 @@ cifs_write_from_iter(loff_t fpos, size_t len, struct iov_iter *from, do { struct cifs_credits credits_on_stack; struct cifs_credits *credits = &credits_on_stack; - unsigned int wsize, nsegs = 0; + unsigned int nsegs = 0; + size_t wsize; if (signal_pending(current)) { rc = -EINTR;
@@ -3819,7 +3820,7 @@ static int cifs_resend_rdata(struct cifs_io_subrequest *rdata,struct list_head *rdata_list, struct cifs_aio_ctx *ctx) { - unsigned int rsize; + size_t rsize;struct cifs_credits credits;int rc;struct TCP_Server_Info *server;
@@ -3893,10 +3894,10 @@ cifs_send_async_read(loff_t fpos, size_t len, struct cifsFileInfo *open_file, struct cifs_aio_ctx *ctx) {struct cifs_io_subrequest *rdata; -unsigned int rsize, nsegs, max_segs =INT_MAX ; +unsigned int nsegs, max_segs =INT_MAX ;struct cifs_credits credits_on_stack;struct cifs_credits *credits = &credits_on_stack; -size_t cur_len, max_len; +size_t cur_len, max_len, rsize;int rc;pid_t pid;struct TCP_Server_Info *server;
@@ -4492,12 +4493,13 @@ static void cifs_readahead(struct readahead_control *ractl)* Chop the readahead request up into rsize-sized read requests. */ while ((nr_pages = ra_pages)) { -unsigned int i, rsize; +unsigned int i;struct cifs_io_subrequest *rdata;struct cifs_credits credits_on_stack;struct cifs_credits *credits = &credits_on_stack;struct folio *folio;pgoff_t fsize; +size_t rsize;/* * Find out if we have anything cached in the range of
fs/smb/client/smb2ops.c +2 -2
@@ -216,8 +216,8 @@ smb2_get_credits(struct mid_q_entry *mid) }static int -smb2_wait_mtu_credits (struct TCP_Server_Info *server,unsigned int size, -unsigned int *num,struct cifs_credits *credits) +smb2_wait_mtu_credits (struct TCP_Server_Info *server,size_t size, +size_t *num,struct cifs_credits *credits) {int rc =0 ;unsigned int scredits, in_flight;
fs/smb/client/transport.c +2 -2
@@ -693,8 +693,8 @@ wait_for_compound_request(struct TCP_Server_Info *server, int num, }int -cifs_wait_mtu_credits (struct TCP_Server_Info *server,unsigned int size, -unsigned int *num,struct cifs_credits *credits) +cifs_wait_mtu_credits (struct TCP_Server_Info *server,size_t size, +size_t *num,struct cifs_credits *credits) { *num = size; credits->value =0 ;
David Howells
maintainerRFC PATCH 48/53 cifs: Implement netfslib hooks
In reply to David HowellsProvide implementation of the netfslib hooks that will be used by netfslib to ask cifs to set up and perform operations. Of particular note are
(*) cifs_clamp_length() - This is used to negotiate the size of the next
subrequest in a read request, taking into account the credit available and the rsize. The credits are attached to the subrequest.
(*) cifs_req_issue_read() - This is used to issue a subrequest that has
been set up and clamped.
(*) cifs_create_write_requests() - This is used to break the given span of
file positions into suboperations according to cifs's wsize and available credits. As each subop is created, it can be dispatched or queued for dispatch.
At this point, cifs is not wired up to actually *use* netfslib; that will be done in a subsequent patch.
--- fs/netfs/buffered_write.c | 3 + fs/smb/client/Kconfig | 1 + fs/smb/client/cifsglob.h | 26 ++- fs/smb/client/file.c | 373 +++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 1 + include/trace/events/netfs.h | 1 + 6 files changed, 397 insertions(+), 8 deletions(-)
fs/netfs/buffered_write.c +3 -0
@@ -373,6 +373,9 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, }while (iov_iter_count (iter)); out: +if (likely (written) && ctx->ops->post_modify) + ctx->ops->post_modify (inode); +if (unlikely (wreq)) { ret =netfs_end_writethrough (wreq, iocb);wbc_detach_inode (&wbc);
fs/smb/client/Kconfig +1 -0
@@ -2,6 +2,7 @@ config CIFS tristate "SMB3 and CIFS support (advanced network filesystem)" depends on INET + select NETFS_SUPPORT select NLS select NLS_UCS2_UTILS select CRYPTO
fs/smb/client/cifsglob.h +18 -8
@@ -1420,15 +1420,23 @@ struct cifs_aio_ctx {bool direct_io; }; +struct cifs_io_request { +struct netfs_io_request rreq; +struct cifsFileInfo *cfile; +}; +/* asynchronous read support */ struct cifs_io_subrequest { -struct netfs_io_subrequest subreq; -struct cifsFileInfo *cfile; -struct address_space *mapping; -struct cifs_aio_ctx *ctx; +union { +struct netfs_io_subrequest subreq; +struct netfs_io_request *rreq; +struct cifs_io_request *req; + };ssize_t got_bytes;pid_t pid; +unsigned int xid;int result; +bool have_credits;struct kvec iov[2 ];struct TCP_Server_Info *server;#ifdef CONFIG_CIFS_SMB_DIRECT
@@ -1436,14 +1444,16 @@ struct cifs_io_subrequest {#endif struct cifs_credits credits; -enum writeback_sync_modes sync_mode; -bool uncached; -struct bio_vec *bv; -// TODO: Remove following elements struct list_head list;struct completion done;struct work_struct work; +struct cifsFileInfo *cfile; +struct address_space *mapping; +struct cifs_aio_ctx *ctx; +enum writeback_sync_modes sync_mode; +bool uncached; +struct bio_vec *bv; };/*
fs/smb/client/file.c +373 -0
379 lines not on this page · raw message
include/linux/netfs.h +1 -0
@@ -322,6 +322,7 @@ struct netfs_request_ops {/* Modification handling */ void (*update_i_size)(struct inode *inode,loff_t i_size); +void (*post_modify)(struct inode *inode);/* Write request handling */ void (*create_write_requests)(struct netfs_io_request *wreq,
include/trace/events/netfs.h +1 -0
@@ -106,6 +106,7 @@#define netfs_sreq_ref_traces \ EM(netfs_sreq_trace_get_copy_to_cache, "GET COPY2C ") \ EM(netfs_sreq_trace_get_resubmit, "GET RESUBMIT") \ + EM(netfs_sreq_trace_get_submit, "GET SUBMIT") \ EM(netfs_sreq_trace_get_short_read, "GET SHORTRD") \ EM(netfs_sreq_trace_new, "NEW ") \ EM(netfs_sreq_trace_put_clear, "PUT CLEAR ") \
David Howells
maintainerRFC PATCH 49/53 cifs: Move cifs_loose_read_iter() and cifs_file_write_iter() to file.c
In reply to David HowellsMove cifs_loose_read_iter() and cifs_file_write_iter() to file.c so that they are colocated with similar functions rather than being split with cifsfs.c.
--- fs/smb/client/cifsfs.c | 55 ------------------------------------------ fs/smb/client/cifsfs.h | 2 ++ fs/smb/client/file.c | 53 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 55 insertions(+), 55 deletions(-)
fs/smb/client/cifsfs.c +0 -55
@@ -982,61 +982,6 @@ cifs_smb3_do_mount(struct file_system_type *fs_type,return root; } - -static ssize_t -cifs_loose_read_iter (struct kiocb *iocb,struct iov_iter *iter) -{ -ssize_t rc; -struct inode *inode =file_inode (iocb->ki_filp); - -if (iocb->ki_flags &IOCB_DIRECT ) -return cifs_user_readv (iocb, iter); - - rc =cifs_revalidate_mapping (inode); -if (rc) -return rc; - -return generic_file_read_iter (iocb, iter); -} - -static ssize_t cifs_file_write_iter (struct kiocb *iocb,struct iov_iter *from) -{ -struct inode *inode =file_inode (iocb->ki_filp); -struct cifsInodeInfo *cinode =CIFS_I (inode); -ssize_t written; -int rc; - -if (iocb->ki_filp->f_flags &O_DIRECT ) { - written =cifs_user_writev (iocb, from); -if (written >0 &&CIFS_CACHE_READ (cinode)) { -cifs_zap_mapping (inode); -cifs_dbg (FYI , -"Set no oplock for inode=%p after a write operation\n" , - inode); - cinode->oplock =0 ; - } -return written; - } - - written =cifs_get_writer (cinode); -if (written) -return written; - - written =generic_file_write_iter (iocb, from); - -if (CIFS_CACHE_WRITE (CIFS_I (inode))) - goto out; - - rc =filemap_fdatawrite (inode->i_mapping); -if (rc) -cifs_dbg (FYI ,"cifs_file_write_iter: %d rc on %p inode\n" , - rc, inode); - -out: -cifs_put_writer (cinode); -return written; -} -static loff_t cifs_llseek (struct file *file,loff_t offset,int whence) {struct cifsFileInfo *cfile = file->private_data;
fs/smb/client/cifsfs.h +2 -0
@@ -100,6 +100,8 @@ extern ssize_t cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to);extern ssize_t cifs_user_writev (struct kiocb *iocb,struct iov_iter *from);extern ssize_t cifs_direct_writev (struct kiocb *iocb,struct iov_iter *from);extern ssize_t cifs_strict_writev (struct kiocb *iocb,struct iov_iter *from); +ssize_t cifs_file_write_iter (struct kiocb *iocb,struct iov_iter *from); +ssize_t cifs_loose_read_iter (struct kiocb *iocb,struct iov_iter *iter);extern int cifs_flock (struct file *pfile,int cmd,struct file_lock *plock);extern int cifs_lock (struct file *,int ,struct file_lock *);extern int cifs_fsync (struct file *,loff_t ,loff_t ,int );
fs/smb/client/file.c +53 -0
59 lines not on this page · raw message
David Howells
maintainerRFC PATCH 50/53 cifs: Cut over to using netfslib
In reply to David HowellsMake the cifs filesystem use netfslib to handle reading and writing on behalf of cifs. The changes include:
(1) Various read_iter/write_iter type functions are turned into wrappers around netfslib API functions or are pointed directly at those functions:
cifs_file_direct{,_nobrl}_ops switch to use netfs_unbuffered_read_iter and netfs_unbuffered_write_iter.
Large pieces of code that will be removed are #if'd out and will be removed in subsequent patches.
[?] Why does cifs mark the page dirty in the destination buffer of a DIO
read? Should that happen automatically? Does netfs need to do that?
--- fs/netfs/io.c | 7 +- fs/smb/client/cifsfs.c | 8 +-- fs/smb/client/cifsfs.h | 8 +-- fs/smb/client/cifsglob.h | 3 +- fs/smb/client/cifsproto.h | 4 ++ fs/smb/client/cifssmb.c | 45 +++++++----- fs/smb/client/file.c | 130 ++++++++++++++++++---------------- fs/smb/client/fscache.c | 2 + fs/smb/client/fscache.h | 4 ++ fs/smb/client/inode.c | 19 ++++- fs/smb/client/smb2pdu.c | 98 ++++++++++++++++---------- fs/smb/client/trace.h | 144 +++++++++++++++++++++++++++++++++----- fs/smb/client/transport.c | 3 + 13 files changed, 326 insertions(+), 149 deletions(-)
fs/netfs/io.c +6 -1
@@ -351,8 +351,13 @@ static void netfs_rreq_assess_dio(struct netfs_io_request *rreq)unsigned int i;size_t transferred =0 ; -for (i =0 ; i < rreq->direct_bv_count; i++) +for (i =0 ; i < rreq->direct_bv_count; i++) {flush_dcache_page (rreq->direct_bv[i].bv_page); +// TODO: cifs marks pages in the destination buffer +// dirty under some circumstances after a read. Do we +// need to do that too? +set_page_dirty (rreq->direct_bv[i].bv_page); + }list_for_each_entry (subreq, &rreq->subrequests, rreq_link) {if (subreq->error || subreq->transferred ==0 )
fs/smb/client/cifsfs.c +4 -4
@@ -1352,8 +1352,8 @@ const struct file_operations cifs_file_strict_ops = { };const struct file_operations cifs_file_direct_ops = { - .read_iter = cifs_direct_readv, - .write_iter = cifs_direct_writev, + .read_iter = netfs_unbuffered_read_iter, + .write_iter = netfs_file_write_iter, .open = cifs_open, .release = cifs_close, .lock = cifs_lock,
@@ -1408,8 +1408,8 @@ const struct file_operations cifs_file_strict_nobrl_ops = { };const struct file_operations cifs_file_direct_nobrl_ops = { - .read_iter = cifs_direct_readv, - .write_iter = cifs_direct_writev, + .read_iter = netfs_unbuffered_read_iter, + .write_iter = netfs_file_write_iter, .open = cifs_open, .release = cifs_close, .fsync = cifs_fsync,
fs/smb/client/cifsfs.h +1 -7
@@ -85,6 +85,7 @@ extern const struct inode_operations cifs_namespace_inode_operations;/* Functions related to files and directories */ +extern const struct netfs_request_ops cifs_req_ops;extern const struct file_operations cifs_file_ops;extern const struct file_operations cifs_file_direct_ops;/* if directio mnt */ extern const struct file_operations cifs_file_strict_ops;/* if strictio mnt */
@@ -94,11 +95,7 @@ extern const struct file_operations cifs_file_strict_nobrl_ops;extern int cifs_open (struct inode *inode,struct file *file);extern int cifs_close (struct inode *inode,struct file *file);extern int cifs_closedir (struct inode *inode,struct file *file); -extern ssize_t cifs_user_readv (struct kiocb *iocb,struct iov_iter *to); -extern ssize_t cifs_direct_readv (struct kiocb *iocb,struct iov_iter *to);extern ssize_t cifs_strict_readv (struct kiocb *iocb,struct iov_iter *to); -extern ssize_t cifs_user_writev (struct kiocb *iocb,struct iov_iter *from); -extern ssize_t cifs_direct_writev (struct kiocb *iocb,struct iov_iter *from);extern ssize_t cifs_strict_writev (struct kiocb *iocb,struct iov_iter *from);ssize_t cifs_file_write_iter (struct kiocb *iocb,struct iov_iter *from);ssize_t cifs_loose_read_iter (struct kiocb *iocb,struct iov_iter *iter);
@@ -112,9 +109,6 @@ extern int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma);extern const struct file_operations cifs_dir_ops;extern int cifs_dir_open (struct inode *inode,struct file *file);extern int cifs_readdir (struct file *file,struct dir_context *ctx); -extern void cifs_pages_written_back (struct inode *inode,loff_t start,unsigned int len); -extern void cifs_pages_write_failed (struct inode *inode,loff_t start,unsigned int len); -extern void cifs_pages_write_redirty (struct inode *inode,loff_t start,unsigned int len);/* Functions related to dir entries */ extern const struct dentry_operations cifs_dentry_ops;
fs/smb/client/cifsglob.h +2 -1
@@ -1444,7 +1444,7 @@ struct cifs_io_subrequest {#endif struct cifs_credits credits; -// TODO: Remove following elements +#if 0 // TODO: Remove following elements struct list_head list;struct completion done;struct work_struct work;
@@ -1454,6 +1454,7 @@ struct cifs_io_subrequest {enum writeback_sync_modes sync_mode;bool uncached;struct bio_vec *bv; +#endif };/*
fs/smb/client/cifsproto.h +4 -0
@@ -580,17 +580,20 @@ void __cifs_put_smb_ses(struct cifs_ses *ses);extern struct cifs_ses *cifs_get_smb_ses (struct TCP_Server_Info *server,struct smb3_fs_context *ctx); +#if 0 // TODO Remove void cifs_readdata_release (struct cifs_io_subrequest *rdata);static inline void cifs_put_readdata (struct cifs_io_subrequest *rdata) {if (refcount_dec_and_test (&rdata->subreq.ref))cifs_readdata_release (rdata); } +#endif int cifs_async_readv (struct cifs_io_subrequest *rdata);int cifs_readv_receive (struct TCP_Server_Info *server,struct mid_q_entry *mid);int cifs_async_writev (struct cifs_io_subrequest *wdata);void cifs_writev_complete (struct work_struct *work); +#if 0 // TODO Remove struct cifs_io_subrequest *cifs_writedata_alloc (work_func_t complete);void cifs_writedata_release (struct cifs_io_subrequest *rdata);static inline void cifs_get_writedata (struct cifs_io_subrequest *wdata)
@@ -602,6 +605,7 @@ static inline void cifs_put_writedata(struct cifs_io_subrequest *wdata)if (refcount_dec_and_test (&wdata->subreq.ref))cifs_writedata_release (wdata); } +#endif int cifs_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon, struct cifs_sb_info *cifs_sb, const unsigned char *path, char *pbuf,
fs/smb/client/cifssmb.c +26 -19
127 lines not on this page · raw message
fs/smb/client/file.c +70 -60
335 lines not on this page · raw message
fs/smb/client/fscache.c +2 -0
@@ -137,6 +137,7 @@ void cifs_fscache_release_inode_cookie(struct inode *inode) } } +#if 0 // TODO remove /* * Fallback page reading interface. */
@@ -245,3 +246,4 @@ int __cifs_fscache_query_occupancy(struct inode *inode,fscache_end_operation (&cres); return ret; } +#endif
fs/smb/client/fscache.h +4 -0
@@ -74,6 +74,7 @@ static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags i_size_read(inode), flags); } +#if 0 // TODO remove extern int __cifs_fscache_query_occupancy(struct inode *inode, pgoff_t first, unsigned int nr_pages, pgoff_t *_data_first,
@@ -108,6 +109,7 @@ static inline void cifs_readahead_to_fscache(struct inode *inode,if (cifs_inode_cookie (inode))__cifs_readahead_to_fscache (inode, pos, len); } +#endif #else /* CONFIG_CIFS_FSCACHE */ static inline
@@ -125,6 +127,7 @@ static inline void cifs_fscache_unuse_inode_cookie(struct inode *inode, bool updstatic inline struct fscache_cookie *cifs_inode_cookie (struct inode *inode) {return NULL ; }static inline void cifs_invalidate_cache (struct inode *inode,unsigned int flags) {} +#if 0 // TODO remove static inline int cifs_fscache_query_occupancy(struct inode *inode, pgoff_t first, unsigned int nr_pages, pgoff_t *_data_first,
@@ -143,6 +146,7 @@ cifs_readpage_from_fscache(struct inode *inode, struct page *page)static inline void cifs_readahead_to_fscache (struct inode *inode,loff_t pos,size_t len) {} +#endif #endif /* CONFIG_CIFS_FSCACHE */
fs/smb/client/inode.c +18 -1
@@ -27,14 +27,29 @@#include "cifs_ioctl.h" #include "cached_dir.h" +/* +* Set parameters for the netfs library +*/ +static void cifs_set_netfs_context (struct inode *inode) +{ +struct cifsInodeInfo *cifs_i =CIFS_I (inode); +struct cifs_sb_info *cifs_sb =CIFS_SB (inode->i_sb); + +netfs_inode_init (&cifs_i->netfs, &cifs_req_ops); +if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_STRICT_IO ) +__set_bit (NETFS_ICTX_WRITETHROUGH , &cifs_i->netfs.flags); +} +static void cifs_set_ops (struct inode *inode) {struct cifs_sb_info *cifs_sb =CIFS_SB (inode->i_sb); +struct netfs_inode *ictx =netfs_inode (inode);switch (inode->i_mode &S_IFMT ) {case S_IFREG : inode->i_op = &cifs_file_inode_ops;if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_DIRECT_IO ) { +set_bit (NETFS_ICTX_UNBUFFERED , &ictx->flags);if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_NO_BRL ) inode->i_fop = &cifs_file_direct_nobrl_ops;else
@@ -216,8 +231,10 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)if (fattr->cf_flags &CIFS_FATTR_JUNCTION ) inode->i_flags |=S_AUTOMOUNT ; -if (inode->i_state &I_NEW ) +if (inode->i_state &I_NEW ) { +cifs_set_netfs_context (inode);cifs_set_ops (inode); + }return 0 ; }
fs/smb/client/smb2pdu.c +61 -37
241 lines not on this page · raw message
fs/smb/client/trace.h +125 -19
178 lines not on this page · raw message
fs/smb/client/transport.c +3 -0
@@ -1807,8 +1807,11 @@ cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid) length = data_len;/* An RDMA read is already done. */ else#endif + { length =cifs_read_iter_from_socket (server, &rdata->subreq.io_iter, data_len); +iov_iter_revert (&rdata->subreq.io_iter, data_len); + }if (length >0 ) rdata->got_bytes += length; server->total_read += length;
David Howells
maintainerRFC PATCH 51/53 cifs: Remove some code that's no longer used, part 1
In reply to David HowellsRemove some code that was #if'd out with the netfslib conversion. This is split into parts for file.c as the diff generator otherwise produces a hard to read diff for part of it where a big chunk is cut out.
--- fs/smb/client/cifsglob.h | 12 - fs/smb/client/cifsproto.h | 21 -- fs/smb/client/file.c | 639 -------------------------------------- fs/smb/client/fscache.c | 111 ------- fs/smb/client/fscache.h | 58 ---- 5 files changed, 841 deletions(-)
fs/smb/client/cifsglob.h +0 -12
@@ -1443,18 +1443,6 @@ struct cifs_io_subrequest {struct smbd_mr *mr;#endif struct cifs_credits credits; - -#if 0 // TODO: Remove following elements -struct list_head list; -struct completion done; -struct work_struct work; -struct cifsFileInfo *cfile; -struct address_space *mapping; -struct cifs_aio_ctx *ctx; -enum writeback_sync_modes sync_mode; -bool uncached; -struct bio_vec *bv; -#endif };/*
fs/smb/client/cifsproto.h +0 -21
@@ -580,32 +580,11 @@ void __cifs_put_smb_ses(struct cifs_ses *ses);extern struct cifs_ses *cifs_get_smb_ses (struct TCP_Server_Info *server,struct smb3_fs_context *ctx); -#if 0 // TODO Remove -void cifs_readdata_release (struct cifs_io_subrequest *rdata); -static inline void cifs_put_readdata (struct cifs_io_subrequest *rdata) -{ -if (refcount_dec_and_test (&rdata->subreq.ref)) -cifs_readdata_release (rdata); -} -#endif int cifs_async_readv (struct cifs_io_subrequest *rdata);int cifs_readv_receive (struct TCP_Server_Info *server,struct mid_q_entry *mid);int cifs_async_writev (struct cifs_io_subrequest *wdata);void cifs_writev_complete (struct work_struct *work); -#if 0 // TODO Remove -struct cifs_io_subrequest *cifs_writedata_alloc (work_func_t complete); -void cifs_writedata_release (struct cifs_io_subrequest *rdata); -static inline void cifs_get_writedata (struct cifs_io_subrequest *wdata) -{ -refcount_inc (&wdata->subreq.ref); -} -static inline void cifs_put_writedata (struct cifs_io_subrequest *wdata) -{ -if (refcount_dec_and_test (&wdata->subreq.ref)) -cifs_writedata_release (wdata); -} -#endif int cifs_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon, struct cifs_sb_info *cifs_sb, const unsigned char *path, char *pbuf,
fs/smb/client/file.c +0 -639
669 lines not on this page · raw message
fs/smb/client/fscache.c +0 -111
114 lines not on this page · raw message
fs/smb/client/fscache.h +0 -58
70 lines not on this page · raw message
David Howells
maintainerRFC PATCH 52/53 cifs: Remove some code that's no longer used, part 2
In reply to David HowellsRemove some code that was #if'd out with the netfslib conversion. This is split into parts for file.c as the diff generator otherwise produces a hard to read diff for part of it where a big chunk is cut out.
--- fs/smb/client/file.c | 696 +------------------------------------------ 1 file changed, 1 insertion(+), 695 deletions(-)
fs/smb/client/file.c +1 -695
@@ -2574,701 +2574,6 @@ cifs_get_readable_path(struct cifs_tcon *tcon, const char *name,return -ENOENT ; } -#if 0 // TODO remove 2773 -void -cifs_writedata_release (struct cifs_io_subrequest *wdata) -{ -if (wdata->uncached) -kref_put (&wdata->ctx->refcount, cifs_aio_ctx_release); -#ifdef CONFIG_CIFS_SMB_DIRECT -if (wdata->mr) { -smbd_deregister_mr (wdata->mr); - wdata->mr =NULL ; - } -#endif - -if (wdata->cfile) -cifsFileInfo_put (wdata->cfile); - -kfree (wdata); -} - -/* -* Write failed with a retryable error. Resend the write request. It's also -* possible that the page was redirtied so re-clean the page. -*/ -static void -cifs_writev_requeue (struct cifs_io_subrequest *wdata) -{ -int rc =0 ; -struct inode *inode =d_inode (wdata->cfile->dentry); -struct TCP_Server_Info *server; -unsigned int rest_len = wdata->subreq.len; -loff_t fpos = wdata->subreq.start; - - server =tlink_tcon (wdata->cfile->tlink)->ses->server; -do { -struct cifs_io_subrequest *wdata2; -unsigned int wsize, cur_len; - - wsize = server->ops->wp_retry_size (inode); -if (wsize < rest_len) { -if (wsize <PAGE_SIZE ) { - rc = -EOPNOTSUPP ; -break ; - } - cur_len =min (round_down (wsize,PAGE_SIZE ), rest_len); - }else { - cur_len = rest_len; - } - - wdata2 =cifs_writedata_alloc (cifs_writev_complete); -if (!wdata2) { - rc = -ENOMEM ; -break ; - } - - wdata2->sync_mode = wdata->sync_mode; - wdata2->subreq.start = fpos; - wdata2->subreq.len = cur_len; - wdata2->subreq.io_iter = wdata->subreq.io_iter; - -iov_iter_advance (&wdata2->subreq.io_iter, fpos - wdata->subreq.start); -iov_iter_truncate (&wdata2->subreq.io_iter, wdata2->subreq.len); - -if (iov_iter_is_xarray (&wdata2->subreq.io_iter)) -/* Check for pages having been redirtied and clean -* them. We can do this by walking the xarray. If -* it's not an xarray, then it's a DIO and we shouldn't -* be mucking around with the page bits. -*/ -cifs_undirty_folios (inode, fpos, cur_len); - - rc =cifs_get_writable_file (CIFS_I (inode),FIND_WR_ANY , - &wdata2->cfile); -if (!wdata2->cfile) { -cifs_dbg (VFS ,"No writable handle to retry writepages rc=%d\n" , - rc); -if (!is_retryable_error (rc)) - rc = -EBADF ; - }else { - wdata2->pid = wdata2->cfile->pid; - rc = server->ops->async_writev (wdata2); - } - -cifs_put_writedata (wdata2); -if (rc) { -if (is_retryable_error (rc)) -continue ; - fpos += cur_len; - rest_len -= cur_len; -break ; - } - - fpos += cur_len; - rest_len -= cur_len; - }while (rest_len >0 ); - -/* Clean up remaining pages from the original wdata */ -if (iov_iter_is_xarray (&wdata->subreq.io_iter)) -cifs_pages_write_failed (inode, fpos, rest_len); - -if (rc !=0 && !is_retryable_error (rc)) -mapping_set_error (inode->i_mapping, rc); -cifs_put_writedata (wdata); -} - -void -cifs_writev_complete (struct work_struct *work) -{ -struct cifs_io_subrequest *wdata =container_of (work, - struct cifs_io_subrequest, work); -struct inode *inode =d_inode (wdata->cfile->dentry); - -if (wdata->result ==0 ) { -spin_lock (&inode->i_lock); -cifs_update_eof (CIFS_I (inode), wdata->subreq.start, wdata->subreq.len); -spin_unlock (&inode->i_lock); -cifs_stats_bytes_written (tlink_tcon (wdata->cfile->tlink), - wdata->subreq.len); - }else if (wdata->sync_mode ==WB_SYNC_ALL && wdata->result == -EAGAIN ) -return cifs_writev_requeue (wdata); - -if (wdata->result == -EAGAIN ) -cifs_pages_write_redirty (inode, wdata->subreq.start, wdata->subreq.len); -else if (wdata->result <0 ) -cifs_pages_write_failed (inode, wdata->subreq.start, wdata->subreq.len); -else -cifs_pages_written_back (inode, wdata->subreq.start, wdata->subreq.len); - -if (wdata->result != -EAGAIN ) -mapping_set_error (inode->i_mapping, wdata->result); -cifs_put_writedata (wdata); -} - -struct cifs_io_subrequest *cifs_writedata_alloc (work_func_t complete) -{ -struct cifs_io_subrequest *wdata; - - wdata =kzalloc (sizeof (*wdata),GFP_NOFS ); -if (wdata !=NULL ) { -refcount_set (&wdata->subreq.ref,1 ); -INIT_LIST_HEAD (&wdata->list); -init_completion (&wdata->done); -INIT_WORK (&wdata->work, complete); - } -return wdata; -} - -static int cifs_partialpagewrite (struct page *page,unsigned from,unsigned to) -{ -struct address_space *mapping = page->mapping; -loff_t offset = (loff_t )page->index <<PAGE_SHIFT ; -char *write_data; -int rc = -EFAULT ; -int bytes_written =0 ; -struct inode *inode; -struct cifsFileInfo *open_file; - -if (!mapping || !mapping->host) -return -EFAULT ; - - inode = page->mapping->host; - - offset += (loff_t )from; - write_data =kmap (page); - write_data += from; - -if ((to >PAGE_SIZE ) || (from > to)) { -kunmap (page); -return -EIO ; - } - -/* racing with truncate? */ -if (offset > mapping->host->i_size) { -kunmap (page); -return 0 ;/* don't care */ - } - -/* check to make sure that we are not extending the file */ -if (mapping->host->i_size - offset < (loff_t )to) - to = (unsigned )(mapping->host->i_size - offset); - - rc =cifs_get_writable_file (CIFS_I (mapping->host),FIND_WR_ANY , - &open_file); -if (!rc) { - bytes_written =cifs_write (open_file, open_file->pid, - write_data, to - from, &offset); -cifsFileInfo_put (open_file); -/* Does mm or vfs already set times? */ - inode->i_atime = inode->i_mtime =inode_set_ctime_current (inode); -if ((bytes_written >0 ) && (offset)) - rc =0 ; -else if (bytes_written <0 ) - rc = bytes_written; -else - rc = -EFAULT ; - }else { -cifs_dbg (FYI ,"No writable handle for write page rc=%d\n" , rc); -if (!is_retryable_error (rc)) - rc = -EIO ; - } - -kunmap (page); -return rc; -} - -/* -* Extend the region to be written back to include subsequent contiguously -* dirty pages if possible, but don't sleep while doing so. -*/ -static void cifs_extend_writeback (struct address_space *mapping, -long *_count, -loff_t start, -int max_pages, -size_t max_len, -unsigned int *_len) -{ -struct folio_batch batch; -struct folio *folio; -unsigned int psize, nr_pages; -size_t len = *_len; -pgoff_t index = (start + len) /PAGE_SIZE ; -bool stop = true; -unsigned int i; -XA_STATE (xas, &mapping->i_pages, index); - -folio_batch_init (&batch); - -do { -/* Firstly, we gather up a batch of contiguous dirty pages -* under the RCU read lock - but we can't clear the dirty flags -* there if any of those pages are mapped. -*/ -rcu_read_lock (); - -xas_for_each (&xas, folio,ULONG_MAX ) { - stop = true; -if (xas_retry (&xas, folio)) -continue ; -if (xa_is_value (folio)) -break ; -if (folio_index (folio) != index) -break ; -if (!folio_try_get_rcu (folio)) { -xas_reset (&xas); -continue ; - } - nr_pages =folio_nr_pages (folio); -if (nr_pages > max_pages) -break ; - -/* Has the page moved or been split? */ -if (unlikely (folio !=xas_reload (&xas))) { -folio_put (folio); -break ; - } - -if (!folio_trylock (folio)) { -folio_put (folio); -break ; - } -if (!folio_test_dirty (folio) ||folio_test_writeback (folio)) { -folio_unlock (folio); -folio_put (folio); -break ; - } - - max_pages -= nr_pages; - psize =folio_size (folio); - len += psize; - stop = false; -if (max_pages <=0 || len >= max_len || *_count <=0 ) - stop = true; - - index += nr_pages; -if (!folio_batch_add (&batch, folio)) -break ; -if (stop) -break ; - } - -if (!stop) -xas_pause (&xas); -rcu_read_unlock (); - -/* Now, if we obtained any pages, we can shift them to being -* writable and mark them for caching. -*/ -if (!folio_batch_count (&batch)) -break ; - -for (i =0 ; i <folio_batch_count (&batch); i++) { - folio = batch.folios[i]; -/* The folio should be locked, dirty and not undergoing -* writeback from the loop above. -*/ -if (!folio_clear_dirty_for_io (folio)) -WARN_ON (1 ); -if (folio_start_writeback (folio)) -WARN_ON (1 ); - - *_count -=folio_nr_pages (folio); -folio_unlock (folio); - } - -folio_batch_release (&batch); -cond_resched (); - }while (!stop); - - *_len = len; -} - -/* -* Write back the locked page and any subsequent non-locked dirty pages. -*/ -static ssize_t cifs_write_back_from_locked_folio (struct address_space *mapping, -struct writeback_control *wbc, -struct folio *folio, -loff_t start,loff_t end) -{ -struct inode *inode = mapping->host; -struct TCP_Server_Info *server; -struct cifs_io_subrequest *wdata; -struct cifs_sb_info *cifs_sb =CIFS_SB (inode->i_sb); -struct cifs_credits credits_on_stack; -struct cifs_credits *credits = &credits_on_stack; -struct cifsFileInfo *cfile =NULL ; -unsigned int xid, len; -loff_t i_size =i_size_read (inode); -size_t max_len, wsize; -long count = wbc->nr_to_write; -int rc; - -/* The folio should be locked, dirty and not undergoing writeback. */ -if (folio_start_writeback (folio)) -WARN_ON (1 ); - - count -=folio_nr_pages (folio); - len =folio_size (folio); - - xid =get_xid (); - server =cifs_pick_channel (cifs_sb_master_tcon (cifs_sb)->ses); - - rc =cifs_get_writable_file (CIFS_I (inode),FIND_WR_ANY , &cfile); -if (rc) { -cifs_dbg (VFS ,"No writable handle in writepages rc=%d\n" , rc); - goto err_xid; - } - - rc = server->ops->wait_mtu_credits (server, cifs_sb->ctx->wsize, - &wsize, credits); -if (rc !=0 ) - goto err_close; - - wdata =cifs_writedata_alloc (cifs_writev_complete); -if (!wdata) { - rc = -ENOMEM ; - goto err_uncredit; - } - - wdata->sync_mode = wbc->sync_mode; - wdata->subreq.start =folio_pos (folio); - wdata->pid = cfile->pid; - wdata->credits = credits_on_stack; - wdata->cfile = cfile; - wdata->server = server; - cfile =NULL ; - -/* Find all consecutive lockable dirty pages, stopping when we find a -* page that is not immediately lockable, is not dirty or is missing, -* or we reach the end of the range. -*/ -if (start < i_size) { -/* Trim the write to the EOF; the extra data is ignored. Also -* put an upper limit on the size of a single storedata op. -*/ - max_len = wsize; - max_len = min_t(unsigned long long, max_len, end - start + 1); - max_len = min_t(unsigned long long, max_len, i_size - start); - -if (len < max_len) { -int max_pages =INT_MAX ; - -#ifdef CONFIG_CIFS_SMB_DIRECT -if (server->smbd_conn) - max_pages = server->smbd_conn->max_frmr_depth; -#endif - max_pages -=folio_nr_pages (folio); - -if (max_pages >0 ) -cifs_extend_writeback (mapping, &count, start, - max_pages, max_len, &len); - } - len =min_t (loff_t, len, max_len); - } - - wdata->subreq.len = len; - -/* We now have a contiguous set of dirty pages, each with writeback -* set; the first page is still locked at this point, but all the rest -* have been unlocked. -*/ -folio_unlock (folio); - -if (start < i_size) { -iov_iter_xarray (&wdata->subreq.io_iter,ITER_SOURCE , &mapping->i_pages, - start, len); - - rc =adjust_credits (wdata->server, &wdata->credits, wdata->subreq.len); -if (rc) - goto err_wdata; - -if (wdata->cfile->invalidHandle) - rc = -EAGAIN ; -else - rc = wdata->server->ops->async_writev (wdata); -if (rc >=0 ) { -cifs_put_writedata (wdata); - goto err_close; - } - }else { -/* The dirty region was entirely beyond the EOF. */ -cifs_pages_written_back (inode, start, len); - rc =0 ; - } - -err_wdata: -cifs_put_writedata (wdata); -err_uncredit: -add_credits_and_wake_if (server, credits,0 ); -err_close: -if (cfile) -cifsFileInfo_put (cfile); -err_xid: -free_xid (xid); -if (rc ==0 ) { - wbc->nr_to_write = count; - rc = len; - }else if (is_retryable_error (rc)) { -cifs_pages_write_redirty (inode, start, len); - }else { -cifs_pages_write_failed (inode, start, len); -mapping_set_error (mapping, rc); - } -/* Indication to update ctime and mtime as close is deferred */ -set_bit (CIFS_INO_MODIFIED_ATTR , &CIFS_I (inode)->flags); -return rc; -} - -/* -* write a region of pages back to the server -*/ -static int cifs_writepages_region (struct address_space *mapping, -struct writeback_control *wbc, -loff_t start,loff_t end,loff_t *_next) -{ -struct folio_batch fbatch; -int skips =0 ; - -folio_batch_init (&fbatch); -do { -int nr; -pgoff_t index = start /PAGE_SIZE ; - - nr =filemap_get_folios_tag (mapping, &index, end /PAGE_SIZE , -PAGECACHE_TAG_DIRTY , &fbatch); -if (!nr) -break ; - -for (int i =0 ; i < nr; i++) { -ssize_t ret; -struct folio *folio = fbatch.folios[i]; - -redo_folio: - start =folio_pos (folio);/* May regress with THPs */ - -/* At this point we hold neither the i_pages lock nor the -* page lock: the page may be truncated or invalidated -* (changing page->mapping to NULL), or even swizzled -* back from swapper_space to tmpfs file mapping -*/ -if (wbc->sync_mode !=WB_SYNC_NONE ) { - ret =folio_lock_killable (folio); -if (ret <0 ) - goto write_error; - }else { -if (!folio_trylock (folio)) - goto skip_write; - } - -if (folio_mapping (folio) != mapping || - !folio_test_dirty (folio)) { - start +=folio_size (folio); -folio_unlock (folio); -continue ; - } - -if (folio_test_writeback (folio) || -folio_test_fscache (folio)) { -folio_unlock (folio); -if (wbc->sync_mode ==WB_SYNC_NONE ) - goto skip_write; - -folio_wait_writeback (folio); -#ifdef CONFIG_CIFS_FSCACHE -folio_wait_fscache (folio); -#endif - goto redo_folio; - } - -if (!folio_clear_dirty_for_io (folio)) -/* We hold the page lock - it should've been dirty. */ -WARN_ON (1 ); - - ret =cifs_write_back_from_locked_folio (mapping, wbc, folio, start, end); -if (ret <0 ) - goto write_error; - - start += ret; -continue ; - -write_error: -folio_batch_release (&fbatch); - *_next = start; -return ret; - -skip_write: -/* -* Too many skipped writes, or need to reschedule? -* Treat it as a write error without an error code. -*/ -if (skips >=5 ||need_resched ()) { - ret =0 ; - goto write_error; - } - -/* Otherwise, just skip that folio and go on to the next */ - skips++; - start +=folio_size (folio); -continue ; - } - -folio_batch_release (&fbatch); -cond_resched (); - }while (wbc->nr_to_write >0 ); - - *_next = start; -return 0 ; -} - -/* -* Write some of the pending data back to the server -*/ -static int cifs_writepages (struct address_space *mapping, -struct writeback_control *wbc) -{ -loff_t start, next; -int ret; - -/* We have to be careful as we can end up racing with setattr() -* truncating the pagecache since the caller doesn't take a lock here -* to prevent it. -*/ - -if (wbc->range_cyclic) { - start = mapping->writeback_index *PAGE_SIZE ; - ret =cifs_writepages_region (mapping, wbc, start,LLONG_MAX , &next); -if (ret ==0 ) { - mapping->writeback_index = next /PAGE_SIZE ; -if (start >0 && wbc->nr_to_write >0 ) { - ret =cifs_writepages_region (mapping, wbc,0 , - start, &next); -if (ret ==0 ) - mapping->writeback_index = - next /PAGE_SIZE ; - } - } - }else if (wbc->range_start ==0 && wbc->range_end ==LLONG_MAX ) { - ret =cifs_writepages_region (mapping, wbc,0 ,LLONG_MAX , &next); -if (wbc->nr_to_write >0 && ret ==0 ) - mapping->writeback_index = next /PAGE_SIZE ; - }else { - ret =cifs_writepages_region (mapping, wbc, - wbc->range_start, wbc->range_end, &next); - } - -return ret; -} - -static int -cifs_writepage_locked (struct page *page,struct writeback_control *wbc) -{ -int rc; -unsigned int xid; - - xid =get_xid (); -/* BB add check for wbc flags */ -get_page (page); -if (!PageUptodate (page)) -cifs_dbg (FYI ,"ppw - page not up to date\n" ); - -/* -* Set the "writeback" flag, and clear "dirty" in the radix tree. -* -* A writepage() implementation always needs to do either this, -* or re-dirty the page with "redirty_page_for_writepage()" in -* the case of a failure. -* -* Just unlocking the page will cause the radix tree tag-bits -* to fail to update with the state of the page correctly. -*/ -set_page_writeback (page); -retry_write: - rc =cifs_partialpagewrite (page,0 ,PAGE_SIZE ); -if (is_retryable_error (rc)) { -if (wbc->sync_mode ==WB_SYNC_ALL && rc == -EAGAIN ) - goto retry_write; -redirty_page_for_writepage (wbc, page); - }else if (rc !=0 ) { -SetPageError (page); -mapping_set_error (page->mapping, rc); - }else { -SetPageUptodate (page); - } -end_page_writeback (page); -put_page (page); -free_xid (xid); -return rc; -} - -static int cifs_write_end (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata) -{ -int rc; -struct inode *inode = mapping->host; -struct cifsFileInfo *cfile = file->private_data; -struct cifs_sb_info *cifs_sb =CIFS_SB (cfile->dentry->d_sb); -struct folio *folio =page_folio (page); -__u32 pid; - -if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_RWPIDFORWARD ) - pid = cfile->pid; -else - pid = current->tgid; - -cifs_dbg (FYI ,"write_end for page %p from pos %lld with %d bytes\n" , - page, pos, copied); - -if (folio_test_checked (folio)) { -if (copied == len) -folio_mark_uptodate (folio); -folio_clear_checked (folio); - }else if (!folio_test_uptodate (folio) && copied ==PAGE_SIZE ) -folio_mark_uptodate (folio); - -if (!folio_test_uptodate (folio)) { -char *page_data; -unsigned offset = pos & (PAGE_SIZE -1 ); -unsigned int xid; - - xid =get_xid (); -/* this is probably better than directly calling -partialpage_write since in this function the file handle is -known which we might as well leverage */ -/* BB check if anything else missing out of ppw -such as updating last write time */ - page_data =kmap (page); - rc =cifs_write (cfile, pid, page_data + offset, copied, &pos); -/* if (rc < 0) should we set writebehind rc? */ -kunmap (page); - -free_xid (xid); - }else { - rc = copied; - pos += copied; -set_page_dirty (page); - } - -if (rc >0 ) { -spin_lock (&inode->i_lock); -if (pos > inode->i_size) { -i_size_write (inode, pos); - inode->i_blocks = (512 -1 + pos) >>9 ; - } -spin_unlock (&inode->i_lock); - } - -unlock_page (page); -put_page (page); -/* Indication to update ctime and mtime as close is deferred */ -set_bit (CIFS_INO_MODIFIED_ATTR , &CIFS_I (inode)->flags); - -return rc; -} -#endif // End netfs removal 2773 -/* * Flush data on a strict file. */
@@ -4583,6 +3888,7 @@ cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset) }#endif // end netfslib remove 4633 +static vm_fault_t cifs_page_mkwrite (struct vm_fault *vmf) {return netfs_page_mkwrite (vmf,NULL );
David Howells
maintainerRFC PATCH 53/53 cifs: Remove some code that's no longer used, part 3
In reply to David HowellsRemove some code that was #if'd out with the netfslib conversion. This is split into parts for file.c as the diff generator otherwise produces a hard to read diff for part of it where a big chunk is cut out.
--- fs/smb/client/file.c | 1003 ------------------------------------------ 1 file changed, 1003 deletions(-)
fs/smb/client/file.c +0 -1003
@@ -2700,470 +2700,6 @@ int cifs_flush(struct file *file, fl_owner_t id)return rc; } -#if 0 // TODO remove 3594 -static void collect_uncached_write_data (struct cifs_aio_ctx *ctx); - -static void -cifs_uncached_writev_complete (struct work_struct *work) -{ -struct cifs_io_subrequest *wdata =container_of (work, - struct cifs_io_subrequest, work); -struct inode *inode =d_inode (wdata->cfile->dentry); -struct cifsInodeInfo *cifsi =CIFS_I (inode); - -spin_lock (&inode->i_lock); -cifs_update_eof (cifsi, wdata->subreq.start, wdata->subreq.len); -if (cifsi->netfs.remote_i_size > inode->i_size) -i_size_write (inode, cifsi->netfs.remote_i_size); -spin_unlock (&inode->i_lock); - -complete (&wdata->done); -collect_uncached_write_data (wdata->ctx); -/* the below call can possibly free the last ref to aio ctx */ -cifs_put_writedata (wdata); -} - -static int -cifs_resend_wdata (struct cifs_io_subrequest *wdata,struct list_head *wdata_list, -struct cifs_aio_ctx *ctx) -{ -size_t wsize; -struct cifs_credits credits; -int rc; -struct TCP_Server_Info *server = wdata->server; - -do { -if (wdata->cfile->invalidHandle) { - rc =cifs_reopen_file (wdata->cfile, false); -if (rc == -EAGAIN ) -continue ; -else if (rc) -break ; - } - - -/* -* Wait for credits to resend this wdata. -* Note: we are attempting to resend the whole wdata not in -* segments -*/ -do { - rc = server->ops->wait_mtu_credits (server, wdata->subreq.len, - &wsize, &credits); -if (rc) - goto fail; - -if (wsize < wdata->subreq.len) { -add_credits_and_wake_if (server, &credits,0 ); -msleep (1000 ); - } - }while (wsize < wdata->subreq.len); - wdata->credits = credits; - - rc =adjust_credits (server, &wdata->credits, wdata->subreq.len); - -if (!rc) { -if (wdata->cfile->invalidHandle) - rc = -EAGAIN ; -else { -#ifdef CONFIG_CIFS_SMB_DIRECT -if (wdata->mr) { - wdata->mr->need_invalidate = true; -smbd_deregister_mr (wdata->mr); - wdata->mr =NULL ; - } -#endif - rc = server->ops->async_writev (wdata); - } - } - -/* If the write was successfully sent, we are done */ -if (!rc) { -list_add_tail (&wdata->list, wdata_list); -return 0 ; - } - -/* Roll back credits and retry if needed */ -add_credits_and_wake_if (server, &wdata->credits,0 ); - }while (rc == -EAGAIN ); - -fail: -cifs_put_writedata (wdata); -return rc; -} - -/* -* Select span of a bvec iterator we're going to use. Limit it by both maximum -* size and maximum number of segments. -*/ -static size_t cifs_limit_bvec_subset (const struct iov_iter *iter,size_t max_size, -size_t max_segs,unsigned int *_nsegs) -{ -const struct bio_vec *bvecs = iter->bvec; -unsigned int nbv = iter->nr_segs, ix =0 , nsegs =0 ; -size_t len, span =0 , n = iter->count; -size_t skip = iter->iov_offset; - -if (WARN_ON (!iov_iter_is_bvec (iter)) || n ==0 ) -return 0 ; - -while (n && ix < nbv && skip) { - len = bvecs[ix].bv_len; -if (skip < len) -break ; - skip -= len; - n -= len; - ix++; - } - -while (n && ix < nbv) { - len =min3 (n, bvecs[ix].bv_len - skip, max_size); - span += len; - max_size -= len; - nsegs++; - ix++; -if (max_size ==0 || nsegs >= max_segs) -break ; - skip =0 ; - n -= len; - } - - *_nsegs = nsegs; -return span; -} - -static int -cifs_write_from_iter (loff_t fpos,size_t len,struct iov_iter *from, -struct cifsFileInfo *open_file, -struct cifs_sb_info *cifs_sb,struct list_head *wdata_list, -struct cifs_aio_ctx *ctx) -{ -int rc =0 ; -size_t cur_len, max_len; -struct cifs_io_subrequest *wdata; -pid_t pid; -struct TCP_Server_Info *server; -unsigned int xid, max_segs =INT_MAX ; - -if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_RWPIDFORWARD ) - pid = open_file->pid; -else - pid = current->tgid; - - server =cifs_pick_channel (tlink_tcon (open_file->tlink)->ses); - xid =get_xid (); - -#ifdef CONFIG_CIFS_SMB_DIRECT -if (server->smbd_conn) - max_segs = server->smbd_conn->max_frmr_depth; -#endif - -do { -struct cifs_credits credits_on_stack; -struct cifs_credits *credits = &credits_on_stack; -unsigned int nsegs =0 ; -size_t wsize; - -if (signal_pending (current)) { - rc = -EINTR ; -break ; - } - -if (open_file->invalidHandle) { - rc =cifs_reopen_file (open_file, false); -if (rc == -EAGAIN ) -continue ; -else if (rc) -break ; - } - - rc = server->ops->wait_mtu_credits (server, cifs_sb->ctx->wsize, - &wsize, credits); -if (rc) -break ; - - max_len = min_t(const size_t, len, wsize); -if (!max_len) { - rc = -EAGAIN ; -add_credits_and_wake_if (server, credits,0 ); -break ; - } - - cur_len =cifs_limit_bvec_subset (from, max_len, max_segs, &nsegs); -cifs_dbg (FYI ,"write_from_iter len=%zx/%zx nsegs=%u/%lu/%u\n" , - cur_len, max_len, nsegs, from->nr_segs, max_segs); -if (cur_len ==0 ) { - rc = -EIO ; -add_credits_and_wake_if (server, credits,0 ); -break ; - } - - wdata =cifs_writedata_alloc (cifs_uncached_writev_complete); -if (!wdata) { - rc = -ENOMEM ; -add_credits_and_wake_if (server, credits,0 ); -break ; - } - - wdata->uncached = true; - wdata->sync_mode =WB_SYNC_ALL ; - wdata->subreq.start = (__u64 )fpos; - wdata->cfile =cifsFileInfo_get (open_file); - wdata->server = server; - wdata->pid = pid; - wdata->subreq.len = cur_len; - wdata->credits = credits_on_stack; - wdata->subreq.io_iter = *from; - wdata->ctx = ctx; -kref_get (&ctx->refcount); - -iov_iter_truncate (&wdata->subreq.io_iter, cur_len); - - rc =adjust_credits (server, &wdata->credits, wdata->subreq.len); - -if (!rc) { -if (wdata->cfile->invalidHandle) - rc = -EAGAIN ; -else - rc = server->ops->async_writev (wdata); - } - -if (rc) { -add_credits_and_wake_if (server, &wdata->credits,0 ); -cifs_put_writedata (wdata); -if (rc == -EAGAIN ) -continue ; -break ; - } - -list_add_tail (&wdata->list, wdata_list); -iov_iter_advance (from, cur_len); - fpos += cur_len; - len -= cur_len; - }while (len >0 ); - -free_xid (xid); -return rc; -} - -static void collect_uncached_write_data (struct cifs_aio_ctx *ctx) -{ -struct cifs_io_subrequest *wdata, *tmp; -struct cifs_tcon *tcon; -struct cifs_sb_info *cifs_sb; -struct dentry *dentry = ctx->cfile->dentry; -ssize_t rc; - - tcon =tlink_tcon (ctx->cfile->tlink); - cifs_sb =CIFS_SB (dentry->d_sb); - -mutex_lock (&ctx->aio_mutex); - -if (list_empty (&ctx->list)) { -mutex_unlock (&ctx->aio_mutex); -return ; - } - - rc = ctx->rc; -/* -* Wait for and collect replies for any successful sends in order of -* increasing offset. Once an error is hit, then return without waiting -* for any more replies. -*/ -restart_loop: -list_for_each_entry_safe (wdata, tmp, &ctx->list, list) { -if (!rc) { -if (!try_wait_for_completion (&wdata->done)) { -mutex_unlock (&ctx->aio_mutex); -return ; - } - -if (wdata->result) - rc = wdata->result; -else - ctx->total_len += wdata->subreq.len; - -/* resend call if it's a retryable error */ -if (rc == -EAGAIN ) { -struct list_head tmp_list; -struct iov_iter tmp_from = ctx->iter; - -INIT_LIST_HEAD (&tmp_list); -list_del_init (&wdata->list); - -if (ctx->direct_io) - rc =cifs_resend_wdata ( - wdata, &tmp_list, ctx); -else { -iov_iter_advance (&tmp_from, - wdata->subreq.start - ctx->pos); - - rc =cifs_write_from_iter (wdata->subreq.start, - wdata->subreq.len, &tmp_from, - ctx->cfile, cifs_sb, &tmp_list, - ctx); - -cifs_put_writedata (wdata); - } - -list_splice (&tmp_list, &ctx->list); - goto restart_loop; - } - } -list_del_init (&wdata->list); -cifs_put_writedata (wdata); - } - -cifs_stats_bytes_written (tcon, ctx->total_len); -set_bit (CIFS_INO_INVALID_MAPPING , &CIFS_I (dentry->d_inode)->flags); - - ctx->rc = (rc ==0 ) ? ctx->total_len : rc; - -mutex_unlock (&ctx->aio_mutex); - -if (ctx->iocb && ctx->iocb->ki_complete) - ctx->iocb->ki_complete (ctx->iocb, ctx->rc); -else -complete (&ctx->done); -} - -static ssize_t __cifs_writev ( -struct kiocb *iocb,struct iov_iter *from,bool direct) -{ -struct file *file = iocb->ki_filp; -ssize_t total_written =0 ; -struct cifsFileInfo *cfile; -struct cifs_tcon *tcon; -struct cifs_sb_info *cifs_sb; -struct cifs_aio_ctx *ctx; -int rc; - - rc =generic_write_checks (iocb, from); -if (rc <=0 ) -return rc; - - cifs_sb =CIFS_FILE_SB (file); - cfile = file->private_data; - tcon =tlink_tcon (cfile->tlink); - -if (!tcon->ses->server->ops->async_writev) -return -ENOSYS ; - - ctx =cifs_aio_ctx_alloc (); -if (!ctx) -return -ENOMEM ; - - ctx->cfile =cifsFileInfo_get (cfile); - -if (!is_sync_kiocb (iocb)) - ctx->iocb = iocb; - - ctx->pos = iocb->ki_pos; - ctx->direct_io = direct; - ctx->nr_pinned_pages =0 ; - -if (user_backed_iter (from)) { -/* -* Extract IOVEC/UBUF-type iterators to a BVEC-type iterator as -* they contain references to the calling process's virtual -* memory layout which won't be available in an async worker -* thread. This also takes a pin on every folio involved. -*/ - rc =netfs_extract_user_iter (from,iov_iter_count (from), - &ctx->iter,0 ); -if (rc <0 ) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return rc; - } - - ctx->nr_pinned_pages = rc; - ctx->bv = (void *)ctx->iter.bvec; - ctx->bv_need_unpin =iov_iter_extract_will_pin (from); - }else if ((iov_iter_is_bvec (from) ||iov_iter_is_kvec (from)) && - !is_sync_kiocb (iocb)) { -/* -* If the op is asynchronous, we need to copy the list attached -* to a BVEC/KVEC-type iterator, but we assume that the storage -* will be pinned by the caller; in any case, we may or may not -* be able to pin the pages, so we don't try. -*/ - ctx->bv = (void *)dup_iter (&ctx->iter, from,GFP_KERNEL ); -if (!ctx->bv) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return -ENOMEM ; - } - }else { -/* -* Otherwise, we just pass the iterator down as-is and rely on -* the caller to make sure the pages referred to by the -* iterator don't evaporate. -*/ - ctx->iter = *from; - } - - ctx->len =iov_iter_count (&ctx->iter); - -/* grab a lock here due to read response handlers can access ctx */ -mutex_lock (&ctx->aio_mutex); - - rc =cifs_write_from_iter (iocb->ki_pos, ctx->len, &ctx->iter, - cfile, cifs_sb, &ctx->list, ctx); - -/* -* If at least one write was successfully sent, then discard any rc -* value from the later writes. If the other write succeeds, then -* we'll end up returning whatever was written. If it fails, then -* we'll get a new rc value from that. -*/ -if (!list_empty (&ctx->list)) - rc =0 ; - -mutex_unlock (&ctx->aio_mutex); - -if (rc) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return rc; - } - -if (!is_sync_kiocb (iocb)) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return -EIOCBQUEUED ; - } - - rc =wait_for_completion_killable (&ctx->done); -if (rc) { -mutex_lock (&ctx->aio_mutex); - ctx->rc = rc = -EINTR ; - total_written = ctx->total_len; -mutex_unlock (&ctx->aio_mutex); - }else { - rc = ctx->rc; - total_written = ctx->total_len; - } - -kref_put (&ctx->refcount, cifs_aio_ctx_release); - -if (unlikely (!total_written)) -return rc; - - iocb->ki_pos += total_written; -return total_written; -} - -ssize_t cifs_direct_writev (struct kiocb *iocb,struct iov_iter *from) -{ -struct file *file = iocb->ki_filp; - -cifs_revalidate_mapping (file->f_inode); -return __cifs_writev (iocb, from, true); -} - -ssize_t cifs_user_writev (struct kiocb *iocb,struct iov_iter *from) -{ -return __cifs_writev (iocb, from, false); -} -#endif // TODO remove 3594 -static ssize_t cifs_writev (struct kiocb *iocb,struct iov_iter *from) {
@@ -3252,450 +2788,6 @@ cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)return written; } -#if 0 // TODO remove 4143 -static struct cifs_io_subrequest *cifs_readdata_alloc (work_func_t complete) -{ -struct cifs_io_subrequest *rdata; - - rdata =kzalloc (sizeof (*rdata),GFP_KERNEL ); -if (rdata) { -refcount_set (&rdata->subreq.ref,1 ); -INIT_LIST_HEAD (&rdata->list); -init_completion (&rdata->done); -INIT_WORK (&rdata->work, complete); - } - -return rdata; -} - -void -cifs_readdata_release (struct cifs_io_subrequest *rdata) -{ -if (rdata->ctx) -kref_put (&rdata->ctx->refcount, cifs_aio_ctx_release); -#ifdef CONFIG_CIFS_SMB_DIRECT -if (rdata->mr) { -smbd_deregister_mr (rdata->mr); - rdata->mr =NULL ; - } -#endif -if (rdata->cfile) -cifsFileInfo_put (rdata->cfile); - -kfree (rdata); -} - -static void collect_uncached_read_data (struct cifs_aio_ctx *ctx); - -static void -cifs_uncached_readv_complete (struct work_struct *work) -{ -struct cifs_io_subrequest *rdata = - container_of(work, struct cifs_io_subrequest, work); - -complete (&rdata->done); -collect_uncached_read_data (rdata->ctx); -/* the below call can possibly free the last ref to aio ctx */ -cifs_put_readdata (rdata); -} - -static int cifs_resend_rdata (struct cifs_io_subrequest *rdata, -struct list_head *rdata_list, -struct cifs_aio_ctx *ctx) -{ -size_t rsize; -struct cifs_credits credits; -int rc; -struct TCP_Server_Info *server; - -/* XXX: should we pick a new channel here? */ - server = rdata->server; - -do { -if (rdata->cfile->invalidHandle) { - rc =cifs_reopen_file (rdata->cfile, true); -if (rc == -EAGAIN ) -continue ; -else if (rc) -break ; - } - -/* -* Wait for credits to resend this rdata. -* Note: we are attempting to resend the whole rdata not in -* segments -*/ -do { - rc = server->ops->wait_mtu_credits (server, rdata->subreq.len, - &rsize, &credits); - -if (rc) - goto fail; - -if (rsize < rdata->subreq.len) { -add_credits_and_wake_if (server, &credits,0 ); -msleep (1000 ); - } - }while (rsize < rdata->subreq.len); - rdata->credits = credits; - - rc =adjust_credits (server, &rdata->credits, rdata->subreq.len); -if (!rc) { -if (rdata->cfile->invalidHandle) - rc = -EAGAIN ; -else { -#ifdef CONFIG_CIFS_SMB_DIRECT -if (rdata->mr) { - rdata->mr->need_invalidate = true; -smbd_deregister_mr (rdata->mr); - rdata->mr =NULL ; - } -#endif - rc = server->ops->async_readv (rdata); - } - } - -/* If the read was successfully sent, we are done */ -if (!rc) { -/* Add to aio pending list */ -list_add_tail (&rdata->list, rdata_list); -return 0 ; - } - -/* Roll back credits and retry if needed */ -add_credits_and_wake_if (server, &rdata->credits,0 ); - }while (rc == -EAGAIN ); - -fail: -cifs_put_readdata (rdata); -return rc; -} - -static int -cifs_send_async_read (loff_t fpos,size_t len,struct cifsFileInfo *open_file, -struct cifs_sb_info *cifs_sb,struct list_head *rdata_list, -struct cifs_aio_ctx *ctx) -{ -struct cifs_io_subrequest *rdata; -unsigned int nsegs, max_segs =INT_MAX ; -struct cifs_credits credits_on_stack; -struct cifs_credits *credits = &credits_on_stack; -size_t cur_len, max_len, rsize; -int rc; -pid_t pid; -struct TCP_Server_Info *server; - - server =cifs_pick_channel (tlink_tcon (open_file->tlink)->ses); - -#ifdef CONFIG_CIFS_SMB_DIRECT -if (server->smbd_conn) - max_segs = server->smbd_conn->max_frmr_depth; -#endif - -if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_RWPIDFORWARD ) - pid = open_file->pid; -else - pid = current->tgid; - -do { -if (open_file->invalidHandle) { - rc =cifs_reopen_file (open_file, true); -if (rc == -EAGAIN ) -continue ; -else if (rc) -break ; - } - -if (cifs_sb->ctx->rsize ==0 ) - cifs_sb->ctx->rsize = - server->ops->negotiate_rsize (tlink_tcon (open_file->tlink), - cifs_sb->ctx); - - rc = server->ops->wait_mtu_credits (server, cifs_sb->ctx->rsize, - &rsize, credits); -if (rc) -break ; - - max_len =min_t (size_t, len, rsize); - - cur_len =cifs_limit_bvec_subset (&ctx->iter, max_len, - max_segs, &nsegs); -cifs_dbg (FYI ,"read-to-iter len=%zx/%zx nsegs=%u/%lu/%u\n" , - cur_len, max_len, nsegs, ctx->iter.nr_segs, max_segs); -if (cur_len ==0 ) { - rc = -EIO ; -add_credits_and_wake_if (server, credits,0 ); -break ; - } - - rdata =cifs_readdata_alloc (cifs_uncached_readv_complete); -if (!rdata) { -add_credits_and_wake_if (server, credits,0 ); - rc = -ENOMEM ; -break ; - } - - rdata->server = server; - rdata->cfile =cifsFileInfo_get (open_file); - rdata->subreq.start = fpos; - rdata->subreq.len = cur_len; - rdata->pid = pid; - rdata->credits = credits_on_stack; - rdata->ctx = ctx; -kref_get (&ctx->refcount); - - rdata->subreq.io_iter = ctx->iter; -iov_iter_truncate (&rdata->subreq.io_iter, cur_len); - - rc =adjust_credits (server, &rdata->credits, rdata->subreq.len); - -if (!rc) { -if (rdata->cfile->invalidHandle) - rc = -EAGAIN ; -else - rc = server->ops->async_readv (rdata); - } - -if (rc) { -add_credits_and_wake_if (server, &rdata->credits,0 ); -cifs_put_readdata (rdata); -if (rc == -EAGAIN ) -continue ; -break ; - } - -list_add_tail (&rdata->list, rdata_list); -iov_iter_advance (&ctx->iter, cur_len); - fpos += cur_len; - len -= cur_len; - }while (len >0 ); - -return rc; -} - -static void -collect_uncached_read_data (struct cifs_aio_ctx *ctx) -{ -struct cifs_io_subrequest *rdata, *tmp; -struct cifs_sb_info *cifs_sb; -int rc; - - cifs_sb =CIFS_SB (ctx->cfile->dentry->d_sb); - -mutex_lock (&ctx->aio_mutex); - -if (list_empty (&ctx->list)) { -mutex_unlock (&ctx->aio_mutex); -return ; - } - - rc = ctx->rc; -/* the loop below should proceed in the order of increasing offsets */ -again: -list_for_each_entry_safe (rdata, tmp, &ctx->list, list) { -if (!rc) { -if (!try_wait_for_completion (&rdata->done)) { -mutex_unlock (&ctx->aio_mutex); -return ; - } - -if (rdata->result == -EAGAIN ) { -/* resend call if it's a retryable error */ -struct list_head tmp_list; -unsigned int got_bytes = rdata->got_bytes; - -list_del_init (&rdata->list); -INIT_LIST_HEAD (&tmp_list); - -if (ctx->direct_io) { -/* -* Re-use rdata as this is a -* direct I/O -*/ - rc =cifs_resend_rdata ( - rdata, - &tmp_list, ctx); - }else { - rc =cifs_send_async_read ( - rdata->subreq.start + got_bytes, - rdata->subreq.len - got_bytes, - rdata->cfile, cifs_sb, - &tmp_list, ctx); - -cifs_put_readdata (rdata); - } - -list_splice (&tmp_list, &ctx->list); - - goto again; - }else if (rdata->result) - rc = rdata->result; - -/* if there was a short read -- discard anything left */ -if (rdata->got_bytes && rdata->got_bytes < rdata->subreq.len) - rc = -ENODATA ; - - ctx->total_len += rdata->got_bytes; - } -list_del_init (&rdata->list); -cifs_put_readdata (rdata); - } - -/* mask nodata case */ -if (rc == -ENODATA ) - rc =0 ; - - ctx->rc = (rc ==0 ) ? (ssize_t )ctx->total_len : rc; - -mutex_unlock (&ctx->aio_mutex); - -if (ctx->iocb && ctx->iocb->ki_complete) - ctx->iocb->ki_complete (ctx->iocb, ctx->rc); -else -complete (&ctx->done); -} - -static ssize_t __cifs_readv ( -struct kiocb *iocb,struct iov_iter *to,bool direct) -{ -size_t len; -struct file *file = iocb->ki_filp; -struct cifs_sb_info *cifs_sb; -struct cifsFileInfo *cfile; -struct cifs_tcon *tcon; -ssize_t rc, total_read =0 ; -loff_t offset = iocb->ki_pos; -struct cifs_aio_ctx *ctx; - - len =iov_iter_count (to); -if (!len) -return 0 ; - - cifs_sb =CIFS_FILE_SB (file); - cfile = file->private_data; - tcon =tlink_tcon (cfile->tlink); - -if (!tcon->ses->server->ops->async_readv) -return -ENOSYS ; - -if ((file->f_flags &O_ACCMODE ) ==O_WRONLY ) -cifs_dbg (FYI ,"attempting read on write only file instance\n" ); - - ctx =cifs_aio_ctx_alloc (); -if (!ctx) -return -ENOMEM ; - - ctx->pos = offset; - ctx->direct_io = direct; - ctx->len = len; - ctx->cfile =cifsFileInfo_get (cfile); - ctx->nr_pinned_pages =0 ; - -if (!is_sync_kiocb (iocb)) - ctx->iocb = iocb; - -if (user_backed_iter (to)) { -/* -* Extract IOVEC/UBUF-type iterators to a BVEC-type iterator as -* they contain references to the calling process's virtual -* memory layout which won't be available in an async worker -* thread. This also takes a pin on every folio involved. -*/ - rc =netfs_extract_user_iter (to,iov_iter_count (to), - &ctx->iter,0 ); -if (rc <0 ) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return rc; - } - - ctx->nr_pinned_pages = rc; - ctx->bv = (void *)ctx->iter.bvec; - ctx->bv_need_unpin =iov_iter_extract_will_pin (to); - ctx->should_dirty = true; - }else if ((iov_iter_is_bvec (to) ||iov_iter_is_kvec (to)) && - !is_sync_kiocb (iocb)) { -/* -* If the op is asynchronous, we need to copy the list attached -* to a BVEC/KVEC-type iterator, but we assume that the storage -* will be retained by the caller; in any case, we may or may -* not be able to pin the pages, so we don't try. -*/ - ctx->bv = (void *)dup_iter (&ctx->iter, to,GFP_KERNEL ); -if (!ctx->bv) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return -ENOMEM ; - } - }else { -/* -* Otherwise, we just pass the iterator down as-is and rely on -* the caller to make sure the pages referred to by the -* iterator don't evaporate. -*/ - ctx->iter = *to; - } - -if (direct) { - rc =filemap_write_and_wait_range (file->f_inode->i_mapping, - offset, offset + len -1 ); -if (rc) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return -EAGAIN ; - } - } - -/* grab a lock here due to read response handlers can access ctx */ -mutex_lock (&ctx->aio_mutex); - - rc =cifs_send_async_read (offset, len, cfile, cifs_sb, &ctx->list, ctx); - -/* if at least one read request send succeeded, then reset rc */ -if (!list_empty (&ctx->list)) - rc =0 ; - -mutex_unlock (&ctx->aio_mutex); - -if (rc) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return rc; - } - -if (!is_sync_kiocb (iocb)) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return -EIOCBQUEUED ; - } - - rc =wait_for_completion_killable (&ctx->done); -if (rc) { -mutex_lock (&ctx->aio_mutex); - ctx->rc = rc = -EINTR ; - total_read = ctx->total_len; -mutex_unlock (&ctx->aio_mutex); - }else { - rc = ctx->rc; - total_read = ctx->total_len; - } - -kref_put (&ctx->refcount, cifs_aio_ctx_release); - -if (total_read) { - iocb->ki_pos += total_read; -return total_read; - } -return rc; -} - -ssize_t cifs_direct_readv (struct kiocb *iocb,struct iov_iter *to) -{ -return __cifs_readv (iocb, to, true); -} - -ssize_t cifs_user_readv (struct kiocb *iocb,struct iov_iter *to) -{ -return __cifs_readv (iocb, to, false); - -} -#endif // end netfslib removal 4143 -ssize_t cifs_loose_read_iter (struct kiocb *iocb,struct iov_iter *iter) {ssize_t rc;
@@ -3794,101 +2886,6 @@ cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)return rc; } -#if 0 // TODO remove 4633 -static ssize_t -cifs_read (struct file *file,char *read_data,size_t read_size,loff_t *offset) -{ -int rc = -EACCES ; -unsigned int bytes_read =0 ; -unsigned int total_read; -unsigned int current_read_size; -unsigned int rsize; -struct cifs_sb_info *cifs_sb; -struct cifs_tcon *tcon; -struct TCP_Server_Info *server; -unsigned int xid; -char *cur_offset; -struct cifsFileInfo *open_file; -struct cifs_io_parms io_parms = {0 }; -int buf_type =CIFS_NO_BUFFER ; -__u32 pid; - - xid =get_xid (); - cifs_sb =CIFS_FILE_SB (file); - -/* FIXME: set up handlers for larger reads and/or convert to async */ - rsize = min_t(unsigned int, cifs_sb->ctx->rsize, CIFSMaxBufSize); - -if (file->private_data ==NULL ) { - rc = -EBADF ; -free_xid (xid); -return rc; - } - open_file = file->private_data; - tcon =tlink_tcon (open_file->tlink); - server =cifs_pick_channel (tcon->ses); - -if (!server->ops->sync_read) { -free_xid (xid); -return -ENOSYS ; - } - -if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_RWPIDFORWARD ) - pid = open_file->pid; -else - pid = current->tgid; - -if ((file->f_flags &O_ACCMODE ) ==O_WRONLY ) -cifs_dbg (FYI ,"attempting read on write only file instance\n" ); - -for (total_read =0 , cur_offset = read_data; read_size > total_read; - total_read += bytes_read, cur_offset += bytes_read) { -do { - current_read_size =min_t (uint, read_size - total_read, - rsize); -/* -* For windows me and 9x we do not want to request more -* than it negotiated since it will refuse the read -* then. -*/ -if (!(tcon->ses->capabilities & - tcon->ses->server->vals->cap_large_files)) { - current_read_size =min_t (uint, - current_read_size, CIFSMaxBufSize); - } -if (open_file->invalidHandle) { - rc =cifs_reopen_file (open_file, true); -if (rc !=0 ) -break ; - } - io_parms.pid = pid; - io_parms.tcon = tcon; - io_parms.offset = *offset; - io_parms.length = current_read_size; - io_parms.server = server; - rc = server->ops->sync_read (xid, &open_file->fid, &io_parms, - &bytes_read, &cur_offset, - &buf_type); - }while (rc == -EAGAIN ); - -if (rc || (bytes_read ==0 )) { -if (total_read) { -break ; - }else { -free_xid (xid); -return rc; - } - }else { -cifs_stats_bytes_read (tcon, total_read); - *offset += bytes_read; - } - } -free_xid (xid); -return total_read; -} -#endif // end netfslib remove 4633 - -static vm_fault_t cifs_page_mkwrite (struct vm_fault *vmf) {return netfs_page_mkwrite (vmf,NULL );