Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
file.c
Go to the documentation of this file.
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 [email protected].
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/aio.h>
30 #include <linux/gfp.h>
31 #include <linux/swap.h>
32 
33 #include <asm/uaccess.h>
34 
35 #include "delegation.h"
36 #include "internal.h"
37 #include "iostat.h"
38 #include "fscache.h"
39 
40 #define NFSDBG_FACILITY NFSDBG_FILE
41 
42 static const struct vm_operations_struct nfs_file_vm_ops;
43 
44 /* Hack for future NFS swap support */
45 #ifndef IS_SWAPFILE
46 # define IS_SWAPFILE(inode) (0)
47 #endif
48 
50 {
51  if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
52  return -EINVAL;
53 
54  return 0;
55 }
57 
58 /*
59  * Open file
60  */
61 static int
62 nfs_file_open(struct inode *inode, struct file *filp)
63 {
64  int res;
65 
66  dprintk("NFS: open file(%s/%s)\n",
67  filp->f_path.dentry->d_parent->d_name.name,
68  filp->f_path.dentry->d_name.name);
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(%s/%s)\n",
83  filp->f_path.dentry->d_parent->d_name.name,
84  filp->f_path.dentry->d_name.name);
85 
86  nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
87  return nfs_release(inode, filp);
88 }
90 
102 static int nfs_revalidate_file_size(struct inode *inode, struct file *filp)
103 {
104  struct nfs_server *server = NFS_SERVER(inode);
105  struct nfs_inode *nfsi = NFS_I(inode);
106 
107  if (nfs_have_delegated_attributes(inode))
108  goto out_noreval;
109 
110  if (filp->f_flags & O_DIRECT)
111  goto force_reval;
113  goto force_reval;
114  if (nfs_attribute_timeout(inode))
115  goto force_reval;
116 out_noreval:
117  return 0;
118 force_reval:
119  return __nfs_revalidate_inode(server, inode);
120 }
121 
122 loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
123 {
124  dprintk("NFS: llseek file(%s/%s, %lld, %d)\n",
125  filp->f_path.dentry->d_parent->d_name.name,
126  filp->f_path.dentry->d_name.name,
127  offset, origin);
128 
129  /*
130  * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
131  * the cached file length
132  */
133  if (origin != SEEK_SET && origin != SEEK_CUR) {
134  struct inode *inode = filp->f_mapping->host;
135 
136  int retval = nfs_revalidate_file_size(inode, filp);
137  if (retval < 0)
138  return (loff_t)retval;
139  }
140 
141  return generic_file_llseek(filp, offset, origin);
142 }
144 
145 /*
146  * Flush all dirty pages, and check for write errors.
147  */
148 int
150 {
151  struct dentry *dentry = file->f_path.dentry;
152  struct inode *inode = dentry->d_inode;
153 
154  dprintk("NFS: flush(%s/%s)\n",
155  dentry->d_parent->d_name.name,
156  dentry->d_name.name);
157 
158  nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
159  if ((file->f_mode & FMODE_WRITE) == 0)
160  return 0;
161 
162  /*
163  * If we're holding a write delegation, then just start the i/o
164  * but don't wait for completion (or send a commit).
165  */
166  if (NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE))
167  return filemap_fdatawrite(file->f_mapping);
168 
169  /* Flush writes to the server and return any errors */
170  return vfs_fsync(file, 0);
171 }
173 
174 ssize_t
175 nfs_file_read(struct kiocb *iocb, const struct iovec *iov,
176  unsigned long nr_segs, loff_t pos)
177 {
178  struct dentry * dentry = iocb->ki_filp->f_path.dentry;
179  struct inode * inode = dentry->d_inode;
180  ssize_t result;
181 
182  if (iocb->ki_filp->f_flags & O_DIRECT)
183  return nfs_file_direct_read(iocb, iov, nr_segs, pos, true);
184 
185  dprintk("NFS: read(%s/%s, %lu@%lu)\n",
186  dentry->d_parent->d_name.name, dentry->d_name.name,
187  (unsigned long) iov_length(iov, nr_segs), (unsigned long) pos);
188 
189  result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping);
190  if (!result) {
191  result = generic_file_aio_read(iocb, iov, nr_segs, pos);
192  if (result > 0)
193  nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result);
194  }
195  return result;
196 }
198 
199 ssize_t
200 nfs_file_splice_read(struct file *filp, loff_t *ppos,
201  struct pipe_inode_info *pipe, size_t count,
202  unsigned int flags)
203 {
204  struct dentry *dentry = filp->f_path.dentry;
205  struct inode *inode = dentry->d_inode;
206  ssize_t res;
207 
208  dprintk("NFS: splice_read(%s/%s, %lu@%Lu)\n",
209  dentry->d_parent->d_name.name, dentry->d_name.name,
210  (unsigned long) count, (unsigned long long) *ppos);
211 
212  res = nfs_revalidate_mapping(inode, filp->f_mapping);
213  if (!res) {
214  res = generic_file_splice_read(filp, ppos, pipe, count, flags);
215  if (res > 0)
216  nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res);
217  }
218  return res;
219 }
221 
222 int
223 nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
224 {
225  struct dentry *dentry = file->f_path.dentry;
226  struct inode *inode = dentry->d_inode;
227  int status;
228 
229  dprintk("NFS: mmap(%s/%s)\n",
230  dentry->d_parent->d_name.name, dentry->d_name.name);
231 
232  /* Note: generic_file_mmap() returns ENOSYS on nommu systems
233  * so we call that before revalidating the mapping
234  */
235  status = generic_file_mmap(file, vma);
236  if (!status) {
237  vma->vm_ops = &nfs_file_vm_ops;
238  status = nfs_revalidate_mapping(inode, file->f_mapping);
239  }
240  return status;
241 }
243 
244 /*
245  * Flush any dirty pages for this process, and check for write errors.
246  * The return status from this call provides a reliable indication of
247  * whether any write errors occurred for this process.
248  *
249  * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to
250  * disk, but it retrieves and clears ctx->error after synching, despite
251  * the two being set at the same time in nfs_context_set_write_error().
252  * This is because the former is used to notify the _next_ call to
253  * nfs_file_write() that a write error occurred, and hence cause it to
254  * fall back to doing a synchronous write.
255  */
256 int
257 nfs_file_fsync_commit(struct file *file, loff_t start, loff_t end, int datasync)
258 {
259  struct dentry *dentry = file->f_path.dentry;
260  struct nfs_open_context *ctx = nfs_file_open_context(file);
261  struct inode *inode = dentry->d_inode;
262  int have_error, do_resend, status;
263  int ret = 0;
264 
265  dprintk("NFS: fsync file(%s/%s) datasync %d\n",
266  dentry->d_parent->d_name.name, dentry->d_name.name,
267  datasync);
268 
269  nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
271  have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
272  status = nfs_commit_inode(inode, FLUSH_SYNC);
273  have_error |= test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
274  if (have_error) {
275  ret = xchg(&ctx->error, 0);
276  if (ret)
277  goto out;
278  }
279  if (status < 0) {
280  ret = status;
281  goto out;
282  }
283  do_resend |= test_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
284  if (do_resend)
285  ret = -EAGAIN;
286 out:
287  return ret;
288 }
290 
291 static int
292 nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
293 {
294  int ret;
295  struct inode *inode = file->f_path.dentry->d_inode;
296 
297  do {
298  ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
299  if (ret != 0)
300  break;
301  mutex_lock(&inode->i_mutex);
302  ret = nfs_file_fsync_commit(file, start, end, datasync);
303  mutex_unlock(&inode->i_mutex);
304  /*
305  * If nfs_file_fsync_commit detected a server reboot, then
306  * resend all dirty pages that might have been covered by
307  * the NFS_CONTEXT_RESEND_WRITES flag
308  */
309  start = 0;
310  end = LLONG_MAX;
311  } while (ret == -EAGAIN);
312 
313  return ret;
314 }
315 
316 /*
317  * Decide whether a read/modify/write cycle may be more efficient
318  * then a modify/write/read cycle when writing to a page in the
319  * page cache.
320  *
321  * The modify/write/read cycle may occur if a page is read before
322  * being completely filled by the writer. In this situation, the
323  * page must be completely written to stable storage on the server
324  * before it can be refilled by reading in the page from the server.
325  * This can lead to expensive, small, FILE_SYNC mode writes being
326  * done.
327  *
328  * It may be more efficient to read the page first if the file is
329  * open for reading in addition to writing, the page is not marked
330  * as Uptodate, it is not dirty or waiting to be committed,
331  * indicating that it was previously allocated and then modified,
332  * that there were valid bytes of data in that range of the file,
333  * and that the new data won't completely replace the old data in
334  * that range of the file.
335  */
336 static int nfs_want_read_modify_write(struct file *file, struct page *page,
337  loff_t pos, unsigned len)
338 {
339  unsigned int pglen = nfs_page_length(page);
340  unsigned int offset = pos & (PAGE_CACHE_SIZE - 1);
341  unsigned int end = offset + len;
342 
343  if ((file->f_mode & FMODE_READ) && /* open for read? */
344  !PageUptodate(page) && /* Uptodate? */
345  !PagePrivate(page) && /* i/o request already? */
346  pglen && /* valid bytes of file? */
347  (end < pglen || offset)) /* replace all valid bytes? */
348  return 1;
349  return 0;
350 }
351 
352 /*
353  * This does the "real" work of the write. We must allocate and lock the
354  * page to be sent back to the generic routine, which then copies the
355  * data from user space.
356  *
357  * If the writer ends up delaying the write, the writer needs to
358  * increment the page use counts until he is done with the page.
359  */
360 static int nfs_write_begin(struct file *file, struct address_space *mapping,
361  loff_t pos, unsigned len, unsigned flags,
362  struct page **pagep, void **fsdata)
363 {
364  int ret;
365  pgoff_t index = pos >> PAGE_CACHE_SHIFT;
366  struct page *page;
367  int once_thru = 0;
368 
369  dfprintk(PAGECACHE, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n",
370  file->f_path.dentry->d_parent->d_name.name,
371  file->f_path.dentry->d_name.name,
372  mapping->host->i_ino, len, (long long) pos);
373 
374 start:
375  /*
376  * Prevent starvation issues if someone is doing a consistency
377  * sync-to-disk
378  */
379  ret = wait_on_bit(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING,
381  if (ret)
382  return ret;
383 
384  page = grab_cache_page_write_begin(mapping, index, flags);
385  if (!page)
386  return -ENOMEM;
387  *pagep = page;
388 
389  ret = nfs_flush_incompatible(file, page);
390  if (ret) {
391  unlock_page(page);
392  page_cache_release(page);
393  } else if (!once_thru &&
394  nfs_want_read_modify_write(file, page, pos, len)) {
395  once_thru = 1;
396  ret = nfs_readpage(file, page);
397  page_cache_release(page);
398  if (!ret)
399  goto start;
400  }
401  return ret;
402 }
403 
404 static int nfs_write_end(struct file *file, struct address_space *mapping,
405  loff_t pos, unsigned len, unsigned copied,
406  struct page *page, void *fsdata)
407 {
408  unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
409  int status;
410 
411  dfprintk(PAGECACHE, "NFS: write_end(%s/%s(%ld), %u@%lld)\n",
412  file->f_path.dentry->d_parent->d_name.name,
413  file->f_path.dentry->d_name.name,
414  mapping->host->i_ino, len, (long long) pos);
415 
416  /*
417  * Zero any uninitialised parts of the page, and then mark the page
418  * as up to date if it turns out that we're extending the file.
419  */
420  if (!PageUptodate(page)) {
421  unsigned pglen = nfs_page_length(page);
422  unsigned end = offset + len;
423 
424  if (pglen == 0) {
425  zero_user_segments(page, 0, offset,
426  end, PAGE_CACHE_SIZE);
427  SetPageUptodate(page);
428  } else if (end >= pglen) {
429  zero_user_segment(page, end, PAGE_CACHE_SIZE);
430  if (offset == 0)
431  SetPageUptodate(page);
432  } else
433  zero_user_segment(page, pglen, PAGE_CACHE_SIZE);
434  }
435 
436  status = nfs_updatepage(file, page, offset, copied);
437 
438  unlock_page(page);
439  page_cache_release(page);
440 
441  if (status < 0)
442  return status;
443  NFS_I(mapping->host)->write_io += copied;
444  return copied;
445 }
446 
447 /*
448  * Partially or wholly invalidate a page
449  * - Release the private state associated with a page if undergoing complete
450  * page invalidation
451  * - Called if either PG_private or PG_fscache is set on the page
452  * - Caller holds page lock
453  */
454 static void nfs_invalidate_page(struct page *page, unsigned long offset)
455 {
456  dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %lu)\n", page, offset);
457 
458  if (offset != 0)
459  return;
460  /* Cancel any unstarted writes on this page */
461  nfs_wb_page_cancel(page_file_mapping(page)->host, page);
462 
463  nfs_fscache_invalidate_page(page, page->mapping->host);
464 }
465 
466 /*
467  * Attempt to release the private state associated with a page
468  * - Called if either PG_private or PG_fscache is set on the page
469  * - Caller holds page lock
470  * - Return true (may release page) or false (may not)
471  */
472 static int nfs_release_page(struct page *page, gfp_t gfp)
473 {
474  struct address_space *mapping = page->mapping;
475 
476  dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);
477 
478  /* Only do I/O if gfp is a superset of GFP_KERNEL, and we're not
479  * doing this memory reclaim for a fs-related allocation.
480  */
481  if (mapping && (gfp & GFP_KERNEL) == GFP_KERNEL &&
482  !(current->flags & PF_FSTRANS)) {
483  int how = FLUSH_SYNC;
484 
485  /* Don't let kswapd deadlock waiting for OOM RPC calls */
486  if (current_is_kswapd())
487  how = 0;
488  nfs_commit_inode(mapping->host, how);
489  }
490  /* If PagePrivate() is set, then the page is not freeable */
491  if (PagePrivate(page))
492  return 0;
493  return nfs_fscache_release_page(page, gfp);
494 }
495 
496 /*
497  * Attempt to clear the private state associated with a page when an error
498  * occurs that requires the cached contents of an inode to be written back or
499  * destroyed
500  * - Called if either PG_private or fscache is set on the page
501  * - Caller holds page lock
502  * - Return 0 if successful, -error otherwise
503  */
504 static int nfs_launder_page(struct page *page)
505 {
506  struct inode *inode = page_file_mapping(page)->host;
507  struct nfs_inode *nfsi = NFS_I(inode);
508 
509  dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
510  inode->i_ino, (long long)page_offset(page));
511 
512  nfs_fscache_wait_on_page_write(nfsi, page);
513  return nfs_wb_page(inode, page);
514 }
515 
516 #ifdef CONFIG_NFS_SWAP
517 static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file,
518  sector_t *span)
519 {
520  *span = sis->pages;
521  return xs_swapper(NFS_CLIENT(file->f_mapping->host)->cl_xprt, 1);
522 }
523 
524 static void nfs_swap_deactivate(struct file *file)
525 {
526  xs_swapper(NFS_CLIENT(file->f_mapping->host)->cl_xprt, 0);
527 }
528 #endif
529 
531  .readpage = nfs_readpage,
532  .readpages = nfs_readpages,
533  .set_page_dirty = __set_page_dirty_nobuffers,
534  .writepage = nfs_writepage,
535  .writepages = nfs_writepages,
536  .write_begin = nfs_write_begin,
537  .write_end = nfs_write_end,
538  .invalidatepage = nfs_invalidate_page,
539  .releasepage = nfs_release_page,
540  .direct_IO = nfs_direct_IO,
541  .migratepage = nfs_migrate_page,
542  .launder_page = nfs_launder_page,
543  .error_remove_page = generic_error_remove_page,
544 #ifdef CONFIG_NFS_SWAP
545  .swap_activate = nfs_swap_activate,
546  .swap_deactivate = nfs_swap_deactivate,
547 #endif
548 };
549 
550 /*
551  * Notification that a PTE pointing to an NFS page is about to be made
552  * writable, implying that someone is about to modify the page through a
553  * shared-writable mapping
554  */
555 static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
556 {
557  struct page *page = vmf->page;
558  struct file *filp = vma->vm_file;
559  struct dentry *dentry = filp->f_path.dentry;
560  unsigned pagelen;
561  int ret = VM_FAULT_NOPAGE;
562  struct address_space *mapping;
563 
564  dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%s/%s(%ld), offset %lld)\n",
565  dentry->d_parent->d_name.name, dentry->d_name.name,
566  filp->f_mapping->host->i_ino,
567  (long long)page_offset(page));
568 
569  /* make sure the cache has finished storing the page */
570  nfs_fscache_wait_on_page_write(NFS_I(dentry->d_inode), page);
571 
572  lock_page(page);
573  mapping = page_file_mapping(page);
574  if (mapping != dentry->d_inode->i_mapping)
575  goto out_unlock;
576 
577  wait_on_page_writeback(page);
578 
579  pagelen = nfs_page_length(page);
580  if (pagelen == 0)
581  goto out_unlock;
582 
583  ret = VM_FAULT_LOCKED;
584  if (nfs_flush_incompatible(filp, page) == 0 &&
585  nfs_updatepage(filp, page, 0, pagelen) == 0)
586  goto out;
587 
588  ret = VM_FAULT_SIGBUS;
589 out_unlock:
590  unlock_page(page);
591 out:
592  return ret;
593 }
594 
595 static const struct vm_operations_struct nfs_file_vm_ops = {
596  .fault = filemap_fault,
597  .page_mkwrite = nfs_vm_page_mkwrite,
598  .remap_pages = generic_file_remap_pages,
599 };
600 
601 static int nfs_need_sync_write(struct file *filp, struct inode *inode)
602 {
603  struct nfs_open_context *ctx;
604 
605  if (IS_SYNC(inode) || (filp->f_flags & O_DSYNC))
606  return 1;
607  ctx = nfs_file_open_context(filp);
609  return 1;
610  return 0;
611 }
612 
613 ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
614  unsigned long nr_segs, loff_t pos)
615 {
616  struct dentry * dentry = iocb->ki_filp->f_path.dentry;
617  struct inode * inode = dentry->d_inode;
618  unsigned long written = 0;
619  ssize_t result;
620  size_t count = iov_length(iov, nr_segs);
621 
622  if (iocb->ki_filp->f_flags & O_DIRECT)
623  return nfs_file_direct_write(iocb, iov, nr_segs, pos, true);
624 
625  dprintk("NFS: write(%s/%s, %lu@%Ld)\n",
626  dentry->d_parent->d_name.name, dentry->d_name.name,
627  (unsigned long) count, (long long) pos);
628 
629  result = -EBUSY;
630  if (IS_SWAPFILE(inode))
631  goto out_swapfile;
632  /*
633  * O_APPEND implies that we must revalidate the file length.
634  */
635  if (iocb->ki_filp->f_flags & O_APPEND) {
636  result = nfs_revalidate_file_size(inode, iocb->ki_filp);
637  if (result)
638  goto out;
639  }
640 
641  result = count;
642  if (!count)
643  goto out;
644 
645  result = generic_file_aio_write(iocb, iov, nr_segs, pos);
646  if (result > 0)
647  written = result;
648 
649  /* Return error values for O_DSYNC and IS_SYNC() */
650  if (result >= 0 && nfs_need_sync_write(iocb->ki_filp, inode)) {
651  int err = vfs_fsync(iocb->ki_filp, 0);
652  if (err < 0)
653  result = err;
654  }
655  if (result > 0)
656  nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
657 out:
658  return result;
659 
660 out_swapfile:
661  printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
662  goto out;
663 }
665 
667  struct file *filp, loff_t *ppos,
668  size_t count, unsigned int flags)
669 {
670  struct dentry *dentry = filp->f_path.dentry;
671  struct inode *inode = dentry->d_inode;
672  unsigned long written = 0;
673  ssize_t ret;
674 
675  dprintk("NFS splice_write(%s/%s, %lu@%llu)\n",
676  dentry->d_parent->d_name.name, dentry->d_name.name,
677  (unsigned long) count, (unsigned long long) *ppos);
678 
679  /*
680  * The combination of splice and an O_APPEND destination is disallowed.
681  */
682 
683  ret = generic_file_splice_write(pipe, filp, ppos, count, flags);
684  if (ret > 0)
685  written = ret;
686 
687  if (ret >= 0 && nfs_need_sync_write(filp, inode)) {
688  int err = vfs_fsync(filp, 0);
689  if (err < 0)
690  ret = err;
691  }
692  if (ret > 0)
693  nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
694  return ret;
695 }
697 
698 static int
699 do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
700 {
701  struct inode *inode = filp->f_mapping->host;
702  int status = 0;
703  unsigned int saved_type = fl->fl_type;
704 
705  /* Try local locking first */
706  posix_test_lock(filp, fl);
707  if (fl->fl_type != F_UNLCK) {
708  /* found a conflict */
709  goto out;
710  }
711  fl->fl_type = saved_type;
712 
713  if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
714  goto out_noconflict;
715 
716  if (is_local)
717  goto out_noconflict;
718 
719  status = NFS_PROTO(inode)->lock(filp, cmd, fl);
720 out:
721  return status;
722 out_noconflict:
723  fl->fl_type = F_UNLCK;
724  goto out;
725 }
726 
727 static int do_vfs_lock(struct file *file, struct file_lock *fl)
728 {
729  int res = 0;
730  switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
731  case FL_POSIX:
732  res = posix_lock_file_wait(file, fl);
733  break;
734  case FL_FLOCK:
735  res = flock_lock_file_wait(file, fl);
736  break;
737  default:
738  BUG();
739  }
740  return res;
741 }
742 
743 static int
744 do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
745 {
746  struct inode *inode = filp->f_mapping->host;
747  int status;
748 
749  /*
750  * Flush all pending writes before doing anything
751  * with locks..
752  */
754 
755  /* NOTE: special case
756  * If we're signalled while cleaning up locks on process exit, we
757  * still need to complete the unlock.
758  */
759  /*
760  * Use local locking if mounted with "-onolock" or with appropriate
761  * "-olocal_lock="
762  */
763  if (!is_local)
764  status = NFS_PROTO(inode)->lock(filp, cmd, fl);
765  else
766  status = do_vfs_lock(filp, fl);
767  return status;
768 }
769 
770 static int
771 is_time_granular(struct timespec *ts) {
772  return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
773 }
774 
775 static int
776 do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
777 {
778  struct inode *inode = filp->f_mapping->host;
779  int status;
780 
781  /*
782  * Flush all pending writes before doing anything
783  * with locks..
784  */
785  status = nfs_sync_mapping(filp->f_mapping);
786  if (status != 0)
787  goto out;
788 
789  /*
790  * Use local locking if mounted with "-onolock" or with appropriate
791  * "-olocal_lock="
792  */
793  if (!is_local)
794  status = NFS_PROTO(inode)->lock(filp, cmd, fl);
795  else
796  status = do_vfs_lock(filp, fl);
797  if (status < 0)
798  goto out;
799 
800  /*
801  * Revalidate the cache if the server has time stamps granular
802  * enough to detect subsecond changes. Otherwise, clear the
803  * cache to prevent missing any changes.
804  *
805  * This makes locking act as a cache coherency point.
806  */
808  if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) {
809  if (is_time_granular(&NFS_SERVER(inode)->time_delta))
810  __nfs_revalidate_inode(NFS_SERVER(inode), inode);
811  else
812  nfs_zap_caches(inode);
813  }
814 out:
815  return status;
816 }
817 
818 /*
819  * Lock a (portion of) a file
820  */
821 int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
822 {
823  struct inode *inode = filp->f_mapping->host;
824  int ret = -ENOLCK;
825  int is_local = 0;
826 
827  dprintk("NFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n",
828  filp->f_path.dentry->d_parent->d_name.name,
829  filp->f_path.dentry->d_name.name,
830  fl->fl_type, fl->fl_flags,
831  (long long)fl->fl_start, (long long)fl->fl_end);
832 
833  nfs_inc_stats(inode, NFSIOS_VFSLOCK);
834 
835  /* No mandatory locks over NFS */
836  if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
837  goto out_err;
838 
839  if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
840  is_local = 1;
841 
842  if (NFS_PROTO(inode)->lock_check_bounds != NULL) {
843  ret = NFS_PROTO(inode)->lock_check_bounds(fl);
844  if (ret < 0)
845  goto out_err;
846  }
847 
848  if (IS_GETLK(cmd))
849  ret = do_getlk(filp, cmd, fl, is_local);
850  else if (fl->fl_type == F_UNLCK)
851  ret = do_unlk(filp, cmd, fl, is_local);
852  else
853  ret = do_setlk(filp, cmd, fl, is_local);
854 out_err:
855  return ret;
856 }
858 
859 /*
860  * Lock a (portion of) a file
861  */
862 int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
863 {
864  struct inode *inode = filp->f_mapping->host;
865  int is_local = 0;
866 
867  dprintk("NFS: flock(%s/%s, t=%x, fl=%x)\n",
868  filp->f_path.dentry->d_parent->d_name.name,
869  filp->f_path.dentry->d_name.name,
870  fl->fl_type, fl->fl_flags);
871 
872  if (!(fl->fl_flags & FL_FLOCK))
873  return -ENOLCK;
874 
875  /*
876  * The NFSv4 protocol doesn't support LOCK_MAND, which is not part of
877  * any standard. In principle we might be able to support LOCK_MAND
878  * on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the
879  * NFS code is not set up for it.
880  */
881  if (fl->fl_type & LOCK_MAND)
882  return -EINVAL;
883 
884  if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
885  is_local = 1;
886 
887  /* We're simulating flock() locks using posix locks on the server */
888  fl->fl_owner = (fl_owner_t)filp;
889  fl->fl_start = 0;
890  fl->fl_end = OFFSET_MAX;
891 
892  if (fl->fl_type == F_UNLCK)
893  return do_unlk(filp, cmd, fl, is_local);
894  return do_setlk(filp, cmd, fl, is_local);
895 }
897 
898 /*
899  * There is no protocol support for leases, so we have no way to implement
900  * them correctly in the face of opens by other clients.
901  */
902 int nfs_setlease(struct file *file, long arg, struct file_lock **fl)
903 {
904  dprintk("NFS: setlease(%s/%s, arg=%ld)\n",
905  file->f_path.dentry->d_parent->d_name.name,
906  file->f_path.dentry->d_name.name, arg);
907  return -EINVAL;
908 }
910 
912  .llseek = nfs_file_llseek,
913  .read = do_sync_read,
914  .write = do_sync_write,
915  .aio_read = nfs_file_read,
916  .aio_write = nfs_file_write,
917  .mmap = nfs_file_mmap,
918  .open = nfs_file_open,
919  .flush = nfs_file_flush,
920  .release = nfs_file_release,
921  .fsync = nfs_file_fsync,
922  .lock = nfs_lock,
923  .flock = nfs_flock,
924  .splice_read = nfs_file_splice_read,
925  .splice_write = nfs_file_splice_write,
926  .check_flags = nfs_check_flags,
927  .setlease = nfs_setlease,
928 };
929 EXPORT_SYMBOL_GPL(nfs_file_operations);