netfs: Miscellaneous fixes
Subsystems (8)
David Howells
maintainerv6 cover netfs: Miscellaneous fixes
Hi Christian,
Here are the outstanding miscellaneous fixes for netfslib gathered together and with some fixes-to-fixes folded down and one rearrangement. Various Sashiko review comments[1][2][3][4][5] are addressed:
(1) Fix subrequest cancellation cleanup in DIO read and single-read.
(2) Fix missing locking around retry adding new subrequests.
(3) Fix read and write result collection to use barriering correctly to access a request's subrequest lists without taking a lock.
This adds list_add_tail_release() and list_first_entry_or_null_acquire() to appropriate incorporate barriering into some list functions.
(4) Fix netfs_read_to_pagecache() to pause on subrequest I/O failure.
(5) Fix the potential for 64-bit tearing on a 32-bit machine when reading
netfs_inode->remote_i_size and ->zero_point by using much the same
mechanism as is used for ->i_size. (6) Fix the calculation of zero_point in netfs_release_folio() to limit it
to ->remote_i_size, not ->i_size.
(7) Fix triggering of a VM_BUG_ON_FOLIO() in netfs_write_begin().
(8) Fix a potentially uninitialised error value in netfs_extract_user_iter().
(9) Fix error handling in netfs_extract_user_iter().
(10) Fix overrun checking in netfs_extract_user_iter().
(11) Fix netfs_invalidate_folio() to clear the folio dirty bit if all dirty data removed.
(12) Defer the emission of trace_netfs_folio() in netfs_perform_write(). This allows the next patch to emit the correct traces.
(13) Fix the handling of a partially failed copy (ie. EFAULT) into a streaming write folio. Also remove the netfs_folio if a streaming write folio is entirely overwritten.
(14) Fix a potential deadlock in writethrough writing.
(15) Fix netfs_read_gaps() to remove the netfs_folio from a filled folio.
(16) Fix netfs_perform_write() to not disable streaming writes when writing to an fd that's open O_RDWR.
(17) Fix an early put of the sink page used in netfs_read_gaps(), before the request has completed.
(18) Fix request leak in netfs_write_begin() error handling.
(19) Fix a potential UAF in netfs_unlock_abandoned_read_pages() due to trying to check index of each folio we're abandoning to see if that folio is actually owned by the caller (in which case, we're not actually allowed to dereference it).
(20) Fix incorrect adjustment of dirty region when partially invalidating a streaming write folio.
(21) Fix the handling of folio->private in netfs_perform_write() and the attached netfs_folio and/or group when a streaming write folio is modified.
(22) Fix netfs_read_folio() to wait on writeback first (it holds the folio lock) otherwise we aren't allowed to look at the netfs_folio struct as that could be modified at any time by the writeback collector.
(23) Fix write skipping in dir/symlink writepages.
(24) Fix the locking used by afs_get_link().
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/20260414082004.3756080-1-dhowells%40redhat.com
[2] https://sashiko.dev/#/patchset/20260326104544.509518-1-dhowells%40redhat.com
[3] https://sashiko.dev/#/patchset/20260425125426.3855807-1-dhowells%40redhat.com
[4] https://sashiko.dev/#/patchset/20260427154639.180684-1-dhowells%40redhat.com
[5] https://sashiko.dev/#/patchset/20260428131756.922303-1-dhowells%40redhat.com
Changes
=======
ver #6)
- Fix more Sashiko issues[5].
- Handle another missed cancellation in netfs_read_to_pagecache().
- Made sure that all updates of i_size within netfslib, 9p, afs and cifs are done with i_lock held to prevent i_size_seqcount getting corrupted if remote_i_size or zero_point are updated.
- In netfs_perform_write(), make it so that in write-through mode the modified folios aren't put into writeback mode until each is completed to prevent races with mmap.
- In netfs_perform_write(), annotate the conditions under which group differences cause a folio to be flushed and warn if the filesystem mixes no-group (ie. NULL) with groups.
- In afs_evict_symlink(), avoid a lockdep splat due to not holding any locks when doing an RCU op.
- In afs_init_new_symlink(), don't access an __rcu pointer directly.
- In afs_do_read_symlink(), use the size returned by netfs_read_single() rather than i_size as the size of the symlink content.
- In afs_symlink_writepages(), avoid a double free.
- In afs_validate(), make sure we don't call afs_invalidate_symlink() on a directory.
ver #5)
- Fix more Sashiko issues[4].
- Handle missed cancellations in netfs_read_to_pagecache().
- Fixed potential double dio-end/put if no subreqs were submitted in dio read.
- In netfs_single_dispatch_read(), cancellation needs to set ALL_QUEUED and invoke the collector.
- In read/write retry, lock around deletion of subreqs also.
- Renamed list_first_entry_acquire() to list_first_entry_or_null_acquire().
- In netfs_push_back_zero_point(), fix use of cmpxchg().
- Provide netfs_write_remote_i_size_locked() that can be used by a func
holding inode->i_lock (e.g. cifs_fattr_to_inode()).
- In netfs_extract_user_iter(), improved overrun checking.
- Added a patch to fix a potential deadlock with write-through writes.
- In netfs_page_mkwrite(), skip the flush if no group set on the folio.
- In the single-write users, mark the inode dirty again if a contended lock was skipped due to WB_SYNC_NONE.
ver #4)
- Rebase on v7.0-rc1
- Fix more Sashiko issues[3].
- Move the ->subrequests barriering patch up front as it modifies linux/list.h.
- Split that barriering patch and make the first patch to harmonise the order of adding a read subreq to the queue, for buffered, dio and single reads and to fix cancellation on prep failure. The second patch then fixes the barriering.
- Lock ->subrequests in retry when adding in extra subreqs.
- Use a spinlock as well when modifying ->zero_point with a seq lock.
- Atomically check and change ->zero_point when bumping it up.
- Merged the two patches sorting out the locking in afs symlink handling, then fixed a number of issues in them.
- Added a patch to make afs dir and symlink writepages skip if the validate_lock is held and WB_SYNC_NONE is set.
ver #3)
- Rebase on linus/master.
- Consolidate the various sets of fixes for reposting.
- Fold down fixes-to-fixes.
- Move the tracing change in netfs_perform_write() down to below the patch it primarily affects.
base-commit: 5d6919055dec134de3c40167a490f33c74c12581
David Howells (22):
netfs: Fix cancellation of a DIO and single read subrequests
netfs: Fix missing locking around retry adding new subreqs
netfs: Fix missing barriers when accessing stream->subrequests
locklessly
netfs: Fix netfs_read_to_pagecache() to pause on subreq failure
netfs: Fix potential for tearing in ->remote_i_size and ->zero_point
netfs: Fix zeropoint update where i_size > remote_i_size
netfs: Fix potential uninitialised var in netfs_extract_user_iter()
netfs: Fix overrun check in netfs_extract_user_iter()
netfs: Fix netfs_invalidate_folio() to clear dirty bit if all changes
gone
netfs: Defer the emission of trace_netfs_folio()
netfs: Fix streaming write being overwritten
netfs: Fix potential deadlock in write-through mode
netfs: Fix read-gaps to remove netfs_folio from filled folio
netfs: Fix write streaming disablement if fd open O_RDWR
netfs: Fix early put of sink folio in netfs_read_gaps()
netfs: Fix leak of request in netfs_write_begin() error handling
netfs: Fix potential UAF in netfs_unlock_abandoned_read_pages()
netfs: Fix partial invalidation of streaming-write folio
netfs: Fix folio->private handling in netfs_perform_write()
netfs: Fix netfs_read_folio() to wait on writeback
netfs, afs: Fix write skipping in dir/link writepages
afs: Fix the locking used by afs_get_link()
Paulo Alcantara (1):
netfs: fix error handling in netfs_extract_user_iter()
Viacheslav Dubeyko (1):
netfs: fix VM_BUG_ON_FOLIO() issue in netfs_write_begin() call
fs/9p/v9fs_vfs.h | 13 -- fs/9p/vfs_inode.c | 6 +- fs/9p/vfs_inode_dotl.c | 12 +- fs/afs/Makefile | 1 + fs/afs/dir.c | 79 +++++----- fs/afs/file.c | 24 ++- fs/afs/fsclient.c | 4 +- fs/afs/inode.c | 127 +++------------ fs/afs/internal.h | 45 +++--- fs/afs/symlink.c | 278 +++++++++++++++++++++++++++++++++ fs/afs/validation.c | 14 +- fs/afs/write.c | 2 +- fs/afs/yfsclient.c | 4 +- fs/netfs/buffered_read.c | 73 +++++---- fs/netfs/buffered_write.c | 174 +++++++++++++-------- fs/netfs/direct_read.c | 42 ++--- fs/netfs/direct_write.c | 6 +- fs/netfs/internal.h | 3 + fs/netfs/iterator.c | 41 +++-- fs/netfs/misc.c | 41 +++-- fs/netfs/read_collect.c | 19 ++- fs/netfs/read_retry.c | 17 +- fs/netfs/read_single.c | 23 ++- fs/netfs/write_collect.c | 15 +- fs/netfs/write_issue.c | 49 ++++-- fs/netfs/write_retry.c | 6 +- fs/smb/client/cifsfs.c | 38 +++-- fs/smb/client/cifssmb.c | 3 +- fs/smb/client/file.c | 13 +- fs/smb/client/inode.c | 14 +- fs/smb/client/readdir.c | 3 +- fs/smb/client/smb2ops.c | 42 +++-- fs/smb/client/smb2pdu.c | 3 +- include/linux/list.h | 37 +++++ include/linux/netfs.h | 295 +++++++++++++++++++++++++++++++++-- include/trace/events/netfs.h | 8 + 36 files changed, 1142 insertions(+), 432 deletions(-) create mode 100644 fs/afs/symlink.c
David Howells
maintainerPATCH v6 1/24 netfs: Fix cancellation of a DIO and single read subrequests
When the preparation of a new subrequest for a read fails, if the subrequest has already been added to the stream->subrequests list, it can't simply be put and abandoned as the collector may see it. Also, if it hasn't been queued yet, it has two outstanding refs that both need to be put. Both DIO read and single-read dispatch fail at this; further, both differ in the order they do things to the way buffered read works.
Fix cancellation of both DIO-read and single-read subrequests that failed preparation by the following steps:
(1) Harmonise all three reads (buffered, dio, single) to queue the subreq before prepping it.
(2) Make all three call netfs_queue_read() to do the queuing.
(3) Set NETFS_RREQ_ALL_QUEUED independently of the queuing as we don't know the length of the subreq at this point.
(4) In all cases, set the error and NETFS_SREQ_FAILED flag on the subreq and then call netfs_read_subreq_terminated() to deal with it. This will pass responsibility off to the collector for dealing with it.
--- fs/netfs/buffered_read.c | 34 +++++++++++++------------------- fs/netfs/direct_read.c | 42 +++++++++++++--------------------------- fs/netfs/internal.h | 3 +++ fs/netfs/read_collect.c | 11 +++++++++++ fs/netfs/read_single.c | 23 ++++++++++------------ 5 files changed, 50 insertions(+), 63 deletions(-)
fs/netfs/buffered_read.c +13 -21
@@ -156,9 +156,8 @@ static void netfs_read_cache_to_pagecache(struct netfs_io_request *rreq, netfs_cache_read_terminated, subreq); } -static void netfs_queue_read (struct netfs_io_request *rreq, -struct netfs_io_subrequest *subreq, -bool last_subreq) +void netfs_queue_read (struct netfs_io_request *rreq, +struct netfs_io_subrequest *subreq) {struct netfs_io_stream *stream = &rreq->io_streams[0 ];
@@ -178,11 +177,6 @@ static void netfs_queue_read(struct netfs_io_request *rreq, } } -if (last_subreq) { -smp_wmb ();/* Write lists before ALL_QUEUED. */ -set_bit (NETFS_RREQ_ALL_QUEUED , &rreq->flags); - } -spin_unlock (&rreq->lock); }
@@ -233,6 +227,8 @@ static void netfs_read_to_pagecache(struct netfs_io_request *rreq, subreq->start = start; subreq->len = size; +netfs_queue_read (rreq, subreq); + source =netfs_cache_prepare_read (rreq, subreq, rreq->i_size); subreq->source = source;if (source ==NETFS_DOWNLOAD_FROM_SERVER ) {
@@ -253,6 +249,7 @@ static void netfs_read_to_pagecache(struct netfs_io_request *rreq, rreq->debug_id, subreq->debug_index, subreq->len, size, subreq->start, ictx->zero_point, rreq->i_size); +netfs_cancel_read (subreq, ret);break ; } subreq->len = len;
@@ -261,12 +258,7 @@ static void netfs_read_to_pagecache(struct netfs_io_request *rreq,if (rreq->netfs_ops->prepare_read) { ret = rreq->netfs_ops->prepare_read (subreq);if (ret <0 ) { - subreq->error = ret; -/* Not queued - release both refs. */ -netfs_put_subrequest (subreq, - netfs_sreq_trace_put_cancel); -netfs_put_subrequest (subreq, - netfs_sreq_trace_put_cancel); +netfs_cancel_read (subreq, ret);break ; }trace_netfs_sreq (subreq, netfs_sreq_trace_prepare);
@@ -289,23 +281,23 @@ static void netfs_read_to_pagecache(struct netfs_io_request *rreq,pr_err ("Unexpected read source %u\n" , source);WARN_ON_ONCE (1 ); +netfs_cancel_read (subreq, ret);break ; issue: slice =netfs_prepare_read_iterator (subreq, ractl);if (slice <0 ) { ret = slice; - subreq->error = ret; -trace_netfs_sreq (subreq, netfs_sreq_trace_cancel); -/* Not queued - release both refs. */ -netfs_put_subrequest (subreq, netfs_sreq_trace_put_cancel); -netfs_put_subrequest (subreq, netfs_sreq_trace_put_cancel); +netfs_cancel_read (subreq, ret);break ; } - size -= slice; start += slice; + size -= slice; +if (size <=0 ) { +smp_wmb ();/* Write lists before ALL_QUEUED. */ +set_bit (NETFS_RREQ_ALL_QUEUED , &rreq->flags); + } -netfs_queue_read (rreq, subreq, size <=0 );netfs_issue_read (rreq, subreq);cond_resched (); }while (size >0 );
fs/netfs/direct_read.c +13 -29
86 lines not on this page · raw message
fs/netfs/internal.h +3 -0
@@ -23,6 +23,8 @@/* * buffered_read.c */ +void netfs_queue_read (struct netfs_io_request *rreq, +struct netfs_io_subrequest *subreq);void netfs_cache_read_terminated (void *priv,ssize_t transferred_or_error);int netfs_prefetch_for_write (struct file *file,struct folio *folio,size_t offset,size_t len);
@@ -108,6 +110,7 @@ static inline void netfs_see_subrequest(struct netfs_io_subrequest *subreq,*/ 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);void netfs_cache_read_terminated (void *priv,ssize_t transferred_or_error);/*
fs/netfs/read_collect.c +11 -0
@@ -575,6 +575,17 @@ void netfs_read_subreq_terminated(struct netfs_io_subrequest *subreq) }EXPORT_SYMBOL (netfs_read_subreq_terminated); +/* +* Cancel a read subrequest due to preparation failure. +*/ +void netfs_cancel_read (struct netfs_io_subrequest *subreq,int error) +{ +trace_netfs_sreq (subreq, netfs_sreq_trace_cancel); + subreq->error = error; +__set_bit (NETFS_SREQ_FAILED , &subreq->flags); +netfs_read_subreq_terminated (subreq); +} +/* * Handle termination of a read from the cache. */
fs/netfs/read_single.c +10 -13
@@ -89,7 +89,6 @@ static void netfs_single_read_cache(struct netfs_io_request *rreq,*/ static int netfs_single_dispatch_read (struct netfs_io_request *rreq) { -struct netfs_io_stream *stream = &rreq->io_streams[0 ];struct netfs_io_subrequest *subreq;int ret =0 ;
@@ -102,14 +101,7 @@ static int netfs_single_dispatch_read(struct netfs_io_request *rreq) subreq->len = rreq->len; subreq->io_iter = rreq->buffer.iter; -__set_bit (NETFS_SREQ_IN_PROGRESS , &subreq->flags); - -spin_lock (&rreq->lock); -list_add_tail (&subreq->rreq_link, &stream->subrequests); -trace_netfs_sreq (subreq, netfs_sreq_trace_added); -/* Store list pointers before active flag */ -smp_store_release (&stream->active, true); -spin_unlock (&rreq->lock); +netfs_queue_read (rreq, subreq);netfs_single_cache_prepare_read (rreq, subreq);switch (subreq->source) {
@@ -121,10 +113,14 @@ static int netfs_single_dispatch_read(struct netfs_io_request *rreq) goto cancel; } +smp_wmb ();/* Write lists before ALL_QUEUED. */ +set_bit (NETFS_RREQ_ALL_QUEUED , &rreq->flags); rreq->netfs_ops->issue_read (subreq); rreq->submitted += subreq->len;break ;case NETFS_READ_FROM_CACHE : +smp_wmb ();/* Write lists before ALL_QUEUED. */ +set_bit (NETFS_RREQ_ALL_QUEUED , &rreq->flags);trace_netfs_sreq (subreq, netfs_sreq_trace_submit);netfs_single_read_cache (rreq, subreq); rreq->submitted += subreq->len;
@@ -134,14 +130,15 @@ static int netfs_single_dispatch_read(struct netfs_io_request *rreq)pr_warn ("Unexpected single-read source %u\n" , subreq->source);WARN_ON_ONCE (true); ret = -EIO ; -break ; + goto cancel; } -smp_wmb ();/* Write lists before ALL_QUEUED. */ -set_bit (NETFS_RREQ_ALL_QUEUED , &rreq->flags);return ret; cancel: -netfs_put_subrequest (subreq, netfs_sreq_trace_put_cancel); +netfs_cancel_read (subreq, ret); +smp_wmb ();/* Write lists before ALL_QUEUED. */ +set_bit (NETFS_RREQ_ALL_QUEUED , &rreq->flags); +netfs_wake_collector (rreq);return ret; }
David Howells
maintainerPATCH v6 2/24 netfs: Fix missing locking around retry adding new subreqs
In reply to David HowellsFix netfs_retry_read_subrequests() and netfs_retry_write_stream() to take the appropriate lock when adding extra subrequests into stream->subrequests.
--- fs/netfs/read_retry.c | 6 +++++- fs/netfs/write_retry.c | 6 +++++- 2 files changed, 10 insertions(+), 2 deletions(-)
fs/netfs/read_retry.c +5 -1
@@ -175,7 +175,9 @@ static void netfs_retry_read_subrequests(struct netfs_io_request *rreq)list_for_each_entry_safe_from (subreq, tmp, &stream->subrequests, rreq_link) {trace_netfs_sreq (subreq, netfs_sreq_trace_superfluous); +spin_lock (&rreq->lock);list_del (&subreq->rreq_link); +spin_unlock (&rreq->lock);netfs_put_subrequest (subreq, netfs_sreq_trace_put_done);if (subreq == to)break ;
@@ -203,8 +205,10 @@ static void netfs_retry_read_subrequests(struct netfs_io_request *rreq)refcount_read (&subreq->ref), netfs_sreq_trace_new); +spin_lock (&rreq->lock);list_add (&subreq->rreq_link, &to->rreq_link); - to =list_next_entry (to, rreq_link); +spin_unlock (&rreq->lock); + to = subreq;trace_netfs_sreq (subreq, netfs_sreq_trace_retry); stream->sreq_max_len =umin (len, rreq->rsize);
fs/netfs/write_retry.c +5 -1
@@ -130,7 +130,9 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq,list_for_each_entry_safe_from (subreq, tmp, &stream->subrequests, rreq_link) {trace_netfs_sreq (subreq, netfs_sreq_trace_discard); +spin_lock (&wreq->lock);list_del (&subreq->rreq_link); +spin_unlock (&wreq->lock);netfs_put_subrequest (subreq, netfs_sreq_trace_put_done);if (subreq == to)break ;
@@ -153,8 +155,10 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq, netfs_sreq_trace_new);trace_netfs_sreq (subreq, netfs_sreq_trace_split); +spin_lock (&wreq->lock);list_add (&subreq->rreq_link, &to->rreq_link); - to =list_next_entry (to, rreq_link); +spin_unlock (&wreq->lock); + to = subreq;trace_netfs_sreq (subreq, netfs_sreq_trace_retry); stream->sreq_max_len = len;
David Howells
maintainerPATCH v6 3/24 netfs: Fix missing barriers when accessing stream->subrequests locklessly
In reply to David HowellsThe list of subrequests attached to stream->subrequests is accessed without locks by netfs_collect_read_results() and netfs_collect_write_results(), and then they access subreq->flags without taking a barrier after getting the subreq pointer from the list. Relatedly, the functions that build the list don't use any sort of write barrier when constructing the list to make sure that the NETFS_SREQ_IN_PROGRESS flag is perceived to be set first if no lock is taken.
Fix this by:
(1) Add a new list_add_tail_release() function that uses a release barrier to set the pointer to the new member of the list.
(2) Add a new list_first_entry_or_null_acquire() function that uses an acquire barrier to read the pointer to the first member in a list (or return NULL).
(3) Use list_add_tail_release() when adding a subreq to ->subrequests.
(4) Use list_first_entry_or_null_acquire() when initially accessing the front of the list (when an item is removed, the pointer to the new front iterm is obtained under the same lock).
--- fs/netfs/buffered_read.c | 3 ++- fs/netfs/misc.c | 1 + fs/netfs/read_collect.c | 6 ++++-- fs/netfs/write_collect.c | 6 ++++-- fs/netfs/write_issue.c | 3 ++- include/linux/list.h | 37 +++++++++++++++++++++++++++++++++++++ 6 files changed, 50 insertions(+), 6 deletions(-)
fs/netfs/buffered_read.c +2 -1
@@ -168,7 +168,8 @@ void netfs_queue_read(struct netfs_io_request *rreq,* remove entries off of the front. */ spin_lock (&rreq->lock); -list_add_tail (&subreq->rreq_link, &stream->subrequests); +/* Write IN_PROGRESS before pointer to new subreq */ +list_add_tail_release (&subreq->rreq_link, &stream->subrequests);if (list_is_first (&subreq->rreq_link, &stream->subrequests)) {if (!stream->active) { stream->collected_to = subreq->start;
fs/netfs/misc.c +1 -0
@@ -356,6 +356,7 @@ void netfs_wait_for_in_progress_stream(struct netfs_io_request *rreq,DEFINE_WAIT (myself);list_for_each_entry (subreq, &stream->subrequests, rreq_link) { +smp_rmb ();/* Read ->next before IN_PROGRESS. */ if (!netfs_check_subreq_in_progress (subreq))continue ;
fs/netfs/read_collect.c +4 -2
@@ -205,8 +205,10 @@ static void netfs_collect_read_results(struct netfs_io_request *rreq)* in progress. The issuer thread may be adding stuff to the tail * whilst we're doing this. */ - front =list_first_entry_or_null (&stream->subrequests, - struct netfs_io_subrequest, rreq_link); + front =list_first_entry_or_null_acquire (&stream->subrequests, + struct netfs_io_subrequest, rreq_link); +/* Read first subreq pointer before IN_PROGRESS flag. */ +while (front) {size_t transferred;
fs/netfs/write_collect.c +4 -2
@@ -228,8 +228,10 @@ static void netfs_collect_write_results(struct netfs_io_request *wreq)if (!smp_load_acquire (&stream->active))continue ; - front =list_first_entry_or_null (&stream->subrequests, - struct netfs_io_subrequest, rreq_link); + front =list_first_entry_or_null_acquire (&stream->subrequests, + struct netfs_io_subrequest, rreq_link); +/* Read first subreq pointer before IN_PROGRESS flag. */ +while (front) {trace_netfs_collect_sreq (wreq, front);//_debug("sreq [%x] %llx %zx/%zx",
fs/netfs/write_issue.c +2 -1
@@ -204,7 +204,8 @@ void netfs_prepare_write(struct netfs_io_request *wreq,* remove entries off of the front. */ spin_lock (&wreq->lock); -list_add_tail (&subreq->rreq_link, &stream->subrequests); +/* Write IN_PROGRESS before pointer to new subreq */ +list_add_tail_release (&subreq->rreq_link, &stream->subrequests);if (list_is_first (&subreq->rreq_link, &stream->subrequests)) {if (!stream->active) { stream->collected_to = subreq->start;
include/linux/list.h +37 -0
@@ -191,6 +191,29 @@ static inline void list_add_tail(struct list_head *new, struct list_head *head)__list_add (new, head->prev, head); } +/** +* list_add_tail_release - add a new entry with release barrier +* @new: new entry to be added +* @head: list head to add it before +* +* Insert a new entry before the specified head, using a release barrier to set +* the ->next pointer that points to it. This is useful for implementing +* queues, in particular one that the elements will be walked through forwards +* locklessly. +*/ +static inline void list_add_tail_release (struct list_head *new, +struct list_head *head) +{ +struct list_head *prev = head->prev; + +if (__list_add_valid (new, prev, head)) { + new->next = head; + new->prev = prev; + head->prev = new; +smp_store_release (&prev->next, new); + } +} +/* * Delete a list entry by making the prev/next entries * point to each other.
@@ -644,6 +667,20 @@ static inline void list_splice_tail_init(struct list_head *list, pos__ != head__ ?list_entry (pos__, type, member) :NULL ; \ }) +/** +* list_first_entry_or_null_acquire - get the first element from a list with barrier +* @ptr: the list head to take the element from. +* @type: the type of the struct this is embedded in. +* @member: the name of the list_head within the struct. +* +* Note that if the list is empty, it returns NULL. +*/ +#define list_first_entry_or_null_acquire (ptr, type, member) ({ \ + struct list_head *head__ = (ptr); \ + struct list_head *pos__ = smp_load_acquire(&head__->next); \ + pos__ != head__ ? list_entry(pos__, type, member) : NULL; \ +}) +/** * list_last_entry_or_null - get the last element from a list * @ptr: the list head to take the element from.
David Howells
maintainerPATCH v6 4/24 netfs: Fix netfs_read_to_pagecache() to pause on subreq failure
In reply to David HowellsFix netfs_read_to_pagecache() so that it pauses the generation of new subrequests if an already-issued subrequest fails.
--- fs/netfs/buffered_read.c | 5 +++++ 1 file changed, 5 insertions(+)
fs/netfs/buffered_read.c +5 -0
@@ -300,6 +300,11 @@ static void netfs_read_to_pagecache(struct netfs_io_request *rreq, }netfs_issue_read (rreq, subreq); + +if (test_bit (NETFS_RREQ_PAUSE , &rreq->flags)) +netfs_wait_for_paused_read (rreq); +if (test_bit (NETFS_RREQ_FAILED , &rreq->flags)) +break ;cond_resched (); }while (size >0 );
David Howells
maintainerPATCH v6 5/24 netfs: Fix potential for tearing in ->remote_i_size and ->zero_point
In reply to David HowellsFix potential tearing in using ->remote_i_size and ->zero_point by copying i_size_read() and i_size_write() and using the same seqcount as for i_size.
We need to make sure that netfslib and the filesystems that use it always hold i_lock whilst updating any of the sizes to prevent i_size_seqcount from getting corrupted.
--- fs/9p/v9fs_vfs.h | 13 -- fs/9p/vfs_inode.c | 6 +- fs/9p/vfs_inode_dotl.c | 12 +- fs/afs/file.c | 24 +++- fs/afs/inode.c | 31 ++-- fs/afs/internal.h | 11 +- fs/afs/write.c | 2 +- fs/netfs/buffered_read.c | 6 +- fs/netfs/buffered_write.c | 2 +- fs/netfs/direct_write.c | 6 +- fs/netfs/misc.c | 32 +++-- fs/netfs/write_collect.c | 9 +- fs/smb/client/cifsfs.c | 38 +++-- fs/smb/client/cifssmb.c | 3 +- fs/smb/client/file.c | 13 +- fs/smb/client/inode.c | 14 +- fs/smb/client/readdir.c | 3 +- fs/smb/client/smb2ops.c | 42 +++--- fs/smb/client/smb2pdu.c | 3 +- include/linux/netfs.h | 293 ++++++++++++++++++++++++++++++++++++-- 20 files changed, 450 insertions(+), 113 deletions(-)
fs/9p/v9fs_vfs.h +0 -13
@@ -75,17 +75,4 @@ static inline void v9fs_invalidate_inode_attr(struct inode *inode)int v9fs_open_to_dotl_flags (int flags); -static inline void v9fs_i_size_write (struct inode *inode,loff_t i_size) -{ -/* -* 32-bit need the lock, concurrent updates could break the -* sequences and make i_size_read() loop forever. -* 64-bit updates are atomic and can skip the locking. -*/ -if (sizeof (i_size) >sizeof (long )) -spin_lock (&inode->i_lock); -i_size_write (inode, i_size); -if (sizeof (i_size) >sizeof (long )) -spin_unlock (&inode->i_lock); -}#endif
fs/9p/vfs_inode.c +4 -2
@@ -1141,11 +1141,13 @@ v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode, mode |= inode->i_mode & ~S_IALLUGO ; inode->i_mode = mode; - v9inode->netfs.remote_i_size = stat->length; +spin_lock (&inode->i_lock); +netfs_write_remote_i_size (inode, stat->length);if (!(flags &V9FS_STAT2INODE_KEEP_ISIZE )) -v9fs_i_size_write (inode, stat->length); +i_size_write (inode, stat->length);/* not real number of blocks, but 512 byte ones ... */ inode->i_blocks = (stat->length +512 -1 ) >>9 ; +spin_unlock (&inode->i_lock); v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR ; }
fs/9p/vfs_inode_dotl.c +8 -4
@@ -634,10 +634,12 @@ v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode, mode |= inode->i_mode & ~S_IALLUGO ; inode->i_mode = mode; - v9inode->netfs.remote_i_size = stat->st_size; +spin_lock (&inode->i_lock); +netfs_write_remote_i_size (inode, stat->st_size);if (!(flags &V9FS_STAT2INODE_KEEP_ISIZE )) -v9fs_i_size_write (inode, stat->st_size); +i_size_write (inode, stat->st_size); inode->i_blocks = stat->st_blocks; +spin_unlock (&inode->i_lock); }else {if (stat->st_result_mask &P9_STATS_ATIME ) { inode_set_atime(inode, stat->st_atime_sec,
@@ -662,13 +664,15 @@ v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode, mode |= inode->i_mode & ~S_IALLUGO ; inode->i_mode = mode; } +spin_lock (&inode->i_lock);if (!(flags &V9FS_STAT2INODE_KEEP_ISIZE ) && stat->st_result_mask &P9_STATS_SIZE ) { - v9inode->netfs.remote_i_size = stat->st_size; -v9fs_i_size_write (inode, stat->st_size); +netfs_write_remote_i_size (inode, stat->st_size); +i_size_write (inode, stat->st_size); }if (stat->st_result_mask &P9_STATS_BLOCKS ) inode->i_blocks = stat->st_blocks; +spin_unlock (&inode->i_lock); }if (stat->st_result_mask &P9_STATS_GEN ) inode->i_generation = stat->st_gen;
fs/afs/file.c +19 -5
@@ -427,21 +427,35 @@ static void afs_free_request(struct netfs_io_request *rreq)afs_put_wb_key (rreq->netfs_priv2); } -static void afs_update_i_size (struct inode *inode,loff_t new_i_size) +/* +* Set the file size and block count, taking ->cb_lock and ->i_lock to maintain +* coherency and prevent 64-bit tearing on 32-bit arches. +* +* Also, estimate the number of 512 bytes blocks used, rounded up to nearest 1K +* for consistency with other AFS clients. +*/ +void afs_set_i_size (struct afs_vnode *vnode,loff_t new_i_size) { -struct afs_vnode *vnode =AFS_FS_I (inode); +struct inode *inode = &vnode->netfs.inode;loff_t i_size;write_seqlock (&vnode->cb_lock); - i_size =i_size_read (&vnode->netfs.inode); +spin_lock (&inode->i_lock); + i_size =i_size_read (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); +i_size_write (inode, new_i_size); +inode_set_bytes (inode,round_up (new_i_size,1024 )); } +spin_unlock (&inode->i_lock);write_sequnlock (&vnode->cb_lock);fscache_update_cookie (afs_vnode_cache (vnode),NULL , &new_i_size); } +static void afs_update_i_size (struct inode *inode,loff_t new_i_size) +{ +afs_set_i_size (AFS_FS_I (inode), new_i_size); +} +static void afs_netfs_invalidate_cache (struct netfs_io_request *wreq) {struct afs_vnode *vnode =AFS_FS_I (wreq->inode);
fs/afs/inode.c +22 -9
@@ -224,7 +224,8 @@ static int afs_inode_init_from_status(struct afs_operation *op,return afs_protocol_error (NULL , afs_eproto_file_type); } -afs_set_i_size (vnode, status->size); +i_size_write (inode, status->size); +inode_set_bytes (inode, status->size);afs_set_netfs_context (vnode); vnode->invalid_before = status->data_version;
@@ -253,7 +254,8 @@ static void afs_apply_status(struct afs_operation *op, {struct afs_file_status *status = &vp->scb.status;struct afs_vnode *vnode = vp->vnode; -struct inode *inode = &vnode->netfs.inode; +struct netfs_inode *ictx = &vnode->netfs; +struct inode *inode = &ictx->inode;struct timespec64 t;umode_t mode;bool unexpected_jump = false;
@@ -336,6 +338,8 @@ static void afs_apply_status(struct afs_operation *op, }if (data_changed) { +unsigned long long zero_point, size = status->size; +inode_set_iversion_raw (inode, status->data_version);/* Only update the size if the data version jumped. If the
@@ -343,16 +347,25 @@ static void afs_apply_status(struct afs_operation *op,* idea of what the size should be that's not the same as * what's on the server. */ - vnode->netfs.remote_i_size = status->size; -if (change_size || status->size >i_size_read (inode)) { -afs_set_i_size (vnode, status->size); +spin_lock (&inode->i_lock); + +if (change_size || size >i_size_read (inode)) { +/* We can read the sizes directly as we hold i_lock. */ + zero_point = ictx->_zero_point; +if (unexpected_jump) - vnode->netfs.zero_point = status->size; + zero_point = size; +netfs_write_sizes (inode, size, size, zero_point); +inode_set_bytes (inode, size);inode_set_ctime_to_ts (inode, t);inode_set_atime_to_ts (inode, t); + }else { +netfs_write_remote_i_size (inode, size); } +spin_unlock (&inode->i_lock); +if (op->ops == &afs_fetch_data_operation) - op->fetch.subreq->rreq->i_size = status->size; + op->fetch.subreq->rreq->i_size = size; } }
@@ -709,7 +722,7 @@ int afs_getattr(struct mnt_idmap *idmap, const struct path *path,* it, but we need to give userspace the server's size. */ if (S_ISDIR (inode->i_mode)) - stat->size = vnode->netfs.remote_i_size; + stat->size =netfs_read_remote_i_size (inode); }while (read_seqretry (&vnode->cb_lock, seq));return 0 ;
@@ -889,7 +902,7 @@ int afs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,*/ if (!(attr->ia_valid & (supported & ~ATTR_SIZE & ~ATTR_MTIME )) && attr->ia_size < i_size && - attr->ia_size > vnode->netfs.remote_i_size) { + attr->ia_size >netfs_read_remote_i_size (inode)) {truncate_setsize (inode, attr->ia_size);netfs_resize_file (&vnode->netfs, size, false); fscache_resize_cookie(afs_vnode_cache(vnode),
fs/afs/internal.h +1 -10
@@ -1157,6 +1157,7 @@ extern int afs_open(struct inode *, struct file *);extern int afs_release (struct inode *,struct file *);void afs_fetch_data_async_rx (struct work_struct *work);void afs_fetch_data_immediate_cancel (struct afs_call *call); +void afs_set_i_size (struct afs_vnode *vnode,loff_t new_i_size);/* * flock.c
@@ -1758,16 +1759,6 @@ static inline void afs_update_dentry_version(struct afs_operation *op, (void *)(unsigned long )dir_vp->scb.status.data_version; } -/* -* Set the file size and block count. Estimate the number of 512 bytes blocks -* used, rounded up to nearest 1K for consistency with other AFS clients. -*/ -static inline void afs_set_i_size (struct afs_vnode *vnode,u64 size) -{ -i_size_write (&vnode->netfs.inode, size); - vnode->netfs.inode.i_blocks = ((size +1023 ) >>10 ) <<1 ; -} -/* * Check for a conflicting operation on a directory that we just unlinked from. * If someone managed to sneak a link or an unlink in on the file we just
fs/afs/write.c +1 -1
@@ -142,7 +142,7 @@ static void afs_issue_write_worker(struct work_struct *work)afs_begin_vnode_operation (op); op->store.write_iter = &subreq->io_iter; - op->store.i_size =umax (pos + len, vnode->netfs.remote_i_size); + op->store.i_size =umax (pos + len,netfs_read_remote_i_size (&vnode->netfs.inode)); op->mtime =inode_get_mtime (&vnode->netfs.inode);afs_wait_for_operation (op);
fs/netfs/buffered_read.c +3 -3
@@ -209,7 +209,6 @@ static void netfs_issue_read(struct netfs_io_request *rreq,static void netfs_read_to_pagecache (struct netfs_io_request *rreq,struct readahead_control *ractl) { -struct netfs_inode *ictx =netfs_inode (rreq->inode);unsigned long long start = rreq->start;ssize_t size = rreq->len;int ret =0 ;
@@ -233,7 +232,8 @@ static void netfs_read_to_pagecache(struct netfs_io_request *rreq, source =netfs_cache_prepare_read (rreq, subreq, rreq->i_size); subreq->source = source;if (source ==NETFS_DOWNLOAD_FROM_SERVER ) { -unsigned long long zp =umin (ictx->zero_point, rreq->i_size); +unsigned long long zero_point =netfs_read_zero_point (rreq->inode); +unsigned long long zp =umin (zero_point, rreq->i_size);size_t len = subreq->len;if (unlikely (rreq->origin ==NETFS_READ_SINGLE ))
@@ -249,7 +249,7 @@ static void netfs_read_to_pagecache(struct netfs_io_request *rreq,pr_err ("ZERO-LEN READ: R=%08x[%x] l=%zx/%zx s=%llx z=%llx i=%llx" , rreq->debug_id, subreq->debug_index, subreq->len, size, - subreq->start, ictx->zero_point, rreq->i_size); + subreq->start, zero_point, rreq->i_size);netfs_cancel_read (subreq, ret);break ; }
fs/netfs/buffered_write.c +1 -1
@@ -230,7 +230,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,* server would just return a block of zeros or a short read if * we try to read it. */ -if (fpos >= ctx->zero_point) { +if (fpos >=netfs_read_zero_point (inode)) {folio_zero_segment (folio,0 , offset); copied =copy_folio_from_iter_atomic (folio, offset, part, iter);if (unlikely (copied ==0 ))
fs/netfs/direct_write.c +4 -2
@@ -376,8 +376,10 @@ ssize_t netfs_unbuffered_write_iter(struct kiocb *iocb, struct iov_iter *from)if (ret <0 ) goto out; end = iocb->ki_pos +iov_iter_count (from); -if (end > ictx->zero_point) - ictx->zero_point = end; +spin_lock (&inode->i_lock); +if (end > ictx->_zero_point) +netfs_write_zero_point (inode, end); +spin_unlock (&inode->i_lock);fscache_invalidate (netfs_i_cookie (ictx),NULL ,i_size_read (inode),FSCACHE_INVAL_DIO_WRITE );
fs/netfs/misc.c +23 -9
@@ -211,18 +211,25 @@ EXPORT_SYMBOL(netfs_clear_inode_writeback);void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length) {struct netfs_folio *finfo; -struct netfs_inode *ctx =netfs_inode (folio_inode (folio)); +struct inode *inode =folio_inode (folio); +struct netfs_inode *ctx =netfs_inode (inode);size_t flen =folio_size (folio);_enter ("{%lx},%zx,%zx" , folio->index, offset, length);if (offset ==0 && length == flen) { -unsigned long long i_size =i_size_read (&ctx->inode); +unsigned long long i_size, remote_i_size, zero_point;unsigned long long fpos =folio_pos (folio), end; +netfs_read_sizes (inode, &i_size, &remote_i_size, &zero_point); end =umin (fpos + flen, i_size); -if (fpos < i_size && end > ctx->zero_point) - ctx->zero_point = end; +if (fpos < i_size && end > zero_point) { +spin_lock (&inode->i_lock); + end =umin (fpos + flen, inode->i_size); +if (fpos < i_size && end > ctx->_zero_point) +netfs_write_zero_point (inode, end); +spin_unlock (&inode->i_lock); + } }folio_wait_private_2 (folio);/* [DEPRECATED] */
@@ -292,15 +299,22 @@ EXPORT_SYMBOL(netfs_invalidate_folio);*/ bool netfs_release_folio (struct folio *folio,gfp_t gfp) { -struct netfs_inode *ctx =netfs_inode (folio_inode (folio)); -unsigned long long end; +struct inode *inode =folio_inode (folio); +struct netfs_inode *ctx =netfs_inode (inode); +unsigned long long i_size, remote_i_size, zero_point, end;if (folio_test_dirty (folio))return false; - end =umin (folio_next_pos (folio),i_size_read (&ctx->inode)); -if (end > ctx->zero_point) - ctx->zero_point = end; +netfs_read_sizes (inode, &i_size, &remote_i_size, &zero_point); + end =umin (folio_next_pos (folio), i_size); +if (end > zero_point) { +spin_lock (&inode->i_lock); + end =umin (folio_next_pos (folio), inode->i_size); +if (end > ctx->_zero_point) +netfs_write_zero_point (inode, end); +spin_unlock (&inode->i_lock); + }if (folio_test_private (folio))return false;
fs/netfs/write_collect.c +6 -3
@@ -57,7 +57,8 @@ static void netfs_dump_request(const struct netfs_io_request *rreq)int netfs_folio_written_back (struct folio *folio) {enum netfs_folio_trace why = netfs_folio_trace_clear; -struct netfs_inode *ictx =netfs_inode (folio->mapping->host); +struct inode *inode =folio_inode (folio); +struct netfs_inode *ictx =netfs_inode (inode);struct netfs_folio *finfo;struct netfs_group *group =NULL ;int gcount =0 ;
@@ -69,8 +70,10 @@ int netfs_folio_written_back(struct folio *folio)unsigned long long fend; fend =folio_pos (folio) + finfo->dirty_offset + finfo->dirty_len; -if (fend > ictx->zero_point) - ictx->zero_point = fend; +spin_lock (&ictx->inode.i_lock); +if (fend > ictx->_zero_point) +netfs_write_zero_point (inode, fend); +spin_unlock (&ictx->inode.i_lock);folio_detach_private (folio); group = finfo->netfs_group;
fs/smb/client/cifsfs.c +25 -13
@@ -434,7 +434,8 @@ 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->netfs.remote_i_size =0 ; + cifs_inode->netfs._remote_i_size =0 ; + cifs_inode->netfs._zero_point =0 ; cifs_inode->uniqueid =0 ; cifs_inode->createtime =0 ; cifs_inode->epoch =0 ;
@@ -1303,7 +1304,8 @@ static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,struct cifsFileInfo *smb_file_src = src_file->private_data;struct cifsFileInfo *smb_file_target = dst_file->private_data;struct cifs_tcon *target_tcon, *src_tcon; -unsigned long long destend, fstart, fend, old_size, new_size; +unsigned long long i_size, old_size, new_size, zero_point; +unsigned long long destend, fstart, fend;unsigned int xid;int rc;
@@ -1347,7 +1349,7 @@ static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,* Advance the EOF marker after the flush above to the end of the range * if it's short of that. */ -if (src_cifsi->netfs.remote_i_size < off + len) { +if (netfs_read_remote_i_size (src_inode) < off + len) { rc =cifs_precopy_set_eof (src_inode, src_cifsi, src_tcon, xid, off + len);if (rc <0 ) goto unlock;
@@ -1368,16 +1370,18 @@ static loff_t cifs_remap_file_range(struct file *src_file, loff_t off, rc =cifs_flush_folio (target_inode, destend, &fstart, &fend, false);if (rc) goto unlock; -if (fend > target_cifsi->netfs.zero_point) - target_cifsi->netfs.zero_point = fend +1 ; - old_size = target_cifsi->netfs.remote_i_size; + +spin_lock (&target_inode->i_lock); +if (fend > zero_point) +netfs_write_zero_point (target_inode, fend +1 ); + i_size = target_inode->i_size; +spin_unlock (&target_inode->i_lock);/* Discard all the folios that overlap the destination region. */ cifs_dbg (FYI ,"about to discard pages %llx-%llx\n" , fstart, fend);truncate_inode_pages_range (&target_inode->i_data, fstart, fend); -fscache_invalidate (cifs_inode_cookie (target_inode),NULL , -i_size_read (target_inode),0 ); +fscache_invalidate (cifs_inode_cookie (target_inode),NULL , i_size,0 ); rc = -EOPNOTSUPP ;if (target_tcon->ses->server->ops->duplicate_extents) {
@@ -1402,8 +1406,12 @@ static loff_t cifs_remap_file_range(struct file *src_file, loff_t off, rc = -EINVAL ; } } -if (rc ==0 && new_size > target_cifsi->netfs.zero_point) - target_cifsi->netfs.zero_point = new_size; +if (rc ==0 ) { +spin_lock (&target_inode->i_lock); +if (new_size > target_cifsi->netfs._zero_point) +netfs_write_zero_point (target_inode, new_size); +spin_unlock (&target_inode->i_lock); + } }/* force revalidate of size and timestamps of target file now
@@ -1474,7 +1482,7 @@ ssize_t cifs_file_copychunk_range(unsigned int xid,* Advance the EOF marker after the flush above to the end of the range * if it's short of that. */ -if (src_cifsi->netfs.remote_i_size < off + len) { +if (netfs_read_remote_i_size (src_inode) < off + len) { rc =cifs_precopy_set_eof (src_inode, src_cifsi, src_tcon, xid, off + len);if (rc <0 ) goto unlock;
@@ -1502,8 +1510,12 @@ ssize_t cifs_file_copychunk_range(unsigned int xid,fscache_resize_cookie (cifs_inode_cookie (target_inode),i_size_read (target_inode)); } -if (rc >0 && destoff + rc > target_cifsi->netfs.zero_point) - target_cifsi->netfs.zero_point = destoff + rc; +if (rc >0 ) { +spin_lock (&target_inode->i_lock); +if (destoff + rc > target_cifsi->netfs._zero_point) +netfs_write_zero_point (target_inode, destoff + rc); +spin_unlock (&target_inode->i_lock); + } }file_accessed (src_file);
fs/smb/client/cifssmb.c +2 -1
@@ -1465,6 +1465,7 @@ cifs_readv_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid)struct cifs_io_subrequest *rdata = mid->callback_data;struct netfs_inode *ictx =netfs_inode (rdata->rreq->inode);struct cifs_tcon *tcon =tlink_tcon (rdata->req->cfile->tlink); +struct inode *inode = &ictx->inode;struct smb_rqst rqst = { .rq_iov = rdata->iov, .rq_nvec =1 , .rq_iter = rdata->subreq.io_iter };
@@ -1538,7 +1539,7 @@ cifs_readv_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid) }else {size_t trans = rdata->subreq.transferred + rdata->got_bytes;if (trans < rdata->subreq.len && - rdata->subreq.start + trans >= ictx->remote_i_size) { + rdata->subreq.start + trans >=netfs_read_remote_i_size (inode)) { rdata->result =0 ;__set_bit (NETFS_SREQ_HIT_EOF , &rdata->subreq.flags); }else if (rdata->got_bytes >0 ) {
fs/smb/client/file.c +9 -4
@@ -2517,18 +2517,23 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *flock)void cifs_write_subrequest_terminated (struct cifs_io_subrequest *wdata,ssize_t result) {struct netfs_io_request *wreq = wdata->rreq; -struct netfs_inode *ictx =netfs_inode (wreq->inode); +struct inode *inode = wreq->inode; +struct netfs_inode *ictx =netfs_inode (inode);loff_t wrend;if (result >0 ) { +spin_lock (&inode->i_lock); + wrend = wdata->subreq.start + wdata->subreq.transferred + result; -if (wrend > ictx->zero_point && +if (wrend > ictx->_zero_point && (wdata->rreq->origin ==NETFS_UNBUFFERED_WRITE || wdata->rreq->origin ==NETFS_DIO_WRITE )) - ictx->zero_point = wrend; -if (wrend > ictx->remote_i_size) +netfs_write_zero_point (inode, wrend); +if (wrend > ictx->_remote_i_size)netfs_resize_file (ictx, wrend, true); + +spin_unlock (&inode->i_lock); }netfs_write_subrequest_terminated (&wdata->subreq, result);
fs/smb/client/inode.c +8 -6
@@ -119,7 +119,7 @@ cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr) fattr->cf_mtime =timestamp_truncate (fattr->cf_mtime, inode); mtime =inode_get_mtime (inode);if (timespec64_equal (&mtime, &fattr->cf_mtime) && - cifs_i->netfs.remote_i_size == fattr->cf_eof) { +netfs_read_remote_i_size (inode) == fattr->cf_eof) {cifs_dbg (FYI ,"%s: inode %llu is unchanged\n" , __func__, cifs_i->uniqueid);return ;
@@ -173,12 +173,12 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr,CIFS_I (inode)->time =0 ;/* force reval */ return -ESTALE ; } -if (inode_state_read_once (inode) &I_NEW ) -CIFS_I (inode)->netfs.zero_point = fattr->cf_eof; -cifs_revalidate_cache (inode, fattr);spin_lock (&inode->i_lock); +if (inode_state_read_once (inode) &I_NEW ) +netfs_write_zero_point (inode, fattr->cf_eof); + fattr->cf_mtime =timestamp_truncate (fattr->cf_mtime, inode); fattr->cf_atime =timestamp_truncate (fattr->cf_atime, inode); fattr->cf_ctime =timestamp_truncate (fattr->cf_ctime, inode);
@@ -212,7 +212,7 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr,else clear_bit (CIFS_INO_DELETE_PENDING , &cifs_i->flags); - cifs_i->netfs.remote_i_size = fattr->cf_eof; +netfs_write_remote_i_size (inode, fattr->cf_eof);/* * Can't safely change the file size here if the client is writing to * it due to potential races.
@@ -2772,7 +2772,9 @@ cifs_revalidate_mapping(struct inode *inode)if (cifs_sb_flags (cifs_sb) &CIFS_MOUNT_RW_CACHE ) goto skip_invalidate; - cifs_inode->netfs.zero_point = cifs_inode->netfs.remote_i_size; +spin_lock (&inode->i_lock); +netfs_write_zero_point (inode,netfs_inode (inode)->_remote_i_size); +spin_unlock (&inode->i_lock); rc =filemap_invalidate_inode (inode, true,0 ,LLONG_MAX );if (rc) { cifs_dbg(VFS, "%s: invalidate inode %p failed with rc %d\n",
fs/smb/client/readdir.c +2 -1
@@ -143,7 +143,8 @@ cifs_prime_dcache(struct dentry *parent, struct qstr *name, fattr->cf_rdev = inode->i_rdev; fattr->cf_uid = inode->i_uid; fattr->cf_gid = inode->i_gid; - fattr->cf_eof =CIFS_I (inode)->netfs.remote_i_size; + fattr->cf_eof = +netfs_read_remote_i_size (inode); fattr->cf_symlink_target =NULL ; }else {CIFS_I (inode)->time =0 ;
fs/smb/client/smb2ops.c +26 -16
108 lines not on this page · raw message
fs/smb/client/smb2pdu.c +2 -1
@@ -4608,6 +4608,7 @@ smb2_readv_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid)struct netfs_inode *ictx =netfs_inode (rdata->rreq->inode);struct cifs_tcon *tcon =tlink_tcon (rdata->req->cfile->tlink);struct smb2_hdr *shdr = (struct smb2_hdr *)rdata->iov[0 ].iov_base; +struct inode *inode = &ictx->inode;struct cifs_credits credits = { .value =0 , .instance =0 ,
@@ -4721,7 +4722,7 @@ smb2_readv_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid) }else {size_t trans = rdata->subreq.transferred + rdata->got_bytes;if (trans < rdata->subreq.len && - rdata->subreq.start + trans >= ictx->remote_i_size) { + rdata->subreq.start + trans >=netfs_read_remote_i_size (inode)) {__set_bit (NETFS_SREQ_HIT_EOF , &rdata->subreq.flags); rdata->result =0 ; }
include/linux/netfs.h +284 -9
326 lines not on this page · raw message
David Howells
maintainerPATCH v6 6/24 netfs: Fix zeropoint update where i_size > remote_i_size
In reply to David HowellsFix the update of the zero point[*] by netfs_release_folio() when there is uncommitted data in the pagecache beyond the folio being released but the on-server EOF is in this folio (ie. i_size > remote_i_size). The update needs to limit zero_point to remote_i_size, not i_size as i_size is a local phenomenon reflecting updates made locally to the pagecache, not stuff written to the server. remote_i_size tracks the server's i_size.
[*] The zero point is the file position from which we can assume that the
server will just return zeros, so we can avoid generating reads.
Note that netfs_invalidate_folio() probably doesn't need fixing as zero_point should be updated by setattr after truncation or fallocate.
Found with:
fsx -q -N 1000000 -p 10000 -o 128000 -l 600000 \
/xfstest.test/junk --replay-ops=junk.fsxopsusing the following as junk.fsxops:
truncate 0x0 0x1bbae 0x82864
write 0x3ef2e 0xf9c8 0x1bbae
write 0x67e05 0xcb5a 0x4e8f6
mapread 0x57781 0x85b6 0x7495f
copy_range 0x5d3d 0x10329 0x54fac 0x7495f
write 0x64710 0x1c2b 0x7495f
mapread 0x64000 0x1000 0x7495fon cifs with the default cache option.
It shows read-gaps on folio 0x64 failing with a short read (ie. it hits EOF) if the FMODE_READ check is commented out in netfs_perform_write():
if (//(file->f_mode & FMODE_READ) ||
netfs_is_cache_enabled(ctx)) {and no fscache. This was initially found with the generic/522 xfstest.
--- fs/netfs/misc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/netfs/misc.c +2 -2
@@ -307,10 +307,10 @@ bool netfs_release_folio(struct folio *folio, gfp_t gfp)return false;netfs_read_sizes (inode, &i_size, &remote_i_size, &zero_point); - end =umin (folio_next_pos (folio), i_size); + end =folio_next_pos (folio);if (end > zero_point) {spin_lock (&inode->i_lock); - end =umin (folio_next_pos (folio), inode->i_size); + end =umin (end, ctx->_remote_i_size);if (end > ctx->_zero_point)netfs_write_zero_point (inode, end);spin_unlock (&inode->i_lock);
David Howells
maintainerPATCH v6 7/24 netfs: fix VM_BUG_ON_FOLIO() issue in netfs_write_begin() call
In reply to David HowellsFrom: Viacheslav Dubeyko <[email protected]>
The multiple runs of generic/013 test-case is capable to reproduce a kernel BUG at mm/filemap.c:1504 with probability of 30%.
while true; do
sudo ./check generic/013
done
[ 9849.452376] page: refcount:3 mapcount:0 mapping:00000000e58ff252 index:0x10781 pfn:0x1c322 [ 9849.452412] memcg:ffff8881a1915800 [ 9849.452417] aops:ceph_aops ino:1000058db9e dentry name(?):"f9XXXXXX" [ 9849.452432] flags: 0x17ffffc0000000(node=0|zone=2|lastcpupid=0x1fffff) [ 9849.452441] raw: 0017ffffc0000000 0000000000000000 dead000000000122 ffff88816110d248 [ 9849.452445] raw: 0000000000010781 0000000000000000 00000003ffffffff ffff8881a1915800 [ 9849.452447] page dumped because: VM_BUG_ON_FOLIO(!folio_test_locked(folio)) [ 9849.452474] ------------[ cut here ]------------ [ 9849.452476] kernel BUG at mm/filemap.c:1504! [ 9849.478635] Oops: invalid opcode: 0000 [#1] SMP KASAN NOPTI [ 9849.481772] CPU: 2 UID: 0 PID: 84223 Comm: fsstress Not tainted 7.0.0-rc1+ #18 PREEMPT(full) [ 9849.482881] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.17.0-9.fc43 06/1 0/2025 [ 9849.484539] RIP: 0010:folio_unlock+0x85/0xa0 [ 9849.485076] Code: 89 df 31 f6 e8 1c f3 ff ff 48 8b 5d f8 c9 31 c0 31 d2 31 f6 31 ff c3 cc cc cc cc 48 c7 c6 80 6c d9 a7 48 89 df e8 4b b3 10 00 <0f> 0b 48 89 df e8 21 e6 2c 00 eb 9d 0f 1f 40 00 66 66 2e 0f 1f 84 [ 9849.493818] RSP: 0018:ffff8881bb8076b0 EFLAGS: 00010246 [ 9849.495740] RAX: 0000000000000000 RBX: ffffea00070c8980 RCX: 0000000000000000 [ 9849.498678] RDX: 0000000000000000 RSI: 0000000000000000 RDI: 0000000000000000 [ 9849.500559] RBP: ffff8881bb8076b8 R08: 0000000000000000 R09: 0000000000000000 [ 9849.501097] R10: 0000000000000000 R11: 0000000000000000 R12: 0000000010782000 [ 9849.502108] R13: ffff8881935de738 R14: ffff88816110d010 R15: 0000000000001000 [ 9849.502516] FS: 00007e36cbe94740(0000) GS:ffff88824a899000(0000) knlGS:0000000000000000 [ 9849.502996] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 9849.503810] CR2: 000000c0002b0000 CR3: 000000011bbf6004 CR4: 0000000000772ef0 [ 9849.504459] PKRU: 55555554 [ 9849.504626] Call Trace: [ 9849.505242] <TASK> [ 9849.505379] netfs_write_begin+0x7c8/0x10a0 [ 9849.505877] ? __kasan_check_read+0x11/0x20 [ 9849.506384] ? __pfx_netfs_write_begin+0x10/0x10 [ 9849.507178] ceph_write_begin+0x8c/0x1c0 [ 9849.507934] generic_perform_write+0x391/0x8f0 [ 9849.508503] ? __pfx_generic_perform_write+0x10/0x10 [ 9849.509062] ? file_update_time_flags+0x19a/0x4b0 [ 9849.509581] ? ceph_get_caps+0x63/0xf0 [ 9849.510259] ? ceph_get_caps+0x63/0xf0 [ 9849.510530] ceph_write_iter+0xe79/0x1ae0 [ 9849.511282] ? __pfx_ceph_write_iter+0x10/0x10 [ 9849.511839] ? lock_acquire+0x1ad/0x310 [ 9849.512334] ? ksys_write+0xf9/0x230 [ 9849.512582] ? lock_is_held_type+0xaa/0x140 [ 9849.513128] vfs_write+0x512/0x1110 [ 9849.513634] ? __fget_files+0x33/0x350 [ 9849.513893] ? __pfx_vfs_write+0x10/0x10 [ 9849.514143] ? mutex_lock_nested+0x1b/0x30 [ 9849.514394] ksys_write+0xf9/0x230 [ 9849.514621] ? __pfx_ksys_write+0x10/0x10 [ 9849.514887] ? do_syscall_64+0x25e/0x1520 [ 9849.515122] ? __kasan_check_read+0x11/0x20 [ 9849.515366] ? trace_hardirqs_on_prepare+0x178/0x1c0 [ 9849.515655] __x64_sys_write+0x72/0xd0 [ 9849.515885] ? trace_hardirqs_on+0x24/0x1c0 [ 9849.516130] x64_sys_call+0x22f/0x2390 [ 9849.516341] do_syscall_64+0x12b/0x1520 [ 9849.516545] ? do_syscall_64+0x27c/0x1520 [ 9849.516783] ? do_syscall_64+0x27c/0x1520 [ 9849.517003] ? lock_release+0x318/0x480 [ 9849.517220] ? __x64_sys_io_getevents+0x143/0x2d0 [ 9849.517479] ? percpu_ref_put_many.constprop.0+0x8f/0x210 [ 9849.517779] ? entry_SYSCALL_64_after_hwframe+0x76/0x7e [ 9849.518073] ? do_syscall_64+0x25e/0x1520 [ 9849.518291] ? __kasan_check_read+0x11/0x20 [ 9849.518519] ? trace_hardirqs_on_prepare+0x178/0x1c0 [ 9849.518799] ? do_syscall_64+0x27c/0x1520 [ 9849.519024] ? local_clock_noinstr+0xf/0x120 [ 9849.519262] ? entry_SYSCALL_64_after_hwframe+0x76/0x7e [ 9849.519544] ? do_syscall_64+0x25e/0x1520 [ 9849.519781] ? __kasan_check_read+0x11/0x20 [ 9849.520008] ? trace_hardirqs_on_prepare+0x178/0x1c0 [ 9849.520273] ? do_syscall_64+0x27c/0x1520 [ 9849.520491] ? trace_hardirqs_on_prepare+0x178/0x1c0 [ 9849.520767] ? irqentry_exit+0x10c/0x6c0 [ 9849.520984] ? trace_hardirqs_off+0x86/0x1b0 [ 9849.521224] ? exc_page_fault+0xab/0x130 [ 9849.521472] entry_SYSCALL_64_after_hwframe+0x76/0x7e [ 9849.521766] RIP: 0033:0x7e36cbd14907 [ 9849.521989] Code: 10 00 f7 d8 64 89 02 48 c7 c0 ff ff ff ff eb b7 0f 1f 00 f3 0f 1e fa 64 8b 04 25 18 00 00 00 85 c0 75 10 b8 01 00 00 00 0f 05 <48> 3d 00 f0 ff ff 77 51 c3 48 83 ec 28 48 89 54 24 18 48 89 74 24 [ 9849.523057] RSP: 002b:00007ffff2d2a968 EFLAGS: 00000246 ORIG_RAX: 0000000000000001 [ 9849.523484] RAX: ffffffffffffffda RBX: 000000000000e549 RCX: 00007e36cbd14907 [ 9849.523885] RDX: 000000000000e549 RSI: 00005bd797ec6370 RDI: 0000000000000004 [ 9849.524277] RBP: 0000000000000004 R08: 0000000000000047 R09: 00005bd797ec6370 [ 9849.524652] R10: 0000000000000078 R11: 0000000000000246 R12: 0000000000000049 [ 9849.525062] R13: 0000000010781a37 R14: 00005bd797ec6370 R15: 0000000000000000 [ 9849.525447] </TASK> [ 9849.525574] Modules linked in: intel_rapl_msr intel_rapl_common intel_uncore_frequency_common intel_pmc_core pmt_telemetry pmt_discovery pmt_class intel_pmc_ssram_telemetry intel_vsec kvm_intel joydev kvm irqbypass ghash_clmulni_intel aesni_intel input_leds rapl mac_hid psmouse vga16fb serio_raw vgastate floppy i2c_piix4 bochs qemu_fw_cfg i2c_smbus pata_acpi sch_fq_codel rbd msr parport_pc ppdev lp parport efi_pstore [ 9849.529150] ---[ end trace 0000000000000000 ]--- [ 9849.529502] RIP: 0010:folio_unlock+0x85/0xa0 [ 9849.530813] Code: 89 df 31 f6 e8 1c f3 ff ff 48 8b 5d f8 c9 31 c0 31 d2 31 f6 31 ff c3 cc cc cc cc 48 c7 c6 80 6c d9 a7 48 89 df e8 4b b3 10 00 <0f> 0b 48 89 df e8 21 e6 2c 00 eb 9d 0f 1f 40 00 66 66 2e 0f 1f 84 [ 9849.534986] RSP: 0018:ffff8881bb8076b0 EFLAGS: 00010246 [ 9849.536198] RAX: 0000000000000000 RBX: ffffea00070c8980 RCX: 0000000000000000 [ 9849.537718] RDX: 0000000000000000 RSI: 0000000000000000 RDI: 0000000000000000 [ 9849.539321] RBP: ffff8881bb8076b8 R08: 0000000000000000 R09: 0000000000000000 [ 9849.540862] R10: 0000000000000000 R11: 0000000000000000 R12: 0000000010782000 [ 9849.542438] R13: ffff8881935de738 R14: ffff88816110d010 R15: 0000000000001000 [ 9849.543996] FS: 00007e36cbe94740(0000) GS:ffff88824b899000(0000) knlGS:0000000000000000 [ 9849.545854] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 9849.547092] CR2: 00007e36cb3ff000 CR3: 000000011bbf6006 CR4: 0000000000772ef0 [ 9849.548679] PKRU: 55555554
The race sequence:
1. Read completes -> netfs_read_collection() runs
2. netfs_wake_rreq_flag(rreq, NETFS_RREQ_IN_PROGRESS, ...)
3. netfs_wait_for_read() returns -EFAULT to netfs_write_begin()
4. The netfs_unlock_abandoned_read_pages() unlocks the folio
5. netfs_write_begin() calls folio_unlock(folio) -> VM_BUG_ON_FOLIO()
The key reason of the issue that netfs_unlock_abandoned_read_pages() doesn't check the flag NETFS_RREQ_NO_UNLOCK_FOLIO and executes folio_unlock() unconditionally. This patch implements in netfs_unlock_abandoned_read_pages() logic similar to netfs_unlock_read_folio().
--- fs/netfs/read_retry.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)
fs/netfs/read_retry.c +9 -2
@@ -292,8 +292,15 @@ void netfs_unlock_abandoned_read_pages(struct netfs_io_request *rreq)struct folio *folio =folioq_folio (p, slot);if (folio && !folioq_is_marked2 (p, slot)) { -trace_netfs_folio (folio, netfs_folio_trace_abandon); -folio_unlock (folio); +if (folio->index == rreq->no_unlock_folio && +test_bit (NETFS_RREQ_NO_UNLOCK_FOLIO , + &rreq->flags)) { +_debug ("no unlock" ); + }else { +trace_netfs_folio (folio, + netfs_folio_trace_abandon); +folio_unlock (folio); + } } } }
David Howells
maintainerPATCH v6 8/24 netfs: Fix potential uninitialised var in netfs_extract_user_iter()
In reply to David HowellsIn netfs_extract_user_iter(), if it's given a zero-length iterator, it will fall through the loop without setting ret, and so the error handling behaviour will be undefined, depending on whether ret happens to be negative. The value of ret then propagates back up the callstack.
Fix this by presetting ret to 0.
--- fs/netfs/iterator.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/netfs/iterator.c +1 -1
@@ -43,7 +43,7 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len,unsigned int max_pages;unsigned int npages =0 ;unsigned int i; -ssize_t ret; +ssize_t ret =0 ;size_t count = orig_len, offset, len;size_t bv_size, pg_size;
Re: [PATCH v6 08/24] netfs: Fix potential uninitialised var in netfs_extract_user_iter()
Hi, David.
It looks like ret does not need to be initialized to 0, because it is only used after being assigned the
return value of iov_iter_extract_pages(). In the zero-length case, the loop is skipped and ret is not used at all.
What do you think?
Thanks
DaeMyung
2026년 5월 12일 (화) 오후 9:43, David Howells <[email protected]>님이 작성:
Quoted 34 lines
In
netfs_extract_user_iter(), if it's given a zero-length iterator, it will fall through the loop without setting ret, and so the error handling behaviour will be undefined, depending on whether ret happens to be negative. The value of ret then propagates back up the callstack.Fix this by presetting ret to 0.
Fixes 85dd2c8ff368 ("netfs: Add a function to extract a UBUF or IOVEC into a BVEC iterator")Signed-off-by David Howells <[email protected]>cc Paulo Alcantara <[email protected]>cc Matthew Wilcox <[email protected]>--- fs/netfs/iterator.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)fs/netfs/iterator.c +1
-1@@ -43,7 +43,7 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len,unsigned int max_pages;unsigned int npages =0 ;unsigned int i; -ssize_t ret; +ssize_t ret =0 ;size_t count = orig_len, offset, len;size_t bv_size, pg_size;
Re: [PATCH v6 08/24] netfs: Fix potential uninitialised var in netfs_extract_user_iter()
Hi, David.
Sorry for the confusion. I was looking at the current mainline code, but after checking
the version with commit 8ef352bc015d, I agree that ret needs to be initialized to 0.
Looks good to me.
Thanks.
DaeMyung
2026년 5월 12일 (화) 오후 10:07, CharSyam <[email protected]>님이 작성:
Quoted 47 lines
Hi, David.
It looks like ret does not need to be initialized to 0, because it is only used after being assigned the
return value ofiov_iter_extract_pages(). In the zero-length case, the loop is skipped and ret is not used at all.
What do you think?Thanks
DaeMyung2026년 5월 12일 (화) 오후 9:43, David Howells <[email protected]>님이 작성:
Quoted 34 lines
In
netfs_extract_user_iter(), if it's given a zero-length iterator, it will fall through the loop without setting ret, and so the error handling behaviour will be undefined, depending on whether ret happens to be negative. The value of ret then propagates back up the callstack.Fix this by presetting ret to 0.
Fixes 85dd2c8ff368 ("netfs: Add a function to extract a UBUF or IOVEC into a BVEC iterator")Signed-off-by David Howells <[email protected]>cc Paulo Alcantara <[email protected]>cc Matthew Wilcox <[email protected]>--- fs/netfs/iterator.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)fs/netfs/iterator.c +1
-1@@ -43,7 +43,7 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len,unsigned int max_pages;unsigned int npages =0 ;unsigned int i; -ssize_t ret; +ssize_t ret =0 ;size_t count = orig_len, offset, len;size_t bv_size, pg_size;
David Howells
maintainerPATCH v6 9/24 netfs: fix error handling in netfs_extract_user_iter()
In reply to David HowellsFrom: Paulo Alcantara <[email protected]>
In netfs_extract_user_iter(), if iov_iter_extract_pages() failed to extract user pages, bail out on -ENOMEM, otherwise return the error code only if @npages == 0, allowing short DIO reads and writes to be issued.
This fixes mmapstress02 from LTP tests against CIFS.
--- fs/netfs/iterator.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-)
fs/netfs/iterator.c +10 -3
@@ -22,7 +22,7 @@* * Extract the page fragments from the given amount of the source iterator and * build up a second iterator that refers to all of those bits. This allows -* the original iterator to disposed of. +* the original iterator to be disposed of. * * @extraction_flags can have ITER_ALLOW_P2PDMA set to request peer-to-peer DMA be * allowed on the pages extracted.
@@ -67,8 +67,8 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len, ret =iov_iter_extract_pages (orig, &pages, count, max_pages - npages, extraction_flags, &offset); -if (ret <0 ) { -pr_err ("Couldn't get user pages (rc=%zd)\n" , ret); +if (unlikely (ret <=0 )) { + ret = ret ?: -EIO ;break ; }
@@ -97,6 +97,13 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len, npages += cur_npages; } +if (ret <0 && (ret == -ENOMEM || npages ==0 )) { +for (i =0 ; i < npages; i++) +unpin_user_page (bv[i].bv_page); +kvfree (bv); +return ret; + } +iov_iter_bvec (new, orig->data_source, bv, npages, orig_len - count);return npages; }
David Howells
maintainerPATCH v6 10/24 netfs: Fix overrun check in netfs_extract_user_iter()
In reply to David HowellsFix netfs_extract_user_iter() so that if iov_iter_extract_pages() overfills pages[], then those pages don't get included in the iterator constructed at the end of the function. If there was an overfill, memory corruption has already happened.
--- fs/netfs/iterator.c | 26 +++++++++++++++++--------- 1 file changed, 17 insertions(+), 9 deletions(-)
fs/netfs/iterator.c +17 -9
@@ -72,21 +72,24 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len,break ; } -if (ret > count) { -pr_err ("get_pages rc=%zd more than %zu\n" , ret, count); +if (WARN (ret > count, +"%s: extract_pages overrun %zd > %zu bytes\n" , + __func__, ret, count)) { + ret = -EIO ;break ; } - count -= ret; - ret += offset; - cur_npages =DIV_ROUND_UP (ret,PAGE_SIZE ); - -if (npages + cur_npages > max_pages) { -pr_err ("Out of bvec array capacity (%u vs %u)\n" , - npages + cur_npages, max_pages); + cur_npages =DIV_ROUND_UP (offset + ret,PAGE_SIZE ); +if (WARN (cur_npages > max_pages - npages, +"%s: extract_pages overrun %u > %u pages\n" , + __func__, npages + cur_npages, max_pages)) { + ret = -EIO ;break ; } + count -= ret; + ret += offset; +for (i =0 ; i < cur_npages; i++) { len = ret >PAGE_SIZE ?PAGE_SIZE : ret;bvec_set_page (bv + npages + i, *pages++, len - offset, offset);
@@ -97,6 +100,11 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len, npages += cur_npages; } +/* Note: Don't try to clean up after EIO. Either we got no pages, so +* nothing to clean up, or we got a buffer overrun, memory corruption +* and can't trust the stuff in the buffer (a WARN was emitted). +*/ +if (ret <0 && (ret == -ENOMEM || npages ==0 )) {for (i =0 ; i < npages; i++)unpin_user_page (bv[i].bv_page);
David Howells
maintainerPATCH v6 11/24 netfs: Fix netfs_invalidate_folio() to clear dirty bit if all changes gone
In reply to David HowellsIf a streaming write is made, this will leave the relevant modified folio in a not-uptodate, but dirty state with a netfs_folio struct hung off of folio->private indicating the dirty range. Subsequently truncating the file such that the dirty data in the folio is removed, but the first part of the folio theoretically remains will cause the netfs_folio struct to be discarded... but will leave the dirty flag set.
If the folio is then read via mmap(), netfs_read_folio() will see that the page is dirty and jump to netfs_read_gaps() to fill in the missing bits. netfs_read_gaps(), however, expects there to be a netfs_folio struct present and can oops because truncate removed it.
Fix this by calling folio_cancel_dirty() in netfs_invalidate_folio() in the event that all the dirty data in the folio is erased (as nfs does).
Also add some tracepoints to log modifications to a dirty page.
This can be reproduced with something like:
dd if=/dev/zero of=/xfstest.test/foo bs=1M count=1
umount /xfstest.test
mount /xfstest.test
xfs_io -c "w 0xbbbf 0xf96c" \
-c "truncate 0xbbbf" \
-c "mmap -r 0xb000 0x11000" \
-c "mr 0xb000 0x11000" \
/xfstest.test/foowith fscaching disabled (otherwise streaming writes are suppressed) and a change to netfs_perform_write() to disallow streaming writes if the fd is open O_RDWR:
if (//(file->f_mode & FMODE_READ) || <--- comment this out
netfs_is_cache_enabled(ctx)) {It should be reproducible even without this change, but if prevents the above trivial xfs_io command from reproducing it.
Note that the initial dd is important: the file must start out sufficiently large that the zero-point logic doesn't just clear the gaps because it knows there's nothing in the file to read yet. Unmounting and mounting is needed to clear the pagecache (there are other ways to do that that may also work).
This was initially reproduced with the generic/522 xfstest on some patches that remove the FMODE_READ restriction.
--- fs/netfs/misc.c | 6 +++++- include/trace/events/netfs.h | 4 ++++ 2 files changed, 9 insertions(+), 1 deletion(-)
fs/netfs/misc.c +5 -1
@@ -263,6 +263,7 @@ void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length)/* Move the start of the data. */ finfo->dirty_len = fend - iend; finfo->dirty_offset = offset; +trace_netfs_folio (folio, netfs_folio_trace_invalidate_front);return ; }
@@ -271,12 +272,14 @@ void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length)*/ if (iend >= fend) { finfo->dirty_len = offset - fstart; +trace_netfs_folio (folio, netfs_folio_trace_invalidate_tail);return ; }/* A partial write was split. The caller has already zeroed * it, so just absorb the hole. */ +trace_netfs_folio (folio, netfs_folio_trace_invalidate_middle); }return ;
@@ -284,8 +287,9 @@ void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length)netfs_put_group (netfs_folio_group (folio));folio_detach_private (folio);folio_clear_uptodate (folio); +folio_cancel_dirty (folio);kfree (finfo); -return ; +trace_netfs_folio (folio, netfs_folio_trace_invalidate_all); }EXPORT_SYMBOL (netfs_invalidate_folio);
include/trace/events/netfs.h +4 -0
@@ -194,6 +194,10 @@ EM(netfs_folio_trace_copy_to_cache, "mark-copy") \ EM(netfs_folio_trace_end_copy, "end-copy") \ EM(netfs_folio_trace_filled_gaps, "filled-gaps") \ + EM(netfs_folio_trace_invalidate_all, "inval-all") \ + EM(netfs_folio_trace_invalidate_front, "inval-front") \ + EM(netfs_folio_trace_invalidate_middle, "inval-mid") \ + EM(netfs_folio_trace_invalidate_tail, "inval-tail") \ EM(netfs_folio_trace_kill, "kill") \ EM(netfs_folio_trace_kill_cc, "kill-cc") \EM (netfs_folio_trace_kill_g,"kill-g" ) \
David Howells
maintainerPATCH v6 12/24 netfs: Defer the emission of trace_netfs_folio()
In reply to David HowellsChange netfs_perform_write() to keep the netfs_folio trace value in a variable and emit it later to make it easier to choose the value displayed. This is a prerequisite for a subsequent patch.
--- fs/netfs/buffered_write.c | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-)
fs/netfs/buffered_write.c +10 -8
@@ -149,6 +149,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, } do { + enum netfs_folio_trace trace; struct netfs_folio *finfo; struct netfs_group *group; unsigned long long fpos;
@@ -222,7 +223,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,if (unlikely (copied ==0 )) goto copy_failed;netfs_set_group (folio, netfs_group); -trace_netfs_folio (folio, netfs_folio_is_uptodate); + trace = netfs_folio_is_uptodate; goto copied; }
@@ -238,7 +239,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,folio_zero_segment (folio, offset + copied, flen);__netfs_set_group (folio, netfs_group);folio_mark_uptodate (folio); -trace_netfs_folio (folio, netfs_modify_and_clear); + trace = netfs_modify_and_clear; goto copied; }
@@ -256,7 +257,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, }__netfs_set_group (folio, netfs_group);folio_mark_uptodate (folio); -trace_netfs_folio (folio, netfs_whole_folio_modify); + trace = netfs_whole_folio_modify; goto copied; }
@@ -283,7 +284,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,if (unlikely (copied ==0 )) goto copy_failed;netfs_set_group (folio, netfs_group); -trace_netfs_folio (folio, netfs_just_prefetch); + trace = netfs_just_prefetch; goto copied; }
@@ -297,7 +298,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,if (offset ==0 && copied == flen) {__netfs_set_group (folio, netfs_group);folio_mark_uptodate (folio); -trace_netfs_folio (folio, netfs_streaming_filled_page); + trace = netfs_streaming_filled_page; goto copied; }
@@ -312,7 +313,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, finfo->dirty_len = copied;folio_attach_private (folio, (void *)((unsigned long )finfo |NETFS_FOLIO_INFO )); -trace_netfs_folio (folio, netfs_streaming_write); + trace = netfs_streaming_write; goto copied; }
@@ -332,9 +333,9 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,folio_detach_private (folio);folio_mark_uptodate (folio);kfree (finfo); -trace_netfs_folio (folio, netfs_streaming_cont_filled_page); + trace = netfs_streaming_cont_filled_page; }else { -trace_netfs_folio (folio, netfs_streaming_write_cont); + trace = netfs_streaming_write_cont; } goto copied; }
@@ -350,6 +351,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,continue ; copied: +trace_netfs_folio (folio, trace);flush_dcache_folio (folio);/* Update the inode size if we moved the EOF marker */
David Howells
maintainerPATCH v6 13/24 netfs: Fix streaming write being overwritten
In reply to David HowellsIn order to avoid reading whilst writing, netfslib will allow "streaming writes" in which dirty data is stored directly into folios without reading them first. Such folios are marked dirty but may not be marked uptodate. If a folio is entirely written by a streaming write, uptodate will be set, otherwise it will have a netfs_folio struct attached to ->private recording the dirty region.
In the event that a partially written streaming write page is to be overwritten entirely by a single write(), netfs_perform_write() will try to copy over it, but doesn't discard the netfs_folio if it succeeds; further, it doesn't correctly handle a partial copy that overwrites some of the dirty data.
Fix this by the following:
(1) If the folio is successfully overwritten, free the netfs_folio struct before marking the page uptodate.
(2) If the copy to the folio partially fails, but short of the dirty data, just ignore the copy.
(3) If the copy partially fails and overwrites some of the dirty data, accept the copy, update the netfs_folio struct to record the new data. If the folio is now filled, free the netfs_folio and set uptodate, otherwise return a partial write.
Found with:
fsx -q -N 1000000 -p 10000 -o 128000 -l 600000 \ /xfstest.test/junk --replay-ops=junk.fsxops
using the following as junk.fsxops:
truncate 0x0 0 0x927c0 write 0x63fb8 0x53c8 0 copy_range 0xb704 0x19b9 0x24429 0x79380 write 0x2402b 0x144a2 0x90660 * write 0x204d5 0x140a0 0x927c0 * copy_range 0x1f72c 0x137d0 0x7a906 0x927c0 * read 0x00000 0x20000 0x9157c read 0x20000 0x20000 0x9157c read 0x40000 0x20000 0x9157c read 0x60000 0x20000 0x9157c read 0x7e1a0 0xcfb9 0x9157c
on cifs with the default cache option.
It shows folio 0x24 misbehaving if the FMODE_READ check is commented out in netfs_perform_write():
if (//(file->f_mode & FMODE_READ) ||
netfs_is_cache_enabled(ctx)) {and no fscache. This was initially found with the generic/522 xfstest.
--- fs/netfs/buffered_write.c | 47 ++++++++++++++++++++++++++---------- include/trace/events/netfs.h | 3 +++ 2 files changed, 37 insertions(+), 13 deletions(-)
fs/netfs/buffered_write.c +34 -13
@@ -246,18 +246,38 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,/* See if we can write a whole folio in one go. */ if (!maybe_trouble && offset ==0 && part >= flen) { copied =copy_folio_from_iter_atomic (folio, offset, part, iter); -if (unlikely (copied ==0 )) +if (likely (copied == part)) { +if (finfo) { + trace = netfs_whole_folio_modify_filled; + goto folio_now_filled; + } +__netfs_set_group (folio, netfs_group); +folio_mark_uptodate (folio); + trace = netfs_whole_folio_modify; + goto copied; + } +if (copied ==0 ) goto copy_failed; -if (unlikely (copied < part)) { +if (!finfo || copied <= finfo->dirty_offset) { maybe_trouble = true;iov_iter_revert (iter, copied); copied =0 ;folio_unlock (folio); goto retry; } -__netfs_set_group (folio, netfs_group); -folio_mark_uptodate (folio); - trace = netfs_whole_folio_modify; + +/* We overwrote some existing dirty data, so we have to +* accept the partial write. +*/ + finfo->dirty_len += finfo->dirty_offset; +if (finfo->dirty_len == flen) { + trace = netfs_whole_folio_modify_filled_efault; + goto folio_now_filled; + } +if (copied > finfo->dirty_len) + finfo->dirty_len = copied; + finfo->dirty_offset =0 ; + trace = netfs_whole_folio_modify_efault; goto copied; }
@@ -327,16 +347,10 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, goto copy_failed; finfo->dirty_len += copied;if (finfo->dirty_offset ==0 && finfo->dirty_len == flen) { -if (finfo->netfs_group) -folio_change_private (folio, finfo->netfs_group); -else -folio_detach_private (folio); -folio_mark_uptodate (folio); -kfree (finfo); trace = netfs_streaming_cont_filled_page; - }else { - trace = netfs_streaming_write_cont; + goto folio_now_filled; } + trace = netfs_streaming_write_cont; goto copied; }
@@ -350,6 +364,13 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, goto out;continue ; + folio_now_filled: +if (finfo->netfs_group) +folio_change_private (folio, finfo->netfs_group); +else +folio_detach_private (folio); +folio_mark_uptodate (folio); +kfree (finfo); copied:trace_netfs_folio (folio, trace);flush_dcache_folio (folio);
include/trace/events/netfs.h +3 -0
@@ -177,6 +177,9 @@ EM(netfs_folio_is_uptodate, "mod-uptodate") \ EM(netfs_just_prefetch, "mod-prefetch") \ EM(netfs_whole_folio_modify, "mod-whole-f") \ + EM(netfs_whole_folio_modify_efault, "mod-whole-f!") \ + EM(netfs_whole_folio_modify_filled, "mod-whole-f+") \ + EM(netfs_whole_folio_modify_filled_efault, "mod-whole-f+!") \ EM(netfs_modify_and_clear, "mod-n-clear") \ EM(netfs_streaming_write, "mod-streamw") \EM (netfs_streaming_write_cont,"mod-streamw+" ) \
David Howells
maintainerPATCH v6 14/24 netfs: Fix potential deadlock in write-through mode
In reply to David HowellsFix netfs_advance_writethrough() to always unlock the supplied folio and to mark it dirty if it isn't yet written to the end. Unfortunately, it can't be marked for writeback until the folio is done with as that may cause a deadlock against mmapped reads and writes.
Even though it has been marked dirty, premature writeback can't occur as the caller is holding both inode->i_rwsem (which will prevent concurrent truncation, fallocation, DIO and other writes) and ictx->wb_lock (which will cause flushing to wait and writeback to skip or wait).
Note that this may be easier to deal with once the queuing of folios is split from the generation of subrequests.
--- fs/netfs/write_issue.c | 39 +++++++++++++++++++++++++-------------- 1 file changed, 25 insertions(+), 14 deletions(-)
fs/netfs/write_issue.c +25 -14
@@ -414,12 +414,7 @@ static int netfs_write_folio(struct netfs_io_request *wreq,if (streamw)netfs_issue_write (wreq, cache); -/* Flip the page to the writeback state and unlock. If we're called -* from write-through, then the page has already been put into the wb -* state. -*/ -if (wreq->origin ==NETFS_WRITEBACK ) -folio_start_writeback (folio); +folio_start_writeback (folio);folio_unlock (folio);if (fgroup ==NETFS_FOLIO_COPY_TO_CACHE ) {
@@ -647,29 +642,41 @@ int netfs_advance_writethrough(struct netfs_io_request *wreq, struct writeback_c struct folio *folio, size_t copied, bool to_page_end, struct folio **writethrough_cache) { + int ret; +_enter ("R=%x ic=%zu ws=%u cp=%zu tp=%u" , wreq->debug_id, wreq->buffer.iter.count, wreq->wsize, copied, to_page_end); -if (!*writethrough_cache) { -if (folio_test_dirty (folio)) -/* Sigh. mmap. */ -folio_clear_dirty_for_io (folio); +/* The folio is locked. */ +if (*writethrough_cache != folio) { +if (*writethrough_cache) { +/* Did the folio get moved? */ +folio_put (*writethrough_cache); + *writethrough_cache =NULL ; + }/* We can make multiple writes to the folio... */ -folio_start_writeback (folio);if (wreq->len ==0 )trace_netfs_folio (folio, netfs_folio_trace_wthru);else trace_netfs_folio (folio, netfs_folio_trace_wthru_plus); *writethrough_cache = folio; +folio_get (folio); } wreq->len += copied; -if (!to_page_end) + +if (!to_page_end) { +folio_mark_dirty (folio); +folio_unlock (folio);return 0 ; + } + ret =netfs_write_folio (wreq, wbc, folio); +folio_put (*writethrough_cache); *writethrough_cache =NULL ; -return netfs_write_folio (wreq, wbc, folio); + wreq->submitted = wreq->len; +return ret; }/*
@@ -683,8 +690,12 @@ ssize_t netfs_end_writethrough(struct netfs_io_request *wreq, struct writeback_c_enter ("R=%x" , wreq->debug_id); -if (writethrough_cache) +if (writethrough_cache) { +folio_lock (writethrough_cache);netfs_write_folio (wreq, wbc, writethrough_cache); +folio_put (writethrough_cache); + wreq->submitted = wreq->len; + }netfs_end_issue_write (wreq);
David Howells
maintainerPATCH v6 15/24 netfs: Fix read-gaps to remove netfs_folio from filled folio
In reply to David HowellsFix netfs_read_gaps() to remove the netfs_folio record from the folio record before marking the folio uptodate if it successfully fills the gaps around the dirty data in a streaming write folio (dirty, but not uptodate).
Found with:
fsx -q -N 1000000 -p 10000 -o 128000 -l 600000 \
/xfstest.test/junk --replay-ops=junk.fsxopsusing the following as junk.fsxops:
truncate 0x0 0x138b1 0x8b15d *
write 0x507ee 0x10df7 0x927c0
write 0x19993 0x10e04 0x927c0 *
mapwrite 0x66214 0x1a253 0x927c0
copy_range 0xb704 0x89b9 0x24429 0x79380
write 0x2402b 0x144a2 0x90660 *
mapwrite 0x204d5 0x140a0 0x927c0 *
copy_range 0x1f72c 0x137d0 0x7a906 0x927c0 *
read 0 0x9157c 0x9157con cifs with the default cache option.
It shows folio 0x24 misbehaving if the FMODE_READ check is commented out in netfs_perform_write():
if (//(file->f_mode & FMODE_READ) ||
netfs_is_cache_enabled(ctx)) {and no fscache. This was initially found with the generic/522 xfstest.
--- fs/netfs/buffered_read.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)
fs/netfs/buffered_read.c +8 -3
@@ -395,6 +395,7 @@ static int netfs_read_gaps(struct file *file, struct folio *folio) {struct netfs_io_request *rreq;struct address_space *mapping = folio->mapping; +struct netfs_group *group =netfs_folio_group (folio);struct netfs_folio *finfo =netfs_folio_info (folio);struct netfs_inode *ctx =netfs_inode (mapping->host);struct folio *sink =NULL ;
@@ -461,6 +462,12 @@ static int netfs_read_gaps(struct file *file, struct folio *folio) ret =netfs_wait_for_read (rreq);if (ret >=0 ) { +if (group) +folio_change_private (folio, group); +else +folio_detach_private (folio); +kfree (finfo); +trace_netfs_folio (folio, netfs_folio_trace_filled_gaps);flush_dcache_folio (folio);folio_mark_uptodate (folio); }
@@ -496,10 +503,8 @@ int netfs_read_folio(struct file *file, struct folio *folio)struct netfs_inode *ctx =netfs_inode (mapping->host);int ret; -if (folio_test_dirty (folio)) { -trace_netfs_folio (folio, netfs_folio_trace_read_gaps); +if (folio_test_dirty (folio))return netfs_read_gaps (file, folio); - }_enter ("%lx" , folio->index);
David Howells
maintainerPATCH v6 16/24 netfs: Fix write streaming disablement if fd open O_RDWR
In reply to David HowellsIn netfs_perform_write(), "write streaming" (the caching of dirty data in dirty but !uptodate folios) is performed to avoid the need to read data that is just going to get immediately overwritten. However, this is/will be disabled in three circumstances: if the fd is open O_RDWR, if fscache is in use (as we need to round out the blocks for DIO) or if content encryption is enabled (again for rounding out purposes).
The idea behind disabling it if the fd is open O_RDWR is that we'd need to flush the write-streaming page before we could read the data, particularly through mmap. But netfs now fills in the gaps if ->read_folio() is called on the page, so that is unnecessary. Further, this doesn't actually work if a separate fd is open for reading.
Fix this by removing the check for O_RDWR, thereby allowing streaming writes even when we might read.
This caused a number of problems with the generic/522 xfstest, but those are now fixed.
--- fs/netfs/buffered_write.c | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-)
fs/netfs/buffered_write.c +7 -10
@@ -203,11 +203,11 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, }/* 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 avoid it. If we're doing local -* caching or content crypto, we award that priority over -* avoiding RMW. If the file is open readably, then we also -* assume that we may want to read what we wrote. +* to do write-streaming, as we don't want to a local RMW cycle +* if we can avoid it. If we're doing local caching or content +* crypto, we award that priority over avoiding RMW. If the +* file is open readably, then we let ->read_folio() fill in +* the gaps. */ finfo =netfs_folio_info (folio); group =netfs_folio_group (folio);
@@ -283,12 +283,9 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,/* We don't want to do a streaming write on a file that loses * caching service temporarily because the backing store got -* culled and we don't really want to get a streaming write on -* a file that's open for reading as ->read_folio() then has to -* be able to flush it. +* culled. */ -if ((file->f_mode &FMODE_READ ) || -netfs_is_cache_enabled (ctx)) { +if (netfs_is_cache_enabled (ctx)) {if (finfo) {netfs_stat (&netfs_n_wh_wstream_conflict); goto flush_content;
David Howells
maintainerPATCH v6 17/24 netfs: Fix early put of sink folio in netfs_read_gaps()
In reply to David HowellsFix netfs_read_gaps() to release the sink page it uses after waiting for the request to complete. The way the sink page is used is that an ITER_BVEC-class iterator is created that has the gaps from the target folio at either end, but has the sink page tiled over the middle so that a single read op can fill in both gaps.
The bug was found by KASAN detecting a UAF on the generic/075 xfstest in the cifsd kernel thread that handles reception of data from the TCP socket:
BUG: KASAN: use-after-free in _copy_to_iter+0x48a/0xa20 Write of size 885 at addr ffff888107f92000 by task cifsd/1285 CPU: 2 UID: 0 PID: 1285 Comm: cifsd Not tainted 7.0.0 #6 PREEMPT(lazy) Call Trace: dump_stack_lvl+0x5d/0x80 print_report+0x17f/0x4f1 kasan_report+0x100/0x1e0 kasan_check_range+0x10f/0x1e0 __asan_memcpy+0x3c/0x60 _copy_to_iter+0x48a/0xa20 __skb_datagram_iter+0x2c9/0x430 skb_copy_datagram_iter+0x6e/0x160 tcp_recvmsg_locked+0xce0/0x1130 tcp_recvmsg+0xeb/0x300 inet_recvmsg+0xcf/0x3a0 sock_recvmsg+0xea/0x100 cifs_readv_from_socket+0x3a6/0x4d0 [cifs] cifs_read_iter_from_socket+0xdd/0x130 [cifs] cifs_readv_receive+0xaad/0xb10 [cifs] cifs_demultiplex_thread+0x1148/0x1740 [cifs] kthread+0x1cf/0x210
--- fs/netfs/buffered_read.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
fs/netfs/buffered_read.c +3 -3
@@ -457,9 +457,6 @@ static int netfs_read_gaps(struct file *file, struct folio *folio)netfs_read_to_pagecache (rreq,NULL ); -if (sink) -folio_put (sink); - ret =netfs_wait_for_read (rreq);if (ret >=0 ) {if (group)
@@ -471,6 +468,9 @@ static int netfs_read_gaps(struct file *file, struct folio *folio)flush_dcache_folio (folio);folio_mark_uptodate (folio); } + +if (sink) +folio_put (sink);folio_unlock (folio);netfs_put_request (rreq, netfs_rreq_trace_put_return);return ret <0 ? ret :0 ;
David Howells
maintainerPATCH v6 18/24 netfs: Fix leak of request in netfs_write_begin() error handling
In reply to David HowellsFix netfs_write_begin() to not leak our ref on the request in the event that we get an error from netfs_wait_for_read().
--- fs/netfs/buffered_read.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/netfs/buffered_read.c +1 -1
@@ -687,9 +687,9 @@ int netfs_write_begin(struct netfs_inode *ctx,netfs_read_to_pagecache (rreq,NULL ); ret =netfs_wait_for_read (rreq); +netfs_put_request (rreq, netfs_rreq_trace_put_return);if (ret <0 ) goto error; -netfs_put_request (rreq, netfs_rreq_trace_put_return); have_folio: ret =folio_wait_private_2_killable (folio);
David Howells
maintainerPATCH v6 19/24 netfs: Fix potential UAF in netfs_unlock_abandoned_read_pages()
In reply to David Howellsnetfs_unlock_abandoned_read_pages(rreq) accesses the index of the folios it is wanting to unlock and compares that to rreq->no_unlock_folio so that it doesn't unlock a folio being read for netfs_perform_write() or netfs_write_begin().
However, given that netfs_unlock_abandoned_read_pages() is called _after_ NETFS_RREQ_IN_PROGRESS is cleared, the one folio that it's not allowed to dereference is the one specified by ->no_unlock_folio as ownership immediately reverts to the caller.
Fix this by storing the folio pointer instead and using that rather than the index. Also fix netfs_unlock_read_folio() where the same applies.
--- fs/netfs/buffered_read.c | 4 ++-- fs/netfs/read_collect.c | 2 +- fs/netfs/read_retry.c | 2 +- include/linux/netfs.h | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-)
fs/netfs/buffered_read.c +2 -2
@@ -670,7 +670,7 @@ int netfs_write_begin(struct netfs_inode *ctx, ret =PTR_ERR (rreq); goto error; } - rreq->no_unlock_folio = folio->index; + rreq->no_unlock_folio = folio;__set_bit (NETFS_RREQ_NO_UNLOCK_FOLIO , &rreq->flags); ret =netfs_begin_cache_read (rreq, ctx);
@@ -736,7 +736,7 @@ int netfs_prefetch_for_write(struct file *file, struct folio *folio, goto error; } - rreq->no_unlock_folio = folio->index; + rreq->no_unlock_folio = folio;__set_bit (NETFS_RREQ_NO_UNLOCK_FOLIO , &rreq->flags); ret =netfs_begin_cache_read (rreq, ctx);if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS )
fs/netfs/read_collect.c +1 -1
@@ -83,7 +83,7 @@ static void netfs_unlock_read_folio(struct netfs_io_request *rreq, } just_unlock: -if (folio->index == rreq->no_unlock_folio && +if (folio == rreq->no_unlock_folio &&test_bit (NETFS_RREQ_NO_UNLOCK_FOLIO , &rreq->flags)) {_debug ("no unlock" ); }else {
fs/netfs/read_retry.c +1 -1
@@ -292,7 +292,7 @@ void netfs_unlock_abandoned_read_pages(struct netfs_io_request *rreq)struct folio *folio =folioq_folio (p, slot);if (folio && !folioq_is_marked2 (p, slot)) { -if (folio->index == rreq->no_unlock_folio && +if (folio == rreq->no_unlock_folio &&test_bit (NETFS_RREQ_NO_UNLOCK_FOLIO , &rreq->flags)) {_debug ("no unlock" );
include/linux/netfs.h +1 -1
@@ -252,7 +252,7 @@ struct netfs_io_request {unsigned long long collected_to;/* Point we've collected to */ unsigned long long cleaned_to;/* Position we've cleaned folios to */ unsigned long long abandon_to;/* Position to abandon folios to */ -pgoff_t no_unlock_folio;/* Don't unlock this folio after read */ +const struct folio *no_unlock_folio;/* Don't unlock this folio after read */ unsigned int direct_bv_count;/* Number of elements in direct_bv[] */ unsigned int debug_id;unsigned int rsize;/* Maximum read size (0 for none) */
David Howells
maintainerPATCH v6 20/24 netfs: Fix partial invalidation of streaming-write folio
In reply to David HowellsIn netfs_invalidate_folio(), if the region of a partial invalidation overlaps the front (but not all) of a dirty write cached in a streaming write page (dirty, but not uptodate, with the dirty region tracked by a netfs_folio struct), the function modifies the dirty region - but incorrectly as it moves the region forward by setting the start to the start, not the end, of the invalidation region.
Fix this by setting finfo->dirty_offset to the end of the invalidation region (iend).
--- fs/netfs/misc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/netfs/misc.c +1 -1
@@ -262,7 +262,7 @@ void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length) goto erase_completely;/* Move the start of the data. */ finfo->dirty_len = fend - iend; - finfo->dirty_offset = offset; + finfo->dirty_offset = iend;trace_netfs_folio (folio, netfs_folio_trace_invalidate_front);return ; }
David Howells
maintainerPATCH v6 21/24 netfs: Fix folio->private handling in netfs_perform_write()
In reply to David HowellsUnder some circumstances, netfs_perform_write() doesn't correctly manipulate folio->private between NULL, NETFS_FOLIO_COPY_TO_CACHE, pointing to a group and pointing to a netfs_folio struct, leading to potential multiple attachments of private data with associated folio ref leaks and also leaks of netfs_folio structs or netfs_group refs.
Fix this by consolidating the place at which a folio is marked uptodate in one place and having that look at what's attached to folio->private and decide how to clean it up and then set the new group. Also, the content shouldn't be flushed if group is NULL, even if a group is specified in the netfs_group parameter, as that would be the case for a new folio. A filesystem should always specify netfs_group or never specify netfs_group.
The Sashiko auto-review tool noted that it was theoretically possible that the fpos >= ctx->zero_point section might leak if it modified a streaming write folio. This is unlikely, but with a network filesystem, third party changes can happen. It also pointed out that __netfs_set_group() would leak if called multiple times on the same folio from the "whole folio modify section".
--- fs/netfs/buffered_write.c | 134 +++++++++++++++++++++-------------- include/trace/events/netfs.h | 1 + 2 files changed, 82 insertions(+), 53 deletions(-)
fs/netfs/buffered_write.c +81 -53
@@ -12,24 +12,6 @@#include <linux/slab.h> #include "internal.h" -static void __netfs_set_group (struct folio *folio,struct netfs_group *netfs_group) -{ -if (netfs_group) -folio_attach_private (folio,netfs_get_group (netfs_group)); -} - -static void netfs_set_group (struct folio *folio,struct netfs_group *netfs_group) -{ -void *priv =folio_get_private (folio); - -if (unlikely (priv != netfs_group)) { -if (netfs_group && (!priv || priv ==NETFS_FOLIO_COPY_TO_CACHE )) -folio_attach_private (folio,netfs_get_group (netfs_group)); -else if (!netfs_group && priv ==NETFS_FOLIO_COPY_TO_CACHE ) -folio_detach_private (folio); - } -} -/* * 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.
@@ -157,6 +139,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,size_t offset;/* Offset into pagecache folio */ size_t part;/* Bytes to write to folio */ size_t copied;/* Bytes copied from user */ +void *priv; offset = pos & (max_chunk -1 ); part =min (max_chunk - offset,iov_iter_count (iter));
@@ -202,6 +185,25 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, goto error_folio_unlock; } + finfo =netfs_folio_info (folio); + group =netfs_folio_group (folio); + +/* If the requested group differs from the group set on the +* page, then we need to flush out the folio if it has a group +* set (ie. is non-NULL). Note that COPY_TO_CACHE is a special +* case, being a netfs annotation rather than an actual group. +* +* The filesystem isn't permitted to mix writes with groups and +* writes without groups as the NULL group is used to indicate +* that no group is set. +*/ +if (unlikely (group != netfs_group) && + group !=NETFS_FOLIO_COPY_TO_CACHE && + group) { +WARN_ON_ONCE (!netfs_group); + goto flush_content; + } +/* Decide how we should modify a folio. We might be attempting * to do write-streaming, as we don't want to a local RMW cycle * if we can avoid it. If we're doing local caching or content
@@ -209,22 +211,14 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,* file is open readably, then we let ->read_folio() fill in * the gaps. */ - finfo =netfs_folio_info (folio); - group =netfs_folio_group (folio); - -if (unlikely (group != netfs_group) && - group !=NETFS_FOLIO_COPY_TO_CACHE ) - goto flush_content; -if (folio_test_uptodate (folio)) {if (mapping_writably_mapped (mapping))flush_dcache_folio (folio); copied =copy_folio_from_iter_atomic (folio, offset, part, iter);if (unlikely (copied ==0 )) goto copy_failed; -netfs_set_group (folio, netfs_group); trace = netfs_folio_is_uptodate; - goto copied; + goto copied_uptodate; }/* If the page is above the zero-point then we assume that the
@@ -237,24 +231,22 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,if (unlikely (copied ==0 )) goto copy_failed;folio_zero_segment (folio, offset + copied, flen); -__netfs_set_group (folio, netfs_group); -folio_mark_uptodate (folio); - trace = netfs_modify_and_clear; - goto copied; +if (finfo) + trace = netfs_modify_and_clear_rm_finfo; +else + trace = netfs_modify_and_clear; + goto mark_uptodate; }/* See if we can write a whole folio in one go. */ if (!maybe_trouble && offset ==0 && part >= flen) { copied =copy_folio_from_iter_atomic (folio, offset, part, iter);if (likely (copied == part)) { -if (finfo) { +if (finfo) trace = netfs_whole_folio_modify_filled; - goto folio_now_filled; - } -__netfs_set_group (folio, netfs_group); -folio_mark_uptodate (folio); - trace = netfs_whole_folio_modify; - goto copied; +else + trace = netfs_whole_folio_modify; + goto mark_uptodate; }if (copied ==0 ) goto copy_failed;
@@ -272,7 +264,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, finfo->dirty_len += finfo->dirty_offset;if (finfo->dirty_len == flen) { trace = netfs_whole_folio_modify_filled_efault; - goto folio_now_filled; + goto mark_uptodate; }if (copied > finfo->dirty_len) finfo->dirty_len = copied;
@@ -300,11 +292,11 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, copied =copy_folio_from_iter_atomic (folio, offset, part, iter);if (unlikely (copied ==0 )) goto copy_failed; -netfs_set_group (folio, netfs_group); trace = netfs_just_prefetch; - goto copied; + goto copied_uptodate; } +/* Do a streaming write on a folio that has nothing in it yet. */ if (!finfo) { ret = -EIO ;if (WARN_ON (folio_get_private (folio)))
@@ -313,10 +305,8 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,if (unlikely (copied ==0 )) goto copy_failed;if (offset ==0 && copied == flen) { -__netfs_set_group (folio, netfs_group); -folio_mark_uptodate (folio); trace = netfs_streaming_filled_page; - goto copied; + goto mark_uptodate; } finfo =kzalloc_obj (*finfo);
@@ -345,7 +335,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, finfo->dirty_len += copied;if (finfo->dirty_offset ==0 && finfo->dirty_len == flen) { trace = netfs_streaming_cont_filled_page; - goto folio_now_filled; + goto mark_uptodate; } trace = netfs_streaming_write_cont; goto copied;
@@ -361,13 +351,36 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, goto out;continue ; - folio_now_filled: -if (finfo->netfs_group) -folio_change_private (folio, finfo->netfs_group); -else -folio_detach_private (folio); +/* Mark a folio as being up to data when we've filled it +* completely. If the folio has a group attached, then it must +* be the same group, otherwise we should have flushed it out +* above. We have to get rid of the netfs_folio struct if +* there was one. +*/ + mark_uptodate:folio_mark_uptodate (folio); -kfree (finfo); + + copied_uptodate: + priv =folio_get_private (folio); +if (likely (priv == netfs_group)) { +/* Already set correctly; no change required. */ + }else if (priv ==NETFS_FOLIO_COPY_TO_CACHE ) { +if (!netfs_group) +folio_detach_private (folio); +else +folio_change_private (folio,netfs_get_group (netfs_group)); + }else if (!priv) { +folio_attach_private (folio,netfs_get_group (netfs_group)); + }else { +WARN_ON_ONCE (!finfo); +if (netfs_group) +/* finfo->netfs_group has a ref */ +folio_change_private (folio, netfs_group); +else +folio_detach_private (folio); +kfree (finfo); + } + copied:trace_netfs_folio (folio, trace);flush_dcache_folio (folio);
@@ -530,6 +543,7 @@ vm_fault_t netfs_page_mkwrite(struct vm_fault *vmf, struct netfs_group *netfs_grstruct inode *inode =file_inode (file);struct netfs_inode *ictx =netfs_inode (inode);vm_fault_t ret =VM_FAULT_NOPAGE ; +void *priv;int err;_enter ("%lx" , folio->index);
@@ -550,7 +564,9 @@ vm_fault_t netfs_page_mkwrite(struct vm_fault *vmf, struct netfs_group *netfs_gr } group =netfs_folio_group (folio); -if (group != netfs_group && group !=NETFS_FOLIO_COPY_TO_CACHE ) { +if (group && + group != netfs_group && + group !=NETFS_FOLIO_COPY_TO_CACHE ) {folio_unlock (folio); err = filemap_fdatawrite_range(mapping, folio_pos(folio),
@@ -572,7 +588,19 @@ vm_fault_t netfs_page_mkwrite(struct vm_fault *vmf, struct netfs_group *netfs_grtrace_netfs_folio (folio, netfs_folio_trace_mkwrite_plus); elsetrace_netfs_folio (folio ,netfs_folio_trace_mkwrite ); -netfs_set_group (folio, netfs_group); + + priv =folio_get_private (folio); +if (priv != netfs_group) { +if (!netfs_group && priv ==NETFS_FOLIO_COPY_TO_CACHE ) +folio_detach_private (folio); +else if (netfs_group && priv ==NETFS_FOLIO_COPY_TO_CACHE ) +folio_change_private (folio,netfs_get_group (netfs_group)); +else if (netfs_group && !priv) +folio_attach_private (folio,netfs_get_group (netfs_group)); +else +WARN_ON_ONCE (1 ); + } +file_update_time (file);set_bit (NETFS_ICTX_MODIFIED_ATTR , &ictx->flags);if (ictx->ops->post_modify)
include/trace/events/netfs.h +1 -0
@@ -181,6 +181,7 @@ EM(netfs_whole_folio_modify_filled, "mod-whole-f+") \ EM(netfs_whole_folio_modify_filled_efault, "mod-whole-f+!") \ EM(netfs_modify_and_clear, "mod-n-clear") \ + EM(netfs_modify_and_clear_rm_finfo, "mod-n-clear+") \ EM(netfs_streaming_write, "mod-streamw") \ EM(netfs_streaming_write_cont, "mod-streamw+") \EM (netfs_flush_content,"flush" ) \
David Howells
maintainerPATCH v6 22/24 netfs: Fix netfs_read_folio() to wait on writeback
In reply to David HowellsFix netfs_read_folio() to wait for an ongoing writeback to complete so that it can trust the dirty flag and whatever is attached to folio->private (folio->private may get cleaned up by the collector before it clears the writeback flag).
--- fs/netfs/buffered_read.c | 2 ++ 1 file changed, 2 insertions(+)
fs/netfs/buffered_read.c +2 -0
@@ -503,6 +503,8 @@ int netfs_read_folio(struct file *file, struct folio *folio)struct netfs_inode *ctx =netfs_inode (mapping->host);int ret; +folio_wait_writeback (folio); +if (folio_test_dirty (folio))return netfs_read_gaps (file, folio);
David Howells
maintainerPATCH v6 23/24 netfs, afs: Fix write skipping in dir/link writepages
In reply to David HowellsFix netfs_write_single() and afs_single_writepages() to better handle a write that would be skipped due to lock contention and WB_SYNC_NONE by returning 1 from netfs_write_single() if it skipped and making afs_single_writepages() skip also. If a skip occurs, the inode must be re-marked as the VFS may have cleared the mark.
This is really only theoretical for directories in netfs_write_single() as the only path to that is through afs_single_writepages() that takes the ->validate_lock around it, thereby serialising it.
--- fs/afs/dir.c | 11 ++++++++++- fs/netfs/write_issue.c | 7 ++++++- 2 files changed, 16 insertions(+), 2 deletions(-)
fs/afs/dir.c +10 -1
@@ -2206,7 +2206,14 @@ int afs_single_writepages(struct address_space *mapping,/* Need to lock to prevent the folio queue and folios from being thrown * away. */ -down_read (&dvnode->validate_lock); +if (!down_read_trylock (&dvnode->validate_lock)) { +if (wbc->sync_mode ==WB_SYNC_NONE ) { +/* The VFS will have undirtied the inode. */ +netfs_single_mark_inode_dirty (&dvnode->netfs.inode); +return 0 ; + } +down_read (&dvnode->validate_lock); + } if (is_dir ? test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) :
@@ -2214,6 +2221,8 @@ int afs_single_writepages(struct address_space *mapping,iov_iter_folio_queue (&iter,ITER_SOURCE , dvnode->directory,0 ,0 ,i_size_read (&dvnode->netfs.inode)); ret =netfs_writeback_single (mapping, wbc, &iter); +if (ret ==1 ) + ret =0 ;/* Skipped write due to lock conflict. */ }up_read (&dvnode->validate_lock);
fs/netfs/write_issue.c +6 -1
@@ -830,6 +830,9 @@ static int netfs_write_folio_single(struct netfs_io_request *wreq,* * Write a monolithic, non-pagecache object back to the server and/or * the cache. +* +* Return: 0 if successful; 1 if skipped due to lock conflict and WB_SYNC_NONE; +* or a negative error code. */ int netfs_writeback_single(struct address_space *mapping, struct writeback_control *wbc,
@@ -846,8 +849,10 @@ int netfs_writeback_single(struct address_space *mapping,if (!mutex_trylock (&ictx->wb_lock)) {if (wbc->sync_mode ==WB_SYNC_NONE ) { +/* The VFS will have undirtied the inode. */ +netfs_single_mark_inode_dirty (&ictx->inode);netfs_stat (&netfs_n_wb_lock_skip); -return 0 ; +return 1 ; }netfs_stat (&netfs_n_wb_lock_wait);mutex_lock (&ictx->wb_lock);
David Howells
maintainerPATCH v6 24/24 afs: Fix the locking used by afs_get_link()
In reply to David HowellsThe afs filesystem in the kernel doesn't do locking correctly for symbolic links. There are a number of problems:
(1) It doesn't do any locking around afs_read_single() to prevent races
between multiple ->get_link() calls, thereby allowing the possibility
of leaks.(2) It doesn't use RCU barriering when accessing the buffer pointers during RCU pathwalk.
(3) It can race with another thread updating the contents of the symlink if a third party updated it on the server.
Fix this by the following means:
(0) Move symlink handling into its own file as this makes it more complicated.
(1) Take the validate_lock around afs_read_single() to prevent races
between multiple ->get_link() calls.
(2) Keep a separate copy of the symlink contents with an rcu_head. This is always going to be a lot smaller than a page, so it can be kmalloc'd and save quite a bit of memory. It also needs a refcount for non-RCU pathwalk.
(3) Split the symlink read and write-to-cache routines in afs from those for directories.
(4) Discard the I/O buffer as soon as the write-to-cache completes as this is a full page (plus a folio_queue).
(5) If there's no cache, discard the I/O buffer immediately after reading and copying if there is no cache.
--- fs/afs/Makefile | 1 + fs/afs/dir.c | 68 +++++------ fs/afs/fsclient.c | 4 +- fs/afs/inode.c | 96 +-------------- fs/afs/internal.h | 34 ++++-- fs/afs/symlink.c | 278 ++++++++++++++++++++++++++++++++++++++++++++ fs/afs/validation.c | 14 ++- fs/afs/yfsclient.c | 4 +- 8 files changed, 357 insertions(+), 142 deletions(-) create mode 100644 fs/afs/symlink.c
fs/afs/Makefile +1 -0
@@ -30,6 +30,7 @@ kafs-y := \ server.o \ server_list.o \ super.o \ + symlink.o \ validation.o \ vlclient.o \ vl_alias.o \
fs/afs/dir.c +34 -34
156 lines not on this page · raw message
fs/afs/fsclient.c +2 -2
@@ -886,7 +886,7 @@ void afs_fs_symlink(struct afs_operation *op) namesz = name->len; padsz = (4 - (namesz &3 )) &3 ; - c_namesz =strlen (op->create.symlink); + c_namesz =strlen (op->create.symlink->content); c_padsz = (4 - (c_namesz &3 )) &3 ; reqsz = (6 *4 ) + namesz + padsz + c_namesz + c_padsz + (6 *4 );
@@ -910,7 +910,7 @@ void afs_fs_symlink(struct afs_operation *op) bp = (void *) bp + padsz; } *bp++ =htonl (c_namesz); -memcpy (bp, op->create.symlink, c_namesz); +memcpy (bp, op->create.symlink->content, c_namesz); bp = (void *) bp + c_namesz;if (c_padsz >0 ) {memset (bp,0 , c_padsz);
fs/afs/inode.c +4 -92
119 lines not on this page · raw message
fs/afs/internal.h +26 -8
@@ -710,6 +710,7 @@ struct afs_vnode {#define AFS_VNODE_DIR_READ 11/* Set if we've read a dir's contents */ struct folio_queue *directory;/* Directory contents */ +struct afs_symlink __rcu *symlink;/* Symlink content */ struct list_head wb_keys;/* List of keys available for writeback */ struct list_head pending_locks;/* locks waiting to be granted */ struct list_head granted_locks;/* locks granted on this file */
@@ -776,6 +777,15 @@ struct afs_permits { struct afs_permit permits[] __counted_by(nr_permits); /* List of permits sorted by key pointer */ }; +/* +* Copy of symlink content for normal use. +*/ +struct afs_symlink { +struct rcu_head rcu; +refcount_t ref; +char content[]; +}; +/* * Error prioritisation and accumulation. */
@@ -887,7 +897,7 @@ struct afs_operation {struct {int reason;/* enum afs_edit_dir_reason */ mode_t mode; -const char *symlink; +struct afs_symlink *symlink; } create;struct {bool need_rehash;
@@ -1098,13 +1108,10 @@ extern const struct inode_operations afs_dir_inode_operations;extern const struct address_space_operations afs_dir_aops;extern const struct dentry_operations afs_fs_dentry_operations; -ssize_t afs_read_single (struct afs_vnode *dvnode,struct file *file); ssize_t afs_read_dir(struct afs_vnode *dvnode, struct file *file) __acquires(&dvnode->validate_lock);extern void afs_d_release (struct dentry *);extern void afs_check_for_remote_deletion (struct afs_operation *); -int afs_single_writepages (struct address_space *mapping, -struct writeback_control *wbc);/* * dir_edit.c
@@ -1247,10 +1254,6 @@ extern void afs_fs_probe_cleanup(struct afs_net *);*/ extern const struct afs_operation_ops afs_fetch_status_operation; -void afs_init_new_symlink (struct afs_vnode *vnode,struct afs_operation *op); -const char *afs_get_link (struct dentry *dentry,struct inode *inode, -struct delayed_call *callback); -int afs_readlink (struct dentry *dentry,char __user *buffer,int buflen);extern void afs_vnode_commit_status (struct afs_operation *,struct afs_vnode_param *);extern int afs_fetch_status (struct afs_vnode *,struct key *,bool ,afs_access_t *);extern int afs_ilookup5_test_by_fid (struct inode *,void *);
@@ -1600,6 +1603,21 @@ void afs_detach_volume_from_servers(struct afs_volume *volume, struct afs_serverextern int __init afs_fs_init (void );extern void afs_fs_exit (void ); +/* +* symlink.c +*/ +extern const struct inode_operations afs_symlink_inode_operations; +extern const struct address_space_operations afs_symlink_aops; + +void afs_invalidate_symlink (struct afs_vnode *vnode); +void afs_evict_symlink (struct afs_vnode *vnode); +void afs_init_new_symlink (struct afs_vnode *vnode,struct afs_operation *op); +const char *afs_get_link (struct dentry *dentry,struct inode *inode, +struct delayed_call *callback); +int afs_readlink (struct dentry *dentry,char __user *buffer,int buflen); +int afs_symlink_writepages (struct address_space *mapping, +struct writeback_control *wbc); +/* * validation.c */
fs/afs/symlink.c new file +278 -0
278 lines not on this page · raw message
fs/afs/validation.c +10 -4
@@ -465,11 +465,17 @@ int afs_validate(struct afs_vnode *vnode, struct key *key) vnode->cb_ro_snapshot = cb_ro_snapshot; vnode->cb_scrub = cb_scrub; -/* if the vnode's data version number changed then its contents are -* different */ +/* If the vnode's data version number changed then its contents are +* different. Note that afs_apply_status() doesn't set ZAP_DATA on +* directories. +*/ zap |=test_and_clear_bit (AFS_VNODE_ZAP_DATA , &vnode->flags); -if (zap) -afs_zap_data (vnode); +if (zap) { +if (S_ISREG (vnode->netfs.inode.i_mode)) +afs_zap_data (vnode); +else if (S_ISLNK (vnode->netfs.inode.i_mode)) +afs_invalidate_symlink (vnode); + }up_write (&vnode->validate_lock);_leave (" = 0" );return 0 ;
fs/afs/yfsclient.c +2 -2
@@ -960,7 +960,7 @@ void yfs_fs_symlink(struct afs_operation *op)_enter ("" ); - contents_sz =strlen (op->create.symlink); + contents_sz =strlen (op->create.symlink->content); call = afs_alloc_flat_call(op->net, &yfs_RXYFSSymlink, sizeof(__be32) + sizeof(struct yfs_xdr_RPCFlags) +
@@ -981,7 +981,7 @@ void yfs_fs_symlink(struct afs_operation *op) bp =xdr_encode_u32 (bp,0 );/* RPC flags */ bp =xdr_encode_YFSFid (bp, &dvp->fid); bp =xdr_encode_name (bp, name); - bp =xdr_encode_string (bp, op->create.symlink, contents_sz); + bp =xdr_encode_string (bp, op->create.symlink->content, contents_sz); bp =xdr_encode_YFSStoreStatus (bp, &mode, &op->mtime);yfs_check_req (call, bp);
Quoted 9 lines · David Howells
Here are the outstanding miscellaneous fixes for netfslib gathered together and with some fixes-to-fixes folded down and one rearrangement. Various Sashiko review comments[1][2][3][4][5] are addressed:
(1) Fix subrequest cancellation cleanup in DIO read and single-read.
(2) Fix missing locking around retry adding new subrequests.
[...]
Applied to the vfs.fixes branch of the vfs/vfs.git tree. Patches in the vfs.fixes branch should appear in linux-next soon.
Please report any outstanding bugs that were missed during review in a new review to the original patch series allowing us to drop it.
It's encouraged to provide Acked-bys and Reviewed-bys even though the patch has now been applied. If possible patch trailers will be updated.
Note that commit hashes shown below are subject to change due to rebase, trailer updates or similar. If in doubt, please check the listed branch.
tree: https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git branch: vfs.fixes
[01/24] netfs: Fix cancellation of a DIO and single read subrequests
https://git.kernel.org/vfs/vfs/c/6f0f7ac1915a [02/24] netfs: Fix missing locking around retry adding new subreqs https://git.kernel.org/vfs/vfs/c/cce18c263e96 [03/24] netfs: Fix missing barriers when accessing stream->subrequests locklessly https://git.kernel.org/vfs/vfs/c/b5782e2d462c [04/24] netfs: Fix netfs_read_to_pagecache() to pause on subreq failure https://git.kernel.org/vfs/vfs/c/8a8c0cfdf465 [05/24] netfs: Fix potential for tearing in ->remote_i_size and ->zero_point https://git.kernel.org/vfs/vfs/c/2c8f4742bb76 [06/24] netfs: Fix zeropoint update where i_size > remote_i_size https://git.kernel.org/vfs/vfs/c/4543a4d73794 [07/24] netfs: fix VM_BUG_ON_FOLIO() issue in netfs_write_begin() call https://git.kernel.org/vfs/vfs/c/dc7832d05deb [08/24] netfs: Fix potential uninitialised var in netfs_extract_user_iter() https://git.kernel.org/vfs/vfs/c/7e3d8db899d5 [09/24] netfs: fix error handling in netfs_extract_user_iter() https://git.kernel.org/vfs/vfs/c/0aad5704c6b4 [10/24] netfs: Fix overrun check in netfs_extract_user_iter() https://git.kernel.org/vfs/vfs/c/0ef37eef83fa [11/24] netfs: Fix netfs_invalidate_folio() to clear dirty bit if all changes gone https://git.kernel.org/vfs/vfs/c/156ac2ec2ee7 [12/24] netfs: Defer the emission of trace_netfs_folio() https://git.kernel.org/vfs/vfs/c/daeb443b9281 [13/24] netfs: Fix streaming write being overwritten https://git.kernel.org/vfs/vfs/c/7b4dcf1b9455 [14/24] netfs: Fix potential deadlock in write-through mode https://git.kernel.org/vfs/vfs/c/b6a4ae1634b3 [15/24] netfs: Fix read-gaps to remove netfs_folio from filled folio https://git.kernel.org/vfs/vfs/c/a41168aef634 [16/24] netfs: Fix write streaming disablement if fd open O_RDWR https://git.kernel.org/vfs/vfs/c/70a7b9193bbb [17/24] netfs: Fix early put of sink folio in netfs_read_gaps() https://git.kernel.org/vfs/vfs/c/3e5dd91b87a8 [18/24] netfs: Fix leak of request in netfs_write_begin() error handling https://git.kernel.org/vfs/vfs/c/5046a34f0643 [19/24] netfs: Fix potential UAF in netfs_unlock_abandoned_read_pages() https://git.kernel.org/vfs/vfs/c/dbe556972100 [20/24] netfs: Fix partial invalidation of streaming-write folio https://git.kernel.org/vfs/vfs/c/6d91acc7fb85 [21/24] netfs: Fix folio->private handling in netfs_perform_write() https://git.kernel.org/vfs/vfs/c/ccde2ac757c7 [22/24] netfs: Fix netfs_read_folio() to wait on writeback https://git.kernel.org/vfs/vfs/c/ded0c6f16060 [23/24] netfs, afs: Fix write skipping in dir/link writepages https://git.kernel.org/vfs/vfs/c/9871938f99cc [24/24] afs: Fix the locking used by afs_get_link() https://git.kernel.org/vfs/vfs/c/c0410adf3da6