Unverified Commit 52d55922 authored by David Howells's avatar David Howells Committed by Christian Brauner
Browse files

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: default avatarDavid 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/

 # v2
Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parent 73425800

fs/afs/write.c

+3 −1
Original line number Diff line number Diff line
@@ -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;

}



/*

fs/cachefiles/io.c

+3 −2
Original line number Diff line number Diff line
@@ -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))

fs/netfs/io.c

+2 −2
Original line number Diff line number Diff line
@@ -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);

fs/netfs/write_collect.c

+5 −5
Original line number Diff line number Diff line
@@ -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;

fs/netfs/write_issue.c

+7 −7
Original line number Diff line number Diff line
@@ -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;