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

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

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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/file.c
  3  *
  4  *  Copyright (C) 1992  Rick Sladkey
  5  *
  6  *  Changes Copyright (C) 1994 by Florian La Roche
  7  *   - Do not copy data too often around in the kernel.
  8  *   - In nfs_file_read the return value of kmalloc wasn't checked.
  9  *   - Put in a better version of read look-ahead buffering. Original idea
 10  *     and implementation by Wai S Kok elekokws@ee.nus.sg.
 11  *
 12  *  Expire cache on write to a file by Wai S Kok (Oct 1994).
 13  *
 14  *  Total rewrite of read side for new NFS buffer cache.. Linus.
 15  *
 16  *  nfs regular file handling functions
 17  */
 18 
 19 #include <linux/module.h>
 20 #include <linux/time.h>
 21 #include <linux/kernel.h>
 22 #include <linux/errno.h>
 23 #include <linux/fcntl.h>
 24 #include <linux/stat.h>
 25 #include <linux/nfs_fs.h>
 26 #include <linux/nfs_mount.h>
 27 #include <linux/mm.h>
 28 #include <linux/pagemap.h>
 29 #include <linux/gfp.h>
 30 #include <linux/swap.h>
 31 
 32 #include <asm/uaccess.h>
 33 
 34 #include "delegation.h"
 35 #include "internal.h"
 36 #include "iostat.h"
 37 #include "fscache.h"
 38 #include "pnfs.h"
 39 
 40 #include "nfstrace.h"
 41 
 42 #define NFSDBG_FACILITY         NFSDBG_FILE
 43 
 44 static const struct vm_operations_struct nfs_file_vm_ops;
 45 
 46 /* Hack for future NFS swap support */
 47 #ifndef IS_SWAPFILE
 48 # define IS_SWAPFILE(inode)     (0)
 49 #endif
 50 
 51 int nfs_check_flags(int flags)
 52 {
 53         if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
 54                 return -EINVAL;
 55 
 56         return 0;
 57 }
 58 EXPORT_SYMBOL_GPL(nfs_check_flags);
 59 
 60 /*
 61  * Open file
 62  */
 63 static int
 64 nfs_file_open(struct inode *inode, struct file *filp)
 65 {
 66         int res;
 67 
 68         dprintk("NFS: open file(%pD2)\n", filp);
 69 
 70         nfs_inc_stats(inode, NFSIOS_VFSOPEN);
 71         res = nfs_check_flags(filp->f_flags);
 72         if (res)
 73                 return res;
 74 
 75         res = nfs_open(inode, filp);
 76         return res;
 77 }
 78 
 79 int
 80 nfs_file_release(struct inode *inode, struct file *filp)
 81 {
 82         dprintk("NFS: release(%pD2)\n", filp);
 83 
 84         nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
 85         nfs_file_clear_open_context(filp);
 86         return 0;
 87 }
 88 EXPORT_SYMBOL_GPL(nfs_file_release);
 89 
 90 /**
 91  * nfs_revalidate_size - Revalidate the file size
 92  * @inode - pointer to inode struct
 93  * @file - pointer to struct file
 94  *
 95  * Revalidates the file length. This is basically a wrapper around
 96  * nfs_revalidate_inode() that takes into account the fact that we may
 97  * have cached writes (in which case we don't care about the server's
 98  * idea of what the file length is), or O_DIRECT (in which case we
 99  * shouldn't trust the cache).
100  */
101 static int nfs_revalidate_file_size(struct inode *inode, struct file *filp)
102 {
103         struct nfs_server *server = NFS_SERVER(inode);
104         struct nfs_inode *nfsi = NFS_I(inode);
105 
106         if (nfs_have_delegated_attributes(inode))
107                 goto out_noreval;
108 
109         if (filp->f_flags & O_DIRECT)
110                 goto force_reval;
111         if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
112                 goto force_reval;
113         if (nfs_attribute_timeout(inode))
114                 goto force_reval;
115 out_noreval:
116         return 0;
117 force_reval:
118         return __nfs_revalidate_inode(server, inode);
119 }
120 
121 loff_t nfs_file_llseek(struct file *filp, loff_t offset, int whence)
122 {
123         dprintk("NFS: llseek file(%pD2, %lld, %d)\n",
124                         filp, offset, whence);
125 
126         /*
127          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
128          * the cached file length
129          */
130         if (whence != SEEK_SET && whence != SEEK_CUR) {
131                 struct inode *inode = filp->f_mapping->host;
132 
133                 int retval = nfs_revalidate_file_size(inode, filp);
134                 if (retval < 0)
135                         return (loff_t)retval;
136         }
137 
138         return generic_file_llseek(filp, offset, whence);
139 }
140 EXPORT_SYMBOL_GPL(nfs_file_llseek);
141 
142 /*
143  * Flush all dirty pages, and check for write errors.
144  */
145 static int
146 nfs_file_flush(struct file *file, fl_owner_t id)
147 {
148         struct inode    *inode = file_inode(file);
149 
150         dprintk("NFS: flush(%pD2)\n", file);
151 
152         nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
153         if ((file->f_mode & FMODE_WRITE) == 0)
154                 return 0;
155 
156         /* Flush writes to the server and return any errors */
157         return vfs_fsync(file, 0);
158 }
159 
160 ssize_t
161 nfs_file_read(struct kiocb *iocb, struct iov_iter *to)
162 {
163         struct inode *inode = file_inode(iocb->ki_filp);
164         ssize_t result;
165 
166         if (iocb->ki_flags & IOCB_DIRECT)
167                 return nfs_file_direct_read(iocb, to, iocb->ki_pos);
168 
169         dprintk("NFS: read(%pD2, %zu@%lu)\n",
170                 iocb->ki_filp,
171                 iov_iter_count(to), (unsigned long) iocb->ki_pos);
172 
173         result = nfs_revalidate_mapping_protected(inode, iocb->ki_filp->f_mapping);
174         if (!result) {
175                 result = generic_file_read_iter(iocb, to);
176                 if (result > 0)
177                         nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result);
178         }
179         return result;
180 }
181 EXPORT_SYMBOL_GPL(nfs_file_read);
182 
183 ssize_t
184 nfs_file_splice_read(struct file *filp, loff_t *ppos,
185                      struct pipe_inode_info *pipe, size_t count,
186                      unsigned int flags)
187 {
188         struct inode *inode = file_inode(filp);
189         ssize_t res;
190 
191         dprintk("NFS: splice_read(%pD2, %lu@%Lu)\n",
192                 filp, (unsigned long) count, (unsigned long long) *ppos);
193 
194         res = nfs_revalidate_mapping_protected(inode, filp->f_mapping);
195         if (!res) {
196                 res = generic_file_splice_read(filp, ppos, pipe, count, flags);
197                 if (res > 0)
198                         nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res);
199         }
200         return res;
201 }
202 EXPORT_SYMBOL_GPL(nfs_file_splice_read);
203 
204 int
205 nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
206 {
207         struct inode *inode = file_inode(file);
208         int     status;
209 
210         dprintk("NFS: mmap(%pD2)\n", file);
211 
212         /* Note: generic_file_mmap() returns ENOSYS on nommu systems
213          *       so we call that before revalidating the mapping
214          */
215         status = generic_file_mmap(file, vma);
216         if (!status) {
217                 vma->vm_ops = &nfs_file_vm_ops;
218                 status = nfs_revalidate_mapping(inode, file->f_mapping);
219         }
220         return status;
221 }
222 EXPORT_SYMBOL_GPL(nfs_file_mmap);
223 
224 /*
225  * Flush any dirty pages for this process, and check for write errors.
226  * The return status from this call provides a reliable indication of
227  * whether any write errors occurred for this process.
228  *
229  * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to
230  * disk, but it retrieves and clears ctx->error after synching, despite
231  * the two being set at the same time in nfs_context_set_write_error().
232  * This is because the former is used to notify the _next_ call to
233  * nfs_file_write() that a write error occurred, and hence cause it to
234  * fall back to doing a synchronous write.
235  */
236 static int
237 nfs_file_fsync_commit(struct file *file, loff_t start, loff_t end, int datasync)
238 {
239         struct nfs_open_context *ctx = nfs_file_open_context(file);
240         struct inode *inode = file_inode(file);
241         int have_error, do_resend, status;
242         int ret = 0;
243 
244         dprintk("NFS: fsync file(%pD2) datasync %d\n", file, datasync);
245 
246         nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
247         do_resend = test_and_clear_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
248         have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
249         status = nfs_commit_inode(inode, FLUSH_SYNC);
250         have_error |= test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
251         if (have_error) {
252                 ret = xchg(&ctx->error, 0);
253                 if (ret)
254                         goto out;
255         }
256         if (status < 0) {
257                 ret = status;
258                 goto out;
259         }
260         do_resend |= test_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
261         if (do_resend)
262                 ret = -EAGAIN;
263 out:
264         return ret;
265 }
266 
267 int
268 nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
269 {
270         int ret;
271         struct inode *inode = file_inode(file);
272 
273         trace_nfs_fsync_enter(inode);
274 
275         inode_dio_wait(inode);
276         do {
277                 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
278                 if (ret != 0)
279                         break;
280                 inode_lock(inode);
281                 ret = nfs_file_fsync_commit(file, start, end, datasync);
282                 if (!ret)
283                         ret = pnfs_sync_inode(inode, !!datasync);
284                 inode_unlock(inode);
285                 /*
286                  * If nfs_file_fsync_commit detected a server reboot, then
287                  * resend all dirty pages that might have been covered by
288                  * the NFS_CONTEXT_RESEND_WRITES flag
289                  */
290                 start = 0;
291                 end = LLONG_MAX;
292         } while (ret == -EAGAIN);
293 
294         trace_nfs_fsync_exit(inode, ret);
295         return ret;
296 }
297 EXPORT_SYMBOL_GPL(nfs_file_fsync);
298 
299 /*
300  * Decide whether a read/modify/write cycle may be more efficient
301  * then a modify/write/read cycle when writing to a page in the
302  * page cache.
303  *
304  * The modify/write/read cycle may occur if a page is read before
305  * being completely filled by the writer.  In this situation, the
306  * page must be completely written to stable storage on the server
307  * before it can be refilled by reading in the page from the server.
308  * This can lead to expensive, small, FILE_SYNC mode writes being
309  * done.
310  *
311  * It may be more efficient to read the page first if the file is
312  * open for reading in addition to writing, the page is not marked
313  * as Uptodate, it is not dirty or waiting to be committed,
314  * indicating that it was previously allocated and then modified,
315  * that there were valid bytes of data in that range of the file,
316  * and that the new data won't completely replace the old data in
317  * that range of the file.
318  */
319 static int nfs_want_read_modify_write(struct file *file, struct page *page,
320                         loff_t pos, unsigned len)
321 {
322         unsigned int pglen = nfs_page_length(page);
323         unsigned int offset = pos & (PAGE_SIZE - 1);
324         unsigned int end = offset + len;
325 
326         if (pnfs_ld_read_whole_page(file->f_mapping->host)) {
327                 if (!PageUptodate(page))
328                         return 1;
329                 return 0;
330         }
331 
332         if ((file->f_mode & FMODE_READ) &&      /* open for read? */
333             !PageUptodate(page) &&              /* Uptodate? */
334             !PagePrivate(page) &&               /* i/o request already? */
335             pglen &&                            /* valid bytes of file? */
336             (end < pglen || offset))            /* replace all valid bytes? */
337                 return 1;
338         return 0;
339 }
340 
341 /*
342  * This does the "real" work of the write. We must allocate and lock the
343  * page to be sent back to the generic routine, which then copies the
344  * data from user space.
345  *
346  * If the writer ends up delaying the write, the writer needs to
347  * increment the page use counts until he is done with the page.
348  */
349 static int nfs_write_begin(struct file *file, struct address_space *mapping,
350                         loff_t pos, unsigned len, unsigned flags,
351                         struct page **pagep, void **fsdata)
352 {
353         int ret;
354         pgoff_t index = pos >> PAGE_SHIFT;
355         struct page *page;
356         int once_thru = 0;
357 
358         dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n",
359                 file, mapping->host->i_ino, len, (long long) pos);
360 
361 start:
362         /*
363          * Prevent starvation issues if someone is doing a consistency
364          * sync-to-disk
365          */
366         ret = wait_on_bit_action(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING,
367                                  nfs_wait_bit_killable, TASK_KILLABLE);
368         if (ret)
369                 return ret;
370         /*
371          * Wait for O_DIRECT to complete
372          */
373         inode_dio_wait(mapping->host);
374 
375         page = grab_cache_page_write_begin(mapping, index, flags);
376         if (!page)
377                 return -ENOMEM;
378         *pagep = page;
379 
380         ret = nfs_flush_incompatible(file, page);
381         if (ret) {
382                 unlock_page(page);
383                 put_page(page);
384         } else if (!once_thru &&
385                    nfs_want_read_modify_write(file, page, pos, len)) {
386                 once_thru = 1;
387                 ret = nfs_readpage(file, page);
388                 put_page(page);
389                 if (!ret)
390                         goto start;
391         }
392         return ret;
393 }
394 
395 static int nfs_write_end(struct file *file, struct address_space *mapping,
396                         loff_t pos, unsigned len, unsigned copied,
397                         struct page *page, void *fsdata)
398 {
399         unsigned offset = pos & (PAGE_SIZE - 1);
400         struct nfs_open_context *ctx = nfs_file_open_context(file);
401         int status;
402 
403         dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n",
404                 file, mapping->host->i_ino, len, (long long) pos);
405 
406         /*
407          * Zero any uninitialised parts of the page, and then mark the page
408          * as up to date if it turns out that we're extending the file.
409          */
410         if (!PageUptodate(page)) {
411                 unsigned pglen = nfs_page_length(page);
412                 unsigned end = offset + len;
413 
414                 if (pglen == 0) {
415                         zero_user_segments(page, 0, offset,
416                                         end, PAGE_SIZE);
417                         SetPageUptodate(page);
418                 } else if (end >= pglen) {
419                         zero_user_segment(page, end, PAGE_SIZE);
420                         if (offset == 0)
421                                 SetPageUptodate(page);
422                 } else
423                         zero_user_segment(page, pglen, PAGE_SIZE);
424         }
425 
426         status = nfs_updatepage(file, page, offset, copied);
427 
428         unlock_page(page);
429         put_page(page);
430 
431         if (status < 0)
432                 return status;
433         NFS_I(mapping->host)->write_io += copied;
434 
435         if (nfs_ctx_key_to_expire(ctx)) {
436                 status = nfs_wb_all(mapping->host);
437                 if (status < 0)
438                         return status;
439         }
440 
441         return copied;
442 }
443 
444 /*
445  * Partially or wholly invalidate a page
446  * - Release the private state associated with a page if undergoing complete
447  *   page invalidation
448  * - Called if either PG_private or PG_fscache is set on the page
449  * - Caller holds page lock
450  */
451 static void nfs_invalidate_page(struct page *page, unsigned int offset,
452                                 unsigned int length)
453 {
454         dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %u, %u)\n",
455                  page, offset, length);
456 
457         if (offset != 0 || length < PAGE_SIZE)
458                 return;
459         /* Cancel any unstarted writes on this page */
460         nfs_wb_page_cancel(page_file_mapping(page)->host, page);
461 
462         nfs_fscache_invalidate_page(page, page->mapping->host);
463 }
464 
465 /*
466  * Attempt to release the private state associated with a page
467  * - Called if either PG_private or PG_fscache is set on the page
468  * - Caller holds page lock
469  * - Return true (may release page) or false (may not)
470  */
471 static int nfs_release_page(struct page *page, gfp_t gfp)
472 {
473         struct address_space *mapping = page->mapping;
474 
475         dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);
476 
477         /* Always try to initiate a 'commit' if relevant, but only
478          * wait for it if the caller allows blocking.  Even then,
479          * only wait 1 second and only if the 'bdi' is not congested.
480          * Waiting indefinitely can cause deadlocks when the NFS
481          * server is on this machine, when a new TCP connection is
482          * needed and in other rare cases.  There is no particular
483          * need to wait extensively here.  A short wait has the
484          * benefit that someone else can worry about the freezer.
485          */
486         if (mapping) {
487                 struct nfs_server *nfss = NFS_SERVER(mapping->host);
488                 nfs_commit_inode(mapping->host, 0);
489                 if (gfpflags_allow_blocking(gfp) &&
490                     !bdi_write_congested(&nfss->backing_dev_info)) {
491                         wait_on_page_bit_killable_timeout(page, PG_private,
492                                                           HZ);
493                         if (PagePrivate(page))
494                                 set_bdi_congested(&nfss->backing_dev_info,
495                                                   BLK_RW_ASYNC);
496                 }
497         }
498         /* If PagePrivate() is set, then the page is not freeable */
499         if (PagePrivate(page))
500                 return 0;
501         return nfs_fscache_release_page(page, gfp);
502 }
503 
504 static void nfs_check_dirty_writeback(struct page *page,
505                                 bool *dirty, bool *writeback)
506 {
507         struct nfs_inode *nfsi;
508         struct address_space *mapping = page_file_mapping(page);
509 
510         if (!mapping || PageSwapCache(page))
511                 return;
512 
513         /*
514          * Check if an unstable page is currently being committed and
515          * if so, have the VM treat it as if the page is under writeback
516          * so it will not block due to pages that will shortly be freeable.
517          */
518         nfsi = NFS_I(mapping->host);
519         if (atomic_read(&nfsi->commit_info.rpcs_out)) {
520                 *writeback = true;
521                 return;
522         }
523 
524         /*
525          * If PagePrivate() is set, then the page is not freeable and as the
526          * inode is not being committed, it's not going to be cleaned in the
527          * near future so treat it as dirty
528          */
529         if (PagePrivate(page))
530                 *dirty = true;
531 }
532 
533 /*
534  * Attempt to clear the private state associated with a page when an error
535  * occurs that requires the cached contents of an inode to be written back or
536  * destroyed
537  * - Called if either PG_private or fscache is set on the page
538  * - Caller holds page lock
539  * - Return 0 if successful, -error otherwise
540  */
541 static int nfs_launder_page(struct page *page)
542 {
543         struct inode *inode = page_file_mapping(page)->host;
544         struct nfs_inode *nfsi = NFS_I(inode);
545 
546         dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
547                 inode->i_ino, (long long)page_offset(page));
548 
549         nfs_fscache_wait_on_page_write(nfsi, page);
550         return nfs_wb_launder_page(inode, page);
551 }
552 
553 static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file,
554                                                 sector_t *span)
555 {
556         struct rpc_clnt *clnt = NFS_CLIENT(file->f_mapping->host);
557 
558         *span = sis->pages;
559 
560         return rpc_clnt_swap_activate(clnt);
561 }
562 
563 static void nfs_swap_deactivate(struct file *file)
564 {
565         struct rpc_clnt *clnt = NFS_CLIENT(file->f_mapping->host);
566 
567         rpc_clnt_swap_deactivate(clnt);
568 }
569 
570 const struct address_space_operations nfs_file_aops = {
571         .readpage = nfs_readpage,
572         .readpages = nfs_readpages,
573         .set_page_dirty = __set_page_dirty_nobuffers,
574         .writepage = nfs_writepage,
575         .writepages = nfs_writepages,
576         .write_begin = nfs_write_begin,
577         .write_end = nfs_write_end,
578         .invalidatepage = nfs_invalidate_page,
579         .releasepage = nfs_release_page,
580         .direct_IO = nfs_direct_IO,
581         .migratepage = nfs_migrate_page,
582         .launder_page = nfs_launder_page,
583         .is_dirty_writeback = nfs_check_dirty_writeback,
584         .error_remove_page = generic_error_remove_page,
585         .swap_activate = nfs_swap_activate,
586         .swap_deactivate = nfs_swap_deactivate,
587 };
588 
589 /*
590  * Notification that a PTE pointing to an NFS page is about to be made
591  * writable, implying that someone is about to modify the page through a
592  * shared-writable mapping
593  */
594 static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
595 {
596         struct page *page = vmf->page;
597         struct file *filp = vma->vm_file;
598         struct inode *inode = file_inode(filp);
599         unsigned pagelen;
600         int ret = VM_FAULT_NOPAGE;
601         struct address_space *mapping;
602 
603         dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n",
604                 filp, filp->f_mapping->host->i_ino,
605                 (long long)page_offset(page));
606 
607         /* make sure the cache has finished storing the page */
608         nfs_fscache_wait_on_page_write(NFS_I(inode), page);
609 
610         wait_on_bit_action(&NFS_I(inode)->flags, NFS_INO_INVALIDATING,
611                         nfs_wait_bit_killable, TASK_KILLABLE);
612 
613         lock_page(page);
614         mapping = page_file_mapping(page);
615         if (mapping != inode->i_mapping)
616                 goto out_unlock;
617 
618         wait_on_page_writeback(page);
619 
620         pagelen = nfs_page_length(page);
621         if (pagelen == 0)
622                 goto out_unlock;
623 
624         ret = VM_FAULT_LOCKED;
625         if (nfs_flush_incompatible(filp, page) == 0 &&
626             nfs_updatepage(filp, page, 0, pagelen) == 0)
627                 goto out;
628 
629         ret = VM_FAULT_SIGBUS;
630 out_unlock:
631         unlock_page(page);
632 out:
633         return ret;
634 }
635 
636 static const struct vm_operations_struct nfs_file_vm_ops = {
637         .fault = filemap_fault,
638         .map_pages = filemap_map_pages,
639         .page_mkwrite = nfs_vm_page_mkwrite,
640 };
641 
642 static int nfs_need_check_write(struct file *filp, struct inode *inode)
643 {
644         struct nfs_open_context *ctx;
645 
646         ctx = nfs_file_open_context(filp);
647         if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags) ||
648             nfs_ctx_key_to_expire(ctx))
649                 return 1;
650         return 0;
651 }
652 
653 ssize_t nfs_file_write(struct kiocb *iocb, struct iov_iter *from)
654 {
655         struct file *file = iocb->ki_filp;
656         struct inode *inode = file_inode(file);
657         unsigned long written = 0;
658         ssize_t result;
659         size_t count = iov_iter_count(from);
660 
661         result = nfs_key_timeout_notify(file, inode);
662         if (result)
663                 return result;
664 
665         if (iocb->ki_flags & IOCB_DIRECT) {
666                 result = generic_write_checks(iocb, from);
667                 if (result <= 0)
668                         return result;
669                 return nfs_file_direct_write(iocb, from);
670         }
671 
672         dprintk("NFS: write(%pD2, %zu@%Ld)\n",
673                 file, count, (long long) iocb->ki_pos);
674 
675         result = -EBUSY;
676         if (IS_SWAPFILE(inode))
677                 goto out_swapfile;
678         /*
679          * O_APPEND implies that we must revalidate the file length.
680          */
681         if (iocb->ki_flags & IOCB_APPEND) {
682                 result = nfs_revalidate_file_size(inode, file);
683                 if (result)
684                         goto out;
685         }
686 
687         result = count;
688         if (!count)
689                 goto out;
690 
691         result = generic_file_write_iter(iocb, from);
692         if (result > 0)
693                 written = result;
694 
695         /* Return error values */
696         if (result >= 0 && nfs_need_check_write(file, inode)) {
697                 int err = vfs_fsync(file, 0);
698                 if (err < 0)
699                         result = err;
700         }
701         if (result > 0)
702                 nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
703 out:
704         return result;
705 
706 out_swapfile:
707         printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
708         goto out;
709 }
710 EXPORT_SYMBOL_GPL(nfs_file_write);
711 
712 static int
713 do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
714 {
715         struct inode *inode = filp->f_mapping->host;
716         int status = 0;
717         unsigned int saved_type = fl->fl_type;
718 
719         /* Try local locking first */
720         posix_test_lock(filp, fl);
721         if (fl->fl_type != F_UNLCK) {
722                 /* found a conflict */
723                 goto out;
724         }
725         fl->fl_type = saved_type;
726 
727         if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
728                 goto out_noconflict;
729 
730         if (is_local)
731                 goto out_noconflict;
732 
733         status = NFS_PROTO(inode)->lock(filp, cmd, fl);
734 out:
735         return status;
736 out_noconflict:
737         fl->fl_type = F_UNLCK;
738         goto out;
739 }
740 
741 static int do_vfs_lock(struct file *file, struct file_lock *fl)
742 {
743         return locks_lock_file_wait(file, fl);
744 }
745 
746 static int
747 do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
748 {
749         struct inode *inode = filp->f_mapping->host;
750         struct nfs_lock_context *l_ctx;
751         int status;
752 
753         /*
754          * Flush all pending writes before doing anything
755          * with locks..
756          */
757         vfs_fsync(filp, 0);
758 
759         l_ctx = nfs_get_lock_context(nfs_file_open_context(filp));
760         if (!IS_ERR(l_ctx)) {
761                 status = nfs_iocounter_wait(l_ctx);
762                 nfs_put_lock_context(l_ctx);
763                 if (status < 0)
764                         return status;
765         }
766 
767         /* NOTE: special case
768          *      If we're signalled while cleaning up locks on process exit, we
769          *      still need to complete the unlock.
770          */
771         /*
772          * Use local locking if mounted with "-onolock" or with appropriate
773          * "-olocal_lock="
774          */
775         if (!is_local)
776                 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
777         else
778                 status = do_vfs_lock(filp, fl);
779         return status;
780 }
781 
782 static int
783 is_time_granular(struct timespec *ts) {
784         return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
785 }
786 
787 static int
788 do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
789 {
790         struct inode *inode = filp->f_mapping->host;
791         int status;
792 
793         /*
794          * Flush all pending writes before doing anything
795          * with locks..
796          */
797         status = nfs_sync_mapping(filp->f_mapping);
798         if (status != 0)
799                 goto out;
800 
801         /*
802          * Use local locking if mounted with "-onolock" or with appropriate
803          * "-olocal_lock="
804          */
805         if (!is_local)
806                 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
807         else
808                 status = do_vfs_lock(filp, fl);
809         if (status < 0)
810                 goto out;
811 
812         /*
813          * Revalidate the cache if the server has time stamps granular
814          * enough to detect subsecond changes.  Otherwise, clear the
815          * cache to prevent missing any changes.
816          *
817          * This makes locking act as a cache coherency point.
818          */
819         nfs_sync_mapping(filp->f_mapping);
820         if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) {
821                 if (is_time_granular(&NFS_SERVER(inode)->time_delta))
822                         __nfs_revalidate_inode(NFS_SERVER(inode), inode);
823                 else
824                         nfs_zap_caches(inode);
825         }
826 out:
827         return status;
828 }
829 
830 /*
831  * Lock a (portion of) a file
832  */
833 int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
834 {
835         struct inode *inode = filp->f_mapping->host;
836         int ret = -ENOLCK;
837         int is_local = 0;
838 
839         dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n",
840                         filp, fl->fl_type, fl->fl_flags,
841                         (long long)fl->fl_start, (long long)fl->fl_end);
842 
843         nfs_inc_stats(inode, NFSIOS_VFSLOCK);
844 
845         /* No mandatory locks over NFS */
846         if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
847                 goto out_err;
848 
849         if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
850                 is_local = 1;
851 
852         if (NFS_PROTO(inode)->lock_check_bounds != NULL) {
853                 ret = NFS_PROTO(inode)->lock_check_bounds(fl);
854                 if (ret < 0)
855                         goto out_err;
856         }
857 
858         if (IS_GETLK(cmd))
859                 ret = do_getlk(filp, cmd, fl, is_local);
860         else if (fl->fl_type == F_UNLCK)
861                 ret = do_unlk(filp, cmd, fl, is_local);
862         else
863                 ret = do_setlk(filp, cmd, fl, is_local);
864 out_err:
865         return ret;
866 }
867 EXPORT_SYMBOL_GPL(nfs_lock);
868 
869 /*
870  * Lock a (portion of) a file
871  */
872 int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
873 {
874         struct inode *inode = filp->f_mapping->host;
875         int is_local = 0;
876 
877         dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n",
878                         filp, fl->fl_type, fl->fl_flags);
879 
880         if (!(fl->fl_flags & FL_FLOCK))
881                 return -ENOLCK;
882 
883         /*
884          * The NFSv4 protocol doesn't support LOCK_MAND, which is not part of
885          * any standard. In principle we might be able to support LOCK_MAND
886          * on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the
887          * NFS code is not set up for it.
888          */
889         if (fl->fl_type & LOCK_MAND)
890                 return -EINVAL;
891 
892         if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
893                 is_local = 1;
894 
895         /* We're simulating flock() locks using posix locks on the server */
896         if (fl->fl_type == F_UNLCK)
897                 return do_unlk(filp, cmd, fl, is_local);
898         return do_setlk(filp, cmd, fl, is_local);
899 }
900 EXPORT_SYMBOL_GPL(nfs_flock);
901 
902 const struct file_operations nfs_file_operations = {
903         .llseek         = nfs_file_llseek,
904         .read_iter      = nfs_file_read,
905         .write_iter     = nfs_file_write,
906         .mmap           = nfs_file_mmap,
907         .open           = nfs_file_open,
908         .flush          = nfs_file_flush,
909         .release        = nfs_file_release,
910         .fsync          = nfs_file_fsync,
911         .lock           = nfs_lock,
912         .flock          = nfs_flock,
913         .splice_read    = nfs_file_splice_read,
914         .splice_write   = iter_file_splice_write,
915         .check_flags    = nfs_check_flags,
916         .setlease       = simple_nosetlease,
917 };
918 EXPORT_SYMBOL_GPL(nfs_file_operations);
919 

~ [ 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