~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/read.c

Version: ~ [ linux-5.9-rc6 ] ~ [ linux-5.8.10 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.66 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.146 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.198 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.236 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.236 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * linux/fs/nfs/read.c
  3  *
  4  * Block I/O for NFS
  5  *
  6  * Partial copy of Linus' read cache modifications to fs/nfs/file.c
  7  * modified for async RPC by okir@monad.swb.de
  8  */
  9 
 10 #include <linux/time.h>
 11 #include <linux/kernel.h>
 12 #include <linux/errno.h>
 13 #include <linux/fcntl.h>
 14 #include <linux/stat.h>
 15 #include <linux/mm.h>
 16 #include <linux/slab.h>
 17 #include <linux/pagemap.h>
 18 #include <linux/sunrpc/clnt.h>
 19 #include <linux/nfs_fs.h>
 20 #include <linux/nfs_page.h>
 21 #include <linux/module.h>
 22 
 23 #include "nfs4_fs.h"
 24 #include "internal.h"
 25 #include "iostat.h"
 26 #include "fscache.h"
 27 #include "pnfs.h"
 28 
 29 #define NFSDBG_FACILITY         NFSDBG_PAGECACHE
 30 
 31 static const struct nfs_pgio_completion_ops nfs_async_read_completion_ops;
 32 static const struct nfs_rw_ops nfs_rw_read_ops;
 33 
 34 static struct kmem_cache *nfs_rdata_cachep;
 35 
 36 static struct nfs_pgio_header *nfs_readhdr_alloc(void)
 37 {
 38         return kmem_cache_zalloc(nfs_rdata_cachep, GFP_KERNEL);
 39 }
 40 
 41 static void nfs_readhdr_free(struct nfs_pgio_header *rhdr)
 42 {
 43         kmem_cache_free(nfs_rdata_cachep, rhdr);
 44 }
 45 
 46 static
 47 int nfs_return_empty_page(struct page *page)
 48 {
 49         zero_user(page, 0, PAGE_CACHE_SIZE);
 50         SetPageUptodate(page);
 51         unlock_page(page);
 52         return 0;
 53 }
 54 
 55 void nfs_pageio_init_read(struct nfs_pageio_descriptor *pgio,
 56                               struct inode *inode, bool force_mds,
 57                               const struct nfs_pgio_completion_ops *compl_ops)
 58 {
 59         struct nfs_server *server = NFS_SERVER(inode);
 60         const struct nfs_pageio_ops *pg_ops = &nfs_pgio_rw_ops;
 61 
 62 #ifdef CONFIG_NFS_V4_1
 63         if (server->pnfs_curr_ld && !force_mds)
 64                 pg_ops = server->pnfs_curr_ld->pg_read_ops;
 65 #endif
 66         nfs_pageio_init(pgio, inode, pg_ops, compl_ops, &nfs_rw_read_ops,
 67                         server->rsize, 0);
 68 }
 69 EXPORT_SYMBOL_GPL(nfs_pageio_init_read);
 70 
 71 void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio)
 72 {
 73         struct nfs_pgio_mirror *mirror;
 74 
 75         if (pgio->pg_ops && pgio->pg_ops->pg_cleanup)
 76                 pgio->pg_ops->pg_cleanup(pgio);
 77 
 78         pgio->pg_ops = &nfs_pgio_rw_ops;
 79 
 80         /* read path should never have more than one mirror */
 81         WARN_ON_ONCE(pgio->pg_mirror_count != 1);
 82 
 83         mirror = &pgio->pg_mirrors[0];
 84         mirror->pg_bsize = NFS_SERVER(pgio->pg_inode)->rsize;
 85 }
 86 EXPORT_SYMBOL_GPL(nfs_pageio_reset_read_mds);
 87 
 88 int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
 89                        struct page *page)
 90 {
 91         struct nfs_page *new;
 92         unsigned int len;
 93         struct nfs_pageio_descriptor pgio;
 94         struct nfs_pgio_mirror *pgm;
 95 
 96         len = nfs_page_length(page);
 97         if (len == 0)
 98                 return nfs_return_empty_page(page);
 99         new = nfs_create_request(ctx, page, NULL, 0, len);
100         if (IS_ERR(new)) {
101                 unlock_page(page);
102                 return PTR_ERR(new);
103         }
104         if (len < PAGE_CACHE_SIZE)
105                 zero_user_segment(page, len, PAGE_CACHE_SIZE);
106 
107         nfs_pageio_init_read(&pgio, inode, false,
108                              &nfs_async_read_completion_ops);
109         nfs_pageio_add_request(&pgio, new);
110         nfs_pageio_complete(&pgio);
111 
112         /* It doesn't make sense to do mirrored reads! */
113         WARN_ON_ONCE(pgio.pg_mirror_count != 1);
114 
115         pgm = &pgio.pg_mirrors[0];
116         NFS_I(inode)->read_io += pgm->pg_bytes_written;
117 
118         return 0;
119 }
120 
121 static void nfs_readpage_release(struct nfs_page *req)
122 {
123         struct inode *inode = d_inode(req->wb_context->dentry);
124 
125         dprintk("NFS: read done (%s/%llu %d@%lld)\n", inode->i_sb->s_id,
126                 (unsigned long long)NFS_FILEID(inode), req->wb_bytes,
127                 (long long)req_offset(req));
128 
129         if (nfs_page_group_sync_on_bit(req, PG_UNLOCKPAGE)) {
130                 if (PageUptodate(req->wb_page))
131                         nfs_readpage_to_fscache(inode, req->wb_page, 0);
132 
133                 unlock_page(req->wb_page);
134         }
135         nfs_release_request(req);
136 }
137 
138 static void nfs_page_group_set_uptodate(struct nfs_page *req)
139 {
140         if (nfs_page_group_sync_on_bit(req, PG_UPTODATE))
141                 SetPageUptodate(req->wb_page);
142 }
143 
144 static void nfs_read_completion(struct nfs_pgio_header *hdr)
145 {
146         unsigned long bytes = 0;
147 
148         if (test_bit(NFS_IOHDR_REDO, &hdr->flags))
149                 goto out;
150         while (!list_empty(&hdr->pages)) {
151                 struct nfs_page *req = nfs_list_entry(hdr->pages.next);
152                 struct page *page = req->wb_page;
153                 unsigned long start = req->wb_pgbase;
154                 unsigned long end = req->wb_pgbase + req->wb_bytes;
155 
156                 if (test_bit(NFS_IOHDR_EOF, &hdr->flags)) {
157                         /* note: regions of the page not covered by a
158                          * request are zeroed in nfs_readpage_async /
159                          * readpage_async_filler */
160                         if (bytes > hdr->good_bytes) {
161                                 /* nothing in this request was good, so zero
162                                  * the full extent of the request */
163                                 zero_user_segment(page, start, end);
164 
165                         } else if (hdr->good_bytes - bytes < req->wb_bytes) {
166                                 /* part of this request has good bytes, but
167                                  * not all. zero the bad bytes */
168                                 start += hdr->good_bytes - bytes;
169                                 WARN_ON(start < req->wb_pgbase);
170                                 zero_user_segment(page, start, end);
171                         }
172                 }
173                 bytes += req->wb_bytes;
174                 if (test_bit(NFS_IOHDR_ERROR, &hdr->flags)) {
175                         if (bytes <= hdr->good_bytes)
176                                 nfs_page_group_set_uptodate(req);
177                 } else
178                         nfs_page_group_set_uptodate(req);
179                 nfs_list_remove_request(req);
180                 nfs_readpage_release(req);
181         }
182 out:
183         hdr->release(hdr);
184 }
185 
186 static void nfs_initiate_read(struct nfs_pgio_header *hdr,
187                               struct rpc_message *msg,
188                               const struct nfs_rpc_ops *rpc_ops,
189                               struct rpc_task_setup *task_setup_data, int how)
190 {
191         struct inode *inode = hdr->inode;
192         int swap_flags = IS_SWAPFILE(inode) ? NFS_RPC_SWAPFLAGS : 0;
193 
194         task_setup_data->flags |= swap_flags;
195         rpc_ops->read_setup(hdr, msg);
196 }
197 
198 static void
199 nfs_async_read_error(struct list_head *head)
200 {
201         struct nfs_page *req;
202 
203         while (!list_empty(head)) {
204                 req = nfs_list_entry(head->next);
205                 nfs_list_remove_request(req);
206                 nfs_readpage_release(req);
207         }
208 }
209 
210 static const struct nfs_pgio_completion_ops nfs_async_read_completion_ops = {
211         .error_cleanup = nfs_async_read_error,
212         .completion = nfs_read_completion,
213 };
214 
215 /*
216  * This is the callback from RPC telling us whether a reply was
217  * received or some error occurred (timeout or socket shutdown).
218  */
219 static int nfs_readpage_done(struct rpc_task *task,
220                              struct nfs_pgio_header *hdr,
221                              struct inode *inode)
222 {
223         int status = NFS_PROTO(inode)->read_done(task, hdr);
224         if (status != 0)
225                 return status;
226 
227         nfs_add_stats(inode, NFSIOS_SERVERREADBYTES, hdr->res.count);
228 
229         if (task->tk_status == -ESTALE) {
230                 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
231                 nfs_mark_for_revalidate(inode);
232         }
233         return 0;
234 }
235 
236 static void nfs_readpage_retry(struct rpc_task *task,
237                                struct nfs_pgio_header *hdr)
238 {
239         struct nfs_pgio_args *argp = &hdr->args;
240         struct nfs_pgio_res  *resp = &hdr->res;
241 
242         /* This is a short read! */
243         nfs_inc_stats(hdr->inode, NFSIOS_SHORTREAD);
244         /* Has the server at least made some progress? */
245         if (resp->count == 0) {
246                 nfs_set_pgio_error(hdr, -EIO, argp->offset);
247                 return;
248         }
249         /* Yes, so retry the read at the end of the hdr */
250         hdr->mds_offset += resp->count;
251         argp->offset += resp->count;
252         argp->pgbase += resp->count;
253         argp->count -= resp->count;
254         rpc_restart_call_prepare(task);
255 }
256 
257 static void nfs_readpage_result(struct rpc_task *task,
258                                 struct nfs_pgio_header *hdr)
259 {
260         if (hdr->res.eof) {
261                 loff_t bound;
262 
263                 bound = hdr->args.offset + hdr->res.count;
264                 spin_lock(&hdr->lock);
265                 if (bound < hdr->io_start + hdr->good_bytes) {
266                         set_bit(NFS_IOHDR_EOF, &hdr->flags);
267                         clear_bit(NFS_IOHDR_ERROR, &hdr->flags);
268                         hdr->good_bytes = bound - hdr->io_start;
269                 }
270                 spin_unlock(&hdr->lock);
271         } else if (hdr->res.count != hdr->args.count)
272                 nfs_readpage_retry(task, hdr);
273 }
274 
275 /*
276  * Read a page over NFS.
277  * We read the page synchronously in the following case:
278  *  -   The error flag is set for this page. This happens only when a
279  *      previous async read operation failed.
280  */
281 int nfs_readpage(struct file *file, struct page *page)
282 {
283         struct nfs_open_context *ctx;
284         struct inode *inode = page_file_mapping(page)->host;
285         int             error;
286 
287         dprintk("NFS: nfs_readpage (%p %ld@%lu)\n",
288                 page, PAGE_CACHE_SIZE, page_file_index(page));
289         nfs_inc_stats(inode, NFSIOS_VFSREADPAGE);
290         nfs_add_stats(inode, NFSIOS_READPAGES, 1);
291 
292         /*
293          * Try to flush any pending writes to the file..
294          *
295          * NOTE! Because we own the page lock, there cannot
296          * be any new pending writes generated at this point
297          * for this page (other pages can be written to).
298          */
299         error = nfs_wb_page(inode, page);
300         if (error)
301                 goto out_unlock;
302         if (PageUptodate(page))
303                 goto out_unlock;
304 
305         error = -ESTALE;
306         if (NFS_STALE(inode))
307                 goto out_unlock;
308 
309         if (file == NULL) {
310                 error = -EBADF;
311                 ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
312                 if (ctx == NULL)
313                         goto out_unlock;
314         } else
315                 ctx = get_nfs_open_context(nfs_file_open_context(file));
316 
317         if (!IS_SYNC(inode)) {
318                 error = nfs_readpage_from_fscache(ctx, inode, page);
319                 if (error == 0)
320                         goto out;
321         }
322 
323         error = nfs_readpage_async(ctx, inode, page);
324 
325 out:
326         put_nfs_open_context(ctx);
327         return error;
328 out_unlock:
329         unlock_page(page);
330         return error;
331 }
332 
333 struct nfs_readdesc {
334         struct nfs_pageio_descriptor *pgio;
335         struct nfs_open_context *ctx;
336 };
337 
338 static int
339 readpage_async_filler(void *data, struct page *page)
340 {
341         struct nfs_readdesc *desc = (struct nfs_readdesc *)data;
342         struct nfs_page *new;
343         unsigned int len;
344         int error;
345 
346         len = nfs_page_length(page);
347         if (len == 0)
348                 return nfs_return_empty_page(page);
349 
350         new = nfs_create_request(desc->ctx, page, NULL, 0, len);
351         if (IS_ERR(new))
352                 goto out_error;
353 
354         if (len < PAGE_CACHE_SIZE)
355                 zero_user_segment(page, len, PAGE_CACHE_SIZE);
356         if (!nfs_pageio_add_request(desc->pgio, new)) {
357                 error = desc->pgio->pg_error;
358                 goto out_unlock;
359         }
360         return 0;
361 out_error:
362         error = PTR_ERR(new);
363 out_unlock:
364         unlock_page(page);
365         return error;
366 }
367 
368 int nfs_readpages(struct file *filp, struct address_space *mapping,
369                 struct list_head *pages, unsigned nr_pages)
370 {
371         struct nfs_pageio_descriptor pgio;
372         struct nfs_pgio_mirror *pgm;
373         struct nfs_readdesc desc = {
374                 .pgio = &pgio,
375         };
376         struct inode *inode = mapping->host;
377         unsigned long npages;
378         int ret = -ESTALE;
379 
380         dprintk("NFS: nfs_readpages (%s/%Lu %d)\n",
381                         inode->i_sb->s_id,
382                         (unsigned long long)NFS_FILEID(inode),
383                         nr_pages);
384         nfs_inc_stats(inode, NFSIOS_VFSREADPAGES);
385 
386         if (NFS_STALE(inode))
387                 goto out;
388 
389         if (filp == NULL) {
390                 desc.ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
391                 if (desc.ctx == NULL)
392                         return -EBADF;
393         } else
394                 desc.ctx = get_nfs_open_context(nfs_file_open_context(filp));
395 
396         /* attempt to read as many of the pages as possible from the cache
397          * - this returns -ENOBUFS immediately if the cookie is negative
398          */
399         ret = nfs_readpages_from_fscache(desc.ctx, inode, mapping,
400                                          pages, &nr_pages);
401         if (ret == 0)
402                 goto read_complete; /* all pages were read */
403 
404         nfs_pageio_init_read(&pgio, inode, false,
405                              &nfs_async_read_completion_ops);
406 
407         ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc);
408         nfs_pageio_complete(&pgio);
409 
410         /* It doesn't make sense to do mirrored reads! */
411         WARN_ON_ONCE(pgio.pg_mirror_count != 1);
412 
413         pgm = &pgio.pg_mirrors[0];
414         NFS_I(inode)->read_io += pgm->pg_bytes_written;
415         npages = (pgm->pg_bytes_written + PAGE_CACHE_SIZE - 1) >>
416                  PAGE_CACHE_SHIFT;
417         nfs_add_stats(inode, NFSIOS_READPAGES, npages);
418 read_complete:
419         put_nfs_open_context(desc.ctx);
420 out:
421         return ret;
422 }
423 
424 int __init nfs_init_readpagecache(void)
425 {
426         nfs_rdata_cachep = kmem_cache_create("nfs_read_data",
427                                              sizeof(struct nfs_pgio_header),
428                                              0, SLAB_HWCACHE_ALIGN,
429                                              NULL);
430         if (nfs_rdata_cachep == NULL)
431                 return -ENOMEM;
432 
433         return 0;
434 }
435 
436 void nfs_destroy_readpagecache(void)
437 {
438         kmem_cache_destroy(nfs_rdata_cachep);
439 }
440 
441 static const struct nfs_rw_ops nfs_rw_read_ops = {
442         .rw_mode                = FMODE_READ,
443         .rw_alloc_header        = nfs_readhdr_alloc,
444         .rw_free_header         = nfs_readhdr_free,
445         .rw_done                = nfs_readpage_done,
446         .rw_result              = nfs_readpage_result,
447         .rw_initiate            = nfs_initiate_read,
448 };
449 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp