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