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