netfs: Move max_len/max_nr_segs from netfs_io_subrequest to netfs_io_stream

Move max_len/max_nr_segs from struct netfs_io_subrequest to struct
netfs_io_stream as we only issue one subreq at a time and then don't need
these values again for that subreq unless and until we have to retry it -
in which case we want to renegotiate them.

Signed-off-by: David Howells <dhowells@redhat.com>
cc: Jeff Layton <jlayton@kernel.org>
cc: netfs@lists.linux.dev
cc: linux-fsdevel@vger.kernel.org
Link: https://lore.kernel.org/r/20240814203850.2240469-8-dhowells@redhat.com/
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/afs/write.c b/fs/afs/write.c
index e959640694c25c67f97b2b79cb8065de3d68f714..34107b55f834c8eede7d05232911ed0fe8ac9b17 100644 (file)
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -89,10 +89,12 @@ static const struct afs_operation_ops afs_store_data_operation = {
  */
 void afs_prepare_write(struct netfs_io_subrequest *subreq)
 {
+       struct netfs_io_stream *stream = &subreq->rreq->io_streams[subreq->stream_nr];
+
        //if (test_bit(NETFS_SREQ_RETRYING, &subreq->flags))
        //      subreq->max_len = 512 * 1024;
        //else
-       subreq->max_len = 256 * 1024 * 1024;
+       stream->sreq_max_len = 256 * 1024 * 1024;
 }
 
 /*

diff --git a/fs/cachefiles/io.c b/fs/cachefiles/io.c
index a91acd03ee1299da5311338d9f1e7d8d4496ec20..5b82ba7785cd3dadea35031dc83bfab75f5e4182 100644 (file)
--- a/fs/cachefiles/io.c
+++ b/fs/cachefiles/io.c
@@ -627,11 +627,12 @@ static void cachefiles_prepare_write_subreq(struct netfs_io_subrequest *subreq)
 {
        struct netfs_io_request *wreq = subreq->rreq;
        struct netfs_cache_resources *cres = &wreq->cache_resources;
+       struct netfs_io_stream *stream = &wreq->io_streams[subreq->stream_nr];
 
        _enter("W=%x[%x] %llx", wreq->debug_id, subreq->debug_index, subreq->start);
 
-       subreq->max_len = MAX_RW_COUNT;
-       subreq->max_nr_segs = BIO_MAX_VECS;
+       stream->sreq_max_len = MAX_RW_COUNT;
+       stream->sreq_max_segs = BIO_MAX_VECS;
 
        if (!cachefiles_cres_file(cres)) {
                if (!fscache_wait_for_operation(cres, FSCACHE_WANT_WRITE))

diff --git a/fs/netfs/io.c b/fs/netfs/io.c
index 943128507af550f36a9d90a0e245e2e810ce555f..ad9580c2dd6c4b4a10e58de67e3c1560a0087fbe 100644 (file)
--- a/fs/netfs/io.c
+++ b/fs/netfs/io.c
@@ -624,9 +624,9 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq,
                        goto out;
                }
 
-               if (subreq->max_nr_segs) {
+               if (rreq->io_streams[0].sreq_max_segs) {
                        lsize = netfs_limit_iter(io_iter, 0, subreq->len,
-                                                subreq->max_nr_segs);
+                                                rreq->io_streams[0].sreq_max_segs);
                        if (subreq->len > lsize) {
                                subreq->len = lsize;
                                trace_netfs_sreq(subreq, netfs_sreq_trace_limited);

diff --git a/fs/netfs/write_collect.c b/fs/netfs/write_collect.c
index ae7a2043f67036b9a21e2a038188885ac4b13d74..90abc21cc019f77d4d05813c2cfc6e4c8824635c 100644 (file)
--- a/fs/netfs/write_collect.c
+++ b/fs/netfs/write_collect.c
@@ -238,7 +238,7 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq,
                        __set_bit(NETFS_SREQ_RETRYING, &subreq->flags);
                        stream->prepare_write(subreq);
 
-                       part = min(len, subreq->max_len);
+                       part = min(len, stream->sreq_max_len);
                        subreq->len = part;
                        subreq->start = start;
                        subreq->transferred = 0;
@@ -278,8 +278,6 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq,
                        subreq = netfs_alloc_subrequest(wreq);
                        subreq->source          = to->source;
                        subreq->start           = start;
-                       subreq->max_len         = len;
-                       subreq->max_nr_segs     = INT_MAX;
                        subreq->debug_index     = atomic_inc_return(&wreq->subreq_counter);
                        subreq->stream_nr       = to->stream_nr;
                        __set_bit(NETFS_SREQ_RETRYING, &subreq->flags);
@@ -293,10 +291,12 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq,
                        to = list_next_entry(to, rreq_link);
                        trace_netfs_sreq(subreq, netfs_sreq_trace_retry);
 
+                       stream->sreq_max_len    = len;
+                       stream->sreq_max_segs   = INT_MAX;
                        switch (stream->source) {
                        case NETFS_UPLOAD_TO_SERVER:
                                netfs_stat(&netfs_n_wh_upload);
-                               subreq->max_len = min(len, wreq->wsize);
+                               stream->sreq_max_len = umin(len, wreq->wsize);
                                break;
                        case NETFS_WRITE_TO_CACHE:
                                netfs_stat(&netfs_n_wh_write);
@@ -307,7 +307,7 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq,
 
                        stream->prepare_write(subreq);
 
-                       part = min(len, subreq->max_len);
+                       part = umin(len, stream->sreq_max_len);
                        subreq->len = subreq->transferred + part;
                        len -= part;
                        start += part;

diff --git a/fs/netfs/write_issue.c b/fs/netfs/write_issue.c
index 44f35a0faaca14b765d4504bc7df118a8d90b777..34e541afd79b5bce936eff65cfe8aedc35011052 100644 (file)
--- a/fs/netfs/write_issue.c
+++ b/fs/netfs/write_issue.c
@@ -158,8 +158,6 @@ static void netfs_prepare_write(struct netfs_io_request *wreq,
        subreq = netfs_alloc_subrequest(wreq);
        subreq->source          = stream->source;
        subreq->start           = start;
-       subreq->max_len         = ULONG_MAX;
-       subreq->max_nr_segs     = INT_MAX;
        subreq->stream_nr       = stream->stream_nr;
 
        _enter("R=%x[%x]", wreq->debug_id, subreq->debug_index);
@@ -170,10 +168,12 @@ static void netfs_prepare_write(struct netfs_io_request *wreq,
 
        trace_netfs_sreq(subreq, netfs_sreq_trace_prepare);
 
+       stream->sreq_max_len    = UINT_MAX;
+       stream->sreq_max_segs   = INT_MAX;
        switch (stream->source) {
        case NETFS_UPLOAD_TO_SERVER:
                netfs_stat(&netfs_n_wh_upload);
-               subreq->max_len = wreq->wsize;
+               stream->sreq_max_len = wreq->wsize;
                break;
        case NETFS_WRITE_TO_CACHE:
                netfs_stat(&netfs_n_wh_write);
@@ -290,13 +290,13 @@ int netfs_advance_write(struct netfs_io_request *wreq,
                netfs_prepare_write(wreq, stream, start);
        subreq = stream->construct;
 
-       part = min(subreq->max_len - subreq->len, len);
-       _debug("part %zx/%zx %zx/%zx", subreq->len, subreq->max_len, part, len);
+       part = umin(stream->sreq_max_len - subreq->len, len);
+       _debug("part %zx/%zx %zx/%zx", subreq->len, stream->sreq_max_len, part, len);
        subreq->len += part;
        subreq->nr_segs++;
 
-       if (subreq->len >= subreq->max_len ||
-           subreq->nr_segs >= subreq->max_nr_segs ||
+       if (subreq->len >= stream->sreq_max_len ||
+           subreq->nr_segs >= stream->sreq_max_segs ||
            to_eof) {
                netfs_issue_write(wreq, stream);
                subreq = NULL;

diff --git a/fs/smb/client/file.c b/fs/smb/client/file.c
index 283c9b6d9094c6aa680e2214194f08f65bed690d..ceef7048cad237d1a3e729699fddf8d802f0822f 100644 (file)
--- a/fs/smb/client/file.c
+++ b/fs/smb/client/file.c
@@ -49,6 +49,7 @@ static void cifs_prepare_write(struct netfs_io_subrequest *subreq)
        struct cifs_io_subrequest *wdata =
                container_of(subreq, struct cifs_io_subrequest, subreq);
        struct cifs_io_request *req = wdata->req;
+       struct netfs_io_stream *stream = &req->rreq.io_streams[subreq->stream_nr];
        struct TCP_Server_Info *server;
        struct cifsFileInfo *open_file = req->cfile;
        size_t wsize = req->rreq.wsize;
@@ -73,7 +74,7 @@ retry:
                }
        }
 
-       rc = server->ops->wait_mtu_credits(server, wsize, &wdata->subreq.max_len,
+       rc = server->ops->wait_mtu_credits(server, wsize, &stream->sreq_max_len,
                                           &wdata->credits);
        if (rc < 0) {
                subreq->error = rc;
@@ -92,7 +93,7 @@ retry:
 
 #ifdef CONFIG_CIFS_SMB_DIRECT
        if (server->smbd_conn)
-               subreq->max_nr_segs = server->smbd_conn->max_frmr_depth;
+               stream->sreq_max_segs = server->smbd_conn->max_frmr_depth;
 #endif
 }
 
@@ -150,11 +151,11 @@ static void cifs_netfs_invalidate_cache(struct netfs_io_request *wreq)
 static bool cifs_clamp_length(struct netfs_io_subrequest *subreq)
 {
        struct netfs_io_request *rreq = subreq->rreq;
+       struct netfs_io_stream *stream = &rreq->io_streams[subreq->stream_nr];
        struct cifs_io_subrequest *rdata = container_of(subreq, struct cifs_io_subrequest, subreq);
        struct cifs_io_request *req = container_of(subreq->rreq, struct cifs_io_request, rreq);
        struct TCP_Server_Info *server = req->server;
        struct cifs_sb_info *cifs_sb = CIFS_SB(rreq->inode->i_sb);
-       size_t rsize;
        int rc;
 
        rdata->xid = get_xid();
@@ -168,7 +169,7 @@ static bool cifs_clamp_length(struct netfs_io_subrequest *subreq)
 
 
        rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
-                                          &rsize, &rdata->credits);
+                                          &stream->sreq_max_len, &rdata->credits);
        if (rc) {
                subreq->error = rc;
                return false;
@@ -184,12 +185,12 @@ static bool cifs_clamp_length(struct netfs_io_subrequest *subreq)
                              server->credits, server->in_flight, 0,
                              cifs_trace_rw_credits_read_submit);
 
-       subreq->len = umin(subreq->len, rsize);
+       subreq->len = umin(subreq->len, stream->sreq_max_len);
        rdata->actual_len = subreq->len;
 
 #ifdef CONFIG_CIFS_SMB_DIRECT
        if (server->smbd_conn)
-               subreq->max_nr_segs = server->smbd_conn->max_frmr_depth;
+               stream->sreq_max_segs = server->smbd_conn->max_frmr_depth;
 #endif
        return true;
 }

diff --git a/include/linux/netfs.h b/include/linux/netfs.h
index 71c748c53a1f11787a1576321abeae0b2159a898..eea5ea2842f60fdadd149cdd5302285c6c8fd04d 100644 (file)
--- a/include/linux/netfs.h
+++ b/include/linux/netfs.h
@@ -134,6 +134,8 @@ static inline struct netfs_group *netfs_folio_group(struct folio *folio)
 struct netfs_io_stream {
        /* Submission tracking */
        struct netfs_io_subrequest *construct;  /* Op being constructed */
+       size_t                  sreq_max_len;   /* Maximum size of a subrequest */
+       unsigned int            sreq_max_segs;  /* 0 or max number of segments in an iterator */
        unsigned int            submit_off;     /* Folio offset we're submitting from */
        unsigned int            submit_len;     /* Amount of data left to submit */
        unsigned int            submit_max_len; /* Amount I/O can be rounded up to */
@@ -177,14 +179,12 @@ struct netfs_io_subrequest {
        struct list_head        rreq_link;      /* Link in rreq->subrequests */
        struct iov_iter         io_iter;        /* Iterator for this subrequest */
        unsigned long long      start;          /* Where to start the I/O */
-       size_t                  max_len;        /* Maximum size of the I/O */
        size_t                  len;            /* Size of the I/O */
        size_t                  transferred;    /* Amount of data transferred */
        refcount_t              ref;
        short                   error;          /* 0 or error that occurred */
        unsigned short          debug_index;    /* Index in list (for debugging output) */
        unsigned int            nr_segs;        /* Number of segs in io_iter */
-       unsigned int            max_nr_segs;    /* 0 or max number of segments in an iterator */
        enum netfs_io_source    source;         /* Where to read from/write to */
        unsigned char           stream_nr;      /* I/O stream this belongs to */
        unsigned long           flags;