1/* 2 * linux/fs/nfs/inode.c 3 * 4 * Copyright (C) 1992 Rick Sladkey 5 * 6 * nfs inode and superblock handling functions 7 * 8 * Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some 9 * experimental NFS changes. Modularisation taken straight from SYS5 fs. 10 * 11 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts. 12 * J.S.Peatfield@damtp.cam.ac.uk 13 * 14 */ 15 16#include <linux/module.h> 17#include <linux/init.h> 18#include <linux/sched.h> 19#include <linux/time.h> 20#include <linux/kernel.h> 21#include <linux/mm.h> 22#include <linux/string.h> 23#include <linux/stat.h> 24#include <linux/errno.h> 25#include <linux/unistd.h> 26#include <linux/sunrpc/clnt.h> 27#include <linux/sunrpc/stats.h> 28#include <linux/sunrpc/metrics.h> 29#include <linux/nfs_fs.h> 30#include <linux/nfs_mount.h> 31#include <linux/nfs4_mount.h> 32#include <linux/lockd/bind.h> 33#include <linux/smp_lock.h> 34#include <linux/seq_file.h> 35#include <linux/mount.h> 36#include <linux/nfs_idmap.h> 37#include <linux/vfs.h> 38#include <linux/inet.h> 39#include <linux/nfs_xdr.h> 40 41#include <asm/system.h> 42#include <asm/uaccess.h> 43 44#include "nfs4_fs.h" 45#include "callback.h" 46#include "delegation.h" 47#include "iostat.h" 48#include "internal.h" 49 50#define NFSDBG_FACILITY NFSDBG_VFS 51 52static void nfs_invalidate_inode(struct inode *); 53static int nfs_update_inode(struct inode *, struct nfs_fattr *); 54 55static void nfs_zap_acl_cache(struct inode *); 56 57static struct kmem_cache * nfs_inode_cachep; 58 59static inline unsigned long 60nfs_fattr_to_ino_t(struct nfs_fattr *fattr) 61{ 62 return nfs_fileid_to_ino_t(fattr->fileid); 63} 64 65int nfs_write_inode(struct inode *inode, int sync) 66{ 67 int ret; 68 69 if (sync) { 70 ret = filemap_fdatawait(inode->i_mapping); 71 if (ret == 0) 72 ret = nfs_commit_inode(inode, FLUSH_SYNC); 73 } else 74 ret = nfs_commit_inode(inode, 0); 75 if (ret >= 0) 76 return 0; 77 __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 78 return ret; 79} 80 81void nfs_clear_inode(struct inode *inode) 82{ 83 /* 84 * The following should never happen... 85 */ 86 BUG_ON(nfs_have_writebacks(inode)); 87 BUG_ON(!list_empty(&NFS_I(inode)->open_files)); 88 BUG_ON(atomic_read(&NFS_I(inode)->data_updates) != 0); 89 nfs_zap_acl_cache(inode); 90 nfs_access_zap_cache(inode); 91} 92 93/** 94 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk 95 */ 96int nfs_sync_mapping(struct address_space *mapping) 97{ 98 int ret; 99 100 if (mapping->nrpages == 0) 101 return 0; 102 unmap_mapping_range(mapping, 0, 0, 0); 103 ret = filemap_write_and_wait(mapping); 104 if (ret != 0) 105 goto out; 106 ret = nfs_wb_all(mapping->host); 107out: 108 return ret; 109} 110 111/* 112 * Invalidate the local caches 113 */ 114static void nfs_zap_caches_locked(struct inode *inode) 115{ 116 struct nfs_inode *nfsi = NFS_I(inode); 117 int mode = inode->i_mode; 118 119 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 120 121 NFS_ATTRTIMEO(inode) = NFS_MINATTRTIMEO(inode); 122 NFS_ATTRTIMEO_UPDATE(inode) = jiffies; 123 124 memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode))); 125 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) 126 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE; 127 else 128 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE; 129} 130 131void nfs_zap_caches(struct inode *inode) 132{ 133 spin_lock(&inode->i_lock); 134 nfs_zap_caches_locked(inode); 135 spin_unlock(&inode->i_lock); 136} 137 138void nfs_zap_mapping(struct inode *inode, struct address_space *mapping) 139{ 140 if (mapping->nrpages != 0) { 141 spin_lock(&inode->i_lock); 142 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA; 143 spin_unlock(&inode->i_lock); 144 } 145} 146 147static void nfs_zap_acl_cache(struct inode *inode) 148{ 149 void (*clear_acl_cache)(struct inode *); 150 151 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache; 152 if (clear_acl_cache != NULL) 153 clear_acl_cache(inode); 154 spin_lock(&inode->i_lock); 155 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL; 156 spin_unlock(&inode->i_lock); 157} 158 159/* 160 * Invalidate, but do not unhash, the inode. 161 * NB: must be called with inode->i_lock held! 162 */ 163static void nfs_invalidate_inode(struct inode *inode) 164{ 165 set_bit(NFS_INO_STALE, &NFS_FLAGS(inode)); 166 nfs_zap_caches_locked(inode); 167} 168 169struct nfs_find_desc { 170 struct nfs_fh *fh; 171 struct nfs_fattr *fattr; 172}; 173 174/* 175 * In NFSv3 we can have 64bit inode numbers. In order to support 176 * this, and re-exported directories (also seen in NFSv2) 177 * we are forced to allow 2 different inodes to have the same 178 * i_ino. 179 */ 180static int 181nfs_find_actor(struct inode *inode, void *opaque) 182{ 183 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque; 184 struct nfs_fh *fh = desc->fh; 185 struct nfs_fattr *fattr = desc->fattr; 186 187 if (NFS_FILEID(inode) != fattr->fileid) 188 return 0; 189 if (nfs_compare_fh(NFS_FH(inode), fh)) 190 return 0; 191 if (is_bad_inode(inode) || NFS_STALE(inode)) 192 return 0; 193 return 1; 194} 195 196static int 197nfs_init_locked(struct inode *inode, void *opaque) 198{ 199 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque; 200 struct nfs_fattr *fattr = desc->fattr; 201 202 NFS_FILEID(inode) = fattr->fileid; 203 nfs_copy_fh(NFS_FH(inode), desc->fh); 204 return 0; 205} 206 207/* Don't use READDIRPLUS on directories that we believe are too large */ 208#define NFS_LIMIT_READDIRPLUS (8*PAGE_SIZE) 209 210/* 211 * This is our front-end to iget that looks up inodes by file handle 212 * instead of inode number. 213 */ 214struct inode * 215nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr) 216{ 217 struct nfs_find_desc desc = { 218 .fh = fh, 219 .fattr = fattr 220 }; 221 struct inode *inode = ERR_PTR(-ENOENT); 222 unsigned long hash; 223 224 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 225 goto out_no_inode; 226 227 if (!fattr->nlink) { 228 printk("NFS: Buggy server - nlink == 0!\n"); 229 goto out_no_inode; 230 } 231 232 hash = nfs_fattr_to_ino_t(fattr); 233 234 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc); 235 if (inode == NULL) { 236 inode = ERR_PTR(-ENOMEM); 237 goto out_no_inode; 238 } 239 240 if (inode->i_state & I_NEW) { 241 struct nfs_inode *nfsi = NFS_I(inode); 242 unsigned long now = jiffies; 243 244 /* We set i_ino for the few things that still rely on it, 245 * such as stat(2) */ 246 inode->i_ino = hash; 247 248 /* We can't support update_atime(), since the server will reset it */ 249 inode->i_flags |= S_NOATIME|S_NOCMTIME; 250 inode->i_mode = fattr->mode; 251 /* Why so? Because we want revalidate for devices/FIFOs, and 252 * that's precisely what we have in nfs_file_inode_operations. 253 */ 254 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops; 255 if (S_ISREG(inode->i_mode)) { 256 inode->i_fop = &nfs_file_operations; 257 inode->i_data.a_ops = &nfs_file_aops; 258 inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info; 259 } else if (S_ISDIR(inode->i_mode)) { 260 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops; 261 inode->i_fop = &nfs_dir_operations; 262 if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS) 263 && fattr->size <= NFS_LIMIT_READDIRPLUS) 264 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode)); 265 /* Deal with crossing mountpoints */ 266 if (!nfs_fsid_equal(&NFS_SB(sb)->fsid, &fattr->fsid)) { 267 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) 268 inode->i_op = &nfs_referral_inode_operations; 269 else 270 inode->i_op = &nfs_mountpoint_inode_operations; 271 inode->i_fop = NULL; 272 } 273 } else if (S_ISLNK(inode->i_mode)) 274 inode->i_op = &nfs_symlink_inode_operations; 275 else 276 init_special_inode(inode, inode->i_mode, fattr->rdev); 277 278 nfsi->read_cache_jiffies = fattr->time_start; 279 nfsi->last_updated = now; 280 nfsi->cache_change_attribute = now; 281 inode->i_atime = fattr->atime; 282 inode->i_mtime = fattr->mtime; 283 inode->i_ctime = fattr->ctime; 284 if (fattr->valid & NFS_ATTR_FATTR_V4) 285 nfsi->change_attr = fattr->change_attr; 286 inode->i_size = nfs_size_to_loff_t(fattr->size); 287 inode->i_nlink = fattr->nlink; 288 inode->i_uid = fattr->uid; 289 inode->i_gid = fattr->gid; 290 if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) { 291 /* 292 * report the blocks in 512byte units 293 */ 294 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 295 } else { 296 inode->i_blocks = fattr->du.nfs2.blocks; 297 } 298 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 299 nfsi->attrtimeo_timestamp = now; 300 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf)); 301 nfsi->access_cache = RB_ROOT; 302 303 unlock_new_inode(inode); 304 } else 305 nfs_refresh_inode(inode, fattr); 306 dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n", 307 inode->i_sb->s_id, 308 (long long)NFS_FILEID(inode), 309 atomic_read(&inode->i_count)); 310 311out: 312 return inode; 313 314out_no_inode: 315 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode)); 316 goto out; 317} 318 319#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET) 320 321int 322nfs_setattr(struct dentry *dentry, struct iattr *attr) 323{ 324 struct inode *inode = dentry->d_inode; 325 struct nfs_fattr fattr; 326 int error; 327 328 nfs_inc_stats(inode, NFSIOS_VFSSETATTR); 329 330 if (attr->ia_valid & ATTR_SIZE) { 331 if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode)) 332 attr->ia_valid &= ~ATTR_SIZE; 333 } 334 335 /* Optimization: if the end result is no change, don't RPC */ 336 attr->ia_valid &= NFS_VALID_ATTRS; 337 if (attr->ia_valid == 0) 338 return 0; 339 340 lock_kernel(); 341 nfs_begin_data_update(inode); 342 /* Write all dirty data */ 343 if (S_ISREG(inode->i_mode)) { 344 filemap_write_and_wait(inode->i_mapping); 345 nfs_wb_all(inode); 346 } 347 /* 348 * Return any delegations if we're going to change ACLs 349 */ 350 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) 351 nfs_inode_return_delegation(inode); 352 error = NFS_PROTO(inode)->setattr(dentry, &fattr, attr); 353 if (error == 0) 354 nfs_refresh_inode(inode, &fattr); 355 nfs_end_data_update(inode); 356 unlock_kernel(); 357 return error; 358} 359 360/** 361 * nfs_setattr_update_inode - Update inode metadata after a setattr call. 362 * @inode: pointer to struct inode 363 * @attr: pointer to struct iattr 364 * 365 * Note: we do this in the *proc.c in order to ensure that 366 * it works for things like exclusive creates too. 367 */ 368void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr) 369{ 370 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) { 371 if ((attr->ia_valid & ATTR_MODE) != 0) { 372 int mode = attr->ia_mode & S_IALLUGO; 373 mode |= inode->i_mode & ~S_IALLUGO; 374 inode->i_mode = mode; 375 } 376 if ((attr->ia_valid & ATTR_UID) != 0) 377 inode->i_uid = attr->ia_uid; 378 if ((attr->ia_valid & ATTR_GID) != 0) 379 inode->i_gid = attr->ia_gid; 380 spin_lock(&inode->i_lock); 381 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 382 spin_unlock(&inode->i_lock); 383 } 384 if ((attr->ia_valid & ATTR_SIZE) != 0) { 385 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC); 386 inode->i_size = attr->ia_size; 387 vmtruncate(inode, attr->ia_size); 388 } 389} 390 391static int nfs_wait_schedule(void *word) 392{ 393 if (signal_pending(current)) 394 return -ERESTARTSYS; 395 schedule(); 396 return 0; 397} 398 399/* 400 * Wait for the inode to get unlocked. 401 */ 402static int nfs_wait_on_inode(struct inode *inode) 403{ 404 struct rpc_clnt *clnt = NFS_CLIENT(inode); 405 struct nfs_inode *nfsi = NFS_I(inode); 406 sigset_t oldmask; 407 int error; 408 409 rpc_clnt_sigmask(clnt, &oldmask); 410 error = wait_on_bit_lock(&nfsi->flags, NFS_INO_REVALIDATING, 411 nfs_wait_schedule, TASK_INTERRUPTIBLE); 412 rpc_clnt_sigunmask(clnt, &oldmask); 413 414 return error; 415} 416 417static void nfs_wake_up_inode(struct inode *inode) 418{ 419 struct nfs_inode *nfsi = NFS_I(inode); 420 421 clear_bit(NFS_INO_REVALIDATING, &nfsi->flags); 422 smp_mb__after_clear_bit(); 423 wake_up_bit(&nfsi->flags, NFS_INO_REVALIDATING); 424} 425 426int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 427{ 428 struct inode *inode = dentry->d_inode; 429 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME; 430 int err; 431 432 /* Flush out writes to the server in order to update c/mtime */ 433 if (S_ISREG(inode->i_mode)) 434 nfs_sync_mapping_range(inode->i_mapping, 0, 0, FLUSH_NOCOMMIT); 435 436 /* 437 * We may force a getattr if the user cares about atime. 438 * 439 * Note that we only have to check the vfsmount flags here: 440 * - NFS always sets S_NOATIME by so checking it would give a 441 * bogus result 442 * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is 443 * no point in checking those. 444 */ 445 if ((mnt->mnt_flags & MNT_NOATIME) || 446 ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))) 447 need_atime = 0; 448 449 if (need_atime) 450 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 451 else 452 err = nfs_revalidate_inode(NFS_SERVER(inode), inode); 453 if (!err) 454 generic_fillattr(inode, stat); 455 return err; 456} 457 458static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, struct dentry *dentry, struct rpc_cred *cred) 459{ 460 struct nfs_open_context *ctx; 461 462 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); 463 if (ctx != NULL) { 464 atomic_set(&ctx->count, 1); 465 ctx->dentry = dget(dentry); 466 ctx->vfsmnt = mntget(mnt); 467 ctx->cred = get_rpccred(cred); 468 ctx->state = NULL; 469 ctx->lockowner = current->files; 470 ctx->error = 0; 471 ctx->dir_cookie = 0; 472 } 473 return ctx; 474} 475 476struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx) 477{ 478 if (ctx != NULL) 479 atomic_inc(&ctx->count); 480 return ctx; 481} 482 483void put_nfs_open_context(struct nfs_open_context *ctx) 484{ 485 if (atomic_dec_and_test(&ctx->count)) { 486 if (!list_empty(&ctx->list)) { 487 struct inode *inode = ctx->dentry->d_inode; 488 spin_lock(&inode->i_lock); 489 list_del(&ctx->list); 490 spin_unlock(&inode->i_lock); 491 } 492 if (ctx->state != NULL) 493 nfs4_close_state(ctx->state, ctx->mode); 494 if (ctx->cred != NULL) 495 put_rpccred(ctx->cred); 496 dput(ctx->dentry); 497 mntput(ctx->vfsmnt); 498 kfree(ctx); 499 } 500} 501 502/* 503 * Ensure that mmap has a recent RPC credential for use when writing out 504 * shared pages 505 */ 506static void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx) 507{ 508 struct inode *inode = filp->f_path.dentry->d_inode; 509 struct nfs_inode *nfsi = NFS_I(inode); 510 511 filp->private_data = get_nfs_open_context(ctx); 512 spin_lock(&inode->i_lock); 513 list_add(&ctx->list, &nfsi->open_files); 514 spin_unlock(&inode->i_lock); 515} 516 517/* 518 * Given an inode, search for an open context with the desired characteristics 519 */ 520struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode) 521{ 522 struct nfs_inode *nfsi = NFS_I(inode); 523 struct nfs_open_context *pos, *ctx = NULL; 524 525 spin_lock(&inode->i_lock); 526 list_for_each_entry(pos, &nfsi->open_files, list) { 527 if (cred != NULL && pos->cred != cred) 528 continue; 529 if ((pos->mode & mode) == mode) { 530 ctx = get_nfs_open_context(pos); 531 break; 532 } 533 } 534 spin_unlock(&inode->i_lock); 535 return ctx; 536} 537 538static void nfs_file_clear_open_context(struct file *filp) 539{ 540 struct inode *inode = filp->f_path.dentry->d_inode; 541 struct nfs_open_context *ctx = (struct nfs_open_context *)filp->private_data; 542 543 if (ctx) { 544 filp->private_data = NULL; 545 spin_lock(&inode->i_lock); 546 list_move_tail(&ctx->list, &NFS_I(inode)->open_files); 547 spin_unlock(&inode->i_lock); 548 put_nfs_open_context(ctx); 549 } 550} 551 552/* 553 * These allocate and release file read/write context information. 554 */ 555int nfs_open(struct inode *inode, struct file *filp) 556{ 557 struct nfs_open_context *ctx; 558 struct rpc_cred *cred; 559 560 cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0); 561 if (IS_ERR(cred)) 562 return PTR_ERR(cred); 563 ctx = alloc_nfs_open_context(filp->f_path.mnt, filp->f_path.dentry, cred); 564 put_rpccred(cred); 565 if (ctx == NULL) 566 return -ENOMEM; 567 ctx->mode = filp->f_mode; 568 nfs_file_set_open_context(filp, ctx); 569 put_nfs_open_context(ctx); 570 return 0; 571} 572 573int nfs_release(struct inode *inode, struct file *filp) 574{ 575 nfs_file_clear_open_context(filp); 576 return 0; 577} 578 579/* 580 * This function is called whenever some part of NFS notices that 581 * the cached attributes have to be refreshed. 582 */ 583int 584__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 585{ 586 int status = -ESTALE; 587 struct nfs_fattr fattr; 588 struct nfs_inode *nfsi = NFS_I(inode); 589 590 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n", 591 inode->i_sb->s_id, (long long)NFS_FILEID(inode)); 592 593 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE); 594 lock_kernel(); 595 if (is_bad_inode(inode)) 596 goto out_nowait; 597 if (NFS_STALE(inode)) 598 goto out_nowait; 599 600 status = nfs_wait_on_inode(inode); 601 if (status < 0) 602 goto out; 603 if (NFS_STALE(inode)) { 604 status = -ESTALE; 605 /* Do we trust the cached ESTALE? */ 606 if (NFS_ATTRTIMEO(inode) != 0) { 607 if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME)) { 608 /* no */ 609 } else 610 goto out; 611 } 612 } 613 614 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), &fattr); 615 if (status != 0) { 616 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n", 617 inode->i_sb->s_id, 618 (long long)NFS_FILEID(inode), status); 619 if (status == -ESTALE) { 620 nfs_zap_caches(inode); 621 if (!S_ISDIR(inode->i_mode)) 622 set_bit(NFS_INO_STALE, &NFS_FLAGS(inode)); 623 } 624 goto out; 625 } 626 627 spin_lock(&inode->i_lock); 628 status = nfs_update_inode(inode, &fattr); 629 if (status) { 630 spin_unlock(&inode->i_lock); 631 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n", 632 inode->i_sb->s_id, 633 (long long)NFS_FILEID(inode), status); 634 goto out; 635 } 636 spin_unlock(&inode->i_lock); 637 638 if (nfsi->cache_validity & NFS_INO_INVALID_ACL) 639 nfs_zap_acl_cache(inode); 640 641 dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n", 642 inode->i_sb->s_id, 643 (long long)NFS_FILEID(inode)); 644 645 out: 646 nfs_wake_up_inode(inode); 647 648 out_nowait: 649 unlock_kernel(); 650 return status; 651} 652 653int nfs_attribute_timeout(struct inode *inode) 654{ 655 struct nfs_inode *nfsi = NFS_I(inode); 656 657 if (nfs_have_delegation(inode, FMODE_READ)) 658 return 0; 659 return time_after(jiffies, nfsi->read_cache_jiffies+nfsi->attrtimeo); 660} 661 662/** 663 * nfs_revalidate_inode - Revalidate the inode attributes 664 * @server - pointer to nfs_server struct 665 * @inode - pointer to inode struct 666 * 667 * Updates inode attribute information by retrieving the data from the server. 668 */ 669int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 670{ 671 if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR) 672 && !nfs_attribute_timeout(inode)) 673 return NFS_STALE(inode) ? -ESTALE : 0; 674 return __nfs_revalidate_inode(server, inode); 675} 676 677static int nfs_invalidate_mapping_nolock(struct inode *inode, struct address_space *mapping) 678{ 679 struct nfs_inode *nfsi = NFS_I(inode); 680 681 if (mapping->nrpages != 0) { 682 int ret = invalidate_inode_pages2(mapping); 683 if (ret < 0) 684 return ret; 685 } 686 spin_lock(&inode->i_lock); 687 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA; 688 if (S_ISDIR(inode->i_mode)) { 689 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf)); 690 /* This ensures we revalidate child dentries */ 691 nfsi->cache_change_attribute = jiffies; 692 } 693 spin_unlock(&inode->i_lock); 694 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE); 695 dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n", 696 inode->i_sb->s_id, (long long)NFS_FILEID(inode)); 697 return 0; 698} 699 700static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping) 701{ 702 int ret = 0; 703 704 mutex_lock(&inode->i_mutex); 705 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_DATA) { 706 ret = nfs_sync_mapping(mapping); 707 if (ret == 0) 708 ret = nfs_invalidate_mapping_nolock(inode, mapping); 709 } 710 mutex_unlock(&inode->i_mutex); 711 return ret; 712} 713 714/** 715 * nfs_revalidate_mapping_nolock - Revalidate the pagecache 716 * @inode - pointer to host inode 717 * @mapping - pointer to mapping 718 */ 719int nfs_revalidate_mapping_nolock(struct inode *inode, struct address_space *mapping) 720{ 721 struct nfs_inode *nfsi = NFS_I(inode); 722 int ret = 0; 723 724 if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE) 725 || nfs_attribute_timeout(inode) || NFS_STALE(inode)) { 726 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 727 if (ret < 0) 728 goto out; 729 } 730 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 731 ret = nfs_invalidate_mapping_nolock(inode, mapping); 732out: 733 return ret; 734} 735 736/** 737 * nfs_revalidate_mapping - Revalidate the pagecache 738 * @inode - pointer to host inode 739 * @mapping - pointer to mapping 740 * 741 * This version of the function will take the inode->i_mutex and attempt to 742 * flush out all dirty data if it needs to invalidate the page cache. 743 */ 744int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) 745{ 746 struct nfs_inode *nfsi = NFS_I(inode); 747 int ret = 0; 748 749 if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE) 750 || nfs_attribute_timeout(inode) || NFS_STALE(inode)) { 751 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 752 if (ret < 0) 753 goto out; 754 } 755 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 756 ret = nfs_invalidate_mapping(inode, mapping); 757out: 758 return ret; 759} 760 761/** 762 * nfs_begin_data_update 763 * @inode - pointer to inode 764 * Declare that a set of operations will update file data on the server 765 */ 766void nfs_begin_data_update(struct inode *inode) 767{ 768 atomic_inc(&NFS_I(inode)->data_updates); 769} 770 771/** 772 * nfs_end_data_update 773 * @inode - pointer to inode 774 * Declare end of the operations that will update file data 775 * This will mark the inode as immediately needing revalidation 776 * of its attribute cache. 777 */ 778void nfs_end_data_update(struct inode *inode) 779{ 780 struct nfs_inode *nfsi = NFS_I(inode); 781 782 /* Directories: invalidate page cache */ 783 if (S_ISDIR(inode->i_mode)) { 784 spin_lock(&inode->i_lock); 785 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 786 spin_unlock(&inode->i_lock); 787 } 788 nfsi->cache_change_attribute = jiffies; 789 atomic_dec(&nfsi->data_updates); 790} 791 792static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr) 793{ 794 struct nfs_inode *nfsi = NFS_I(inode); 795 unsigned long now = jiffies; 796 797 /* If we have atomic WCC data, we may update some attributes */ 798 if ((fattr->valid & NFS_ATTR_WCC) != 0) { 799 if (timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) { 800 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); 801 nfsi->cache_change_attribute = now; 802 } 803 if (timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) { 804 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); 805 nfsi->cache_change_attribute = now; 806 } 807 if (inode->i_size == fattr->pre_size && nfsi->npages == 0) { 808 inode->i_size = fattr->size; 809 nfsi->cache_change_attribute = now; 810 } 811 } 812} 813 814/** 815 * nfs_check_inode_attributes - verify consistency of the inode attribute cache 816 * @inode - pointer to inode 817 * @fattr - updated attributes 818 * 819 * Verifies the attribute cache. If we have just changed the attributes, 820 * so that fattr carries weak cache consistency data, then it may 821 * also update the ctime/mtime/change_attribute. 822 */ 823static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr) 824{ 825 struct nfs_inode *nfsi = NFS_I(inode); 826 loff_t cur_size, new_isize; 827 int data_unstable; 828 829 830 /* Has the inode gone and changed behind our back? */ 831 if (nfsi->fileid != fattr->fileid 832 || (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) { 833 return -EIO; 834 } 835 836 /* Are we in the process of updating data on the server? */ 837 data_unstable = nfs_caches_unstable(inode); 838 839 /* Do atomic weak cache consistency updates */ 840 nfs_wcc_update_inode(inode, fattr); 841 842 if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 && 843 nfsi->change_attr != fattr->change_attr) 844 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 845 846 /* Verify a few of the more important attributes */ 847 if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) 848 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 849 850 cur_size = i_size_read(inode); 851 new_isize = nfs_size_to_loff_t(fattr->size); 852 if (cur_size != new_isize && nfsi->npages == 0) 853 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 854 855 /* Have any file permissions changed? */ 856 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO) 857 || inode->i_uid != fattr->uid 858 || inode->i_gid != fattr->gid) 859 nfsi->cache_validity |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 860 861 /* Has the link count changed? */ 862 if (inode->i_nlink != fattr->nlink) 863 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 864 865 if (!timespec_equal(&inode->i_atime, &fattr->atime)) 866 nfsi->cache_validity |= NFS_INO_INVALID_ATIME; 867 868 nfsi->read_cache_jiffies = fattr->time_start; 869 return 0; 870} 871 872/** 873 * nfs_refresh_inode - try to update the inode attribute cache 874 * @inode - pointer to inode 875 * @fattr - updated attributes 876 * 877 * Check that an RPC call that returned attributes has not overlapped with 878 * other recent updates of the inode metadata, then decide whether it is 879 * safe to do a full update of the inode attributes, or whether just to 880 * call nfs_check_inode_attributes. 881 */ 882int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr) 883{ 884 struct nfs_inode *nfsi = NFS_I(inode); 885 int status; 886 887 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 888 return 0; 889 spin_lock(&inode->i_lock); 890 if (time_after(fattr->time_start, nfsi->last_updated)) 891 status = nfs_update_inode(inode, fattr); 892 else 893 status = nfs_check_inode_attributes(inode, fattr); 894 895 spin_unlock(&inode->i_lock); 896 return status; 897} 898 899/** 900 * nfs_post_op_update_inode - try to update the inode attribute cache 901 * @inode - pointer to inode 902 * @fattr - updated attributes 903 * 904 * After an operation that has changed the inode metadata, mark the 905 * attribute cache as being invalid, then try to update it. 906 * 907 * NB: if the server didn't return any post op attributes, this 908 * function will force the retrieval of attributes before the next 909 * NFS request. Thus it should be used only for operations that 910 * are expected to change one or more attributes, to avoid 911 * unnecessary NFS requests and trips through nfs_update_inode(). 912 */ 913int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr) 914{ 915 struct nfs_inode *nfsi = NFS_I(inode); 916 int status = 0; 917 918 spin_lock(&inode->i_lock); 919 if (unlikely((fattr->valid & NFS_ATTR_FATTR) == 0)) { 920 nfsi->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 921 goto out; 922 } 923 status = nfs_update_inode(inode, fattr); 924out: 925 spin_unlock(&inode->i_lock); 926 return status; 927} 928 929/* 930 * Many nfs protocol calls return the new file attributes after 931 * an operation. Here we update the inode to reflect the state 932 * of the server's inode. 933 * 934 * This is a bit tricky because we have to make sure all dirty pages 935 * have been sent off to the server before calling invalidate_inode_pages. 936 * To make sure no other process adds more write requests while we try 937 * our best to flush them, we make them sleep during the attribute refresh. 938 * 939 * A very similar scenario holds for the dir cache. 940 */ 941static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 942{ 943 struct nfs_server *server; 944 struct nfs_inode *nfsi = NFS_I(inode); 945 loff_t cur_isize, new_isize; 946 unsigned int invalid = 0; 947 unsigned long now = jiffies; 948 int data_stable; 949 950 dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n", 951 __FUNCTION__, inode->i_sb->s_id, inode->i_ino, 952 atomic_read(&inode->i_count), fattr->valid); 953 954 if (nfsi->fileid != fattr->fileid) 955 goto out_fileid; 956 957 /* 958 * Make sure the inode's type hasn't changed. 959 */ 960 if ((inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) 961 goto out_changed; 962 963 server = NFS_SERVER(inode); 964 /* Update the fsid if and only if this is the root directory */ 965 if (inode == inode->i_sb->s_root->d_inode 966 && !nfs_fsid_equal(&server->fsid, &fattr->fsid)) 967 server->fsid = fattr->fsid; 968 969 /* 970 * Update the read time so we don't revalidate too often. 971 */ 972 nfsi->read_cache_jiffies = fattr->time_start; 973 nfsi->last_updated = now; 974 975 /* Fix a wraparound issue with nfsi->cache_change_attribute */ 976 if (time_before(now, nfsi->cache_change_attribute)) 977 nfsi->cache_change_attribute = now - 600*HZ; 978 979 /* Are we racing with known updates of the metadata on the server? */ 980 data_stable = nfs_verify_change_attribute(inode, fattr->time_start); 981 if (data_stable) 982 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_ATIME); 983 984 /* Do atomic weak cache consistency updates */ 985 nfs_wcc_update_inode(inode, fattr); 986 987 /* Check if our cached file size is stale */ 988 new_isize = nfs_size_to_loff_t(fattr->size); 989 cur_isize = i_size_read(inode); 990 if (new_isize != cur_isize) { 991 /* Do we perhaps have any outstanding writes? */ 992 if (nfsi->npages == 0) { 993 /* No, but did we race with nfs_end_data_update()? */ 994 if (data_stable) { 995 inode->i_size = new_isize; 996 invalid |= NFS_INO_INVALID_DATA; 997 } 998 invalid |= NFS_INO_INVALID_ATTR; 999 } else if (new_isize > cur_isize) { 1000 inode->i_size = new_isize; 1001 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA; 1002 } 1003 nfsi->cache_change_attribute = now; 1004 dprintk("NFS: isize change on server for file %s/%ld\n", 1005 inode->i_sb->s_id, inode->i_ino); 1006 } 1007 1008 /* Check if the mtime agrees */ 1009 if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) { 1010 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); 1011 dprintk("NFS: mtime change on server for file %s/%ld\n", 1012 inode->i_sb->s_id, inode->i_ino); 1013 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA; 1014 nfsi->cache_change_attribute = now; 1015 } 1016 1017 /* If ctime has changed we should definitely clear access+acl caches */ 1018 if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) { 1019 invalid |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1020 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); 1021 nfsi->cache_change_attribute = now; 1022 } 1023 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime)); 1024 1025 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO) || 1026 inode->i_uid != fattr->uid || 1027 inode->i_gid != fattr->gid) 1028 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1029 1030 inode->i_mode = fattr->mode; 1031 inode->i_nlink = fattr->nlink; 1032 inode->i_uid = fattr->uid; 1033 inode->i_gid = fattr->gid; 1034 1035 if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) { 1036 /* 1037 * report the blocks in 512byte units 1038 */ 1039 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 1040 } else { 1041 inode->i_blocks = fattr->du.nfs2.blocks; 1042 } 1043 1044 if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 && 1045 nfsi->change_attr != fattr->change_attr) { 1046 dprintk("NFS: change_attr change on server for file %s/%ld\n", 1047 inode->i_sb->s_id, inode->i_ino); 1048 nfsi->change_attr = fattr->change_attr; 1049 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1050 nfsi->cache_change_attribute = now; 1051 } 1052 1053 /* Update attrtimeo value if we're out of the unstable period */ 1054 if (invalid & NFS_INO_INVALID_ATTR) { 1055 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 1056 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 1057 nfsi->attrtimeo_timestamp = now; 1058 } else if (time_after(now, nfsi->attrtimeo_timestamp+nfsi->attrtimeo)) { 1059 if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode)) 1060 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode); 1061 nfsi->attrtimeo_timestamp = now; 1062 } 1063 /* Don't invalidate the data if we were to blame */ 1064 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) 1065 || S_ISLNK(inode->i_mode))) 1066 invalid &= ~NFS_INO_INVALID_DATA; 1067 if (data_stable) 1068 invalid &= ~(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME|NFS_INO_REVAL_PAGECACHE); 1069 if (!nfs_have_delegation(inode, FMODE_READ)) 1070 nfsi->cache_validity |= invalid; 1071 1072 return 0; 1073 out_changed: 1074 /* 1075 * Big trouble! The inode has become a different object. 1076 */ 1077 printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n", 1078 __FUNCTION__, inode->i_ino, inode->i_mode, fattr->mode); 1079 out_err: 1080 /* 1081 * No need to worry about unhashing the dentry, as the 1082 * lookup validation will know that the inode is bad. 1083 * (But we fall through to invalidate the caches.) 1084 */ 1085 nfs_invalidate_inode(inode); 1086 return -ESTALE; 1087 1088 out_fileid: 1089 printk(KERN_ERR "NFS: server %s error: fileid changed\n" 1090 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n", 1091 NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id, 1092 (long long)nfsi->fileid, (long long)fattr->fileid); 1093 goto out_err; 1094} 1095 1096 1097#ifdef CONFIG_NFS_V4 1098 1099/* 1100 * Clean out any remaining NFSv4 state that might be left over due 1101 * to open() calls that passed nfs_atomic_lookup, but failed to call 1102 * nfs_open(). 1103 */ 1104void nfs4_clear_inode(struct inode *inode) 1105{ 1106 struct nfs_inode *nfsi = NFS_I(inode); 1107 1108 /* If we are holding a delegation, return it! */ 1109 nfs_inode_return_delegation(inode); 1110 /* First call standard NFS clear_inode() code */ 1111 nfs_clear_inode(inode); 1112 /* Now clear out any remaining state */ 1113 while (!list_empty(&nfsi->open_states)) { 1114 struct nfs4_state *state; 1115 1116 state = list_entry(nfsi->open_states.next, 1117 struct nfs4_state, 1118 inode_states); 1119 dprintk("%s(%s/%Ld): found unclaimed NFSv4 state %p\n", 1120 __FUNCTION__, 1121 inode->i_sb->s_id, 1122 (long long)NFS_FILEID(inode), 1123 state); 1124 BUG_ON(atomic_read(&state->count) != 1); 1125 nfs4_close_state(state, state->state); 1126 } 1127} 1128#endif 1129 1130struct inode *nfs_alloc_inode(struct super_block *sb) 1131{ 1132 struct nfs_inode *nfsi; 1133 nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL); 1134 if (!nfsi) 1135 return NULL; 1136 nfsi->flags = 0UL; 1137 nfsi->cache_validity = 0UL; 1138#ifdef CONFIG_NFS_V3_ACL 1139 nfsi->acl_access = ERR_PTR(-EAGAIN); 1140 nfsi->acl_default = ERR_PTR(-EAGAIN); 1141#endif 1142#ifdef CONFIG_NFS_V4 1143 nfsi->nfs4_acl = NULL; 1144#endif /* CONFIG_NFS_V4 */ 1145 return &nfsi->vfs_inode; 1146} 1147 1148void nfs_destroy_inode(struct inode *inode) 1149{ 1150 kmem_cache_free(nfs_inode_cachep, NFS_I(inode)); 1151} 1152 1153static inline void nfs4_init_once(struct nfs_inode *nfsi) 1154{ 1155#ifdef CONFIG_NFS_V4 1156 INIT_LIST_HEAD(&nfsi->open_states); 1157 nfsi->delegation = NULL; 1158 nfsi->delegation_state = 0; 1159 init_rwsem(&nfsi->rwsem); 1160#endif 1161} 1162 1163static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags) 1164{ 1165 struct nfs_inode *nfsi = (struct nfs_inode *) foo; 1166 1167 inode_init_once(&nfsi->vfs_inode); 1168 spin_lock_init(&nfsi->req_lock); 1169 INIT_LIST_HEAD(&nfsi->dirty); 1170 INIT_LIST_HEAD(&nfsi->commit); 1171 INIT_LIST_HEAD(&nfsi->open_files); 1172 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru); 1173 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru); 1174 INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC); 1175 atomic_set(&nfsi->data_updates, 0); 1176 nfsi->ndirty = 0; 1177 nfsi->ncommit = 0; 1178 nfsi->npages = 0; 1179 nfs4_init_once(nfsi); 1180} 1181 1182static int __init nfs_init_inodecache(void) 1183{ 1184 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", 1185 sizeof(struct nfs_inode), 1186 0, (SLAB_RECLAIM_ACCOUNT| 1187 SLAB_MEM_SPREAD), 1188 init_once, NULL); 1189 if (nfs_inode_cachep == NULL) 1190 return -ENOMEM; 1191 1192 return 0; 1193} 1194 1195static void nfs_destroy_inodecache(void) 1196{ 1197 kmem_cache_destroy(nfs_inode_cachep); 1198} 1199 1200/* 1201 * Initialize NFS 1202 */ 1203static int __init init_nfs_fs(void) 1204{ 1205 int err; 1206 1207 err = nfs_fs_proc_init(); 1208 if (err) 1209 goto out5; 1210 1211 err = nfs_init_nfspagecache(); 1212 if (err) 1213 goto out4; 1214 1215 err = nfs_init_inodecache(); 1216 if (err) 1217 goto out3; 1218 1219 err = nfs_init_readpagecache(); 1220 if (err) 1221 goto out2; 1222 1223 err = nfs_init_writepagecache(); 1224 if (err) 1225 goto out1; 1226 1227 err = nfs_init_directcache(); 1228 if (err) 1229 goto out0; 1230 1231#ifdef CONFIG_PROC_FS 1232 rpc_proc_register(&nfs_rpcstat); 1233#endif 1234 if ((err = register_nfs_fs()) != 0) 1235 goto out; 1236 return 0; 1237out: 1238#ifdef CONFIG_PROC_FS 1239 rpc_proc_unregister("nfs"); 1240#endif 1241 nfs_destroy_directcache(); 1242out0: 1243 nfs_destroy_writepagecache(); 1244out1: 1245 nfs_destroy_readpagecache(); 1246out2: 1247 nfs_destroy_inodecache(); 1248out3: 1249 nfs_destroy_nfspagecache(); 1250out4: 1251 nfs_fs_proc_exit(); 1252out5: 1253 return err; 1254} 1255 1256static void __exit exit_nfs_fs(void) 1257{ 1258 nfs_destroy_directcache(); 1259 nfs_destroy_writepagecache(); 1260 nfs_destroy_readpagecache(); 1261 nfs_destroy_inodecache(); 1262 nfs_destroy_nfspagecache(); 1263#ifdef CONFIG_PROC_FS 1264 rpc_proc_unregister("nfs"); 1265#endif 1266 unregister_nfs_fs(); 1267 nfs_fs_proc_exit(); 1268} 1269 1270/* Not quite true; I just maintain it */ 1271MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 1272MODULE_LICENSE("GPL"); 1273 1274module_init(init_nfs_fs) 1275module_exit(exit_nfs_fs) 1276