22 static void netfs_clear_unread(struct netfs_io_subrequest *subreq)
24 	iov_iter_zero(iov_iter_count(&subreq->io_iter), &subreq->io_iter);
30 	struct netfs_io_subrequest *subreq = priv;
32 	netfs_subreq_terminated(subreq, transferred_or_error, was_async);
37  * - Eats the caller's ref on subreq.
40 				  struct netfs_io_subrequest *subreq,
46 	cres->ops->read(cres, subreq->start, &subreq->io_iter, read_hole,
47 			netfs_cache_read_terminated, subreq);
54 				   struct netfs_io_subrequest *subreq)
57 	__set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
58 	netfs_subreq_terminated(subreq, 0, false);
64  * The netfs is expected to read from subreq->pos + subreq->transferred to
65  * subreq->pos + subreq->len - 1.  It may not backtrack and write data into the
78 				   struct netfs_io_subrequest *subreq)
83 	    iov_iter_count(&subreq->io_iter) != subreq->len - subreq->transferred)
85 			rreq->debug_id, subreq->debug_index,
86 			iov_iter_count(&subreq->io_iter), subreq->len,
87 			subreq->transferred, subreq->flags);
88 	rreq->netfs_ops->issue_read(subreq);
110 	struct netfs_io_subrequest *subreq;
117 	list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
118 		XA_STATE(xas, &rreq->mapping->i_pages, subreq->start / PAGE_SIZE);
120 		xas_for_each(&xas, folio, (subreq->start + subreq->len - 1) / PAGE_SIZE) {
143 	struct netfs_io_subrequest *subreq = priv;
144 	struct netfs_io_request *rreq = subreq->rreq;
148 		trace_netfs_failure(rreq, subreq, transferred_or_error,
154 	trace_netfs_sreq(subreq, netfs_sreq_trace_write_term);
160 	netfs_put_subrequest(subreq, was_async, netfs_sreq_trace_put_terminated);
170 	struct netfs_io_subrequest *subreq, *next, *p;
181 	list_for_each_entry_safe(subreq, p, &rreq->subrequests, rreq_link) {
182 		if (!test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags)) {
183 			list_del_init(&subreq->rreq_link);
184 			netfs_put_subrequest(subreq, false,
189 	list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
191 		while (!list_is_last(&subreq->rreq_link, &rreq->subrequests)) {
192 			next = list_next_entry(subreq, rreq_link);
193 			if (next->start != subreq->start + subreq->len)
195 			subreq->len += next->len;
201 		ret = cres->ops->prepare_write(cres, &subreq->start, &subreq->len,
202 					       subreq->len, rreq->i_size, true);
204 			trace_netfs_failure(rreq, subreq, ret, netfs_fail_prepare_write);
205 			trace_netfs_sreq(subreq, netfs_sreq_trace_write_skip);
210 				subreq->start, subreq->len);
214 		netfs_get_subrequest(subreq, netfs_sreq_trace_get_copy_to_cache);
215 		trace_netfs_sreq(subreq, netfs_sreq_trace_write);
216 		cres->ops->write(cres, subreq->start, &iter,
217 				 netfs_rreq_copy_terminated, subreq);
244 				  struct netfs_io_subrequest *subreq)
246 	__clear_bit(NETFS_SREQ_SHORT_IO, &subreq->flags);
247 	__set_bit(NETFS_SREQ_SEEK_DATA_READ, &subreq->flags);
250 	trace_netfs_sreq(subreq, netfs_sreq_trace_resubmit_short);
252 	netfs_get_subrequest(subreq, netfs_sreq_trace_get_short_read);
254 	if (subreq->source == NETFS_READ_FROM_CACHE)
255 		netfs_read_from_cache(rreq, subreq, NETFS_READ_HOLE_CLEAR);
257 		netfs_read_from_server(rreq, subreq);
264 				    struct netfs_io_subrequest *subreq)
266 	size_t remaining = subreq->len - subreq->transferred;
267 	size_t count = iov_iter_count(&subreq->io_iter);
273 	       rreq->debug_id, subreq->debug_index,
274 	       iov_iter_count(&subreq->io_iter), subreq->transferred,
275 	       subreq->len, rreq->i_size,
276 	       subreq->io_iter.iter_type);
279 		iov_iter_revert(&subreq->io_iter, remaining - count);
281 		iov_iter_advance(&subreq->io_iter, count - remaining);
290 	struct netfs_io_subrequest *subreq;
302 	list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
303 		if (subreq->error) {
304 			if (subreq->source != NETFS_READ_FROM_CACHE)
306 			subreq->source = NETFS_DOWNLOAD_FROM_SERVER;
307 			subreq->error = 0;
309 			trace_netfs_sreq(subreq, netfs_sreq_trace_download_instead);
310 			netfs_get_subrequest(subreq, netfs_sreq_trace_get_resubmit);
312 			netfs_reset_subreq_iter(rreq, subreq);
313 			netfs_read_from_server(rreq, subreq);
314 		} else if (test_bit(NETFS_SREQ_SHORT_IO, &subreq->flags)) {
315 			netfs_rreq_short_read(rreq, subreq);
332 	struct netfs_io_subrequest *subreq;
338 	list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
339 		if (subreq->source == NETFS_READ_FROM_CACHE) {
340 			subreq->error = -ESTALE;
351 	struct netfs_io_subrequest *subreq;
358 	list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
359 		if (subreq->error || subreq->transferred == 0)
361 		transferred += subreq->transferred;
362 		if (subreq->transferred < subreq->len)
443  * @subreq: The I/O request that has terminated.
459 void netfs_subreq_terminated(struct netfs_io_subrequest *subreq,
463 	struct netfs_io_request *rreq = subreq->rreq;
467 	       rreq->debug_id, subreq->debug_index,
468 	       subreq->start, subreq->flags, transferred_or_error);
470 	switch (subreq->source) {
482 		subreq->error = transferred_or_error;
483 		trace_netfs_failure(rreq, subreq, transferred_or_error,
488 	if (WARN(transferred_or_error > subreq->len - subreq->transferred,
490 		 rreq->debug_id, subreq->debug_index,
491 		 transferred_or_error, subreq->len, subreq->transferred))
492 		transferred_or_error = subreq->len - subreq->transferred;
494 	subreq->error = 0;
495 	subreq->transferred += transferred_or_error;
496 	if (subreq->transferred < subreq->len)
500 	__clear_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags);
501 	if (test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags))
505 	trace_netfs_sreq(subreq, netfs_sreq_trace_terminated);
514 	netfs_put_subrequest(subreq, was_async, netfs_sreq_trace_put_terminated);
518 	if (test_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags)) {
519 		netfs_clear_unread(subreq);
520 		subreq->transferred = subreq->len;
525 		if (__test_and_set_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags)) {
526 			subreq->error = -ENODATA;
530 		__clear_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags);
533 	__set_bit(NETFS_SREQ_SHORT_IO, &subreq->flags);
538 	if (subreq->source == NETFS_READ_FROM_CACHE) {
544 		rreq->error = subreq->error;
550 static enum netfs_io_source netfs_cache_prepare_read(struct netfs_io_subrequest *subreq,
553 	struct netfs_io_request *rreq = subreq->rreq;
557 		return cres->ops->prepare_read(subreq, i_size);
558 	if (subreq->start >= rreq->i_size)
568 			struct netfs_io_subrequest *subreq,
575 	_enter("%llx-%llx,%llx", subreq->start, subreq->start + subreq->len, rreq->i_size);
578 		source = netfs_cache_prepare_read(subreq, rreq->i_size);
591 			if (subreq->start >= ictx->zero_point) {
595 			if (subreq->len > ictx->zero_point - subreq->start)
596 				subreq->len = ictx->zero_point - subreq->start;
598 		if (subreq->len > rreq->i_size - subreq->start)
599 			subreq->len = rreq->i_size - subreq->start;
600 		if (rreq->rsize && subreq->len > rreq->rsize)
601 			subreq->len = rreq->rsize;
604 		    !rreq->netfs_ops->clamp_length(subreq)) {
609 		if (subreq->max_nr_segs) {
610 			lsize = netfs_limit_iter(io_iter, 0, subreq->len,
611 						 subreq->max_nr_segs);
612 			if (subreq->len > lsize) {
613 				subreq->len = lsize;
614 				trace_netfs_sreq(subreq, netfs_sreq_trace_limited);
620 	if (subreq->len > rreq->len)
622 			rreq->debug_id, subreq->debug_index,
623 			subreq->len, rreq->len);
625 	if (WARN_ON(subreq->len == 0)) {
630 	subreq->source = source;
631 	trace_netfs_sreq(subreq, netfs_sreq_trace_prepare);
633 	subreq->io_iter = *io_iter;
634 	iov_iter_truncate(&subreq->io_iter, subreq->len);
635 	iov_iter_advance(io_iter, subreq->len);
637 	subreq->source = source;
638 	trace_netfs_sreq(subreq, netfs_sreq_trace_prepare);
649 	struct netfs_io_subrequest *subreq;
652 	subreq = netfs_alloc_subrequest(rreq);
653 	if (!subreq)
656 	subreq->debug_index	= (*_debug_index)++;
657 	subreq->start		= rreq->start + rreq->submitted;
658 	subreq->len		= io_iter->count;
660 	_debug("slice %llx,%zx,%zx", subreq->start, subreq->len, rreq->submitted);
661 	list_add_tail(&subreq->rreq_link, &rreq->subrequests);
664 	 * subset.  It tells us in subreq->flags what it decided should be done
665 	 * and adjusts subreq->len down if the subset crosses a cache boundary.
671 	source = netfs_rreq_prepare_read(rreq, subreq, io_iter);
677 	rreq->submitted += subreq->len;
679 	trace_netfs_sreq(subreq, netfs_sreq_trace_submit);
682 		netfs_fill_with_zeroes(rreq, subreq);
685 		netfs_read_from_server(rreq, subreq);
688 		netfs_read_from_cache(rreq, subreq, NETFS_READ_HOLE_IGNORE);
697 	rreq->error = subreq->error;
698 	netfs_put_subrequest(subreq, false, netfs_sreq_trace_put_failed);

Indexes created Fri May 10 11:38:11 MDT 2024