1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/fs/nfs/inode.c 4 * 5 * Copyright (C) 1992 Rick Sladkey 6 * 7 * nfs inode and superblock handling functions 8 * 9 * Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some 10 * experimental NFS changes. Modularisation taken straight from SYS5 fs. 11 * 12 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts. 13 * J.S.Peatfield@damtp.cam.ac.uk 14 * 15 */ 16 17 #include <linux/module.h> 18 #include <linux/init.h> 19 #include <linux/sched/signal.h> 20 #include <linux/time.h> 21 #include <linux/kernel.h> 22 #include <linux/mm.h> 23 #include <linux/string.h> 24 #include <linux/stat.h> 25 #include <linux/errno.h> 26 #include <linux/unistd.h> 27 #include <linux/sunrpc/clnt.h> 28 #include <linux/sunrpc/stats.h> 29 #include <linux/sunrpc/metrics.h> 30 #include <linux/nfs_fs.h> 31 #include <linux/nfs_mount.h> 32 #include <linux/nfs4_mount.h> 33 #include <linux/lockd/bind.h> 34 #include <linux/seq_file.h> 35 #include <linux/mount.h> 36 #include <linux/vfs.h> 37 #include <linux/inet.h> 38 #include <linux/nfs_xdr.h> 39 #include <linux/slab.h> 40 #include <linux/compat.h> 41 #include <linux/freezer.h> 42 #include <linux/uaccess.h> 43 #include <linux/iversion.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 #include "sysfs.h" 55 56 #include "nfstrace.h" 57 58 #define NFSDBG_FACILITY NFSDBG_VFS 59 60 #define NFS_64_BIT_INODE_NUMBERS_ENABLED 1 61 62 /* Default is to see 64-bit inode numbers */ 63 static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED; 64 65 static int nfs_update_inode(struct inode *, struct nfs_fattr *); 66 67 static struct kmem_cache * nfs_inode_cachep; 68 69 static inline unsigned long 70 nfs_fattr_to_ino_t(struct nfs_fattr *fattr) 71 { 72 return nfs_fileid_to_ino_t(fattr->fileid); 73 } 74 75 static int nfs_wait_killable(int mode) 76 { 77 freezable_schedule_unsafe(); 78 if (signal_pending_state(mode, current)) 79 return -ERESTARTSYS; 80 return 0; 81 } 82 83 int nfs_wait_bit_killable(struct wait_bit_key *key, int mode) 84 { 85 return nfs_wait_killable(mode); 86 } 87 EXPORT_SYMBOL_GPL(nfs_wait_bit_killable); 88 89 /** 90 * nfs_compat_user_ino64 - returns the user-visible inode number 91 * @fileid: 64-bit fileid 92 * 93 * This function returns a 32-bit inode number if the boot parameter 94 * nfs.enable_ino64 is zero. 95 */ 96 u64 nfs_compat_user_ino64(u64 fileid) 97 { 98 #ifdef CONFIG_COMPAT 99 compat_ulong_t ino; 100 #else 101 unsigned long ino; 102 #endif 103 104 if (enable_ino64) 105 return fileid; 106 ino = fileid; 107 if (sizeof(ino) < sizeof(fileid)) 108 ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8; 109 return ino; 110 } 111 112 int nfs_drop_inode(struct inode *inode) 113 { 114 return NFS_STALE(inode) || generic_drop_inode(inode); 115 } 116 EXPORT_SYMBOL_GPL(nfs_drop_inode); 117 118 void nfs_clear_inode(struct inode *inode) 119 { 120 /* 121 * The following should never happen... 122 */ 123 WARN_ON_ONCE(nfs_have_writebacks(inode)); 124 WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files)); 125 nfs_zap_acl_cache(inode); 126 nfs_access_zap_cache(inode); 127 nfs_fscache_clear_inode(inode); 128 } 129 EXPORT_SYMBOL_GPL(nfs_clear_inode); 130 131 void nfs_evict_inode(struct inode *inode) 132 { 133 truncate_inode_pages_final(&inode->i_data); 134 clear_inode(inode); 135 nfs_clear_inode(inode); 136 } 137 138 int nfs_sync_inode(struct inode *inode) 139 { 140 inode_dio_wait(inode); 141 return nfs_wb_all(inode); 142 } 143 EXPORT_SYMBOL_GPL(nfs_sync_inode); 144 145 /** 146 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk 147 * @mapping: pointer to struct address_space 148 */ 149 int nfs_sync_mapping(struct address_space *mapping) 150 { 151 int ret = 0; 152 153 if (mapping->nrpages != 0) { 154 unmap_mapping_range(mapping, 0, 0, 0); 155 ret = nfs_wb_all(mapping->host); 156 } 157 return ret; 158 } 159 160 static int nfs_attribute_timeout(struct inode *inode) 161 { 162 struct nfs_inode *nfsi = NFS_I(inode); 163 164 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo); 165 } 166 167 static bool nfs_check_cache_flags_invalid(struct inode *inode, 168 unsigned long flags) 169 { 170 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity); 171 172 return (cache_validity & flags) != 0; 173 } 174 175 bool nfs_check_cache_invalid(struct inode *inode, unsigned long flags) 176 { 177 if (nfs_check_cache_flags_invalid(inode, flags)) 178 return true; 179 return nfs_attribute_cache_expired(inode); 180 } 181 EXPORT_SYMBOL_GPL(nfs_check_cache_invalid); 182 183 #ifdef CONFIG_NFS_V4_2 184 static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi) 185 { 186 return nfsi->xattr_cache != NULL; 187 } 188 #else 189 static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi) 190 { 191 return false; 192 } 193 #endif 194 195 void nfs_set_cache_invalid(struct inode *inode, unsigned long flags) 196 { 197 struct nfs_inode *nfsi = NFS_I(inode); 198 bool have_delegation = NFS_PROTO(inode)->have_delegation(inode, FMODE_READ); 199 200 if (have_delegation) { 201 if (!(flags & NFS_INO_REVAL_FORCED)) 202 flags &= ~(NFS_INO_INVALID_MODE | 203 NFS_INO_INVALID_OTHER | 204 NFS_INO_INVALID_XATTR); 205 flags &= ~(NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE); 206 } else if (flags & NFS_INO_REVAL_PAGECACHE) 207 flags |= NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE; 208 209 if (!nfs_has_xattr_cache(nfsi)) 210 flags &= ~NFS_INO_INVALID_XATTR; 211 if (flags & NFS_INO_INVALID_DATA) 212 nfs_fscache_invalidate(inode, 0); 213 flags &= ~(NFS_INO_REVAL_PAGECACHE | NFS_INO_REVAL_FORCED); 214 215 nfsi->cache_validity |= flags; 216 217 if (inode->i_mapping->nrpages == 0) 218 nfsi->cache_validity &= ~(NFS_INO_INVALID_DATA | 219 NFS_INO_DATA_INVAL_DEFER); 220 else if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 221 nfsi->cache_validity &= ~NFS_INO_DATA_INVAL_DEFER; 222 trace_nfs_set_cache_invalid(inode, 0); 223 } 224 EXPORT_SYMBOL_GPL(nfs_set_cache_invalid); 225 226 /* 227 * Invalidate the local caches 228 */ 229 static void nfs_zap_caches_locked(struct inode *inode) 230 { 231 struct nfs_inode *nfsi = NFS_I(inode); 232 int mode = inode->i_mode; 233 234 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 235 236 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 237 nfsi->attrtimeo_timestamp = jiffies; 238 239 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) { 240 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR 241 | NFS_INO_INVALID_DATA 242 | NFS_INO_INVALID_ACCESS 243 | NFS_INO_INVALID_ACL 244 | NFS_INO_INVALID_XATTR 245 | NFS_INO_REVAL_PAGECACHE); 246 } else 247 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR 248 | NFS_INO_INVALID_ACCESS 249 | NFS_INO_INVALID_ACL 250 | NFS_INO_INVALID_XATTR 251 | NFS_INO_REVAL_PAGECACHE); 252 nfs_zap_label_cache_locked(nfsi); 253 } 254 255 void nfs_zap_caches(struct inode *inode) 256 { 257 spin_lock(&inode->i_lock); 258 nfs_zap_caches_locked(inode); 259 spin_unlock(&inode->i_lock); 260 } 261 262 void nfs_zap_mapping(struct inode *inode, struct address_space *mapping) 263 { 264 if (mapping->nrpages != 0) { 265 spin_lock(&inode->i_lock); 266 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA); 267 spin_unlock(&inode->i_lock); 268 } 269 } 270 271 void nfs_zap_acl_cache(struct inode *inode) 272 { 273 void (*clear_acl_cache)(struct inode *); 274 275 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache; 276 if (clear_acl_cache != NULL) 277 clear_acl_cache(inode); 278 spin_lock(&inode->i_lock); 279 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL; 280 spin_unlock(&inode->i_lock); 281 } 282 EXPORT_SYMBOL_GPL(nfs_zap_acl_cache); 283 284 void nfs_invalidate_atime(struct inode *inode) 285 { 286 spin_lock(&inode->i_lock); 287 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME); 288 spin_unlock(&inode->i_lock); 289 } 290 EXPORT_SYMBOL_GPL(nfs_invalidate_atime); 291 292 /* 293 * Invalidate, but do not unhash, the inode. 294 * NB: must be called with inode->i_lock held! 295 */ 296 static void nfs_set_inode_stale_locked(struct inode *inode) 297 { 298 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 299 nfs_zap_caches_locked(inode); 300 trace_nfs_set_inode_stale(inode); 301 } 302 303 void nfs_set_inode_stale(struct inode *inode) 304 { 305 spin_lock(&inode->i_lock); 306 nfs_set_inode_stale_locked(inode); 307 spin_unlock(&inode->i_lock); 308 } 309 310 struct nfs_find_desc { 311 struct nfs_fh *fh; 312 struct nfs_fattr *fattr; 313 }; 314 315 /* 316 * In NFSv3 we can have 64bit inode numbers. In order to support 317 * this, and re-exported directories (also seen in NFSv2) 318 * we are forced to allow 2 different inodes to have the same 319 * i_ino. 320 */ 321 static int 322 nfs_find_actor(struct inode *inode, void *opaque) 323 { 324 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque; 325 struct nfs_fh *fh = desc->fh; 326 struct nfs_fattr *fattr = desc->fattr; 327 328 if (NFS_FILEID(inode) != fattr->fileid) 329 return 0; 330 if (inode_wrong_type(inode, fattr->mode)) 331 return 0; 332 if (nfs_compare_fh(NFS_FH(inode), fh)) 333 return 0; 334 if (is_bad_inode(inode) || NFS_STALE(inode)) 335 return 0; 336 return 1; 337 } 338 339 static int 340 nfs_init_locked(struct inode *inode, void *opaque) 341 { 342 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque; 343 struct nfs_fattr *fattr = desc->fattr; 344 345 set_nfs_fileid(inode, fattr->fileid); 346 inode->i_mode = fattr->mode; 347 nfs_copy_fh(NFS_FH(inode), desc->fh); 348 return 0; 349 } 350 351 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 352 static void nfs_clear_label_invalid(struct inode *inode) 353 { 354 spin_lock(&inode->i_lock); 355 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_LABEL; 356 spin_unlock(&inode->i_lock); 357 } 358 359 void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr) 360 { 361 int error; 362 363 if (fattr->label == NULL) 364 return; 365 366 if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) && inode->i_security) { 367 error = security_inode_notifysecctx(inode, fattr->label->label, 368 fattr->label->len); 369 if (error) 370 printk(KERN_ERR "%s() %s %d " 371 "security_inode_notifysecctx() %d\n", 372 __func__, 373 (char *)fattr->label->label, 374 fattr->label->len, error); 375 nfs_clear_label_invalid(inode); 376 } 377 } 378 379 struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags) 380 { 381 struct nfs4_label *label; 382 383 if (!(server->caps & NFS_CAP_SECURITY_LABEL)) 384 return NULL; 385 386 label = kzalloc(sizeof(struct nfs4_label), flags); 387 if (label == NULL) 388 return ERR_PTR(-ENOMEM); 389 390 label->label = kzalloc(NFS4_MAXLABELLEN, flags); 391 if (label->label == NULL) { 392 kfree(label); 393 return ERR_PTR(-ENOMEM); 394 } 395 label->len = NFS4_MAXLABELLEN; 396 397 return label; 398 } 399 EXPORT_SYMBOL_GPL(nfs4_label_alloc); 400 #else 401 void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr) 402 { 403 } 404 #endif 405 EXPORT_SYMBOL_GPL(nfs_setsecurity); 406 407 /* Search for inode identified by fh, fileid and i_mode in inode cache. */ 408 struct inode * 409 nfs_ilookup(struct super_block *sb, struct nfs_fattr *fattr, struct nfs_fh *fh) 410 { 411 struct nfs_find_desc desc = { 412 .fh = fh, 413 .fattr = fattr, 414 }; 415 struct inode *inode; 416 unsigned long hash; 417 418 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID) || 419 !(fattr->valid & NFS_ATTR_FATTR_TYPE)) 420 return NULL; 421 422 hash = nfs_fattr_to_ino_t(fattr); 423 inode = ilookup5(sb, hash, nfs_find_actor, &desc); 424 425 dprintk("%s: returning %p\n", __func__, inode); 426 return inode; 427 } 428 429 static void nfs_inode_init_regular(struct nfs_inode *nfsi) 430 { 431 atomic_long_set(&nfsi->nrequests, 0); 432 INIT_LIST_HEAD(&nfsi->commit_info.list); 433 atomic_long_set(&nfsi->commit_info.ncommit, 0); 434 atomic_set(&nfsi->commit_info.rpcs_out, 0); 435 mutex_init(&nfsi->commit_mutex); 436 } 437 438 static void nfs_inode_init_dir(struct nfs_inode *nfsi) 439 { 440 nfsi->cache_change_attribute = 0; 441 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf)); 442 init_rwsem(&nfsi->rmdir_sem); 443 } 444 445 /* 446 * This is our front-end to iget that looks up inodes by file handle 447 * instead of inode number. 448 */ 449 struct inode * 450 nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr) 451 { 452 struct nfs_find_desc desc = { 453 .fh = fh, 454 .fattr = fattr 455 }; 456 struct inode *inode = ERR_PTR(-ENOENT); 457 u64 fattr_supported = NFS_SB(sb)->fattr_valid; 458 unsigned long hash; 459 460 nfs_attr_check_mountpoint(sb, fattr); 461 462 if (nfs_attr_use_mounted_on_fileid(fattr)) 463 fattr->fileid = fattr->mounted_on_fileid; 464 else if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0) 465 goto out_no_inode; 466 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0) 467 goto out_no_inode; 468 469 hash = nfs_fattr_to_ino_t(fattr); 470 471 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc); 472 if (inode == NULL) { 473 inode = ERR_PTR(-ENOMEM); 474 goto out_no_inode; 475 } 476 477 if (inode->i_state & I_NEW) { 478 struct nfs_inode *nfsi = NFS_I(inode); 479 unsigned long now = jiffies; 480 481 /* We set i_ino for the few things that still rely on it, 482 * such as stat(2) */ 483 inode->i_ino = hash; 484 485 /* We can't support update_atime(), since the server will reset it */ 486 inode->i_flags |= S_NOATIME|S_NOCMTIME; 487 inode->i_mode = fattr->mode; 488 nfsi->cache_validity = 0; 489 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0 490 && (fattr_supported & NFS_ATTR_FATTR_MODE)) 491 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MODE); 492 /* Why so? Because we want revalidate for devices/FIFOs, and 493 * that's precisely what we have in nfs_file_inode_operations. 494 */ 495 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops; 496 if (S_ISREG(inode->i_mode)) { 497 inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops; 498 inode->i_data.a_ops = &nfs_file_aops; 499 nfs_inode_init_regular(nfsi); 500 } else if (S_ISDIR(inode->i_mode)) { 501 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops; 502 inode->i_fop = &nfs_dir_operations; 503 inode->i_data.a_ops = &nfs_dir_aops; 504 nfs_inode_init_dir(nfsi); 505 /* Deal with crossing mountpoints */ 506 if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT || 507 fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) { 508 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) 509 inode->i_op = &nfs_referral_inode_operations; 510 else 511 inode->i_op = &nfs_mountpoint_inode_operations; 512 inode->i_fop = NULL; 513 inode->i_flags |= S_AUTOMOUNT; 514 } 515 } else if (S_ISLNK(inode->i_mode)) { 516 inode->i_op = &nfs_symlink_inode_operations; 517 inode_nohighmem(inode); 518 } else 519 init_special_inode(inode, inode->i_mode, fattr->rdev); 520 521 memset(&inode->i_atime, 0, sizeof(inode->i_atime)); 522 memset(&inode->i_mtime, 0, sizeof(inode->i_mtime)); 523 memset(&inode->i_ctime, 0, sizeof(inode->i_ctime)); 524 inode_set_iversion_raw(inode, 0); 525 inode->i_size = 0; 526 clear_nlink(inode); 527 inode->i_uid = make_kuid(&init_user_ns, -2); 528 inode->i_gid = make_kgid(&init_user_ns, -2); 529 inode->i_blocks = 0; 530 nfsi->write_io = 0; 531 nfsi->read_io = 0; 532 533 nfsi->read_cache_jiffies = fattr->time_start; 534 nfsi->attr_gencount = fattr->gencount; 535 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 536 inode->i_atime = fattr->atime; 537 else if (fattr_supported & NFS_ATTR_FATTR_ATIME) 538 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME); 539 if (fattr->valid & NFS_ATTR_FATTR_MTIME) 540 inode->i_mtime = fattr->mtime; 541 else if (fattr_supported & NFS_ATTR_FATTR_MTIME) 542 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME); 543 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 544 inode->i_ctime = fattr->ctime; 545 else if (fattr_supported & NFS_ATTR_FATTR_CTIME) 546 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CTIME); 547 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) 548 inode_set_iversion_raw(inode, fattr->change_attr); 549 else 550 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE); 551 if (fattr->valid & NFS_ATTR_FATTR_SIZE) 552 inode->i_size = nfs_size_to_loff_t(fattr->size); 553 else 554 nfs_set_cache_invalid(inode, NFS_INO_INVALID_SIZE); 555 if (fattr->valid & NFS_ATTR_FATTR_NLINK) 556 set_nlink(inode, fattr->nlink); 557 else if (fattr_supported & NFS_ATTR_FATTR_NLINK) 558 nfs_set_cache_invalid(inode, NFS_INO_INVALID_NLINK); 559 if (fattr->valid & NFS_ATTR_FATTR_OWNER) 560 inode->i_uid = fattr->uid; 561 else if (fattr_supported & NFS_ATTR_FATTR_OWNER) 562 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER); 563 if (fattr->valid & NFS_ATTR_FATTR_GROUP) 564 inode->i_gid = fattr->gid; 565 else if (fattr_supported & NFS_ATTR_FATTR_GROUP) 566 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER); 567 if (nfs_server_capable(inode, NFS_CAP_XATTR)) 568 nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR); 569 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) 570 inode->i_blocks = fattr->du.nfs2.blocks; 571 else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED && 572 fattr->size != 0) 573 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS); 574 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { 575 /* 576 * report the blocks in 512byte units 577 */ 578 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 579 } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED && 580 fattr->size != 0) 581 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS); 582 583 nfs_setsecurity(inode, fattr); 584 585 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 586 nfsi->attrtimeo_timestamp = now; 587 nfsi->access_cache = RB_ROOT; 588 589 nfs_fscache_init_inode(inode); 590 591 unlock_new_inode(inode); 592 } else { 593 int err = nfs_refresh_inode(inode, fattr); 594 if (err < 0) { 595 iput(inode); 596 inode = ERR_PTR(err); 597 goto out_no_inode; 598 } 599 } 600 dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n", 601 inode->i_sb->s_id, 602 (unsigned long long)NFS_FILEID(inode), 603 nfs_display_fhandle_hash(fh), 604 atomic_read(&inode->i_count)); 605 606 out: 607 return inode; 608 609 out_no_inode: 610 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode)); 611 goto out; 612 } 613 EXPORT_SYMBOL_GPL(nfs_fhget); 614 615 #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) 616 617 int 618 nfs_setattr(struct user_namespace *mnt_userns, struct dentry *dentry, 619 struct iattr *attr) 620 { 621 struct inode *inode = d_inode(dentry); 622 struct nfs_fattr *fattr; 623 int error = 0; 624 625 nfs_inc_stats(inode, NFSIOS_VFSSETATTR); 626 627 /* skip mode change if it's just for clearing setuid/setgid */ 628 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) 629 attr->ia_valid &= ~ATTR_MODE; 630 631 if (attr->ia_valid & ATTR_SIZE) { 632 BUG_ON(!S_ISREG(inode->i_mode)); 633 634 error = inode_newsize_ok(inode, attr->ia_size); 635 if (error) 636 return error; 637 638 if (attr->ia_size == i_size_read(inode)) 639 attr->ia_valid &= ~ATTR_SIZE; 640 } 641 642 /* Optimization: if the end result is no change, don't RPC */ 643 if (((attr->ia_valid & NFS_VALID_ATTRS) & ~(ATTR_FILE|ATTR_OPEN)) == 0) 644 return 0; 645 646 trace_nfs_setattr_enter(inode); 647 648 /* Write all dirty data */ 649 if (S_ISREG(inode->i_mode)) 650 nfs_sync_inode(inode); 651 652 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode)); 653 if (fattr == NULL) { 654 error = -ENOMEM; 655 goto out; 656 } 657 658 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr); 659 if (error == 0) 660 error = nfs_refresh_inode(inode, fattr); 661 nfs_free_fattr(fattr); 662 out: 663 trace_nfs_setattr_exit(inode, error); 664 return error; 665 } 666 EXPORT_SYMBOL_GPL(nfs_setattr); 667 668 /** 669 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall 670 * @inode: inode of the file used 671 * @offset: file offset to start truncating 672 * 673 * This is a copy of the common vmtruncate, but with the locking 674 * corrected to take into account the fact that NFS requires 675 * inode->i_size to be updated under the inode->i_lock. 676 * Note: must be called with inode->i_lock held! 677 */ 678 static int nfs_vmtruncate(struct inode * inode, loff_t offset) 679 { 680 int err; 681 682 err = inode_newsize_ok(inode, offset); 683 if (err) 684 goto out; 685 686 trace_nfs_size_truncate(inode, offset); 687 i_size_write(inode, offset); 688 /* Optimisation */ 689 if (offset == 0) 690 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_DATA | 691 NFS_INO_DATA_INVAL_DEFER); 692 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE; 693 694 spin_unlock(&inode->i_lock); 695 truncate_pagecache(inode, offset); 696 spin_lock(&inode->i_lock); 697 out: 698 return err; 699 } 700 701 /** 702 * nfs_setattr_update_inode - Update inode metadata after a setattr call. 703 * @inode: pointer to struct inode 704 * @attr: pointer to struct iattr 705 * @fattr: pointer to struct nfs_fattr 706 * 707 * Note: we do this in the *proc.c in order to ensure that 708 * it works for things like exclusive creates too. 709 */ 710 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr, 711 struct nfs_fattr *fattr) 712 { 713 /* Barrier: bump the attribute generation count. */ 714 nfs_fattr_set_barrier(fattr); 715 716 spin_lock(&inode->i_lock); 717 NFS_I(inode)->attr_gencount = fattr->gencount; 718 if ((attr->ia_valid & ATTR_SIZE) != 0) { 719 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME | 720 NFS_INO_INVALID_BLOCKS); 721 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC); 722 nfs_vmtruncate(inode, attr->ia_size); 723 } 724 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) { 725 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_CTIME; 726 if ((attr->ia_valid & ATTR_KILL_SUID) != 0 && 727 inode->i_mode & S_ISUID) 728 inode->i_mode &= ~S_ISUID; 729 if ((attr->ia_valid & ATTR_KILL_SGID) != 0 && 730 (inode->i_mode & (S_ISGID | S_IXGRP)) == 731 (S_ISGID | S_IXGRP)) 732 inode->i_mode &= ~S_ISGID; 733 if ((attr->ia_valid & ATTR_MODE) != 0) { 734 int mode = attr->ia_mode & S_IALLUGO; 735 mode |= inode->i_mode & ~S_IALLUGO; 736 inode->i_mode = mode; 737 } 738 if ((attr->ia_valid & ATTR_UID) != 0) 739 inode->i_uid = attr->ia_uid; 740 if ((attr->ia_valid & ATTR_GID) != 0) 741 inode->i_gid = attr->ia_gid; 742 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 743 inode->i_ctime = fattr->ctime; 744 else 745 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE 746 | NFS_INO_INVALID_CTIME); 747 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ACCESS 748 | NFS_INO_INVALID_ACL); 749 } 750 if (attr->ia_valid & (ATTR_ATIME_SET|ATTR_ATIME)) { 751 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_ATIME 752 | NFS_INO_INVALID_CTIME); 753 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 754 inode->i_atime = fattr->atime; 755 else if (attr->ia_valid & ATTR_ATIME_SET) 756 inode->i_atime = attr->ia_atime; 757 else 758 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME); 759 760 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 761 inode->i_ctime = fattr->ctime; 762 else 763 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE 764 | NFS_INO_INVALID_CTIME); 765 } 766 if (attr->ia_valid & (ATTR_MTIME_SET|ATTR_MTIME)) { 767 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_MTIME 768 | NFS_INO_INVALID_CTIME); 769 if (fattr->valid & NFS_ATTR_FATTR_MTIME) 770 inode->i_mtime = fattr->mtime; 771 else if (attr->ia_valid & ATTR_MTIME_SET) 772 inode->i_mtime = attr->ia_mtime; 773 else 774 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME); 775 776 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 777 inode->i_ctime = fattr->ctime; 778 else 779 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE 780 | NFS_INO_INVALID_CTIME); 781 } 782 if (fattr->valid) 783 nfs_update_inode(inode, fattr); 784 spin_unlock(&inode->i_lock); 785 } 786 EXPORT_SYMBOL_GPL(nfs_setattr_update_inode); 787 788 static void nfs_readdirplus_parent_cache_miss(struct dentry *dentry) 789 { 790 struct dentry *parent; 791 792 if (!nfs_server_capable(d_inode(dentry), NFS_CAP_READDIRPLUS)) 793 return; 794 parent = dget_parent(dentry); 795 nfs_force_use_readdirplus(d_inode(parent)); 796 dput(parent); 797 } 798 799 static void nfs_readdirplus_parent_cache_hit(struct dentry *dentry) 800 { 801 struct dentry *parent; 802 803 if (!nfs_server_capable(d_inode(dentry), NFS_CAP_READDIRPLUS)) 804 return; 805 parent = dget_parent(dentry); 806 nfs_advise_use_readdirplus(d_inode(parent)); 807 dput(parent); 808 } 809 810 static u32 nfs_get_valid_attrmask(struct inode *inode) 811 { 812 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity); 813 u32 reply_mask = STATX_INO | STATX_TYPE; 814 815 if (!(cache_validity & NFS_INO_INVALID_ATIME)) 816 reply_mask |= STATX_ATIME; 817 if (!(cache_validity & NFS_INO_INVALID_CTIME)) 818 reply_mask |= STATX_CTIME; 819 if (!(cache_validity & NFS_INO_INVALID_MTIME)) 820 reply_mask |= STATX_MTIME; 821 if (!(cache_validity & NFS_INO_INVALID_SIZE)) 822 reply_mask |= STATX_SIZE; 823 if (!(cache_validity & NFS_INO_INVALID_NLINK)) 824 reply_mask |= STATX_NLINK; 825 if (!(cache_validity & NFS_INO_INVALID_MODE)) 826 reply_mask |= STATX_MODE; 827 if (!(cache_validity & NFS_INO_INVALID_OTHER)) 828 reply_mask |= STATX_UID | STATX_GID; 829 if (!(cache_validity & NFS_INO_INVALID_BLOCKS)) 830 reply_mask |= STATX_BLOCKS; 831 return reply_mask; 832 } 833 834 int nfs_getattr(struct user_namespace *mnt_userns, const struct path *path, 835 struct kstat *stat, u32 request_mask, unsigned int query_flags) 836 { 837 struct inode *inode = d_inode(path->dentry); 838 struct nfs_server *server = NFS_SERVER(inode); 839 unsigned long cache_validity; 840 int err = 0; 841 bool force_sync = query_flags & AT_STATX_FORCE_SYNC; 842 bool do_update = false; 843 844 trace_nfs_getattr_enter(inode); 845 846 request_mask &= STATX_TYPE | STATX_MODE | STATX_NLINK | STATX_UID | 847 STATX_GID | STATX_ATIME | STATX_MTIME | STATX_CTIME | 848 STATX_INO | STATX_SIZE | STATX_BLOCKS; 849 850 if ((query_flags & AT_STATX_DONT_SYNC) && !force_sync) { 851 nfs_readdirplus_parent_cache_hit(path->dentry); 852 goto out_no_revalidate; 853 } 854 855 /* Flush out writes to the server in order to update c/mtime. */ 856 if ((request_mask & (STATX_CTIME|STATX_MTIME)) && 857 S_ISREG(inode->i_mode)) { 858 err = filemap_write_and_wait(inode->i_mapping); 859 if (err) 860 goto out; 861 } 862 863 /* 864 * We may force a getattr if the user cares about atime. 865 * 866 * Note that we only have to check the vfsmount flags here: 867 * - NFS always sets S_NOATIME by so checking it would give a 868 * bogus result 869 * - NFS never sets SB_NOATIME or SB_NODIRATIME so there is 870 * no point in checking those. 871 */ 872 if ((path->mnt->mnt_flags & MNT_NOATIME) || 873 ((path->mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))) 874 request_mask &= ~STATX_ATIME; 875 876 /* Is the user requesting attributes that might need revalidation? */ 877 if (!(request_mask & (STATX_MODE|STATX_NLINK|STATX_ATIME|STATX_CTIME| 878 STATX_MTIME|STATX_UID|STATX_GID| 879 STATX_SIZE|STATX_BLOCKS))) 880 goto out_no_revalidate; 881 882 /* Check whether the cached attributes are stale */ 883 do_update |= force_sync || nfs_attribute_cache_expired(inode); 884 cache_validity = READ_ONCE(NFS_I(inode)->cache_validity); 885 do_update |= cache_validity & NFS_INO_INVALID_CHANGE; 886 if (request_mask & STATX_ATIME) 887 do_update |= cache_validity & NFS_INO_INVALID_ATIME; 888 if (request_mask & STATX_CTIME) 889 do_update |= cache_validity & NFS_INO_INVALID_CTIME; 890 if (request_mask & STATX_MTIME) 891 do_update |= cache_validity & NFS_INO_INVALID_MTIME; 892 if (request_mask & STATX_SIZE) 893 do_update |= cache_validity & NFS_INO_INVALID_SIZE; 894 if (request_mask & STATX_NLINK) 895 do_update |= cache_validity & NFS_INO_INVALID_NLINK; 896 if (request_mask & STATX_MODE) 897 do_update |= cache_validity & NFS_INO_INVALID_MODE; 898 if (request_mask & (STATX_UID | STATX_GID)) 899 do_update |= cache_validity & NFS_INO_INVALID_OTHER; 900 if (request_mask & STATX_BLOCKS) 901 do_update |= cache_validity & NFS_INO_INVALID_BLOCKS; 902 903 if (do_update) { 904 /* Update the attribute cache */ 905 if (!(server->flags & NFS_MOUNT_NOAC)) 906 nfs_readdirplus_parent_cache_miss(path->dentry); 907 else 908 nfs_readdirplus_parent_cache_hit(path->dentry); 909 err = __nfs_revalidate_inode(server, inode); 910 if (err) 911 goto out; 912 } else 913 nfs_readdirplus_parent_cache_hit(path->dentry); 914 out_no_revalidate: 915 /* Only return attributes that were revalidated. */ 916 stat->result_mask = nfs_get_valid_attrmask(inode) | request_mask; 917 918 generic_fillattr(&init_user_ns, inode, stat); 919 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode)); 920 if (S_ISDIR(inode->i_mode)) 921 stat->blksize = NFS_SERVER(inode)->dtsize; 922 out: 923 trace_nfs_getattr_exit(inode, err); 924 return err; 925 } 926 EXPORT_SYMBOL_GPL(nfs_getattr); 927 928 static void nfs_init_lock_context(struct nfs_lock_context *l_ctx) 929 { 930 refcount_set(&l_ctx->count, 1); 931 l_ctx->lockowner = current->files; 932 INIT_LIST_HEAD(&l_ctx->list); 933 atomic_set(&l_ctx->io_count, 0); 934 } 935 936 static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx) 937 { 938 struct nfs_lock_context *pos; 939 940 list_for_each_entry_rcu(pos, &ctx->lock_context.list, list) { 941 if (pos->lockowner != current->files) 942 continue; 943 if (refcount_inc_not_zero(&pos->count)) 944 return pos; 945 } 946 return NULL; 947 } 948 949 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx) 950 { 951 struct nfs_lock_context *res, *new = NULL; 952 struct inode *inode = d_inode(ctx->dentry); 953 954 rcu_read_lock(); 955 res = __nfs_find_lock_context(ctx); 956 rcu_read_unlock(); 957 if (res == NULL) { 958 new = kmalloc(sizeof(*new), GFP_KERNEL); 959 if (new == NULL) 960 return ERR_PTR(-ENOMEM); 961 nfs_init_lock_context(new); 962 spin_lock(&inode->i_lock); 963 res = __nfs_find_lock_context(ctx); 964 if (res == NULL) { 965 new->open_context = get_nfs_open_context(ctx); 966 if (new->open_context) { 967 list_add_tail_rcu(&new->list, 968 &ctx->lock_context.list); 969 res = new; 970 new = NULL; 971 } else 972 res = ERR_PTR(-EBADF); 973 } 974 spin_unlock(&inode->i_lock); 975 kfree(new); 976 } 977 return res; 978 } 979 EXPORT_SYMBOL_GPL(nfs_get_lock_context); 980 981 void nfs_put_lock_context(struct nfs_lock_context *l_ctx) 982 { 983 struct nfs_open_context *ctx = l_ctx->open_context; 984 struct inode *inode = d_inode(ctx->dentry); 985 986 if (!refcount_dec_and_lock(&l_ctx->count, &inode->i_lock)) 987 return; 988 list_del_rcu(&l_ctx->list); 989 spin_unlock(&inode->i_lock); 990 put_nfs_open_context(ctx); 991 kfree_rcu(l_ctx, rcu_head); 992 } 993 EXPORT_SYMBOL_GPL(nfs_put_lock_context); 994 995 /** 996 * nfs_close_context - Common close_context() routine NFSv2/v3 997 * @ctx: pointer to context 998 * @is_sync: is this a synchronous close 999 * 1000 * Ensure that the attributes are up to date if we're mounted 1001 * with close-to-open semantics and we have cached data that will 1002 * need to be revalidated on open. 1003 */ 1004 void nfs_close_context(struct nfs_open_context *ctx, int is_sync) 1005 { 1006 struct nfs_inode *nfsi; 1007 struct inode *inode; 1008 1009 if (!(ctx->mode & FMODE_WRITE)) 1010 return; 1011 if (!is_sync) 1012 return; 1013 inode = d_inode(ctx->dentry); 1014 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) 1015 return; 1016 nfsi = NFS_I(inode); 1017 if (inode->i_mapping->nrpages == 0) 1018 return; 1019 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 1020 return; 1021 if (!list_empty(&nfsi->open_files)) 1022 return; 1023 if (NFS_SERVER(inode)->flags & NFS_MOUNT_NOCTO) 1024 return; 1025 nfs_revalidate_inode(inode, 1026 NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE); 1027 } 1028 EXPORT_SYMBOL_GPL(nfs_close_context); 1029 1030 struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, 1031 fmode_t f_mode, 1032 struct file *filp) 1033 { 1034 struct nfs_open_context *ctx; 1035 1036 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); 1037 if (!ctx) 1038 return ERR_PTR(-ENOMEM); 1039 nfs_sb_active(dentry->d_sb); 1040 ctx->dentry = dget(dentry); 1041 if (filp) 1042 ctx->cred = get_cred(filp->f_cred); 1043 else 1044 ctx->cred = get_current_cred(); 1045 rcu_assign_pointer(ctx->ll_cred, NULL); 1046 ctx->state = NULL; 1047 ctx->mode = f_mode; 1048 ctx->flags = 0; 1049 ctx->error = 0; 1050 ctx->flock_owner = (fl_owner_t)filp; 1051 nfs_init_lock_context(&ctx->lock_context); 1052 ctx->lock_context.open_context = ctx; 1053 INIT_LIST_HEAD(&ctx->list); 1054 ctx->mdsthreshold = NULL; 1055 return ctx; 1056 } 1057 EXPORT_SYMBOL_GPL(alloc_nfs_open_context); 1058 1059 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx) 1060 { 1061 if (ctx != NULL && refcount_inc_not_zero(&ctx->lock_context.count)) 1062 return ctx; 1063 return NULL; 1064 } 1065 EXPORT_SYMBOL_GPL(get_nfs_open_context); 1066 1067 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync) 1068 { 1069 struct inode *inode = d_inode(ctx->dentry); 1070 struct super_block *sb = ctx->dentry->d_sb; 1071 1072 if (!refcount_dec_and_test(&ctx->lock_context.count)) 1073 return; 1074 if (!list_empty(&ctx->list)) { 1075 spin_lock(&inode->i_lock); 1076 list_del_rcu(&ctx->list); 1077 spin_unlock(&inode->i_lock); 1078 } 1079 if (inode != NULL) 1080 NFS_PROTO(inode)->close_context(ctx, is_sync); 1081 put_cred(ctx->cred); 1082 dput(ctx->dentry); 1083 nfs_sb_deactive(sb); 1084 put_rpccred(rcu_dereference_protected(ctx->ll_cred, 1)); 1085 kfree(ctx->mdsthreshold); 1086 kfree_rcu(ctx, rcu_head); 1087 } 1088 1089 void put_nfs_open_context(struct nfs_open_context *ctx) 1090 { 1091 __put_nfs_open_context(ctx, 0); 1092 } 1093 EXPORT_SYMBOL_GPL(put_nfs_open_context); 1094 1095 static void put_nfs_open_context_sync(struct nfs_open_context *ctx) 1096 { 1097 __put_nfs_open_context(ctx, 1); 1098 } 1099 1100 /* 1101 * Ensure that mmap has a recent RPC credential for use when writing out 1102 * shared pages 1103 */ 1104 void nfs_inode_attach_open_context(struct nfs_open_context *ctx) 1105 { 1106 struct inode *inode = d_inode(ctx->dentry); 1107 struct nfs_inode *nfsi = NFS_I(inode); 1108 1109 spin_lock(&inode->i_lock); 1110 if (list_empty(&nfsi->open_files) && 1111 (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER)) 1112 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA | 1113 NFS_INO_REVAL_FORCED); 1114 list_add_tail_rcu(&ctx->list, &nfsi->open_files); 1115 spin_unlock(&inode->i_lock); 1116 } 1117 EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context); 1118 1119 void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx) 1120 { 1121 filp->private_data = get_nfs_open_context(ctx); 1122 set_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags); 1123 if (list_empty(&ctx->list)) 1124 nfs_inode_attach_open_context(ctx); 1125 } 1126 EXPORT_SYMBOL_GPL(nfs_file_set_open_context); 1127 1128 /* 1129 * Given an inode, search for an open context with the desired characteristics 1130 */ 1131 struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode) 1132 { 1133 struct nfs_inode *nfsi = NFS_I(inode); 1134 struct nfs_open_context *pos, *ctx = NULL; 1135 1136 rcu_read_lock(); 1137 list_for_each_entry_rcu(pos, &nfsi->open_files, list) { 1138 if (cred != NULL && cred_fscmp(pos->cred, cred) != 0) 1139 continue; 1140 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode) 1141 continue; 1142 if (!test_bit(NFS_CONTEXT_FILE_OPEN, &pos->flags)) 1143 continue; 1144 ctx = get_nfs_open_context(pos); 1145 if (ctx) 1146 break; 1147 } 1148 rcu_read_unlock(); 1149 return ctx; 1150 } 1151 1152 void nfs_file_clear_open_context(struct file *filp) 1153 { 1154 struct nfs_open_context *ctx = nfs_file_open_context(filp); 1155 1156 if (ctx) { 1157 struct inode *inode = d_inode(ctx->dentry); 1158 1159 clear_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags); 1160 /* 1161 * We fatal error on write before. Try to writeback 1162 * every page again. 1163 */ 1164 if (ctx->error < 0) 1165 invalidate_inode_pages2(inode->i_mapping); 1166 filp->private_data = NULL; 1167 put_nfs_open_context_sync(ctx); 1168 } 1169 } 1170 1171 /* 1172 * These allocate and release file read/write context information. 1173 */ 1174 int nfs_open(struct inode *inode, struct file *filp) 1175 { 1176 struct nfs_open_context *ctx; 1177 1178 ctx = alloc_nfs_open_context(file_dentry(filp), filp->f_mode, filp); 1179 if (IS_ERR(ctx)) 1180 return PTR_ERR(ctx); 1181 nfs_file_set_open_context(filp, ctx); 1182 put_nfs_open_context(ctx); 1183 nfs_fscache_open_file(inode, filp); 1184 return 0; 1185 } 1186 EXPORT_SYMBOL_GPL(nfs_open); 1187 1188 /* 1189 * This function is called whenever some part of NFS notices that 1190 * the cached attributes have to be refreshed. 1191 */ 1192 int 1193 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 1194 { 1195 int status = -ESTALE; 1196 struct nfs_fattr *fattr = NULL; 1197 struct nfs_inode *nfsi = NFS_I(inode); 1198 1199 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Lu)\n", 1200 inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode)); 1201 1202 trace_nfs_revalidate_inode_enter(inode); 1203 1204 if (is_bad_inode(inode)) 1205 goto out; 1206 if (NFS_STALE(inode)) 1207 goto out; 1208 1209 /* pNFS: Attributes aren't updated until we layoutcommit */ 1210 if (S_ISREG(inode->i_mode)) { 1211 status = pnfs_sync_inode(inode, false); 1212 if (status) 1213 goto out; 1214 } 1215 1216 status = -ENOMEM; 1217 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode)); 1218 if (fattr == NULL) 1219 goto out; 1220 1221 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE); 1222 1223 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, inode); 1224 if (status != 0) { 1225 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n", 1226 inode->i_sb->s_id, 1227 (unsigned long long)NFS_FILEID(inode), status); 1228 switch (status) { 1229 case -ETIMEDOUT: 1230 /* A soft timeout occurred. Use cached information? */ 1231 if (server->flags & NFS_MOUNT_SOFTREVAL) 1232 status = 0; 1233 break; 1234 case -ESTALE: 1235 if (!S_ISDIR(inode->i_mode)) 1236 nfs_set_inode_stale(inode); 1237 else 1238 nfs_zap_caches(inode); 1239 } 1240 goto out; 1241 } 1242 1243 status = nfs_refresh_inode(inode, fattr); 1244 if (status) { 1245 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n", 1246 inode->i_sb->s_id, 1247 (unsigned long long)NFS_FILEID(inode), status); 1248 goto out; 1249 } 1250 1251 if (nfsi->cache_validity & NFS_INO_INVALID_ACL) 1252 nfs_zap_acl_cache(inode); 1253 1254 nfs_setsecurity(inode, fattr); 1255 1256 dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n", 1257 inode->i_sb->s_id, 1258 (unsigned long long)NFS_FILEID(inode)); 1259 1260 out: 1261 nfs_free_fattr(fattr); 1262 trace_nfs_revalidate_inode_exit(inode, status); 1263 return status; 1264 } 1265 1266 int nfs_attribute_cache_expired(struct inode *inode) 1267 { 1268 if (nfs_have_delegated_attributes(inode)) 1269 return 0; 1270 return nfs_attribute_timeout(inode); 1271 } 1272 1273 /** 1274 * nfs_revalidate_inode - Revalidate the inode attributes 1275 * @inode: pointer to inode struct 1276 * @flags: cache flags to check 1277 * 1278 * Updates inode attribute information by retrieving the data from the server. 1279 */ 1280 int nfs_revalidate_inode(struct inode *inode, unsigned long flags) 1281 { 1282 if (!nfs_check_cache_invalid(inode, flags)) 1283 return NFS_STALE(inode) ? -ESTALE : 0; 1284 return __nfs_revalidate_inode(NFS_SERVER(inode), inode); 1285 } 1286 EXPORT_SYMBOL_GPL(nfs_revalidate_inode); 1287 1288 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping) 1289 { 1290 int ret; 1291 1292 nfs_fscache_invalidate(inode, 0); 1293 if (mapping->nrpages != 0) { 1294 if (S_ISREG(inode->i_mode)) { 1295 ret = nfs_sync_mapping(mapping); 1296 if (ret < 0) 1297 return ret; 1298 } 1299 ret = invalidate_inode_pages2(mapping); 1300 if (ret < 0) 1301 return ret; 1302 } 1303 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE); 1304 1305 dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n", 1306 inode->i_sb->s_id, 1307 (unsigned long long)NFS_FILEID(inode)); 1308 return 0; 1309 } 1310 1311 /** 1312 * nfs_clear_invalid_mapping - Conditionally clear a mapping 1313 * @mapping: pointer to mapping 1314 * 1315 * If the NFS_INO_INVALID_DATA inode flag is set, clear the mapping. 1316 */ 1317 int nfs_clear_invalid_mapping(struct address_space *mapping) 1318 { 1319 struct inode *inode = mapping->host; 1320 struct nfs_inode *nfsi = NFS_I(inode); 1321 unsigned long *bitlock = &nfsi->flags; 1322 int ret = 0; 1323 1324 /* 1325 * We must clear NFS_INO_INVALID_DATA first to ensure that 1326 * invalidations that come in while we're shooting down the mappings 1327 * are respected. But, that leaves a race window where one revalidator 1328 * can clear the flag, and then another checks it before the mapping 1329 * gets invalidated. Fix that by serializing access to this part of 1330 * the function. 1331 * 1332 * At the same time, we need to allow other tasks to see whether we 1333 * might be in the middle of invalidating the pages, so we only set 1334 * the bit lock here if it looks like we're going to be doing that. 1335 */ 1336 for (;;) { 1337 ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING, 1338 nfs_wait_bit_killable, TASK_KILLABLE); 1339 if (ret) 1340 goto out; 1341 spin_lock(&inode->i_lock); 1342 if (test_bit(NFS_INO_INVALIDATING, bitlock)) { 1343 spin_unlock(&inode->i_lock); 1344 continue; 1345 } 1346 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 1347 break; 1348 spin_unlock(&inode->i_lock); 1349 goto out; 1350 } 1351 1352 set_bit(NFS_INO_INVALIDATING, bitlock); 1353 smp_wmb(); 1354 nfsi->cache_validity &= 1355 ~(NFS_INO_INVALID_DATA | NFS_INO_DATA_INVAL_DEFER); 1356 spin_unlock(&inode->i_lock); 1357 trace_nfs_invalidate_mapping_enter(inode); 1358 ret = nfs_invalidate_mapping(inode, mapping); 1359 trace_nfs_invalidate_mapping_exit(inode, ret); 1360 1361 clear_bit_unlock(NFS_INO_INVALIDATING, bitlock); 1362 smp_mb__after_atomic(); 1363 wake_up_bit(bitlock, NFS_INO_INVALIDATING); 1364 out: 1365 return ret; 1366 } 1367 1368 bool nfs_mapping_need_revalidate_inode(struct inode *inode) 1369 { 1370 return nfs_check_cache_invalid(inode, NFS_INO_INVALID_CHANGE) || 1371 NFS_STALE(inode); 1372 } 1373 1374 int nfs_revalidate_mapping_rcu(struct inode *inode) 1375 { 1376 struct nfs_inode *nfsi = NFS_I(inode); 1377 unsigned long *bitlock = &nfsi->flags; 1378 int ret = 0; 1379 1380 if (IS_SWAPFILE(inode)) 1381 goto out; 1382 if (nfs_mapping_need_revalidate_inode(inode)) { 1383 ret = -ECHILD; 1384 goto out; 1385 } 1386 spin_lock(&inode->i_lock); 1387 if (test_bit(NFS_INO_INVALIDATING, bitlock) || 1388 (nfsi->cache_validity & NFS_INO_INVALID_DATA)) 1389 ret = -ECHILD; 1390 spin_unlock(&inode->i_lock); 1391 out: 1392 return ret; 1393 } 1394 1395 /** 1396 * nfs_revalidate_mapping - Revalidate the pagecache 1397 * @inode: pointer to host inode 1398 * @mapping: pointer to mapping 1399 */ 1400 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) 1401 { 1402 /* swapfiles are not supposed to be shared. */ 1403 if (IS_SWAPFILE(inode)) 1404 return 0; 1405 1406 if (nfs_mapping_need_revalidate_inode(inode)) { 1407 int ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 1408 if (ret < 0) 1409 return ret; 1410 } 1411 1412 return nfs_clear_invalid_mapping(mapping); 1413 } 1414 1415 static bool nfs_file_has_writers(struct nfs_inode *nfsi) 1416 { 1417 struct inode *inode = &nfsi->vfs_inode; 1418 1419 if (!S_ISREG(inode->i_mode)) 1420 return false; 1421 if (list_empty(&nfsi->open_files)) 1422 return false; 1423 return inode_is_open_for_write(inode); 1424 } 1425 1426 static bool nfs_file_has_buffered_writers(struct nfs_inode *nfsi) 1427 { 1428 return nfs_file_has_writers(nfsi) && nfs_file_io_is_buffered(nfsi); 1429 } 1430 1431 static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1432 { 1433 struct timespec64 ts; 1434 1435 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE) 1436 && (fattr->valid & NFS_ATTR_FATTR_CHANGE) 1437 && inode_eq_iversion_raw(inode, fattr->pre_change_attr)) { 1438 inode_set_iversion_raw(inode, fattr->change_attr); 1439 if (S_ISDIR(inode->i_mode)) 1440 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA); 1441 else if (nfs_server_capable(inode, NFS_CAP_XATTR)) 1442 nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR); 1443 } 1444 /* If we have atomic WCC data, we may update some attributes */ 1445 ts = inode->i_ctime; 1446 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME) 1447 && (fattr->valid & NFS_ATTR_FATTR_CTIME) 1448 && timespec64_equal(&ts, &fattr->pre_ctime)) { 1449 inode->i_ctime = fattr->ctime; 1450 } 1451 1452 ts = inode->i_mtime; 1453 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME) 1454 && (fattr->valid & NFS_ATTR_FATTR_MTIME) 1455 && timespec64_equal(&ts, &fattr->pre_mtime)) { 1456 inode->i_mtime = fattr->mtime; 1457 } 1458 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE) 1459 && (fattr->valid & NFS_ATTR_FATTR_SIZE) 1460 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size) 1461 && !nfs_have_writebacks(inode)) { 1462 trace_nfs_size_wcc(inode, fattr->size); 1463 i_size_write(inode, nfs_size_to_loff_t(fattr->size)); 1464 } 1465 } 1466 1467 /** 1468 * nfs_check_inode_attributes - verify consistency of the inode attribute cache 1469 * @inode: pointer to inode 1470 * @fattr: updated attributes 1471 * 1472 * Verifies the attribute cache. If we have just changed the attributes, 1473 * so that fattr carries weak cache consistency data, then it may 1474 * also update the ctime/mtime/change_attribute. 1475 */ 1476 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr) 1477 { 1478 struct nfs_inode *nfsi = NFS_I(inode); 1479 loff_t cur_size, new_isize; 1480 unsigned long invalid = 0; 1481 struct timespec64 ts; 1482 1483 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) 1484 return 0; 1485 1486 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) { 1487 /* Only a mounted-on-fileid? Just exit */ 1488 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) 1489 return 0; 1490 /* Has the inode gone and changed behind our back? */ 1491 } else if (nfsi->fileid != fattr->fileid) { 1492 /* Is this perhaps the mounted-on fileid? */ 1493 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) && 1494 nfsi->fileid == fattr->mounted_on_fileid) 1495 return 0; 1496 return -ESTALE; 1497 } 1498 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) 1499 return -ESTALE; 1500 1501 1502 if (!nfs_file_has_buffered_writers(nfsi)) { 1503 /* Verify a few of the more important attributes */ 1504 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && !inode_eq_iversion_raw(inode, fattr->change_attr)) 1505 invalid |= NFS_INO_INVALID_CHANGE; 1506 1507 ts = inode->i_mtime; 1508 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec64_equal(&ts, &fattr->mtime)) 1509 invalid |= NFS_INO_INVALID_MTIME; 1510 1511 ts = inode->i_ctime; 1512 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) && !timespec64_equal(&ts, &fattr->ctime)) 1513 invalid |= NFS_INO_INVALID_CTIME; 1514 1515 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 1516 cur_size = i_size_read(inode); 1517 new_isize = nfs_size_to_loff_t(fattr->size); 1518 if (cur_size != new_isize) 1519 invalid |= NFS_INO_INVALID_SIZE; 1520 } 1521 } 1522 1523 /* Have any file permissions changed? */ 1524 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) 1525 invalid |= NFS_INO_INVALID_MODE; 1526 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid)) 1527 invalid |= NFS_INO_INVALID_OTHER; 1528 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid)) 1529 invalid |= NFS_INO_INVALID_OTHER; 1530 1531 /* Has the link count changed? */ 1532 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink) 1533 invalid |= NFS_INO_INVALID_NLINK; 1534 1535 ts = inode->i_atime; 1536 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec64_equal(&ts, &fattr->atime)) 1537 invalid |= NFS_INO_INVALID_ATIME; 1538 1539 if (invalid != 0) 1540 nfs_set_cache_invalid(inode, invalid); 1541 1542 nfsi->read_cache_jiffies = fattr->time_start; 1543 return 0; 1544 } 1545 1546 static atomic_long_t nfs_attr_generation_counter; 1547 1548 static unsigned long nfs_read_attr_generation_counter(void) 1549 { 1550 return atomic_long_read(&nfs_attr_generation_counter); 1551 } 1552 1553 unsigned long nfs_inc_attr_generation_counter(void) 1554 { 1555 return atomic_long_inc_return(&nfs_attr_generation_counter); 1556 } 1557 EXPORT_SYMBOL_GPL(nfs_inc_attr_generation_counter); 1558 1559 void nfs_fattr_init(struct nfs_fattr *fattr) 1560 { 1561 fattr->valid = 0; 1562 fattr->time_start = jiffies; 1563 fattr->gencount = nfs_inc_attr_generation_counter(); 1564 fattr->owner_name = NULL; 1565 fattr->group_name = NULL; 1566 } 1567 EXPORT_SYMBOL_GPL(nfs_fattr_init); 1568 1569 /** 1570 * nfs_fattr_set_barrier 1571 * @fattr: attributes 1572 * 1573 * Used to set a barrier after an attribute was updated. This 1574 * barrier ensures that older attributes from RPC calls that may 1575 * have raced with our update cannot clobber these new values. 1576 * Note that you are still responsible for ensuring that other 1577 * operations which change the attribute on the server do not 1578 * collide. 1579 */ 1580 void nfs_fattr_set_barrier(struct nfs_fattr *fattr) 1581 { 1582 fattr->gencount = nfs_inc_attr_generation_counter(); 1583 } 1584 1585 struct nfs_fattr *nfs_alloc_fattr(void) 1586 { 1587 struct nfs_fattr *fattr; 1588 1589 fattr = kmalloc(sizeof(*fattr), GFP_NOFS); 1590 if (fattr != NULL) { 1591 nfs_fattr_init(fattr); 1592 fattr->label = NULL; 1593 } 1594 return fattr; 1595 } 1596 EXPORT_SYMBOL_GPL(nfs_alloc_fattr); 1597 1598 struct nfs_fattr *nfs_alloc_fattr_with_label(struct nfs_server *server) 1599 { 1600 struct nfs_fattr *fattr = nfs_alloc_fattr(); 1601 1602 if (!fattr) 1603 return NULL; 1604 1605 fattr->label = nfs4_label_alloc(server, GFP_NOFS); 1606 if (IS_ERR(fattr->label)) { 1607 kfree(fattr); 1608 return NULL; 1609 } 1610 1611 return fattr; 1612 } 1613 EXPORT_SYMBOL_GPL(nfs_alloc_fattr_with_label); 1614 1615 struct nfs_fh *nfs_alloc_fhandle(void) 1616 { 1617 struct nfs_fh *fh; 1618 1619 fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS); 1620 if (fh != NULL) 1621 fh->size = 0; 1622 return fh; 1623 } 1624 EXPORT_SYMBOL_GPL(nfs_alloc_fhandle); 1625 1626 #ifdef NFS_DEBUG 1627 /* 1628 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle 1629 * in the same way that wireshark does 1630 * 1631 * @fh: file handle 1632 * 1633 * For debugging only. 1634 */ 1635 u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh) 1636 { 1637 /* wireshark uses 32-bit AUTODIN crc and does a bitwise 1638 * not on the result */ 1639 return nfs_fhandle_hash(fh); 1640 } 1641 EXPORT_SYMBOL_GPL(_nfs_display_fhandle_hash); 1642 1643 /* 1644 * _nfs_display_fhandle - display an NFS file handle on the console 1645 * 1646 * @fh: file handle to display 1647 * @caption: display caption 1648 * 1649 * For debugging only. 1650 */ 1651 void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption) 1652 { 1653 unsigned short i; 1654 1655 if (fh == NULL || fh->size == 0) { 1656 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh); 1657 return; 1658 } 1659 1660 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n", 1661 caption, fh, fh->size, _nfs_display_fhandle_hash(fh)); 1662 for (i = 0; i < fh->size; i += 16) { 1663 __be32 *pos = (__be32 *)&fh->data[i]; 1664 1665 switch ((fh->size - i - 1) >> 2) { 1666 case 0: 1667 printk(KERN_DEFAULT " %08x\n", 1668 be32_to_cpup(pos)); 1669 break; 1670 case 1: 1671 printk(KERN_DEFAULT " %08x %08x\n", 1672 be32_to_cpup(pos), be32_to_cpup(pos + 1)); 1673 break; 1674 case 2: 1675 printk(KERN_DEFAULT " %08x %08x %08x\n", 1676 be32_to_cpup(pos), be32_to_cpup(pos + 1), 1677 be32_to_cpup(pos + 2)); 1678 break; 1679 default: 1680 printk(KERN_DEFAULT " %08x %08x %08x %08x\n", 1681 be32_to_cpup(pos), be32_to_cpup(pos + 1), 1682 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3)); 1683 } 1684 } 1685 } 1686 EXPORT_SYMBOL_GPL(_nfs_display_fhandle); 1687 #endif 1688 1689 /** 1690 * nfs_inode_attrs_cmp_generic - compare attributes 1691 * @fattr: attributes 1692 * @inode: pointer to inode 1693 * 1694 * Attempt to divine whether or not an RPC call reply carrying stale 1695 * attributes got scheduled after another call carrying updated ones. 1696 * Note also the check for wraparound of 'attr_gencount' 1697 * 1698 * The function returns '1' if it thinks the attributes in @fattr are 1699 * more recent than the ones cached in @inode. Otherwise it returns 1700 * the value '0'. 1701 */ 1702 static int nfs_inode_attrs_cmp_generic(const struct nfs_fattr *fattr, 1703 const struct inode *inode) 1704 { 1705 unsigned long attr_gencount = NFS_I(inode)->attr_gencount; 1706 1707 return (long)(fattr->gencount - attr_gencount) > 0 || 1708 (long)(attr_gencount - nfs_read_attr_generation_counter()) > 0; 1709 } 1710 1711 /** 1712 * nfs_inode_attrs_cmp_monotonic - compare attributes 1713 * @fattr: attributes 1714 * @inode: pointer to inode 1715 * 1716 * Attempt to divine whether or not an RPC call reply carrying stale 1717 * attributes got scheduled after another call carrying updated ones. 1718 * 1719 * We assume that the server observes monotonic semantics for 1720 * the change attribute, so a larger value means that the attributes in 1721 * @fattr are more recent, in which case the function returns the 1722 * value '1'. 1723 * A return value of '0' indicates no measurable change 1724 * A return value of '-1' means that the attributes in @inode are 1725 * more recent. 1726 */ 1727 static int nfs_inode_attrs_cmp_monotonic(const struct nfs_fattr *fattr, 1728 const struct inode *inode) 1729 { 1730 s64 diff = fattr->change_attr - inode_peek_iversion_raw(inode); 1731 if (diff > 0) 1732 return 1; 1733 return diff == 0 ? 0 : -1; 1734 } 1735 1736 /** 1737 * nfs_inode_attrs_cmp_strict_monotonic - compare attributes 1738 * @fattr: attributes 1739 * @inode: pointer to inode 1740 * 1741 * Attempt to divine whether or not an RPC call reply carrying stale 1742 * attributes got scheduled after another call carrying updated ones. 1743 * 1744 * We assume that the server observes strictly monotonic semantics for 1745 * the change attribute, so a larger value means that the attributes in 1746 * @fattr are more recent, in which case the function returns the 1747 * value '1'. 1748 * A return value of '-1' means that the attributes in @inode are 1749 * more recent or unchanged. 1750 */ 1751 static int nfs_inode_attrs_cmp_strict_monotonic(const struct nfs_fattr *fattr, 1752 const struct inode *inode) 1753 { 1754 return nfs_inode_attrs_cmp_monotonic(fattr, inode) > 0 ? 1 : -1; 1755 } 1756 1757 /** 1758 * nfs_inode_attrs_cmp - compare attributes 1759 * @fattr: attributes 1760 * @inode: pointer to inode 1761 * 1762 * This function returns '1' if it thinks the attributes in @fattr are 1763 * more recent than the ones cached in @inode. It returns '-1' if 1764 * the attributes in @inode are more recent than the ones in @fattr, 1765 * and it returns 0 if not sure. 1766 */ 1767 static int nfs_inode_attrs_cmp(const struct nfs_fattr *fattr, 1768 const struct inode *inode) 1769 { 1770 if (nfs_inode_attrs_cmp_generic(fattr, inode) > 0) 1771 return 1; 1772 switch (NFS_SERVER(inode)->change_attr_type) { 1773 case NFS4_CHANGE_TYPE_IS_UNDEFINED: 1774 break; 1775 case NFS4_CHANGE_TYPE_IS_TIME_METADATA: 1776 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE)) 1777 break; 1778 return nfs_inode_attrs_cmp_monotonic(fattr, inode); 1779 default: 1780 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE)) 1781 break; 1782 return nfs_inode_attrs_cmp_strict_monotonic(fattr, inode); 1783 } 1784 return 0; 1785 } 1786 1787 /** 1788 * nfs_inode_finish_partial_attr_update - complete a previous inode update 1789 * @fattr: attributes 1790 * @inode: pointer to inode 1791 * 1792 * Returns '1' if the last attribute update left the inode cached 1793 * attributes in a partially unrevalidated state, and @fattr 1794 * matches the change attribute of that partial update. 1795 * Otherwise returns '0'. 1796 */ 1797 static int nfs_inode_finish_partial_attr_update(const struct nfs_fattr *fattr, 1798 const struct inode *inode) 1799 { 1800 const unsigned long check_valid = 1801 NFS_INO_INVALID_ATIME | NFS_INO_INVALID_CTIME | 1802 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE | 1803 NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_OTHER | 1804 NFS_INO_INVALID_NLINK; 1805 unsigned long cache_validity = NFS_I(inode)->cache_validity; 1806 enum nfs4_change_attr_type ctype = NFS_SERVER(inode)->change_attr_type; 1807 1808 if (ctype != NFS4_CHANGE_TYPE_IS_UNDEFINED && 1809 !(cache_validity & NFS_INO_INVALID_CHANGE) && 1810 (cache_validity & check_valid) != 0 && 1811 (fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 1812 nfs_inode_attrs_cmp_monotonic(fattr, inode) == 0) 1813 return 1; 1814 return 0; 1815 } 1816 1817 static int nfs_refresh_inode_locked(struct inode *inode, 1818 struct nfs_fattr *fattr) 1819 { 1820 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode); 1821 int ret = 0; 1822 1823 trace_nfs_refresh_inode_enter(inode); 1824 1825 if (attr_cmp > 0 || nfs_inode_finish_partial_attr_update(fattr, inode)) 1826 ret = nfs_update_inode(inode, fattr); 1827 else if (attr_cmp == 0) 1828 ret = nfs_check_inode_attributes(inode, fattr); 1829 1830 trace_nfs_refresh_inode_exit(inode, ret); 1831 return ret; 1832 } 1833 1834 /** 1835 * nfs_refresh_inode - try to update the inode attribute cache 1836 * @inode: pointer to inode 1837 * @fattr: updated attributes 1838 * 1839 * Check that an RPC call that returned attributes has not overlapped with 1840 * other recent updates of the inode metadata, then decide whether it is 1841 * safe to do a full update of the inode attributes, or whether just to 1842 * call nfs_check_inode_attributes. 1843 */ 1844 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr) 1845 { 1846 int status; 1847 1848 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 1849 return 0; 1850 spin_lock(&inode->i_lock); 1851 status = nfs_refresh_inode_locked(inode, fattr); 1852 spin_unlock(&inode->i_lock); 1853 1854 return status; 1855 } 1856 EXPORT_SYMBOL_GPL(nfs_refresh_inode); 1857 1858 static int nfs_post_op_update_inode_locked(struct inode *inode, 1859 struct nfs_fattr *fattr, unsigned int invalid) 1860 { 1861 if (S_ISDIR(inode->i_mode)) 1862 invalid |= NFS_INO_INVALID_DATA; 1863 nfs_set_cache_invalid(inode, invalid); 1864 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 1865 return 0; 1866 return nfs_refresh_inode_locked(inode, fattr); 1867 } 1868 1869 /** 1870 * nfs_post_op_update_inode - try to update the inode attribute cache 1871 * @inode: pointer to inode 1872 * @fattr: updated attributes 1873 * 1874 * After an operation that has changed the inode metadata, mark the 1875 * attribute cache as being invalid, then try to update it. 1876 * 1877 * NB: if the server didn't return any post op attributes, this 1878 * function will force the retrieval of attributes before the next 1879 * NFS request. Thus it should be used only for operations that 1880 * are expected to change one or more attributes, to avoid 1881 * unnecessary NFS requests and trips through nfs_update_inode(). 1882 */ 1883 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1884 { 1885 int status; 1886 1887 spin_lock(&inode->i_lock); 1888 nfs_fattr_set_barrier(fattr); 1889 status = nfs_post_op_update_inode_locked(inode, fattr, 1890 NFS_INO_INVALID_CHANGE 1891 | NFS_INO_INVALID_CTIME 1892 | NFS_INO_REVAL_FORCED); 1893 spin_unlock(&inode->i_lock); 1894 1895 return status; 1896 } 1897 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode); 1898 1899 /** 1900 * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache 1901 * @inode: pointer to inode 1902 * @fattr: updated attributes 1903 * 1904 * After an operation that has changed the inode metadata, mark the 1905 * attribute cache as being invalid, then try to update it. Fake up 1906 * weak cache consistency data, if none exist. 1907 * 1908 * This function is mainly designed to be used by the ->write_done() functions. 1909 */ 1910 int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr) 1911 { 1912 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode); 1913 int status; 1914 1915 /* Don't do a WCC update if these attributes are already stale */ 1916 if (attr_cmp < 0) 1917 return 0; 1918 if ((fattr->valid & NFS_ATTR_FATTR) == 0 || !attr_cmp) { 1919 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE 1920 | NFS_ATTR_FATTR_PRESIZE 1921 | NFS_ATTR_FATTR_PREMTIME 1922 | NFS_ATTR_FATTR_PRECTIME); 1923 goto out_noforce; 1924 } 1925 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 1926 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) { 1927 fattr->pre_change_attr = inode_peek_iversion_raw(inode); 1928 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE; 1929 } 1930 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 && 1931 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) { 1932 fattr->pre_ctime = inode->i_ctime; 1933 fattr->valid |= NFS_ATTR_FATTR_PRECTIME; 1934 } 1935 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 && 1936 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) { 1937 fattr->pre_mtime = inode->i_mtime; 1938 fattr->valid |= NFS_ATTR_FATTR_PREMTIME; 1939 } 1940 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 && 1941 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) { 1942 fattr->pre_size = i_size_read(inode); 1943 fattr->valid |= NFS_ATTR_FATTR_PRESIZE; 1944 } 1945 out_noforce: 1946 status = nfs_post_op_update_inode_locked(inode, fattr, 1947 NFS_INO_INVALID_CHANGE 1948 | NFS_INO_INVALID_CTIME 1949 | NFS_INO_INVALID_MTIME 1950 | NFS_INO_INVALID_BLOCKS); 1951 return status; 1952 } 1953 1954 /** 1955 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache 1956 * @inode: pointer to inode 1957 * @fattr: updated attributes 1958 * 1959 * After an operation that has changed the inode metadata, mark the 1960 * attribute cache as being invalid, then try to update it. Fake up 1961 * weak cache consistency data, if none exist. 1962 * 1963 * This function is mainly designed to be used by the ->write_done() functions. 1964 */ 1965 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr) 1966 { 1967 int status; 1968 1969 spin_lock(&inode->i_lock); 1970 nfs_fattr_set_barrier(fattr); 1971 status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr); 1972 spin_unlock(&inode->i_lock); 1973 return status; 1974 } 1975 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc); 1976 1977 1978 /* 1979 * Many nfs protocol calls return the new file attributes after 1980 * an operation. Here we update the inode to reflect the state 1981 * of the server's inode. 1982 * 1983 * This is a bit tricky because we have to make sure all dirty pages 1984 * have been sent off to the server before calling invalidate_inode_pages. 1985 * To make sure no other process adds more write requests while we try 1986 * our best to flush them, we make them sleep during the attribute refresh. 1987 * 1988 * A very similar scenario holds for the dir cache. 1989 */ 1990 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1991 { 1992 struct nfs_server *server = NFS_SERVER(inode); 1993 struct nfs_inode *nfsi = NFS_I(inode); 1994 loff_t cur_isize, new_isize; 1995 u64 fattr_supported = server->fattr_valid; 1996 unsigned long invalid = 0; 1997 unsigned long now = jiffies; 1998 unsigned long save_cache_validity; 1999 bool have_writers = nfs_file_has_buffered_writers(nfsi); 2000 bool cache_revalidated = true; 2001 bool attr_changed = false; 2002 bool have_delegation; 2003 2004 dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%x)\n", 2005 __func__, inode->i_sb->s_id, inode->i_ino, 2006 nfs_display_fhandle_hash(NFS_FH(inode)), 2007 atomic_read(&inode->i_count), fattr->valid); 2008 2009 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) { 2010 /* Only a mounted-on-fileid? Just exit */ 2011 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) 2012 return 0; 2013 /* Has the inode gone and changed behind our back? */ 2014 } else if (nfsi->fileid != fattr->fileid) { 2015 /* Is this perhaps the mounted-on fileid? */ 2016 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) && 2017 nfsi->fileid == fattr->mounted_on_fileid) 2018 return 0; 2019 printk(KERN_ERR "NFS: server %s error: fileid changed\n" 2020 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n", 2021 NFS_SERVER(inode)->nfs_client->cl_hostname, 2022 inode->i_sb->s_id, (long long)nfsi->fileid, 2023 (long long)fattr->fileid); 2024 goto out_err; 2025 } 2026 2027 /* 2028 * Make sure the inode's type hasn't changed. 2029 */ 2030 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) { 2031 /* 2032 * Big trouble! The inode has become a different object. 2033 */ 2034 printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n", 2035 __func__, inode->i_ino, inode->i_mode, fattr->mode); 2036 goto out_err; 2037 } 2038 2039 /* Update the fsid? */ 2040 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) && 2041 !nfs_fsid_equal(&server->fsid, &fattr->fsid) && 2042 !IS_AUTOMOUNT(inode)) 2043 server->fsid = fattr->fsid; 2044 2045 /* Save the delegation state before clearing cache_validity */ 2046 have_delegation = nfs_have_delegated_attributes(inode); 2047 2048 /* 2049 * Update the read time so we don't revalidate too often. 2050 */ 2051 nfsi->read_cache_jiffies = fattr->time_start; 2052 2053 save_cache_validity = nfsi->cache_validity; 2054 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR 2055 | NFS_INO_INVALID_ATIME 2056 | NFS_INO_REVAL_FORCED 2057 | NFS_INO_INVALID_BLOCKS); 2058 2059 /* Do atomic weak cache consistency updates */ 2060 nfs_wcc_update_inode(inode, fattr); 2061 2062 if (pnfs_layoutcommit_outstanding(inode)) { 2063 nfsi->cache_validity |= 2064 save_cache_validity & 2065 (NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME | 2066 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE | 2067 NFS_INO_INVALID_BLOCKS); 2068 cache_revalidated = false; 2069 } 2070 2071 /* More cache consistency checks */ 2072 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) { 2073 if (!inode_eq_iversion_raw(inode, fattr->change_attr)) { 2074 /* Could it be a race with writeback? */ 2075 if (!(have_writers || have_delegation)) { 2076 invalid |= NFS_INO_INVALID_DATA 2077 | NFS_INO_INVALID_ACCESS 2078 | NFS_INO_INVALID_ACL 2079 | NFS_INO_INVALID_XATTR; 2080 /* Force revalidate of all attributes */ 2081 save_cache_validity |= NFS_INO_INVALID_CTIME 2082 | NFS_INO_INVALID_MTIME 2083 | NFS_INO_INVALID_SIZE 2084 | NFS_INO_INVALID_BLOCKS 2085 | NFS_INO_INVALID_NLINK 2086 | NFS_INO_INVALID_MODE 2087 | NFS_INO_INVALID_OTHER; 2088 if (S_ISDIR(inode->i_mode)) 2089 nfs_force_lookup_revalidate(inode); 2090 attr_changed = true; 2091 dprintk("NFS: change_attr change on server for file %s/%ld\n", 2092 inode->i_sb->s_id, 2093 inode->i_ino); 2094 } else if (!have_delegation) 2095 nfsi->cache_validity |= NFS_INO_DATA_INVAL_DEFER; 2096 inode_set_iversion_raw(inode, fattr->change_attr); 2097 } 2098 } else { 2099 nfsi->cache_validity |= 2100 save_cache_validity & NFS_INO_INVALID_CHANGE; 2101 if (!have_delegation || 2102 (nfsi->cache_validity & NFS_INO_INVALID_CHANGE) != 0) 2103 cache_revalidated = false; 2104 } 2105 2106 if (fattr->valid & NFS_ATTR_FATTR_MTIME) 2107 inode->i_mtime = fattr->mtime; 2108 else if (fattr_supported & NFS_ATTR_FATTR_MTIME) 2109 nfsi->cache_validity |= 2110 save_cache_validity & NFS_INO_INVALID_MTIME; 2111 2112 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 2113 inode->i_ctime = fattr->ctime; 2114 else if (fattr_supported & NFS_ATTR_FATTR_CTIME) 2115 nfsi->cache_validity |= 2116 save_cache_validity & NFS_INO_INVALID_CTIME; 2117 2118 /* Check if our cached file size is stale */ 2119 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 2120 new_isize = nfs_size_to_loff_t(fattr->size); 2121 cur_isize = i_size_read(inode); 2122 if (new_isize != cur_isize && !have_delegation) { 2123 /* Do we perhaps have any outstanding writes, or has 2124 * the file grown beyond our last write? */ 2125 if (!nfs_have_writebacks(inode) || new_isize > cur_isize) { 2126 trace_nfs_size_update(inode, new_isize); 2127 i_size_write(inode, new_isize); 2128 if (!have_writers) 2129 invalid |= NFS_INO_INVALID_DATA; 2130 } 2131 } 2132 if (new_isize == 0 && 2133 !(fattr->valid & (NFS_ATTR_FATTR_SPACE_USED | 2134 NFS_ATTR_FATTR_BLOCKS_USED))) { 2135 fattr->du.nfs3.used = 0; 2136 fattr->valid |= NFS_ATTR_FATTR_SPACE_USED; 2137 } 2138 } else 2139 nfsi->cache_validity |= 2140 save_cache_validity & NFS_INO_INVALID_SIZE; 2141 2142 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 2143 inode->i_atime = fattr->atime; 2144 else if (fattr_supported & NFS_ATTR_FATTR_ATIME) 2145 nfsi->cache_validity |= 2146 save_cache_validity & NFS_INO_INVALID_ATIME; 2147 2148 if (fattr->valid & NFS_ATTR_FATTR_MODE) { 2149 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) { 2150 umode_t newmode = inode->i_mode & S_IFMT; 2151 newmode |= fattr->mode & S_IALLUGO; 2152 inode->i_mode = newmode; 2153 invalid |= NFS_INO_INVALID_ACCESS 2154 | NFS_INO_INVALID_ACL; 2155 } 2156 } else if (fattr_supported & NFS_ATTR_FATTR_MODE) 2157 nfsi->cache_validity |= 2158 save_cache_validity & NFS_INO_INVALID_MODE; 2159 2160 if (fattr->valid & NFS_ATTR_FATTR_OWNER) { 2161 if (!uid_eq(inode->i_uid, fattr->uid)) { 2162 invalid |= NFS_INO_INVALID_ACCESS 2163 | NFS_INO_INVALID_ACL; 2164 inode->i_uid = fattr->uid; 2165 } 2166 } else if (fattr_supported & NFS_ATTR_FATTR_OWNER) 2167 nfsi->cache_validity |= 2168 save_cache_validity & NFS_INO_INVALID_OTHER; 2169 2170 if (fattr->valid & NFS_ATTR_FATTR_GROUP) { 2171 if (!gid_eq(inode->i_gid, fattr->gid)) { 2172 invalid |= NFS_INO_INVALID_ACCESS 2173 | NFS_INO_INVALID_ACL; 2174 inode->i_gid = fattr->gid; 2175 } 2176 } else if (fattr_supported & NFS_ATTR_FATTR_GROUP) 2177 nfsi->cache_validity |= 2178 save_cache_validity & NFS_INO_INVALID_OTHER; 2179 2180 if (fattr->valid & NFS_ATTR_FATTR_NLINK) { 2181 if (inode->i_nlink != fattr->nlink) 2182 set_nlink(inode, fattr->nlink); 2183 } else if (fattr_supported & NFS_ATTR_FATTR_NLINK) 2184 nfsi->cache_validity |= 2185 save_cache_validity & NFS_INO_INVALID_NLINK; 2186 2187 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { 2188 /* 2189 * report the blocks in 512byte units 2190 */ 2191 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 2192 } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED) 2193 nfsi->cache_validity |= 2194 save_cache_validity & NFS_INO_INVALID_BLOCKS; 2195 2196 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) 2197 inode->i_blocks = fattr->du.nfs2.blocks; 2198 else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED) 2199 nfsi->cache_validity |= 2200 save_cache_validity & NFS_INO_INVALID_BLOCKS; 2201 2202 /* Update attrtimeo value if we're out of the unstable period */ 2203 if (attr_changed) { 2204 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 2205 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 2206 nfsi->attrtimeo_timestamp = now; 2207 /* Set barrier to be more recent than all outstanding updates */ 2208 nfsi->attr_gencount = nfs_inc_attr_generation_counter(); 2209 } else { 2210 if (cache_revalidated) { 2211 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, 2212 nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) { 2213 nfsi->attrtimeo <<= 1; 2214 if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode)) 2215 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode); 2216 } 2217 nfsi->attrtimeo_timestamp = now; 2218 } 2219 /* Set the barrier to be more recent than this fattr */ 2220 if ((long)(fattr->gencount - nfsi->attr_gencount) > 0) 2221 nfsi->attr_gencount = fattr->gencount; 2222 } 2223 2224 /* Don't invalidate the data if we were to blame */ 2225 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) 2226 || S_ISLNK(inode->i_mode))) 2227 invalid &= ~NFS_INO_INVALID_DATA; 2228 nfs_set_cache_invalid(inode, invalid); 2229 2230 return 0; 2231 out_err: 2232 /* 2233 * No need to worry about unhashing the dentry, as the 2234 * lookup validation will know that the inode is bad. 2235 * (But we fall through to invalidate the caches.) 2236 */ 2237 nfs_set_inode_stale_locked(inode); 2238 return -ESTALE; 2239 } 2240 2241 struct inode *nfs_alloc_inode(struct super_block *sb) 2242 { 2243 struct nfs_inode *nfsi; 2244 nfsi = kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL); 2245 if (!nfsi) 2246 return NULL; 2247 nfsi->flags = 0UL; 2248 nfsi->cache_validity = 0UL; 2249 #if IS_ENABLED(CONFIG_NFS_V4) 2250 nfsi->nfs4_acl = NULL; 2251 #endif /* CONFIG_NFS_V4 */ 2252 #ifdef CONFIG_NFS_V4_2 2253 nfsi->xattr_cache = NULL; 2254 #endif 2255 return &nfsi->vfs_inode; 2256 } 2257 EXPORT_SYMBOL_GPL(nfs_alloc_inode); 2258 2259 void nfs_free_inode(struct inode *inode) 2260 { 2261 kmem_cache_free(nfs_inode_cachep, NFS_I(inode)); 2262 } 2263 EXPORT_SYMBOL_GPL(nfs_free_inode); 2264 2265 static inline void nfs4_init_once(struct nfs_inode *nfsi) 2266 { 2267 #if IS_ENABLED(CONFIG_NFS_V4) 2268 INIT_LIST_HEAD(&nfsi->open_states); 2269 nfsi->delegation = NULL; 2270 init_rwsem(&nfsi->rwsem); 2271 nfsi->layout = NULL; 2272 #endif 2273 } 2274 2275 static void init_once(void *foo) 2276 { 2277 struct nfs_inode *nfsi = (struct nfs_inode *) foo; 2278 2279 inode_init_once(&nfsi->vfs_inode); 2280 INIT_LIST_HEAD(&nfsi->open_files); 2281 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru); 2282 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru); 2283 nfs4_init_once(nfsi); 2284 } 2285 2286 static int __init nfs_init_inodecache(void) 2287 { 2288 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", 2289 sizeof(struct nfs_inode), 2290 0, (SLAB_RECLAIM_ACCOUNT| 2291 SLAB_MEM_SPREAD|SLAB_ACCOUNT), 2292 init_once); 2293 if (nfs_inode_cachep == NULL) 2294 return -ENOMEM; 2295 2296 return 0; 2297 } 2298 2299 static void nfs_destroy_inodecache(void) 2300 { 2301 /* 2302 * Make sure all delayed rcu free inodes are flushed before we 2303 * destroy cache. 2304 */ 2305 rcu_barrier(); 2306 kmem_cache_destroy(nfs_inode_cachep); 2307 } 2308 2309 struct workqueue_struct *nfsiod_workqueue; 2310 EXPORT_SYMBOL_GPL(nfsiod_workqueue); 2311 2312 /* 2313 * start up the nfsiod workqueue 2314 */ 2315 static int nfsiod_start(void) 2316 { 2317 struct workqueue_struct *wq; 2318 dprintk("RPC: creating workqueue nfsiod\n"); 2319 wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM | WQ_UNBOUND, 0); 2320 if (wq == NULL) 2321 return -ENOMEM; 2322 nfsiod_workqueue = wq; 2323 return 0; 2324 } 2325 2326 /* 2327 * Destroy the nfsiod workqueue 2328 */ 2329 static void nfsiod_stop(void) 2330 { 2331 struct workqueue_struct *wq; 2332 2333 wq = nfsiod_workqueue; 2334 if (wq == NULL) 2335 return; 2336 nfsiod_workqueue = NULL; 2337 destroy_workqueue(wq); 2338 } 2339 2340 unsigned int nfs_net_id; 2341 EXPORT_SYMBOL_GPL(nfs_net_id); 2342 2343 static int nfs_net_init(struct net *net) 2344 { 2345 nfs_clients_init(net); 2346 return nfs_fs_proc_net_init(net); 2347 } 2348 2349 static void nfs_net_exit(struct net *net) 2350 { 2351 nfs_fs_proc_net_exit(net); 2352 nfs_clients_exit(net); 2353 } 2354 2355 static struct pernet_operations nfs_net_ops = { 2356 .init = nfs_net_init, 2357 .exit = nfs_net_exit, 2358 .id = &nfs_net_id, 2359 .size = sizeof(struct nfs_net), 2360 }; 2361 2362 /* 2363 * Initialize NFS 2364 */ 2365 static int __init init_nfs_fs(void) 2366 { 2367 int err; 2368 2369 err = nfs_sysfs_init(); 2370 if (err < 0) 2371 goto out10; 2372 2373 err = register_pernet_subsys(&nfs_net_ops); 2374 if (err < 0) 2375 goto out9; 2376 2377 err = nfsiod_start(); 2378 if (err) 2379 goto out7; 2380 2381 err = nfs_fs_proc_init(); 2382 if (err) 2383 goto out6; 2384 2385 err = nfs_init_nfspagecache(); 2386 if (err) 2387 goto out5; 2388 2389 err = nfs_init_inodecache(); 2390 if (err) 2391 goto out4; 2392 2393 err = nfs_init_readpagecache(); 2394 if (err) 2395 goto out3; 2396 2397 err = nfs_init_writepagecache(); 2398 if (err) 2399 goto out2; 2400 2401 err = nfs_init_directcache(); 2402 if (err) 2403 goto out1; 2404 2405 rpc_proc_register(&init_net, &nfs_rpcstat); 2406 2407 err = register_nfs_fs(); 2408 if (err) 2409 goto out0; 2410 2411 return 0; 2412 out0: 2413 rpc_proc_unregister(&init_net, "nfs"); 2414 nfs_destroy_directcache(); 2415 out1: 2416 nfs_destroy_writepagecache(); 2417 out2: 2418 nfs_destroy_readpagecache(); 2419 out3: 2420 nfs_destroy_inodecache(); 2421 out4: 2422 nfs_destroy_nfspagecache(); 2423 out5: 2424 nfs_fs_proc_exit(); 2425 out6: 2426 nfsiod_stop(); 2427 out7: 2428 unregister_pernet_subsys(&nfs_net_ops); 2429 out9: 2430 nfs_sysfs_exit(); 2431 out10: 2432 return err; 2433 } 2434 2435 static void __exit exit_nfs_fs(void) 2436 { 2437 nfs_destroy_directcache(); 2438 nfs_destroy_writepagecache(); 2439 nfs_destroy_readpagecache(); 2440 nfs_destroy_inodecache(); 2441 nfs_destroy_nfspagecache(); 2442 unregister_pernet_subsys(&nfs_net_ops); 2443 rpc_proc_unregister(&init_net, "nfs"); 2444 unregister_nfs_fs(); 2445 nfs_fs_proc_exit(); 2446 nfsiod_stop(); 2447 nfs_sysfs_exit(); 2448 } 2449 2450 /* Not quite true; I just maintain it */ 2451 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 2452 MODULE_LICENSE("GPL"); 2453 module_param(enable_ino64, bool, 0644); 2454 2455 module_init(init_nfs_fs) 2456 module_exit(exit_nfs_fs) 2457