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 nfs_setsecurity(inode, fattr, label); 467 dprintk("NFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n", 468 inode->i_sb->s_id, 469 (long long)NFS_FILEID(inode), 470 nfs_display_fhandle_hash(fh), 471 atomic_read(&inode->i_count)); 472 473 out: 474 return inode; 475 476 out_no_inode: 477 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode)); 478 goto out; 479 } 480 EXPORT_SYMBOL_GPL(nfs_fhget); 481 482 #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) 483 484 int 485 nfs_setattr(struct dentry *dentry, struct iattr *attr) 486 { 487 struct inode *inode = dentry->d_inode; 488 struct nfs_fattr *fattr; 489 int error = -ENOMEM; 490 491 nfs_inc_stats(inode, NFSIOS_VFSSETATTR); 492 493 /* skip mode change if it's just for clearing setuid/setgid */ 494 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) 495 attr->ia_valid &= ~ATTR_MODE; 496 497 if (attr->ia_valid & ATTR_SIZE) { 498 if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode)) 499 attr->ia_valid &= ~ATTR_SIZE; 500 } 501 502 /* Optimization: if the end result is no change, don't RPC */ 503 attr->ia_valid &= NFS_VALID_ATTRS; 504 if ((attr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0) 505 return 0; 506 507 /* Write all dirty data */ 508 if (S_ISREG(inode->i_mode)) { 509 nfs_inode_dio_wait(inode); 510 nfs_wb_all(inode); 511 } 512 513 fattr = nfs_alloc_fattr(); 514 if (fattr == NULL) 515 goto out; 516 /* 517 * Return any delegations if we're going to change ACLs 518 */ 519 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) 520 NFS_PROTO(inode)->return_delegation(inode); 521 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr); 522 if (error == 0) 523 error = nfs_refresh_inode(inode, fattr); 524 nfs_free_fattr(fattr); 525 out: 526 return error; 527 } 528 EXPORT_SYMBOL_GPL(nfs_setattr); 529 530 /** 531 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall 532 * @inode: inode of the file used 533 * @offset: file offset to start truncating 534 * 535 * This is a copy of the common vmtruncate, but with the locking 536 * corrected to take into account the fact that NFS requires 537 * inode->i_size to be updated under the inode->i_lock. 538 */ 539 static int nfs_vmtruncate(struct inode * inode, loff_t offset) 540 { 541 loff_t oldsize; 542 int err; 543 544 err = inode_newsize_ok(inode, offset); 545 if (err) 546 goto out; 547 548 spin_lock(&inode->i_lock); 549 oldsize = inode->i_size; 550 i_size_write(inode, offset); 551 spin_unlock(&inode->i_lock); 552 553 truncate_pagecache(inode, oldsize, offset); 554 out: 555 return err; 556 } 557 558 /** 559 * nfs_setattr_update_inode - Update inode metadata after a setattr call. 560 * @inode: pointer to struct inode 561 * @attr: pointer to struct iattr 562 * 563 * Note: we do this in the *proc.c in order to ensure that 564 * it works for things like exclusive creates too. 565 */ 566 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr) 567 { 568 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) { 569 spin_lock(&inode->i_lock); 570 if ((attr->ia_valid & ATTR_MODE) != 0) { 571 int mode = attr->ia_mode & S_IALLUGO; 572 mode |= inode->i_mode & ~S_IALLUGO; 573 inode->i_mode = mode; 574 } 575 if ((attr->ia_valid & ATTR_UID) != 0) 576 inode->i_uid = attr->ia_uid; 577 if ((attr->ia_valid & ATTR_GID) != 0) 578 inode->i_gid = attr->ia_gid; 579 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 580 spin_unlock(&inode->i_lock); 581 } 582 if ((attr->ia_valid & ATTR_SIZE) != 0) { 583 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC); 584 nfs_vmtruncate(inode, attr->ia_size); 585 } 586 } 587 EXPORT_SYMBOL_GPL(nfs_setattr_update_inode); 588 589 int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 590 { 591 struct inode *inode = dentry->d_inode; 592 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME; 593 int err; 594 595 /* Flush out writes to the server in order to update c/mtime. */ 596 if (S_ISREG(inode->i_mode)) { 597 nfs_inode_dio_wait(inode); 598 err = filemap_write_and_wait(inode->i_mapping); 599 if (err) 600 goto out; 601 } 602 603 /* 604 * We may force a getattr if the user cares about atime. 605 * 606 * Note that we only have to check the vfsmount flags here: 607 * - NFS always sets S_NOATIME by so checking it would give a 608 * bogus result 609 * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is 610 * no point in checking those. 611 */ 612 if ((mnt->mnt_flags & MNT_NOATIME) || 613 ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))) 614 need_atime = 0; 615 616 if (need_atime) 617 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 618 else 619 err = nfs_revalidate_inode(NFS_SERVER(inode), inode); 620 if (!err) { 621 generic_fillattr(inode, stat); 622 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode)); 623 } 624 out: 625 return err; 626 } 627 EXPORT_SYMBOL_GPL(nfs_getattr); 628 629 static void nfs_init_lock_context(struct nfs_lock_context *l_ctx) 630 { 631 atomic_set(&l_ctx->count, 1); 632 l_ctx->lockowner.l_owner = current->files; 633 l_ctx->lockowner.l_pid = current->tgid; 634 INIT_LIST_HEAD(&l_ctx->list); 635 nfs_iocounter_init(&l_ctx->io_count); 636 } 637 638 static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx) 639 { 640 struct nfs_lock_context *head = &ctx->lock_context; 641 struct nfs_lock_context *pos = head; 642 643 do { 644 if (pos->lockowner.l_owner != current->files) 645 continue; 646 if (pos->lockowner.l_pid != current->tgid) 647 continue; 648 atomic_inc(&pos->count); 649 return pos; 650 } while ((pos = list_entry(pos->list.next, typeof(*pos), list)) != head); 651 return NULL; 652 } 653 654 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx) 655 { 656 struct nfs_lock_context *res, *new = NULL; 657 struct inode *inode = ctx->dentry->d_inode; 658 659 spin_lock(&inode->i_lock); 660 res = __nfs_find_lock_context(ctx); 661 if (res == NULL) { 662 spin_unlock(&inode->i_lock); 663 new = kmalloc(sizeof(*new), GFP_KERNEL); 664 if (new == NULL) 665 return ERR_PTR(-ENOMEM); 666 nfs_init_lock_context(new); 667 spin_lock(&inode->i_lock); 668 res = __nfs_find_lock_context(ctx); 669 if (res == NULL) { 670 list_add_tail(&new->list, &ctx->lock_context.list); 671 new->open_context = ctx; 672 res = new; 673 new = NULL; 674 } 675 } 676 spin_unlock(&inode->i_lock); 677 kfree(new); 678 return res; 679 } 680 681 void nfs_put_lock_context(struct nfs_lock_context *l_ctx) 682 { 683 struct nfs_open_context *ctx = l_ctx->open_context; 684 struct inode *inode = ctx->dentry->d_inode; 685 686 if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock)) 687 return; 688 list_del(&l_ctx->list); 689 spin_unlock(&inode->i_lock); 690 kfree(l_ctx); 691 } 692 693 /** 694 * nfs_close_context - Common close_context() routine NFSv2/v3 695 * @ctx: pointer to context 696 * @is_sync: is this a synchronous close 697 * 698 * always ensure that the attributes are up to date if we're mounted 699 * with close-to-open semantics 700 */ 701 void nfs_close_context(struct nfs_open_context *ctx, int is_sync) 702 { 703 struct inode *inode; 704 struct nfs_server *server; 705 706 if (!(ctx->mode & FMODE_WRITE)) 707 return; 708 if (!is_sync) 709 return; 710 inode = ctx->dentry->d_inode; 711 if (!list_empty(&NFS_I(inode)->open_files)) 712 return; 713 server = NFS_SERVER(inode); 714 if (server->flags & NFS_MOUNT_NOCTO) 715 return; 716 nfs_revalidate_inode(server, inode); 717 } 718 EXPORT_SYMBOL_GPL(nfs_close_context); 719 720 struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode) 721 { 722 struct nfs_open_context *ctx; 723 struct rpc_cred *cred = rpc_lookup_cred(); 724 if (IS_ERR(cred)) 725 return ERR_CAST(cred); 726 727 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); 728 if (!ctx) { 729 put_rpccred(cred); 730 return ERR_PTR(-ENOMEM); 731 } 732 nfs_sb_active(dentry->d_sb); 733 ctx->dentry = dget(dentry); 734 ctx->cred = cred; 735 ctx->state = NULL; 736 ctx->mode = f_mode; 737 ctx->flags = 0; 738 ctx->error = 0; 739 nfs_init_lock_context(&ctx->lock_context); 740 ctx->lock_context.open_context = ctx; 741 INIT_LIST_HEAD(&ctx->list); 742 ctx->mdsthreshold = NULL; 743 return ctx; 744 } 745 EXPORT_SYMBOL_GPL(alloc_nfs_open_context); 746 747 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx) 748 { 749 if (ctx != NULL) 750 atomic_inc(&ctx->lock_context.count); 751 return ctx; 752 } 753 EXPORT_SYMBOL_GPL(get_nfs_open_context); 754 755 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync) 756 { 757 struct inode *inode = ctx->dentry->d_inode; 758 struct super_block *sb = ctx->dentry->d_sb; 759 760 if (!list_empty(&ctx->list)) { 761 if (!atomic_dec_and_lock(&ctx->lock_context.count, &inode->i_lock)) 762 return; 763 list_del(&ctx->list); 764 spin_unlock(&inode->i_lock); 765 } else if (!atomic_dec_and_test(&ctx->lock_context.count)) 766 return; 767 if (inode != NULL) 768 NFS_PROTO(inode)->close_context(ctx, is_sync); 769 if (ctx->cred != NULL) 770 put_rpccred(ctx->cred); 771 dput(ctx->dentry); 772 nfs_sb_deactive(sb); 773 kfree(ctx->mdsthreshold); 774 kfree(ctx); 775 } 776 777 void put_nfs_open_context(struct nfs_open_context *ctx) 778 { 779 __put_nfs_open_context(ctx, 0); 780 } 781 EXPORT_SYMBOL_GPL(put_nfs_open_context); 782 783 /* 784 * Ensure that mmap has a recent RPC credential for use when writing out 785 * shared pages 786 */ 787 void nfs_inode_attach_open_context(struct nfs_open_context *ctx) 788 { 789 struct inode *inode = ctx->dentry->d_inode; 790 struct nfs_inode *nfsi = NFS_I(inode); 791 792 spin_lock(&inode->i_lock); 793 list_add(&ctx->list, &nfsi->open_files); 794 spin_unlock(&inode->i_lock); 795 } 796 EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context); 797 798 void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx) 799 { 800 filp->private_data = get_nfs_open_context(ctx); 801 if (list_empty(&ctx->list)) 802 nfs_inode_attach_open_context(ctx); 803 } 804 EXPORT_SYMBOL_GPL(nfs_file_set_open_context); 805 806 /* 807 * Given an inode, search for an open context with the desired characteristics 808 */ 809 struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode) 810 { 811 struct nfs_inode *nfsi = NFS_I(inode); 812 struct nfs_open_context *pos, *ctx = NULL; 813 814 spin_lock(&inode->i_lock); 815 list_for_each_entry(pos, &nfsi->open_files, list) { 816 if (cred != NULL && pos->cred != cred) 817 continue; 818 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode) 819 continue; 820 ctx = get_nfs_open_context(pos); 821 break; 822 } 823 spin_unlock(&inode->i_lock); 824 return ctx; 825 } 826 827 static void nfs_file_clear_open_context(struct file *filp) 828 { 829 struct nfs_open_context *ctx = nfs_file_open_context(filp); 830 831 if (ctx) { 832 struct inode *inode = ctx->dentry->d_inode; 833 834 filp->private_data = NULL; 835 spin_lock(&inode->i_lock); 836 list_move_tail(&ctx->list, &NFS_I(inode)->open_files); 837 spin_unlock(&inode->i_lock); 838 __put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1); 839 } 840 } 841 842 /* 843 * These allocate and release file read/write context information. 844 */ 845 int nfs_open(struct inode *inode, struct file *filp) 846 { 847 struct nfs_open_context *ctx; 848 849 ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode); 850 if (IS_ERR(ctx)) 851 return PTR_ERR(ctx); 852 nfs_file_set_open_context(filp, ctx); 853 put_nfs_open_context(ctx); 854 nfs_fscache_set_inode_cookie(inode, filp); 855 return 0; 856 } 857 858 int nfs_release(struct inode *inode, struct file *filp) 859 { 860 nfs_file_clear_open_context(filp); 861 return 0; 862 } 863 864 /* 865 * This function is called whenever some part of NFS notices that 866 * the cached attributes have to be refreshed. 867 */ 868 int 869 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 870 { 871 int status = -ESTALE; 872 struct nfs4_label *label = NULL; 873 struct nfs_fattr *fattr = NULL; 874 struct nfs_inode *nfsi = NFS_I(inode); 875 876 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n", 877 inode->i_sb->s_id, (long long)NFS_FILEID(inode)); 878 879 if (is_bad_inode(inode)) 880 goto out; 881 if (NFS_STALE(inode)) 882 goto out; 883 884 status = -ENOMEM; 885 fattr = nfs_alloc_fattr(); 886 if (fattr == NULL) 887 goto out; 888 889 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE); 890 891 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL); 892 if (IS_ERR(label)) { 893 status = PTR_ERR(label); 894 goto out; 895 } 896 897 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, label); 898 if (status != 0) { 899 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n", 900 inode->i_sb->s_id, 901 (long long)NFS_FILEID(inode), status); 902 if (status == -ESTALE) { 903 nfs_zap_caches(inode); 904 if (!S_ISDIR(inode->i_mode)) 905 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 906 } 907 goto err_out; 908 } 909 910 status = nfs_refresh_inode(inode, fattr); 911 if (status) { 912 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n", 913 inode->i_sb->s_id, 914 (long long)NFS_FILEID(inode), status); 915 goto err_out; 916 } 917 918 if (nfsi->cache_validity & NFS_INO_INVALID_ACL) 919 nfs_zap_acl_cache(inode); 920 921 dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n", 922 inode->i_sb->s_id, 923 (long long)NFS_FILEID(inode)); 924 925 err_out: 926 nfs4_label_free(label); 927 out: 928 nfs_free_fattr(fattr); 929 return status; 930 } 931 932 int nfs_attribute_timeout(struct inode *inode) 933 { 934 struct nfs_inode *nfsi = NFS_I(inode); 935 936 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo); 937 } 938 939 int nfs_attribute_cache_expired(struct inode *inode) 940 { 941 if (nfs_have_delegated_attributes(inode)) 942 return 0; 943 return nfs_attribute_timeout(inode); 944 } 945 946 /** 947 * nfs_revalidate_inode - Revalidate the inode attributes 948 * @server - pointer to nfs_server struct 949 * @inode - pointer to inode struct 950 * 951 * Updates inode attribute information by retrieving the data from the server. 952 */ 953 int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 954 { 955 if (!(NFS_I(inode)->cache_validity & 956 (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL)) 957 && !nfs_attribute_cache_expired(inode)) 958 return NFS_STALE(inode) ? -ESTALE : 0; 959 return __nfs_revalidate_inode(server, inode); 960 } 961 EXPORT_SYMBOL_GPL(nfs_revalidate_inode); 962 963 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping) 964 { 965 struct nfs_inode *nfsi = NFS_I(inode); 966 967 if (mapping->nrpages != 0) { 968 int ret = invalidate_inode_pages2(mapping); 969 if (ret < 0) 970 return ret; 971 } 972 spin_lock(&inode->i_lock); 973 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA; 974 if (S_ISDIR(inode->i_mode)) 975 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf)); 976 spin_unlock(&inode->i_lock); 977 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE); 978 nfs_fscache_wait_on_invalidate(inode); 979 dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n", 980 inode->i_sb->s_id, (long long)NFS_FILEID(inode)); 981 return 0; 982 } 983 984 static bool nfs_mapping_need_revalidate_inode(struct inode *inode) 985 { 986 if (nfs_have_delegated_attributes(inode)) 987 return false; 988 return (NFS_I(inode)->cache_validity & NFS_INO_REVAL_PAGECACHE) 989 || nfs_attribute_timeout(inode) 990 || NFS_STALE(inode); 991 } 992 993 /** 994 * nfs_revalidate_mapping - Revalidate the pagecache 995 * @inode - pointer to host inode 996 * @mapping - pointer to mapping 997 */ 998 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) 999 { 1000 struct nfs_inode *nfsi = NFS_I(inode); 1001 int ret = 0; 1002 1003 /* swapfiles are not supposed to be shared. */ 1004 if (IS_SWAPFILE(inode)) 1005 goto out; 1006 1007 if (nfs_mapping_need_revalidate_inode(inode)) { 1008 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 1009 if (ret < 0) 1010 goto out; 1011 } 1012 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 1013 ret = nfs_invalidate_mapping(inode, mapping); 1014 out: 1015 return ret; 1016 } 1017 1018 static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1019 { 1020 struct nfs_inode *nfsi = NFS_I(inode); 1021 unsigned long ret = 0; 1022 1023 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE) 1024 && (fattr->valid & NFS_ATTR_FATTR_CHANGE) 1025 && inode->i_version == fattr->pre_change_attr) { 1026 inode->i_version = fattr->change_attr; 1027 if (S_ISDIR(inode->i_mode)) 1028 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 1029 ret |= NFS_INO_INVALID_ATTR; 1030 } 1031 /* If we have atomic WCC data, we may update some attributes */ 1032 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME) 1033 && (fattr->valid & NFS_ATTR_FATTR_CTIME) 1034 && timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) { 1035 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); 1036 ret |= NFS_INO_INVALID_ATTR; 1037 } 1038 1039 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME) 1040 && (fattr->valid & NFS_ATTR_FATTR_MTIME) 1041 && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) { 1042 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); 1043 if (S_ISDIR(inode->i_mode)) 1044 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 1045 ret |= NFS_INO_INVALID_ATTR; 1046 } 1047 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE) 1048 && (fattr->valid & NFS_ATTR_FATTR_SIZE) 1049 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size) 1050 && nfsi->npages == 0) { 1051 i_size_write(inode, nfs_size_to_loff_t(fattr->size)); 1052 ret |= NFS_INO_INVALID_ATTR; 1053 } 1054 1055 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 1056 nfs_fscache_invalidate(inode); 1057 1058 return ret; 1059 } 1060 1061 /** 1062 * nfs_check_inode_attributes - verify consistency of the inode attribute cache 1063 * @inode - pointer to inode 1064 * @fattr - updated attributes 1065 * 1066 * Verifies the attribute cache. If we have just changed the attributes, 1067 * so that fattr carries weak cache consistency data, then it may 1068 * also update the ctime/mtime/change_attribute. 1069 */ 1070 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr) 1071 { 1072 struct nfs_inode *nfsi = NFS_I(inode); 1073 loff_t cur_size, new_isize; 1074 unsigned long invalid = 0; 1075 1076 1077 if (nfs_have_delegated_attributes(inode)) 1078 return 0; 1079 /* Has the inode gone and changed behind our back? */ 1080 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) 1081 return -EIO; 1082 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) 1083 return -EIO; 1084 1085 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 1086 inode->i_version != fattr->change_attr) 1087 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 1088 1089 /* Verify a few of the more important attributes */ 1090 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime)) 1091 invalid |= NFS_INO_INVALID_ATTR; 1092 1093 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 1094 cur_size = i_size_read(inode); 1095 new_isize = nfs_size_to_loff_t(fattr->size); 1096 if (cur_size != new_isize && nfsi->npages == 0) 1097 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 1098 } 1099 1100 /* Have any file permissions changed? */ 1101 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) 1102 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 1103 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid)) 1104 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 1105 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid)) 1106 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 1107 1108 /* Has the link count changed? */ 1109 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink) 1110 invalid |= NFS_INO_INVALID_ATTR; 1111 1112 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime)) 1113 invalid |= NFS_INO_INVALID_ATIME; 1114 1115 if (invalid != 0) 1116 nfsi->cache_validity |= invalid; 1117 1118 nfsi->read_cache_jiffies = fattr->time_start; 1119 return 0; 1120 } 1121 1122 static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 1123 { 1124 if (!(fattr->valid & NFS_ATTR_FATTR_CTIME)) 1125 return 0; 1126 return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0; 1127 } 1128 1129 static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 1130 { 1131 if (!(fattr->valid & NFS_ATTR_FATTR_SIZE)) 1132 return 0; 1133 return nfs_size_to_loff_t(fattr->size) > i_size_read(inode); 1134 } 1135 1136 static atomic_long_t nfs_attr_generation_counter; 1137 1138 static unsigned long nfs_read_attr_generation_counter(void) 1139 { 1140 return atomic_long_read(&nfs_attr_generation_counter); 1141 } 1142 1143 unsigned long nfs_inc_attr_generation_counter(void) 1144 { 1145 return atomic_long_inc_return(&nfs_attr_generation_counter); 1146 } 1147 1148 void nfs_fattr_init(struct nfs_fattr *fattr) 1149 { 1150 fattr->valid = 0; 1151 fattr->time_start = jiffies; 1152 fattr->gencount = nfs_inc_attr_generation_counter(); 1153 fattr->owner_name = NULL; 1154 fattr->group_name = NULL; 1155 } 1156 EXPORT_SYMBOL_GPL(nfs_fattr_init); 1157 1158 struct nfs_fattr *nfs_alloc_fattr(void) 1159 { 1160 struct nfs_fattr *fattr; 1161 1162 fattr = kmalloc(sizeof(*fattr), GFP_NOFS); 1163 if (fattr != NULL) 1164 nfs_fattr_init(fattr); 1165 return fattr; 1166 } 1167 EXPORT_SYMBOL_GPL(nfs_alloc_fattr); 1168 1169 struct nfs_fh *nfs_alloc_fhandle(void) 1170 { 1171 struct nfs_fh *fh; 1172 1173 fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS); 1174 if (fh != NULL) 1175 fh->size = 0; 1176 return fh; 1177 } 1178 EXPORT_SYMBOL_GPL(nfs_alloc_fhandle); 1179 1180 #ifdef NFS_DEBUG 1181 /* 1182 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle 1183 * in the same way that wireshark does 1184 * 1185 * @fh: file handle 1186 * 1187 * For debugging only. 1188 */ 1189 u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh) 1190 { 1191 /* wireshark uses 32-bit AUTODIN crc and does a bitwise 1192 * not on the result */ 1193 return ~crc32(0xFFFFFFFF, &fh->data[0], fh->size); 1194 } 1195 1196 /* 1197 * _nfs_display_fhandle - display an NFS file handle on the console 1198 * 1199 * @fh: file handle to display 1200 * @caption: display caption 1201 * 1202 * For debugging only. 1203 */ 1204 void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption) 1205 { 1206 unsigned short i; 1207 1208 if (fh == NULL || fh->size == 0) { 1209 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh); 1210 return; 1211 } 1212 1213 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n", 1214 caption, fh, fh->size, _nfs_display_fhandle_hash(fh)); 1215 for (i = 0; i < fh->size; i += 16) { 1216 __be32 *pos = (__be32 *)&fh->data[i]; 1217 1218 switch ((fh->size - i - 1) >> 2) { 1219 case 0: 1220 printk(KERN_DEFAULT " %08x\n", 1221 be32_to_cpup(pos)); 1222 break; 1223 case 1: 1224 printk(KERN_DEFAULT " %08x %08x\n", 1225 be32_to_cpup(pos), be32_to_cpup(pos + 1)); 1226 break; 1227 case 2: 1228 printk(KERN_DEFAULT " %08x %08x %08x\n", 1229 be32_to_cpup(pos), be32_to_cpup(pos + 1), 1230 be32_to_cpup(pos + 2)); 1231 break; 1232 default: 1233 printk(KERN_DEFAULT " %08x %08x %08x %08x\n", 1234 be32_to_cpup(pos), be32_to_cpup(pos + 1), 1235 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3)); 1236 } 1237 } 1238 } 1239 #endif 1240 1241 /** 1242 * nfs_inode_attrs_need_update - check if the inode attributes need updating 1243 * @inode - pointer to inode 1244 * @fattr - attributes 1245 * 1246 * Attempt to divine whether or not an RPC call reply carrying stale 1247 * attributes got scheduled after another call carrying updated ones. 1248 * 1249 * To do so, the function first assumes that a more recent ctime means 1250 * that the attributes in fattr are newer, however it also attempt to 1251 * catch the case where ctime either didn't change, or went backwards 1252 * (if someone reset the clock on the server) by looking at whether 1253 * or not this RPC call was started after the inode was last updated. 1254 * Note also the check for wraparound of 'attr_gencount' 1255 * 1256 * The function returns 'true' if it thinks the attributes in 'fattr' are 1257 * more recent than the ones cached in the inode. 1258 * 1259 */ 1260 static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 1261 { 1262 const struct nfs_inode *nfsi = NFS_I(inode); 1263 1264 return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 || 1265 nfs_ctime_need_update(inode, fattr) || 1266 nfs_size_need_update(inode, fattr) || 1267 ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0); 1268 } 1269 1270 static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr) 1271 { 1272 if (nfs_inode_attrs_need_update(inode, fattr)) 1273 return nfs_update_inode(inode, fattr); 1274 return nfs_check_inode_attributes(inode, fattr); 1275 } 1276 1277 /** 1278 * nfs_refresh_inode - try to update the inode attribute cache 1279 * @inode - pointer to inode 1280 * @fattr - updated attributes 1281 * 1282 * Check that an RPC call that returned attributes has not overlapped with 1283 * other recent updates of the inode metadata, then decide whether it is 1284 * safe to do a full update of the inode attributes, or whether just to 1285 * call nfs_check_inode_attributes. 1286 */ 1287 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr) 1288 { 1289 int status; 1290 1291 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 1292 return 0; 1293 spin_lock(&inode->i_lock); 1294 status = nfs_refresh_inode_locked(inode, fattr); 1295 spin_unlock(&inode->i_lock); 1296 1297 return status; 1298 } 1299 EXPORT_SYMBOL_GPL(nfs_refresh_inode); 1300 1301 static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr) 1302 { 1303 struct nfs_inode *nfsi = NFS_I(inode); 1304 1305 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 1306 if (S_ISDIR(inode->i_mode)) { 1307 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 1308 nfs_fscache_invalidate(inode); 1309 } 1310 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 1311 return 0; 1312 return nfs_refresh_inode_locked(inode, fattr); 1313 } 1314 1315 /** 1316 * nfs_post_op_update_inode - try to update the inode attribute cache 1317 * @inode - pointer to inode 1318 * @fattr - updated attributes 1319 * 1320 * After an operation that has changed the inode metadata, mark the 1321 * attribute cache as being invalid, then try to update it. 1322 * 1323 * NB: if the server didn't return any post op attributes, this 1324 * function will force the retrieval of attributes before the next 1325 * NFS request. Thus it should be used only for operations that 1326 * are expected to change one or more attributes, to avoid 1327 * unnecessary NFS requests and trips through nfs_update_inode(). 1328 */ 1329 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1330 { 1331 int status; 1332 1333 spin_lock(&inode->i_lock); 1334 status = nfs_post_op_update_inode_locked(inode, fattr); 1335 spin_unlock(&inode->i_lock); 1336 1337 return status; 1338 } 1339 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode); 1340 1341 /** 1342 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache 1343 * @inode - pointer to inode 1344 * @fattr - updated attributes 1345 * 1346 * After an operation that has changed the inode metadata, mark the 1347 * attribute cache as being invalid, then try to update it. Fake up 1348 * weak cache consistency data, if none exist. 1349 * 1350 * This function is mainly designed to be used by the ->write_done() functions. 1351 */ 1352 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr) 1353 { 1354 int status; 1355 1356 spin_lock(&inode->i_lock); 1357 /* Don't do a WCC update if these attributes are already stale */ 1358 if ((fattr->valid & NFS_ATTR_FATTR) == 0 || 1359 !nfs_inode_attrs_need_update(inode, fattr)) { 1360 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE 1361 | NFS_ATTR_FATTR_PRESIZE 1362 | NFS_ATTR_FATTR_PREMTIME 1363 | NFS_ATTR_FATTR_PRECTIME); 1364 goto out_noforce; 1365 } 1366 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 1367 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) { 1368 fattr->pre_change_attr = inode->i_version; 1369 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE; 1370 } 1371 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 && 1372 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) { 1373 memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime)); 1374 fattr->valid |= NFS_ATTR_FATTR_PRECTIME; 1375 } 1376 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 && 1377 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) { 1378 memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime)); 1379 fattr->valid |= NFS_ATTR_FATTR_PREMTIME; 1380 } 1381 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 && 1382 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) { 1383 fattr->pre_size = i_size_read(inode); 1384 fattr->valid |= NFS_ATTR_FATTR_PRESIZE; 1385 } 1386 out_noforce: 1387 status = nfs_post_op_update_inode_locked(inode, fattr); 1388 spin_unlock(&inode->i_lock); 1389 return status; 1390 } 1391 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc); 1392 1393 /* 1394 * Many nfs protocol calls return the new file attributes after 1395 * an operation. Here we update the inode to reflect the state 1396 * of the server's inode. 1397 * 1398 * This is a bit tricky because we have to make sure all dirty pages 1399 * have been sent off to the server before calling invalidate_inode_pages. 1400 * To make sure no other process adds more write requests while we try 1401 * our best to flush them, we make them sleep during the attribute refresh. 1402 * 1403 * A very similar scenario holds for the dir cache. 1404 */ 1405 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1406 { 1407 struct nfs_server *server; 1408 struct nfs_inode *nfsi = NFS_I(inode); 1409 loff_t cur_isize, new_isize; 1410 unsigned long invalid = 0; 1411 unsigned long now = jiffies; 1412 unsigned long save_cache_validity; 1413 1414 dfprintk(VFS, "NFS: %s(%s/%ld fh_crc=0x%08x ct=%d info=0x%x)\n", 1415 __func__, inode->i_sb->s_id, inode->i_ino, 1416 nfs_display_fhandle_hash(NFS_FH(inode)), 1417 atomic_read(&inode->i_count), fattr->valid); 1418 1419 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) { 1420 printk(KERN_ERR "NFS: server %s error: fileid changed\n" 1421 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n", 1422 NFS_SERVER(inode)->nfs_client->cl_hostname, 1423 inode->i_sb->s_id, (long long)nfsi->fileid, 1424 (long long)fattr->fileid); 1425 goto out_err; 1426 } 1427 1428 /* 1429 * Make sure the inode's type hasn't changed. 1430 */ 1431 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) { 1432 /* 1433 * Big trouble! The inode has become a different object. 1434 */ 1435 printk(KERN_DEBUG "NFS: %s: inode %ld mode changed, %07o to %07o\n", 1436 __func__, inode->i_ino, inode->i_mode, fattr->mode); 1437 goto out_err; 1438 } 1439 1440 server = NFS_SERVER(inode); 1441 /* Update the fsid? */ 1442 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) && 1443 !nfs_fsid_equal(&server->fsid, &fattr->fsid) && 1444 !IS_AUTOMOUNT(inode)) 1445 server->fsid = fattr->fsid; 1446 1447 /* 1448 * Update the read time so we don't revalidate too often. 1449 */ 1450 nfsi->read_cache_jiffies = fattr->time_start; 1451 1452 save_cache_validity = nfsi->cache_validity; 1453 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR 1454 | NFS_INO_INVALID_ATIME 1455 | NFS_INO_REVAL_FORCED 1456 | NFS_INO_REVAL_PAGECACHE); 1457 1458 /* Do atomic weak cache consistency updates */ 1459 invalid |= nfs_wcc_update_inode(inode, fattr); 1460 1461 /* More cache consistency checks */ 1462 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) { 1463 if (inode->i_version != fattr->change_attr) { 1464 dprintk("NFS: change_attr change on server for file %s/%ld\n", 1465 inode->i_sb->s_id, inode->i_ino); 1466 invalid |= NFS_INO_INVALID_ATTR 1467 | NFS_INO_INVALID_DATA 1468 | NFS_INO_INVALID_ACCESS 1469 | NFS_INO_INVALID_ACL 1470 | NFS_INO_REVAL_PAGECACHE; 1471 if (S_ISDIR(inode->i_mode)) 1472 nfs_force_lookup_revalidate(inode); 1473 inode->i_version = fattr->change_attr; 1474 } 1475 } else if (server->caps & NFS_CAP_CHANGE_ATTR) 1476 invalid |= save_cache_validity; 1477 1478 if (fattr->valid & NFS_ATTR_FATTR_MTIME) { 1479 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); 1480 } else if (server->caps & NFS_CAP_MTIME) 1481 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1482 | NFS_INO_REVAL_FORCED); 1483 1484 if (fattr->valid & NFS_ATTR_FATTR_CTIME) { 1485 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); 1486 } else if (server->caps & NFS_CAP_CTIME) 1487 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1488 | NFS_INO_REVAL_FORCED); 1489 1490 /* Check if our cached file size is stale */ 1491 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 1492 new_isize = nfs_size_to_loff_t(fattr->size); 1493 cur_isize = i_size_read(inode); 1494 if (new_isize != cur_isize) { 1495 /* Do we perhaps have any outstanding writes, or has 1496 * the file grown beyond our last write? */ 1497 if ((nfsi->npages == 0 && !test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) || 1498 new_isize > cur_isize) { 1499 i_size_write(inode, new_isize); 1500 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA; 1501 } 1502 dprintk("NFS: isize change on server for file %s/%ld " 1503 "(%Ld to %Ld)\n", 1504 inode->i_sb->s_id, 1505 inode->i_ino, 1506 (long long)cur_isize, 1507 (long long)new_isize); 1508 } 1509 } else 1510 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1511 | NFS_INO_REVAL_PAGECACHE 1512 | NFS_INO_REVAL_FORCED); 1513 1514 1515 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 1516 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime)); 1517 else if (server->caps & NFS_CAP_ATIME) 1518 invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME 1519 | NFS_INO_REVAL_FORCED); 1520 1521 if (fattr->valid & NFS_ATTR_FATTR_MODE) { 1522 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) { 1523 umode_t newmode = inode->i_mode & S_IFMT; 1524 newmode |= fattr->mode & S_IALLUGO; 1525 inode->i_mode = newmode; 1526 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1527 } 1528 } else if (server->caps & NFS_CAP_MODE) 1529 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1530 | NFS_INO_INVALID_ACCESS 1531 | NFS_INO_INVALID_ACL 1532 | NFS_INO_REVAL_FORCED); 1533 1534 if (fattr->valid & NFS_ATTR_FATTR_OWNER) { 1535 if (!uid_eq(inode->i_uid, fattr->uid)) { 1536 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1537 inode->i_uid = fattr->uid; 1538 } 1539 } else if (server->caps & NFS_CAP_OWNER) 1540 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1541 | NFS_INO_INVALID_ACCESS 1542 | NFS_INO_INVALID_ACL 1543 | NFS_INO_REVAL_FORCED); 1544 1545 if (fattr->valid & NFS_ATTR_FATTR_GROUP) { 1546 if (!gid_eq(inode->i_gid, fattr->gid)) { 1547 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1548 inode->i_gid = fattr->gid; 1549 } 1550 } else if (server->caps & NFS_CAP_OWNER_GROUP) 1551 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1552 | NFS_INO_INVALID_ACCESS 1553 | NFS_INO_INVALID_ACL 1554 | NFS_INO_REVAL_FORCED); 1555 1556 if (fattr->valid & NFS_ATTR_FATTR_NLINK) { 1557 if (inode->i_nlink != fattr->nlink) { 1558 invalid |= NFS_INO_INVALID_ATTR; 1559 if (S_ISDIR(inode->i_mode)) 1560 invalid |= NFS_INO_INVALID_DATA; 1561 set_nlink(inode, fattr->nlink); 1562 } 1563 } else if (server->caps & NFS_CAP_NLINK) 1564 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1565 | NFS_INO_REVAL_FORCED); 1566 1567 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { 1568 /* 1569 * report the blocks in 512byte units 1570 */ 1571 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 1572 } 1573 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) 1574 inode->i_blocks = fattr->du.nfs2.blocks; 1575 1576 /* Update attrtimeo value if we're out of the unstable period */ 1577 if (invalid & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL)) { 1578 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 1579 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 1580 nfsi->attrtimeo_timestamp = now; 1581 nfsi->attr_gencount = nfs_inc_attr_generation_counter(); 1582 } else { 1583 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) { 1584 if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode)) 1585 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode); 1586 nfsi->attrtimeo_timestamp = now; 1587 } 1588 } 1589 invalid &= ~NFS_INO_INVALID_ATTR; 1590 invalid &= ~NFS_INO_INVALID_LABEL; 1591 /* Don't invalidate the data if we were to blame */ 1592 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) 1593 || S_ISLNK(inode->i_mode))) 1594 invalid &= ~NFS_INO_INVALID_DATA; 1595 if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ) || 1596 (save_cache_validity & NFS_INO_REVAL_FORCED)) 1597 nfsi->cache_validity |= invalid; 1598 1599 if (invalid & NFS_INO_INVALID_DATA) 1600 nfs_fscache_invalidate(inode); 1601 1602 return 0; 1603 out_err: 1604 /* 1605 * No need to worry about unhashing the dentry, as the 1606 * lookup validation will know that the inode is bad. 1607 * (But we fall through to invalidate the caches.) 1608 */ 1609 nfs_invalidate_inode(inode); 1610 return -ESTALE; 1611 } 1612 1613 struct inode *nfs_alloc_inode(struct super_block *sb) 1614 { 1615 struct nfs_inode *nfsi; 1616 nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL); 1617 if (!nfsi) 1618 return NULL; 1619 nfsi->flags = 0UL; 1620 nfsi->cache_validity = 0UL; 1621 #ifdef CONFIG_NFS_V3_ACL 1622 nfsi->acl_access = ERR_PTR(-EAGAIN); 1623 nfsi->acl_default = ERR_PTR(-EAGAIN); 1624 #endif 1625 #if IS_ENABLED(CONFIG_NFS_V4) 1626 nfsi->nfs4_acl = NULL; 1627 #endif /* CONFIG_NFS_V4 */ 1628 return &nfsi->vfs_inode; 1629 } 1630 EXPORT_SYMBOL_GPL(nfs_alloc_inode); 1631 1632 static void nfs_i_callback(struct rcu_head *head) 1633 { 1634 struct inode *inode = container_of(head, struct inode, i_rcu); 1635 kmem_cache_free(nfs_inode_cachep, NFS_I(inode)); 1636 } 1637 1638 void nfs_destroy_inode(struct inode *inode) 1639 { 1640 call_rcu(&inode->i_rcu, nfs_i_callback); 1641 } 1642 EXPORT_SYMBOL_GPL(nfs_destroy_inode); 1643 1644 static inline void nfs4_init_once(struct nfs_inode *nfsi) 1645 { 1646 #if IS_ENABLED(CONFIG_NFS_V4) 1647 INIT_LIST_HEAD(&nfsi->open_states); 1648 nfsi->delegation = NULL; 1649 nfsi->delegation_state = 0; 1650 init_rwsem(&nfsi->rwsem); 1651 nfsi->layout = NULL; 1652 #endif 1653 } 1654 1655 static void init_once(void *foo) 1656 { 1657 struct nfs_inode *nfsi = (struct nfs_inode *) foo; 1658 1659 inode_init_once(&nfsi->vfs_inode); 1660 INIT_LIST_HEAD(&nfsi->open_files); 1661 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru); 1662 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru); 1663 INIT_LIST_HEAD(&nfsi->commit_info.list); 1664 nfsi->npages = 0; 1665 nfsi->commit_info.ncommit = 0; 1666 atomic_set(&nfsi->commit_info.rpcs_out, 0); 1667 atomic_set(&nfsi->silly_count, 1); 1668 INIT_HLIST_HEAD(&nfsi->silly_list); 1669 init_waitqueue_head(&nfsi->waitqueue); 1670 nfs4_init_once(nfsi); 1671 } 1672 1673 static int __init nfs_init_inodecache(void) 1674 { 1675 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", 1676 sizeof(struct nfs_inode), 1677 0, (SLAB_RECLAIM_ACCOUNT| 1678 SLAB_MEM_SPREAD), 1679 init_once); 1680 if (nfs_inode_cachep == NULL) 1681 return -ENOMEM; 1682 1683 return 0; 1684 } 1685 1686 static void nfs_destroy_inodecache(void) 1687 { 1688 /* 1689 * Make sure all delayed rcu free inodes are flushed before we 1690 * destroy cache. 1691 */ 1692 rcu_barrier(); 1693 kmem_cache_destroy(nfs_inode_cachep); 1694 } 1695 1696 struct workqueue_struct *nfsiod_workqueue; 1697 EXPORT_SYMBOL_GPL(nfsiod_workqueue); 1698 1699 /* 1700 * start up the nfsiod workqueue 1701 */ 1702 static int nfsiod_start(void) 1703 { 1704 struct workqueue_struct *wq; 1705 dprintk("RPC: creating workqueue nfsiod\n"); 1706 wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0); 1707 if (wq == NULL) 1708 return -ENOMEM; 1709 nfsiod_workqueue = wq; 1710 return 0; 1711 } 1712 1713 /* 1714 * Destroy the nfsiod workqueue 1715 */ 1716 static void nfsiod_stop(void) 1717 { 1718 struct workqueue_struct *wq; 1719 1720 wq = nfsiod_workqueue; 1721 if (wq == NULL) 1722 return; 1723 nfsiod_workqueue = NULL; 1724 destroy_workqueue(wq); 1725 } 1726 1727 int nfs_net_id; 1728 EXPORT_SYMBOL_GPL(nfs_net_id); 1729 1730 static int nfs_net_init(struct net *net) 1731 { 1732 nfs_clients_init(net); 1733 return 0; 1734 } 1735 1736 static void nfs_net_exit(struct net *net) 1737 { 1738 nfs_cleanup_cb_ident_idr(net); 1739 } 1740 1741 static struct pernet_operations nfs_net_ops = { 1742 .init = nfs_net_init, 1743 .exit = nfs_net_exit, 1744 .id = &nfs_net_id, 1745 .size = sizeof(struct nfs_net), 1746 }; 1747 1748 /* 1749 * Initialize NFS 1750 */ 1751 static int __init init_nfs_fs(void) 1752 { 1753 int err; 1754 1755 err = register_pernet_subsys(&nfs_net_ops); 1756 if (err < 0) 1757 goto out9; 1758 1759 err = nfs_fscache_register(); 1760 if (err < 0) 1761 goto out8; 1762 1763 err = nfsiod_start(); 1764 if (err) 1765 goto out7; 1766 1767 err = nfs_fs_proc_init(); 1768 if (err) 1769 goto out6; 1770 1771 err = nfs_init_nfspagecache(); 1772 if (err) 1773 goto out5; 1774 1775 err = nfs_init_inodecache(); 1776 if (err) 1777 goto out4; 1778 1779 err = nfs_init_readpagecache(); 1780 if (err) 1781 goto out3; 1782 1783 err = nfs_init_writepagecache(); 1784 if (err) 1785 goto out2; 1786 1787 err = nfs_init_directcache(); 1788 if (err) 1789 goto out1; 1790 1791 #ifdef CONFIG_PROC_FS 1792 rpc_proc_register(&init_net, &nfs_rpcstat); 1793 #endif 1794 if ((err = register_nfs_fs()) != 0) 1795 goto out0; 1796 1797 return 0; 1798 out0: 1799 #ifdef CONFIG_PROC_FS 1800 rpc_proc_unregister(&init_net, "nfs"); 1801 #endif 1802 nfs_destroy_directcache(); 1803 out1: 1804 nfs_destroy_writepagecache(); 1805 out2: 1806 nfs_destroy_readpagecache(); 1807 out3: 1808 nfs_destroy_inodecache(); 1809 out4: 1810 nfs_destroy_nfspagecache(); 1811 out5: 1812 nfs_fs_proc_exit(); 1813 out6: 1814 nfsiod_stop(); 1815 out7: 1816 nfs_fscache_unregister(); 1817 out8: 1818 unregister_pernet_subsys(&nfs_net_ops); 1819 out9: 1820 return err; 1821 } 1822 1823 static void __exit exit_nfs_fs(void) 1824 { 1825 nfs_destroy_directcache(); 1826 nfs_destroy_writepagecache(); 1827 nfs_destroy_readpagecache(); 1828 nfs_destroy_inodecache(); 1829 nfs_destroy_nfspagecache(); 1830 nfs_fscache_unregister(); 1831 unregister_pernet_subsys(&nfs_net_ops); 1832 #ifdef CONFIG_PROC_FS 1833 rpc_proc_unregister(&init_net, "nfs"); 1834 #endif 1835 unregister_nfs_fs(); 1836 nfs_fs_proc_exit(); 1837 nfsiod_stop(); 1838 } 1839 1840 /* Not quite true; I just maintain it */ 1841 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 1842 MODULE_LICENSE("GPL"); 1843 module_param(enable_ino64, bool, 0644); 1844 1845 module_init(init_nfs_fs) 1846 module_exit(exit_nfs_fs) 1847