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 31 #include <asm/uaccess.h> 32 #include <asm/system.h> 33 34 #include "delegation.h" 35 #include "iostat.h" 36 37 #define NFSDBG_FACILITY NFSDBG_FILE 38 39 static int nfs_file_open(struct inode *, struct file *); 40 static int nfs_file_release(struct inode *, struct file *); 41 static loff_t nfs_file_llseek(struct file *file, loff_t offset, int origin); 42 static int nfs_file_mmap(struct file *, struct vm_area_struct *); 43 static ssize_t nfs_file_sendfile(struct file *, loff_t *, size_t, read_actor_t, void *); 44 static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov, 45 unsigned long nr_segs, loff_t pos); 46 static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov, 47 unsigned long nr_segs, loff_t pos); 48 static int nfs_file_flush(struct file *, fl_owner_t id); 49 static int nfs_fsync(struct file *, struct dentry *dentry, int datasync); 50 static int nfs_check_flags(int flags); 51 static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl); 52 static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl); 53 54 const struct file_operations nfs_file_operations = { 55 .llseek = nfs_file_llseek, 56 .read = do_sync_read, 57 .write = do_sync_write, 58 .aio_read = nfs_file_read, 59 .aio_write = nfs_file_write, 60 .mmap = nfs_file_mmap, 61 .open = nfs_file_open, 62 .flush = nfs_file_flush, 63 .release = nfs_file_release, 64 .fsync = nfs_fsync, 65 .lock = nfs_lock, 66 .flock = nfs_flock, 67 .sendfile = nfs_file_sendfile, 68 .check_flags = nfs_check_flags, 69 }; 70 71 const struct inode_operations nfs_file_inode_operations = { 72 .permission = nfs_permission, 73 .getattr = nfs_getattr, 74 .setattr = nfs_setattr, 75 }; 76 77 #ifdef CONFIG_NFS_V3 78 const struct inode_operations nfs3_file_inode_operations = { 79 .permission = nfs_permission, 80 .getattr = nfs_getattr, 81 .setattr = nfs_setattr, 82 .listxattr = nfs3_listxattr, 83 .getxattr = nfs3_getxattr, 84 .setxattr = nfs3_setxattr, 85 .removexattr = nfs3_removexattr, 86 }; 87 #endif /* CONFIG_NFS_v3 */ 88 89 /* Hack for future NFS swap support */ 90 #ifndef IS_SWAPFILE 91 # define IS_SWAPFILE(inode) (0) 92 #endif 93 94 static int nfs_check_flags(int flags) 95 { 96 if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT)) 97 return -EINVAL; 98 99 return 0; 100 } 101 102 /* 103 * Open file 104 */ 105 static int 106 nfs_file_open(struct inode *inode, struct file *filp) 107 { 108 int res; 109 110 res = nfs_check_flags(filp->f_flags); 111 if (res) 112 return res; 113 114 nfs_inc_stats(inode, NFSIOS_VFSOPEN); 115 lock_kernel(); 116 res = NFS_PROTO(inode)->file_open(inode, filp); 117 unlock_kernel(); 118 return res; 119 } 120 121 static int 122 nfs_file_release(struct inode *inode, struct file *filp) 123 { 124 /* Ensure that dirty pages are flushed out with the right creds */ 125 if (filp->f_mode & FMODE_WRITE) 126 filemap_fdatawrite(filp->f_mapping); 127 nfs_inc_stats(inode, NFSIOS_VFSRELEASE); 128 return NFS_PROTO(inode)->file_release(inode, filp); 129 } 130 131 /** 132 * nfs_revalidate_size - Revalidate the file size 133 * @inode - pointer to inode struct 134 * @file - pointer to struct file 135 * 136 * Revalidates the file length. This is basically a wrapper around 137 * nfs_revalidate_inode() that takes into account the fact that we may 138 * have cached writes (in which case we don't care about the server's 139 * idea of what the file length is), or O_DIRECT (in which case we 140 * shouldn't trust the cache). 141 */ 142 static int nfs_revalidate_file_size(struct inode *inode, struct file *filp) 143 { 144 struct nfs_server *server = NFS_SERVER(inode); 145 struct nfs_inode *nfsi = NFS_I(inode); 146 147 if (server->flags & NFS_MOUNT_NOAC) 148 goto force_reval; 149 if (filp->f_flags & O_DIRECT) 150 goto force_reval; 151 if (nfsi->npages != 0) 152 return 0; 153 if (!(nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE) && !nfs_attribute_timeout(inode)) 154 return 0; 155 force_reval: 156 return __nfs_revalidate_inode(server, inode); 157 } 158 159 static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin) 160 { 161 /* origin == SEEK_END => we must revalidate the cached file length */ 162 if (origin == SEEK_END) { 163 struct inode *inode = filp->f_mapping->host; 164 int retval = nfs_revalidate_file_size(inode, filp); 165 if (retval < 0) 166 return (loff_t)retval; 167 } 168 return remote_llseek(filp, offset, origin); 169 } 170 171 /* 172 * Flush all dirty pages, and check for write errors. 173 * 174 */ 175 static int 176 nfs_file_flush(struct file *file, fl_owner_t id) 177 { 178 struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data; 179 struct inode *inode = file->f_path.dentry->d_inode; 180 int status; 181 182 dfprintk(VFS, "nfs: flush(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino); 183 184 if ((file->f_mode & FMODE_WRITE) == 0) 185 return 0; 186 nfs_inc_stats(inode, NFSIOS_VFSFLUSH); 187 lock_kernel(); 188 /* Ensure that data+attribute caches are up to date after close() */ 189 status = nfs_wb_all(inode); 190 if (!status) { 191 status = ctx->error; 192 ctx->error = 0; 193 if (!status) 194 nfs_revalidate_inode(NFS_SERVER(inode), inode); 195 } 196 unlock_kernel(); 197 return status; 198 } 199 200 static ssize_t 201 nfs_file_read(struct kiocb *iocb, const struct iovec *iov, 202 unsigned long nr_segs, loff_t pos) 203 { 204 struct dentry * dentry = iocb->ki_filp->f_path.dentry; 205 struct inode * inode = dentry->d_inode; 206 ssize_t result; 207 size_t count = iov_length(iov, nr_segs); 208 209 #ifdef CONFIG_NFS_DIRECTIO 210 if (iocb->ki_filp->f_flags & O_DIRECT) 211 return nfs_file_direct_read(iocb, iov, nr_segs, pos); 212 #endif 213 214 dfprintk(VFS, "nfs: read(%s/%s, %lu@%lu)\n", 215 dentry->d_parent->d_name.name, dentry->d_name.name, 216 (unsigned long) count, (unsigned long) pos); 217 218 result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping); 219 nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, count); 220 if (!result) 221 result = generic_file_aio_read(iocb, iov, nr_segs, pos); 222 return result; 223 } 224 225 static ssize_t 226 nfs_file_sendfile(struct file *filp, loff_t *ppos, size_t count, 227 read_actor_t actor, void *target) 228 { 229 struct dentry *dentry = filp->f_path.dentry; 230 struct inode *inode = dentry->d_inode; 231 ssize_t res; 232 233 dfprintk(VFS, "nfs: sendfile(%s/%s, %lu@%Lu)\n", 234 dentry->d_parent->d_name.name, dentry->d_name.name, 235 (unsigned long) count, (unsigned long long) *ppos); 236 237 res = nfs_revalidate_mapping(inode, filp->f_mapping); 238 if (!res) 239 res = generic_file_sendfile(filp, ppos, count, actor, target); 240 return res; 241 } 242 243 static int 244 nfs_file_mmap(struct file * file, struct vm_area_struct * vma) 245 { 246 struct dentry *dentry = file->f_path.dentry; 247 struct inode *inode = dentry->d_inode; 248 int status; 249 250 dfprintk(VFS, "nfs: mmap(%s/%s)\n", 251 dentry->d_parent->d_name.name, dentry->d_name.name); 252 253 status = nfs_revalidate_mapping(inode, file->f_mapping); 254 if (!status) 255 status = generic_file_mmap(file, vma); 256 return status; 257 } 258 259 /* 260 * Flush any dirty pages for this process, and check for write errors. 261 * The return status from this call provides a reliable indication of 262 * whether any write errors occurred for this process. 263 */ 264 static int 265 nfs_fsync(struct file *file, struct dentry *dentry, int datasync) 266 { 267 struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data; 268 struct inode *inode = dentry->d_inode; 269 int status; 270 271 dfprintk(VFS, "nfs: fsync(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino); 272 273 nfs_inc_stats(inode, NFSIOS_VFSFSYNC); 274 lock_kernel(); 275 status = nfs_wb_all(inode); 276 if (!status) { 277 status = ctx->error; 278 ctx->error = 0; 279 } 280 unlock_kernel(); 281 return status; 282 } 283 284 /* 285 * This does the "real" work of the write. The generic routine has 286 * allocated the page, locked it, done all the page alignment stuff 287 * calculations etc. Now we should just copy the data from user 288 * space and write it back to the real medium.. 289 * 290 * If the writer ends up delaying the write, the writer needs to 291 * increment the page use counts until he is done with the page. 292 */ 293 static int nfs_prepare_write(struct file *file, struct page *page, unsigned offset, unsigned to) 294 { 295 return nfs_flush_incompatible(file, page); 296 } 297 298 static int nfs_commit_write(struct file *file, struct page *page, unsigned offset, unsigned to) 299 { 300 long status; 301 302 lock_kernel(); 303 status = nfs_updatepage(file, page, offset, to-offset); 304 unlock_kernel(); 305 return status; 306 } 307 308 static void nfs_invalidate_page(struct page *page, unsigned long offset) 309 { 310 if (offset != 0) 311 return; 312 /* Cancel any unstarted writes on this page */ 313 nfs_wb_page_priority(page->mapping->host, page, FLUSH_INVALIDATE); 314 } 315 316 static int nfs_release_page(struct page *page, gfp_t gfp) 317 { 318 /* If PagePrivate() is set, then the page is not freeable */ 319 return 0; 320 } 321 322 static int nfs_launder_page(struct page *page) 323 { 324 return nfs_wb_page(page->mapping->host, page); 325 } 326 327 const struct address_space_operations nfs_file_aops = { 328 .readpage = nfs_readpage, 329 .readpages = nfs_readpages, 330 .set_page_dirty = nfs_set_page_dirty, 331 .writepage = nfs_writepage, 332 .writepages = nfs_writepages, 333 .prepare_write = nfs_prepare_write, 334 .commit_write = nfs_commit_write, 335 .invalidatepage = nfs_invalidate_page, 336 .releasepage = nfs_release_page, 337 #ifdef CONFIG_NFS_DIRECTIO 338 .direct_IO = nfs_direct_IO, 339 #endif 340 .launder_page = nfs_launder_page, 341 }; 342 343 static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov, 344 unsigned long nr_segs, loff_t pos) 345 { 346 struct dentry * dentry = iocb->ki_filp->f_path.dentry; 347 struct inode * inode = dentry->d_inode; 348 ssize_t result; 349 size_t count = iov_length(iov, nr_segs); 350 351 #ifdef CONFIG_NFS_DIRECTIO 352 if (iocb->ki_filp->f_flags & O_DIRECT) 353 return nfs_file_direct_write(iocb, iov, nr_segs, pos); 354 #endif 355 356 dfprintk(VFS, "nfs: write(%s/%s(%ld), %lu@%Ld)\n", 357 dentry->d_parent->d_name.name, dentry->d_name.name, 358 inode->i_ino, (unsigned long) count, (long long) pos); 359 360 result = -EBUSY; 361 if (IS_SWAPFILE(inode)) 362 goto out_swapfile; 363 /* 364 * O_APPEND implies that we must revalidate the file length. 365 */ 366 if (iocb->ki_filp->f_flags & O_APPEND) { 367 result = nfs_revalidate_file_size(inode, iocb->ki_filp); 368 if (result) 369 goto out; 370 } 371 372 result = count; 373 if (!count) 374 goto out; 375 376 nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, count); 377 result = generic_file_aio_write(iocb, iov, nr_segs, pos); 378 /* Return error values for O_SYNC and IS_SYNC() */ 379 if (result >= 0 && (IS_SYNC(inode) || (iocb->ki_filp->f_flags & O_SYNC))) { 380 int err = nfs_fsync(iocb->ki_filp, dentry, 1); 381 if (err < 0) 382 result = err; 383 } 384 out: 385 return result; 386 387 out_swapfile: 388 printk(KERN_INFO "NFS: attempt to write to active swap file!\n"); 389 goto out; 390 } 391 392 static int do_getlk(struct file *filp, int cmd, struct file_lock *fl) 393 { 394 struct inode *inode = filp->f_mapping->host; 395 int status = 0; 396 397 lock_kernel(); 398 /* Try local locking first */ 399 if (posix_test_lock(filp, fl)) { 400 goto out; 401 } 402 403 if (nfs_have_delegation(inode, FMODE_READ)) 404 goto out_noconflict; 405 406 if (NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM) 407 goto out_noconflict; 408 409 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 410 out: 411 unlock_kernel(); 412 return status; 413 out_noconflict: 414 fl->fl_type = F_UNLCK; 415 goto out; 416 } 417 418 static int do_vfs_lock(struct file *file, struct file_lock *fl) 419 { 420 int res = 0; 421 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 422 case FL_POSIX: 423 res = posix_lock_file_wait(file, fl); 424 break; 425 case FL_FLOCK: 426 res = flock_lock_file_wait(file, fl); 427 break; 428 default: 429 BUG(); 430 } 431 if (res < 0) 432 dprintk(KERN_WARNING "%s: VFS is out of sync with lock manager" 433 " - error %d!\n", 434 __FUNCTION__, res); 435 return res; 436 } 437 438 static int do_unlk(struct file *filp, int cmd, struct file_lock *fl) 439 { 440 struct inode *inode = filp->f_mapping->host; 441 int status; 442 443 /* 444 * Flush all pending writes before doing anything 445 * with locks.. 446 */ 447 nfs_sync_mapping(filp->f_mapping); 448 449 /* NOTE: special case 450 * If we're signalled while cleaning up locks on process exit, we 451 * still need to complete the unlock. 452 */ 453 lock_kernel(); 454 /* Use local locking if mounted with "-onolock" */ 455 if (!(NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM)) 456 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 457 else 458 status = do_vfs_lock(filp, fl); 459 unlock_kernel(); 460 return status; 461 } 462 463 static int do_setlk(struct file *filp, int cmd, struct file_lock *fl) 464 { 465 struct inode *inode = filp->f_mapping->host; 466 int status; 467 468 /* 469 * Flush all pending writes before doing anything 470 * with locks.. 471 */ 472 status = nfs_sync_mapping(filp->f_mapping); 473 if (status != 0) 474 goto out; 475 476 lock_kernel(); 477 /* Use local locking if mounted with "-onolock" */ 478 if (!(NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM)) { 479 status = NFS_PROTO(inode)->lock(filp, cmd, fl); 480 /* If we were signalled we still need to ensure that 481 * we clean up any state on the server. We therefore 482 * record the lock call as having succeeded in order to 483 * ensure that locks_remove_posix() cleans it out when 484 * the process exits. 485 */ 486 if (status == -EINTR || status == -ERESTARTSYS) 487 do_vfs_lock(filp, fl); 488 } else 489 status = do_vfs_lock(filp, fl); 490 unlock_kernel(); 491 if (status < 0) 492 goto out; 493 /* 494 * Make sure we clear the cache whenever we try to get the lock. 495 * This makes locking act as a cache coherency point. 496 */ 497 nfs_sync_mapping(filp->f_mapping); 498 nfs_zap_caches(inode); 499 out: 500 return status; 501 } 502 503 /* 504 * Lock a (portion of) a file 505 */ 506 static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl) 507 { 508 struct inode * inode = filp->f_mapping->host; 509 510 dprintk("NFS: nfs_lock(f=%s/%ld, t=%x, fl=%x, r=%Ld:%Ld)\n", 511 inode->i_sb->s_id, inode->i_ino, 512 fl->fl_type, fl->fl_flags, 513 (long long)fl->fl_start, (long long)fl->fl_end); 514 nfs_inc_stats(inode, NFSIOS_VFSLOCK); 515 516 /* No mandatory locks over NFS */ 517 if ((inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID && 518 fl->fl_type != F_UNLCK) 519 return -ENOLCK; 520 521 if (IS_GETLK(cmd)) 522 return do_getlk(filp, cmd, fl); 523 if (fl->fl_type == F_UNLCK) 524 return do_unlk(filp, cmd, fl); 525 return do_setlk(filp, cmd, fl); 526 } 527 528 /* 529 * Lock a (portion of) a file 530 */ 531 static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl) 532 { 533 dprintk("NFS: nfs_flock(f=%s/%ld, t=%x, fl=%x)\n", 534 filp->f_path.dentry->d_inode->i_sb->s_id, 535 filp->f_path.dentry->d_inode->i_ino, 536 fl->fl_type, fl->fl_flags); 537 538 /* 539 * No BSD flocks over NFS allowed. 540 * Note: we could try to fake a POSIX lock request here by 541 * using ((u32) filp | 0x80000000) or some such as the pid. 542 * Not sure whether that would be unique, though, or whether 543 * that would break in other places. 544 */ 545 if (!(fl->fl_flags & FL_FLOCK)) 546 return -ENOLCK; 547 548 /* We're simulating flock() locks using posix locks on the server */ 549 fl->fl_owner = (fl_owner_t)filp; 550 fl->fl_start = 0; 551 fl->fl_end = OFFSET_MAX; 552 553 if (fl->fl_type == F_UNLCK) 554 return do_unlk(filp, cmd, fl); 555 return do_setlk(filp, cmd, fl); 556 } 557