[PATCH v11 33/36] netfs: Set subrequest->source at alloc before trace emission
David Howells
dhowells at redhat.com
Wed Sep 2 10:33:45 PDT 2026
Set subrequest->source in netfs_alloc_subrequest() before we emit the trace
line indicating we allocated the subrequest. Note that this requires the
allocation of the subreq in netfs_read_to_pagecache() to be pushed to after
the decision about what sort of subreq it should be.
Signed-off-by: David Howells <dhowells at redhat.com>
cc: Paulo Alcantara <pc at manguebit.org>
cc: netfs at lists.linux.dev
cc: linux-fsdevel at vger.kernel.org
cc: linux-mm at kvack.org
---
fs/netfs/buffered_read.c | 69 ++++++++++++++++++++--------------------
fs/netfs/direct_read.c | 3 +-
fs/netfs/internal.h | 3 +-
fs/netfs/objects.c | 4 ++-
fs/netfs/read_retry.c | 3 +-
fs/netfs/read_single.c | 2 +-
fs/netfs/write_issue.c | 6 ++--
fs/netfs/write_retry.c | 3 +-
8 files changed, 45 insertions(+), 48 deletions(-)
diff --git a/fs/netfs/buffered_read.c b/fs/netfs/buffered_read.c
index 94bf9a2c2321..5178d9bba453 100644
--- a/fs/netfs/buffered_read.c
+++ b/fs/netfs/buffered_read.c
@@ -295,8 +295,11 @@ static void netfs_read_to_pagecache(struct netfs_io_request *rreq)
do {
int (*prepare_read)(struct netfs_io_subrequest *subreq) = NULL;
struct netfs_io_subrequest *subreq;
+ enum netfs_io_source source;
ssize_t slice;
uoff_t hole_to, cache_to;
+ size_t len = size;
+ bool copy = false;
/* If we don't have any, find out the next couple of data
* extents from the cache, containing of following the
@@ -327,48 +330,34 @@ static void netfs_read_to_pagecache(struct netfs_io_request *rreq)
continue;
}
- subreq = netfs_alloc_subrequest(rreq);
- if (!subreq) {
- ret = -ENOMEM;
- break;
- }
-
- subreq->start = start;
- subreq->len = size;
-
- netfs_queue_read(rreq, subreq);
-
uoff_t zero_point = netfs_read_zero_point(rreq->inode);
uoff_t zlimit = umin(zero_point, rreq->i_size);
- _debug("rsub %llx %llx-%llx", subreq->start, hole_to, cache_to);
+ _debug("rsub %llx %llx-%llx", start, hole_to, cache_to);
if (start >= hole_to && start < cache_to) {
/* Overlap with a cached region, where the cache may
* record a block of zeroes.
*/
_debug("cached s=%llx c=%llx l=%zx", start, cache_to, size);
- subreq->len = umin(cache_to - start, size);
- subreq->len = round_up(subreq->len, occ->granularity);
+ len = umin(cache_to - start, size);
+ len = round_up(len, occ->granularity);
if (occ->cached_type[0] == FSCACHE_EXTENT_ZERO) {
- subreq->source = NETFS_FILL_WITH_ZEROES;
+ source = NETFS_FILL_WITH_ZEROES;
netfs_stat(&netfs_n_rh_zero);
} else {
- subreq->source = NETFS_READ_FROM_CACHE;
+ source = NETFS_READ_FROM_CACHE;
prepare_read = rreq->cache_resources.ops->prepare_read;
}
-
- trace_netfs_sreq(subreq, netfs_sreq_trace_prepare);
-
- } else if (subreq->start >= zlimit && size > 0) {
+ } else if (start >= zlimit && size > 0) {
/* If this range lies beyond the zero-point, that part
* can just be cleared locally.
*/
_debug("zero %llx-%llx", start, start + size);
- subreq->len = size;
- subreq->source = NETFS_FILL_WITH_ZEROES;
+ len = size;
+ source = NETFS_FILL_WITH_ZEROES;
if (rreq->cache_resources.ops)
- __set_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
+ copy = true;
netfs_stat(&netfs_n_rh_zero);
} else {
/* Read a cache hole from the server. If any part of
@@ -379,22 +368,33 @@ static void netfs_read_to_pagecache(struct netfs_io_request *rreq)
_debug("limit %llx %llx", rreq->i_size, zero_point);
_debug("download %llx-%llx", start, start + size);
- subreq->len = umin(limit - subreq->start, ULONG_MAX);
- subreq->source = NETFS_DOWNLOAD_FROM_SERVER;
+ len = umin(limit - start, ULONG_MAX);
+ source = NETFS_DOWNLOAD_FROM_SERVER;
if (rreq->cache_resources.ops)
- __set_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
+ copy = true;
netfs_stat(&netfs_n_rh_download);
}
- if (size == 0) {
- 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, zero_point, rreq->i_size);
- netfs_cancel_read(subreq, ret);
+ if (len == 0) {
+ pr_err("ZERO-LEN READ: R=%08x l=%zx/%zx s=%llx z=%llx i=%llx",
+ rreq->debug_id, len, size,
+ start, zero_point, rreq->i_size);
+ break;
+ }
+
+ subreq = netfs_alloc_subrequest(rreq, source);
+ if (!subreq) {
+ ret = -ENOMEM;
break;
}
+ subreq->start = start;
+ subreq->len = size;
+ if (copy)
+ __set_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
+
+ netfs_queue_read(rreq, subreq);
+
rreq->io_streams[0].sreq_max_len = MAX_RW_COUNT;
rreq->io_streams[0].sreq_max_segs = INT_MAX;
@@ -418,10 +418,9 @@ static void netfs_read_to_pagecache(struct netfs_io_request *rreq)
if (size <= 0)
netfs_all_subreqs_queued(rreq);
+ /* See if the cache indicated this should be cached. */
if (mark_cursor.bvecq) {
- /* See if the cache indicated this should be cached. */
- bool copy = test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
-
+ copy = test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
netfs_mark_copy_to_cache(rreq, &mark_cursor, slice, copy);
}
diff --git a/fs/netfs/direct_read.c b/fs/netfs/direct_read.c
index 058cc6bb7124..40407bf9aa3f 100644
--- a/fs/netfs/direct_read.c
+++ b/fs/netfs/direct_read.c
@@ -33,7 +33,7 @@ static void netfs_dispatch_unbuffered_reads(struct netfs_io_request *rreq)
do {
struct netfs_io_subrequest *subreq;
- subreq = netfs_alloc_subrequest(rreq);
+ subreq = netfs_alloc_subrequest(rreq, NETFS_DOWNLOAD_FROM_SERVER);
if (!subreq) {
/* Stash the error in the request if there's not
* already an error set.
@@ -42,7 +42,6 @@ static void netfs_dispatch_unbuffered_reads(struct netfs_io_request *rreq)
break;
}
- subreq->source = NETFS_DOWNLOAD_FROM_SERVER;
subreq->start = start;
subreq->len = size;
diff --git a/fs/netfs/internal.h b/fs/netfs/internal.h
index bdf0f1ddcfec..e1e051ef60b4 100644
--- a/fs/netfs/internal.h
+++ b/fs/netfs/internal.h
@@ -93,7 +93,8 @@ void netfs_get_request(struct netfs_io_request *rreq, enum netfs_rreq_ref_trace
void netfs_clear_subrequests(struct netfs_io_request *rreq);
void netfs_put_request(struct netfs_io_request *rreq, enum netfs_rreq_ref_trace what);
void netfs_put_failed_request(struct netfs_io_request *rreq);
-struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreq);
+struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreq,
+ enum netfs_io_source source);
static inline void netfs_see_request(struct netfs_io_request *rreq,
enum netfs_rreq_ref_trace what)
diff --git a/fs/netfs/objects.c b/fs/netfs/objects.c
index 6852fa27eeb3..64fbb6e6c445 100644
--- a/fs/netfs/objects.c
+++ b/fs/netfs/objects.c
@@ -213,7 +213,8 @@ void netfs_put_failed_request(struct netfs_io_request *rreq)
/*
* Allocate and partially initialise an I/O request structure.
*/
-struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreq)
+struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreq,
+ enum netfs_io_source source)
{
struct netfs_io_subrequest *subreq;
mempool_t *mempool = rreq->netfs_ops->subrequest_pool ?: &netfs_subrequest_pool;
@@ -230,6 +231,7 @@ struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreq
INIT_WORK(&subreq->work, NULL);
INIT_LIST_HEAD(&subreq->rreq_link);
refcount_set(&subreq->ref, 2);
+ subreq->source = source;
subreq->rreq = rreq;
subreq->debug_index = atomic_inc_return(&rreq->subreq_counter);
netfs_get_request(rreq, netfs_rreq_trace_get_subreq);
diff --git a/fs/netfs/read_retry.c b/fs/netfs/read_retry.c
index 9dc531659259..08b0bf526759 100644
--- a/fs/netfs/read_retry.c
+++ b/fs/netfs/read_retry.c
@@ -210,12 +210,11 @@ static void netfs_retry_read_subrequests(struct netfs_io_request *rreq)
* and insert them after.
*/
do {
- subreq = netfs_alloc_subrequest(rreq);
+ subreq = netfs_alloc_subrequest(rreq, NETFS_DOWNLOAD_FROM_SERVER);
if (!subreq) {
subreq = to;
goto abandon_after;
}
- subreq->source = NETFS_DOWNLOAD_FROM_SERVER;
subreq->start = start;
subreq->len = len;
subreq->stream_nr = stream->stream_nr;
diff --git a/fs/netfs/read_single.c b/fs/netfs/read_single.c
index 9fd07dbb08b5..46dc22c3859b 100644
--- a/fs/netfs/read_single.c
+++ b/fs/netfs/read_single.c
@@ -86,7 +86,7 @@ static int netfs_single_dispatch_read(struct netfs_io_request *rreq)
struct netfs_io_subrequest *subreq;
int ret = 0;
- subreq = netfs_alloc_subrequest(rreq);
+ subreq = netfs_alloc_subrequest(rreq, NETFS_DOWNLOAD_FROM_SERVER);
if (!subreq)
return -ENOMEM;
diff --git a/fs/netfs/write_issue.c b/fs/netfs/write_issue.c
index a12846a66a3c..08bc84182847 100644
--- a/fs/netfs/write_issue.c
+++ b/fs/netfs/write_issue.c
@@ -193,11 +193,10 @@ struct netfs_io_subrequest *netfs_alloc_write_subreq(struct netfs_io_request *wr
{
struct netfs_io_subrequest *subreq;
- subreq = netfs_alloc_subrequest(wreq);
+ subreq = netfs_alloc_subrequest(wreq, stream->source);
if (!subreq)
return subreq;
- subreq->source = stream->source;
subreq->start = stream->issue_from;
subreq->len = stream->buffered;
subreq->stream_nr = stream->stream_nr;
@@ -245,10 +244,9 @@ void netfs_prepare_write(struct netfs_io_request *wreq,
{
struct netfs_io_subrequest *subreq;
- subreq = netfs_alloc_subrequest(wreq);
+ subreq = netfs_alloc_subrequest(wreq, stream->source);
if (!subreq)
return;
- subreq->source = stream->source;
subreq->start = start;
subreq->stream_nr = stream->stream_nr;
diff --git a/fs/netfs/write_retry.c b/fs/netfs/write_retry.c
index c61bed687244..7fa09e190203 100644
--- a/fs/netfs/write_retry.c
+++ b/fs/netfs/write_retry.c
@@ -158,8 +158,7 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq,
* and insert them after.
*/
do {
- subreq = netfs_alloc_subrequest(wreq);
- subreq->source = to->source;
+ subreq = netfs_alloc_subrequest(wreq, stream->source);
subreq->start = start;
subreq->stream_nr = to->stream_nr;
subreq->retry_count = 1;
More information about the linux-afs
mailing list