NFS: Fix a delegation callback race
[linux-3.10.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/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
49 int nfs_check_flags(int flags)
50 {
51         if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
52                 return -EINVAL;
53
54         return 0;
55 }
56 EXPORT_SYMBOL_GPL(nfs_check_flags);
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 }
89 EXPORT_SYMBOL_GPL(nfs_file_release);
90
91 /**
92  * nfs_revalidate_size - Revalidate the file size
93  * @inode - pointer to inode struct
94  * @file - pointer to struct file
95  *
96  * Revalidates the file length. This is basically a wrapper around
97  * nfs_revalidate_inode() that takes into account the fact that we may
98  * have cached writes (in which case we don't care about the server's
99  * idea of what the file length is), or O_DIRECT (in which case we
100  * shouldn't trust the cache).
101  */
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;
112         if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
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 whence)
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, whence);
128
129         /*
130          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
131          * the cached file length
132          */
133         if (whence != SEEK_SET && whence != 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, whence);
142 }
143 EXPORT_SYMBOL_GPL(nfs_file_llseek);
144
145 /*
146  * Flush all dirty pages, and check for write errors.
147  */
148 int
149 nfs_file_flush(struct file *file, fl_owner_t id)
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 }
172 EXPORT_SYMBOL_GPL(nfs_file_flush);
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 }
197 EXPORT_SYMBOL_GPL(nfs_file_read);
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 }
220 EXPORT_SYMBOL_GPL(nfs_file_splice_read);
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 }
242 EXPORT_SYMBOL_GPL(nfs_file_mmap);
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);
270         do_resend = test_and_clear_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
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 }
289 EXPORT_SYMBOL_GPL(nfs_file_fsync_commit);
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_inode(file);
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,
380                         nfs_wait_bit_killable, TASK_KILLABLE);
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
530 const struct address_space_operations nfs_file_aops = {
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);
608         if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags))
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 }
664 EXPORT_SYMBOL_GPL(nfs_file_write);
665
666 ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
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 }
696 EXPORT_SYMBOL_GPL(nfs_file_splice_write);
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         struct nfs_lock_context *l_ctx;
748         int status;
749
750         /*
751          * Flush all pending writes before doing anything
752          * with locks..
753          */
754         nfs_sync_mapping(filp->f_mapping);
755
756         l_ctx = nfs_get_lock_context(nfs_file_open_context(filp));
757         if (!IS_ERR(l_ctx)) {
758                 status = nfs_iocounter_wait(&l_ctx->io_count);
759                 nfs_put_lock_context(l_ctx);
760                 if (status < 0)
761                         return status;
762         }
763
764         /* NOTE: special case
765          *      If we're signalled while cleaning up locks on process exit, we
766          *      still need to complete the unlock.
767          */
768         /*
769          * Use local locking if mounted with "-onolock" or with appropriate
770          * "-olocal_lock="
771          */
772         if (!is_local)
773                 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
774         else
775                 status = do_vfs_lock(filp, fl);
776         return status;
777 }
778
779 static int
780 is_time_granular(struct timespec *ts) {
781         return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
782 }
783
784 static int
785 do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
786 {
787         struct inode *inode = filp->f_mapping->host;
788         int status;
789
790         /*
791          * Flush all pending writes before doing anything
792          * with locks..
793          */
794         status = nfs_sync_mapping(filp->f_mapping);
795         if (status != 0)
796                 goto out;
797
798         /*
799          * Use local locking if mounted with "-onolock" or with appropriate
800          * "-olocal_lock="
801          */
802         if (!is_local)
803                 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
804         else
805                 status = do_vfs_lock(filp, fl);
806         if (status < 0)
807                 goto out;
808
809         /*
810          * Revalidate the cache if the server has time stamps granular
811          * enough to detect subsecond changes.  Otherwise, clear the
812          * cache to prevent missing any changes.
813          *
814          * This makes locking act as a cache coherency point.
815          */
816         nfs_sync_mapping(filp->f_mapping);
817         if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) {
818                 if (is_time_granular(&NFS_SERVER(inode)->time_delta))
819                         __nfs_revalidate_inode(NFS_SERVER(inode), inode);
820                 else
821                         nfs_zap_caches(inode);
822         }
823 out:
824         return status;
825 }
826
827 /*
828  * Lock a (portion of) a file
829  */
830 int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
831 {
832         struct inode *inode = filp->f_mapping->host;
833         int ret = -ENOLCK;
834         int is_local = 0;
835
836         dprintk("NFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n",
837                         filp->f_path.dentry->d_parent->d_name.name,
838                         filp->f_path.dentry->d_name.name,
839                         fl->fl_type, fl->fl_flags,
840                         (long long)fl->fl_start, (long long)fl->fl_end);
841
842         nfs_inc_stats(inode, NFSIOS_VFSLOCK);
843
844         /* No mandatory locks over NFS */
845         if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
846                 goto out_err;
847
848         if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
849                 is_local = 1;
850
851         if (NFS_PROTO(inode)->lock_check_bounds != NULL) {
852                 ret = NFS_PROTO(inode)->lock_check_bounds(fl);
853                 if (ret < 0)
854                         goto out_err;
855         }
856
857         if (IS_GETLK(cmd))
858                 ret = do_getlk(filp, cmd, fl, is_local);
859         else if (fl->fl_type == F_UNLCK)
860                 ret = do_unlk(filp, cmd, fl, is_local);
861         else
862                 ret = do_setlk(filp, cmd, fl, is_local);
863 out_err:
864         return ret;
865 }
866 EXPORT_SYMBOL_GPL(nfs_lock);
867
868 /*
869  * Lock a (portion of) a file
870  */
871 int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
872 {
873         struct inode *inode = filp->f_mapping->host;
874         int is_local = 0;
875
876         dprintk("NFS: flock(%s/%s, t=%x, fl=%x)\n",
877                         filp->f_path.dentry->d_parent->d_name.name,
878                         filp->f_path.dentry->d_name.name,
879                         fl->fl_type, fl->fl_flags);
880
881         if (!(fl->fl_flags & FL_FLOCK))
882                 return -ENOLCK;
883
884         /*
885          * The NFSv4 protocol doesn't support LOCK_MAND, which is not part of
886          * any standard. In principle we might be able to support LOCK_MAND
887          * on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the
888          * NFS code is not set up for it.
889          */
890         if (fl->fl_type & LOCK_MAND)
891                 return -EINVAL;
892
893         if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
894                 is_local = 1;
895
896         /* We're simulating flock() locks using posix locks on the server */
897         fl->fl_owner = (fl_owner_t)filp;
898         fl->fl_start = 0;
899         fl->fl_end = OFFSET_MAX;
900
901         if (fl->fl_type == F_UNLCK)
902                 return do_unlk(filp, cmd, fl, is_local);
903         return do_setlk(filp, cmd, fl, is_local);
904 }
905 EXPORT_SYMBOL_GPL(nfs_flock);
906
907 /*
908  * There is no protocol support for leases, so we have no way to implement
909  * them correctly in the face of opens by other clients.
910  */
911 int nfs_setlease(struct file *file, long arg, struct file_lock **fl)
912 {
913         dprintk("NFS: setlease(%s/%s, arg=%ld)\n",
914                         file->f_path.dentry->d_parent->d_name.name,
915                         file->f_path.dentry->d_name.name, arg);
916         return -EINVAL;
917 }
918 EXPORT_SYMBOL_GPL(nfs_setlease);
919
920 const struct file_operations nfs_file_operations = {
921         .llseek         = nfs_file_llseek,
922         .read           = do_sync_read,
923         .write          = do_sync_write,
924         .aio_read       = nfs_file_read,
925         .aio_write      = nfs_file_write,
926         .mmap           = nfs_file_mmap,
927         .open           = nfs_file_open,
928         .flush          = nfs_file_flush,
929         .release        = nfs_file_release,
930         .fsync          = nfs_file_fsync,
931         .lock           = nfs_lock,
932         .flock          = nfs_flock,
933         .splice_read    = nfs_file_splice_read,
934         .splice_write   = nfs_file_splice_write,
935         .check_flags    = nfs_check_flags,
936         .setlease       = nfs_setlease,
937 };
938 EXPORT_SYMBOL_GPL(nfs_file_operations);