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>
34 #include <linux/filelock.h>
36 #include "delegation.h"
44 #define NFSDBG_FACILITY NFSDBG_FILE
46 static const struct vm_operations_struct nfs_file_vm_ops
;
48 int nfs_check_flags(int flags
)
50 if ((flags
& (O_APPEND
| O_DIRECT
)) == (O_APPEND
| O_DIRECT
))
55 EXPORT_SYMBOL_GPL(nfs_check_flags
);
61 nfs_file_open(struct inode
*inode
, struct file
*filp
)
65 dprintk("NFS: open file(%pD2)\n", filp
);
67 nfs_inc_stats(inode
, NFSIOS_VFSOPEN
);
68 res
= nfs_check_flags(filp
->f_flags
);
72 res
= nfs_open(inode
, filp
);
74 filp
->f_mode
|= FMODE_CAN_ODIRECT
;
79 nfs_file_release(struct inode
*inode
, struct file
*filp
)
81 dprintk("NFS: release(%pD2)\n", filp
);
83 nfs_inc_stats(inode
, NFSIOS_VFSRELEASE
);
84 nfs_file_clear_open_context(filp
);
85 nfs_fscache_release_file(inode
, filp
);
88 EXPORT_SYMBOL_GPL(nfs_file_release
);
91 * nfs_revalidate_file_size - Revalidate the file size
92 * @inode: pointer to inode struct
93 * @filp: pointer to struct file
95 * Revalidates the file length. This is basically a wrapper around
96 * nfs_revalidate_inode() that takes into account the fact that we may
97 * have cached writes (in which case we don't care about the server's
98 * idea of what the file length is), or O_DIRECT (in which case we
99 * shouldn't trust the cache).
101 static int nfs_revalidate_file_size(struct inode
*inode
, struct file
*filp
)
103 struct nfs_server
*server
= NFS_SERVER(inode
);
105 if (filp
->f_flags
& O_DIRECT
)
107 if (nfs_check_cache_invalid(inode
, NFS_INO_INVALID_SIZE
))
111 return __nfs_revalidate_inode(server
, inode
);
114 loff_t
nfs_file_llseek(struct file
*filp
, loff_t offset
, int whence
)
116 dprintk("NFS: llseek file(%pD2, %lld, %d)\n",
117 filp
, offset
, whence
);
120 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
121 * the cached file length
123 if (whence
!= SEEK_SET
&& whence
!= SEEK_CUR
) {
124 struct inode
*inode
= filp
->f_mapping
->host
;
126 int retval
= nfs_revalidate_file_size(inode
, filp
);
128 return (loff_t
)retval
;
131 return generic_file_llseek(filp
, offset
, whence
);
133 EXPORT_SYMBOL_GPL(nfs_file_llseek
);
136 * Flush all dirty pages, and check for write errors.
139 nfs_file_flush(struct file
*file
, fl_owner_t id
)
141 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 since
= filemap_sample_wb_err(file
->f_mapping
);
153 return filemap_check_wb_err(file
->f_mapping
, since
);
157 nfs_file_read(struct kiocb
*iocb
, struct iov_iter
*to
)
159 struct inode
*inode
= file_inode(iocb
->ki_filp
);
162 if (iocb
->ki_flags
& IOCB_DIRECT
)
163 return nfs_file_direct_read(iocb
, to
, false);
165 dprintk("NFS: read(%pD2, %zu@%lu)\n",
167 iov_iter_count(to
), (unsigned long) iocb
->ki_pos
);
169 nfs_start_io_read(inode
);
170 result
= nfs_revalidate_mapping(inode
, iocb
->ki_filp
->f_mapping
);
172 result
= generic_file_read_iter(iocb
, to
);
174 nfs_add_stats(inode
, NFSIOS_NORMALREADBYTES
, result
);
176 nfs_end_io_read(inode
);
179 EXPORT_SYMBOL_GPL(nfs_file_read
);
182 nfs_file_mmap(struct file
* file
, struct vm_area_struct
* vma
)
184 struct inode
*inode
= file_inode(file
);
187 dprintk("NFS: mmap(%pD2)\n", file
);
189 /* Note: generic_file_mmap() returns ENOSYS on nommu systems
190 * so we call that before revalidating the mapping
192 status
= generic_file_mmap(file
, vma
);
194 vma
->vm_ops
= &nfs_file_vm_ops
;
195 status
= nfs_revalidate_mapping(inode
, file
->f_mapping
);
199 EXPORT_SYMBOL_GPL(nfs_file_mmap
);
202 * Flush any dirty pages for this process, and check for write errors.
203 * The return status from this call provides a reliable indication of
204 * whether any write errors occurred for this process.
207 nfs_file_fsync_commit(struct file
*file
, int datasync
)
209 struct inode
*inode
= file_inode(file
);
212 dprintk("NFS: fsync file(%pD2) datasync %d\n", file
, datasync
);
214 nfs_inc_stats(inode
, NFSIOS_VFSFSYNC
);
215 ret
= nfs_commit_inode(inode
, FLUSH_SYNC
);
216 ret2
= file_check_and_advance_wb_err(file
);
223 nfs_file_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
225 struct inode
*inode
= file_inode(file
);
226 struct nfs_inode
*nfsi
= NFS_I(inode
);
227 long save_nredirtied
= atomic_long_read(&nfsi
->redirtied_pages
);
231 trace_nfs_fsync_enter(inode
);
234 ret
= file_write_and_wait_range(file
, start
, end
);
237 ret
= nfs_file_fsync_commit(file
, datasync
);
240 ret
= pnfs_sync_inode(inode
, !!datasync
);
243 nredirtied
= atomic_long_read(&nfsi
->redirtied_pages
);
244 if (nredirtied
== save_nredirtied
)
246 save_nredirtied
= nredirtied
;
249 trace_nfs_fsync_exit(inode
, ret
);
252 EXPORT_SYMBOL_GPL(nfs_file_fsync
);
255 * Decide whether a read/modify/write cycle may be more efficient
256 * then a modify/write/read cycle when writing to a page in the
259 * Some pNFS layout drivers can only read/write at a certain block
260 * granularity like all block devices and therefore we must perform
261 * read/modify/write whenever a page hasn't read yet and the data
262 * to be written there is not aligned to a block boundary and/or
263 * smaller than the block size.
265 * The modify/write/read cycle may occur if a page is read before
266 * being completely filled by the writer. In this situation, the
267 * page must be completely written to stable storage on the server
268 * before it can be refilled by reading in the page from the server.
269 * This can lead to expensive, small, FILE_SYNC mode writes being
272 * It may be more efficient to read the page first if the file is
273 * open for reading in addition to writing, the page is not marked
274 * as Uptodate, it is not dirty or waiting to be committed,
275 * indicating that it was previously allocated and then modified,
276 * that there were valid bytes of data in that range of the file,
277 * and that the new data won't completely replace the old data in
278 * that range of the file.
280 static bool nfs_folio_is_full_write(struct folio
*folio
, loff_t pos
,
283 unsigned int pglen
= nfs_folio_length(folio
);
284 unsigned int offset
= offset_in_folio(folio
, pos
);
285 unsigned int end
= offset
+ len
;
287 return !pglen
|| (end
>= pglen
&& !offset
);
290 static bool nfs_want_read_modify_write(struct file
*file
, struct folio
*folio
,
291 loff_t pos
, unsigned int len
)
294 * Up-to-date pages, those with ongoing or full-page write
295 * don't need read/modify/write
297 if (folio_test_uptodate(folio
) || folio_test_private(folio
) ||
298 nfs_folio_is_full_write(folio
, pos
, len
))
301 if (pnfs_ld_read_whole_page(file_inode(file
)))
303 /* Open for reading too? */
304 if (file
->f_mode
& FMODE_READ
)
310 * This does the "real" work of the write. We must allocate and lock the
311 * page to be sent back to the generic routine, which then copies the
312 * data from user space.
314 * If the writer ends up delaying the write, the writer needs to
315 * increment the page use counts until he is done with the page.
317 static int nfs_write_begin(struct file
*file
, struct address_space
*mapping
,
318 loff_t pos
, unsigned len
, struct page
**pagep
,
325 dfprintk(PAGECACHE
, "NFS: write_begin(%pD2(%lu), %u@%lld)\n",
326 file
, mapping
->host
->i_ino
, len
, (long long) pos
);
329 folio
= __filemap_get_folio(mapping
, pos
>> PAGE_SHIFT
, FGP_WRITEBEGIN
,
330 mapping_gfp_mask(mapping
));
332 return PTR_ERR(folio
);
333 *pagep
= &folio
->page
;
335 ret
= nfs_flush_incompatible(file
, folio
);
339 } else if (!once_thru
&&
340 nfs_want_read_modify_write(file
, folio
, pos
, len
)) {
342 ret
= nfs_read_folio(file
, folio
);
350 static int nfs_write_end(struct file
*file
, struct address_space
*mapping
,
351 loff_t pos
, unsigned len
, unsigned copied
,
352 struct page
*page
, void *fsdata
)
354 struct nfs_open_context
*ctx
= nfs_file_open_context(file
);
355 struct folio
*folio
= page_folio(page
);
356 unsigned offset
= offset_in_folio(folio
, pos
);
359 dfprintk(PAGECACHE
, "NFS: write_end(%pD2(%lu), %u@%lld)\n",
360 file
, mapping
->host
->i_ino
, len
, (long long) pos
);
363 * Zero any uninitialised parts of the page, and then mark the page
364 * as up to date if it turns out that we're extending the file.
366 if (!folio_test_uptodate(folio
)) {
367 size_t fsize
= folio_size(folio
);
368 unsigned pglen
= nfs_folio_length(folio
);
369 unsigned end
= offset
+ copied
;
372 folio_zero_segments(folio
, 0, offset
, end
, fsize
);
373 folio_mark_uptodate(folio
);
374 } else if (end
>= pglen
) {
375 folio_zero_segment(folio
, end
, fsize
);
377 folio_mark_uptodate(folio
);
379 folio_zero_segment(folio
, pglen
, fsize
);
382 status
= nfs_update_folio(file
, folio
, offset
, copied
);
389 NFS_I(mapping
->host
)->write_io
+= copied
;
391 if (nfs_ctx_key_to_expire(ctx
, mapping
->host
))
392 nfs_wb_all(mapping
->host
);
398 * Partially or wholly invalidate a page
399 * - Release the private state associated with a page if undergoing complete
401 * - Called if either PG_private or PG_fscache is set on the page
402 * - Caller holds page lock
404 static void nfs_invalidate_folio(struct folio
*folio
, size_t offset
,
407 struct inode
*inode
= folio_file_mapping(folio
)->host
;
408 dfprintk(PAGECACHE
, "NFS: invalidate_folio(%lu, %zu, %zu)\n",
409 folio
->index
, offset
, length
);
411 if (offset
!= 0 || length
< folio_size(folio
))
413 /* Cancel any unstarted writes on this page */
414 nfs_wb_folio_cancel(inode
, folio
);
415 folio_wait_fscache(folio
);
416 trace_nfs_invalidate_folio(inode
, folio
);
420 * Attempt to release the private state associated with a folio
421 * - Called if either private or fscache flags are set on the folio
422 * - Caller holds folio lock
423 * - Return true (may release folio) or false (may not)
425 static bool nfs_release_folio(struct folio
*folio
, gfp_t gfp
)
427 dfprintk(PAGECACHE
, "NFS: release_folio(%p)\n", folio
);
429 /* If the private flag is set, then the folio is not freeable */
430 if (folio_test_private(folio
)) {
431 if ((current_gfp_context(gfp
) & GFP_KERNEL
) != GFP_KERNEL
||
434 if (nfs_wb_folio(folio_file_mapping(folio
)->host
, folio
) < 0)
437 return nfs_fscache_release_folio(folio
, gfp
);
440 static void nfs_check_dirty_writeback(struct folio
*folio
,
441 bool *dirty
, bool *writeback
)
443 struct nfs_inode
*nfsi
;
444 struct address_space
*mapping
= folio
->mapping
;
447 * Check if an unstable folio is currently being committed and
448 * if so, have the VM treat it as if the folio is under writeback
449 * so it will not block due to folios that will shortly be freeable.
451 nfsi
= NFS_I(mapping
->host
);
452 if (atomic_read(&nfsi
->commit_info
.rpcs_out
)) {
458 * If the private flag is set, then the folio is not freeable
459 * and as the inode is not being committed, it's not going to
460 * be cleaned in the near future so treat it as dirty
462 if (folio_test_private(folio
))
467 * Attempt to clear the private state associated with a page when an error
468 * occurs that requires the cached contents of an inode to be written back or
470 * - Called if either PG_private or fscache is set on the page
471 * - Caller holds page lock
472 * - Return 0 if successful, -error otherwise
474 static int nfs_launder_folio(struct folio
*folio
)
476 struct inode
*inode
= folio
->mapping
->host
;
479 dfprintk(PAGECACHE
, "NFS: launder_folio(%ld, %llu)\n",
480 inode
->i_ino
, folio_pos(folio
));
482 folio_wait_fscache(folio
);
483 ret
= nfs_wb_folio(inode
, folio
);
484 trace_nfs_launder_folio_done(inode
, folio
, ret
);
488 static int nfs_swap_activate(struct swap_info_struct
*sis
, struct file
*file
,
491 unsigned long blocks
;
494 struct inode
*inode
= file_inode(file
);
495 struct rpc_clnt
*clnt
= NFS_CLIENT(inode
);
496 struct nfs_client
*cl
= NFS_SERVER(inode
)->nfs_client
;
498 spin_lock(&inode
->i_lock
);
499 blocks
= inode
->i_blocks
;
500 isize
= inode
->i_size
;
501 spin_unlock(&inode
->i_lock
);
502 if (blocks
*512 < isize
) {
503 pr_warn("swap activate: swapfile has holes\n");
507 ret
= rpc_clnt_swap_activate(clnt
);
510 ret
= add_swap_extent(sis
, 0, sis
->max
, 0);
512 rpc_clnt_swap_deactivate(clnt
);
518 if (cl
->rpc_ops
->enable_swap
)
519 cl
->rpc_ops
->enable_swap(inode
);
521 sis
->flags
|= SWP_FS_OPS
;
525 static void nfs_swap_deactivate(struct file
*file
)
527 struct inode
*inode
= file_inode(file
);
528 struct rpc_clnt
*clnt
= NFS_CLIENT(inode
);
529 struct nfs_client
*cl
= NFS_SERVER(inode
)->nfs_client
;
531 rpc_clnt_swap_deactivate(clnt
);
532 if (cl
->rpc_ops
->disable_swap
)
533 cl
->rpc_ops
->disable_swap(file_inode(file
));
536 const struct address_space_operations nfs_file_aops
= {
537 .read_folio
= nfs_read_folio
,
538 .readahead
= nfs_readahead
,
539 .dirty_folio
= filemap_dirty_folio
,
540 .writepage
= nfs_writepage
,
541 .writepages
= nfs_writepages
,
542 .write_begin
= nfs_write_begin
,
543 .write_end
= nfs_write_end
,
544 .invalidate_folio
= nfs_invalidate_folio
,
545 .release_folio
= nfs_release_folio
,
546 .migrate_folio
= nfs_migrate_folio
,
547 .launder_folio
= nfs_launder_folio
,
548 .is_dirty_writeback
= nfs_check_dirty_writeback
,
549 .error_remove_page
= generic_error_remove_page
,
550 .swap_activate
= nfs_swap_activate
,
551 .swap_deactivate
= nfs_swap_deactivate
,
552 .swap_rw
= nfs_swap_rw
,
556 * Notification that a PTE pointing to an NFS page is about to be made
557 * writable, implying that someone is about to modify the page through a
558 * shared-writable mapping
560 static vm_fault_t
nfs_vm_page_mkwrite(struct vm_fault
*vmf
)
562 struct file
*filp
= vmf
->vma
->vm_file
;
563 struct inode
*inode
= file_inode(filp
);
565 vm_fault_t ret
= VM_FAULT_NOPAGE
;
566 struct address_space
*mapping
;
567 struct folio
*folio
= page_folio(vmf
->page
);
569 dfprintk(PAGECACHE
, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n",
570 filp
, filp
->f_mapping
->host
->i_ino
,
571 (long long)folio_file_pos(folio
));
573 sb_start_pagefault(inode
->i_sb
);
575 /* make sure the cache has finished storing the page */
576 if (folio_test_fscache(folio
) &&
577 folio_wait_fscache_killable(folio
) < 0) {
578 ret
= VM_FAULT_RETRY
;
582 wait_on_bit_action(&NFS_I(inode
)->flags
, NFS_INO_INVALIDATING
,
583 nfs_wait_bit_killable
,
584 TASK_KILLABLE
|TASK_FREEZABLE_UNSAFE
);
587 mapping
= folio_file_mapping(folio
);
588 if (mapping
!= inode
->i_mapping
)
591 folio_wait_writeback(folio
);
593 pagelen
= nfs_folio_length(folio
);
597 ret
= VM_FAULT_LOCKED
;
598 if (nfs_flush_incompatible(filp
, folio
) == 0 &&
599 nfs_update_folio(filp
, folio
, 0, pagelen
) == 0)
602 ret
= VM_FAULT_SIGBUS
;
606 sb_end_pagefault(inode
->i_sb
);
610 static const struct vm_operations_struct nfs_file_vm_ops
= {
611 .fault
= filemap_fault
,
612 .map_pages
= filemap_map_pages
,
613 .page_mkwrite
= nfs_vm_page_mkwrite
,
616 ssize_t
nfs_file_write(struct kiocb
*iocb
, struct iov_iter
*from
)
618 struct file
*file
= iocb
->ki_filp
;
619 struct inode
*inode
= file_inode(file
);
620 unsigned int mntflags
= NFS_SERVER(inode
)->flags
;
621 ssize_t result
, written
;
625 result
= nfs_key_timeout_notify(file
, inode
);
629 if (iocb
->ki_flags
& IOCB_DIRECT
)
630 return nfs_file_direct_write(iocb
, from
, false);
632 dprintk("NFS: write(%pD2, %zu@%Ld)\n",
633 file
, iov_iter_count(from
), (long long) iocb
->ki_pos
);
635 if (IS_SWAPFILE(inode
))
638 * O_APPEND implies that we must revalidate the file length.
640 if (iocb
->ki_flags
& IOCB_APPEND
|| iocb
->ki_pos
> i_size_read(inode
)) {
641 result
= nfs_revalidate_file_size(inode
, file
);
646 nfs_clear_invalid_mapping(file
->f_mapping
);
648 since
= filemap_sample_wb_err(file
->f_mapping
);
649 nfs_start_io_write(inode
);
650 result
= generic_write_checks(iocb
, from
);
652 current
->backing_dev_info
= inode_to_bdi(inode
);
653 result
= generic_perform_write(iocb
, from
);
654 current
->backing_dev_info
= NULL
;
656 nfs_end_io_write(inode
);
661 iocb
->ki_pos
+= written
;
662 nfs_add_stats(inode
, NFSIOS_NORMALWRITTENBYTES
, written
);
664 if (mntflags
& NFS_MOUNT_WRITE_EAGER
) {
665 result
= filemap_fdatawrite_range(file
->f_mapping
,
666 iocb
->ki_pos
- written
,
671 if (mntflags
& NFS_MOUNT_WRITE_WAIT
) {
672 filemap_fdatawait_range(file
->f_mapping
,
673 iocb
->ki_pos
- written
,
676 result
= generic_write_sync(iocb
, written
);
681 /* Return error values */
682 error
= filemap_check_wb_err(file
->f_mapping
, since
);
690 error
= file_check_and_advance_wb_err(file
);
697 printk(KERN_INFO
"NFS: attempt to write to active swap file!\n");
700 EXPORT_SYMBOL_GPL(nfs_file_write
);
703 do_getlk(struct file
*filp
, int cmd
, struct file_lock
*fl
, int is_local
)
705 struct inode
*inode
= filp
->f_mapping
->host
;
707 unsigned int saved_type
= fl
->fl_type
;
709 /* Try local locking first */
710 posix_test_lock(filp
, fl
);
711 if (fl
->fl_type
!= F_UNLCK
) {
712 /* found a conflict */
715 fl
->fl_type
= saved_type
;
717 if (NFS_PROTO(inode
)->have_delegation(inode
, FMODE_READ
))
723 status
= NFS_PROTO(inode
)->lock(filp
, cmd
, fl
);
727 fl
->fl_type
= F_UNLCK
;
732 do_unlk(struct file
*filp
, int cmd
, struct file_lock
*fl
, int is_local
)
734 struct inode
*inode
= filp
->f_mapping
->host
;
735 struct nfs_lock_context
*l_ctx
;
739 * Flush all pending writes before doing anything
744 l_ctx
= nfs_get_lock_context(nfs_file_open_context(filp
));
745 if (!IS_ERR(l_ctx
)) {
746 status
= nfs_iocounter_wait(l_ctx
);
747 nfs_put_lock_context(l_ctx
);
748 /* NOTE: special case
749 * If we're signalled while cleaning up locks on process exit, we
750 * still need to complete the unlock.
752 if (status
< 0 && !(fl
->fl_flags
& FL_CLOSE
))
757 * Use local locking if mounted with "-onolock" or with appropriate
761 status
= NFS_PROTO(inode
)->lock(filp
, cmd
, fl
);
763 status
= locks_lock_file_wait(filp
, fl
);
768 do_setlk(struct file
*filp
, int cmd
, struct file_lock
*fl
, int is_local
)
770 struct inode
*inode
= filp
->f_mapping
->host
;
774 * Flush all pending writes before doing anything
777 status
= nfs_sync_mapping(filp
->f_mapping
);
782 * Use local locking if mounted with "-onolock" or with appropriate
786 status
= NFS_PROTO(inode
)->lock(filp
, cmd
, fl
);
788 status
= locks_lock_file_wait(filp
, fl
);
793 * Invalidate cache to prevent missing any changes. If
794 * the file is mapped, clear the page cache as well so
795 * those mappings will be loaded.
797 * This makes locking act as a cache coherency point.
799 nfs_sync_mapping(filp
->f_mapping
);
800 if (!NFS_PROTO(inode
)->have_delegation(inode
, FMODE_READ
)) {
801 nfs_zap_caches(inode
);
802 if (mapping_mapped(filp
->f_mapping
))
803 nfs_revalidate_mapping(inode
, filp
->f_mapping
);
810 * Lock a (portion of) a file
812 int nfs_lock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
814 struct inode
*inode
= filp
->f_mapping
->host
;
818 dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n",
819 filp
, fl
->fl_type
, fl
->fl_flags
,
820 (long long)fl
->fl_start
, (long long)fl
->fl_end
);
822 nfs_inc_stats(inode
, NFSIOS_VFSLOCK
);
824 if (fl
->fl_flags
& FL_RECLAIM
)
827 if (NFS_SERVER(inode
)->flags
& NFS_MOUNT_LOCAL_FCNTL
)
830 if (NFS_PROTO(inode
)->lock_check_bounds
!= NULL
) {
831 ret
= NFS_PROTO(inode
)->lock_check_bounds(fl
);
837 ret
= do_getlk(filp
, cmd
, fl
, is_local
);
838 else if (fl
->fl_type
== F_UNLCK
)
839 ret
= do_unlk(filp
, cmd
, fl
, is_local
);
841 ret
= do_setlk(filp
, cmd
, fl
, is_local
);
845 EXPORT_SYMBOL_GPL(nfs_lock
);
848 * Lock a (portion of) a file
850 int nfs_flock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
852 struct inode
*inode
= filp
->f_mapping
->host
;
855 dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n",
856 filp
, fl
->fl_type
, fl
->fl_flags
);
858 if (!(fl
->fl_flags
& FL_FLOCK
))
861 if (NFS_SERVER(inode
)->flags
& NFS_MOUNT_LOCAL_FLOCK
)
864 /* We're simulating flock() locks using posix locks on the server */
865 if (fl
->fl_type
== F_UNLCK
)
866 return do_unlk(filp
, cmd
, fl
, is_local
);
867 return do_setlk(filp
, cmd
, fl
, is_local
);
869 EXPORT_SYMBOL_GPL(nfs_flock
);
871 const struct file_operations nfs_file_operations
= {
872 .llseek
= nfs_file_llseek
,
873 .read_iter
= nfs_file_read
,
874 .write_iter
= nfs_file_write
,
875 .mmap
= nfs_file_mmap
,
876 .open
= nfs_file_open
,
877 .flush
= nfs_file_flush
,
878 .release
= nfs_file_release
,
879 .fsync
= nfs_file_fsync
,
882 .splice_read
= generic_file_splice_read
,
883 .splice_write
= iter_file_splice_write
,
884 .check_flags
= nfs_check_flags
,
885 .setlease
= simple_nosetlease
,
887 EXPORT_SYMBOL_GPL(nfs_file_operations
);