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