]> Git Repo - J-linux.git/blob - fs/netfs/direct_read.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / fs / netfs / direct_read.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Direct I/O support.
3  *
4  * Copyright (C) 2023 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells ([email protected])
6  */
7
8 #include <linux/export.h>
9 #include <linux/fs.h>
10 #include <linux/mm.h>
11 #include <linux/pagemap.h>
12 #include <linux/slab.h>
13 #include <linux/uio.h>
14 #include <linux/sched/mm.h>
15 #include <linux/task_io_accounting_ops.h>
16 #include <linux/netfs.h>
17 #include "internal.h"
18
19 static void netfs_prepare_dio_read_iterator(struct netfs_io_subrequest *subreq)
20 {
21         struct netfs_io_request *rreq = subreq->rreq;
22         size_t rsize;
23
24         rsize = umin(subreq->len, rreq->io_streams[0].sreq_max_len);
25         subreq->len = rsize;
26
27         if (unlikely(rreq->io_streams[0].sreq_max_segs)) {
28                 size_t limit = netfs_limit_iter(&rreq->iter, 0, rsize,
29                                                 rreq->io_streams[0].sreq_max_segs);
30
31                 if (limit < rsize) {
32                         subreq->len = limit;
33                         trace_netfs_sreq(subreq, netfs_sreq_trace_limited);
34                 }
35         }
36
37         trace_netfs_sreq(subreq, netfs_sreq_trace_prepare);
38
39         subreq->io_iter = rreq->iter;
40         iov_iter_truncate(&subreq->io_iter, subreq->len);
41         iov_iter_advance(&rreq->iter, subreq->len);
42 }
43
44 /*
45  * Perform a read to a buffer from the server, slicing up the region to be read
46  * according to the network rsize.
47  */
48 static int netfs_dispatch_unbuffered_reads(struct netfs_io_request *rreq)
49 {
50         unsigned long long start = rreq->start;
51         ssize_t size = rreq->len;
52         int ret = 0;
53
54         atomic_set(&rreq->nr_outstanding, 1);
55
56         do {
57                 struct netfs_io_subrequest *subreq;
58                 ssize_t slice;
59
60                 subreq = netfs_alloc_subrequest(rreq);
61                 if (!subreq) {
62                         ret = -ENOMEM;
63                         break;
64                 }
65
66                 subreq->source  = NETFS_DOWNLOAD_FROM_SERVER;
67                 subreq->start   = start;
68                 subreq->len     = size;
69
70                 atomic_inc(&rreq->nr_outstanding);
71                 spin_lock_bh(&rreq->lock);
72                 list_add_tail(&subreq->rreq_link, &rreq->subrequests);
73                 subreq->prev_donated = rreq->prev_donated;
74                 rreq->prev_donated = 0;
75                 trace_netfs_sreq(subreq, netfs_sreq_trace_added);
76                 spin_unlock_bh(&rreq->lock);
77
78                 netfs_stat(&netfs_n_rh_download);
79                 if (rreq->netfs_ops->prepare_read) {
80                         ret = rreq->netfs_ops->prepare_read(subreq);
81                         if (ret < 0) {
82                                 atomic_dec(&rreq->nr_outstanding);
83                                 netfs_put_subrequest(subreq, false, netfs_sreq_trace_put_cancel);
84                                 break;
85                         }
86                 }
87
88                 netfs_prepare_dio_read_iterator(subreq);
89                 slice = subreq->len;
90                 rreq->netfs_ops->issue_read(subreq);
91
92                 size -= slice;
93                 start += slice;
94                 rreq->submitted += slice;
95
96                 if (test_bit(NETFS_RREQ_BLOCKED, &rreq->flags) &&
97                     test_bit(NETFS_RREQ_NONBLOCK, &rreq->flags))
98                         break;
99                 cond_resched();
100         } while (size > 0);
101
102         if (atomic_dec_and_test(&rreq->nr_outstanding))
103                 netfs_rreq_terminated(rreq, false);
104         return ret;
105 }
106
107 /*
108  * Perform a read to an application buffer, bypassing the pagecache and the
109  * local disk cache.
110  */
111 static int netfs_unbuffered_read(struct netfs_io_request *rreq, bool sync)
112 {
113         int ret;
114
115         _enter("R=%x %llx-%llx",
116                rreq->debug_id, rreq->start, rreq->start + rreq->len - 1);
117
118         if (rreq->len == 0) {
119                 pr_err("Zero-sized read [R=%x]\n", rreq->debug_id);
120                 return -EIO;
121         }
122
123         // TODO: Use bounce buffer if requested
124
125         inode_dio_begin(rreq->inode);
126
127         ret = netfs_dispatch_unbuffered_reads(rreq);
128
129         if (!rreq->submitted) {
130                 netfs_put_request(rreq, false, netfs_rreq_trace_put_no_submit);
131                 inode_dio_end(rreq->inode);
132                 ret = 0;
133                 goto out;
134         }
135
136         if (sync) {
137                 trace_netfs_rreq(rreq, netfs_rreq_trace_wait_ip);
138                 wait_on_bit(&rreq->flags, NETFS_RREQ_IN_PROGRESS,
139                             TASK_UNINTERRUPTIBLE);
140
141                 ret = rreq->error;
142                 if (ret == 0 && rreq->submitted < rreq->len &&
143                     rreq->origin != NETFS_DIO_READ) {
144                         trace_netfs_failure(rreq, NULL, ret, netfs_fail_short_read);
145                         ret = -EIO;
146                 }
147         } else {
148                 ret = -EIOCBQUEUED;
149         }
150
151 out:
152         _leave(" = %d", ret);
153         return ret;
154 }
155
156 /**
157  * netfs_unbuffered_read_iter_locked - Perform an unbuffered or direct I/O read
158  * @iocb: The I/O control descriptor describing the read
159  * @iter: The output buffer (also specifies read length)
160  *
161  * Perform an unbuffered I/O or direct I/O from the file in @iocb to the
162  * output buffer.  No use is made of the pagecache.
163  *
164  * The caller must hold any appropriate locks.
165  */
166 ssize_t netfs_unbuffered_read_iter_locked(struct kiocb *iocb, struct iov_iter *iter)
167 {
168         struct netfs_io_request *rreq;
169         ssize_t ret;
170         size_t orig_count = iov_iter_count(iter);
171         bool sync = is_sync_kiocb(iocb);
172
173         _enter("");
174
175         if (!orig_count)
176                 return 0; /* Don't update atime */
177
178         ret = kiocb_write_and_wait(iocb, orig_count);
179         if (ret < 0)
180                 return ret;
181         file_accessed(iocb->ki_filp);
182
183         rreq = netfs_alloc_request(iocb->ki_filp->f_mapping, iocb->ki_filp,
184                                    iocb->ki_pos, orig_count,
185                                    NETFS_DIO_READ);
186         if (IS_ERR(rreq))
187                 return PTR_ERR(rreq);
188
189         netfs_stat(&netfs_n_rh_dio_read);
190         trace_netfs_read(rreq, rreq->start, rreq->len, netfs_read_trace_dio_read);
191
192         /* If this is an async op, we have to keep track of the destination
193          * buffer for ourselves as the caller's iterator will be trashed when
194          * we return.
195          *
196          * In such a case, extract an iterator to represent as much of the the
197          * output buffer as we can manage.  Note that the extraction might not
198          * be able to allocate a sufficiently large bvec array and may shorten
199          * the request.
200          */
201         if (user_backed_iter(iter)) {
202                 ret = netfs_extract_user_iter(iter, rreq->len, &rreq->iter, 0);
203                 if (ret < 0)
204                         goto out;
205                 rreq->direct_bv = (struct bio_vec *)rreq->iter.bvec;
206                 rreq->direct_bv_count = ret;
207                 rreq->direct_bv_unpin = iov_iter_extract_will_pin(iter);
208                 rreq->len = iov_iter_count(&rreq->iter);
209         } else {
210                 rreq->iter = *iter;
211                 rreq->len = orig_count;
212                 rreq->direct_bv_unpin = false;
213                 iov_iter_advance(iter, orig_count);
214         }
215
216         // TODO: Set up bounce buffer if needed
217
218         if (!sync)
219                 rreq->iocb = iocb;
220
221         ret = netfs_unbuffered_read(rreq, sync);
222         if (ret < 0)
223                 goto out; /* May be -EIOCBQUEUED */
224         if (sync) {
225                 // TODO: Copy from bounce buffer
226                 iocb->ki_pos += rreq->transferred;
227                 ret = rreq->transferred;
228         }
229
230 out:
231         netfs_put_request(rreq, false, netfs_rreq_trace_put_return);
232         if (ret > 0)
233                 orig_count -= ret;
234         return ret;
235 }
236 EXPORT_SYMBOL(netfs_unbuffered_read_iter_locked);
237
238 /**
239  * netfs_unbuffered_read_iter - Perform an unbuffered or direct I/O read
240  * @iocb: The I/O control descriptor describing the read
241  * @iter: The output buffer (also specifies read length)
242  *
243  * Perform an unbuffered I/O or direct I/O from the file in @iocb to the
244  * output buffer.  No use is made of the pagecache.
245  */
246 ssize_t netfs_unbuffered_read_iter(struct kiocb *iocb, struct iov_iter *iter)
247 {
248         struct inode *inode = file_inode(iocb->ki_filp);
249         ssize_t ret;
250
251         if (!iter->count)
252                 return 0; /* Don't update atime */
253
254         ret = netfs_start_io_direct(inode);
255         if (ret == 0) {
256                 ret = netfs_unbuffered_read_iter_locked(iocb, iter);
257                 netfs_end_io_direct(inode);
258         }
259         return ret;
260 }
261 EXPORT_SYMBOL(netfs_unbuffered_read_iter);
This page took 0.04207 seconds and 4 git commands to generate.