1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/fs/nfs/file.c 4 * 5 * Copyright (C) 1992 Rick Sladkey 6 * 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. 12 * 13 * Expire cache on write to a file by Wai S Kok (Oct 1994). 14 * 15 * Total rewrite of read side for new NFS buffer cache.. Linus. 16 * 17 * nfs regular file handling functions 18 */ 19 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> 28 #include <linux/mm.h> 29 #include <linux/pagemap.h> 30 #include <linux/gfp.h> 31 #include <linux/swap.h> 32 33 #include <linux/uaccess.h> 34 35 #include "delegation.h" 36 #include "internal.h" 37 #include "iostat.h" 38 #include "fscache.h" 39 #include "pnfs.h" 40 41 #include "nfstrace.h" 42 43 #define NFSDBG_FACILITY NFSDBG_FILE 44 45 static const struct vm_operations_struct nfs_file_vm_ops; 46 47 int nfs_check_flags(int flags) 48 { 49 if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT)) 50 return -EINVAL; 51 52 return 0; 53 } 54 EXPORT_SYMBOL_GPL(nfs_check_flags); 55 56 /* 57 * Open file 58 */ 59 static int 60 nfs_file_open(struct inode *inode, struct file *filp) 61 { 62 int res; 63 64 dprintk("NFS: open file(%pD2)\n", filp); 65 66 nfs_inc_stats(inode, NFSIOS_VFSOPEN); 67 res = nfs_check_flags(filp->f_flags); 68 if (res) 69 return res; 70 71 res = nfs_open(inode, filp); 72 if (res == 0) 73 filp->f_mode |= FMODE_CAN_ODIRECT; 74 return res; 75 } 76 77 int 78 nfs_file_release(struct inode *inode, struct file *filp) 79 { 80 dprintk("NFS: release(%pD2)\n", filp); 81 82 nfs_inc_stats(inode, NFSIOS_VFSRELEASE); 83 nfs_file_clear_open_context(filp); 84 nfs_fscache_release_file(inode, filp); 85 return 0; 86 } 87 EXPORT_SYMBOL_GPL(nfs_file_release); 88 89 /** 90 * nfs_revalidate_file_size - Revalidate the file size 91 * @inode: pointer to inode struct 92 * @filp: pointer to struct file 93 * 94 * Revalidates the file length. This is basically a wrapper around 95 * nfs_revalidate_inode() that takes into account the fact that we may 96 * have cached writes (in which case we don't care about the server's 97 * idea of what the file length is), or O_DIRECT (in which case we 98 * shouldn't trust the cache). 99 */ 100 static int nfs_revalidate_file_size(struct inode *inode, struct file *filp) 101 { 102 struct nfs_server *server = NFS_SERVER(inode); 103 104 if (filp->f_flags & O_DIRECT) 105 goto force_reval; 106 if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_SIZE)) 107 goto force_reval; 108 return 0; 109 force_reval: 110 return __nfs_revalidate_inode(server, inode); 111 } 112 113 loff_t nfs_file_llseek(struct file *filp, loff_t offset, int whence) 114 { 115 dprintk("NFS: llseek file(%pD2, %lld, %d)\n", 116 filp, offset, whence); 117 118 /* 119 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate 120 * the cached file length 121 */ 122 if (whence != SEEK_SET && whence != SEEK_CUR) { 123 struct inode *inode = filp->f_mapping->host; 124 125 int retval = nfs_revalidate_file_size(inode, filp); 126 if (retval < 0) 127 return (loff_t)retval; 128 } 129 130 return generic_file_llseek(filp, offset, whence); 131 } 132 EXPORT_SYMBOL_GPL(nfs_file_llseek); 133 134 /* 135 * Flush all dirty pages, and check for write errors. 136 */ 137 static int 138 nfs_file_flush(struct file *file, fl_owner_t id) 139 { 140 struct inode *inode = file_inode(file); 141 errseq_t since; 142 143 dprintk("NFS: flush(%pD2)\n", file); 144 145 nfs_inc_stats(inode, NFSIOS_VFSFLUSH); 146 if ((file->f_mode & FMODE_WRITE) == 0) 147 return 0; 148 149 /* Flush writes to the server and return any errors */ 150 since = filemap_sample_wb_err(file->f_mapping); 151 nfs_wb_all(inode); 152 return filemap_check_wb_err(file->f_mapping, since); 153 } 154 155 ssize_t 156 nfs_file_read(struct kiocb *iocb, struct iov_iter *to) 157 { 158 struct inode *inode = file_inode(iocb->ki_filp); 159 ssize_t result; 160 161 if (iocb->ki_flags & IOCB_DIRECT) 162 return nfs_file_direct_read(iocb, to, false); 163 164 dprintk("NFS: read(%pD2, %zu@%lu)\n", 165 iocb->ki_filp, 166 iov_iter_count(to), (unsigned long) iocb->ki_pos); 167 168 nfs_start_io_read(inode); 169 result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping); 170 if (!result) { 171 result = generic_file_read_iter(iocb, to); 172 if (result > 0) 173 nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result); 174 } 175 nfs_end_io_read(inode); 176 return result; 177 } 178 EXPORT_SYMBOL_GPL(nfs_file_read); 179 180 int 181 nfs_file_mmap(struct file * file, struct vm_area_struct * vma) 182 { 183 struct inode *inode = file_inode(file); 184 int status; 185 186 dprintk("NFS: mmap(%pD2)\n", file); 187 188 /* Note: generic_file_mmap() returns ENOSYS on nommu systems 189 * so we call that before revalidating the mapping 190 */ 191 status = generic_file_mmap(file, vma); 192 if (!status) { 193 vma->vm_ops = &nfs_file_vm_ops; 194 status = nfs_revalidate_mapping(inode, file->f_mapping); 195 } 196 return status; 197 } 198 EXPORT_SYMBOL_GPL(nfs_file_mmap); 199 200 /* 201 * Flush any dirty pages for this process, and check for write errors. 202 * The return status from this call provides a reliable indication of 203 * whether any write errors occurred for this process. 204 */ 205 static int 206 nfs_file_fsync_commit(struct file *file, int datasync) 207 { 208 struct inode *inode = file_inode(file); 209 int ret, ret2; 210 211 dprintk("NFS: fsync file(%pD2) datasync %d\n", file, datasync); 212 213 nfs_inc_stats(inode, NFSIOS_VFSFSYNC); 214 ret = nfs_commit_inode(inode, FLUSH_SYNC); 215 ret2 = file_check_and_advance_wb_err(file); 216 if (ret2 < 0) 217 return ret2; 218 return ret; 219 } 220 221 int 222 nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync) 223 { 224 struct inode *inode = file_inode(file); 225 struct nfs_inode *nfsi = NFS_I(inode); 226 long save_nredirtied = atomic_long_read(&nfsi->redirtied_pages); 227 long nredirtied; 228 int ret; 229 230 trace_nfs_fsync_enter(inode); 231 232 for (;;) { 233 ret = file_write_and_wait_range(file, start, end); 234 if (ret != 0) 235 break; 236 ret = nfs_file_fsync_commit(file, datasync); 237 if (ret != 0) 238 break; 239 ret = pnfs_sync_inode(inode, !!datasync); 240 if (ret != 0) 241 break; 242 nredirtied = atomic_long_read(&nfsi->redirtied_pages); 243 if (nredirtied == save_nredirtied) 244 break; 245 save_nredirtied = nredirtied; 246 } 247 248 trace_nfs_fsync_exit(inode, ret); 249 return ret; 250 } 251 EXPORT_SYMBOL_GPL(nfs_file_fsync); 252 253 /* 254 * Decide whether a read/modify/write cycle may be more efficient 255 * then a modify/write/read cycle when writing to a page in the 256 * page cache. 257 * 258 * Some pNFS layout drivers can only read/write at a certain block 259 * granularity like all block devices and therefore we must perform 260 * read/modify/write whenever a page hasn't read yet and the data 261 * to be written there is not aligned to a block boundary and/or 262 * smaller than the block size. 263 * 264 * The modify/write/read cycle may occur if a page is read before 265 * being completely filled by the writer. In this situation, the 266 * page must be completely written to stable storage on the server 267 * before it can be refilled by reading in the page from the server. 268 * This can lead to expensive, small, FILE_SYNC mode writes being 269 * done. 270 * 271 * It may be more efficient to read the page first if the file is 272 * open for reading in addition to writing, the page is not marked 273 * as Uptodate, it is not dirty or waiting to be committed, 274 * indicating that it was previously allocated and then modified, 275 * that there were valid bytes of data in that range of the file, 276 * and that the new data won't completely replace the old data in 277 * that range of the file. 278 */ 279 static bool nfs_full_page_write(struct page *page, loff_t pos, unsigned int len) 280 { 281 unsigned int pglen = nfs_page_length(page); 282 unsigned int offset = pos & (PAGE_SIZE - 1); 283 unsigned int end = offset + len; 284 285 return !pglen || (end >= pglen && !offset); 286 } 287 288 static bool nfs_want_read_modify_write(struct file *file, struct page *page, 289 loff_t pos, unsigned int len) 290 { 291 /* 292 * Up-to-date pages, those with ongoing or full-page write 293 * don't need read/modify/write 294 */ 295 if (PageUptodate(page) || PagePrivate(page) || 296 nfs_full_page_write(page, pos, len)) 297 return false; 298 299 if (pnfs_ld_read_whole_page(file->f_mapping->host)) 300 return true; 301 /* Open for reading too? */ 302 if (file->f_mode & FMODE_READ) 303 return true; 304 return false; 305 } 306 307 /* 308 * This does the "real" work of the write. We must allocate and lock the 309 * page to be sent back to the generic routine, which then copies the 310 * data from user space. 311 * 312 * If the writer ends up delaying the write, the writer needs to 313 * increment the page use counts until he is done with the page. 314 */ 315 static int nfs_write_begin(struct file *file, struct address_space *mapping, 316 loff_t pos, unsigned len, 317 struct page **pagep, void **fsdata) 318 { 319 int ret; 320 pgoff_t index = pos >> PAGE_SHIFT; 321 struct page *page; 322 int once_thru = 0; 323 324 dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n", 325 file, mapping->host->i_ino, len, (long long) pos); 326 327 start: 328 page = grab_cache_page_write_begin(mapping, index); 329 if (!page) 330 return -ENOMEM; 331 *pagep = page; 332 333 ret = nfs_flush_incompatible(file, page); 334 if (ret) { 335 unlock_page(page); 336 put_page(page); 337 } else if (!once_thru && 338 nfs_want_read_modify_write(file, page, pos, len)) { 339 once_thru = 1; 340 ret = nfs_read_folio(file, page_folio(page)); 341 put_page(page); 342 if (!ret) 343 goto start; 344 } 345 return ret; 346 } 347 348 static int nfs_write_end(struct file *file, struct address_space *mapping, 349 loff_t pos, unsigned len, unsigned copied, 350 struct page *page, void *fsdata) 351 { 352 unsigned offset = pos & (PAGE_SIZE - 1); 353 struct nfs_open_context *ctx = nfs_file_open_context(file); 354 int status; 355 356 dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n", 357 file, mapping->host->i_ino, len, (long long) pos); 358 359 /* 360 * Zero any uninitialised parts of the page, and then mark the page 361 * as up to date if it turns out that we're extending the file. 362 */ 363 if (!PageUptodate(page)) { 364 unsigned pglen = nfs_page_length(page); 365 unsigned end = offset + copied; 366 367 if (pglen == 0) { 368 zero_user_segments(page, 0, offset, 369 end, PAGE_SIZE); 370 SetPageUptodate(page); 371 } else if (end >= pglen) { 372 zero_user_segment(page, end, PAGE_SIZE); 373 if (offset == 0) 374 SetPageUptodate(page); 375 } else 376 zero_user_segment(page, pglen, PAGE_SIZE); 377 } 378 379 status = nfs_updatepage(file, page, offset, copied); 380 381 unlock_page(page); 382 put_page(page); 383 384 if (status < 0) 385 return status; 386 NFS_I(mapping->host)->write_io += copied; 387 388 if (nfs_ctx_key_to_expire(ctx, mapping->host)) 389 nfs_wb_all(mapping->host); 390 391 return copied; 392 } 393 394 /* 395 * Partially or wholly invalidate a page 396 * - Release the private state associated with a page if undergoing complete 397 * page invalidation 398 * - Called if either PG_private or PG_fscache is set on the page 399 * - Caller holds page lock 400 */ 401 static void nfs_invalidate_folio(struct folio *folio, size_t offset, 402 size_t length) 403 { 404 dfprintk(PAGECACHE, "NFS: invalidate_folio(%lu, %zu, %zu)\n", 405 folio->index, offset, length); 406 407 if (offset != 0 || length < folio_size(folio)) 408 return; 409 /* Cancel any unstarted writes on this page */ 410 nfs_wb_folio_cancel(folio->mapping->host, folio); 411 folio_wait_fscache(folio); 412 } 413 414 /* 415 * Attempt to release the private state associated with a folio 416 * - Called if either private or fscache flags are set on the folio 417 * - Caller holds folio lock 418 * - Return true (may release folio) or false (may not) 419 */ 420 static bool nfs_release_folio(struct folio *folio, gfp_t gfp) 421 { 422 dfprintk(PAGECACHE, "NFS: release_folio(%p)\n", folio); 423 424 /* If the private flag is set, then the folio is not freeable */ 425 if (folio_test_private(folio)) 426 return false; 427 return nfs_fscache_release_folio(folio, gfp); 428 } 429 430 static void nfs_check_dirty_writeback(struct folio *folio, 431 bool *dirty, bool *writeback) 432 { 433 struct nfs_inode *nfsi; 434 struct address_space *mapping = folio->mapping; 435 436 /* 437 * Check if an unstable folio is currently being committed and 438 * if so, have the VM treat it as if the folio is under writeback 439 * so it will not block due to folios that will shortly be freeable. 440 */ 441 nfsi = NFS_I(mapping->host); 442 if (atomic_read(&nfsi->commit_info.rpcs_out)) { 443 *writeback = true; 444 return; 445 } 446 447 /* 448 * If the private flag is set, then the folio is not freeable 449 * and as the inode is not being committed, it's not going to 450 * be cleaned in the near future so treat it as dirty 451 */ 452 if (folio_test_private(folio)) 453 *dirty = true; 454 } 455 456 /* 457 * Attempt to clear the private state associated with a page when an error 458 * occurs that requires the cached contents of an inode to be written back or 459 * destroyed 460 * - Called if either PG_private or fscache is set on the page 461 * - Caller holds page lock 462 * - Return 0 if successful, -error otherwise 463 */ 464 static int nfs_launder_folio(struct folio *folio) 465 { 466 struct inode *inode = folio->mapping->host; 467 468 dfprintk(PAGECACHE, "NFS: launder_folio(%ld, %llu)\n", 469 inode->i_ino, folio_pos(folio)); 470 471 folio_wait_fscache(folio); 472 return nfs_wb_page(inode, &folio->page); 473 } 474 475 static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file, 476 sector_t *span) 477 { 478 unsigned long blocks; 479 long long isize; 480 int ret; 481 struct inode *inode = file_inode(file); 482 struct rpc_clnt *clnt = NFS_CLIENT(inode); 483 struct nfs_client *cl = NFS_SERVER(inode)->nfs_client; 484 485 spin_lock(&inode->i_lock); 486 blocks = inode->i_blocks; 487 isize = inode->i_size; 488 spin_unlock(&inode->i_lock); 489 if (blocks*512 < isize) { 490 pr_warn("swap activate: swapfile has holes\n"); 491 return -EINVAL; 492 } 493 494 ret = rpc_clnt_swap_activate(clnt); 495 if (ret) 496 return ret; 497 ret = add_swap_extent(sis, 0, sis->max, 0); 498 if (ret < 0) { 499 rpc_clnt_swap_deactivate(clnt); 500 return ret; 501 } 502 503 *span = sis->pages; 504 505 if (cl->rpc_ops->enable_swap) 506 cl->rpc_ops->enable_swap(inode); 507 508 sis->flags |= SWP_FS_OPS; 509 return ret; 510 } 511 512 static void nfs_swap_deactivate(struct file *file) 513 { 514 struct inode *inode = file_inode(file); 515 struct rpc_clnt *clnt = NFS_CLIENT(inode); 516 struct nfs_client *cl = NFS_SERVER(inode)->nfs_client; 517 518 rpc_clnt_swap_deactivate(clnt); 519 if (cl->rpc_ops->disable_swap) 520 cl->rpc_ops->disable_swap(file_inode(file)); 521 } 522 523 const struct address_space_operations nfs_file_aops = { 524 .read_folio = nfs_read_folio, 525 .readahead = nfs_readahead, 526 .dirty_folio = filemap_dirty_folio, 527 .writepage = nfs_writepage, 528 .writepages = nfs_writepages, 529 .write_begin = nfs_write_begin, 530 .write_end = nfs_write_end, 531 .invalidate_folio = nfs_invalidate_folio, 532 .release_folio = nfs_release_folio, 533 .migrate_folio = nfs_migrate_folio, 534 .launder_folio = nfs_launder_folio, 535 .is_dirty_writeback = nfs_check_dirty_writeback, 536 .error_remove_page = generic_error_remove_page, 537 .swap_activate = nfs_swap_activate, 538 .swap_deactivate = nfs_swap_deactivate, 539 .swap_rw = nfs_swap_rw, 540 }; 541 542 /* 543 * Notification that a PTE pointing to an NFS page is about to be made 544 * writable, implying that someone is about to modify the page through a 545 * shared-writable mapping 546 */ 547 static vm_fault_t nfs_vm_page_mkwrite(struct vm_fault *vmf) 548 { 549 struct page *page = vmf->page; 550 struct file *filp = vmf->vma->vm_file; 551 struct inode *inode = file_inode(filp); 552 unsigned pagelen; 553 vm_fault_t ret = VM_FAULT_NOPAGE; 554 struct address_space *mapping; 555 556 dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n", 557 filp, filp->f_mapping->host->i_ino, 558 (long long)page_offset(page)); 559 560 sb_start_pagefault(inode->i_sb); 561 562 /* make sure the cache has finished storing the page */ 563 if (PageFsCache(page) && 564 wait_on_page_fscache_killable(vmf->page) < 0) { 565 ret = VM_FAULT_RETRY; 566 goto out; 567 } 568 569 wait_on_bit_action(&NFS_I(inode)->flags, NFS_INO_INVALIDATING, 570 nfs_wait_bit_killable, TASK_KILLABLE); 571 572 lock_page(page); 573 mapping = page_file_mapping(page); 574 if (mapping != inode->i_mapping) 575 goto out_unlock; 576 577 wait_on_page_writeback(page); 578 579 pagelen = nfs_page_length(page); 580 if (pagelen == 0) 581 goto out_unlock; 582 583 ret = VM_FAULT_LOCKED; 584 if (nfs_flush_incompatible(filp, page) == 0 && 585 nfs_updatepage(filp, page, 0, pagelen) == 0) 586 goto out; 587 588 ret = VM_FAULT_SIGBUS; 589 out_unlock: 590 unlock_page(page); 591 out: 592 sb_end_pagefault(inode->i_sb); 593 return ret; 594 } 595 596 static const struct vm_operations_struct nfs_file_vm_ops = { 597 .fault = filemap_fault, 598 .map_pages = filemap_map_pages, 599 .page_mkwrite = nfs_vm_page_mkwrite, 600 }; 601 602 ssize_t nfs_file_write(struct kiocb *iocb, struct iov_iter *from) 603 { 604 struct file *file = iocb->ki_filp; 605 struct inode *inode = file_inode(file); 606 unsigned int mntflags = NFS_SERVER(inode)->flags; 607 ssize_t result, written; 608 errseq_t since; 609 int error; 610 611 result = nfs_key_timeout_notify(file, inode); 612 if (result) 613 return result; 614 615 if (iocb->ki_flags & IOCB_DIRECT) 616 return nfs_file_direct_write(iocb, from, false); 617 618 dprintk("NFS: write(%pD2, %zu@%Ld)\n", 619 file, iov_iter_count(from), (long long) iocb->ki_pos); 620 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_flags & IOCB_APPEND || iocb->ki_pos > i_size_read(inode)) { 627 result = nfs_revalidate_file_size(inode, file); 628 if (result) 629 return result; 630 } 631 632 nfs_clear_invalid_mapping(file->f_mapping); 633 634 since = filemap_sample_wb_err(file->f_mapping); 635 nfs_start_io_write(inode); 636 result = generic_write_checks(iocb, from); 637 if (result > 0) { 638 current->backing_dev_info = inode_to_bdi(inode); 639 result = generic_perform_write(iocb, from); 640 current->backing_dev_info = NULL; 641 } 642 nfs_end_io_write(inode); 643 if (result <= 0) 644 goto out; 645 646 written = result; 647 iocb->ki_pos += written; 648 nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written); 649 650 if (mntflags & NFS_MOUNT_WRITE_EAGER) { 651 result = filemap_fdatawrite_range(file->f_mapping, 652 iocb->ki_pos - written, 653 iocb->ki_pos - 1); 654 if (result < 0) 655 goto out; 656 } 657 if (mntflags & NFS_MOUNT_WRITE_WAIT) { 658 result = filemap_fdatawait_range(file->f_mapping, 659 iocb->ki_pos - written, 660 iocb->ki_pos - 1); 661 } 662 result = generic_write_sync(iocb, written); 663 if (result < 0) 664 return result; 665 666 out: 667 /* Return error values */ 668 error = filemap_check_wb_err(file->f_mapping, since); 669 switch (error) { 670 default: 671 break; 672 case -EDQUOT: 673 case -EFBIG: 674 case -ENOSPC: 675 nfs_wb_all(inode); 676 error = file_check_and_advance_wb_err(file); 677 if (error < 0) 678 result = error; 679 } 680 return result; 681 682 out_swapfile: 683 printk(KERN_INFO "NFS: attempt to write to active swap file!\n"); 684 return -ETXTBSY; 685 } 686 EXPORT_SYMBOL_GPL(nfs_file_write); 687 688 static int 689 do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) 690 { 691 struct inode *inode = filp->f_mapping->host; 692 int status = 0; 693 unsigned int saved_type = fl->fl_type; 694 695 /* Try local locking first */ 696 posix_test_lock(filp, fl); 697 if (fl->fl_type != F_UNLCK) { 698 /* found a conflict */ 699 goto out; 700 } 701 fl->fl_type = saved_type; 702 703 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) 704 goto out_noconflict; 705 706 if (is_local) 707 goto out_noconflict; 708 709 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 710 out: 711 return status; 712 out_noconflict: 713 fl->fl_type = F_UNLCK; 714 goto out; 715 } 716 717 static int 718 do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) 719 { 720 struct inode *inode = filp->f_mapping->host; 721 struct nfs_lock_context *l_ctx; 722 int status; 723 724 /* 725 * Flush all pending writes before doing anything 726 * with locks.. 727 */ 728 nfs_wb_all(inode); 729 730 l_ctx = nfs_get_lock_context(nfs_file_open_context(filp)); 731 if (!IS_ERR(l_ctx)) { 732 status = nfs_iocounter_wait(l_ctx); 733 nfs_put_lock_context(l_ctx); 734 /* NOTE: special case 735 * If we're signalled while cleaning up locks on process exit, we 736 * still need to complete the unlock. 737 */ 738 if (status < 0 && !(fl->fl_flags & FL_CLOSE)) 739 return status; 740 } 741 742 /* 743 * Use local locking if mounted with "-onolock" or with appropriate 744 * "-olocal_lock=" 745 */ 746 if (!is_local) 747 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 748 else 749 status = locks_lock_file_wait(filp, fl); 750 return status; 751 } 752 753 static int 754 do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) 755 { 756 struct inode *inode = filp->f_mapping->host; 757 int status; 758 759 /* 760 * Flush all pending writes before doing anything 761 * with locks.. 762 */ 763 status = nfs_sync_mapping(filp->f_mapping); 764 if (status != 0) 765 goto out; 766 767 /* 768 * Use local locking if mounted with "-onolock" or with appropriate 769 * "-olocal_lock=" 770 */ 771 if (!is_local) 772 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 773 else 774 status = locks_lock_file_wait(filp, fl); 775 if (status < 0) 776 goto out; 777 778 /* 779 * Invalidate cache to prevent missing any changes. If 780 * the file is mapped, clear the page cache as well so 781 * those mappings will be loaded. 782 * 783 * This makes locking act as a cache coherency point. 784 */ 785 nfs_sync_mapping(filp->f_mapping); 786 if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) { 787 nfs_zap_caches(inode); 788 if (mapping_mapped(filp->f_mapping)) 789 nfs_revalidate_mapping(inode, filp->f_mapping); 790 } 791 out: 792 return status; 793 } 794 795 /* 796 * Lock a (portion of) a file 797 */ 798 int nfs_lock(struct file *filp, int cmd, struct file_lock *fl) 799 { 800 struct inode *inode = filp->f_mapping->host; 801 int ret = -ENOLCK; 802 int is_local = 0; 803 804 dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n", 805 filp, fl->fl_type, fl->fl_flags, 806 (long long)fl->fl_start, (long long)fl->fl_end); 807 808 nfs_inc_stats(inode, NFSIOS_VFSLOCK); 809 810 if (fl->fl_flags & FL_RECLAIM) 811 return -ENOGRACE; 812 813 if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL) 814 is_local = 1; 815 816 if (NFS_PROTO(inode)->lock_check_bounds != NULL) { 817 ret = NFS_PROTO(inode)->lock_check_bounds(fl); 818 if (ret < 0) 819 goto out_err; 820 } 821 822 if (IS_GETLK(cmd)) 823 ret = do_getlk(filp, cmd, fl, is_local); 824 else if (fl->fl_type == F_UNLCK) 825 ret = do_unlk(filp, cmd, fl, is_local); 826 else 827 ret = do_setlk(filp, cmd, fl, is_local); 828 out_err: 829 return ret; 830 } 831 EXPORT_SYMBOL_GPL(nfs_lock); 832 833 /* 834 * Lock a (portion of) a file 835 */ 836 int nfs_flock(struct file *filp, int cmd, struct file_lock *fl) 837 { 838 struct inode *inode = filp->f_mapping->host; 839 int is_local = 0; 840 841 dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n", 842 filp, fl->fl_type, fl->fl_flags); 843 844 if (!(fl->fl_flags & FL_FLOCK)) 845 return -ENOLCK; 846 847 if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK) 848 is_local = 1; 849 850 /* We're simulating flock() locks using posix locks on the server */ 851 if (fl->fl_type == F_UNLCK) 852 return do_unlk(filp, cmd, fl, is_local); 853 return do_setlk(filp, cmd, fl, is_local); 854 } 855 EXPORT_SYMBOL_GPL(nfs_flock); 856 857 const struct file_operations nfs_file_operations = { 858 .llseek = nfs_file_llseek, 859 .read_iter = nfs_file_read, 860 .write_iter = nfs_file_write, 861 .mmap = nfs_file_mmap, 862 .open = nfs_file_open, 863 .flush = nfs_file_flush, 864 .release = nfs_file_release, 865 .fsync = nfs_file_fsync, 866 .lock = nfs_lock, 867 .flock = nfs_flock, 868 .splice_read = generic_file_splice_read, 869 .splice_write = iter_file_splice_write, 870 .check_flags = nfs_check_flags, 871 .setlease = simple_nosetlease, 872 }; 873 EXPORT_SYMBOL_GPL(nfs_file_operations); 874