[PATCH] netfs: Use rreq->issued_to instead of rreq->submitted

[David Howells <dhowells@redhat.com>]

The netfslib read side uses rreq->submitted to track what's been issued and
the write side uses rreq->issued_to - but both mean the same thing.

Switch the read side to use rreq->issued_to instead and get rid of
rreq->submitted.

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
---
 fs/netfs/buffered_read.c |   10 +++++-----
 fs/netfs/direct_read.c   |    4 ++--
 fs/netfs/main.c          |    2 +-
 fs/netfs/misc.c          |    2 +-
 fs/netfs/read_single.c   |    4 ++--
 fs/netfs/write_collect.c |    3 ++-
 include/linux/netfs.h    |    1 -
 7 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/fs/netfs/buffered_read.c b/fs/netfs/buffered_read.c
index fd4619275801..80143f17ed26 100644
--- a/fs/netfs/buffered_read.c
+++ b/fs/netfs/buffered_read.c
@@ -96,14 +96,14 @@ static ssize_t netfs_prepare_read_iterator(struct netfs_io_subrequest *subreq)
 		struct folio_batch put_batch;
 
 		folio_batch_init(&put_batch);
-		while (rreq->submitted < subreq->start + rsize) {
+		while (atomic64_read(&rreq->issued_to) < subreq->start + rsize) {
 			ssize_t added;
 
 			added = rolling_buffer_load_from_ra(&rreq->buffer, rreq->ractl,
 							    &put_batch);
 			if (added < 0)
 				return added;
-			rreq->submitted += added;
+			atomic64_add(added, &rreq->issued_to);
 		}
 		folio_batch_release(&put_batch);
 	}
@@ -360,7 +360,7 @@ void netfs_readahead(struct readahead_control *ractl)
 	netfs_rreq_expand(rreq, ractl);
 
 	rreq->ractl = ractl;
-	rreq->submitted = rreq->start;
+	atomic64_set(&rreq->issued_to, rreq->start);
 	if (rolling_buffer_init(&rreq->buffer, rreq->debug_id, ITER_DEST) < 0)
 		goto cleanup_free;
 	netfs_read_to_pagecache(rreq);
@@ -386,7 +386,7 @@ static int netfs_create_singular_buffer(struct netfs_io_request *rreq, struct fo
 	added = rolling_buffer_append(&rreq->buffer, folio, rollbuf_flags);
 	if (added < 0)
 		return added;
-	rreq->submitted = rreq->start + added;
+	atomic64_set(&rreq->issued_to, rreq->start + added);
 	rreq->ractl = (struct readahead_control *)1UL;
 	return 0;
 }
@@ -455,7 +455,7 @@ static int netfs_read_gaps(struct file *file, struct folio *folio)
 	if (to < flen)
 		bvec_set_folio(&bvec[i++], folio, flen - to, to);
 	iov_iter_bvec(&rreq->buffer.iter, ITER_DEST, bvec, i, rreq->len);
-	rreq->submitted = rreq->start + flen;
+	atomic64_set(&rreq->issued_to, rreq->start + flen);
 
 	netfs_read_to_pagecache(rreq);
 
diff --git a/fs/netfs/direct_read.c b/fs/netfs/direct_read.c
index 17738baa1124..210a11068455 100644
--- a/fs/netfs/direct_read.c
+++ b/fs/netfs/direct_read.c
@@ -94,7 +94,7 @@ static int netfs_dispatch_unbuffered_reads(struct netfs_io_request *rreq)
 		slice = subreq->len;
 		size -= slice;
 		start += slice;
-		rreq->submitted += slice;
+		atomic64_add(slice, &rreq->issued_to);
 		if (size <= 0) {
 			smp_wmb(); /* Write lists before ALL_QUEUED. */
 			set_bit(NETFS_RREQ_ALL_QUEUED, &rreq->flags);
@@ -143,7 +143,7 @@ static int netfs_unbuffered_read(struct netfs_io_request *rreq, bool sync)
 
 	ret = netfs_dispatch_unbuffered_reads(rreq);
 
-	if (!rreq->submitted) {
+	if (!atomic64_read(&rreq->issued_to)) {
 		netfs_put_request(rreq, netfs_rreq_trace_put_no_submit);
 		inode_dio_end(rreq->inode);
 		ret = 0;
diff --git a/fs/netfs/main.c b/fs/netfs/main.c
index 4e3e62040831..07b1adfac57f 100644
--- a/fs/netfs/main.c
+++ b/fs/netfs/main.c
@@ -72,7 +72,7 @@ static int netfs_requests_seq_show(struct seq_file *m, void *v)
 		   rreq->flags,
 		   rreq->error,
 		   0,
-		   rreq->start, rreq->submitted, rreq->len);
+		   rreq->start, atomic64_read(&rreq->issued_to), rreq->len);
 	seq_putc(m, '\n');
 	return 0;
 }
diff --git a/fs/netfs/misc.c b/fs/netfs/misc.c
index 77e7f7c79d27..055b7d53a018 100644
--- a/fs/netfs/misc.c
+++ b/fs/netfs/misc.c
@@ -464,7 +464,7 @@ static ssize_t netfs_wait_for_request(struct netfs_io_request *rreq,
 		case NETFS_UNBUFFERED_WRITE:
 			break;
 		default:
-			if (rreq->submitted < rreq->len) {
+			if (atomic64_read(&rreq->issued_to) < rreq->len) {
 				trace_netfs_failure(rreq, NULL, ret, netfs_fail_short_read);
 				ret = -EIO;
 			}
diff --git a/fs/netfs/read_single.c b/fs/netfs/read_single.c
index fa622a6cd56d..66926c80fda0 100644
--- a/fs/netfs/read_single.c
+++ b/fs/netfs/read_single.c
@@ -123,12 +123,12 @@ static int netfs_single_dispatch_read(struct netfs_io_request *rreq)
 		}
 
 		rreq->netfs_ops->issue_read(subreq);
-		rreq->submitted += subreq->len;
+		atomic64_add(subreq->len, &rreq->issued_to);
 		break;
 	case NETFS_READ_FROM_CACHE:
 		trace_netfs_sreq(subreq, netfs_sreq_trace_submit);
 		netfs_single_read_cache(rreq, subreq);
-		rreq->submitted += subreq->len;
+		atomic64_add(subreq->len, &rreq->issued_to);
 		ret = 0;
 		break;
 	default:
diff --git a/fs/netfs/write_collect.c b/fs/netfs/write_collect.c
index 3cc6a5a0919b..3dbde09b692d 100644
--- a/fs/netfs/write_collect.c
+++ b/fs/netfs/write_collect.c
@@ -27,7 +27,8 @@ static void netfs_dump_request(const struct netfs_io_request *rreq)
 	       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);
+	       rreq->start, rreq->transferred, atomic64_read(&rreq->issued_to),
+	       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);
diff --git a/include/linux/netfs.h b/include/linux/netfs.h
index 6869f6d36ee7..5ec7dfa7a9dc 100644
--- a/include/linux/netfs.h
+++ b/include/linux/netfs.h
@@ -250,7 +250,6 @@ struct netfs_io_request {
 	atomic_t		subreq_counter;	/* Next subreq->debug_index */
 	unsigned int		nr_group_rel;	/* Number of refs to release on ->group */
 	spinlock_t		lock;		/* Lock for queuing subreqs */
-	unsigned long long	submitted;	/* Amount submitted for I/O so far */
 	unsigned long long	len;		/* Length of the request */
 	size_t			transferred;	/* Amount to be indicated as transferred */
 	long			error;		/* 0 or error that occurred */