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