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/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> 27 #include <linux/mm.h> 28 #include <linux/pagemap.h> 29 #include <linux/aio.h> 30 #include <linux/gfp.h> 31 #include <linux/swap.h> 32 33 #include <asm/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 /* Hack for future NFS swap support */ 48 #ifndef IS_SWAPFILE 49 # define IS_SWAPFILE(inode) (0) 50 #endif 51 52 int nfs_check_flags(int flags) 53 { 54 if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT)) 55 return -EINVAL; 56 57 return 0; 58 } 59 EXPORT_SYMBOL_GPL(nfs_check_flags); 60 61 /* 62 * Open file 63 */ 64 static int 65 nfs_file_open(struct inode *inode, struct file *filp) 66 { 67 int res; 68 69 dprintk("NFS: open file(%pD2)\n", filp); 70 71 nfs_inc_stats(inode, NFSIOS_VFSOPEN); 72 res = nfs_check_flags(filp->f_flags); 73 if (res) 74 return res; 75 76 res = nfs_open(inode, filp); 77 return res; 78 } 79 80 int 81 nfs_file_release(struct inode *inode, struct file *filp) 82 { 83 dprintk("NFS: release(%pD2)\n", filp); 84 85 nfs_inc_stats(inode, NFSIOS_VFSRELEASE); 86 return nfs_release(inode, filp); 87 } 88 EXPORT_SYMBOL_GPL(nfs_file_release); 89 90 /** 91 * nfs_revalidate_size - Revalidate the file size 92 * @inode - pointer to inode struct 93 * @file - pointer to struct file 94 * 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). 100 */ 101 static int nfs_revalidate_file_size(struct inode *inode, struct file *filp) 102 { 103 struct nfs_server *server = NFS_SERVER(inode); 104 struct nfs_inode *nfsi = NFS_I(inode); 105 106 if (nfs_have_delegated_attributes(inode)) 107 goto out_noreval; 108 109 if (filp->f_flags & O_DIRECT) 110 goto force_reval; 111 if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE) 112 goto force_reval; 113 if (nfs_attribute_timeout(inode)) 114 goto force_reval; 115 out_noreval: 116 return 0; 117 force_reval: 118 return __nfs_revalidate_inode(server, inode); 119 } 120 121 loff_t nfs_file_llseek(struct file *filp, loff_t offset, int whence) 122 { 123 dprintk("NFS: llseek file(%pD2, %lld, %d)\n", 124 filp, offset, whence); 125 126 /* 127 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate 128 * the cached file length 129 */ 130 if (whence != SEEK_SET && whence != SEEK_CUR) { 131 struct inode *inode = filp->f_mapping->host; 132 133 int retval = nfs_revalidate_file_size(inode, filp); 134 if (retval < 0) 135 return (loff_t)retval; 136 } 137 138 return generic_file_llseek(filp, offset, whence); 139 } 140 EXPORT_SYMBOL_GPL(nfs_file_llseek); 141 142 /* 143 * Flush all dirty pages, and check for write errors. 144 */ 145 int 146 nfs_file_flush(struct file *file, fl_owner_t id) 147 { 148 struct inode *inode = file_inode(file); 149 150 dprintk("NFS: flush(%pD2)\n", file); 151 152 nfs_inc_stats(inode, NFSIOS_VFSFLUSH); 153 if ((file->f_mode & FMODE_WRITE) == 0) 154 return 0; 155 156 /* 157 * If we're holding a write delegation, then just start the i/o 158 * but don't wait for completion (or send a commit). 159 */ 160 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE)) 161 return filemap_fdatawrite(file->f_mapping); 162 163 /* Flush writes to the server and return any errors */ 164 return vfs_fsync(file, 0); 165 } 166 EXPORT_SYMBOL_GPL(nfs_file_flush); 167 168 ssize_t 169 nfs_file_read(struct kiocb *iocb, struct iov_iter *to) 170 { 171 struct inode *inode = file_inode(iocb->ki_filp); 172 ssize_t result; 173 174 if (iocb->ki_filp->f_flags & O_DIRECT) 175 return nfs_file_direct_read(iocb, to, iocb->ki_pos); 176 177 dprintk("NFS: read(%pD2, %zu@%lu)\n", 178 iocb->ki_filp, 179 iov_iter_count(to), (unsigned long) iocb->ki_pos); 180 181 result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping); 182 if (!result) { 183 result = generic_file_read_iter(iocb, to); 184 if (result > 0) 185 nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result); 186 } 187 return result; 188 } 189 EXPORT_SYMBOL_GPL(nfs_file_read); 190 191 ssize_t 192 nfs_file_splice_read(struct file *filp, loff_t *ppos, 193 struct pipe_inode_info *pipe, size_t count, 194 unsigned int flags) 195 { 196 struct inode *inode = file_inode(filp); 197 ssize_t res; 198 199 dprintk("NFS: splice_read(%pD2, %lu@%Lu)\n", 200 filp, (unsigned long) count, (unsigned long long) *ppos); 201 202 res = nfs_revalidate_mapping(inode, filp->f_mapping); 203 if (!res) { 204 res = generic_file_splice_read(filp, ppos, pipe, count, flags); 205 if (res > 0) 206 nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res); 207 } 208 return res; 209 } 210 EXPORT_SYMBOL_GPL(nfs_file_splice_read); 211 212 int 213 nfs_file_mmap(struct file * file, struct vm_area_struct * vma) 214 { 215 struct inode *inode = file_inode(file); 216 int status; 217 218 dprintk("NFS: mmap(%pD2)\n", file); 219 220 /* Note: generic_file_mmap() returns ENOSYS on nommu systems 221 * so we call that before revalidating the mapping 222 */ 223 status = generic_file_mmap(file, vma); 224 if (!status) { 225 vma->vm_ops = &nfs_file_vm_ops; 226 status = nfs_revalidate_mapping(inode, file->f_mapping); 227 } 228 return status; 229 } 230 EXPORT_SYMBOL_GPL(nfs_file_mmap); 231 232 /* 233 * Flush any dirty pages for this process, and check for write errors. 234 * The return status from this call provides a reliable indication of 235 * whether any write errors occurred for this process. 236 * 237 * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to 238 * disk, but it retrieves and clears ctx->error after synching, despite 239 * the two being set at the same time in nfs_context_set_write_error(). 240 * This is because the former is used to notify the _next_ call to 241 * nfs_file_write() that a write error occurred, and hence cause it to 242 * fall back to doing a synchronous write. 243 */ 244 int 245 nfs_file_fsync_commit(struct file *file, loff_t start, loff_t end, int datasync) 246 { 247 struct nfs_open_context *ctx = nfs_file_open_context(file); 248 struct inode *inode = file_inode(file); 249 int have_error, do_resend, status; 250 int ret = 0; 251 252 dprintk("NFS: fsync file(%pD2) datasync %d\n", file, datasync); 253 254 nfs_inc_stats(inode, NFSIOS_VFSFSYNC); 255 do_resend = test_and_clear_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags); 256 have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags); 257 status = nfs_commit_inode(inode, FLUSH_SYNC); 258 have_error |= test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags); 259 if (have_error) { 260 ret = xchg(&ctx->error, 0); 261 if (ret) 262 goto out; 263 } 264 if (status < 0) { 265 ret = status; 266 goto out; 267 } 268 do_resend |= test_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags); 269 if (do_resend) 270 ret = -EAGAIN; 271 out: 272 return ret; 273 } 274 EXPORT_SYMBOL_GPL(nfs_file_fsync_commit); 275 276 static int 277 nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync) 278 { 279 int ret; 280 struct inode *inode = file_inode(file); 281 282 trace_nfs_fsync_enter(inode); 283 284 do { 285 ret = filemap_write_and_wait_range(inode->i_mapping, start, end); 286 if (ret != 0) 287 break; 288 mutex_lock(&inode->i_mutex); 289 ret = nfs_file_fsync_commit(file, start, end, datasync); 290 mutex_unlock(&inode->i_mutex); 291 /* 292 * If nfs_file_fsync_commit detected a server reboot, then 293 * resend all dirty pages that might have been covered by 294 * the NFS_CONTEXT_RESEND_WRITES flag 295 */ 296 start = 0; 297 end = LLONG_MAX; 298 } while (ret == -EAGAIN); 299 300 trace_nfs_fsync_exit(inode, ret); 301 return ret; 302 } 303 304 /* 305 * Decide whether a read/modify/write cycle may be more efficient 306 * then a modify/write/read cycle when writing to a page in the 307 * page cache. 308 * 309 * The modify/write/read cycle may occur if a page is read before 310 * being completely filled by the writer. In this situation, the 311 * page must be completely written to stable storage on the server 312 * before it can be refilled by reading in the page from the server. 313 * This can lead to expensive, small, FILE_SYNC mode writes being 314 * done. 315 * 316 * It may be more efficient to read the page first if the file is 317 * open for reading in addition to writing, the page is not marked 318 * as Uptodate, it is not dirty or waiting to be committed, 319 * indicating that it was previously allocated and then modified, 320 * that there were valid bytes of data in that range of the file, 321 * and that the new data won't completely replace the old data in 322 * that range of the file. 323 */ 324 static int nfs_want_read_modify_write(struct file *file, struct page *page, 325 loff_t pos, unsigned len) 326 { 327 unsigned int pglen = nfs_page_length(page); 328 unsigned int offset = pos & (PAGE_CACHE_SIZE - 1); 329 unsigned int end = offset + len; 330 331 if (pnfs_ld_read_whole_page(file->f_mapping->host)) { 332 if (!PageUptodate(page)) 333 return 1; 334 return 0; 335 } 336 337 if ((file->f_mode & FMODE_READ) && /* open for read? */ 338 !PageUptodate(page) && /* Uptodate? */ 339 !PagePrivate(page) && /* i/o request already? */ 340 pglen && /* valid bytes of file? */ 341 (end < pglen || offset)) /* replace all valid bytes? */ 342 return 1; 343 return 0; 344 } 345 346 /* 347 * This does the "real" work of the write. We must allocate and lock the 348 * page to be sent back to the generic routine, which then copies the 349 * data from user space. 350 * 351 * If the writer ends up delaying the write, the writer needs to 352 * increment the page use counts until he is done with the page. 353 */ 354 static int nfs_write_begin(struct file *file, struct address_space *mapping, 355 loff_t pos, unsigned len, unsigned flags, 356 struct page **pagep, void **fsdata) 357 { 358 int ret; 359 pgoff_t index = pos >> PAGE_CACHE_SHIFT; 360 struct page *page; 361 int once_thru = 0; 362 363 dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n", 364 file, mapping->host->i_ino, len, (long long) pos); 365 366 start: 367 /* 368 * Prevent starvation issues if someone is doing a consistency 369 * sync-to-disk 370 */ 371 ret = wait_on_bit_action(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING, 372 nfs_wait_bit_killable, TASK_KILLABLE); 373 if (ret) 374 return ret; 375 376 page = grab_cache_page_write_begin(mapping, index, flags); 377 if (!page) 378 return -ENOMEM; 379 *pagep = page; 380 381 ret = nfs_flush_incompatible(file, page); 382 if (ret) { 383 unlock_page(page); 384 page_cache_release(page); 385 } else if (!once_thru && 386 nfs_want_read_modify_write(file, page, pos, len)) { 387 once_thru = 1; 388 ret = nfs_readpage(file, page); 389 page_cache_release(page); 390 if (!ret) 391 goto start; 392 } 393 return ret; 394 } 395 396 static int nfs_write_end(struct file *file, struct address_space *mapping, 397 loff_t pos, unsigned len, unsigned copied, 398 struct page *page, void *fsdata) 399 { 400 unsigned offset = pos & (PAGE_CACHE_SIZE - 1); 401 struct nfs_open_context *ctx = nfs_file_open_context(file); 402 int status; 403 404 dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n", 405 file, mapping->host->i_ino, len, (long long) pos); 406 407 /* 408 * Zero any uninitialised parts of the page, and then mark the page 409 * as up to date if it turns out that we're extending the file. 410 */ 411 if (!PageUptodate(page)) { 412 unsigned pglen = nfs_page_length(page); 413 unsigned end = offset + len; 414 415 if (pglen == 0) { 416 zero_user_segments(page, 0, offset, 417 end, PAGE_CACHE_SIZE); 418 SetPageUptodate(page); 419 } else if (end >= pglen) { 420 zero_user_segment(page, end, PAGE_CACHE_SIZE); 421 if (offset == 0) 422 SetPageUptodate(page); 423 } else 424 zero_user_segment(page, pglen, PAGE_CACHE_SIZE); 425 } 426 427 status = nfs_updatepage(file, page, offset, copied); 428 429 unlock_page(page); 430 page_cache_release(page); 431 432 if (status < 0) 433 return status; 434 NFS_I(mapping->host)->write_io += copied; 435 436 if (nfs_ctx_key_to_expire(ctx)) { 437 status = nfs_wb_all(mapping->host); 438 if (status < 0) 439 return status; 440 } 441 442 return copied; 443 } 444 445 /* 446 * Partially or wholly invalidate a page 447 * - Release the private state associated with a page if undergoing complete 448 * page invalidation 449 * - Called if either PG_private or PG_fscache is set on the page 450 * - Caller holds page lock 451 */ 452 static void nfs_invalidate_page(struct page *page, unsigned int offset, 453 unsigned int length) 454 { 455 dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %u, %u)\n", 456 page, offset, length); 457 458 if (offset != 0 || length < PAGE_CACHE_SIZE) 459 return; 460 /* Cancel any unstarted writes on this page */ 461 nfs_wb_page_cancel(page_file_mapping(page)->host, page); 462 463 nfs_fscache_invalidate_page(page, page->mapping->host); 464 } 465 466 /* 467 * Attempt to release the private state associated with a page 468 * - Called if either PG_private or PG_fscache is set on the page 469 * - Caller holds page lock 470 * - Return true (may release page) or false (may not) 471 */ 472 static int nfs_release_page(struct page *page, gfp_t gfp) 473 { 474 struct address_space *mapping = page->mapping; 475 476 dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page); 477 478 /* Always try to initiate a 'commit' if relevant, but only 479 * wait for it if __GFP_WAIT is set. Even then, only wait 1 480 * second and only if the 'bdi' is not congested. 481 * Waiting indefinitely can cause deadlocks when the NFS 482 * server is on this machine, when a new TCP connection is 483 * needed and in other rare cases. There is no particular 484 * need to wait extensively here. A short wait has the 485 * benefit that someone else can worry about the freezer. 486 */ 487 if (mapping) { 488 struct nfs_server *nfss = NFS_SERVER(mapping->host); 489 nfs_commit_inode(mapping->host, 0); 490 if ((gfp & __GFP_WAIT) && 491 !bdi_write_congested(&nfss->backing_dev_info)) { 492 wait_on_page_bit_killable_timeout(page, PG_private, 493 HZ); 494 if (PagePrivate(page)) 495 set_bdi_congested(&nfss->backing_dev_info, 496 BLK_RW_ASYNC); 497 } 498 } 499 /* If PagePrivate() is set, then the page is not freeable */ 500 if (PagePrivate(page)) 501 return 0; 502 return nfs_fscache_release_page(page, gfp); 503 } 504 505 static void nfs_check_dirty_writeback(struct page *page, 506 bool *dirty, bool *writeback) 507 { 508 struct nfs_inode *nfsi; 509 struct address_space *mapping = page_file_mapping(page); 510 511 if (!mapping || PageSwapCache(page)) 512 return; 513 514 /* 515 * Check if an unstable page is currently being committed and 516 * if so, have the VM treat it as if the page is under writeback 517 * so it will not block due to pages that will shortly be freeable. 518 */ 519 nfsi = NFS_I(mapping->host); 520 if (test_bit(NFS_INO_COMMIT, &nfsi->flags)) { 521 *writeback = true; 522 return; 523 } 524 525 /* 526 * If PagePrivate() is set, then the page is not freeable and as the 527 * inode is not being committed, it's not going to be cleaned in the 528 * near future so treat it as dirty 529 */ 530 if (PagePrivate(page)) 531 *dirty = true; 532 } 533 534 /* 535 * Attempt to clear the private state associated with a page when an error 536 * occurs that requires the cached contents of an inode to be written back or 537 * destroyed 538 * - Called if either PG_private or fscache is set on the page 539 * - Caller holds page lock 540 * - Return 0 if successful, -error otherwise 541 */ 542 static int nfs_launder_page(struct page *page) 543 { 544 struct inode *inode = page_file_mapping(page)->host; 545 struct nfs_inode *nfsi = NFS_I(inode); 546 547 dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n", 548 inode->i_ino, (long long)page_offset(page)); 549 550 nfs_fscache_wait_on_page_write(nfsi, page); 551 return nfs_wb_page(inode, page); 552 } 553 554 #ifdef CONFIG_NFS_SWAP 555 static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file, 556 sector_t *span) 557 { 558 int ret; 559 struct rpc_clnt *clnt = NFS_CLIENT(file->f_mapping->host); 560 561 *span = sis->pages; 562 563 rcu_read_lock(); 564 ret = xs_swapper(rcu_dereference(clnt->cl_xprt), 1); 565 rcu_read_unlock(); 566 567 return ret; 568 } 569 570 static void nfs_swap_deactivate(struct file *file) 571 { 572 struct rpc_clnt *clnt = NFS_CLIENT(file->f_mapping->host); 573 574 rcu_read_lock(); 575 xs_swapper(rcu_dereference(clnt->cl_xprt), 0); 576 rcu_read_unlock(); 577 } 578 #endif 579 580 const struct address_space_operations nfs_file_aops = { 581 .readpage = nfs_readpage, 582 .readpages = nfs_readpages, 583 .set_page_dirty = __set_page_dirty_nobuffers, 584 .writepage = nfs_writepage, 585 .writepages = nfs_writepages, 586 .write_begin = nfs_write_begin, 587 .write_end = nfs_write_end, 588 .invalidatepage = nfs_invalidate_page, 589 .releasepage = nfs_release_page, 590 .direct_IO = nfs_direct_IO, 591 .migratepage = nfs_migrate_page, 592 .launder_page = nfs_launder_page, 593 .is_dirty_writeback = nfs_check_dirty_writeback, 594 .error_remove_page = generic_error_remove_page, 595 #ifdef CONFIG_NFS_SWAP 596 .swap_activate = nfs_swap_activate, 597 .swap_deactivate = nfs_swap_deactivate, 598 #endif 599 }; 600 601 /* 602 * Notification that a PTE pointing to an NFS page is about to be made 603 * writable, implying that someone is about to modify the page through a 604 * shared-writable mapping 605 */ 606 static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 607 { 608 struct page *page = vmf->page; 609 struct file *filp = vma->vm_file; 610 struct inode *inode = file_inode(filp); 611 unsigned pagelen; 612 int ret = VM_FAULT_NOPAGE; 613 struct address_space *mapping; 614 615 dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n", 616 filp, filp->f_mapping->host->i_ino, 617 (long long)page_offset(page)); 618 619 /* make sure the cache has finished storing the page */ 620 nfs_fscache_wait_on_page_write(NFS_I(inode), page); 621 622 lock_page(page); 623 mapping = page_file_mapping(page); 624 if (mapping != inode->i_mapping) 625 goto out_unlock; 626 627 wait_on_page_writeback(page); 628 629 pagelen = nfs_page_length(page); 630 if (pagelen == 0) 631 goto out_unlock; 632 633 ret = VM_FAULT_LOCKED; 634 if (nfs_flush_incompatible(filp, page) == 0 && 635 nfs_updatepage(filp, page, 0, pagelen) == 0) 636 goto out; 637 638 ret = VM_FAULT_SIGBUS; 639 out_unlock: 640 unlock_page(page); 641 out: 642 return ret; 643 } 644 645 static const struct vm_operations_struct nfs_file_vm_ops = { 646 .fault = filemap_fault, 647 .map_pages = filemap_map_pages, 648 .page_mkwrite = nfs_vm_page_mkwrite, 649 .remap_pages = generic_file_remap_pages, 650 }; 651 652 static int nfs_need_sync_write(struct file *filp, struct inode *inode) 653 { 654 struct nfs_open_context *ctx; 655 656 if (IS_SYNC(inode) || (filp->f_flags & O_DSYNC)) 657 return 1; 658 ctx = nfs_file_open_context(filp); 659 if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags) || 660 nfs_ctx_key_to_expire(ctx)) 661 return 1; 662 return 0; 663 } 664 665 ssize_t nfs_file_write(struct kiocb *iocb, struct iov_iter *from) 666 { 667 struct file *file = iocb->ki_filp; 668 struct inode *inode = file_inode(file); 669 unsigned long written = 0; 670 ssize_t result; 671 size_t count = iov_iter_count(from); 672 loff_t pos = iocb->ki_pos; 673 674 result = nfs_key_timeout_notify(file, inode); 675 if (result) 676 return result; 677 678 if (file->f_flags & O_DIRECT) 679 return nfs_file_direct_write(iocb, from, pos); 680 681 dprintk("NFS: write(%pD2, %zu@%Ld)\n", 682 file, count, (long long) pos); 683 684 result = -EBUSY; 685 if (IS_SWAPFILE(inode)) 686 goto out_swapfile; 687 /* 688 * O_APPEND implies that we must revalidate the file length. 689 */ 690 if (file->f_flags & O_APPEND) { 691 result = nfs_revalidate_file_size(inode, file); 692 if (result) 693 goto out; 694 } 695 696 result = count; 697 if (!count) 698 goto out; 699 700 result = generic_file_write_iter(iocb, from); 701 if (result > 0) 702 written = result; 703 704 /* Return error values for O_DSYNC and IS_SYNC() */ 705 if (result >= 0 && nfs_need_sync_write(file, inode)) { 706 int err = vfs_fsync(file, 0); 707 if (err < 0) 708 result = err; 709 } 710 if (result > 0) 711 nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written); 712 out: 713 return result; 714 715 out_swapfile: 716 printk(KERN_INFO "NFS: attempt to write to active swap file!\n"); 717 goto out; 718 } 719 EXPORT_SYMBOL_GPL(nfs_file_write); 720 721 static int 722 do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) 723 { 724 struct inode *inode = filp->f_mapping->host; 725 int status = 0; 726 unsigned int saved_type = fl->fl_type; 727 728 /* Try local locking first */ 729 posix_test_lock(filp, fl); 730 if (fl->fl_type != F_UNLCK) { 731 /* found a conflict */ 732 goto out; 733 } 734 fl->fl_type = saved_type; 735 736 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) 737 goto out_noconflict; 738 739 if (is_local) 740 goto out_noconflict; 741 742 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 743 out: 744 return status; 745 out_noconflict: 746 fl->fl_type = F_UNLCK; 747 goto out; 748 } 749 750 static int do_vfs_lock(struct file *file, struct file_lock *fl) 751 { 752 int res = 0; 753 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 754 case FL_POSIX: 755 res = posix_lock_file_wait(file, fl); 756 break; 757 case FL_FLOCK: 758 res = flock_lock_file_wait(file, fl); 759 break; 760 default: 761 BUG(); 762 } 763 return res; 764 } 765 766 static int 767 do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) 768 { 769 struct inode *inode = filp->f_mapping->host; 770 struct nfs_lock_context *l_ctx; 771 int status; 772 773 /* 774 * Flush all pending writes before doing anything 775 * with locks.. 776 */ 777 nfs_sync_mapping(filp->f_mapping); 778 779 l_ctx = nfs_get_lock_context(nfs_file_open_context(filp)); 780 if (!IS_ERR(l_ctx)) { 781 status = nfs_iocounter_wait(&l_ctx->io_count); 782 nfs_put_lock_context(l_ctx); 783 if (status < 0) 784 return status; 785 } 786 787 /* NOTE: special case 788 * If we're signalled while cleaning up locks on process exit, we 789 * still need to complete the unlock. 790 */ 791 /* 792 * Use local locking if mounted with "-onolock" or with appropriate 793 * "-olocal_lock=" 794 */ 795 if (!is_local) 796 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 797 else 798 status = do_vfs_lock(filp, fl); 799 return status; 800 } 801 802 static int 803 is_time_granular(struct timespec *ts) { 804 return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000)); 805 } 806 807 static int 808 do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) 809 { 810 struct inode *inode = filp->f_mapping->host; 811 int status; 812 813 /* 814 * Flush all pending writes before doing anything 815 * with locks.. 816 */ 817 status = nfs_sync_mapping(filp->f_mapping); 818 if (status != 0) 819 goto out; 820 821 /* 822 * Use local locking if mounted with "-onolock" or with appropriate 823 * "-olocal_lock=" 824 */ 825 if (!is_local) 826 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 827 else 828 status = do_vfs_lock(filp, fl); 829 if (status < 0) 830 goto out; 831 832 /* 833 * Revalidate the cache if the server has time stamps granular 834 * enough to detect subsecond changes. Otherwise, clear the 835 * cache to prevent missing any changes. 836 * 837 * This makes locking act as a cache coherency point. 838 */ 839 nfs_sync_mapping(filp->f_mapping); 840 if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) { 841 if (is_time_granular(&NFS_SERVER(inode)->time_delta)) 842 __nfs_revalidate_inode(NFS_SERVER(inode), inode); 843 else 844 nfs_zap_caches(inode); 845 } 846 out: 847 return status; 848 } 849 850 /* 851 * Lock a (portion of) a file 852 */ 853 int nfs_lock(struct file *filp, int cmd, struct file_lock *fl) 854 { 855 struct inode *inode = filp->f_mapping->host; 856 int ret = -ENOLCK; 857 int is_local = 0; 858 859 dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n", 860 filp, fl->fl_type, fl->fl_flags, 861 (long long)fl->fl_start, (long long)fl->fl_end); 862 863 nfs_inc_stats(inode, NFSIOS_VFSLOCK); 864 865 /* No mandatory locks over NFS */ 866 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 867 goto out_err; 868 869 if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL) 870 is_local = 1; 871 872 if (NFS_PROTO(inode)->lock_check_bounds != NULL) { 873 ret = NFS_PROTO(inode)->lock_check_bounds(fl); 874 if (ret < 0) 875 goto out_err; 876 } 877 878 if (IS_GETLK(cmd)) 879 ret = do_getlk(filp, cmd, fl, is_local); 880 else if (fl->fl_type == F_UNLCK) 881 ret = do_unlk(filp, cmd, fl, is_local); 882 else 883 ret = do_setlk(filp, cmd, fl, is_local); 884 out_err: 885 return ret; 886 } 887 EXPORT_SYMBOL_GPL(nfs_lock); 888 889 /* 890 * Lock a (portion of) a file 891 */ 892 int nfs_flock(struct file *filp, int cmd, struct file_lock *fl) 893 { 894 struct inode *inode = filp->f_mapping->host; 895 int is_local = 0; 896 897 dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n", 898 filp, fl->fl_type, fl->fl_flags); 899 900 if (!(fl->fl_flags & FL_FLOCK)) 901 return -ENOLCK; 902 903 /* 904 * The NFSv4 protocol doesn't support LOCK_MAND, which is not part of 905 * any standard. In principle we might be able to support LOCK_MAND 906 * on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the 907 * NFS code is not set up for it. 908 */ 909 if (fl->fl_type & LOCK_MAND) 910 return -EINVAL; 911 912 if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK) 913 is_local = 1; 914 915 /* We're simulating flock() locks using posix locks on the server */ 916 if (fl->fl_type == F_UNLCK) 917 return do_unlk(filp, cmd, fl, is_local); 918 return do_setlk(filp, cmd, fl, is_local); 919 } 920 EXPORT_SYMBOL_GPL(nfs_flock); 921 922 const struct file_operations nfs_file_operations = { 923 .llseek = nfs_file_llseek, 924 .read = new_sync_read, 925 .write = new_sync_write, 926 .read_iter = nfs_file_read, 927 .write_iter = nfs_file_write, 928 .mmap = nfs_file_mmap, 929 .open = nfs_file_open, 930 .flush = nfs_file_flush, 931 .release = nfs_file_release, 932 .fsync = nfs_file_fsync, 933 .lock = nfs_lock, 934 .flock = nfs_flock, 935 .splice_read = nfs_file_splice_read, 936 .splice_write = iter_file_splice_write, 937 .check_flags = nfs_check_flags, 938 .setlease = simple_nosetlease, 939 }; 940 EXPORT_SYMBOL_GPL(nfs_file_operations); 941