GNU Linux-libre 6.1.86-gnu
[releases.git] / fs / netfs / io.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Network filesystem high-level read support.
3  *
4  * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  */
7
8 #include <linux/module.h>
9 #include <linux/export.h>
10 #include <linux/fs.h>
11 #include <linux/mm.h>
12 #include <linux/pagemap.h>
13 #include <linux/slab.h>
14 #include <linux/uio.h>
15 #include <linux/sched/mm.h>
16 #include <linux/task_io_accounting_ops.h>
17 #include "internal.h"
18
19 /*
20  * Clear the unread part of an I/O request.
21  */
22 static void netfs_clear_unread(struct netfs_io_subrequest *subreq)
23 {
24         struct iov_iter iter;
25
26         iov_iter_xarray(&iter, ITER_DEST, &subreq->rreq->mapping->i_pages,
27                         subreq->start + subreq->transferred,
28                         subreq->len   - subreq->transferred);
29         iov_iter_zero(iov_iter_count(&iter), &iter);
30 }
31
32 static void netfs_cache_read_terminated(void *priv, ssize_t transferred_or_error,
33                                         bool was_async)
34 {
35         struct netfs_io_subrequest *subreq = priv;
36
37         netfs_subreq_terminated(subreq, transferred_or_error, was_async);
38 }
39
40 /*
41  * Issue a read against the cache.
42  * - Eats the caller's ref on subreq.
43  */
44 static void netfs_read_from_cache(struct netfs_io_request *rreq,
45                                   struct netfs_io_subrequest *subreq,
46                                   enum netfs_read_from_hole read_hole)
47 {
48         struct netfs_cache_resources *cres = &rreq->cache_resources;
49         struct iov_iter iter;
50
51         netfs_stat(&netfs_n_rh_read);
52         iov_iter_xarray(&iter, ITER_DEST, &rreq->mapping->i_pages,
53                         subreq->start + subreq->transferred,
54                         subreq->len   - subreq->transferred);
55
56         cres->ops->read(cres, subreq->start, &iter, read_hole,
57                         netfs_cache_read_terminated, subreq);
58 }
59
60 /*
61  * Fill a subrequest region with zeroes.
62  */
63 static void netfs_fill_with_zeroes(struct netfs_io_request *rreq,
64                                    struct netfs_io_subrequest *subreq)
65 {
66         netfs_stat(&netfs_n_rh_zero);
67         __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
68         netfs_subreq_terminated(subreq, 0, false);
69 }
70
71 /*
72  * Ask the netfs to issue a read request to the server for us.
73  *
74  * The netfs is expected to read from subreq->pos + subreq->transferred to
75  * subreq->pos + subreq->len - 1.  It may not backtrack and write data into the
76  * buffer prior to the transferred point as it might clobber dirty data
77  * obtained from the cache.
78  *
79  * Alternatively, the netfs is allowed to indicate one of two things:
80  *
81  * - NETFS_SREQ_SHORT_READ: A short read - it will get called again to try and
82  *   make progress.
83  *
84  * - NETFS_SREQ_CLEAR_TAIL: A short read - the rest of the buffer will be
85  *   cleared.
86  */
87 static void netfs_read_from_server(struct netfs_io_request *rreq,
88                                    struct netfs_io_subrequest *subreq)
89 {
90         netfs_stat(&netfs_n_rh_download);
91         rreq->netfs_ops->issue_read(subreq);
92 }
93
94 /*
95  * Release those waiting.
96  */
97 static void netfs_rreq_completed(struct netfs_io_request *rreq, bool was_async)
98 {
99         trace_netfs_rreq(rreq, netfs_rreq_trace_done);
100         netfs_clear_subrequests(rreq, was_async);
101         netfs_put_request(rreq, was_async, netfs_rreq_trace_put_complete);
102 }
103
104 /*
105  * Deal with the completion of writing the data to the cache.  We have to clear
106  * the PG_fscache bits on the folios involved and release the caller's ref.
107  *
108  * May be called in softirq mode and we inherit a ref from the caller.
109  */
110 static void netfs_rreq_unmark_after_write(struct netfs_io_request *rreq,
111                                           bool was_async)
112 {
113         struct netfs_io_subrequest *subreq;
114         struct folio *folio;
115         pgoff_t unlocked = 0;
116         bool have_unlocked = false;
117
118         rcu_read_lock();
119
120         list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
121                 XA_STATE(xas, &rreq->mapping->i_pages, subreq->start / PAGE_SIZE);
122
123                 xas_for_each(&xas, folio, (subreq->start + subreq->len - 1) / PAGE_SIZE) {
124                         if (xas_retry(&xas, folio))
125                                 continue;
126
127                         /* We might have multiple writes from the same huge
128                          * folio, but we mustn't unlock a folio more than once.
129                          */
130                         if (have_unlocked && folio_index(folio) <= unlocked)
131                                 continue;
132                         unlocked = folio_index(folio);
133                         folio_end_fscache(folio);
134                         have_unlocked = true;
135                 }
136         }
137
138         rcu_read_unlock();
139         netfs_rreq_completed(rreq, was_async);
140 }
141
142 static void netfs_rreq_copy_terminated(void *priv, ssize_t transferred_or_error,
143                                        bool was_async)
144 {
145         struct netfs_io_subrequest *subreq = priv;
146         struct netfs_io_request *rreq = subreq->rreq;
147
148         if (IS_ERR_VALUE(transferred_or_error)) {
149                 netfs_stat(&netfs_n_rh_write_failed);
150                 trace_netfs_failure(rreq, subreq, transferred_or_error,
151                                     netfs_fail_copy_to_cache);
152         } else {
153                 netfs_stat(&netfs_n_rh_write_done);
154         }
155
156         trace_netfs_sreq(subreq, netfs_sreq_trace_write_term);
157
158         /* If we decrement nr_copy_ops to 0, the ref belongs to us. */
159         if (atomic_dec_and_test(&rreq->nr_copy_ops))
160                 netfs_rreq_unmark_after_write(rreq, was_async);
161
162         netfs_put_subrequest(subreq, was_async, netfs_sreq_trace_put_terminated);
163 }
164
165 /*
166  * Perform any outstanding writes to the cache.  We inherit a ref from the
167  * caller.
168  */
169 static void netfs_rreq_do_write_to_cache(struct netfs_io_request *rreq)
170 {
171         struct netfs_cache_resources *cres = &rreq->cache_resources;
172         struct netfs_io_subrequest *subreq, *next, *p;
173         struct iov_iter iter;
174         int ret;
175
176         trace_netfs_rreq(rreq, netfs_rreq_trace_copy);
177
178         /* We don't want terminating writes trying to wake us up whilst we're
179          * still going through the list.
180          */
181         atomic_inc(&rreq->nr_copy_ops);
182
183         list_for_each_entry_safe(subreq, p, &rreq->subrequests, rreq_link) {
184                 if (!test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags)) {
185                         list_del_init(&subreq->rreq_link);
186                         netfs_put_subrequest(subreq, false,
187                                              netfs_sreq_trace_put_no_copy);
188                 }
189         }
190
191         list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
192                 /* Amalgamate adjacent writes */
193                 while (!list_is_last(&subreq->rreq_link, &rreq->subrequests)) {
194                         next = list_next_entry(subreq, rreq_link);
195                         if (next->start != subreq->start + subreq->len)
196                                 break;
197                         subreq->len += next->len;
198                         list_del_init(&next->rreq_link);
199                         netfs_put_subrequest(next, false,
200                                              netfs_sreq_trace_put_merged);
201                 }
202
203                 ret = cres->ops->prepare_write(cres, &subreq->start, &subreq->len,
204                                                rreq->i_size, true);
205                 if (ret < 0) {
206                         trace_netfs_failure(rreq, subreq, ret, netfs_fail_prepare_write);
207                         trace_netfs_sreq(subreq, netfs_sreq_trace_write_skip);
208                         continue;
209                 }
210
211                 iov_iter_xarray(&iter, ITER_SOURCE, &rreq->mapping->i_pages,
212                                 subreq->start, subreq->len);
213
214                 atomic_inc(&rreq->nr_copy_ops);
215                 netfs_stat(&netfs_n_rh_write);
216                 netfs_get_subrequest(subreq, netfs_sreq_trace_get_copy_to_cache);
217                 trace_netfs_sreq(subreq, netfs_sreq_trace_write);
218                 cres->ops->write(cres, subreq->start, &iter,
219                                  netfs_rreq_copy_terminated, subreq);
220         }
221
222         /* If we decrement nr_copy_ops to 0, the usage ref belongs to us. */
223         if (atomic_dec_and_test(&rreq->nr_copy_ops))
224                 netfs_rreq_unmark_after_write(rreq, false);
225 }
226
227 static void netfs_rreq_write_to_cache_work(struct work_struct *work)
228 {
229         struct netfs_io_request *rreq =
230                 container_of(work, struct netfs_io_request, work);
231
232         netfs_rreq_do_write_to_cache(rreq);
233 }
234
235 static void netfs_rreq_write_to_cache(struct netfs_io_request *rreq)
236 {
237         rreq->work.func = netfs_rreq_write_to_cache_work;
238         if (!queue_work(system_unbound_wq, &rreq->work))
239                 BUG();
240 }
241
242 /*
243  * Handle a short read.
244  */
245 static void netfs_rreq_short_read(struct netfs_io_request *rreq,
246                                   struct netfs_io_subrequest *subreq)
247 {
248         __clear_bit(NETFS_SREQ_SHORT_IO, &subreq->flags);
249         __set_bit(NETFS_SREQ_SEEK_DATA_READ, &subreq->flags);
250
251         netfs_stat(&netfs_n_rh_short_read);
252         trace_netfs_sreq(subreq, netfs_sreq_trace_resubmit_short);
253
254         netfs_get_subrequest(subreq, netfs_sreq_trace_get_short_read);
255         atomic_inc(&rreq->nr_outstanding);
256         if (subreq->source == NETFS_READ_FROM_CACHE)
257                 netfs_read_from_cache(rreq, subreq, NETFS_READ_HOLE_CLEAR);
258         else
259                 netfs_read_from_server(rreq, subreq);
260 }
261
262 /*
263  * Resubmit any short or failed operations.  Returns true if we got the rreq
264  * ref back.
265  */
266 static bool netfs_rreq_perform_resubmissions(struct netfs_io_request *rreq)
267 {
268         struct netfs_io_subrequest *subreq;
269
270         WARN_ON(in_interrupt());
271
272         trace_netfs_rreq(rreq, netfs_rreq_trace_resubmit);
273
274         /* We don't want terminating submissions trying to wake us up whilst
275          * we're still going through the list.
276          */
277         atomic_inc(&rreq->nr_outstanding);
278
279         __clear_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags);
280         list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
281                 if (subreq->error) {
282                         if (subreq->source != NETFS_READ_FROM_CACHE)
283                                 break;
284                         subreq->source = NETFS_DOWNLOAD_FROM_SERVER;
285                         subreq->error = 0;
286                         netfs_stat(&netfs_n_rh_download_instead);
287                         trace_netfs_sreq(subreq, netfs_sreq_trace_download_instead);
288                         netfs_get_subrequest(subreq, netfs_sreq_trace_get_resubmit);
289                         atomic_inc(&rreq->nr_outstanding);
290                         netfs_read_from_server(rreq, subreq);
291                 } else if (test_bit(NETFS_SREQ_SHORT_IO, &subreq->flags)) {
292                         netfs_rreq_short_read(rreq, subreq);
293                 }
294         }
295
296         /* If we decrement nr_outstanding to 0, the usage ref belongs to us. */
297         if (atomic_dec_and_test(&rreq->nr_outstanding))
298                 return true;
299
300         wake_up_var(&rreq->nr_outstanding);
301         return false;
302 }
303
304 /*
305  * Check to see if the data read is still valid.
306  */
307 static void netfs_rreq_is_still_valid(struct netfs_io_request *rreq)
308 {
309         struct netfs_io_subrequest *subreq;
310
311         if (!rreq->netfs_ops->is_still_valid ||
312             rreq->netfs_ops->is_still_valid(rreq))
313                 return;
314
315         list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
316                 if (subreq->source == NETFS_READ_FROM_CACHE) {
317                         subreq->error = -ESTALE;
318                         __set_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags);
319                 }
320         }
321 }
322
323 /*
324  * Assess the state of a read request and decide what to do next.
325  *
326  * Note that we could be in an ordinary kernel thread, on a workqueue or in
327  * softirq context at this point.  We inherit a ref from the caller.
328  */
329 static void netfs_rreq_assess(struct netfs_io_request *rreq, bool was_async)
330 {
331         trace_netfs_rreq(rreq, netfs_rreq_trace_assess);
332
333 again:
334         netfs_rreq_is_still_valid(rreq);
335
336         if (!test_bit(NETFS_RREQ_FAILED, &rreq->flags) &&
337             test_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags)) {
338                 if (netfs_rreq_perform_resubmissions(rreq))
339                         goto again;
340                 return;
341         }
342
343         netfs_rreq_unlock_folios(rreq);
344
345         clear_bit_unlock(NETFS_RREQ_IN_PROGRESS, &rreq->flags);
346         wake_up_bit(&rreq->flags, NETFS_RREQ_IN_PROGRESS);
347
348         if (test_bit(NETFS_RREQ_COPY_TO_CACHE, &rreq->flags))
349                 return netfs_rreq_write_to_cache(rreq);
350
351         netfs_rreq_completed(rreq, was_async);
352 }
353
354 static void netfs_rreq_work(struct work_struct *work)
355 {
356         struct netfs_io_request *rreq =
357                 container_of(work, struct netfs_io_request, work);
358         netfs_rreq_assess(rreq, false);
359 }
360
361 /*
362  * Handle the completion of all outstanding I/O operations on a read request.
363  * We inherit a ref from the caller.
364  */
365 static void netfs_rreq_terminated(struct netfs_io_request *rreq,
366                                   bool was_async)
367 {
368         if (test_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags) &&
369             was_async) {
370                 if (!queue_work(system_unbound_wq, &rreq->work))
371                         BUG();
372         } else {
373                 netfs_rreq_assess(rreq, was_async);
374         }
375 }
376
377 /**
378  * netfs_subreq_terminated - Note the termination of an I/O operation.
379  * @subreq: The I/O request that has terminated.
380  * @transferred_or_error: The amount of data transferred or an error code.
381  * @was_async: The termination was asynchronous
382  *
383  * This tells the read helper that a contributory I/O operation has terminated,
384  * one way or another, and that it should integrate the results.
385  *
386  * The caller indicates in @transferred_or_error the outcome of the operation,
387  * supplying a positive value to indicate the number of bytes transferred, 0 to
388  * indicate a failure to transfer anything that should be retried or a negative
389  * error code.  The helper will look after reissuing I/O operations as
390  * appropriate and writing downloaded data to the cache.
391  *
392  * If @was_async is true, the caller might be running in softirq or interrupt
393  * context and we can't sleep.
394  */
395 void netfs_subreq_terminated(struct netfs_io_subrequest *subreq,
396                              ssize_t transferred_or_error,
397                              bool was_async)
398 {
399         struct netfs_io_request *rreq = subreq->rreq;
400         int u;
401
402         _enter("[%u]{%llx,%lx},%zd",
403                subreq->debug_index, subreq->start, subreq->flags,
404                transferred_or_error);
405
406         switch (subreq->source) {
407         case NETFS_READ_FROM_CACHE:
408                 netfs_stat(&netfs_n_rh_read_done);
409                 break;
410         case NETFS_DOWNLOAD_FROM_SERVER:
411                 netfs_stat(&netfs_n_rh_download_done);
412                 break;
413         default:
414                 break;
415         }
416
417         if (IS_ERR_VALUE(transferred_or_error)) {
418                 subreq->error = transferred_or_error;
419                 trace_netfs_failure(rreq, subreq, transferred_or_error,
420                                     netfs_fail_read);
421                 goto failed;
422         }
423
424         if (WARN(transferred_or_error > subreq->len - subreq->transferred,
425                  "Subreq overread: R%x[%x] %zd > %zu - %zu",
426                  rreq->debug_id, subreq->debug_index,
427                  transferred_or_error, subreq->len, subreq->transferred))
428                 transferred_or_error = subreq->len - subreq->transferred;
429
430         subreq->error = 0;
431         subreq->transferred += transferred_or_error;
432         if (subreq->transferred < subreq->len)
433                 goto incomplete;
434
435 complete:
436         __clear_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags);
437         if (test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags))
438                 set_bit(NETFS_RREQ_COPY_TO_CACHE, &rreq->flags);
439
440 out:
441         trace_netfs_sreq(subreq, netfs_sreq_trace_terminated);
442
443         /* If we decrement nr_outstanding to 0, the ref belongs to us. */
444         u = atomic_dec_return(&rreq->nr_outstanding);
445         if (u == 0)
446                 netfs_rreq_terminated(rreq, was_async);
447         else if (u == 1)
448                 wake_up_var(&rreq->nr_outstanding);
449
450         netfs_put_subrequest(subreq, was_async, netfs_sreq_trace_put_terminated);
451         return;
452
453 incomplete:
454         if (test_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags)) {
455                 netfs_clear_unread(subreq);
456                 subreq->transferred = subreq->len;
457                 goto complete;
458         }
459
460         if (transferred_or_error == 0) {
461                 if (__test_and_set_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags)) {
462                         subreq->error = -ENODATA;
463                         goto failed;
464                 }
465         } else {
466                 __clear_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags);
467         }
468
469         __set_bit(NETFS_SREQ_SHORT_IO, &subreq->flags);
470         set_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags);
471         goto out;
472
473 failed:
474         if (subreq->source == NETFS_READ_FROM_CACHE) {
475                 netfs_stat(&netfs_n_rh_read_failed);
476                 set_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags);
477         } else {
478                 netfs_stat(&netfs_n_rh_download_failed);
479                 set_bit(NETFS_RREQ_FAILED, &rreq->flags);
480                 rreq->error = subreq->error;
481         }
482         goto out;
483 }
484 EXPORT_SYMBOL(netfs_subreq_terminated);
485
486 static enum netfs_io_source netfs_cache_prepare_read(struct netfs_io_subrequest *subreq,
487                                                        loff_t i_size)
488 {
489         struct netfs_io_request *rreq = subreq->rreq;
490         struct netfs_cache_resources *cres = &rreq->cache_resources;
491
492         if (cres->ops)
493                 return cres->ops->prepare_read(subreq, i_size);
494         if (subreq->start >= rreq->i_size)
495                 return NETFS_FILL_WITH_ZEROES;
496         return NETFS_DOWNLOAD_FROM_SERVER;
497 }
498
499 /*
500  * Work out what sort of subrequest the next one will be.
501  */
502 static enum netfs_io_source
503 netfs_rreq_prepare_read(struct netfs_io_request *rreq,
504                         struct netfs_io_subrequest *subreq)
505 {
506         enum netfs_io_source source;
507
508         _enter("%llx-%llx,%llx", subreq->start, subreq->start + subreq->len, rreq->i_size);
509
510         source = netfs_cache_prepare_read(subreq, rreq->i_size);
511         if (source == NETFS_INVALID_READ)
512                 goto out;
513
514         if (source == NETFS_DOWNLOAD_FROM_SERVER) {
515                 /* Call out to the netfs to let it shrink the request to fit
516                  * its own I/O sizes and boundaries.  If it shinks it here, it
517                  * will be called again to make simultaneous calls; if it wants
518                  * to make serial calls, it can indicate a short read and then
519                  * we will call it again.
520                  */
521                 if (subreq->len > rreq->i_size - subreq->start)
522                         subreq->len = rreq->i_size - subreq->start;
523
524                 if (rreq->netfs_ops->clamp_length &&
525                     !rreq->netfs_ops->clamp_length(subreq)) {
526                         source = NETFS_INVALID_READ;
527                         goto out;
528                 }
529         }
530
531         if (WARN_ON(subreq->len == 0))
532                 source = NETFS_INVALID_READ;
533
534 out:
535         subreq->source = source;
536         trace_netfs_sreq(subreq, netfs_sreq_trace_prepare);
537         return source;
538 }
539
540 /*
541  * Slice off a piece of a read request and submit an I/O request for it.
542  */
543 static bool netfs_rreq_submit_slice(struct netfs_io_request *rreq,
544                                     unsigned int *_debug_index)
545 {
546         struct netfs_io_subrequest *subreq;
547         enum netfs_io_source source;
548
549         subreq = netfs_alloc_subrequest(rreq);
550         if (!subreq)
551                 return false;
552
553         subreq->debug_index     = (*_debug_index)++;
554         subreq->start           = rreq->start + rreq->submitted;
555         subreq->len             = rreq->len   - rreq->submitted;
556
557         _debug("slice %llx,%zx,%zx", subreq->start, subreq->len, rreq->submitted);
558         list_add_tail(&subreq->rreq_link, &rreq->subrequests);
559
560         /* Call out to the cache to find out what it can do with the remaining
561          * subset.  It tells us in subreq->flags what it decided should be done
562          * and adjusts subreq->len down if the subset crosses a cache boundary.
563          *
564          * Then when we hand the subset, it can choose to take a subset of that
565          * (the starts must coincide), in which case, we go around the loop
566          * again and ask it to download the next piece.
567          */
568         source = netfs_rreq_prepare_read(rreq, subreq);
569         if (source == NETFS_INVALID_READ)
570                 goto subreq_failed;
571
572         atomic_inc(&rreq->nr_outstanding);
573
574         rreq->submitted += subreq->len;
575
576         trace_netfs_sreq(subreq, netfs_sreq_trace_submit);
577         switch (source) {
578         case NETFS_FILL_WITH_ZEROES:
579                 netfs_fill_with_zeroes(rreq, subreq);
580                 break;
581         case NETFS_DOWNLOAD_FROM_SERVER:
582                 netfs_read_from_server(rreq, subreq);
583                 break;
584         case NETFS_READ_FROM_CACHE:
585                 netfs_read_from_cache(rreq, subreq, NETFS_READ_HOLE_IGNORE);
586                 break;
587         default:
588                 BUG();
589         }
590
591         return true;
592
593 subreq_failed:
594         rreq->error = subreq->error;
595         netfs_put_subrequest(subreq, false, netfs_sreq_trace_put_failed);
596         return false;
597 }
598
599 /*
600  * Begin the process of reading in a chunk of data, where that data may be
601  * stitched together from multiple sources, including multiple servers and the
602  * local cache.
603  */
604 int netfs_begin_read(struct netfs_io_request *rreq, bool sync)
605 {
606         unsigned int debug_index = 0;
607         int ret;
608
609         _enter("R=%x %llx-%llx",
610                rreq->debug_id, rreq->start, rreq->start + rreq->len - 1);
611
612         if (rreq->len == 0) {
613                 pr_err("Zero-sized read [R=%x]\n", rreq->debug_id);
614                 netfs_put_request(rreq, false, netfs_rreq_trace_put_zero_len);
615                 return -EIO;
616         }
617
618         INIT_WORK(&rreq->work, netfs_rreq_work);
619
620         if (sync)
621                 netfs_get_request(rreq, netfs_rreq_trace_get_hold);
622
623         /* Chop the read into slices according to what the cache and the netfs
624          * want and submit each one.
625          */
626         atomic_set(&rreq->nr_outstanding, 1);
627         do {
628                 if (!netfs_rreq_submit_slice(rreq, &debug_index))
629                         break;
630
631         } while (rreq->submitted < rreq->len);
632
633         if (sync) {
634                 /* Keep nr_outstanding incremented so that the ref always belongs to
635                  * us, and the service code isn't punted off to a random thread pool to
636                  * process.
637                  */
638                 for (;;) {
639                         wait_var_event(&rreq->nr_outstanding,
640                                        atomic_read(&rreq->nr_outstanding) == 1);
641                         netfs_rreq_assess(rreq, false);
642                         if (!test_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags))
643                                 break;
644                         cond_resched();
645                 }
646
647                 ret = rreq->error;
648                 if (ret == 0 && rreq->submitted < rreq->len) {
649                         trace_netfs_failure(rreq, NULL, ret, netfs_fail_short_read);
650                         ret = -EIO;
651                 }
652                 netfs_put_request(rreq, false, netfs_rreq_trace_put_hold);
653         } else {
654                 /* If we decrement nr_outstanding to 0, the ref belongs to us. */
655                 if (atomic_dec_and_test(&rreq->nr_outstanding))
656                         netfs_rreq_assess(rreq, false);
657                 ret = 0;
658         }
659         return ret;
660 }