1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Network filesystem write retrying.
3 *
4 * Copyright (C) 2024 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8 #include <linux/fs.h>
9 #include <linux/mm.h>
10 #include <linux/pagemap.h>
11 #include <linux/slab.h>
12 #include "internal.h"
13
14 /*
15 * Perform retries on the streams that need it.
16 */
netfs_retry_write_stream(struct netfs_io_request * wreq,struct netfs_io_stream * stream)17 static void netfs_retry_write_stream(struct netfs_io_request *wreq,
18 struct netfs_io_stream *stream)
19 {
20 struct list_head *next;
21
22 _enter("R=%x[%x:]", wreq->debug_id, stream->stream_nr);
23
24 if (list_empty(&stream->subrequests))
25 return;
26
27 if (stream->source == NETFS_UPLOAD_TO_SERVER &&
28 wreq->netfs_ops->retry_request)
29 wreq->netfs_ops->retry_request(wreq, stream);
30
31 if (unlikely(stream->failed))
32 return;
33
34 /* If there's no renegotiation to do, just resend each failed subreq. */
35 if (!stream->prepare_write) {
36 struct netfs_io_subrequest *subreq;
37
38 list_for_each_entry(subreq, &stream->subrequests, rreq_link) {
39 if (test_bit(NETFS_SREQ_FAILED, &subreq->flags))
40 break;
41 if (__test_and_clear_bit(NETFS_SREQ_NEED_RETRY, &subreq->flags)) {
42 struct iov_iter source;
43
44 netfs_reset_iter(subreq);
45 source = subreq->io_iter;
46 netfs_get_subrequest(subreq, netfs_sreq_trace_get_resubmit);
47 netfs_reissue_write(stream, subreq, &source);
48 }
49 }
50 return;
51 }
52
53 next = stream->subrequests.next;
54
55 do {
56 struct netfs_io_subrequest *subreq = NULL, *from, *to, *tmp;
57 struct iov_iter source;
58 unsigned long long start, len;
59 size_t part;
60 bool boundary = false;
61
62 /* Go through the stream and find the next span of contiguous
63 * data that we then rejig (cifs, for example, needs the wsize
64 * renegotiating) and reissue.
65 */
66 from = list_entry(next, struct netfs_io_subrequest, rreq_link);
67 to = from;
68 start = from->start + from->transferred;
69 len = from->len - from->transferred;
70
71 if (test_bit(NETFS_SREQ_FAILED, &from->flags) ||
72 !test_bit(NETFS_SREQ_NEED_RETRY, &from->flags))
73 return;
74
75 list_for_each_continue(next, &stream->subrequests) {
76 subreq = list_entry(next, struct netfs_io_subrequest, rreq_link);
77 if (subreq->start + subreq->transferred != start + len ||
78 test_bit(NETFS_SREQ_BOUNDARY, &subreq->flags) ||
79 !test_bit(NETFS_SREQ_NEED_RETRY, &subreq->flags))
80 break;
81 to = subreq;
82 len += to->len;
83 }
84
85 /* Determine the set of buffers we're going to use. Each
86 * subreq gets a subset of a single overall contiguous buffer.
87 */
88 netfs_reset_iter(from);
89 source = from->io_iter;
90 source.count = len;
91
92 /* Work through the sublist. */
93 subreq = from;
94 list_for_each_entry_from(subreq, &stream->subrequests, rreq_link) {
95 if (!len)
96 break;
97
98 subreq->start = start;
99 subreq->len = len;
100 __clear_bit(NETFS_SREQ_NEED_RETRY, &subreq->flags);
101 trace_netfs_sreq(subreq, netfs_sreq_trace_retry);
102
103 /* Renegotiate max_len (wsize) */
104 stream->sreq_max_len = len;
105 stream->prepare_write(subreq);
106
107 part = umin(len, stream->sreq_max_len);
108 if (unlikely(stream->sreq_max_segs))
109 part = netfs_limit_iter(&source, 0, part, stream->sreq_max_segs);
110 subreq->len = part;
111 subreq->transferred = 0;
112 len -= part;
113 start += part;
114 if (len && subreq == to &&
115 __test_and_clear_bit(NETFS_SREQ_BOUNDARY, &to->flags))
116 boundary = true;
117
118 netfs_get_subrequest(subreq, netfs_sreq_trace_get_resubmit);
119 netfs_reissue_write(stream, subreq, &source);
120 if (subreq == to)
121 break;
122 }
123
124 /* If we managed to use fewer subreqs, we can discard the
125 * excess; if we used the same number, then we're done.
126 */
127 if (!len) {
128 if (subreq == to)
129 continue;
130 list_for_each_entry_safe_from(subreq, tmp,
131 &stream->subrequests, rreq_link) {
132 trace_netfs_sreq(subreq, netfs_sreq_trace_discard);
133 spin_lock(&wreq->lock);
134 list_del(&subreq->rreq_link);
135 spin_unlock(&wreq->lock);
136 netfs_put_subrequest(subreq, netfs_sreq_trace_put_done);
137 if (subreq == to)
138 break;
139 }
140 continue;
141 }
142
143 /* We ran out of subrequests, so we need to allocate some more
144 * and insert them after.
145 */
146 do {
147 subreq = netfs_alloc_subrequest(wreq);
148 subreq->source = to->source;
149 subreq->start = start;
150 subreq->stream_nr = to->stream_nr;
151 subreq->retry_count = 1;
152
153 trace_netfs_sreq_ref(wreq->debug_id, subreq->debug_index,
154 refcount_read(&subreq->ref),
155 netfs_sreq_trace_new);
156 trace_netfs_sreq(subreq, netfs_sreq_trace_split);
157
158 spin_lock(&wreq->lock);
159 list_add(&subreq->rreq_link, &to->rreq_link);
160 spin_unlock(&wreq->lock);
161 to = subreq;
162 trace_netfs_sreq(subreq, netfs_sreq_trace_retry);
163
164 stream->sreq_max_len = len;
165 stream->sreq_max_segs = INT_MAX;
166 switch (stream->source) {
167 case NETFS_UPLOAD_TO_SERVER:
168 netfs_stat(&netfs_n_wh_upload);
169 stream->sreq_max_len = umin(len, wreq->wsize);
170 break;
171 case NETFS_WRITE_TO_CACHE:
172 netfs_stat(&netfs_n_wh_write);
173 break;
174 default:
175 WARN_ON_ONCE(1);
176 }
177
178 stream->prepare_write(subreq);
179
180 part = umin(len, stream->sreq_max_len);
181 subreq->len = subreq->transferred + part;
182 len -= part;
183 start += part;
184 if (!len && boundary) {
185 __set_bit(NETFS_SREQ_BOUNDARY, &to->flags);
186 boundary = false;
187 }
188
189 netfs_reissue_write(stream, subreq, &source);
190 if (!len)
191 break;
192
193 } while (len);
194
195 } while (!list_is_head(next, &stream->subrequests));
196 }
197
198 /*
199 * Perform retries on the streams that need it. If we're doing content
200 * encryption and the server copy changed due to a third-party write, we may
201 * need to do an RMW cycle and also rewrite the data to the cache.
202 */
netfs_retry_writes(struct netfs_io_request * wreq)203 void netfs_retry_writes(struct netfs_io_request *wreq)
204 {
205 struct netfs_io_stream *stream;
206 int s;
207
208 netfs_stat(&netfs_n_wh_retry_write_req);
209
210 /* Wait for all outstanding I/O to quiesce before performing retries as
211 * we may need to renegotiate the I/O sizes.
212 */
213 set_bit(NETFS_RREQ_RETRYING, &wreq->flags);
214 for (s = 0; s < NR_IO_STREAMS; s++) {
215 stream = &wreq->io_streams[s];
216 if (stream->active)
217 netfs_wait_for_in_progress_stream(wreq, stream);
218 }
219 clear_bit(NETFS_RREQ_RETRYING, &wreq->flags);
220
221 // TODO: Enc: Fetch changed partial pages
222 // TODO: Enc: Reencrypt content if needed.
223 // TODO: Enc: Wind back transferred point.
224 // TODO: Enc: Mark cache pages for retry.
225
226 for (s = 0; s < NR_IO_STREAMS; s++) {
227 stream = &wreq->io_streams[s];
228 if (stream->need_retry) {
229 stream->need_retry = false;
230 netfs_retry_write_stream(wreq, stream);
231 }
232 }
233 }
234