4 * Copyright (C) 1992 Rick Sladkey
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.
12 * Expire cache on write to a file by Wai S Kok (Oct 1994).
14 * Total rewrite of read side for new NFS buffer cache.. Linus.
16 * nfs regular file handling functions
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>
28 #include <linux/pagemap.h>
29 #include <linux/aio.h>
30 #include <linux/gfp.h>
31 #include <linux/swap.h>
33 #include <asm/uaccess.h>
35 #include "delegation.h"
40 #define NFSDBG_FACILITY NFSDBG_FILE
42 static const struct vm_operations_struct nfs_file_vm_ops
;
44 /* Hack for future NFS swap support */
46 # define IS_SWAPFILE(inode) (0)
49 int nfs_check_flags(int flags
)
51 if ((flags
& (O_APPEND
| O_DIRECT
)) == (O_APPEND
| O_DIRECT
))
56 EXPORT_SYMBOL_GPL(nfs_check_flags
);
62 nfs_file_open(struct inode
*inode
, struct file
*filp
)
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
);
70 nfs_inc_stats(inode
, NFSIOS_VFSOPEN
);
71 res
= nfs_check_flags(filp
->f_flags
);
75 res
= nfs_open(inode
, filp
);
80 nfs_file_release(struct inode
*inode
, struct file
*filp
)
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
);
86 nfs_inc_stats(inode
, NFSIOS_VFSRELEASE
);
87 return nfs_release(inode
, filp
);
89 EXPORT_SYMBOL_GPL(nfs_file_release
);
92 * nfs_revalidate_size - Revalidate the file size
93 * @inode - pointer to inode struct
94 * @file - pointer to struct file
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).
102 static int nfs_revalidate_file_size(struct inode
*inode
, struct file
*filp
)
104 struct nfs_server
*server
= NFS_SERVER(inode
);
105 struct nfs_inode
*nfsi
= NFS_I(inode
);
107 if (nfs_have_delegated_attributes(inode
))
110 if (filp
->f_flags
& O_DIRECT
)
112 if (nfsi
->cache_validity
& NFS_INO_REVAL_PAGECACHE
)
114 if (nfs_attribute_timeout(inode
))
119 return __nfs_revalidate_inode(server
, inode
);
122 loff_t
nfs_file_llseek(struct file
*filp
, loff_t offset
, int origin
)
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
,
130 * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
131 * the cached file length
133 if (origin
!= SEEK_SET
&& origin
!= SEEK_CUR
) {
134 struct inode
*inode
= filp
->f_mapping
->host
;
136 int retval
= nfs_revalidate_file_size(inode
, filp
);
138 return (loff_t
)retval
;
141 return generic_file_llseek(filp
, offset
, origin
);
143 EXPORT_SYMBOL_GPL(nfs_file_llseek
);
146 * Flush all dirty pages, and check for write errors.
149 nfs_file_flush(struct file
*file
, fl_owner_t id
)
151 struct dentry
*dentry
= file
->f_path
.dentry
;
152 struct inode
*inode
= dentry
->d_inode
;
154 dprintk("NFS: flush(%s/%s)\n",
155 dentry
->d_parent
->d_name
.name
,
156 dentry
->d_name
.name
);
158 nfs_inc_stats(inode
, NFSIOS_VFSFLUSH
);
159 if ((file
->f_mode
& FMODE_WRITE
) == 0)
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).
166 if (NFS_PROTO(inode
)->have_delegation(inode
, FMODE_WRITE
))
167 return filemap_fdatawrite(file
->f_mapping
);
169 /* Flush writes to the server and return any errors */
170 return vfs_fsync(file
, 0);
172 EXPORT_SYMBOL_GPL(nfs_file_flush
);
175 nfs_file_read(struct kiocb
*iocb
, const struct iovec
*iov
,
176 unsigned long nr_segs
, loff_t pos
)
178 struct dentry
* dentry
= iocb
->ki_filp
->f_path
.dentry
;
179 struct inode
* inode
= dentry
->d_inode
;
182 if (iocb
->ki_filp
->f_flags
& O_DIRECT
)
183 return nfs_file_direct_read(iocb
, iov
, nr_segs
, pos
, true);
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
);
189 result
= nfs_revalidate_mapping(inode
, iocb
->ki_filp
->f_mapping
);
191 result
= generic_file_aio_read(iocb
, iov
, nr_segs
, pos
);
193 nfs_add_stats(inode
, NFSIOS_NORMALREADBYTES
, result
);
197 EXPORT_SYMBOL_GPL(nfs_file_read
);
200 nfs_file_splice_read(struct file
*filp
, loff_t
*ppos
,
201 struct pipe_inode_info
*pipe
, size_t count
,
204 struct dentry
*dentry
= filp
->f_path
.dentry
;
205 struct inode
*inode
= dentry
->d_inode
;
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
);
212 res
= nfs_revalidate_mapping(inode
, filp
->f_mapping
);
214 res
= generic_file_splice_read(filp
, ppos
, pipe
, count
, flags
);
216 nfs_add_stats(inode
, NFSIOS_NORMALREADBYTES
, res
);
220 EXPORT_SYMBOL_GPL(nfs_file_splice_read
);
223 nfs_file_mmap(struct file
* file
, struct vm_area_struct
* vma
)
225 struct dentry
*dentry
= file
->f_path
.dentry
;
226 struct inode
*inode
= dentry
->d_inode
;
229 dprintk("NFS: mmap(%s/%s)\n",
230 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
232 /* Note: generic_file_mmap() returns ENOSYS on nommu systems
233 * so we call that before revalidating the mapping
235 status
= generic_file_mmap(file
, vma
);
237 vma
->vm_ops
= &nfs_file_vm_ops
;
238 status
= nfs_revalidate_mapping(inode
, file
->f_mapping
);
242 EXPORT_SYMBOL_GPL(nfs_file_mmap
);
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.
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.
257 nfs_file_fsync_commit(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
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
, status
;
265 dprintk("NFS: fsync file(%s/%s) datasync %d\n",
266 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
,
269 nfs_inc_stats(inode
, NFSIOS_VFSFSYNC
);
270 have_error
= test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE
, &ctx
->flags
);
271 status
= nfs_commit_inode(inode
, FLUSH_SYNC
);
272 if (status
>= 0 && ret
< 0)
274 have_error
|= test_bit(NFS_CONTEXT_ERROR_WRITE
, &ctx
->flags
);
276 ret
= xchg(&ctx
->error
, 0);
277 if (!ret
&& status
< 0)
281 EXPORT_SYMBOL_GPL(nfs_file_fsync_commit
);
284 nfs_file_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
287 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
289 ret
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
292 mutex_lock(&inode
->i_mutex
);
293 ret
= nfs_file_fsync_commit(file
, start
, end
, datasync
);
294 mutex_unlock(&inode
->i_mutex
);
300 * Decide whether a read/modify/write cycle may be more efficient
301 * then a modify/write/read cycle when writing to a page in the
304 * The modify/write/read cycle may occur if a page is read before
305 * being completely filled by the writer. In this situation, the
306 * page must be completely written to stable storage on the server
307 * before it can be refilled by reading in the page from the server.
308 * This can lead to expensive, small, FILE_SYNC mode writes being
311 * It may be more efficient to read the page first if the file is
312 * open for reading in addition to writing, the page is not marked
313 * as Uptodate, it is not dirty or waiting to be committed,
314 * indicating that it was previously allocated and then modified,
315 * that there were valid bytes of data in that range of the file,
316 * and that the new data won't completely replace the old data in
317 * that range of the file.
319 static int nfs_want_read_modify_write(struct file
*file
, struct page
*page
,
320 loff_t pos
, unsigned len
)
322 unsigned int pglen
= nfs_page_length(page
);
323 unsigned int offset
= pos
& (PAGE_CACHE_SIZE
- 1);
324 unsigned int end
= offset
+ len
;
326 if ((file
->f_mode
& FMODE_READ
) && /* open for read? */
327 !PageUptodate(page
) && /* Uptodate? */
328 !PagePrivate(page
) && /* i/o request already? */
329 pglen
&& /* valid bytes of file? */
330 (end
< pglen
|| offset
)) /* replace all valid bytes? */
336 * This does the "real" work of the write. We must allocate and lock the
337 * page to be sent back to the generic routine, which then copies the
338 * data from user space.
340 * If the writer ends up delaying the write, the writer needs to
341 * increment the page use counts until he is done with the page.
343 static int nfs_write_begin(struct file
*file
, struct address_space
*mapping
,
344 loff_t pos
, unsigned len
, unsigned flags
,
345 struct page
**pagep
, void **fsdata
)
348 pgoff_t index
= pos
>> PAGE_CACHE_SHIFT
;
352 dfprintk(PAGECACHE
, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n",
353 file
->f_path
.dentry
->d_parent
->d_name
.name
,
354 file
->f_path
.dentry
->d_name
.name
,
355 mapping
->host
->i_ino
, len
, (long long) pos
);
359 * Prevent starvation issues if someone is doing a consistency
362 ret
= wait_on_bit(&NFS_I(mapping
->host
)->flags
, NFS_INO_FLUSHING
,
363 nfs_wait_bit_killable
, TASK_KILLABLE
);
367 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
372 ret
= nfs_flush_incompatible(file
, page
);
375 page_cache_release(page
);
376 } else if (!once_thru
&&
377 nfs_want_read_modify_write(file
, page
, pos
, len
)) {
379 ret
= nfs_readpage(file
, page
);
380 page_cache_release(page
);
387 static int nfs_write_end(struct file
*file
, struct address_space
*mapping
,
388 loff_t pos
, unsigned len
, unsigned copied
,
389 struct page
*page
, void *fsdata
)
391 unsigned offset
= pos
& (PAGE_CACHE_SIZE
- 1);
394 dfprintk(PAGECACHE
, "NFS: write_end(%s/%s(%ld), %u@%lld)\n",
395 file
->f_path
.dentry
->d_parent
->d_name
.name
,
396 file
->f_path
.dentry
->d_name
.name
,
397 mapping
->host
->i_ino
, len
, (long long) pos
);
400 * Zero any uninitialised parts of the page, and then mark the page
401 * as up to date if it turns out that we're extending the file.
403 if (!PageUptodate(page
)) {
404 unsigned pglen
= nfs_page_length(page
);
405 unsigned end
= offset
+ len
;
408 zero_user_segments(page
, 0, offset
,
409 end
, PAGE_CACHE_SIZE
);
410 SetPageUptodate(page
);
411 } else if (end
>= pglen
) {
412 zero_user_segment(page
, end
, PAGE_CACHE_SIZE
);
414 SetPageUptodate(page
);
416 zero_user_segment(page
, pglen
, PAGE_CACHE_SIZE
);
419 status
= nfs_updatepage(file
, page
, offset
, copied
);
422 page_cache_release(page
);
426 NFS_I(mapping
->host
)->write_io
+= copied
;
431 * Partially or wholly invalidate a page
432 * - Release the private state associated with a page if undergoing complete
434 * - Called if either PG_private or PG_fscache is set on the page
435 * - Caller holds page lock
437 static void nfs_invalidate_page(struct page
*page
, unsigned long offset
)
439 dfprintk(PAGECACHE
, "NFS: invalidate_page(%p, %lu)\n", page
, offset
);
443 /* Cancel any unstarted writes on this page */
444 nfs_wb_page_cancel(page_file_mapping(page
)->host
, page
);
446 nfs_fscache_invalidate_page(page
, page
->mapping
->host
);
450 * Attempt to release the private state associated with a page
451 * - Called if either PG_private or PG_fscache is set on the page
452 * - Caller holds page lock
453 * - Return true (may release page) or false (may not)
455 static int nfs_release_page(struct page
*page
, gfp_t gfp
)
457 struct address_space
*mapping
= page
->mapping
;
459 dfprintk(PAGECACHE
, "NFS: release_page(%p)\n", page
);
461 /* Only do I/O if gfp is a superset of GFP_KERNEL, and we're not
462 * doing this memory reclaim for a fs-related allocation.
464 if (mapping
&& (gfp
& GFP_KERNEL
) == GFP_KERNEL
&&
465 !(current
->flags
& PF_FSTRANS
)) {
466 int how
= FLUSH_SYNC
;
468 /* Don't let kswapd deadlock waiting for OOM RPC calls */
469 if (current_is_kswapd())
471 nfs_commit_inode(mapping
->host
, how
);
473 /* If PagePrivate() is set, then the page is not freeable */
474 if (PagePrivate(page
))
476 return nfs_fscache_release_page(page
, gfp
);
480 * Attempt to clear the private state associated with a page when an error
481 * occurs that requires the cached contents of an inode to be written back or
483 * - Called if either PG_private or fscache is set on the page
484 * - Caller holds page lock
485 * - Return 0 if successful, -error otherwise
487 static int nfs_launder_page(struct page
*page
)
489 struct inode
*inode
= page_file_mapping(page
)->host
;
490 struct nfs_inode
*nfsi
= NFS_I(inode
);
492 dfprintk(PAGECACHE
, "NFS: launder_page(%ld, %llu)\n",
493 inode
->i_ino
, (long long)page_offset(page
));
495 nfs_fscache_wait_on_page_write(nfsi
, page
);
496 return nfs_wb_page(inode
, page
);
499 #ifdef CONFIG_NFS_SWAP
500 static int nfs_swap_activate(struct swap_info_struct
*sis
, struct file
*file
,
504 return xs_swapper(NFS_CLIENT(file
->f_mapping
->host
)->cl_xprt
, 1);
507 static void nfs_swap_deactivate(struct file
*file
)
509 xs_swapper(NFS_CLIENT(file
->f_mapping
->host
)->cl_xprt
, 0);
513 const struct address_space_operations nfs_file_aops
= {
514 .readpage
= nfs_readpage
,
515 .readpages
= nfs_readpages
,
516 .set_page_dirty
= __set_page_dirty_nobuffers
,
517 .writepage
= nfs_writepage
,
518 .writepages
= nfs_writepages
,
519 .write_begin
= nfs_write_begin
,
520 .write_end
= nfs_write_end
,
521 .invalidatepage
= nfs_invalidate_page
,
522 .releasepage
= nfs_release_page
,
523 .direct_IO
= nfs_direct_IO
,
524 .migratepage
= nfs_migrate_page
,
525 .launder_page
= nfs_launder_page
,
526 .error_remove_page
= generic_error_remove_page
,
527 #ifdef CONFIG_NFS_SWAP
528 .swap_activate
= nfs_swap_activate
,
529 .swap_deactivate
= nfs_swap_deactivate
,
534 * Notification that a PTE pointing to an NFS page is about to be made
535 * writable, implying that someone is about to modify the page through a
536 * shared-writable mapping
538 static int nfs_vm_page_mkwrite(struct vm_area_struct
*vma
, struct vm_fault
*vmf
)
540 struct page
*page
= vmf
->page
;
541 struct file
*filp
= vma
->vm_file
;
542 struct dentry
*dentry
= filp
->f_path
.dentry
;
544 int ret
= VM_FAULT_NOPAGE
;
545 struct address_space
*mapping
;
547 dfprintk(PAGECACHE
, "NFS: vm_page_mkwrite(%s/%s(%ld), offset %lld)\n",
548 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
,
549 filp
->f_mapping
->host
->i_ino
,
550 (long long)page_offset(page
));
552 /* make sure the cache has finished storing the page */
553 nfs_fscache_wait_on_page_write(NFS_I(dentry
->d_inode
), page
);
556 mapping
= page_file_mapping(page
);
557 if (mapping
!= dentry
->d_inode
->i_mapping
)
560 wait_on_page_writeback(page
);
562 pagelen
= nfs_page_length(page
);
566 ret
= VM_FAULT_LOCKED
;
567 if (nfs_flush_incompatible(filp
, page
) == 0 &&
568 nfs_updatepage(filp
, page
, 0, pagelen
) == 0)
571 ret
= VM_FAULT_SIGBUS
;
578 static const struct vm_operations_struct nfs_file_vm_ops
= {
579 .fault
= filemap_fault
,
580 .page_mkwrite
= nfs_vm_page_mkwrite
,
583 static int nfs_need_sync_write(struct file
*filp
, struct inode
*inode
)
585 struct nfs_open_context
*ctx
;
587 if (IS_SYNC(inode
) || (filp
->f_flags
& O_DSYNC
))
589 ctx
= nfs_file_open_context(filp
);
590 if (test_bit(NFS_CONTEXT_ERROR_WRITE
, &ctx
->flags
))
595 ssize_t
nfs_file_write(struct kiocb
*iocb
, const struct iovec
*iov
,
596 unsigned long nr_segs
, loff_t pos
)
598 struct dentry
* dentry
= iocb
->ki_filp
->f_path
.dentry
;
599 struct inode
* inode
= dentry
->d_inode
;
600 unsigned long written
= 0;
602 size_t count
= iov_length(iov
, nr_segs
);
604 if (iocb
->ki_filp
->f_flags
& O_DIRECT
)
605 return nfs_file_direct_write(iocb
, iov
, nr_segs
, pos
, true);
607 dprintk("NFS: write(%s/%s, %lu@%Ld)\n",
608 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
,
609 (unsigned long) count
, (long long) pos
);
612 if (IS_SWAPFILE(inode
))
615 * O_APPEND implies that we must revalidate the file length.
617 if (iocb
->ki_filp
->f_flags
& O_APPEND
) {
618 result
= nfs_revalidate_file_size(inode
, iocb
->ki_filp
);
627 result
= generic_file_aio_write(iocb
, iov
, nr_segs
, pos
);
631 /* Return error values for O_DSYNC and IS_SYNC() */
632 if (result
>= 0 && nfs_need_sync_write(iocb
->ki_filp
, inode
)) {
633 int err
= vfs_fsync(iocb
->ki_filp
, 0);
638 nfs_add_stats(inode
, NFSIOS_NORMALWRITTENBYTES
, written
);
643 printk(KERN_INFO
"NFS: attempt to write to active swap file!\n");
646 EXPORT_SYMBOL_GPL(nfs_file_write
);
648 ssize_t
nfs_file_splice_write(struct pipe_inode_info
*pipe
,
649 struct file
*filp
, loff_t
*ppos
,
650 size_t count
, unsigned int flags
)
652 struct dentry
*dentry
= filp
->f_path
.dentry
;
653 struct inode
*inode
= dentry
->d_inode
;
654 unsigned long written
= 0;
657 dprintk("NFS splice_write(%s/%s, %lu@%llu)\n",
658 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
,
659 (unsigned long) count
, (unsigned long long) *ppos
);
662 * The combination of splice and an O_APPEND destination is disallowed.
665 ret
= generic_file_splice_write(pipe
, filp
, ppos
, count
, flags
);
669 if (ret
>= 0 && nfs_need_sync_write(filp
, inode
)) {
670 int err
= vfs_fsync(filp
, 0);
675 nfs_add_stats(inode
, NFSIOS_NORMALWRITTENBYTES
, written
);
678 EXPORT_SYMBOL_GPL(nfs_file_splice_write
);
681 do_getlk(struct file
*filp
, int cmd
, struct file_lock
*fl
, int is_local
)
683 struct inode
*inode
= filp
->f_mapping
->host
;
685 unsigned int saved_type
= fl
->fl_type
;
687 /* Try local locking first */
688 posix_test_lock(filp
, fl
);
689 if (fl
->fl_type
!= F_UNLCK
) {
690 /* found a conflict */
693 fl
->fl_type
= saved_type
;
695 if (NFS_PROTO(inode
)->have_delegation(inode
, FMODE_READ
))
701 status
= NFS_PROTO(inode
)->lock(filp
, cmd
, fl
);
705 fl
->fl_type
= F_UNLCK
;
709 static int do_vfs_lock(struct file
*file
, struct file_lock
*fl
)
712 switch (fl
->fl_flags
& (FL_POSIX
|FL_FLOCK
)) {
714 res
= posix_lock_file_wait(file
, fl
);
717 res
= flock_lock_file_wait(file
, fl
);
726 do_unlk(struct file
*filp
, int cmd
, struct file_lock
*fl
, int is_local
)
728 struct inode
*inode
= filp
->f_mapping
->host
;
732 * Flush all pending writes before doing anything
735 nfs_sync_mapping(filp
->f_mapping
);
737 /* NOTE: special case
738 * If we're signalled while cleaning up locks on process exit, we
739 * still need to complete the unlock.
742 * Use local locking if mounted with "-onolock" or with appropriate
746 status
= NFS_PROTO(inode
)->lock(filp
, cmd
, fl
);
748 status
= do_vfs_lock(filp
, fl
);
753 is_time_granular(struct timespec
*ts
) {
754 return ((ts
->tv_sec
== 0) && (ts
->tv_nsec
<= 1000));
758 do_setlk(struct file
*filp
, int cmd
, struct file_lock
*fl
, int is_local
)
760 struct inode
*inode
= filp
->f_mapping
->host
;
764 * Flush all pending writes before doing anything
767 status
= nfs_sync_mapping(filp
->f_mapping
);
772 * Use local locking if mounted with "-onolock" or with appropriate
776 status
= NFS_PROTO(inode
)->lock(filp
, cmd
, fl
);
778 status
= do_vfs_lock(filp
, fl
);
783 * Revalidate the cache if the server has time stamps granular
784 * enough to detect subsecond changes. Otherwise, clear the
785 * cache to prevent missing any changes.
787 * This makes locking act as a cache coherency point.
789 nfs_sync_mapping(filp
->f_mapping
);
790 if (!NFS_PROTO(inode
)->have_delegation(inode
, FMODE_READ
)) {
791 if (is_time_granular(&NFS_SERVER(inode
)->time_delta
))
792 __nfs_revalidate_inode(NFS_SERVER(inode
), inode
);
794 nfs_zap_caches(inode
);
801 * Lock a (portion of) a file
803 int nfs_lock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
805 struct inode
*inode
= filp
->f_mapping
->host
;
809 dprintk("NFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n",
810 filp
->f_path
.dentry
->d_parent
->d_name
.name
,
811 filp
->f_path
.dentry
->d_name
.name
,
812 fl
->fl_type
, fl
->fl_flags
,
813 (long long)fl
->fl_start
, (long long)fl
->fl_end
);
815 nfs_inc_stats(inode
, NFSIOS_VFSLOCK
);
817 /* No mandatory locks over NFS */
818 if (__mandatory_lock(inode
) && fl
->fl_type
!= F_UNLCK
)
821 if (NFS_SERVER(inode
)->flags
& NFS_MOUNT_LOCAL_FCNTL
)
824 if (NFS_PROTO(inode
)->lock_check_bounds
!= NULL
) {
825 ret
= NFS_PROTO(inode
)->lock_check_bounds(fl
);
831 ret
= do_getlk(filp
, cmd
, fl
, is_local
);
832 else if (fl
->fl_type
== F_UNLCK
)
833 ret
= do_unlk(filp
, cmd
, fl
, is_local
);
835 ret
= do_setlk(filp
, cmd
, fl
, is_local
);
839 EXPORT_SYMBOL_GPL(nfs_lock
);
842 * Lock a (portion of) a file
844 int nfs_flock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
846 struct inode
*inode
= filp
->f_mapping
->host
;
849 dprintk("NFS: flock(%s/%s, t=%x, fl=%x)\n",
850 filp
->f_path
.dentry
->d_parent
->d_name
.name
,
851 filp
->f_path
.dentry
->d_name
.name
,
852 fl
->fl_type
, fl
->fl_flags
);
854 if (!(fl
->fl_flags
& FL_FLOCK
))
858 * The NFSv4 protocol doesn't support LOCK_MAND, which is not part of
859 * any standard. In principle we might be able to support LOCK_MAND
860 * on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the
861 * NFS code is not set up for it.
863 if (fl
->fl_type
& LOCK_MAND
)
866 if (NFS_SERVER(inode
)->flags
& NFS_MOUNT_LOCAL_FLOCK
)
869 /* We're simulating flock() locks using posix locks on the server */
870 fl
->fl_owner
= (fl_owner_t
)filp
;
872 fl
->fl_end
= OFFSET_MAX
;
874 if (fl
->fl_type
== F_UNLCK
)
875 return do_unlk(filp
, cmd
, fl
, is_local
);
876 return do_setlk(filp
, cmd
, fl
, is_local
);
878 EXPORT_SYMBOL_GPL(nfs_flock
);
881 * There is no protocol support for leases, so we have no way to implement
882 * them correctly in the face of opens by other clients.
884 int nfs_setlease(struct file
*file
, long arg
, struct file_lock
**fl
)
886 dprintk("NFS: setlease(%s/%s, arg=%ld)\n",
887 file
->f_path
.dentry
->d_parent
->d_name
.name
,
888 file
->f_path
.dentry
->d_name
.name
, arg
);
891 EXPORT_SYMBOL_GPL(nfs_setlease
);
893 const struct file_operations nfs_file_operations
= {
894 .llseek
= nfs_file_llseek
,
895 .read
= do_sync_read
,
896 .write
= do_sync_write
,
897 .aio_read
= nfs_file_read
,
898 .aio_write
= nfs_file_write
,
899 .mmap
= nfs_file_mmap
,
900 .open
= nfs_file_open
,
901 .flush
= nfs_file_flush
,
902 .release
= nfs_file_release
,
903 .fsync
= nfs_file_fsync
,
906 .splice_read
= nfs_file_splice_read
,
907 .splice_write
= nfs_file_splice_write
,
908 .check_flags
= nfs_check_flags
,
909 .setlease
= nfs_setlease
,
911 EXPORT_SYMBOL_GPL(nfs_file_operations
);