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.

Fixes: e2d46f2ec332 ("netfs: Change the read result collector to only use one work item")
Closes: https://sashiko.dev/#/patchset/20260425125426.3855807-1-dhowells%40redhat.com
Signed-off-by: David Howells <dhowells@redhat.com>
Link: https://patch.msgid.link/20260512123404.719402-2-dhowells@redhat.com
cc: Paulo Alcantara <pc@manguebit.org>
cc: netfs@lists.linux.dev
cc: linux-fsdevel@vger.kernel.org
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/netfs/buffered_read.c b/fs/netfs/buffered_read.c
index a8c0d86118c5851f6f1339cfc1a789db75da647b..a27ed501b6d436aec2432dfa8b7aebca3d98660e 100644 (file)
--- a/fs/netfs/buffered_read.c
+++ b/fs/netfs/buffered_read.c
@@ -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);

diff --git a/fs/netfs/direct_read.c b/fs/netfs/direct_read.c
index f72e6da88cca7c45eb451a0dc422cae79de2be1a..6a8fb0d55e040e667c74ff8285b1f4c51da6f314 100644 (file)
--- a/fs/netfs/direct_read.c
+++ b/fs/netfs/direct_read.c
@@ -45,12 +45,11 @@ static void netfs_prepare_dio_read_iterator(struct netfs_io_subrequest *subreq)
  * Perform a read to a buffer from the server, slicing up the region to be read
  * according to the network rsize.
  */
-static int netfs_dispatch_unbuffered_reads(struct netfs_io_request *rreq)
+static void netfs_dispatch_unbuffered_reads(struct netfs_io_request *rreq)
 {
-       struct netfs_io_stream *stream = &rreq->io_streams[0];
        unsigned long long start = rreq->start;
        ssize_t size = rreq->len;
-       int ret = 0;
+       int ret;
 
        do {
                struct netfs_io_subrequest *subreq;
@@ -58,7 +57,10 @@ static int netfs_dispatch_unbuffered_reads(struct netfs_io_request *rreq)
 
                subreq = netfs_alloc_subrequest(rreq);
                if (!subreq) {
-                       ret = -ENOMEM;
+                       /* Stash the error in the request if there's not
+                        * already an error set.
+                        */
+                       cmpxchg(&rreq->error, 0, -ENOMEM);
                        break;
                }
 
@@ -66,25 +68,13 @@ static int netfs_dispatch_unbuffered_reads(struct netfs_io_request *rreq)
                subreq->start   = start;
                subreq->len     = size;
 
-               __set_bit(NETFS_SREQ_IN_PROGRESS, &subreq->flags);
-
-               spin_lock(&rreq->lock);
-               list_add_tail(&subreq->rreq_link, &stream->subrequests);
-               if (list_is_first(&subreq->rreq_link, &stream->subrequests)) {
-                       if (!stream->active) {
-                               stream->collected_to = subreq->start;
-                               /* Store list pointers before active flag */
-                               smp_store_release(&stream->active, true);
-                       }
-               }
-               trace_netfs_sreq(subreq, netfs_sreq_trace_added);
-               spin_unlock(&rreq->lock);
+               netfs_queue_read(rreq, subreq);
 
                netfs_stat(&netfs_n_rh_download);
                if (rreq->netfs_ops->prepare_read) {
                        ret = rreq->netfs_ops->prepare_read(subreq);
                        if (ret < 0) {
-                               netfs_put_subrequest(subreq, netfs_sreq_trace_put_cancel);
+                               netfs_cancel_read(subreq, ret);
                                break;
                        }
                }
@@ -113,8 +103,6 @@ static int netfs_dispatch_unbuffered_reads(struct netfs_io_request *rreq)
                set_bit(NETFS_RREQ_ALL_QUEUED, &rreq->flags);
                netfs_wake_collector(rreq);
        }
-
-       return ret;
 }
 
 /*
@@ -137,21 +125,17 @@ static ssize_t netfs_unbuffered_read(struct netfs_io_request *rreq, bool sync)
        // TODO: Use bounce buffer if requested
 
        inode_dio_begin(rreq->inode);
+       netfs_dispatch_unbuffered_reads(rreq);
 
-       ret = netfs_dispatch_unbuffered_reads(rreq);
-
-       if (!rreq->submitted) {
-               netfs_put_request(rreq, netfs_rreq_trace_put_no_submit);
-               inode_dio_end(rreq->inode);
-               ret = 0;
-               goto out;
-       }
+       /* The collector will get run, even if we don't manage to submit any
+        * subreqs, so we shouldn't call inode_dio_end() here.
+        */
 
        if (sync)
                ret = netfs_wait_for_read(rreq);
        else
                ret = -EIOCBQUEUED;
-out:
+
        _leave(" = %zd", ret);
        return ret;
 }

diff --git a/fs/netfs/internal.h b/fs/netfs/internal.h
index d436e20d3418528782b673a269d28bfa5a44a708..645996ecfc80368af9cba9166194a2cadba51631 100644 (file)
--- a/fs/netfs/internal.h
+++ b/fs/netfs/internal.h
@@ -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);
 
 /*

diff --git a/fs/netfs/read_collect.c b/fs/netfs/read_collect.c
index e5f6665b3341ee27b1bbc8dbf09990d9eb4a453d..d2d902f466271d99f08bf85369d27ce101300a81 100644 (file)
--- a/fs/netfs/read_collect.c
+++ b/fs/netfs/read_collect.c
@@ -575,6 +575,17 @@ skip_error_checks:
 }
 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.
  */

diff --git a/fs/netfs/read_single.c b/fs/netfs/read_single.c
index d0e23bc42445ffde88deed785e14cf9eed8f1590..8833550d2eb608088f7df47501b71d0ef1517543 100644 (file)
--- a/fs/netfs/read_single.c
+++ b/fs/netfs/read_single.c
@@ -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;
 }