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/slab.h> 28 #include <linux/pagemap.h> 29 #include <linux/smp_lock.h> 30 #include <linux/aio.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 39 #define NFSDBG_FACILITY NFSDBG_FILE 40 41 static int nfs_file_open(struct inode *, struct file *); 42 static int nfs_file_release(struct inode *, struct file *); 43 static loff_t nfs_file_llseek(struct file *file, loff_t offset, int origin); 44 static int nfs_file_mmap(struct file *, struct vm_area_struct *); 45 static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos, 46 struct pipe_inode_info *pipe, 47 size_t count, unsigned int flags); 48 static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov, 49 unsigned long nr_segs, loff_t pos); 50 static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov, 51 unsigned long nr_segs, loff_t pos); 52 static int nfs_file_flush(struct file *, fl_owner_t id); 53 static int nfs_file_fsync(struct file *, struct dentry *dentry, int datasync); 54 static int nfs_check_flags(int flags); 55 static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl); 56 static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl); 57 static int nfs_setlease(struct file *file, long arg, struct file_lock **fl); 58 59 static struct vm_operations_struct nfs_file_vm_ops; 60 61 const struct file_operations nfs_file_operations = { 62 .llseek = nfs_file_llseek, 63 .read = do_sync_read, 64 .write = do_sync_write, 65 .aio_read = nfs_file_read, 66 .aio_write = nfs_file_write, 67 #ifdef CONFIG_MMU 68 .mmap = nfs_file_mmap, 69 #else 70 .mmap = generic_file_mmap, 71 #endif 72 .open = nfs_file_open, 73 .flush = nfs_file_flush, 74 .release = nfs_file_release, 75 .fsync = nfs_file_fsync, 76 .lock = nfs_lock, 77 .flock = nfs_flock, 78 .splice_read = nfs_file_splice_read, 79 .check_flags = nfs_check_flags, 80 .setlease = nfs_setlease, 81 }; 82 83 const struct inode_operations nfs_file_inode_operations = { 84 .permission = nfs_permission, 85 .getattr = nfs_getattr, 86 .setattr = nfs_setattr, 87 }; 88 89 #ifdef CONFIG_NFS_V3 90 const struct inode_operations nfs3_file_inode_operations = { 91 .permission = nfs_permission, 92 .getattr = nfs_getattr, 93 .setattr = nfs_setattr, 94 .listxattr = nfs3_listxattr, 95 .getxattr = nfs3_getxattr, 96 .setxattr = nfs3_setxattr, 97 .removexattr = nfs3_removexattr, 98 }; 99 #endif /* CONFIG_NFS_v3 */ 100 101 /* Hack for future NFS swap support */ 102 #ifndef IS_SWAPFILE 103 # define IS_SWAPFILE(inode) (0) 104 #endif 105 106 static int nfs_check_flags(int flags) 107 { 108 if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT)) 109 return -EINVAL; 110 111 return 0; 112 } 113 114 /* 115 * Open file 116 */ 117 static int 118 nfs_file_open(struct inode *inode, struct file *filp) 119 { 120 int res; 121 122 res = nfs_check_flags(filp->f_flags); 123 if (res) 124 return res; 125 126 nfs_inc_stats(inode, NFSIOS_VFSOPEN); 127 lock_kernel(); 128 res = NFS_PROTO(inode)->file_open(inode, filp); 129 unlock_kernel(); 130 return res; 131 } 132 133 static int 134 nfs_file_release(struct inode *inode, struct file *filp) 135 { 136 /* Ensure that dirty pages are flushed out with the right creds */ 137 if (filp->f_mode & FMODE_WRITE) 138 nfs_wb_all(filp->f_path.dentry->d_inode); 139 nfs_inc_stats(inode, NFSIOS_VFSRELEASE); 140 return NFS_PROTO(inode)->file_release(inode, filp); 141 } 142 143 /** 144 * nfs_revalidate_size - Revalidate the file size 145 * @inode - pointer to inode struct 146 * @file - pointer to struct file 147 * 148 * Revalidates the file length. This is basically a wrapper around 149 * nfs_revalidate_inode() that takes into account the fact that we may 150 * have cached writes (in which case we don't care about the server's 151 * idea of what the file length is), or O_DIRECT (in which case we 152 * shouldn't trust the cache). 153 */ 154 static int nfs_revalidate_file_size(struct inode *inode, struct file *filp) 155 { 156 struct nfs_server *server = NFS_SERVER(inode); 157 struct nfs_inode *nfsi = NFS_I(inode); 158 159 if (server->flags & NFS_MOUNT_NOAC) 160 goto force_reval; 161 if (filp->f_flags & O_DIRECT) 162 goto force_reval; 163 if (nfsi->npages != 0) 164 return 0; 165 if (!(nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE) && !nfs_attribute_timeout(inode)) 166 return 0; 167 force_reval: 168 return __nfs_revalidate_inode(server, inode); 169 } 170 171 static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin) 172 { 173 dfprintk(VFS, "NFS: llseek file(%s/%s, %lld, %d)\n", 174 filp->f_path.dentry->d_parent->d_name.name, 175 filp->f_path.dentry->d_name.name, 176 offset, origin); 177 178 /* origin == SEEK_END => we must revalidate the cached file length */ 179 if (origin == SEEK_END) { 180 struct inode *inode = filp->f_mapping->host; 181 int retval = nfs_revalidate_file_size(inode, filp); 182 if (retval < 0) 183 return (loff_t)retval; 184 } 185 return remote_llseek(filp, offset, origin); 186 } 187 188 /* 189 * Helper for nfs_file_flush() and nfs_file_fsync() 190 * 191 * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to 192 * disk, but it retrieves and clears ctx->error after synching, despite 193 * the two being set at the same time in nfs_context_set_write_error(). 194 * This is because the former is used to notify the _next_ call to 195 * nfs_file_write() that a write error occured, and hence cause it to 196 * fall back to doing a synchronous write. 197 */ 198 static int nfs_do_fsync(struct nfs_open_context *ctx, struct inode *inode) 199 { 200 int have_error, status; 201 int ret = 0; 202 203 have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags); 204 status = nfs_wb_all(inode); 205 have_error |= test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags); 206 if (have_error) 207 ret = xchg(&ctx->error, 0); 208 if (!ret) 209 ret = status; 210 return ret; 211 } 212 213 /* 214 * Flush all dirty pages, and check for write errors. 215 * 216 */ 217 static int 218 nfs_file_flush(struct file *file, fl_owner_t id) 219 { 220 struct nfs_open_context *ctx = nfs_file_open_context(file); 221 struct inode *inode = file->f_path.dentry->d_inode; 222 int status; 223 224 dfprintk(VFS, "nfs: flush(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino); 225 226 if ((file->f_mode & FMODE_WRITE) == 0) 227 return 0; 228 nfs_inc_stats(inode, NFSIOS_VFSFLUSH); 229 230 /* Ensure that data+attribute caches are up to date after close() */ 231 status = nfs_do_fsync(ctx, inode); 232 if (!status) 233 nfs_revalidate_inode(NFS_SERVER(inode), inode); 234 return status; 235 } 236 237 static ssize_t 238 nfs_file_read(struct kiocb *iocb, const struct iovec *iov, 239 unsigned long nr_segs, loff_t pos) 240 { 241 struct dentry * dentry = iocb->ki_filp->f_path.dentry; 242 struct inode * inode = dentry->d_inode; 243 ssize_t result; 244 size_t count = iov_length(iov, nr_segs); 245 246 if (iocb->ki_filp->f_flags & O_DIRECT) 247 return nfs_file_direct_read(iocb, iov, nr_segs, pos); 248 249 dfprintk(VFS, "nfs: read(%s/%s, %lu@%lu)\n", 250 dentry->d_parent->d_name.name, dentry->d_name.name, 251 (unsigned long) count, (unsigned long) pos); 252 253 result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping); 254 nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, count); 255 if (!result) 256 result = generic_file_aio_read(iocb, iov, nr_segs, pos); 257 return result; 258 } 259 260 static ssize_t 261 nfs_file_splice_read(struct file *filp, loff_t *ppos, 262 struct pipe_inode_info *pipe, size_t count, 263 unsigned int flags) 264 { 265 struct dentry *dentry = filp->f_path.dentry; 266 struct inode *inode = dentry->d_inode; 267 ssize_t res; 268 269 dfprintk(VFS, "nfs: splice_read(%s/%s, %lu@%Lu)\n", 270 dentry->d_parent->d_name.name, dentry->d_name.name, 271 (unsigned long) count, (unsigned long long) *ppos); 272 273 res = nfs_revalidate_mapping(inode, filp->f_mapping); 274 if (!res) 275 res = generic_file_splice_read(filp, ppos, pipe, count, flags); 276 return res; 277 } 278 279 static int 280 nfs_file_mmap(struct file * file, struct vm_area_struct * vma) 281 { 282 struct dentry *dentry = file->f_path.dentry; 283 struct inode *inode = dentry->d_inode; 284 int status; 285 286 dfprintk(VFS, "nfs: mmap(%s/%s)\n", 287 dentry->d_parent->d_name.name, dentry->d_name.name); 288 289 status = nfs_revalidate_mapping(inode, file->f_mapping); 290 if (!status) { 291 vma->vm_ops = &nfs_file_vm_ops; 292 vma->vm_flags |= VM_CAN_NONLINEAR; 293 file_accessed(file); 294 } 295 return status; 296 } 297 298 /* 299 * Flush any dirty pages for this process, and check for write errors. 300 * The return status from this call provides a reliable indication of 301 * whether any write errors occurred for this process. 302 */ 303 static int 304 nfs_file_fsync(struct file *file, struct dentry *dentry, int datasync) 305 { 306 struct nfs_open_context *ctx = nfs_file_open_context(file); 307 struct inode *inode = dentry->d_inode; 308 309 dfprintk(VFS, "NFS: fsync file(%s/%s) datasync %d\n", 310 dentry->d_parent->d_name.name, dentry->d_name.name, 311 datasync); 312 313 nfs_inc_stats(inode, NFSIOS_VFSFSYNC); 314 return nfs_do_fsync(ctx, inode); 315 } 316 317 /* 318 * This does the "real" work of the write. We must allocate and lock the 319 * page to be sent back to the generic routine, which then copies the 320 * data from user space. 321 * 322 * If the writer ends up delaying the write, the writer needs to 323 * increment the page use counts until he is done with the page. 324 */ 325 static int nfs_write_begin(struct file *file, struct address_space *mapping, 326 loff_t pos, unsigned len, unsigned flags, 327 struct page **pagep, void **fsdata) 328 { 329 int ret; 330 pgoff_t index; 331 struct page *page; 332 index = pos >> PAGE_CACHE_SHIFT; 333 334 page = __grab_cache_page(mapping, index); 335 if (!page) 336 return -ENOMEM; 337 *pagep = page; 338 339 ret = nfs_flush_incompatible(file, page); 340 if (ret) { 341 unlock_page(page); 342 page_cache_release(page); 343 } 344 return ret; 345 } 346 347 static int nfs_write_end(struct file *file, struct address_space *mapping, 348 loff_t pos, unsigned len, unsigned copied, 349 struct page *page, void *fsdata) 350 { 351 unsigned offset = pos & (PAGE_CACHE_SIZE - 1); 352 int status; 353 354 /* 355 * Zero any uninitialised parts of the page, and then mark the page 356 * as up to date if it turns out that we're extending the file. 357 */ 358 if (!PageUptodate(page)) { 359 unsigned pglen = nfs_page_length(page); 360 unsigned end = offset + len; 361 362 if (pglen == 0) { 363 zero_user_segments(page, 0, offset, 364 end, PAGE_CACHE_SIZE); 365 SetPageUptodate(page); 366 } else if (end >= pglen) { 367 zero_user_segment(page, end, PAGE_CACHE_SIZE); 368 if (offset == 0) 369 SetPageUptodate(page); 370 } else 371 zero_user_segment(page, pglen, PAGE_CACHE_SIZE); 372 } 373 374 lock_kernel(); 375 status = nfs_updatepage(file, page, offset, copied); 376 unlock_kernel(); 377 378 unlock_page(page); 379 page_cache_release(page); 380 381 if (status < 0) 382 return status; 383 return copied; 384 } 385 386 static void nfs_invalidate_page(struct page *page, unsigned long offset) 387 { 388 if (offset != 0) 389 return; 390 /* Cancel any unstarted writes on this page */ 391 nfs_wb_page_cancel(page->mapping->host, page); 392 } 393 394 static int nfs_release_page(struct page *page, gfp_t gfp) 395 { 396 /* If PagePrivate() is set, then the page is not freeable */ 397 return 0; 398 } 399 400 static int nfs_launder_page(struct page *page) 401 { 402 return nfs_wb_page(page->mapping->host, page); 403 } 404 405 const struct address_space_operations nfs_file_aops = { 406 .readpage = nfs_readpage, 407 .readpages = nfs_readpages, 408 .set_page_dirty = __set_page_dirty_nobuffers, 409 .writepage = nfs_writepage, 410 .writepages = nfs_writepages, 411 .write_begin = nfs_write_begin, 412 .write_end = nfs_write_end, 413 .invalidatepage = nfs_invalidate_page, 414 .releasepage = nfs_release_page, 415 .direct_IO = nfs_direct_IO, 416 .launder_page = nfs_launder_page, 417 }; 418 419 static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct page *page) 420 { 421 struct file *filp = vma->vm_file; 422 unsigned pagelen; 423 int ret = -EINVAL; 424 struct address_space *mapping; 425 426 lock_page(page); 427 mapping = page->mapping; 428 if (mapping != vma->vm_file->f_path.dentry->d_inode->i_mapping) 429 goto out_unlock; 430 431 ret = 0; 432 pagelen = nfs_page_length(page); 433 if (pagelen == 0) 434 goto out_unlock; 435 436 ret = nfs_flush_incompatible(filp, page); 437 if (ret != 0) 438 goto out_unlock; 439 440 ret = nfs_updatepage(filp, page, 0, pagelen); 441 if (ret == 0) 442 ret = pagelen; 443 out_unlock: 444 unlock_page(page); 445 return ret; 446 } 447 448 static struct vm_operations_struct nfs_file_vm_ops = { 449 .fault = filemap_fault, 450 .page_mkwrite = nfs_vm_page_mkwrite, 451 }; 452 453 static int nfs_need_sync_write(struct file *filp, struct inode *inode) 454 { 455 struct nfs_open_context *ctx; 456 457 if (IS_SYNC(inode) || (filp->f_flags & O_SYNC)) 458 return 1; 459 ctx = nfs_file_open_context(filp); 460 if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags)) 461 return 1; 462 return 0; 463 } 464 465 static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov, 466 unsigned long nr_segs, loff_t pos) 467 { 468 struct dentry * dentry = iocb->ki_filp->f_path.dentry; 469 struct inode * inode = dentry->d_inode; 470 ssize_t result; 471 size_t count = iov_length(iov, nr_segs); 472 473 if (iocb->ki_filp->f_flags & O_DIRECT) 474 return nfs_file_direct_write(iocb, iov, nr_segs, pos); 475 476 dfprintk(VFS, "nfs: write(%s/%s(%ld), %lu@%Ld)\n", 477 dentry->d_parent->d_name.name, dentry->d_name.name, 478 inode->i_ino, (unsigned long) count, (long long) pos); 479 480 result = -EBUSY; 481 if (IS_SWAPFILE(inode)) 482 goto out_swapfile; 483 /* 484 * O_APPEND implies that we must revalidate the file length. 485 */ 486 if (iocb->ki_filp->f_flags & O_APPEND) { 487 result = nfs_revalidate_file_size(inode, iocb->ki_filp); 488 if (result) 489 goto out; 490 } 491 492 result = count; 493 if (!count) 494 goto out; 495 496 nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, count); 497 result = generic_file_aio_write(iocb, iov, nr_segs, pos); 498 /* Return error values for O_SYNC and IS_SYNC() */ 499 if (result >= 0 && nfs_need_sync_write(iocb->ki_filp, inode)) { 500 int err = nfs_do_fsync(nfs_file_open_context(iocb->ki_filp), inode); 501 if (err < 0) 502 result = err; 503 } 504 out: 505 return result; 506 507 out_swapfile: 508 printk(KERN_INFO "NFS: attempt to write to active swap file!\n"); 509 goto out; 510 } 511 512 static int do_getlk(struct file *filp, int cmd, struct file_lock *fl) 513 { 514 struct inode *inode = filp->f_mapping->host; 515 int status = 0; 516 517 lock_kernel(); 518 /* Try local locking first */ 519 posix_test_lock(filp, fl); 520 if (fl->fl_type != F_UNLCK) { 521 /* found a conflict */ 522 goto out; 523 } 524 525 if (nfs_have_delegation(inode, FMODE_READ)) 526 goto out_noconflict; 527 528 if (NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM) 529 goto out_noconflict; 530 531 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 532 out: 533 unlock_kernel(); 534 return status; 535 out_noconflict: 536 fl->fl_type = F_UNLCK; 537 goto out; 538 } 539 540 static int do_vfs_lock(struct file *file, struct file_lock *fl) 541 { 542 int res = 0; 543 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 544 case FL_POSIX: 545 res = posix_lock_file_wait(file, fl); 546 break; 547 case FL_FLOCK: 548 res = flock_lock_file_wait(file, fl); 549 break; 550 default: 551 BUG(); 552 } 553 if (res < 0) 554 dprintk(KERN_WARNING "%s: VFS is out of sync with lock manager" 555 " - error %d!\n", 556 __func__, res); 557 return res; 558 } 559 560 static int do_unlk(struct file *filp, int cmd, struct file_lock *fl) 561 { 562 struct inode *inode = filp->f_mapping->host; 563 int status; 564 565 /* 566 * Flush all pending writes before doing anything 567 * with locks.. 568 */ 569 nfs_sync_mapping(filp->f_mapping); 570 571 /* NOTE: special case 572 * If we're signalled while cleaning up locks on process exit, we 573 * still need to complete the unlock. 574 */ 575 lock_kernel(); 576 /* Use local locking if mounted with "-onolock" */ 577 if (!(NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM)) 578 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 579 else 580 status = do_vfs_lock(filp, fl); 581 unlock_kernel(); 582 return status; 583 } 584 585 static int do_setlk(struct file *filp, int cmd, struct file_lock *fl) 586 { 587 struct inode *inode = filp->f_mapping->host; 588 int status; 589 590 /* 591 * Flush all pending writes before doing anything 592 * with locks.. 593 */ 594 status = nfs_sync_mapping(filp->f_mapping); 595 if (status != 0) 596 goto out; 597 598 lock_kernel(); 599 /* Use local locking if mounted with "-onolock" */ 600 if (!(NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM)) 601 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 602 else 603 status = do_vfs_lock(filp, fl); 604 unlock_kernel(); 605 if (status < 0) 606 goto out; 607 /* 608 * Make sure we clear the cache whenever we try to get the lock. 609 * This makes locking act as a cache coherency point. 610 */ 611 nfs_sync_mapping(filp->f_mapping); 612 if (!nfs_have_delegation(inode, FMODE_READ)) 613 nfs_zap_caches(inode); 614 out: 615 return status; 616 } 617 618 /* 619 * Lock a (portion of) a file 620 */ 621 static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl) 622 { 623 struct inode * inode = filp->f_mapping->host; 624 int ret = -ENOLCK; 625 626 dprintk("NFS: nfs_lock(f=%s/%ld, t=%x, fl=%x, r=%Ld:%Ld)\n", 627 inode->i_sb->s_id, inode->i_ino, 628 fl->fl_type, fl->fl_flags, 629 (long long)fl->fl_start, (long long)fl->fl_end); 630 nfs_inc_stats(inode, NFSIOS_VFSLOCK); 631 632 /* No mandatory locks over NFS */ 633 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 634 goto out_err; 635 636 if (NFS_PROTO(inode)->lock_check_bounds != NULL) { 637 ret = NFS_PROTO(inode)->lock_check_bounds(fl); 638 if (ret < 0) 639 goto out_err; 640 } 641 642 if (IS_GETLK(cmd)) 643 ret = do_getlk(filp, cmd, fl); 644 else if (fl->fl_type == F_UNLCK) 645 ret = do_unlk(filp, cmd, fl); 646 else 647 ret = do_setlk(filp, cmd, fl); 648 out_err: 649 return ret; 650 } 651 652 /* 653 * Lock a (portion of) a file 654 */ 655 static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl) 656 { 657 dprintk("NFS: nfs_flock(f=%s/%ld, t=%x, fl=%x)\n", 658 filp->f_path.dentry->d_inode->i_sb->s_id, 659 filp->f_path.dentry->d_inode->i_ino, 660 fl->fl_type, fl->fl_flags); 661 662 /* 663 * No BSD flocks over NFS allowed. 664 * Note: we could try to fake a POSIX lock request here by 665 * using ((u32) filp | 0x80000000) or some such as the pid. 666 * Not sure whether that would be unique, though, or whether 667 * that would break in other places. 668 */ 669 if (!(fl->fl_flags & FL_FLOCK)) 670 return -ENOLCK; 671 672 /* We're simulating flock() locks using posix locks on the server */ 673 fl->fl_owner = (fl_owner_t)filp; 674 fl->fl_start = 0; 675 fl->fl_end = OFFSET_MAX; 676 677 if (fl->fl_type == F_UNLCK) 678 return do_unlk(filp, cmd, fl); 679 return do_setlk(filp, cmd, fl); 680 } 681 682 static int nfs_setlease(struct file *file, long arg, struct file_lock **fl) 683 { 684 /* 685 * There is no protocol support for leases, so we have no way 686 * to implement them correctly in the face of opens by other 687 * clients. 688 */ 689 return -EINVAL; 690 } 691