Merge branch 'overlayfs-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszer...
[sfrench/cifs-2.6.git] / fs / nfs / file.c
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 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 EXPORT_SYMBOL_GPL(nfs_file_fsync_commit);
267
268 static int
269 nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
270 {
271         int ret;
272         struct inode *inode = file_inode(file);
273
274         trace_nfs_fsync_enter(inode);
275
276         nfs_inode_dio_wait(inode);
277         do {
278                 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
279                 if (ret != 0)
280                         break;
281                 inode_lock(inode);
282                 ret = nfs_file_fsync_commit(file, start, end, datasync);
283                 inode_unlock(inode);
284                 /*
285                  * If nfs_file_fsync_commit detected a server reboot, then
286                  * resend all dirty pages that might have been covered by
287                  * the NFS_CONTEXT_RESEND_WRITES flag
288                  */
289                 start = 0;
290                 end = LLONG_MAX;
291         } while (ret == -EAGAIN);
292
293         trace_nfs_fsync_exit(inode, ret);
294         return ret;
295 }
296
297 /*
298  * Decide whether a read/modify/write cycle may be more efficient
299  * then a modify/write/read cycle when writing to a page in the
300  * page cache.
301  *
302  * The modify/write/read cycle may occur if a page is read before
303  * being completely filled by the writer.  In this situation, the
304  * page must be completely written to stable storage on the server
305  * before it can be refilled by reading in the page from the server.
306  * This can lead to expensive, small, FILE_SYNC mode writes being
307  * done.
308  *
309  * It may be more efficient to read the page first if the file is
310  * open for reading in addition to writing, the page is not marked
311  * as Uptodate, it is not dirty or waiting to be committed,
312  * indicating that it was previously allocated and then modified,
313  * that there were valid bytes of data in that range of the file,
314  * and that the new data won't completely replace the old data in
315  * that range of the file.
316  */
317 static int nfs_want_read_modify_write(struct file *file, struct page *page,
318                         loff_t pos, unsigned len)
319 {
320         unsigned int pglen = nfs_page_length(page);
321         unsigned int offset = pos & (PAGE_CACHE_SIZE - 1);
322         unsigned int end = offset + len;
323
324         if (pnfs_ld_read_whole_page(file->f_mapping->host)) {
325                 if (!PageUptodate(page))
326                         return 1;
327                 return 0;
328         }
329
330         if ((file->f_mode & FMODE_READ) &&      /* open for read? */
331             !PageUptodate(page) &&              /* Uptodate? */
332             !PagePrivate(page) &&               /* i/o request already? */
333             pglen &&                            /* valid bytes of file? */
334             (end < pglen || offset))            /* replace all valid bytes? */
335                 return 1;
336         return 0;
337 }
338
339 /*
340  * This does the "real" work of the write. We must allocate and lock the
341  * page to be sent back to the generic routine, which then copies the
342  * data from user space.
343  *
344  * If the writer ends up delaying the write, the writer needs to
345  * increment the page use counts until he is done with the page.
346  */
347 static int nfs_write_begin(struct file *file, struct address_space *mapping,
348                         loff_t pos, unsigned len, unsigned flags,
349                         struct page **pagep, void **fsdata)
350 {
351         int ret;
352         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
353         struct page *page;
354         int once_thru = 0;
355
356         dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n",
357                 file, mapping->host->i_ino, len, (long long) pos);
358
359 start:
360         /*
361          * Prevent starvation issues if someone is doing a consistency
362          * sync-to-disk
363          */
364         ret = wait_on_bit_action(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING,
365                                  nfs_wait_bit_killable, TASK_KILLABLE);
366         if (ret)
367                 return ret;
368         /*
369          * Wait for O_DIRECT to complete
370          */
371         nfs_inode_dio_wait(mapping->host);
372
373         page = grab_cache_page_write_begin(mapping, index, flags);
374         if (!page)
375                 return -ENOMEM;
376         *pagep = page;
377
378         ret = nfs_flush_incompatible(file, page);
379         if (ret) {
380                 unlock_page(page);
381                 page_cache_release(page);
382         } else if (!once_thru &&
383                    nfs_want_read_modify_write(file, page, pos, len)) {
384                 once_thru = 1;
385                 ret = nfs_readpage(file, page);
386                 page_cache_release(page);
387                 if (!ret)
388                         goto start;
389         }
390         return ret;
391 }
392
393 static int nfs_write_end(struct file *file, struct address_space *mapping,
394                         loff_t pos, unsigned len, unsigned copied,
395                         struct page *page, void *fsdata)
396 {
397         unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
398         struct nfs_open_context *ctx = nfs_file_open_context(file);
399         int status;
400
401         dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n",
402                 file, mapping->host->i_ino, len, (long long) pos);
403
404         /*
405          * Zero any uninitialised parts of the page, and then mark the page
406          * as up to date if it turns out that we're extending the file.
407          */
408         if (!PageUptodate(page)) {
409                 unsigned pglen = nfs_page_length(page);
410                 unsigned end = offset + len;
411
412                 if (pglen == 0) {
413                         zero_user_segments(page, 0, offset,
414                                         end, PAGE_CACHE_SIZE);
415                         SetPageUptodate(page);
416                 } else if (end >= pglen) {
417                         zero_user_segment(page, end, PAGE_CACHE_SIZE);
418                         if (offset == 0)
419                                 SetPageUptodate(page);
420                 } else
421                         zero_user_segment(page, pglen, PAGE_CACHE_SIZE);
422         }
423
424         status = nfs_updatepage(file, page, offset, copied);
425
426         unlock_page(page);
427         page_cache_release(page);
428
429         if (status < 0)
430                 return status;
431         NFS_I(mapping->host)->write_io += copied;
432
433         if (nfs_ctx_key_to_expire(ctx)) {
434                 status = nfs_wb_all(mapping->host);
435                 if (status < 0)
436                         return status;
437         }
438
439         return copied;
440 }
441
442 /*
443  * Partially or wholly invalidate a page
444  * - Release the private state associated with a page if undergoing complete
445  *   page invalidation
446  * - Called if either PG_private or PG_fscache is set on the page
447  * - Caller holds page lock
448  */
449 static void nfs_invalidate_page(struct page *page, unsigned int offset,
450                                 unsigned int length)
451 {
452         dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %u, %u)\n",
453                  page, offset, length);
454
455         if (offset != 0 || length < PAGE_CACHE_SIZE)
456                 return;
457         /* Cancel any unstarted writes on this page */
458         nfs_wb_page_cancel(page_file_mapping(page)->host, page);
459
460         nfs_fscache_invalidate_page(page, page->mapping->host);
461 }
462
463 /*
464  * Attempt to release the private state associated with a page
465  * - Called if either PG_private or PG_fscache is set on the page
466  * - Caller holds page lock
467  * - Return true (may release page) or false (may not)
468  */
469 static int nfs_release_page(struct page *page, gfp_t gfp)
470 {
471         struct address_space *mapping = page->mapping;
472
473         dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);
474
475         /* Always try to initiate a 'commit' if relevant, but only
476          * wait for it if the caller allows blocking.  Even then,
477          * only wait 1 second and only if the 'bdi' is not congested.
478          * Waiting indefinitely can cause deadlocks when the NFS
479          * server is on this machine, when a new TCP connection is
480          * needed and in other rare cases.  There is no particular
481          * need to wait extensively here.  A short wait has the
482          * benefit that someone else can worry about the freezer.
483          */
484         if (mapping) {
485                 struct nfs_server *nfss = NFS_SERVER(mapping->host);
486                 nfs_commit_inode(mapping->host, 0);
487                 if (gfpflags_allow_blocking(gfp) &&
488                     !bdi_write_congested(&nfss->backing_dev_info)) {
489                         wait_on_page_bit_killable_timeout(page, PG_private,
490                                                           HZ);
491                         if (PagePrivate(page))
492                                 set_bdi_congested(&nfss->backing_dev_info,
493                                                   BLK_RW_ASYNC);
494                 }
495         }
496         /* If PagePrivate() is set, then the page is not freeable */
497         if (PagePrivate(page))
498                 return 0;
499         return nfs_fscache_release_page(page, gfp);
500 }
501
502 static void nfs_check_dirty_writeback(struct page *page,
503                                 bool *dirty, bool *writeback)
504 {
505         struct nfs_inode *nfsi;
506         struct address_space *mapping = page_file_mapping(page);
507
508         if (!mapping || PageSwapCache(page))
509                 return;
510
511         /*
512          * Check if an unstable page is currently being committed and
513          * if so, have the VM treat it as if the page is under writeback
514          * so it will not block due to pages that will shortly be freeable.
515          */
516         nfsi = NFS_I(mapping->host);
517         if (atomic_read(&nfsi->commit_info.rpcs_out)) {
518                 *writeback = true;
519                 return;
520         }
521
522         /*
523          * If PagePrivate() is set, then the page is not freeable and as the
524          * inode is not being committed, it's not going to be cleaned in the
525          * near future so treat it as dirty
526          */
527         if (PagePrivate(page))
528                 *dirty = true;
529 }
530
531 /*
532  * Attempt to clear the private state associated with a page when an error
533  * occurs that requires the cached contents of an inode to be written back or
534  * destroyed
535  * - Called if either PG_private or fscache is set on the page
536  * - Caller holds page lock
537  * - Return 0 if successful, -error otherwise
538  */
539 static int nfs_launder_page(struct page *page)
540 {
541         struct inode *inode = page_file_mapping(page)->host;
542         struct nfs_inode *nfsi = NFS_I(inode);
543
544         dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
545                 inode->i_ino, (long long)page_offset(page));
546
547         nfs_fscache_wait_on_page_write(nfsi, page);
548         return nfs_wb_launder_page(inode, page);
549 }
550
551 static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file,
552                                                 sector_t *span)
553 {
554         struct rpc_clnt *clnt = NFS_CLIENT(file->f_mapping->host);
555
556         *span = sis->pages;
557
558         return rpc_clnt_swap_activate(clnt);
559 }
560
561 static void nfs_swap_deactivate(struct file *file)
562 {
563         struct rpc_clnt *clnt = NFS_CLIENT(file->f_mapping->host);
564
565         rpc_clnt_swap_deactivate(clnt);
566 }
567
568 const struct address_space_operations nfs_file_aops = {
569         .readpage = nfs_readpage,
570         .readpages = nfs_readpages,
571         .set_page_dirty = __set_page_dirty_nobuffers,
572         .writepage = nfs_writepage,
573         .writepages = nfs_writepages,
574         .write_begin = nfs_write_begin,
575         .write_end = nfs_write_end,
576         .invalidatepage = nfs_invalidate_page,
577         .releasepage = nfs_release_page,
578         .direct_IO = nfs_direct_IO,
579         .migratepage = nfs_migrate_page,
580         .launder_page = nfs_launder_page,
581         .is_dirty_writeback = nfs_check_dirty_writeback,
582         .error_remove_page = generic_error_remove_page,
583         .swap_activate = nfs_swap_activate,
584         .swap_deactivate = nfs_swap_deactivate,
585 };
586
587 /*
588  * Notification that a PTE pointing to an NFS page is about to be made
589  * writable, implying that someone is about to modify the page through a
590  * shared-writable mapping
591  */
592 static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
593 {
594         struct page *page = vmf->page;
595         struct file *filp = vma->vm_file;
596         struct inode *inode = file_inode(filp);
597         unsigned pagelen;
598         int ret = VM_FAULT_NOPAGE;
599         struct address_space *mapping;
600
601         dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n",
602                 filp, filp->f_mapping->host->i_ino,
603                 (long long)page_offset(page));
604
605         /* make sure the cache has finished storing the page */
606         nfs_fscache_wait_on_page_write(NFS_I(inode), page);
607
608         wait_on_bit_action(&NFS_I(inode)->flags, NFS_INO_INVALIDATING,
609                         nfs_wait_bit_killable, TASK_KILLABLE);
610
611         lock_page(page);
612         mapping = page_file_mapping(page);
613         if (mapping != inode->i_mapping)
614                 goto out_unlock;
615
616         wait_on_page_writeback(page);
617
618         pagelen = nfs_page_length(page);
619         if (pagelen == 0)
620                 goto out_unlock;
621
622         ret = VM_FAULT_LOCKED;
623         if (nfs_flush_incompatible(filp, page) == 0 &&
624             nfs_updatepage(filp, page, 0, pagelen) == 0)
625                 goto out;
626
627         ret = VM_FAULT_SIGBUS;
628 out_unlock:
629         unlock_page(page);
630 out:
631         return ret;
632 }
633
634 static const struct vm_operations_struct nfs_file_vm_ops = {
635         .fault = filemap_fault,
636         .map_pages = filemap_map_pages,
637         .page_mkwrite = nfs_vm_page_mkwrite,
638 };
639
640 static int nfs_need_check_write(struct file *filp, struct inode *inode)
641 {
642         struct nfs_open_context *ctx;
643
644         ctx = nfs_file_open_context(filp);
645         if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags) ||
646             nfs_ctx_key_to_expire(ctx))
647                 return 1;
648         return 0;
649 }
650
651 ssize_t nfs_file_write(struct kiocb *iocb, struct iov_iter *from)
652 {
653         struct file *file = iocb->ki_filp;
654         struct inode *inode = file_inode(file);
655         unsigned long written = 0;
656         ssize_t result;
657         size_t count = iov_iter_count(from);
658
659         result = nfs_key_timeout_notify(file, inode);
660         if (result)
661                 return result;
662
663         if (iocb->ki_flags & IOCB_DIRECT) {
664                 result = generic_write_checks(iocb, from);
665                 if (result <= 0)
666                         return result;
667                 return nfs_file_direct_write(iocb, from);
668         }
669
670         dprintk("NFS: write(%pD2, %zu@%Ld)\n",
671                 file, count, (long long) iocb->ki_pos);
672
673         result = -EBUSY;
674         if (IS_SWAPFILE(inode))
675                 goto out_swapfile;
676         /*
677          * O_APPEND implies that we must revalidate the file length.
678          */
679         if (iocb->ki_flags & IOCB_APPEND) {
680                 result = nfs_revalidate_file_size(inode, file);
681                 if (result)
682                         goto out;
683         }
684
685         result = count;
686         if (!count)
687                 goto out;
688
689         result = generic_file_write_iter(iocb, from);
690         if (result > 0)
691                 written = result;
692
693         /* Return error values */
694         if (result >= 0 && nfs_need_check_write(file, inode)) {
695                 int err = vfs_fsync(file, 0);
696                 if (err < 0)
697                         result = err;
698         }
699         if (result > 0)
700                 nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
701 out:
702         return result;
703
704 out_swapfile:
705         printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
706         goto out;
707 }
708 EXPORT_SYMBOL_GPL(nfs_file_write);
709
710 static int
711 do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
712 {
713         struct inode *inode = filp->f_mapping->host;
714         int status = 0;
715         unsigned int saved_type = fl->fl_type;
716
717         /* Try local locking first */
718         posix_test_lock(filp, fl);
719         if (fl->fl_type != F_UNLCK) {
720                 /* found a conflict */
721                 goto out;
722         }
723         fl->fl_type = saved_type;
724
725         if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
726                 goto out_noconflict;
727
728         if (is_local)
729                 goto out_noconflict;
730
731         status = NFS_PROTO(inode)->lock(filp, cmd, fl);
732 out:
733         return status;
734 out_noconflict:
735         fl->fl_type = F_UNLCK;
736         goto out;
737 }
738
739 static int do_vfs_lock(struct file *file, struct file_lock *fl)
740 {
741         return locks_lock_file_wait(file, fl);
742 }
743
744 static int
745 do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
746 {
747         struct inode *inode = filp->f_mapping->host;
748         struct nfs_lock_context *l_ctx;
749         int status;
750
751         /*
752          * Flush all pending writes before doing anything
753          * with locks..
754          */
755         vfs_fsync(filp, 0);
756
757         l_ctx = nfs_get_lock_context(nfs_file_open_context(filp));
758         if (!IS_ERR(l_ctx)) {
759                 status = nfs_iocounter_wait(l_ctx);
760                 nfs_put_lock_context(l_ctx);
761                 if (status < 0)
762                         return status;
763         }
764
765         /* NOTE: special case
766          *      If we're signalled while cleaning up locks on process exit, we
767          *      still need to complete the unlock.
768          */
769         /*
770          * Use local locking if mounted with "-onolock" or with appropriate
771          * "-olocal_lock="
772          */
773         if (!is_local)
774                 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
775         else
776                 status = do_vfs_lock(filp, fl);
777         return status;
778 }
779
780 static int
781 is_time_granular(struct timespec *ts) {
782         return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
783 }
784
785 static int
786 do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
787 {
788         struct inode *inode = filp->f_mapping->host;
789         int status;
790
791         /*
792          * Flush all pending writes before doing anything
793          * with locks..
794          */
795         status = nfs_sync_mapping(filp->f_mapping);
796         if (status != 0)
797                 goto out;
798
799         /*
800          * Use local locking if mounted with "-onolock" or with appropriate
801          * "-olocal_lock="
802          */
803         if (!is_local)
804                 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
805         else
806                 status = do_vfs_lock(filp, fl);
807         if (status < 0)
808                 goto out;
809
810         /*
811          * Revalidate the cache if the server has time stamps granular
812          * enough to detect subsecond changes.  Otherwise, clear the
813          * cache to prevent missing any changes.
814          *
815          * This makes locking act as a cache coherency point.
816          */
817         nfs_sync_mapping(filp->f_mapping);
818         if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) {
819                 if (is_time_granular(&NFS_SERVER(inode)->time_delta))
820                         __nfs_revalidate_inode(NFS_SERVER(inode), inode);
821                 else
822                         nfs_zap_caches(inode);
823         }
824 out:
825         return status;
826 }
827
828 /*
829  * Lock a (portion of) a file
830  */
831 int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
832 {
833         struct inode *inode = filp->f_mapping->host;
834         int ret = -ENOLCK;
835         int is_local = 0;
836
837         dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n",
838                         filp, fl->fl_type, fl->fl_flags,
839                         (long long)fl->fl_start, (long long)fl->fl_end);
840
841         nfs_inc_stats(inode, NFSIOS_VFSLOCK);
842
843         /* No mandatory locks over NFS */
844         if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
845                 goto out_err;
846
847         if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
848                 is_local = 1;
849
850         if (NFS_PROTO(inode)->lock_check_bounds != NULL) {
851                 ret = NFS_PROTO(inode)->lock_check_bounds(fl);
852                 if (ret < 0)
853                         goto out_err;
854         }
855
856         if (IS_GETLK(cmd))
857                 ret = do_getlk(filp, cmd, fl, is_local);
858         else if (fl->fl_type == F_UNLCK)
859                 ret = do_unlk(filp, cmd, fl, is_local);
860         else
861                 ret = do_setlk(filp, cmd, fl, is_local);
862 out_err:
863         return ret;
864 }
865 EXPORT_SYMBOL_GPL(nfs_lock);
866
867 /*
868  * Lock a (portion of) a file
869  */
870 int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
871 {
872         struct inode *inode = filp->f_mapping->host;
873         int is_local = 0;
874
875         dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n",
876                         filp, fl->fl_type, fl->fl_flags);
877
878         if (!(fl->fl_flags & FL_FLOCK))
879                 return -ENOLCK;
880
881         /*
882          * The NFSv4 protocol doesn't support LOCK_MAND, which is not part of
883          * any standard. In principle we might be able to support LOCK_MAND
884          * on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the
885          * NFS code is not set up for it.
886          */
887         if (fl->fl_type & LOCK_MAND)
888                 return -EINVAL;
889
890         if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
891                 is_local = 1;
892
893         /* We're simulating flock() locks using posix locks on the server */
894         if (fl->fl_type == F_UNLCK)
895                 return do_unlk(filp, cmd, fl, is_local);
896         return do_setlk(filp, cmd, fl, is_local);
897 }
898 EXPORT_SYMBOL_GPL(nfs_flock);
899
900 const struct file_operations nfs_file_operations = {
901         .llseek         = nfs_file_llseek,
902         .read_iter      = nfs_file_read,
903         .write_iter     = nfs_file_write,
904         .mmap           = nfs_file_mmap,
905         .open           = nfs_file_open,
906         .flush          = nfs_file_flush,
907         .release        = nfs_file_release,
908         .fsync          = nfs_file_fsync,
909         .lock           = nfs_lock,
910         .flock          = nfs_flock,
911         .splice_read    = nfs_file_splice_read,
912         .splice_write   = iter_file_splice_write,
913         .check_flags    = nfs_check_flags,
914         .setlease       = simple_nosetlease,
915 };
916 EXPORT_SYMBOL_GPL(nfs_file_operations);