netfs: Miscellaneous fixes
Subsystems (6)
David Howells
maintainercover netfs: Miscellaneous fixes
Hi Christian,
Here are a couple of miscellaneous fixes for netfslib.
(1) Fix an uninitialised return value from netfs_unbuffered_write().
(2) Fix read progress reporting to avoid 64-bit tearing on a 32-bit machine. This has been modified from the previous submission as part of a different series to take account of a sashiko reported issue[1].
The patches can also be found here:
https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git/log/?h=netfs-fixes
Thanks,
David
[1] https://sashiko.dev/#/patchset/20260810144746.574036-1-dhowells%40redhat.com
David Howells (1):
netfs: Fix read progress reporting
Karl Mehltretter (1):
netfs: Fix uninitialized return value in netfs_unbuffered_write()
fs/netfs/buffered_read.c | 4 +++ fs/netfs/direct_write.c | 2 +- fs/netfs/internal.h | 1 + fs/netfs/objects.c | 32 ++++++++++++-------- fs/netfs/read_collect.c | 58 +++++++++++++++++++++++++++--------- fs/netfs/read_single.c | 2 ++ include/linux/netfs.h | 2 +- include/trace/events/netfs.h | 21 +++++++++++++ 8 files changed, 94 insertions(+), 28 deletions(-)
David Howells
maintainerPATCH 1/2 netfs: Fix uninitialized return value in netfs_unbuffered_write()
From: Karl Mehltretter <[email protected]>
If preparation of the first subrequest fails, netfs_unbuffered_write() exits its loop before ret is initialized. The empty-iterator check can do the same.
For synchronous writes, netfs_unbuffered_write_iter_locked() may then return an unrelated error instead of wreq->error. This is reachable through CIFS if cifs_prepare_write() fails to reopen the file or obtain credits.
Initialize ret to 0 so the caller returns wreq->error if no data was written, or the number of bytes already written otherwise.
Found with Clang's -Wconditional-uninitialized.
--- fs/netfs/direct_write.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/netfs/direct_write.c +1 -1
@@ -95,7 +95,7 @@ static int netfs_unbuffered_write(struct netfs_io_request *wreq) {struct netfs_io_subrequest *subreq =NULL ;struct netfs_io_stream *stream = &wreq->io_streams[0 ]; -int ret; +int ret =0 ;_enter ("%llx" , wreq->len);
David Howells
maintainerPATCH 2/2 netfs: Fix read progress reporting
In reply to David HowellsFor really big read RPC ops that span multiple folios, netfslib allows the filesystem to give progress notifications to wake up the collector thread to do a collection of folios that have now been fetched, even if the RPC is still ongoing, thereby allowing the application to make progress.
This works by taking the current rreq->cleaned_to value (which indicates which folios have been unlocked) and adding the stashed size of the next folio to it. cleaned_to, however, is subject to 64-bit tearing on a 32-bit arch.
Fix this by stashing the next progress notification point as a size_t (which won't tear) to be added to rreq->start (which won't change), with the collector thread calculating that from cleaned_to plus the next folio size.
Further, however, if the folios are small, the collector thread gets constantly woken up - which has a negative performance impact on the system.
Fix that too by setting a minimum trigger of 256KiB or the size of the folio at the front of the queue, whichever is larger.
Also, make sure rreq->cleaned_to is initialised up front, along with rreq->collected_to and stream->collected_to.
--- fs/netfs/buffered_read.c | 4 +++ fs/netfs/internal.h | 1 + fs/netfs/objects.c | 32 ++++++++++++-------- fs/netfs/read_collect.c | 58 +++++++++++++++++++++++++++--------- fs/netfs/read_single.c | 2 ++ include/linux/netfs.h | 2 +- include/trace/events/netfs.h | 21 +++++++++++++ 7 files changed, 93 insertions(+), 27 deletions(-)
fs/netfs/buffered_read.c +4 -0
@@ -106,6 +106,9 @@ static ssize_t netfs_prepare_read_iterator(struct netfs_io_subrequest *subreq,folio_batch_release (&put_batch);return added; } + +if (!rreq->progress_at) +netfs_read_set_unlock_at (rreq); rreq->submitted += added; }folio_batch_release (&put_batch);
@@ -387,6 +390,7 @@ static int netfs_create_singular_buffer(struct netfs_io_request *rreq, struct foif (added <0 )return added; rreq->submitted = rreq->start + added; + rreq->progress_at = added;return 0 ; }
fs/netfs/internal.h +1 -0
@@ -109,6 +109,7 @@ static inline void netfs_see_subrequest(struct netfs_io_subrequest *subreq,/* * read_collect.c */ +void netfs_read_set_unlock_at (struct netfs_io_request *rreq);bool netfs_read_collection (struct netfs_io_request *rreq);void netfs_read_collection_worker (struct work_struct *work);void netfs_cancel_read (struct netfs_io_subrequest *subreq,int error);
fs/netfs/objects.c +20 -12
@@ -41,24 +41,32 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,memset (rreq,0 ,kmem_cache_size (cache));INIT_WORK (&rreq->cleanup_work, netfs_free_request); - rreq->gfp = gfp; - rreq->start = start; - rreq->len = len; - rreq->origin = origin; - rreq->netfs_ops = ctx->ops; - rreq->mapping = mapping; - rreq->inode = inode; - rreq->i_size =i_size_read (inode); - rreq->debug_id =atomic_inc_return (&debug_ids); - rreq->wsize =INT_MAX ; + rreq->gfp = gfp; + rreq->start = start; + rreq->collected_to = start; + rreq->cleaned_to = start; + rreq->len = len; + rreq->progress_at =0 ; + rreq->origin = origin; + rreq->netfs_ops = ctx->ops; + rreq->mapping = mapping; + rreq->inode = inode; + rreq->i_size =i_size_read (inode); + rreq->debug_id =atomic_inc_return (&debug_ids); + rreq->wsize =INT_MAX ; rreq->io_streams[0 ].sreq_max_len =ULONG_MAX ; rreq->io_streams[0 ].sreq_max_segs =0 ;spin_lock_init (&rreq->lock); -INIT_LIST_HEAD (&rreq->io_streams[0 ].subrequests); -INIT_LIST_HEAD (&rreq->io_streams[1 ].subrequests);init_waitqueue_head (&rreq->waitq);refcount_set (&rreq->ref,2 ); +for (int s =0 ; s <NR_IO_STREAMS ; s++) { +struct netfs_io_stream *stream = &rreq->io_streams[s]; + +INIT_LIST_HEAD (&stream->subrequests); + stream->collected_to = rreq->start; + } + if (origin == NETFS_READAHEAD || origin == NETFS_READPAGE || origin == NETFS_READ_GAPS ||
fs/netfs/read_collect.c +44 -14
121 lines not on this page · raw message
fs/netfs/read_single.c +2 -0
@@ -170,6 +170,8 @@ ssize_t netfs_read_single(struct inode *inode, struct file *file, struct iov_iteif (IS_ERR (rreq))return PTR_ERR (rreq); + rreq->progress_at = rreq->len; + ret =netfs_single_begin_cache_read (rreq, ictx);if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) goto cleanup_free;
include/linux/netfs.h +1 -1
@@ -247,6 +247,7 @@ struct netfs_io_request {unsigned long long submitted;/* Amount submitted for I/O so far */ unsigned long long len;/* Length of the request */ size_t transferred;/* Amount to be indicated as transferred */ +size_t progress_at;/* Report read progress when hit this much read */ long error;/* 0 or error that occurred */ unsigned long long i_size;/* Size of the file */ unsigned long long start;/* Start position */
@@ -263,7 +264,6 @@ struct netfs_io_request {atomic_t subreq_counter;/* Next subreq->debug_index */ unsigned int nr_group_rel;/* Number of refs to release on ->group */ spinlock_t lock;/* Lock for queuing subreqs */ -unsigned char front_folio_order;/* Order (size) of front folio */ enum netfs_io_origin origin;/* Origin of the request */ bool direct_bv_unpin;/* T if direct_bv[] must be unpinned */ refcount_t ref;
include/trace/events/netfs.h +21 -0
@@ -786,6 +786,27 @@ TRACE_EVENT(netfs_folioq, __print_symbolic(__entry->trace, netfs_folioq_traces)) ); +TRACE_EVENT (netfs_read_progress_at, + TP_PROTO(const struct netfs_io_request *rreq), + +TP_ARGS (rreq), + +TP_STRUCT__entry ( + __field(unsigned int, rreq) + __field(size_t, progress_at) +__field (size_t, cleaned_to) + ), + +TP_fast_assign ( + __entry->rreq = rreq->debug_id; + __entry->cleaned_to = rreq->cleaned_to - rreq->start; + __entry->progress_at = rreq->progress_at; + ), + +TP_printk ("R=%08x cln=%zx prg=%zx" , + __entry->rreq, __entry->cleaned_to, __entry->progress_at) + ); +#undef EM#undef E_#endif /* _TRACE_NETFS_H */