1 // SPDX-License-Identifier: GPL-2.0-only
5 * Copyright (C) 1992 Rick Sladkey
7 * Changes Copyright (C) 1994 by Florian La Roche
8 * - Do not copy data too often around in the kernel.
9 * - In nfs_file_read the return value of kmalloc wasn't checked.
10 * - Put in a better version of read look-ahead buffering. Original idea
11 * and implementation by Wai S Kok elekokws@ee.nus.sg.
13 * Expire cache on write to a file by Wai S Kok (Oct 1994).
15 * Total rewrite of read side for new NFS buffer cache.. Linus.
17 * nfs regular file handling functions
20 #include <linux/module.h>
21 #include <linux/time.h>
22 #include <linux/kernel.h>
23 #include <linux/errno.h>
24 #include <linux/fcntl.h>
25 #include <linux/stat.h>
26 #include <linux/nfs_fs.h>
27 #include <linux/nfs_mount.h>
29 #include <linux/pagemap.h>
30 #include <linux/gfp.h>
31 #include <linux/swap.h>
33 #include <linux/uaccess.h>
35 #include "delegation.h"
43 #define NFSDBG_FACILITY NFSDBG_FILE
45 static const struct vm_operations_struct nfs_file_vm_ops
;
47 /* Hack for future NFS swap support */
49 # define IS_SWAPFILE(inode) (0)
52 int nfs_check_flags(int flags
)
54 if ((flags
& (O_APPEND
| O_DIRECT
)) == (O_APPEND
| O_DIRECT
))
59 EXPORT_SYMBOL_GPL(nfs_check_flags
);
65 nfs_file_open(struct inode
*inode
, struct file
*filp
)
69 dprintk("NFS: open file(%pD2)\n", filp
);
71 nfs_inc_stats(inode
, NFSIOS_VFSOPEN
);
72 res
= nfs_check_flags(filp
->f_flags
);
76 res
= nfs_open(inode
, filp
);
81 nfs_file_release(struct inode
*inode
, struct file
*filp
)
83 dprintk("NFS: release(%pD2)\n", filp
);
85 nfs_inc_stats(inode
, NFSIOS_VFSRELEASE
);
86 nfs_file_clear_open_context(filp
);
89 EXPORT_SYMBOL_GPL(nfs_file_release
);
92 * nfs_revalidate_size - Revalidate the file size
93 * @inode: pointer to inode struct
94 * @filp: 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
);
106 if (filp
->f_flags
& O_DIRECT
)
108 if (nfs_check_cache_invalid(inode
, NFS_INO_REVAL_PAGECACHE
))
112 return __nfs_revalidate_inode(server
, inode
);
115 loff_t
nfs_file_llseek(struct file
*filp
, loff_t offset
, int whence
)
117 dprintk("NFS: llseek file(%pD2, %lld, %d)\n",
118 filp
, offset
, whence
);
121 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
122 * the cached file length
124 if (whence
!= SEEK_SET
&& whence
!= SEEK_CUR
) {
125 struct inode
*inode
= filp
->f_mapping
->host
;
127 int retval
= nfs_revalidate_file_size(inode
, filp
);
129 return (loff_t
)retval
;
132 return generic_file_llseek(filp
, offset
, whence
);
134 EXPORT_SYMBOL_GPL(nfs_file_llseek
);
137 * Flush all dirty pages, and check for write errors.
140 nfs_file_flush(struct file
*file
, fl_owner_t id
)
142 struct inode
*inode
= file_inode(file
);
144 dprintk("NFS: flush(%pD2)\n", file
);
146 nfs_inc_stats(inode
, NFSIOS_VFSFLUSH
);
147 if ((file
->f_mode
& FMODE_WRITE
) == 0)
150 /* Flush writes to the server and return any errors */
151 return nfs_wb_all(inode
);
155 nfs_file_read(struct kiocb
*iocb
, struct iov_iter
*to
)
157 struct inode
*inode
= file_inode(iocb
->ki_filp
);
160 if (iocb
->ki_flags
& IOCB_DIRECT
)
161 return nfs_file_direct_read(iocb
, to
);
163 dprintk("NFS: read(%pD2, %zu@%lu)\n",
165 iov_iter_count(to
), (unsigned long) iocb
->ki_pos
);
167 nfs_start_io_read(inode
);
168 result
= nfs_revalidate_mapping(inode
, iocb
->ki_filp
->f_mapping
);
170 result
= generic_file_read_iter(iocb
, to
);
172 nfs_add_stats(inode
, NFSIOS_NORMALREADBYTES
, result
);
174 nfs_end_io_read(inode
);
177 EXPORT_SYMBOL_GPL(nfs_file_read
);
180 nfs_file_mmap(struct file
* file
, struct vm_area_struct
* vma
)
182 struct inode
*inode
= file_inode(file
);
185 dprintk("NFS: mmap(%pD2)\n", file
);
187 /* Note: generic_file_mmap() returns ENOSYS on nommu systems
188 * so we call that before revalidating the mapping
190 status
= generic_file_mmap(file
, vma
);
192 vma
->vm_ops
= &nfs_file_vm_ops
;
193 status
= nfs_revalidate_mapping(inode
, file
->f_mapping
);
197 EXPORT_SYMBOL_GPL(nfs_file_mmap
);
200 * Flush any dirty pages for this process, and check for write errors.
201 * The return status from this call provides a reliable indication of
202 * whether any write errors occurred for this process.
205 nfs_file_fsync_commit(struct file
*file
, int datasync
)
207 struct nfs_open_context
*ctx
= nfs_file_open_context(file
);
208 struct inode
*inode
= file_inode(file
);
209 int do_resend
, status
;
212 dprintk("NFS: fsync file(%pD2) datasync %d\n", file
, datasync
);
214 nfs_inc_stats(inode
, NFSIOS_VFSFSYNC
);
215 do_resend
= test_and_clear_bit(NFS_CONTEXT_RESEND_WRITES
, &ctx
->flags
);
216 status
= nfs_commit_inode(inode
, FLUSH_SYNC
);
218 status
= file_check_and_advance_wb_err(file
);
223 do_resend
|= test_bit(NFS_CONTEXT_RESEND_WRITES
, &ctx
->flags
);
231 nfs_file_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
234 struct inode
*inode
= file_inode(file
);
236 trace_nfs_fsync_enter(inode
);
239 ret
= file_write_and_wait_range(file
, start
, end
);
242 ret
= nfs_file_fsync_commit(file
, datasync
);
244 ret
= pnfs_sync_inode(inode
, !!datasync
);
246 * If nfs_file_fsync_commit detected a server reboot, then
247 * resend all dirty pages that might have been covered by
248 * the NFS_CONTEXT_RESEND_WRITES flag
252 } while (ret
== -EAGAIN
);
254 trace_nfs_fsync_exit(inode
, ret
);
257 EXPORT_SYMBOL_GPL(nfs_file_fsync
);
260 * Decide whether a read/modify/write cycle may be more efficient
261 * then a modify/write/read cycle when writing to a page in the
264 * Some pNFS layout drivers can only read/write at a certain block
265 * granularity like all block devices and therefore we must perform
266 * read/modify/write whenever a page hasn't read yet and the data
267 * to be written there is not aligned to a block boundary and/or
268 * smaller than the block size.
270 * The modify/write/read cycle may occur if a page is read before
271 * being completely filled by the writer. In this situation, the
272 * page must be completely written to stable storage on the server
273 * before it can be refilled by reading in the page from the server.
274 * This can lead to expensive, small, FILE_SYNC mode writes being
277 * It may be more efficient to read the page first if the file is
278 * open for reading in addition to writing, the page is not marked
279 * as Uptodate, it is not dirty or waiting to be committed,
280 * indicating that it was previously allocated and then modified,
281 * that there were valid bytes of data in that range of the file,
282 * and that the new data won't completely replace the old data in
283 * that range of the file.
285 static bool nfs_full_page_write(struct page
*page
, loff_t pos
, unsigned int len
)
287 unsigned int pglen
= nfs_page_length(page
);
288 unsigned int offset
= pos
& (PAGE_SIZE
- 1);
289 unsigned int end
= offset
+ len
;
291 return !pglen
|| (end
>= pglen
&& !offset
);
294 static bool nfs_want_read_modify_write(struct file
*file
, struct page
*page
,
295 loff_t pos
, unsigned int len
)
298 * Up-to-date pages, those with ongoing or full-page write
299 * don't need read/modify/write
301 if (PageUptodate(page
) || PagePrivate(page
) ||
302 nfs_full_page_write(page
, pos
, len
))
305 if (pnfs_ld_read_whole_page(file
->f_mapping
->host
))
307 /* Open for reading too? */
308 if (file
->f_mode
& FMODE_READ
)
314 * This does the "real" work of the write. We must allocate and lock the
315 * page to be sent back to the generic routine, which then copies the
316 * data from user space.
318 * If the writer ends up delaying the write, the writer needs to
319 * increment the page use counts until he is done with the page.
321 static int nfs_write_begin(struct file
*file
, struct address_space
*mapping
,
322 loff_t pos
, unsigned len
, unsigned flags
,
323 struct page
**pagep
, void **fsdata
)
326 pgoff_t index
= pos
>> PAGE_SHIFT
;
330 dfprintk(PAGECACHE
, "NFS: write_begin(%pD2(%lu), %u@%lld)\n",
331 file
, mapping
->host
->i_ino
, len
, (long long) pos
);
334 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
339 ret
= nfs_flush_incompatible(file
, page
);
343 } else if (!once_thru
&&
344 nfs_want_read_modify_write(file
, page
, pos
, len
)) {
346 ret
= nfs_readpage(file
, page
);
354 static int nfs_write_end(struct file
*file
, struct address_space
*mapping
,
355 loff_t pos
, unsigned len
, unsigned copied
,
356 struct page
*page
, void *fsdata
)
358 unsigned offset
= pos
& (PAGE_SIZE
- 1);
359 struct nfs_open_context
*ctx
= nfs_file_open_context(file
);
362 dfprintk(PAGECACHE
, "NFS: write_end(%pD2(%lu), %u@%lld)\n",
363 file
, mapping
->host
->i_ino
, len
, (long long) pos
);
366 * Zero any uninitialised parts of the page, and then mark the page
367 * as up to date if it turns out that we're extending the file.
369 if (!PageUptodate(page
)) {
370 unsigned pglen
= nfs_page_length(page
);
371 unsigned end
= offset
+ copied
;
374 zero_user_segments(page
, 0, offset
,
376 SetPageUptodate(page
);
377 } else if (end
>= pglen
) {
378 zero_user_segment(page
, end
, PAGE_SIZE
);
380 SetPageUptodate(page
);
382 zero_user_segment(page
, pglen
, PAGE_SIZE
);
385 status
= nfs_updatepage(file
, page
, offset
, copied
);
392 NFS_I(mapping
->host
)->write_io
+= copied
;
394 if (nfs_ctx_key_to_expire(ctx
, mapping
->host
)) {
395 status
= nfs_wb_all(mapping
->host
);
404 * Partially or wholly invalidate a page
405 * - Release the private state associated with a page if undergoing complete
407 * - Called if either PG_private or PG_fscache is set on the page
408 * - Caller holds page lock
410 static void nfs_invalidate_page(struct page
*page
, unsigned int offset
,
413 dfprintk(PAGECACHE
, "NFS: invalidate_page(%p, %u, %u)\n",
414 page
, offset
, length
);
416 if (offset
!= 0 || length
< PAGE_SIZE
)
418 /* Cancel any unstarted writes on this page */
419 nfs_wb_page_cancel(page_file_mapping(page
)->host
, page
);
421 nfs_fscache_invalidate_page(page
, page
->mapping
->host
);
425 * Attempt to release the private state associated with a page
426 * - Called if either PG_private or PG_fscache is set on the page
427 * - Caller holds page lock
428 * - Return true (may release page) or false (may not)
430 static int nfs_release_page(struct page
*page
, gfp_t gfp
)
432 dfprintk(PAGECACHE
, "NFS: release_page(%p)\n", page
);
434 /* If PagePrivate() is set, then the page is not freeable */
435 if (PagePrivate(page
))
437 return nfs_fscache_release_page(page
, gfp
);
440 static void nfs_check_dirty_writeback(struct page
*page
,
441 bool *dirty
, bool *writeback
)
443 struct nfs_inode
*nfsi
;
444 struct address_space
*mapping
= page_file_mapping(page
);
446 if (!mapping
|| PageSwapCache(page
))
450 * Check if an unstable page is currently being committed and
451 * if so, have the VM treat it as if the page is under writeback
452 * so it will not block due to pages that will shortly be freeable.
454 nfsi
= NFS_I(mapping
->host
);
455 if (atomic_read(&nfsi
->commit_info
.rpcs_out
)) {
461 * If PagePrivate() is set, then the page is not freeable and as the
462 * inode is not being committed, it's not going to be cleaned in the
463 * near future so treat it as dirty
465 if (PagePrivate(page
))
470 * Attempt to clear the private state associated with a page when an error
471 * occurs that requires the cached contents of an inode to be written back or
473 * - Called if either PG_private or fscache is set on the page
474 * - Caller holds page lock
475 * - Return 0 if successful, -error otherwise
477 static int nfs_launder_page(struct page
*page
)
479 struct inode
*inode
= page_file_mapping(page
)->host
;
480 struct nfs_inode
*nfsi
= NFS_I(inode
);
482 dfprintk(PAGECACHE
, "NFS: launder_page(%ld, %llu)\n",
483 inode
->i_ino
, (long long)page_offset(page
));
485 nfs_fscache_wait_on_page_write(nfsi
, page
);
486 return nfs_wb_page(inode
, page
);
489 static int nfs_swap_activate(struct swap_info_struct
*sis
, struct file
*file
,
492 struct rpc_clnt
*clnt
= NFS_CLIENT(file
->f_mapping
->host
);
496 return rpc_clnt_swap_activate(clnt
);
499 static void nfs_swap_deactivate(struct file
*file
)
501 struct rpc_clnt
*clnt
= NFS_CLIENT(file
->f_mapping
->host
);
503 rpc_clnt_swap_deactivate(clnt
);
506 const struct address_space_operations nfs_file_aops
= {
507 .readpage
= nfs_readpage
,
508 .readpages
= nfs_readpages
,
509 .set_page_dirty
= __set_page_dirty_nobuffers
,
510 .writepage
= nfs_writepage
,
511 .writepages
= nfs_writepages
,
512 .write_begin
= nfs_write_begin
,
513 .write_end
= nfs_write_end
,
514 .invalidatepage
= nfs_invalidate_page
,
515 .releasepage
= nfs_release_page
,
516 .direct_IO
= nfs_direct_IO
,
517 #ifdef CONFIG_MIGRATION
518 .migratepage
= nfs_migrate_page
,
520 .launder_page
= nfs_launder_page
,
521 .is_dirty_writeback
= nfs_check_dirty_writeback
,
522 .error_remove_page
= generic_error_remove_page
,
523 .swap_activate
= nfs_swap_activate
,
524 .swap_deactivate
= nfs_swap_deactivate
,
528 * Notification that a PTE pointing to an NFS page is about to be made
529 * writable, implying that someone is about to modify the page through a
530 * shared-writable mapping
532 static vm_fault_t
nfs_vm_page_mkwrite(struct vm_fault
*vmf
)
534 struct page
*page
= vmf
->page
;
535 struct file
*filp
= vmf
->vma
->vm_file
;
536 struct inode
*inode
= file_inode(filp
);
538 vm_fault_t ret
= VM_FAULT_NOPAGE
;
539 struct address_space
*mapping
;
541 dfprintk(PAGECACHE
, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n",
542 filp
, filp
->f_mapping
->host
->i_ino
,
543 (long long)page_offset(page
));
545 sb_start_pagefault(inode
->i_sb
);
547 /* make sure the cache has finished storing the page */
548 nfs_fscache_wait_on_page_write(NFS_I(inode
), page
);
550 wait_on_bit_action(&NFS_I(inode
)->flags
, NFS_INO_INVALIDATING
,
551 nfs_wait_bit_killable
, TASK_KILLABLE
);
554 mapping
= page_file_mapping(page
);
555 if (mapping
!= inode
->i_mapping
)
558 wait_on_page_writeback(page
);
560 pagelen
= nfs_page_length(page
);
564 ret
= VM_FAULT_LOCKED
;
565 if (nfs_flush_incompatible(filp
, page
) == 0 &&
566 nfs_updatepage(filp
, page
, 0, pagelen
) == 0)
569 ret
= VM_FAULT_SIGBUS
;
573 sb_end_pagefault(inode
->i_sb
);
577 static const struct vm_operations_struct nfs_file_vm_ops
= {
578 .fault
= filemap_fault
,
579 .map_pages
= filemap_map_pages
,
580 .page_mkwrite
= nfs_vm_page_mkwrite
,
583 static int nfs_need_check_write(struct file
*filp
, struct inode
*inode
)
585 struct nfs_open_context
*ctx
;
587 ctx
= nfs_file_open_context(filp
);
588 if (nfs_ctx_key_to_expire(ctx
, inode
))
593 ssize_t
nfs_file_write(struct kiocb
*iocb
, struct iov_iter
*from
)
595 struct file
*file
= iocb
->ki_filp
;
596 struct inode
*inode
= file_inode(file
);
597 unsigned long written
= 0;
600 result
= nfs_key_timeout_notify(file
, inode
);
604 if (iocb
->ki_flags
& IOCB_DIRECT
)
605 return nfs_file_direct_write(iocb
, from
);
607 dprintk("NFS: write(%pD2, %zu@%Ld)\n",
608 file
, iov_iter_count(from
), (long long) iocb
->ki_pos
);
610 if (IS_SWAPFILE(inode
))
613 * O_APPEND implies that we must revalidate the file length.
615 if (iocb
->ki_flags
& IOCB_APPEND
) {
616 result
= nfs_revalidate_file_size(inode
, file
);
620 if (iocb
->ki_pos
> i_size_read(inode
))
621 nfs_revalidate_mapping(inode
, file
->f_mapping
);
623 nfs_start_io_write(inode
);
624 result
= generic_write_checks(iocb
, from
);
626 current
->backing_dev_info
= inode_to_bdi(inode
);
627 result
= generic_perform_write(file
, from
, iocb
->ki_pos
);
628 current
->backing_dev_info
= NULL
;
630 nfs_end_io_write(inode
);
635 iocb
->ki_pos
+= written
;
636 result
= generic_write_sync(iocb
, written
);
640 /* Return error values */
641 if (nfs_need_check_write(file
, inode
)) {
642 int err
= nfs_wb_all(inode
);
646 nfs_add_stats(inode
, NFSIOS_NORMALWRITTENBYTES
, written
);
651 printk(KERN_INFO
"NFS: attempt to write to active swap file!\n");
654 EXPORT_SYMBOL_GPL(nfs_file_write
);
657 do_getlk(struct file
*filp
, int cmd
, struct file_lock
*fl
, int is_local
)
659 struct inode
*inode
= filp
->f_mapping
->host
;
661 unsigned int saved_type
= fl
->fl_type
;
663 /* Try local locking first */
664 posix_test_lock(filp
, fl
);
665 if (fl
->fl_type
!= F_UNLCK
) {
666 /* found a conflict */
669 fl
->fl_type
= saved_type
;
671 if (NFS_PROTO(inode
)->have_delegation(inode
, FMODE_READ
))
677 status
= NFS_PROTO(inode
)->lock(filp
, cmd
, fl
);
681 fl
->fl_type
= F_UNLCK
;
686 do_unlk(struct file
*filp
, int cmd
, struct file_lock
*fl
, int is_local
)
688 struct inode
*inode
= filp
->f_mapping
->host
;
689 struct nfs_lock_context
*l_ctx
;
693 * Flush all pending writes before doing anything
698 l_ctx
= nfs_get_lock_context(nfs_file_open_context(filp
));
699 if (!IS_ERR(l_ctx
)) {
700 status
= nfs_iocounter_wait(l_ctx
);
701 nfs_put_lock_context(l_ctx
);
702 /* NOTE: special case
703 * If we're signalled while cleaning up locks on process exit, we
704 * still need to complete the unlock.
706 if (status
< 0 && !(fl
->fl_flags
& FL_CLOSE
))
711 * Use local locking if mounted with "-onolock" or with appropriate
715 status
= NFS_PROTO(inode
)->lock(filp
, cmd
, fl
);
717 status
= locks_lock_file_wait(filp
, fl
);
722 do_setlk(struct file
*filp
, int cmd
, struct file_lock
*fl
, int is_local
)
724 struct inode
*inode
= filp
->f_mapping
->host
;
728 * Flush all pending writes before doing anything
731 status
= nfs_sync_mapping(filp
->f_mapping
);
736 * Use local locking if mounted with "-onolock" or with appropriate
740 status
= NFS_PROTO(inode
)->lock(filp
, cmd
, fl
);
742 status
= locks_lock_file_wait(filp
, fl
);
747 * Invalidate cache to prevent missing any changes. If
748 * the file is mapped, clear the page cache as well so
749 * those mappings will be loaded.
751 * This makes locking act as a cache coherency point.
753 nfs_sync_mapping(filp
->f_mapping
);
754 if (!NFS_PROTO(inode
)->have_delegation(inode
, FMODE_READ
)) {
755 nfs_zap_caches(inode
);
756 if (mapping_mapped(filp
->f_mapping
))
757 nfs_revalidate_mapping(inode
, filp
->f_mapping
);
764 * Lock a (portion of) a file
766 int nfs_lock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
768 struct inode
*inode
= filp
->f_mapping
->host
;
772 dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n",
773 filp
, fl
->fl_type
, fl
->fl_flags
,
774 (long long)fl
->fl_start
, (long long)fl
->fl_end
);
776 nfs_inc_stats(inode
, NFSIOS_VFSLOCK
);
778 /* No mandatory locks over NFS */
779 if (__mandatory_lock(inode
) && fl
->fl_type
!= F_UNLCK
)
782 if (NFS_SERVER(inode
)->flags
& NFS_MOUNT_LOCAL_FCNTL
)
785 if (NFS_PROTO(inode
)->lock_check_bounds
!= NULL
) {
786 ret
= NFS_PROTO(inode
)->lock_check_bounds(fl
);
792 ret
= do_getlk(filp
, cmd
, fl
, is_local
);
793 else if (fl
->fl_type
== F_UNLCK
)
794 ret
= do_unlk(filp
, cmd
, fl
, is_local
);
796 ret
= do_setlk(filp
, cmd
, fl
, is_local
);
800 EXPORT_SYMBOL_GPL(nfs_lock
);
803 * Lock a (portion of) a file
805 int nfs_flock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
807 struct inode
*inode
= filp
->f_mapping
->host
;
810 dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n",
811 filp
, fl
->fl_type
, fl
->fl_flags
);
813 if (!(fl
->fl_flags
& FL_FLOCK
))
817 * The NFSv4 protocol doesn't support LOCK_MAND, which is not part of
818 * any standard. In principle we might be able to support LOCK_MAND
819 * on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the
820 * NFS code is not set up for it.
822 if (fl
->fl_type
& LOCK_MAND
)
825 if (NFS_SERVER(inode
)->flags
& NFS_MOUNT_LOCAL_FLOCK
)
828 /* We're simulating flock() locks using posix locks on the server */
829 if (fl
->fl_type
== F_UNLCK
)
830 return do_unlk(filp
, cmd
, fl
, is_local
);
831 return do_setlk(filp
, cmd
, fl
, is_local
);
833 EXPORT_SYMBOL_GPL(nfs_flock
);
835 const struct file_operations nfs_file_operations
= {
836 .llseek
= nfs_file_llseek
,
837 .read_iter
= nfs_file_read
,
838 .write_iter
= nfs_file_write
,
839 .mmap
= nfs_file_mmap
,
840 .open
= nfs_file_open
,
841 .flush
= nfs_file_flush
,
842 .release
= nfs_file_release
,
843 .fsync
= nfs_file_fsync
,
846 .splice_read
= generic_file_splice_read
,
847 .splice_write
= iter_file_splice_write
,
848 .check_flags
= nfs_check_flags
,
849 .setlease
= simple_nosetlease
,
851 EXPORT_SYMBOL_GPL(nfs_file_operations
);