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