netfs: Report on NULL folioq in netfs_writeback_unlock_folios()

It seems that it's possible to get to netfs_writeback_unlock_folios() with
an empty rolling buffer during buffered writes.  This should not be
possible as the rolling buffer is initialised as the write request is set
up and thereafter maintains at least one folio_queue struct therein until
it gets destroyed.  This allows lockless addition and removal of
folio_queue structs in the buffer because, unlike with a ring buffer, the
producer and consumer each only need to look at and alter one pointer into
the buffer.

Now, the rolling buffer is only used for buffered I/O operations as
netfs_collect_write_results() should only call
netfs_writeback_unlock_folios() if the request is of origin type
NETFS_WRITEBACK, NETFS_WRITETHROUGH or NETFS_PGPRIV2_COPY_TO_CACHE.

So it would seem that one of the following occurred: (1) I/O started before
the request was fully initialised, (2) the origin got switched mid-flow or
(3) the request has already been freed and this is a UAF error.  I think
the last is the most likely.

Make netfs_writeback_unlock_folios() report information about the request
and subrequests if folioq is seen to be NULL to try and help debug this,
throw a warning and return.

Note that this does not try to fix the problem.

Reported-by: syzbot+af5c06208fa71bf31b16@syzkaller.appspotmail.com
Link: https://syzkaller.appspot.com/bug?extid=af5c06208fa71bf31b16
Signed-off-by: David Howells <dhowells@redhat.com>
Link: https://lore.kernel.org/r/ZxshMEW4U7MTgQYa@gmail.com/
Link: https://lore.kernel.org/r/20241216204124.3752367-33-dhowells@redhat.com
cc: Chang Yu <marcus.yu.56@gmail.com>
cc: Jeff Layton <jlayton@kernel.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/write_collect.c b/fs/netfs/write_collect.c
index 1b7f53d01b8d0c08024c919b4c9dd971616dd36f..294f67795f79164a35c6dc3e090a23e2543641fd 100644 (file)
--- a/fs/netfs/write_collect.c
+++ b/fs/netfs/write_collect.c
@@ -21,6 +21,34 @@
 #define NEED_RETRY             0x10    /* A front op requests retrying */
 #define SAW_FAILURE            0x20    /* One stream or hit a permanent failure */
 
+static void netfs_dump_request(const struct netfs_io_request *rreq)
+{
+       pr_err("Request R=%08x r=%d fl=%lx or=%x e=%ld\n",
+              rreq->debug_id, refcount_read(&rreq->ref), rreq->flags,
+              rreq->origin, rreq->error);
+       pr_err("  st=%llx tsl=%zx/%llx/%llx\n",
+              rreq->start, rreq->transferred, rreq->submitted, rreq->len);
+       pr_err("  cci=%llx/%llx/%llx\n",
+              rreq->cleaned_to, rreq->collected_to, atomic64_read(&rreq->issued_to));
+       pr_err("  iw=%pSR\n", rreq->netfs_ops->issue_write);
+       for (int i = 0; i < NR_IO_STREAMS; i++) {
+               const struct netfs_io_subrequest *sreq;
+               const struct netfs_io_stream *s = &rreq->io_streams[i];
+
+               pr_err("  str[%x] s=%x e=%d acnf=%u,%u,%u,%u\n",
+                      s->stream_nr, s->source, s->error,
+                      s->avail, s->active, s->need_retry, s->failed);
+               pr_err("  str[%x] ct=%llx t=%zx\n",
+                      s->stream_nr, s->collected_to, s->transferred);
+               list_for_each_entry(sreq, &s->subrequests, rreq_link) {
+                       pr_err("  sreq[%x:%x] sc=%u s=%llx t=%zx/%zx r=%d f=%lx\n",
+                              sreq->stream_nr, sreq->debug_index, sreq->source,
+                              sreq->start, sreq->transferred, sreq->len,
+                              refcount_read(&sreq->ref), sreq->flags);
+               }
+       }
+}
+
 /*
  * Successful completion of write of a folio to the server and/or cache.  Note
  * that we are not allowed to lock the folio here on pain of deadlocking with
@@ -87,6 +115,12 @@ static void netfs_writeback_unlock_folios(struct netfs_io_request *wreq,
        unsigned long long collected_to = wreq->collected_to;
        unsigned int slot = wreq->buffer.first_tail_slot;
 
+       if (WARN_ON_ONCE(!folioq)) {
+               pr_err("[!] Writeback unlock found empty rolling buffer!\n");
+               netfs_dump_request(wreq);
+               return;
+       }
+
        if (wreq->origin == NETFS_PGPRIV2_COPY_TO_CACHE) {
                if (netfs_pgpriv2_unlock_copied_folios(wreq))
                        *notes |= MADE_PROGRESS;