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@lxorguk.ukuu.org.uk>, 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/seq_file.h> 34 #include <linux/mount.h> 35 #include <linux/vfs.h> 36 #include <linux/inet.h> 37 #include <linux/nfs_xdr.h> 38 #include <linux/slab.h> 39 #include <linux/compat.h> 40 #include <linux/freezer.h> 41 #include <linux/crc32.h> 42 43 #include <asm/uaccess.h> 44 45 #include "nfs4_fs.h" 46 #include "callback.h" 47 #include "delegation.h" 48 #include "iostat.h" 49 #include "internal.h" 50 #include "fscache.h" 51 #include "pnfs.h" 52 #include "nfs.h" 53 #include "netns.h" 54 55 #define NFSDBG_FACILITY NFSDBG_VFS 56 57 #define NFS_64_BIT_INODE_NUMBERS_ENABLED 1 58 59 /* Default is to see 64-bit inode numbers */ 60 static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED; 61 62 static void nfs_invalidate_inode(struct inode *); 63 static int nfs_update_inode(struct inode *, struct nfs_fattr *); 64 65 static struct kmem_cache * nfs_inode_cachep; 66 67 static inline unsigned long 68 nfs_fattr_to_ino_t(struct nfs_fattr *fattr) 69 { 70 return nfs_fileid_to_ino_t(fattr->fileid); 71 } 72 73 /** 74 * nfs_wait_bit_killable - helper for functions that are sleeping on bit locks 75 * @word: long word containing the bit lock 76 */ 77 int nfs_wait_bit_killable(void *word) 78 { 79 if (fatal_signal_pending(current)) 80 return -ERESTARTSYS; 81 freezable_schedule_unsafe(); 82 return 0; 83 } 84 EXPORT_SYMBOL_GPL(nfs_wait_bit_killable); 85 86 /** 87 * nfs_compat_user_ino64 - returns the user-visible inode number 88 * @fileid: 64-bit fileid 89 * 90 * This function returns a 32-bit inode number if the boot parameter 91 * nfs.enable_ino64 is zero. 92 */ 93 u64 nfs_compat_user_ino64(u64 fileid) 94 { 95 #ifdef CONFIG_COMPAT 96 compat_ulong_t ino; 97 #else 98 unsigned long ino; 99 #endif 100 101 if (enable_ino64) 102 return fileid; 103 ino = fileid; 104 if (sizeof(ino) < sizeof(fileid)) 105 ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8; 106 return ino; 107 } 108 109 int nfs_drop_inode(struct inode *inode) 110 { 111 return NFS_STALE(inode) || generic_drop_inode(inode); 112 } 113 EXPORT_SYMBOL_GPL(nfs_drop_inode); 114 115 void nfs_clear_inode(struct inode *inode) 116 { 117 /* 118 * The following should never happen... 119 */ 120 WARN_ON_ONCE(nfs_have_writebacks(inode)); 121 WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files)); 122 nfs_zap_acl_cache(inode); 123 nfs_access_zap_cache(inode); 124 nfs_fscache_release_inode_cookie(inode); 125 } 126 EXPORT_SYMBOL_GPL(nfs_clear_inode); 127 128 void nfs_evict_inode(struct inode *inode) 129 { 130 truncate_inode_pages(&inode->i_data, 0); 131 clear_inode(inode); 132 nfs_clear_inode(inode); 133 } 134 135 /** 136 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk 137 */ 138 int nfs_sync_mapping(struct address_space *mapping) 139 { 140 int ret = 0; 141 142 if (mapping->nrpages != 0) { 143 unmap_mapping_range(mapping, 0, 0, 0); 144 ret = nfs_wb_all(mapping->host); 145 } 146 return ret; 147 } 148 149 /* 150 * Invalidate the local caches 151 */ 152 static void nfs_zap_caches_locked(struct inode *inode) 153 { 154 struct nfs_inode *nfsi = NFS_I(inode); 155 int mode = inode->i_mode; 156 157 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 158 159 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 160 nfsi->attrtimeo_timestamp = jiffies; 161 162 memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf)); 163 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) { 164 nfs_fscache_invalidate(inode); 165 nfsi->cache_validity |= NFS_INO_INVALID_ATTR 166 | NFS_INO_INVALID_LABEL 167 | NFS_INO_INVALID_DATA 168 | NFS_INO_INVALID_ACCESS 169 | NFS_INO_INVALID_ACL 170 | NFS_INO_REVAL_PAGECACHE; 171 } else 172 nfsi->cache_validity |= NFS_INO_INVALID_ATTR 173 | NFS_INO_INVALID_LABEL 174 | NFS_INO_INVALID_ACCESS 175 | NFS_INO_INVALID_ACL 176 | NFS_INO_REVAL_PAGECACHE; 177 } 178 179 void nfs_zap_caches(struct inode *inode) 180 { 181 spin_lock(&inode->i_lock); 182 nfs_zap_caches_locked(inode); 183 spin_unlock(&inode->i_lock); 184 } 185 186 void nfs_zap_mapping(struct inode *inode, struct address_space *mapping) 187 { 188 if (mapping->nrpages != 0) { 189 spin_lock(&inode->i_lock); 190 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA; 191 nfs_fscache_invalidate(inode); 192 spin_unlock(&inode->i_lock); 193 } 194 } 195 196 void nfs_zap_acl_cache(struct inode *inode) 197 { 198 void (*clear_acl_cache)(struct inode *); 199 200 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache; 201 if (clear_acl_cache != NULL) 202 clear_acl_cache(inode); 203 spin_lock(&inode->i_lock); 204 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL; 205 spin_unlock(&inode->i_lock); 206 } 207 EXPORT_SYMBOL_GPL(nfs_zap_acl_cache); 208 209 void nfs_invalidate_atime(struct inode *inode) 210 { 211 spin_lock(&inode->i_lock); 212 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME; 213 spin_unlock(&inode->i_lock); 214 } 215 EXPORT_SYMBOL_GPL(nfs_invalidate_atime); 216 217 /* 218 * Invalidate, but do not unhash, the inode. 219 * NB: must be called with inode->i_lock held! 220 */ 221 static void nfs_invalidate_inode(struct inode *inode) 222 { 223 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 224 nfs_zap_caches_locked(inode); 225 } 226 227 struct nfs_find_desc { 228 struct nfs_fh *fh; 229 struct nfs_fattr *fattr; 230 }; 231 232 /* 233 * In NFSv3 we can have 64bit inode numbers. In order to support 234 * this, and re-exported directories (also seen in NFSv2) 235 * we are forced to allow 2 different inodes to have the same 236 * i_ino. 237 */ 238 static int 239 nfs_find_actor(struct inode *inode, void *opaque) 240 { 241 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque; 242 struct nfs_fh *fh = desc->fh; 243 struct nfs_fattr *fattr = desc->fattr; 244 245 if (NFS_FILEID(inode) != fattr->fileid) 246 return 0; 247 if ((S_IFMT & inode->i_mode) != (S_IFMT & fattr->mode)) 248 return 0; 249 if (nfs_compare_fh(NFS_FH(inode), fh)) 250 return 0; 251 if (is_bad_inode(inode) || NFS_STALE(inode)) 252 return 0; 253 return 1; 254 } 255 256 static int 257 nfs_init_locked(struct inode *inode, void *opaque) 258 { 259 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque; 260 struct nfs_fattr *fattr = desc->fattr; 261 262 set_nfs_fileid(inode, fattr->fileid); 263 nfs_copy_fh(NFS_FH(inode), desc->fh); 264 return 0; 265 } 266 267 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 268 void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr, 269 struct nfs4_label *label) 270 { 271 int error; 272 273 if (label == NULL) 274 return; 275 276 if (nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL) == 0) 277 return; 278 279 if (NFS_SERVER(inode)->nfs_client->cl_minorversion < 2) 280 return; 281 282 if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) && inode->i_security) { 283 error = security_inode_notifysecctx(inode, label->label, 284 label->len); 285 if (error) 286 printk(KERN_ERR "%s() %s %d " 287 "security_inode_notifysecctx() %d\n", 288 __func__, 289 (char *)label->label, 290 label->len, error); 291 } 292 } 293 294 struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags) 295 { 296 struct nfs4_label *label = NULL; 297 int minor_version = server->nfs_client->cl_minorversion; 298 299 if (minor_version < 2) 300 return label; 301 302 if (!(server->caps & NFS_CAP_SECURITY_LABEL)) 303 return label; 304 305 label = kzalloc(sizeof(struct nfs4_label), flags); 306 if (label == NULL) 307 return ERR_PTR(-ENOMEM); 308 309 label->label = kzalloc(NFS4_MAXLABELLEN, flags); 310 if (label->label == NULL) { 311 kfree(label); 312 return ERR_PTR(-ENOMEM); 313 } 314 label->len = NFS4_MAXLABELLEN; 315 316 return label; 317 } 318 EXPORT_SYMBOL_GPL(nfs4_label_alloc); 319 #else 320 void inline nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr, 321 struct nfs4_label *label) 322 { 323 } 324 #endif 325 EXPORT_SYMBOL_GPL(nfs_setsecurity); 326 327 /* 328 * This is our front-end to iget that looks up inodes by file handle 329 * instead of inode number. 330 */ 331 struct inode * 332 nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, struct nfs4_label *label) 333 { 334 struct nfs_find_desc desc = { 335 .fh = fh, 336 .fattr = fattr 337 }; 338 struct inode *inode = ERR_PTR(-ENOENT); 339 unsigned long hash; 340 341 nfs_attr_check_mountpoint(sb, fattr); 342 343 if (((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0) && 344 !nfs_attr_use_mounted_on_fileid(fattr)) 345 goto out_no_inode; 346 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0) 347 goto out_no_inode; 348 349 hash = nfs_fattr_to_ino_t(fattr); 350 351 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc); 352 if (inode == NULL) { 353 inode = ERR_PTR(-ENOMEM); 354 goto out_no_inode; 355 } 356 357 if (inode->i_state & I_NEW) { 358 struct nfs_inode *nfsi = NFS_I(inode); 359 unsigned long now = jiffies; 360 361 /* We set i_ino for the few things that still rely on it, 362 * such as stat(2) */ 363 inode->i_ino = hash; 364 365 /* We can't support update_atime(), since the server will reset it */ 366 inode->i_flags |= S_NOATIME|S_NOCMTIME; 367 inode->i_mode = fattr->mode; 368 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0 369 && nfs_server_capable(inode, NFS_CAP_MODE)) 370 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 371 /* Why so? Because we want revalidate for devices/FIFOs, and 372 * that's precisely what we have in nfs_file_inode_operations. 373 */ 374 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops; 375 if (S_ISREG(inode->i_mode)) { 376 inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops; 377 inode->i_data.a_ops = &nfs_file_aops; 378 inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info; 379 } else if (S_ISDIR(inode->i_mode)) { 380 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops; 381 inode->i_fop = &nfs_dir_operations; 382 inode->i_data.a_ops = &nfs_dir_aops; 383 /* Deal with crossing mountpoints */ 384 if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT || 385 fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) { 386 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) 387 inode->i_op = &nfs_referral_inode_operations; 388 else 389 inode->i_op = &nfs_mountpoint_inode_operations; 390 inode->i_fop = NULL; 391 inode->i_flags |= S_AUTOMOUNT; 392 } 393 } else if (S_ISLNK(inode->i_mode)) 394 inode->i_op = &nfs_symlink_inode_operations; 395 else 396 init_special_inode(inode, inode->i_mode, fattr->rdev); 397 398 memset(&inode->i_atime, 0, sizeof(inode->i_atime)); 399 memset(&inode->i_mtime, 0, sizeof(inode->i_mtime)); 400 memset(&inode->i_ctime, 0, sizeof(inode->i_ctime)); 401 inode->i_version = 0; 402 inode->i_size = 0; 403 clear_nlink(inode); 404 inode->i_uid = make_kuid(&init_user_ns, -2); 405 inode->i_gid = make_kgid(&init_user_ns, -2); 406 inode->i_blocks = 0; 407 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf)); 408 nfsi->write_io = 0; 409 nfsi->read_io = 0; 410 411 nfsi->read_cache_jiffies = fattr->time_start; 412 nfsi->attr_gencount = fattr->gencount; 413 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 414 inode->i_atime = fattr->atime; 415 else if (nfs_server_capable(inode, NFS_CAP_ATIME)) 416 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 417 if (fattr->valid & NFS_ATTR_FATTR_MTIME) 418 inode->i_mtime = fattr->mtime; 419 else if (nfs_server_capable(inode, NFS_CAP_MTIME)) 420 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 421 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 422 inode->i_ctime = fattr->ctime; 423 else if (nfs_server_capable(inode, NFS_CAP_CTIME)) 424 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 425 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) 426 inode->i_version = fattr->change_attr; 427 else if (nfs_server_capable(inode, NFS_CAP_CHANGE_ATTR)) 428 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 429 if (fattr->valid & NFS_ATTR_FATTR_SIZE) 430 inode->i_size = nfs_size_to_loff_t(fattr->size); 431 else 432 nfsi->cache_validity |= NFS_INO_INVALID_ATTR 433 | NFS_INO_REVAL_PAGECACHE; 434 if (fattr->valid & NFS_ATTR_FATTR_NLINK) 435 set_nlink(inode, fattr->nlink); 436 else if (nfs_server_capable(inode, NFS_CAP_NLINK)) 437 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 438 if (fattr->valid & NFS_ATTR_FATTR_OWNER) 439 inode->i_uid = fattr->uid; 440 else if (nfs_server_capable(inode, NFS_CAP_OWNER)) 441 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 442 if (fattr->valid & NFS_ATTR_FATTR_GROUP) 443 inode->i_gid = fattr->gid; 444 else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP)) 445 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 446 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) 447 inode->i_blocks = fattr->du.nfs2.blocks; 448 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { 449 /* 450 * report the blocks in 512byte units 451 */ 452 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 453 } 454 455 nfs_setsecurity(inode, fattr, label); 456 457 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 458 nfsi->attrtimeo_timestamp = now; 459 nfsi->access_cache = RB_ROOT; 460 461 nfs_fscache_init_inode_cookie(inode); 462 463 unlock_new_inode(inode); 464 } else 465 nfs_refresh_inode(inode, fattr); 466 dprintk("NFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n", 467 inode->i_sb->s_id, 468 (long long)NFS_FILEID(inode), 469 nfs_display_fhandle_hash(fh), 470 atomic_read(&inode->i_count)); 471 472 out: 473 return inode; 474 475 out_no_inode: 476 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode)); 477 goto out; 478 } 479 EXPORT_SYMBOL_GPL(nfs_fhget); 480 481 #define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE|ATTR_OPEN) 482 483 int 484 nfs_setattr(struct dentry *dentry, struct iattr *attr) 485 { 486 struct inode *inode = dentry->d_inode; 487 struct nfs_fattr *fattr; 488 int error = -ENOMEM; 489 490 nfs_inc_stats(inode, NFSIOS_VFSSETATTR); 491 492 /* skip mode change if it's just for clearing setuid/setgid */ 493 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) 494 attr->ia_valid &= ~ATTR_MODE; 495 496 if (attr->ia_valid & ATTR_SIZE) { 497 if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode)) 498 attr->ia_valid &= ~ATTR_SIZE; 499 } 500 501 /* Optimization: if the end result is no change, don't RPC */ 502 attr->ia_valid &= NFS_VALID_ATTRS; 503 if ((attr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0) 504 return 0; 505 506 /* Write all dirty data */ 507 if (S_ISREG(inode->i_mode)) { 508 nfs_inode_dio_wait(inode); 509 nfs_wb_all(inode); 510 } 511 512 fattr = nfs_alloc_fattr(); 513 if (fattr == NULL) 514 goto out; 515 /* 516 * Return any delegations if we're going to change ACLs 517 */ 518 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) 519 NFS_PROTO(inode)->return_delegation(inode); 520 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr); 521 if (error == 0) 522 error = nfs_refresh_inode(inode, fattr); 523 nfs_free_fattr(fattr); 524 out: 525 return error; 526 } 527 EXPORT_SYMBOL_GPL(nfs_setattr); 528 529 /** 530 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall 531 * @inode: inode of the file used 532 * @offset: file offset to start truncating 533 * 534 * This is a copy of the common vmtruncate, but with the locking 535 * corrected to take into account the fact that NFS requires 536 * inode->i_size to be updated under the inode->i_lock. 537 */ 538 static int nfs_vmtruncate(struct inode * inode, loff_t offset) 539 { 540 loff_t oldsize; 541 int err; 542 543 err = inode_newsize_ok(inode, offset); 544 if (err) 545 goto out; 546 547 spin_lock(&inode->i_lock); 548 oldsize = inode->i_size; 549 i_size_write(inode, offset); 550 spin_unlock(&inode->i_lock); 551 552 truncate_pagecache(inode, oldsize, offset); 553 out: 554 return err; 555 } 556 557 /** 558 * nfs_setattr_update_inode - Update inode metadata after a setattr call. 559 * @inode: pointer to struct inode 560 * @attr: pointer to struct iattr 561 * 562 * Note: we do this in the *proc.c in order to ensure that 563 * it works for things like exclusive creates too. 564 */ 565 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr) 566 { 567 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) { 568 spin_lock(&inode->i_lock); 569 if ((attr->ia_valid & ATTR_MODE) != 0) { 570 int mode = attr->ia_mode & S_IALLUGO; 571 mode |= inode->i_mode & ~S_IALLUGO; 572 inode->i_mode = mode; 573 } 574 if ((attr->ia_valid & ATTR_UID) != 0) 575 inode->i_uid = attr->ia_uid; 576 if ((attr->ia_valid & ATTR_GID) != 0) 577 inode->i_gid = attr->ia_gid; 578 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 579 spin_unlock(&inode->i_lock); 580 } 581 if ((attr->ia_valid & ATTR_SIZE) != 0) { 582 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC); 583 nfs_vmtruncate(inode, attr->ia_size); 584 } 585 } 586 EXPORT_SYMBOL_GPL(nfs_setattr_update_inode); 587 588 int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 589 { 590 struct inode *inode = dentry->d_inode; 591 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME; 592 int err; 593 594 /* Flush out writes to the server in order to update c/mtime. */ 595 if (S_ISREG(inode->i_mode)) { 596 nfs_inode_dio_wait(inode); 597 err = filemap_write_and_wait(inode->i_mapping); 598 if (err) 599 goto out; 600 } 601 602 /* 603 * We may force a getattr if the user cares about atime. 604 * 605 * Note that we only have to check the vfsmount flags here: 606 * - NFS always sets S_NOATIME by so checking it would give a 607 * bogus result 608 * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is 609 * no point in checking those. 610 */ 611 if ((mnt->mnt_flags & MNT_NOATIME) || 612 ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))) 613 need_atime = 0; 614 615 if (need_atime) 616 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 617 else 618 err = nfs_revalidate_inode(NFS_SERVER(inode), inode); 619 if (!err) { 620 generic_fillattr(inode, stat); 621 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode)); 622 } 623 out: 624 return err; 625 } 626 EXPORT_SYMBOL_GPL(nfs_getattr); 627 628 static void nfs_init_lock_context(struct nfs_lock_context *l_ctx) 629 { 630 atomic_set(&l_ctx->count, 1); 631 l_ctx->lockowner.l_owner = current->files; 632 l_ctx->lockowner.l_pid = current->tgid; 633 INIT_LIST_HEAD(&l_ctx->list); 634 nfs_iocounter_init(&l_ctx->io_count); 635 } 636 637 static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx) 638 { 639 struct nfs_lock_context *head = &ctx->lock_context; 640 struct nfs_lock_context *pos = head; 641 642 do { 643 if (pos->lockowner.l_owner != current->files) 644 continue; 645 if (pos->lockowner.l_pid != current->tgid) 646 continue; 647 atomic_inc(&pos->count); 648 return pos; 649 } while ((pos = list_entry(pos->list.next, typeof(*pos), list)) != head); 650 return NULL; 651 } 652 653 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx) 654 { 655 struct nfs_lock_context *res, *new = NULL; 656 struct inode *inode = ctx->dentry->d_inode; 657 658 spin_lock(&inode->i_lock); 659 res = __nfs_find_lock_context(ctx); 660 if (res == NULL) { 661 spin_unlock(&inode->i_lock); 662 new = kmalloc(sizeof(*new), GFP_KERNEL); 663 if (new == NULL) 664 return ERR_PTR(-ENOMEM); 665 nfs_init_lock_context(new); 666 spin_lock(&inode->i_lock); 667 res = __nfs_find_lock_context(ctx); 668 if (res == NULL) { 669 list_add_tail(&new->list, &ctx->lock_context.list); 670 new->open_context = ctx; 671 res = new; 672 new = NULL; 673 } 674 } 675 spin_unlock(&inode->i_lock); 676 kfree(new); 677 return res; 678 } 679 680 void nfs_put_lock_context(struct nfs_lock_context *l_ctx) 681 { 682 struct nfs_open_context *ctx = l_ctx->open_context; 683 struct inode *inode = ctx->dentry->d_inode; 684 685 if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock)) 686 return; 687 list_del(&l_ctx->list); 688 spin_unlock(&inode->i_lock); 689 kfree(l_ctx); 690 } 691 692 /** 693 * nfs_close_context - Common close_context() routine NFSv2/v3 694 * @ctx: pointer to context 695 * @is_sync: is this a synchronous close 696 * 697 * always ensure that the attributes are up to date if we're mounted 698 * with close-to-open semantics 699 */ 700 void nfs_close_context(struct nfs_open_context *ctx, int is_sync) 701 { 702 struct inode *inode; 703 struct nfs_server *server; 704 705 if (!(ctx->mode & FMODE_WRITE)) 706 return; 707 if (!is_sync) 708 return; 709 inode = ctx->dentry->d_inode; 710 if (!list_empty(&NFS_I(inode)->open_files)) 711 return; 712 server = NFS_SERVER(inode); 713 if (server->flags & NFS_MOUNT_NOCTO) 714 return; 715 nfs_revalidate_inode(server, inode); 716 } 717 EXPORT_SYMBOL_GPL(nfs_close_context); 718 719 struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode) 720 { 721 struct nfs_open_context *ctx; 722 struct rpc_cred *cred = rpc_lookup_cred(); 723 if (IS_ERR(cred)) 724 return ERR_CAST(cred); 725 726 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); 727 if (!ctx) { 728 put_rpccred(cred); 729 return ERR_PTR(-ENOMEM); 730 } 731 nfs_sb_active(dentry->d_sb); 732 ctx->dentry = dget(dentry); 733 ctx->cred = cred; 734 ctx->state = NULL; 735 ctx->mode = f_mode; 736 ctx->flags = 0; 737 ctx->error = 0; 738 nfs_init_lock_context(&ctx->lock_context); 739 ctx->lock_context.open_context = ctx; 740 INIT_LIST_HEAD(&ctx->list); 741 ctx->mdsthreshold = NULL; 742 return ctx; 743 } 744 EXPORT_SYMBOL_GPL(alloc_nfs_open_context); 745 746 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx) 747 { 748 if (ctx != NULL) 749 atomic_inc(&ctx->lock_context.count); 750 return ctx; 751 } 752 EXPORT_SYMBOL_GPL(get_nfs_open_context); 753 754 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync) 755 { 756 struct inode *inode = ctx->dentry->d_inode; 757 struct super_block *sb = ctx->dentry->d_sb; 758 759 if (!list_empty(&ctx->list)) { 760 if (!atomic_dec_and_lock(&ctx->lock_context.count, &inode->i_lock)) 761 return; 762 list_del(&ctx->list); 763 spin_unlock(&inode->i_lock); 764 } else if (!atomic_dec_and_test(&ctx->lock_context.count)) 765 return; 766 if (inode != NULL) 767 NFS_PROTO(inode)->close_context(ctx, is_sync); 768 if (ctx->cred != NULL) 769 put_rpccred(ctx->cred); 770 dput(ctx->dentry); 771 nfs_sb_deactive(sb); 772 kfree(ctx->mdsthreshold); 773 kfree(ctx); 774 } 775 776 void put_nfs_open_context(struct nfs_open_context *ctx) 777 { 778 __put_nfs_open_context(ctx, 0); 779 } 780 EXPORT_SYMBOL_GPL(put_nfs_open_context); 781 782 /* 783 * Ensure that mmap has a recent RPC credential for use when writing out 784 * shared pages 785 */ 786 void nfs_inode_attach_open_context(struct nfs_open_context *ctx) 787 { 788 struct inode *inode = ctx->dentry->d_inode; 789 struct nfs_inode *nfsi = NFS_I(inode); 790 791 spin_lock(&inode->i_lock); 792 list_add(&ctx->list, &nfsi->open_files); 793 spin_unlock(&inode->i_lock); 794 } 795 EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context); 796 797 void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx) 798 { 799 filp->private_data = get_nfs_open_context(ctx); 800 if (list_empty(&ctx->list)) 801 nfs_inode_attach_open_context(ctx); 802 } 803 EXPORT_SYMBOL_GPL(nfs_file_set_open_context); 804 805 /* 806 * Given an inode, search for an open context with the desired characteristics 807 */ 808 struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode) 809 { 810 struct nfs_inode *nfsi = NFS_I(inode); 811 struct nfs_open_context *pos, *ctx = NULL; 812 813 spin_lock(&inode->i_lock); 814 list_for_each_entry(pos, &nfsi->open_files, list) { 815 if (cred != NULL && pos->cred != cred) 816 continue; 817 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode) 818 continue; 819 ctx = get_nfs_open_context(pos); 820 break; 821 } 822 spin_unlock(&inode->i_lock); 823 return ctx; 824 } 825 826 static void nfs_file_clear_open_context(struct file *filp) 827 { 828 struct nfs_open_context *ctx = nfs_file_open_context(filp); 829 830 if (ctx) { 831 struct inode *inode = ctx->dentry->d_inode; 832 833 filp->private_data = NULL; 834 spin_lock(&inode->i_lock); 835 list_move_tail(&ctx->list, &NFS_I(inode)->open_files); 836 spin_unlock(&inode->i_lock); 837 __put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1); 838 } 839 } 840 841 /* 842 * These allocate and release file read/write context information. 843 */ 844 int nfs_open(struct inode *inode, struct file *filp) 845 { 846 struct nfs_open_context *ctx; 847 848 ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode); 849 if (IS_ERR(ctx)) 850 return PTR_ERR(ctx); 851 nfs_file_set_open_context(filp, ctx); 852 put_nfs_open_context(ctx); 853 nfs_fscache_set_inode_cookie(inode, filp); 854 return 0; 855 } 856 857 int nfs_release(struct inode *inode, struct file *filp) 858 { 859 nfs_file_clear_open_context(filp); 860 return 0; 861 } 862 863 /* 864 * This function is called whenever some part of NFS notices that 865 * the cached attributes have to be refreshed. 866 */ 867 int 868 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 869 { 870 int status = -ESTALE; 871 struct nfs4_label *label = NULL; 872 struct nfs_fattr *fattr = NULL; 873 struct nfs_inode *nfsi = NFS_I(inode); 874 875 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n", 876 inode->i_sb->s_id, (long long)NFS_FILEID(inode)); 877 878 if (is_bad_inode(inode)) 879 goto out; 880 if (NFS_STALE(inode)) 881 goto out; 882 883 status = -ENOMEM; 884 fattr = nfs_alloc_fattr(); 885 if (fattr == NULL) 886 goto out; 887 888 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE); 889 890 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL); 891 if (IS_ERR(label)) { 892 status = PTR_ERR(label); 893 goto out; 894 } 895 896 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, label); 897 if (status != 0) { 898 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n", 899 inode->i_sb->s_id, 900 (long long)NFS_FILEID(inode), status); 901 if (status == -ESTALE) { 902 nfs_zap_caches(inode); 903 if (!S_ISDIR(inode->i_mode)) 904 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 905 } 906 goto err_out; 907 } 908 909 status = nfs_refresh_inode(inode, fattr); 910 if (status) { 911 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n", 912 inode->i_sb->s_id, 913 (long long)NFS_FILEID(inode), status); 914 goto err_out; 915 } 916 917 if (nfsi->cache_validity & NFS_INO_INVALID_ACL) 918 nfs_zap_acl_cache(inode); 919 920 dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n", 921 inode->i_sb->s_id, 922 (long long)NFS_FILEID(inode)); 923 924 err_out: 925 nfs4_label_free(label); 926 out: 927 nfs_free_fattr(fattr); 928 return status; 929 } 930 931 int nfs_attribute_timeout(struct inode *inode) 932 { 933 struct nfs_inode *nfsi = NFS_I(inode); 934 935 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo); 936 } 937 938 int nfs_attribute_cache_expired(struct inode *inode) 939 { 940 if (nfs_have_delegated_attributes(inode)) 941 return 0; 942 return nfs_attribute_timeout(inode); 943 } 944 945 /** 946 * nfs_revalidate_inode - Revalidate the inode attributes 947 * @server - pointer to nfs_server struct 948 * @inode - pointer to inode struct 949 * 950 * Updates inode attribute information by retrieving the data from the server. 951 */ 952 int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 953 { 954 if (!(NFS_I(inode)->cache_validity & 955 (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL)) 956 && !nfs_attribute_cache_expired(inode)) 957 return NFS_STALE(inode) ? -ESTALE : 0; 958 return __nfs_revalidate_inode(server, inode); 959 } 960 EXPORT_SYMBOL_GPL(nfs_revalidate_inode); 961 962 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping) 963 { 964 struct nfs_inode *nfsi = NFS_I(inode); 965 int ret; 966 967 if (mapping->nrpages != 0) { 968 if (S_ISREG(inode->i_mode)) { 969 ret = nfs_sync_mapping(mapping); 970 if (ret < 0) 971 return ret; 972 } 973 ret = invalidate_inode_pages2(mapping); 974 if (ret < 0) 975 return ret; 976 } 977 spin_lock(&inode->i_lock); 978 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA; 979 if (S_ISDIR(inode->i_mode)) 980 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf)); 981 spin_unlock(&inode->i_lock); 982 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE); 983 nfs_fscache_wait_on_invalidate(inode); 984 dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n", 985 inode->i_sb->s_id, (long long)NFS_FILEID(inode)); 986 return 0; 987 } 988 989 static bool nfs_mapping_need_revalidate_inode(struct inode *inode) 990 { 991 if (nfs_have_delegated_attributes(inode)) 992 return false; 993 return (NFS_I(inode)->cache_validity & NFS_INO_REVAL_PAGECACHE) 994 || nfs_attribute_timeout(inode) 995 || NFS_STALE(inode); 996 } 997 998 /** 999 * nfs_revalidate_mapping - Revalidate the pagecache 1000 * @inode - pointer to host inode 1001 * @mapping - pointer to mapping 1002 */ 1003 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) 1004 { 1005 struct nfs_inode *nfsi = NFS_I(inode); 1006 int ret = 0; 1007 1008 /* swapfiles are not supposed to be shared. */ 1009 if (IS_SWAPFILE(inode)) 1010 goto out; 1011 1012 if (nfs_mapping_need_revalidate_inode(inode)) { 1013 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 1014 if (ret < 0) 1015 goto out; 1016 } 1017 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 1018 ret = nfs_invalidate_mapping(inode, mapping); 1019 out: 1020 return ret; 1021 } 1022 1023 static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1024 { 1025 struct nfs_inode *nfsi = NFS_I(inode); 1026 unsigned long ret = 0; 1027 1028 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE) 1029 && (fattr->valid & NFS_ATTR_FATTR_CHANGE) 1030 && inode->i_version == fattr->pre_change_attr) { 1031 inode->i_version = fattr->change_attr; 1032 if (S_ISDIR(inode->i_mode)) 1033 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 1034 ret |= NFS_INO_INVALID_ATTR; 1035 } 1036 /* If we have atomic WCC data, we may update some attributes */ 1037 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME) 1038 && (fattr->valid & NFS_ATTR_FATTR_CTIME) 1039 && timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) { 1040 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); 1041 ret |= NFS_INO_INVALID_ATTR; 1042 } 1043 1044 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME) 1045 && (fattr->valid & NFS_ATTR_FATTR_MTIME) 1046 && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) { 1047 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); 1048 if (S_ISDIR(inode->i_mode)) 1049 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 1050 ret |= NFS_INO_INVALID_ATTR; 1051 } 1052 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE) 1053 && (fattr->valid & NFS_ATTR_FATTR_SIZE) 1054 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size) 1055 && nfsi->npages == 0) { 1056 i_size_write(inode, nfs_size_to_loff_t(fattr->size)); 1057 ret |= NFS_INO_INVALID_ATTR; 1058 } 1059 1060 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 1061 nfs_fscache_invalidate(inode); 1062 1063 return ret; 1064 } 1065 1066 /** 1067 * nfs_check_inode_attributes - verify consistency of the inode attribute cache 1068 * @inode - pointer to inode 1069 * @fattr - updated attributes 1070 * 1071 * Verifies the attribute cache. If we have just changed the attributes, 1072 * so that fattr carries weak cache consistency data, then it may 1073 * also update the ctime/mtime/change_attribute. 1074 */ 1075 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr) 1076 { 1077 struct nfs_inode *nfsi = NFS_I(inode); 1078 loff_t cur_size, new_isize; 1079 unsigned long invalid = 0; 1080 1081 1082 if (nfs_have_delegated_attributes(inode)) 1083 return 0; 1084 /* Has the inode gone and changed behind our back? */ 1085 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) 1086 return -EIO; 1087 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) 1088 return -EIO; 1089 1090 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 1091 inode->i_version != fattr->change_attr) 1092 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 1093 1094 /* Verify a few of the more important attributes */ 1095 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime)) 1096 invalid |= NFS_INO_INVALID_ATTR; 1097 1098 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 1099 cur_size = i_size_read(inode); 1100 new_isize = nfs_size_to_loff_t(fattr->size); 1101 if (cur_size != new_isize && nfsi->npages == 0) 1102 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 1103 } 1104 1105 /* Have any file permissions changed? */ 1106 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) 1107 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 1108 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid)) 1109 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 1110 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid)) 1111 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 1112 1113 /* Has the link count changed? */ 1114 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink) 1115 invalid |= NFS_INO_INVALID_ATTR; 1116 1117 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime)) 1118 invalid |= NFS_INO_INVALID_ATIME; 1119 1120 if (invalid != 0) 1121 nfsi->cache_validity |= invalid; 1122 1123 nfsi->read_cache_jiffies = fattr->time_start; 1124 return 0; 1125 } 1126 1127 static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 1128 { 1129 if (!(fattr->valid & NFS_ATTR_FATTR_CTIME)) 1130 return 0; 1131 return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0; 1132 } 1133 1134 static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 1135 { 1136 if (!(fattr->valid & NFS_ATTR_FATTR_SIZE)) 1137 return 0; 1138 return nfs_size_to_loff_t(fattr->size) > i_size_read(inode); 1139 } 1140 1141 static atomic_long_t nfs_attr_generation_counter; 1142 1143 static unsigned long nfs_read_attr_generation_counter(void) 1144 { 1145 return atomic_long_read(&nfs_attr_generation_counter); 1146 } 1147 1148 unsigned long nfs_inc_attr_generation_counter(void) 1149 { 1150 return atomic_long_inc_return(&nfs_attr_generation_counter); 1151 } 1152 1153 void nfs_fattr_init(struct nfs_fattr *fattr) 1154 { 1155 fattr->valid = 0; 1156 fattr->time_start = jiffies; 1157 fattr->gencount = nfs_inc_attr_generation_counter(); 1158 fattr->owner_name = NULL; 1159 fattr->group_name = NULL; 1160 } 1161 EXPORT_SYMBOL_GPL(nfs_fattr_init); 1162 1163 struct nfs_fattr *nfs_alloc_fattr(void) 1164 { 1165 struct nfs_fattr *fattr; 1166 1167 fattr = kmalloc(sizeof(*fattr), GFP_NOFS); 1168 if (fattr != NULL) 1169 nfs_fattr_init(fattr); 1170 return fattr; 1171 } 1172 EXPORT_SYMBOL_GPL(nfs_alloc_fattr); 1173 1174 struct nfs_fh *nfs_alloc_fhandle(void) 1175 { 1176 struct nfs_fh *fh; 1177 1178 fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS); 1179 if (fh != NULL) 1180 fh->size = 0; 1181 return fh; 1182 } 1183 EXPORT_SYMBOL_GPL(nfs_alloc_fhandle); 1184 1185 #ifdef NFS_DEBUG 1186 /* 1187 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle 1188 * in the same way that wireshark does 1189 * 1190 * @fh: file handle 1191 * 1192 * For debugging only. 1193 */ 1194 u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh) 1195 { 1196 /* wireshark uses 32-bit AUTODIN crc and does a bitwise 1197 * not on the result */ 1198 return ~crc32(0xFFFFFFFF, &fh->data[0], fh->size); 1199 } 1200 1201 /* 1202 * _nfs_display_fhandle - display an NFS file handle on the console 1203 * 1204 * @fh: file handle to display 1205 * @caption: display caption 1206 * 1207 * For debugging only. 1208 */ 1209 void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption) 1210 { 1211 unsigned short i; 1212 1213 if (fh == NULL || fh->size == 0) { 1214 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh); 1215 return; 1216 } 1217 1218 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n", 1219 caption, fh, fh->size, _nfs_display_fhandle_hash(fh)); 1220 for (i = 0; i < fh->size; i += 16) { 1221 __be32 *pos = (__be32 *)&fh->data[i]; 1222 1223 switch ((fh->size - i - 1) >> 2) { 1224 case 0: 1225 printk(KERN_DEFAULT " %08x\n", 1226 be32_to_cpup(pos)); 1227 break; 1228 case 1: 1229 printk(KERN_DEFAULT " %08x %08x\n", 1230 be32_to_cpup(pos), be32_to_cpup(pos + 1)); 1231 break; 1232 case 2: 1233 printk(KERN_DEFAULT " %08x %08x %08x\n", 1234 be32_to_cpup(pos), be32_to_cpup(pos + 1), 1235 be32_to_cpup(pos + 2)); 1236 break; 1237 default: 1238 printk(KERN_DEFAULT " %08x %08x %08x %08x\n", 1239 be32_to_cpup(pos), be32_to_cpup(pos + 1), 1240 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3)); 1241 } 1242 } 1243 } 1244 #endif 1245 1246 /** 1247 * nfs_inode_attrs_need_update - check if the inode attributes need updating 1248 * @inode - pointer to inode 1249 * @fattr - attributes 1250 * 1251 * Attempt to divine whether or not an RPC call reply carrying stale 1252 * attributes got scheduled after another call carrying updated ones. 1253 * 1254 * To do so, the function first assumes that a more recent ctime means 1255 * that the attributes in fattr are newer, however it also attempt to 1256 * catch the case where ctime either didn't change, or went backwards 1257 * (if someone reset the clock on the server) by looking at whether 1258 * or not this RPC call was started after the inode was last updated. 1259 * Note also the check for wraparound of 'attr_gencount' 1260 * 1261 * The function returns 'true' if it thinks the attributes in 'fattr' are 1262 * more recent than the ones cached in the inode. 1263 * 1264 */ 1265 static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 1266 { 1267 const struct nfs_inode *nfsi = NFS_I(inode); 1268 1269 return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 || 1270 nfs_ctime_need_update(inode, fattr) || 1271 nfs_size_need_update(inode, fattr) || 1272 ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0); 1273 } 1274 1275 static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr) 1276 { 1277 if (nfs_inode_attrs_need_update(inode, fattr)) 1278 return nfs_update_inode(inode, fattr); 1279 return nfs_check_inode_attributes(inode, fattr); 1280 } 1281 1282 /** 1283 * nfs_refresh_inode - try to update the inode attribute cache 1284 * @inode - pointer to inode 1285 * @fattr - updated attributes 1286 * 1287 * Check that an RPC call that returned attributes has not overlapped with 1288 * other recent updates of the inode metadata, then decide whether it is 1289 * safe to do a full update of the inode attributes, or whether just to 1290 * call nfs_check_inode_attributes. 1291 */ 1292 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr) 1293 { 1294 int status; 1295 1296 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 1297 return 0; 1298 spin_lock(&inode->i_lock); 1299 status = nfs_refresh_inode_locked(inode, fattr); 1300 spin_unlock(&inode->i_lock); 1301 1302 return status; 1303 } 1304 EXPORT_SYMBOL_GPL(nfs_refresh_inode); 1305 1306 static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr) 1307 { 1308 struct nfs_inode *nfsi = NFS_I(inode); 1309 1310 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 1311 if (S_ISDIR(inode->i_mode)) { 1312 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 1313 nfs_fscache_invalidate(inode); 1314 } 1315 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 1316 return 0; 1317 return nfs_refresh_inode_locked(inode, fattr); 1318 } 1319 1320 /** 1321 * nfs_post_op_update_inode - try to update the inode attribute cache 1322 * @inode - pointer to inode 1323 * @fattr - updated attributes 1324 * 1325 * After an operation that has changed the inode metadata, mark the 1326 * attribute cache as being invalid, then try to update it. 1327 * 1328 * NB: if the server didn't return any post op attributes, this 1329 * function will force the retrieval of attributes before the next 1330 * NFS request. Thus it should be used only for operations that 1331 * are expected to change one or more attributes, to avoid 1332 * unnecessary NFS requests and trips through nfs_update_inode(). 1333 */ 1334 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1335 { 1336 int status; 1337 1338 spin_lock(&inode->i_lock); 1339 status = nfs_post_op_update_inode_locked(inode, fattr); 1340 spin_unlock(&inode->i_lock); 1341 1342 return status; 1343 } 1344 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode); 1345 1346 /** 1347 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache 1348 * @inode - pointer to inode 1349 * @fattr - updated attributes 1350 * 1351 * After an operation that has changed the inode metadata, mark the 1352 * attribute cache as being invalid, then try to update it. Fake up 1353 * weak cache consistency data, if none exist. 1354 * 1355 * This function is mainly designed to be used by the ->write_done() functions. 1356 */ 1357 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr) 1358 { 1359 int status; 1360 1361 spin_lock(&inode->i_lock); 1362 /* Don't do a WCC update if these attributes are already stale */ 1363 if ((fattr->valid & NFS_ATTR_FATTR) == 0 || 1364 !nfs_inode_attrs_need_update(inode, fattr)) { 1365 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE 1366 | NFS_ATTR_FATTR_PRESIZE 1367 | NFS_ATTR_FATTR_PREMTIME 1368 | NFS_ATTR_FATTR_PRECTIME); 1369 goto out_noforce; 1370 } 1371 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 1372 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) { 1373 fattr->pre_change_attr = inode->i_version; 1374 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE; 1375 } 1376 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 && 1377 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) { 1378 memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime)); 1379 fattr->valid |= NFS_ATTR_FATTR_PRECTIME; 1380 } 1381 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 && 1382 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) { 1383 memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime)); 1384 fattr->valid |= NFS_ATTR_FATTR_PREMTIME; 1385 } 1386 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 && 1387 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) { 1388 fattr->pre_size = i_size_read(inode); 1389 fattr->valid |= NFS_ATTR_FATTR_PRESIZE; 1390 } 1391 out_noforce: 1392 status = nfs_post_op_update_inode_locked(inode, fattr); 1393 spin_unlock(&inode->i_lock); 1394 return status; 1395 } 1396 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc); 1397 1398 /* 1399 * Many nfs protocol calls return the new file attributes after 1400 * an operation. Here we update the inode to reflect the state 1401 * of the server's inode. 1402 * 1403 * This is a bit tricky because we have to make sure all dirty pages 1404 * have been sent off to the server before calling invalidate_inode_pages. 1405 * To make sure no other process adds more write requests while we try 1406 * our best to flush them, we make them sleep during the attribute refresh. 1407 * 1408 * A very similar scenario holds for the dir cache. 1409 */ 1410 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1411 { 1412 struct nfs_server *server; 1413 struct nfs_inode *nfsi = NFS_I(inode); 1414 loff_t cur_isize, new_isize; 1415 unsigned long invalid = 0; 1416 unsigned long now = jiffies; 1417 unsigned long save_cache_validity; 1418 1419 dfprintk(VFS, "NFS: %s(%s/%ld fh_crc=0x%08x ct=%d info=0x%x)\n", 1420 __func__, inode->i_sb->s_id, inode->i_ino, 1421 nfs_display_fhandle_hash(NFS_FH(inode)), 1422 atomic_read(&inode->i_count), fattr->valid); 1423 1424 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) { 1425 printk(KERN_ERR "NFS: server %s error: fileid changed\n" 1426 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n", 1427 NFS_SERVER(inode)->nfs_client->cl_hostname, 1428 inode->i_sb->s_id, (long long)nfsi->fileid, 1429 (long long)fattr->fileid); 1430 goto out_err; 1431 } 1432 1433 /* 1434 * Make sure the inode's type hasn't changed. 1435 */ 1436 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) { 1437 /* 1438 * Big trouble! The inode has become a different object. 1439 */ 1440 printk(KERN_DEBUG "NFS: %s: inode %ld mode changed, %07o to %07o\n", 1441 __func__, inode->i_ino, inode->i_mode, fattr->mode); 1442 goto out_err; 1443 } 1444 1445 server = NFS_SERVER(inode); 1446 /* Update the fsid? */ 1447 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) && 1448 !nfs_fsid_equal(&server->fsid, &fattr->fsid) && 1449 !IS_AUTOMOUNT(inode)) 1450 server->fsid = fattr->fsid; 1451 1452 /* 1453 * Update the read time so we don't revalidate too often. 1454 */ 1455 nfsi->read_cache_jiffies = fattr->time_start; 1456 1457 save_cache_validity = nfsi->cache_validity; 1458 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR 1459 | NFS_INO_INVALID_ATIME 1460 | NFS_INO_REVAL_FORCED 1461 | NFS_INO_REVAL_PAGECACHE); 1462 1463 /* Do atomic weak cache consistency updates */ 1464 invalid |= nfs_wcc_update_inode(inode, fattr); 1465 1466 /* More cache consistency checks */ 1467 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) { 1468 if (inode->i_version != fattr->change_attr) { 1469 dprintk("NFS: change_attr change on server for file %s/%ld\n", 1470 inode->i_sb->s_id, inode->i_ino); 1471 invalid |= NFS_INO_INVALID_ATTR 1472 | NFS_INO_INVALID_DATA 1473 | NFS_INO_INVALID_ACCESS 1474 | NFS_INO_INVALID_ACL 1475 | NFS_INO_REVAL_PAGECACHE; 1476 if (S_ISDIR(inode->i_mode)) 1477 nfs_force_lookup_revalidate(inode); 1478 inode->i_version = fattr->change_attr; 1479 } 1480 } else if (server->caps & NFS_CAP_CHANGE_ATTR) 1481 invalid |= save_cache_validity; 1482 1483 if (fattr->valid & NFS_ATTR_FATTR_MTIME) { 1484 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); 1485 } else if (server->caps & NFS_CAP_MTIME) 1486 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1487 | NFS_INO_REVAL_FORCED); 1488 1489 if (fattr->valid & NFS_ATTR_FATTR_CTIME) { 1490 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); 1491 } else if (server->caps & NFS_CAP_CTIME) 1492 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1493 | NFS_INO_REVAL_FORCED); 1494 1495 /* Check if our cached file size is stale */ 1496 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 1497 new_isize = nfs_size_to_loff_t(fattr->size); 1498 cur_isize = i_size_read(inode); 1499 if (new_isize != cur_isize) { 1500 /* Do we perhaps have any outstanding writes, or has 1501 * the file grown beyond our last write? */ 1502 if ((nfsi->npages == 0 && !test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) || 1503 new_isize > cur_isize) { 1504 i_size_write(inode, new_isize); 1505 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA; 1506 } 1507 dprintk("NFS: isize change on server for file %s/%ld " 1508 "(%Ld to %Ld)\n", 1509 inode->i_sb->s_id, 1510 inode->i_ino, 1511 (long long)cur_isize, 1512 (long long)new_isize); 1513 } 1514 } else 1515 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1516 | NFS_INO_REVAL_PAGECACHE 1517 | NFS_INO_REVAL_FORCED); 1518 1519 1520 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 1521 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime)); 1522 else if (server->caps & NFS_CAP_ATIME) 1523 invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME 1524 | NFS_INO_REVAL_FORCED); 1525 1526 if (fattr->valid & NFS_ATTR_FATTR_MODE) { 1527 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) { 1528 umode_t newmode = inode->i_mode & S_IFMT; 1529 newmode |= fattr->mode & S_IALLUGO; 1530 inode->i_mode = newmode; 1531 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1532 } 1533 } else if (server->caps & NFS_CAP_MODE) 1534 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1535 | NFS_INO_INVALID_ACCESS 1536 | NFS_INO_INVALID_ACL 1537 | NFS_INO_REVAL_FORCED); 1538 1539 if (fattr->valid & NFS_ATTR_FATTR_OWNER) { 1540 if (!uid_eq(inode->i_uid, fattr->uid)) { 1541 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1542 inode->i_uid = fattr->uid; 1543 } 1544 } else if (server->caps & NFS_CAP_OWNER) 1545 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1546 | NFS_INO_INVALID_ACCESS 1547 | NFS_INO_INVALID_ACL 1548 | NFS_INO_REVAL_FORCED); 1549 1550 if (fattr->valid & NFS_ATTR_FATTR_GROUP) { 1551 if (!gid_eq(inode->i_gid, fattr->gid)) { 1552 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1553 inode->i_gid = fattr->gid; 1554 } 1555 } else if (server->caps & NFS_CAP_OWNER_GROUP) 1556 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1557 | NFS_INO_INVALID_ACCESS 1558 | NFS_INO_INVALID_ACL 1559 | NFS_INO_REVAL_FORCED); 1560 1561 if (fattr->valid & NFS_ATTR_FATTR_NLINK) { 1562 if (inode->i_nlink != fattr->nlink) { 1563 invalid |= NFS_INO_INVALID_ATTR; 1564 if (S_ISDIR(inode->i_mode)) 1565 invalid |= NFS_INO_INVALID_DATA; 1566 set_nlink(inode, fattr->nlink); 1567 } 1568 } else if (server->caps & NFS_CAP_NLINK) 1569 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1570 | NFS_INO_REVAL_FORCED); 1571 1572 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { 1573 /* 1574 * report the blocks in 512byte units 1575 */ 1576 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 1577 } 1578 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) 1579 inode->i_blocks = fattr->du.nfs2.blocks; 1580 1581 /* Update attrtimeo value if we're out of the unstable period */ 1582 if (invalid & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL)) { 1583 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 1584 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 1585 nfsi->attrtimeo_timestamp = now; 1586 nfsi->attr_gencount = nfs_inc_attr_generation_counter(); 1587 } else { 1588 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) { 1589 if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode)) 1590 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode); 1591 nfsi->attrtimeo_timestamp = now; 1592 } 1593 } 1594 invalid &= ~NFS_INO_INVALID_ATTR; 1595 invalid &= ~NFS_INO_INVALID_LABEL; 1596 /* Don't invalidate the data if we were to blame */ 1597 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) 1598 || S_ISLNK(inode->i_mode))) 1599 invalid &= ~NFS_INO_INVALID_DATA; 1600 if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ) || 1601 (save_cache_validity & NFS_INO_REVAL_FORCED)) 1602 nfsi->cache_validity |= invalid; 1603 1604 if (invalid & NFS_INO_INVALID_DATA) 1605 nfs_fscache_invalidate(inode); 1606 1607 return 0; 1608 out_err: 1609 /* 1610 * No need to worry about unhashing the dentry, as the 1611 * lookup validation will know that the inode is bad. 1612 * (But we fall through to invalidate the caches.) 1613 */ 1614 nfs_invalidate_inode(inode); 1615 return -ESTALE; 1616 } 1617 1618 struct inode *nfs_alloc_inode(struct super_block *sb) 1619 { 1620 struct nfs_inode *nfsi; 1621 nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL); 1622 if (!nfsi) 1623 return NULL; 1624 nfsi->flags = 0UL; 1625 nfsi->cache_validity = 0UL; 1626 #ifdef CONFIG_NFS_V3_ACL 1627 nfsi->acl_access = ERR_PTR(-EAGAIN); 1628 nfsi->acl_default = ERR_PTR(-EAGAIN); 1629 #endif 1630 #if IS_ENABLED(CONFIG_NFS_V4) 1631 nfsi->nfs4_acl = NULL; 1632 #endif /* CONFIG_NFS_V4 */ 1633 return &nfsi->vfs_inode; 1634 } 1635 EXPORT_SYMBOL_GPL(nfs_alloc_inode); 1636 1637 static void nfs_i_callback(struct rcu_head *head) 1638 { 1639 struct inode *inode = container_of(head, struct inode, i_rcu); 1640 kmem_cache_free(nfs_inode_cachep, NFS_I(inode)); 1641 } 1642 1643 void nfs_destroy_inode(struct inode *inode) 1644 { 1645 call_rcu(&inode->i_rcu, nfs_i_callback); 1646 } 1647 EXPORT_SYMBOL_GPL(nfs_destroy_inode); 1648 1649 static inline void nfs4_init_once(struct nfs_inode *nfsi) 1650 { 1651 #if IS_ENABLED(CONFIG_NFS_V4) 1652 INIT_LIST_HEAD(&nfsi->open_states); 1653 nfsi->delegation = NULL; 1654 nfsi->delegation_state = 0; 1655 init_rwsem(&nfsi->rwsem); 1656 nfsi->layout = NULL; 1657 #endif 1658 } 1659 1660 static void init_once(void *foo) 1661 { 1662 struct nfs_inode *nfsi = (struct nfs_inode *) foo; 1663 1664 inode_init_once(&nfsi->vfs_inode); 1665 INIT_LIST_HEAD(&nfsi->open_files); 1666 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru); 1667 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru); 1668 INIT_LIST_HEAD(&nfsi->commit_info.list); 1669 nfsi->npages = 0; 1670 nfsi->commit_info.ncommit = 0; 1671 atomic_set(&nfsi->commit_info.rpcs_out, 0); 1672 atomic_set(&nfsi->silly_count, 1); 1673 INIT_HLIST_HEAD(&nfsi->silly_list); 1674 init_waitqueue_head(&nfsi->waitqueue); 1675 nfs4_init_once(nfsi); 1676 } 1677 1678 static int __init nfs_init_inodecache(void) 1679 { 1680 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", 1681 sizeof(struct nfs_inode), 1682 0, (SLAB_RECLAIM_ACCOUNT| 1683 SLAB_MEM_SPREAD), 1684 init_once); 1685 if (nfs_inode_cachep == NULL) 1686 return -ENOMEM; 1687 1688 return 0; 1689 } 1690 1691 static void nfs_destroy_inodecache(void) 1692 { 1693 /* 1694 * Make sure all delayed rcu free inodes are flushed before we 1695 * destroy cache. 1696 */ 1697 rcu_barrier(); 1698 kmem_cache_destroy(nfs_inode_cachep); 1699 } 1700 1701 struct workqueue_struct *nfsiod_workqueue; 1702 EXPORT_SYMBOL_GPL(nfsiod_workqueue); 1703 1704 /* 1705 * start up the nfsiod workqueue 1706 */ 1707 static int nfsiod_start(void) 1708 { 1709 struct workqueue_struct *wq; 1710 dprintk("RPC: creating workqueue nfsiod\n"); 1711 wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0); 1712 if (wq == NULL) 1713 return -ENOMEM; 1714 nfsiod_workqueue = wq; 1715 return 0; 1716 } 1717 1718 /* 1719 * Destroy the nfsiod workqueue 1720 */ 1721 static void nfsiod_stop(void) 1722 { 1723 struct workqueue_struct *wq; 1724 1725 wq = nfsiod_workqueue; 1726 if (wq == NULL) 1727 return; 1728 nfsiod_workqueue = NULL; 1729 destroy_workqueue(wq); 1730 } 1731 1732 int nfs_net_id; 1733 EXPORT_SYMBOL_GPL(nfs_net_id); 1734 1735 static int nfs_net_init(struct net *net) 1736 { 1737 nfs_clients_init(net); 1738 return 0; 1739 } 1740 1741 static void nfs_net_exit(struct net *net) 1742 { 1743 nfs_cleanup_cb_ident_idr(net); 1744 } 1745 1746 static struct pernet_operations nfs_net_ops = { 1747 .init = nfs_net_init, 1748 .exit = nfs_net_exit, 1749 .id = &nfs_net_id, 1750 .size = sizeof(struct nfs_net), 1751 }; 1752 1753 /* 1754 * Initialize NFS 1755 */ 1756 static int __init init_nfs_fs(void) 1757 { 1758 int err; 1759 1760 err = register_pernet_subsys(&nfs_net_ops); 1761 if (err < 0) 1762 goto out9; 1763 1764 err = nfs_fscache_register(); 1765 if (err < 0) 1766 goto out8; 1767 1768 err = nfsiod_start(); 1769 if (err) 1770 goto out7; 1771 1772 err = nfs_fs_proc_init(); 1773 if (err) 1774 goto out6; 1775 1776 err = nfs_init_nfspagecache(); 1777 if (err) 1778 goto out5; 1779 1780 err = nfs_init_inodecache(); 1781 if (err) 1782 goto out4; 1783 1784 err = nfs_init_readpagecache(); 1785 if (err) 1786 goto out3; 1787 1788 err = nfs_init_writepagecache(); 1789 if (err) 1790 goto out2; 1791 1792 err = nfs_init_directcache(); 1793 if (err) 1794 goto out1; 1795 1796 #ifdef CONFIG_PROC_FS 1797 rpc_proc_register(&init_net, &nfs_rpcstat); 1798 #endif 1799 if ((err = register_nfs_fs()) != 0) 1800 goto out0; 1801 1802 return 0; 1803 out0: 1804 #ifdef CONFIG_PROC_FS 1805 rpc_proc_unregister(&init_net, "nfs"); 1806 #endif 1807 nfs_destroy_directcache(); 1808 out1: 1809 nfs_destroy_writepagecache(); 1810 out2: 1811 nfs_destroy_readpagecache(); 1812 out3: 1813 nfs_destroy_inodecache(); 1814 out4: 1815 nfs_destroy_nfspagecache(); 1816 out5: 1817 nfs_fs_proc_exit(); 1818 out6: 1819 nfsiod_stop(); 1820 out7: 1821 nfs_fscache_unregister(); 1822 out8: 1823 unregister_pernet_subsys(&nfs_net_ops); 1824 out9: 1825 return err; 1826 } 1827 1828 static void __exit exit_nfs_fs(void) 1829 { 1830 nfs_destroy_directcache(); 1831 nfs_destroy_writepagecache(); 1832 nfs_destroy_readpagecache(); 1833 nfs_destroy_inodecache(); 1834 nfs_destroy_nfspagecache(); 1835 nfs_fscache_unregister(); 1836 unregister_pernet_subsys(&nfs_net_ops); 1837 #ifdef CONFIG_PROC_FS 1838 rpc_proc_unregister(&init_net, "nfs"); 1839 #endif 1840 unregister_nfs_fs(); 1841 nfs_fs_proc_exit(); 1842 nfsiod_stop(); 1843 } 1844 1845 /* Not quite true; I just maintain it */ 1846 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 1847 MODULE_LICENSE("GPL"); 1848 module_param(enable_ino64, bool, 0644); 1849 1850 module_init(init_nfs_fs) 1851 module_exit(exit_nfs_fs) 1852