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 int nfs_wait_bit_killable(struct wait_bit_key *key, int mode) 76 { 77 if (unlikely(nfs_current_task_exiting())) 78 return -EINTR; 79 schedule(); 80 if (signal_pending_state(mode, current)) 81 return -ERESTARTSYS; 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) || inode_generic_drop(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_clear_inode(inode); 125 } 126 EXPORT_SYMBOL_GPL(nfs_clear_inode); 127 128 void nfs_evict_inode(struct inode *inode) 129 { 130 truncate_inode_pages_final(&inode->i_data); 131 clear_inode(inode); 132 nfs_clear_inode(inode); 133 } 134 135 int nfs_sync_inode(struct inode *inode) 136 { 137 inode_dio_wait(inode); 138 return nfs_wb_all(inode); 139 } 140 EXPORT_SYMBOL_GPL(nfs_sync_inode); 141 142 /** 143 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk 144 * @mapping: pointer to struct address_space 145 */ 146 int nfs_sync_mapping(struct address_space *mapping) 147 { 148 int ret = 0; 149 150 if (mapping->nrpages != 0) { 151 unmap_mapping_range(mapping, 0, 0, 0); 152 ret = nfs_wb_all(mapping->host); 153 } 154 return ret; 155 } 156 157 static int nfs_attribute_timeout(struct inode *inode) 158 { 159 struct nfs_inode *nfsi = NFS_I(inode); 160 161 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo); 162 } 163 164 static bool nfs_check_cache_flags_invalid(struct inode *inode, 165 unsigned long flags) 166 { 167 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity); 168 169 return (cache_validity & flags) != 0; 170 } 171 172 bool nfs_check_cache_invalid(struct inode *inode, unsigned long flags) 173 { 174 if (nfs_check_cache_flags_invalid(inode, flags)) 175 return true; 176 return nfs_attribute_cache_expired(inode); 177 } 178 EXPORT_SYMBOL_GPL(nfs_check_cache_invalid); 179 180 #ifdef CONFIG_NFS_V4_2 181 static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi) 182 { 183 return nfsi->xattr_cache != NULL; 184 } 185 #else 186 static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi) 187 { 188 return false; 189 } 190 #endif 191 192 void nfs_set_cache_invalid(struct inode *inode, unsigned long flags) 193 { 194 struct nfs_inode *nfsi = NFS_I(inode); 195 196 if (nfs_have_delegated_attributes(inode)) { 197 if (!(flags & NFS_INO_REVAL_FORCED)) 198 flags &= ~(NFS_INO_INVALID_MODE | 199 NFS_INO_INVALID_OTHER | 200 NFS_INO_INVALID_BTIME | 201 NFS_INO_INVALID_XATTR); 202 flags &= ~(NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE); 203 } 204 205 if (!nfs_has_xattr_cache(nfsi)) 206 flags &= ~NFS_INO_INVALID_XATTR; 207 if (flags & NFS_INO_INVALID_DATA) 208 nfs_fscache_invalidate(inode, 0); 209 flags &= ~NFS_INO_REVAL_FORCED; 210 211 flags |= nfsi->cache_validity; 212 if (inode->i_mapping->nrpages == 0) 213 flags &= ~NFS_INO_INVALID_DATA; 214 215 /* pairs with nfs_clear_invalid_mapping()'s smp_load_acquire() */ 216 smp_store_release(&nfsi->cache_validity, flags); 217 218 if (inode->i_mapping->nrpages == 0 || 219 nfsi->cache_validity & NFS_INO_INVALID_DATA) { 220 nfs_ooo_clear(nfsi); 221 } 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 else 246 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR | 247 NFS_INO_INVALID_ACCESS | 248 NFS_INO_INVALID_ACL | 249 NFS_INO_INVALID_XATTR); 250 nfs_zap_label_cache_locked(nfsi); 251 } 252 253 void nfs_zap_caches(struct inode *inode) 254 { 255 spin_lock(&inode->i_lock); 256 nfs_zap_caches_locked(inode); 257 spin_unlock(&inode->i_lock); 258 } 259 260 void nfs_zap_mapping(struct inode *inode, struct address_space *mapping) 261 { 262 if (mapping->nrpages != 0) { 263 spin_lock(&inode->i_lock); 264 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA); 265 spin_unlock(&inode->i_lock); 266 } 267 } 268 269 void nfs_zap_acl_cache(struct inode *inode) 270 { 271 void (*clear_acl_cache)(struct inode *); 272 273 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache; 274 if (clear_acl_cache != NULL) 275 clear_acl_cache(inode); 276 spin_lock(&inode->i_lock); 277 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL; 278 spin_unlock(&inode->i_lock); 279 } 280 EXPORT_SYMBOL_GPL(nfs_zap_acl_cache); 281 282 void nfs_invalidate_atime(struct inode *inode) 283 { 284 if (nfs_have_delegated_atime(inode)) 285 return; 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 = 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 = 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 atomic_long_set(&nfsi->redirtied_pages, 0); 433 INIT_LIST_HEAD(&nfsi->commit_info.list); 434 atomic_long_set(&nfsi->commit_info.ncommit, 0); 435 atomic_set(&nfsi->commit_info.rpcs_out, 0); 436 mutex_init(&nfsi->commit_mutex); 437 } 438 439 static void nfs_inode_init_dir(struct nfs_inode *nfsi) 440 { 441 nfsi->cache_change_attribute = 0; 442 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf)); 443 init_rwsem(&nfsi->rmdir_sem); 444 } 445 446 /* 447 * This is our front-end to iget that looks up inodes by file handle 448 * instead of inode number. 449 */ 450 struct inode * 451 nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr) 452 { 453 struct nfs_find_desc desc = { 454 .fh = fh, 455 .fattr = fattr 456 }; 457 struct inode *inode = ERR_PTR(-ENOENT); 458 u64 fattr_supported = NFS_SB(sb)->fattr_valid; 459 unsigned long hash; 460 461 nfs_attr_check_mountpoint(sb, fattr); 462 463 if (nfs_attr_use_mounted_on_fileid(fattr)) 464 fattr->fileid = fattr->mounted_on_fileid; 465 else if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0) 466 goto out_no_inode; 467 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0) 468 goto out_no_inode; 469 470 hash = nfs_fattr_to_ino_t(fattr); 471 472 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc); 473 if (inode == NULL) { 474 inode = ERR_PTR(-ENOMEM); 475 goto out_no_inode; 476 } 477 478 if (inode_state_read_once(inode) & I_NEW) { 479 struct nfs_inode *nfsi = NFS_I(inode); 480 unsigned long now = jiffies; 481 482 /* We set i_ino for the few things that still rely on it, 483 * such as stat(2) */ 484 inode->i_ino = hash; 485 486 /* We can't support update_atime(), since the server will reset it */ 487 inode->i_flags |= S_NOATIME|S_NOCMTIME; 488 inode->i_mode = fattr->mode; 489 nfsi->cache_validity = 0; 490 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0 491 && (fattr_supported & NFS_ATTR_FATTR_MODE)) 492 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MODE); 493 /* Why so? Because we want revalidate for devices/FIFOs, and 494 * that's precisely what we have in nfs_file_inode_operations. 495 */ 496 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops; 497 if (S_ISREG(inode->i_mode)) { 498 inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops; 499 inode->i_data.a_ops = &nfs_file_aops; 500 nfs_inode_init_regular(nfsi); 501 mapping_set_large_folios(inode->i_mapping); 502 } else if (S_ISDIR(inode->i_mode)) { 503 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops; 504 inode->i_fop = &nfs_dir_operations; 505 inode->i_data.a_ops = &nfs_dir_aops; 506 nfs_inode_init_dir(nfsi); 507 /* Deal with crossing mountpoints */ 508 if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT || 509 fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) { 510 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) 511 inode->i_op = &nfs_referral_inode_operations; 512 else 513 inode->i_op = &nfs_mountpoint_inode_operations; 514 inode->i_fop = NULL; 515 inode->i_flags |= S_AUTOMOUNT; 516 } 517 } else if (S_ISLNK(inode->i_mode)) { 518 inode->i_op = &nfs_symlink_inode_operations; 519 inode_nohighmem(inode); 520 } else 521 init_special_inode(inode, inode->i_mode, fattr->rdev); 522 523 inode_set_atime(inode, 0, 0); 524 inode_set_mtime(inode, 0, 0); 525 inode_set_ctime(inode, 0, 0); 526 memset(&nfsi->btime, 0, sizeof(nfsi->btime)); 527 inode_set_iversion_raw(inode, 0); 528 inode->i_size = 0; 529 clear_nlink(inode); 530 inode->i_uid = make_kuid(&init_user_ns, -2); 531 inode->i_gid = make_kgid(&init_user_ns, -2); 532 inode->i_blocks = 0; 533 nfsi->write_io = 0; 534 nfsi->read_io = 0; 535 536 nfsi->read_cache_jiffies = fattr->time_start; 537 nfsi->attr_gencount = fattr->gencount; 538 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 539 inode_set_atime_to_ts(inode, fattr->atime); 540 else if (fattr_supported & NFS_ATTR_FATTR_ATIME) 541 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME); 542 if (fattr->valid & NFS_ATTR_FATTR_MTIME) 543 inode_set_mtime_to_ts(inode, fattr->mtime); 544 else if (fattr_supported & NFS_ATTR_FATTR_MTIME) 545 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME); 546 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 547 inode_set_ctime_to_ts(inode, fattr->ctime); 548 else if (fattr_supported & NFS_ATTR_FATTR_CTIME) 549 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CTIME); 550 if (fattr->valid & NFS_ATTR_FATTR_BTIME) 551 nfsi->btime = fattr->btime; 552 else if (fattr_supported & NFS_ATTR_FATTR_BTIME) 553 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BTIME); 554 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) 555 inode_set_iversion_raw(inode, fattr->change_attr); 556 else 557 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE); 558 if (fattr->valid & NFS_ATTR_FATTR_SIZE) 559 inode->i_size = nfs_size_to_loff_t(fattr->size); 560 else 561 nfs_set_cache_invalid(inode, NFS_INO_INVALID_SIZE); 562 if (fattr->valid & NFS_ATTR_FATTR_NLINK) 563 set_nlink(inode, fattr->nlink); 564 else if (fattr_supported & NFS_ATTR_FATTR_NLINK) 565 nfs_set_cache_invalid(inode, NFS_INO_INVALID_NLINK); 566 else 567 set_nlink(inode, 1); 568 if (fattr->valid & NFS_ATTR_FATTR_OWNER) 569 inode->i_uid = fattr->uid; 570 else if (fattr_supported & NFS_ATTR_FATTR_OWNER) 571 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER); 572 if (fattr->valid & NFS_ATTR_FATTR_GROUP) 573 inode->i_gid = fattr->gid; 574 else if (fattr_supported & NFS_ATTR_FATTR_GROUP) 575 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER); 576 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) 577 inode->i_blocks = fattr->du.nfs2.blocks; 578 else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED && 579 fattr->size != 0) 580 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS); 581 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { 582 /* 583 * report the blocks in 512byte units 584 */ 585 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 586 } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED && 587 fattr->size != 0) 588 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS); 589 590 nfs_setsecurity(inode, fattr); 591 592 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 593 nfsi->attrtimeo_timestamp = now; 594 nfsi->access_cache = RB_ROOT; 595 596 nfs_fscache_init_inode(inode); 597 598 unlock_new_inode(inode); 599 } else { 600 int err = nfs_refresh_inode(inode, fattr); 601 if (err < 0) { 602 iput(inode); 603 inode = ERR_PTR(err); 604 goto out_no_inode; 605 } 606 } 607 dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n", 608 inode->i_sb->s_id, 609 (unsigned long long)NFS_FILEID(inode), 610 nfs_display_fhandle_hash(fh), 611 icount_read(inode)); 612 613 out: 614 return inode; 615 616 out_no_inode: 617 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode)); 618 goto out; 619 } 620 EXPORT_SYMBOL_GPL(nfs_fhget); 621 622 static void 623 nfs_fattr_fixup_delegated(struct inode *inode, struct nfs_fattr *fattr) 624 { 625 unsigned long cache_validity = NFS_I(inode)->cache_validity; 626 627 if (nfs_have_delegated_mtime(inode)) { 628 if (!(cache_validity & NFS_INO_INVALID_CTIME)) 629 fattr->valid &= ~(NFS_ATTR_FATTR_PRECTIME | 630 NFS_ATTR_FATTR_CTIME); 631 632 if (!(cache_validity & NFS_INO_INVALID_MTIME)) 633 fattr->valid &= ~(NFS_ATTR_FATTR_PREMTIME | 634 NFS_ATTR_FATTR_MTIME); 635 636 if (!(cache_validity & NFS_INO_INVALID_ATIME)) 637 fattr->valid &= ~NFS_ATTR_FATTR_ATIME; 638 } else if (nfs_have_delegated_atime(inode)) { 639 if (!(cache_validity & NFS_INO_INVALID_ATIME)) 640 fattr->valid &= ~NFS_ATTR_FATTR_ATIME; 641 } 642 } 643 644 static void nfs_set_timestamps_to_ts(struct inode *inode, struct iattr *attr) 645 { 646 unsigned int cache_flags = 0; 647 648 if (attr->ia_valid & ATTR_MTIME_SET) { 649 struct timespec64 ctime = inode_get_ctime(inode); 650 struct timespec64 mtime = inode_get_mtime(inode); 651 struct timespec64 now; 652 int updated = 0; 653 654 now = inode_set_ctime_current(inode); 655 if (!timespec64_equal(&now, &ctime)) 656 updated |= S_CTIME; 657 658 inode_set_mtime_to_ts(inode, attr->ia_mtime); 659 if (!timespec64_equal(&now, &mtime)) 660 updated |= S_MTIME; 661 662 inode_maybe_inc_iversion(inode, updated); 663 cache_flags |= NFS_INO_INVALID_CTIME | NFS_INO_INVALID_MTIME; 664 } 665 if (attr->ia_valid & ATTR_ATIME_SET) { 666 inode_set_atime_to_ts(inode, attr->ia_atime); 667 cache_flags |= NFS_INO_INVALID_ATIME; 668 } 669 NFS_I(inode)->cache_validity &= ~cache_flags; 670 } 671 672 static void nfs_update_timestamps(struct inode *inode, unsigned int ia_valid) 673 { 674 enum file_time_flags time_flags = 0; 675 unsigned int cache_flags = 0; 676 677 if (ia_valid & ATTR_MTIME) { 678 time_flags |= S_MTIME | S_CTIME; 679 cache_flags |= NFS_INO_INVALID_CTIME | NFS_INO_INVALID_MTIME; 680 } 681 if (ia_valid & ATTR_ATIME) { 682 time_flags |= S_ATIME; 683 cache_flags |= NFS_INO_INVALID_ATIME; 684 } 685 inode_update_timestamps(inode, time_flags); 686 NFS_I(inode)->cache_validity &= ~cache_flags; 687 } 688 689 void nfs_update_delegated_atime(struct inode *inode) 690 { 691 spin_lock(&inode->i_lock); 692 if (nfs_have_delegated_atime(inode)) 693 nfs_update_timestamps(inode, ATTR_ATIME); 694 spin_unlock(&inode->i_lock); 695 } 696 697 void nfs_update_delegated_mtime_locked(struct inode *inode) 698 { 699 if (nfs_have_delegated_mtime(inode)) 700 nfs_update_timestamps(inode, ATTR_MTIME); 701 } 702 703 void nfs_update_delegated_mtime(struct inode *inode) 704 { 705 spin_lock(&inode->i_lock); 706 nfs_update_delegated_mtime_locked(inode); 707 spin_unlock(&inode->i_lock); 708 } 709 EXPORT_SYMBOL_GPL(nfs_update_delegated_mtime); 710 711 #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) 712 713 int 714 nfs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, 715 struct iattr *attr) 716 { 717 struct inode *inode = d_inode(dentry); 718 struct nfs_fattr *fattr; 719 loff_t oldsize = i_size_read(inode); 720 int error = 0; 721 kuid_t task_uid = current_fsuid(); 722 kuid_t owner_uid = inode->i_uid; 723 724 nfs_inc_stats(inode, NFSIOS_VFSSETATTR); 725 726 /* skip mode change if it's just for clearing setuid/setgid */ 727 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) 728 attr->ia_valid &= ~ATTR_MODE; 729 730 if (attr->ia_valid & ATTR_SIZE) { 731 BUG_ON(!S_ISREG(inode->i_mode)); 732 733 error = inode_newsize_ok(inode, attr->ia_size); 734 if (error) 735 return error; 736 737 if (attr->ia_size == oldsize) 738 attr->ia_valid &= ~ATTR_SIZE; 739 } 740 741 if (nfs_have_delegated_mtime(inode) && attr->ia_valid & ATTR_MTIME) { 742 spin_lock(&inode->i_lock); 743 if (attr->ia_valid & ATTR_MTIME_SET) { 744 if (uid_eq(task_uid, owner_uid)) { 745 nfs_set_timestamps_to_ts(inode, attr); 746 attr->ia_valid &= ~(ATTR_MTIME|ATTR_MTIME_SET| 747 ATTR_ATIME|ATTR_ATIME_SET); 748 } 749 } else { 750 nfs_update_timestamps(inode, attr->ia_valid); 751 attr->ia_valid &= ~(ATTR_MTIME|ATTR_ATIME); 752 } 753 spin_unlock(&inode->i_lock); 754 } else if (nfs_have_delegated_atime(inode) && 755 attr->ia_valid & ATTR_ATIME && 756 !(attr->ia_valid & ATTR_MTIME)) { 757 if (attr->ia_valid & ATTR_ATIME_SET) { 758 if (uid_eq(task_uid, owner_uid)) { 759 spin_lock(&inode->i_lock); 760 nfs_set_timestamps_to_ts(inode, attr); 761 spin_unlock(&inode->i_lock); 762 attr->ia_valid &= ~(ATTR_ATIME|ATTR_ATIME_SET); 763 } 764 } else { 765 nfs_update_delegated_atime(inode); 766 attr->ia_valid &= ~ATTR_ATIME; 767 } 768 } 769 770 /* Optimization: if the end result is no change, don't RPC */ 771 if (((attr->ia_valid & NFS_VALID_ATTRS) & ~(ATTR_FILE|ATTR_OPEN)) == 0) 772 return 0; 773 774 trace_nfs_setattr_enter(inode); 775 776 /* Write all dirty data */ 777 if (S_ISREG(inode->i_mode)) { 778 nfs_file_block_o_direct(NFS_I(inode)); 779 nfs_sync_inode(inode); 780 } 781 782 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode)); 783 if (fattr == NULL) { 784 error = -ENOMEM; 785 goto out; 786 } 787 788 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr); 789 if (error == 0) { 790 if (attr->ia_valid & ATTR_SIZE) 791 nfs_truncate_last_folio(inode->i_mapping, oldsize, 792 attr->ia_size); 793 error = nfs_refresh_inode(inode, fattr); 794 } 795 nfs_free_fattr(fattr); 796 out: 797 trace_nfs_setattr_exit(inode, error); 798 return error; 799 } 800 EXPORT_SYMBOL_GPL(nfs_setattr); 801 802 /** 803 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall 804 * @inode: inode of the file used 805 * @offset: file offset to start truncating 806 * 807 * This is a copy of the common vmtruncate, but with the locking 808 * corrected to take into account the fact that NFS requires 809 * inode->i_size to be updated under the inode->i_lock. 810 * Note: must be called with inode->i_lock held! 811 */ 812 static int nfs_vmtruncate(struct inode * inode, loff_t offset) 813 { 814 int err; 815 816 err = inode_newsize_ok(inode, offset); 817 if (err) 818 goto out; 819 820 trace_nfs_size_truncate(inode, offset); 821 i_size_write(inode, offset); 822 /* Optimisation */ 823 if (offset == 0) { 824 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_DATA; 825 nfs_ooo_clear(NFS_I(inode)); 826 } 827 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE; 828 829 spin_unlock(&inode->i_lock); 830 truncate_pagecache(inode, offset); 831 nfs_update_delegated_mtime_locked(inode); 832 spin_lock(&inode->i_lock); 833 out: 834 return err; 835 } 836 837 /** 838 * nfs_setattr_update_inode - Update inode metadata after a setattr call. 839 * @inode: pointer to struct inode 840 * @attr: pointer to struct iattr 841 * @fattr: pointer to struct nfs_fattr 842 * 843 * Note: we do this in the *proc.c in order to ensure that 844 * it works for things like exclusive creates too. 845 */ 846 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr, 847 struct nfs_fattr *fattr) 848 { 849 /* Barrier: bump the attribute generation count. */ 850 nfs_fattr_set_barrier(fattr); 851 852 spin_lock(&inode->i_lock); 853 NFS_I(inode)->attr_gencount = fattr->gencount; 854 if ((attr->ia_valid & ATTR_SIZE) != 0) { 855 if (!nfs_have_delegated_mtime(inode)) 856 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME); 857 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS); 858 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC); 859 nfs_vmtruncate(inode, attr->ia_size); 860 } 861 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) { 862 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_CTIME; 863 if ((attr->ia_valid & ATTR_KILL_SUID) != 0 && 864 inode->i_mode & S_ISUID) 865 inode->i_mode &= ~S_ISUID; 866 if (setattr_should_drop_sgid(&nop_mnt_idmap, inode)) 867 inode->i_mode &= ~S_ISGID; 868 if ((attr->ia_valid & ATTR_MODE) != 0) { 869 int mode = attr->ia_mode & S_IALLUGO; 870 mode |= inode->i_mode & ~S_IALLUGO; 871 inode->i_mode = mode; 872 } 873 if ((attr->ia_valid & ATTR_UID) != 0) 874 inode->i_uid = attr->ia_uid; 875 if ((attr->ia_valid & ATTR_GID) != 0) 876 inode->i_gid = attr->ia_gid; 877 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 878 inode_set_ctime_to_ts(inode, fattr->ctime); 879 else 880 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE 881 | NFS_INO_INVALID_CTIME); 882 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ACCESS 883 | NFS_INO_INVALID_ACL); 884 } 885 if (attr->ia_valid & (ATTR_ATIME_SET|ATTR_ATIME)) { 886 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_ATIME 887 | NFS_INO_INVALID_CTIME); 888 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 889 inode_set_atime_to_ts(inode, fattr->atime); 890 else if (attr->ia_valid & ATTR_ATIME_SET) 891 inode_set_atime_to_ts(inode, attr->ia_atime); 892 else 893 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME); 894 895 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 896 inode_set_ctime_to_ts(inode, fattr->ctime); 897 else 898 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE 899 | NFS_INO_INVALID_CTIME); 900 } 901 if (attr->ia_valid & (ATTR_MTIME_SET|ATTR_MTIME)) { 902 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_MTIME 903 | NFS_INO_INVALID_CTIME); 904 if (fattr->valid & NFS_ATTR_FATTR_MTIME) 905 inode_set_mtime_to_ts(inode, fattr->mtime); 906 else if (attr->ia_valid & ATTR_MTIME_SET) 907 inode_set_mtime_to_ts(inode, attr->ia_mtime); 908 else 909 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME); 910 911 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 912 inode_set_ctime_to_ts(inode, fattr->ctime); 913 else 914 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE 915 | NFS_INO_INVALID_CTIME); 916 } 917 if (fattr->valid) 918 nfs_update_inode(inode, fattr); 919 spin_unlock(&inode->i_lock); 920 } 921 EXPORT_SYMBOL_GPL(nfs_setattr_update_inode); 922 923 /* 924 * Don't request help from readdirplus if the file is being written to, 925 * or if attribute caching is turned off 926 */ 927 static bool nfs_getattr_readdirplus_enable(const struct inode *inode) 928 { 929 return nfs_server_capable(inode, NFS_CAP_READDIRPLUS) && 930 !nfs_have_writebacks(inode) && NFS_MAXATTRTIMEO(inode) > 5 * HZ; 931 } 932 933 static void nfs_readdirplus_parent_cache_miss(struct dentry *dentry) 934 { 935 if (!IS_ROOT(dentry)) { 936 struct dentry *parent = dget_parent(dentry); 937 nfs_readdir_record_entry_cache_miss(d_inode(parent)); 938 dput(parent); 939 } 940 } 941 942 static void nfs_readdirplus_parent_cache_hit(struct dentry *dentry) 943 { 944 if (!IS_ROOT(dentry)) { 945 struct dentry *parent = dget_parent(dentry); 946 nfs_readdir_record_entry_cache_hit(d_inode(parent)); 947 dput(parent); 948 } 949 } 950 951 static u32 nfs_get_valid_attrmask(struct inode *inode) 952 { 953 u64 fattr_valid = NFS_SERVER(inode)->fattr_valid; 954 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity); 955 u32 reply_mask = STATX_INO | STATX_TYPE; 956 957 if (!(cache_validity & NFS_INO_INVALID_ATIME)) 958 reply_mask |= STATX_ATIME; 959 if (!(cache_validity & NFS_INO_INVALID_CTIME)) 960 reply_mask |= STATX_CTIME; 961 if (!(cache_validity & NFS_INO_INVALID_MTIME)) 962 reply_mask |= STATX_MTIME; 963 if (!(cache_validity & NFS_INO_INVALID_SIZE)) 964 reply_mask |= STATX_SIZE; 965 if (!(cache_validity & NFS_INO_INVALID_NLINK)) 966 reply_mask |= STATX_NLINK; 967 if (!(cache_validity & NFS_INO_INVALID_MODE)) 968 reply_mask |= STATX_MODE; 969 if (!(cache_validity & NFS_INO_INVALID_OTHER)) 970 reply_mask |= STATX_UID | STATX_GID; 971 if (!(cache_validity & NFS_INO_INVALID_BLOCKS)) 972 reply_mask |= STATX_BLOCKS; 973 if (!(cache_validity & NFS_INO_INVALID_BTIME) && 974 (fattr_valid & NFS_ATTR_FATTR_BTIME)) 975 reply_mask |= STATX_BTIME; 976 if (!(cache_validity & NFS_INO_INVALID_CHANGE)) 977 reply_mask |= STATX_CHANGE_COOKIE; 978 return reply_mask; 979 } 980 981 int nfs_getattr(struct mnt_idmap *idmap, const struct path *path, 982 struct kstat *stat, u32 request_mask, unsigned int query_flags) 983 { 984 struct inode *inode = d_inode(path->dentry); 985 struct nfs_server *server = NFS_SERVER(inode); 986 u64 fattr_valid = server->fattr_valid; 987 unsigned long cache_validity; 988 int err = 0; 989 bool force_sync = query_flags & AT_STATX_FORCE_SYNC; 990 bool do_update = false; 991 bool readdirplus_enabled = nfs_getattr_readdirplus_enable(inode); 992 993 trace_nfs_getattr_enter(inode); 994 995 request_mask &= STATX_TYPE | STATX_MODE | STATX_NLINK | STATX_UID | 996 STATX_GID | STATX_ATIME | STATX_MTIME | STATX_CTIME | 997 STATX_INO | STATX_SIZE | STATX_BLOCKS | STATX_BTIME | 998 STATX_CHANGE_COOKIE; 999 1000 if (!(fattr_valid & NFS_ATTR_FATTR_BTIME)) 1001 request_mask &= ~STATX_BTIME; 1002 1003 if ((query_flags & AT_STATX_DONT_SYNC) && !force_sync) { 1004 if (readdirplus_enabled) 1005 nfs_readdirplus_parent_cache_hit(path->dentry); 1006 goto out_no_revalidate; 1007 } 1008 1009 /* Flush out writes to the server in order to update c/mtime/version. */ 1010 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_CHANGE_COOKIE)) && 1011 S_ISREG(inode->i_mode)) { 1012 if (nfs_have_delegated_mtime(inode)) 1013 filemap_fdatawrite(inode->i_mapping); 1014 else 1015 filemap_write_and_wait(inode->i_mapping); 1016 } 1017 1018 /* 1019 * We may force a getattr if the user cares about atime. 1020 * 1021 * Note that we only have to check the vfsmount flags here: 1022 * - NFS always sets S_NOATIME by so checking it would give a 1023 * bogus result 1024 * - NFS never sets SB_NOATIME or SB_NODIRATIME so there is 1025 * no point in checking those. 1026 */ 1027 if ((path->mnt->mnt_flags & MNT_NOATIME) || 1028 ((path->mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))) 1029 request_mask &= ~STATX_ATIME; 1030 1031 /* Is the user requesting attributes that might need revalidation? */ 1032 if (!(request_mask & (STATX_MODE|STATX_NLINK|STATX_ATIME|STATX_CTIME| 1033 STATX_MTIME|STATX_UID|STATX_GID| 1034 STATX_SIZE|STATX_BLOCKS|STATX_BTIME| 1035 STATX_CHANGE_COOKIE))) 1036 goto out_no_revalidate; 1037 1038 /* Check whether the cached attributes are stale */ 1039 do_update |= force_sync || nfs_attribute_cache_expired(inode); 1040 cache_validity = READ_ONCE(NFS_I(inode)->cache_validity); 1041 do_update |= cache_validity & NFS_INO_INVALID_CHANGE; 1042 if (request_mask & STATX_ATIME) 1043 do_update |= cache_validity & NFS_INO_INVALID_ATIME; 1044 if (request_mask & STATX_CTIME) 1045 do_update |= cache_validity & NFS_INO_INVALID_CTIME; 1046 if (request_mask & STATX_MTIME) 1047 do_update |= cache_validity & NFS_INO_INVALID_MTIME; 1048 if (request_mask & STATX_SIZE) 1049 do_update |= cache_validity & NFS_INO_INVALID_SIZE; 1050 if (request_mask & STATX_NLINK) 1051 do_update |= cache_validity & NFS_INO_INVALID_NLINK; 1052 if (request_mask & STATX_MODE) 1053 do_update |= cache_validity & NFS_INO_INVALID_MODE; 1054 if (request_mask & (STATX_UID | STATX_GID)) 1055 do_update |= cache_validity & NFS_INO_INVALID_OTHER; 1056 if (request_mask & STATX_BLOCKS) 1057 do_update |= cache_validity & NFS_INO_INVALID_BLOCKS; 1058 if (request_mask & STATX_BTIME) 1059 do_update |= cache_validity & NFS_INO_INVALID_BTIME; 1060 1061 if (do_update) { 1062 if (readdirplus_enabled) 1063 nfs_readdirplus_parent_cache_miss(path->dentry); 1064 err = __nfs_revalidate_inode(server, inode); 1065 if (err) 1066 goto out; 1067 } else if (readdirplus_enabled) 1068 nfs_readdirplus_parent_cache_hit(path->dentry); 1069 out_no_revalidate: 1070 /* Only return attributes that were revalidated. */ 1071 stat->result_mask = nfs_get_valid_attrmask(inode) | request_mask; 1072 1073 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat); 1074 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode)); 1075 stat->change_cookie = inode_peek_iversion_raw(inode); 1076 stat->attributes_mask |= STATX_ATTR_CHANGE_MONOTONIC; 1077 if (server->change_attr_type != NFS4_CHANGE_TYPE_IS_UNDEFINED) 1078 stat->attributes |= STATX_ATTR_CHANGE_MONOTONIC; 1079 if (S_ISDIR(inode->i_mode)) 1080 stat->blksize = NFS_SERVER(inode)->dtsize; 1081 stat->btime = NFS_I(inode)->btime; 1082 1083 /* Special handling for STATX_DIOALIGN and STATX_DIO_READ_ALIGN 1084 * - NFS doesn't have DIO alignment constraints, avoid getting 1085 * these DIO attrs from remote and just respond with most 1086 * accommodating limits (so client will issue supported DIO). 1087 * - this is unintuitive, but the most coarse-grained 1088 * dio_offset_align is the most accommodating. 1089 */ 1090 if ((request_mask & (STATX_DIOALIGN | STATX_DIO_READ_ALIGN)) && 1091 S_ISREG(inode->i_mode)) { 1092 stat->result_mask |= STATX_DIOALIGN | STATX_DIO_READ_ALIGN; 1093 stat->dio_mem_align = 4; /* 4-byte alignment */ 1094 stat->dio_offset_align = PAGE_SIZE; 1095 stat->dio_read_offset_align = stat->dio_offset_align; 1096 } 1097 out: 1098 trace_nfs_getattr_exit(inode, err); 1099 return err; 1100 } 1101 EXPORT_SYMBOL_GPL(nfs_getattr); 1102 1103 static void nfs_init_lock_context(struct nfs_lock_context *l_ctx) 1104 { 1105 refcount_set(&l_ctx->count, 1); 1106 l_ctx->lockowner = current->files; 1107 INIT_LIST_HEAD(&l_ctx->list); 1108 atomic_set(&l_ctx->io_count, 0); 1109 } 1110 1111 static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx) 1112 { 1113 struct nfs_lock_context *pos; 1114 1115 list_for_each_entry_rcu(pos, &ctx->lock_context.list, list) { 1116 if (pos->lockowner != current->files) 1117 continue; 1118 if (refcount_inc_not_zero(&pos->count)) 1119 return pos; 1120 } 1121 return NULL; 1122 } 1123 1124 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx) 1125 { 1126 struct nfs_lock_context *res, *new = NULL; 1127 struct inode *inode = d_inode(ctx->dentry); 1128 1129 rcu_read_lock(); 1130 res = __nfs_find_lock_context(ctx); 1131 rcu_read_unlock(); 1132 if (res == NULL) { 1133 new = kmalloc(sizeof(*new), GFP_KERNEL_ACCOUNT); 1134 if (new == NULL) 1135 return ERR_PTR(-ENOMEM); 1136 nfs_init_lock_context(new); 1137 spin_lock(&inode->i_lock); 1138 res = __nfs_find_lock_context(ctx); 1139 if (res == NULL) { 1140 new->open_context = get_nfs_open_context(ctx); 1141 if (new->open_context) { 1142 list_add_tail_rcu(&new->list, 1143 &ctx->lock_context.list); 1144 res = new; 1145 new = NULL; 1146 } else 1147 res = ERR_PTR(-EBADF); 1148 } 1149 spin_unlock(&inode->i_lock); 1150 kfree(new); 1151 } 1152 return res; 1153 } 1154 EXPORT_SYMBOL_GPL(nfs_get_lock_context); 1155 1156 void nfs_put_lock_context(struct nfs_lock_context *l_ctx) 1157 { 1158 struct nfs_open_context *ctx = l_ctx->open_context; 1159 struct inode *inode = d_inode(ctx->dentry); 1160 1161 if (!refcount_dec_and_lock(&l_ctx->count, &inode->i_lock)) 1162 return; 1163 list_del_rcu(&l_ctx->list); 1164 spin_unlock(&inode->i_lock); 1165 put_nfs_open_context(ctx); 1166 kfree_rcu(l_ctx, rcu_head); 1167 } 1168 EXPORT_SYMBOL_GPL(nfs_put_lock_context); 1169 1170 /** 1171 * nfs_close_context - Common close_context() routine NFSv2/v3 1172 * @ctx: pointer to context 1173 * @is_sync: is this a synchronous close 1174 * 1175 * Ensure that the attributes are up to date if we're mounted 1176 * with close-to-open semantics and we have cached data that will 1177 * need to be revalidated on open. 1178 */ 1179 void nfs_close_context(struct nfs_open_context *ctx, int is_sync) 1180 { 1181 struct nfs_inode *nfsi; 1182 struct inode *inode; 1183 1184 if (!(ctx->mode & FMODE_WRITE)) 1185 return; 1186 if (!is_sync) 1187 return; 1188 inode = d_inode(ctx->dentry); 1189 if (nfs_have_read_or_write_delegation(inode)) 1190 return; 1191 nfsi = NFS_I(inode); 1192 if (inode->i_mapping->nrpages == 0) 1193 return; 1194 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 1195 return; 1196 if (!list_empty(&nfsi->open_files)) 1197 return; 1198 if (NFS_SERVER(inode)->flags & NFS_MOUNT_NOCTO) 1199 return; 1200 nfs_revalidate_inode(inode, 1201 NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE); 1202 } 1203 EXPORT_SYMBOL_GPL(nfs_close_context); 1204 1205 struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, 1206 fmode_t f_mode, 1207 struct file *filp) 1208 { 1209 struct nfs_open_context *ctx; 1210 1211 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL_ACCOUNT); 1212 if (!ctx) 1213 return ERR_PTR(-ENOMEM); 1214 nfs_sb_active(dentry->d_sb); 1215 ctx->dentry = dget(dentry); 1216 if (filp) 1217 ctx->cred = get_cred(filp->f_cred); 1218 else 1219 ctx->cred = get_current_cred(); 1220 rcu_assign_pointer(ctx->ll_cred, NULL); 1221 ctx->state = NULL; 1222 ctx->mode = f_mode; 1223 ctx->flags = 0; 1224 ctx->error = 0; 1225 ctx->flock_owner = (fl_owner_t)filp; 1226 nfs_init_lock_context(&ctx->lock_context); 1227 ctx->lock_context.open_context = ctx; 1228 INIT_LIST_HEAD(&ctx->list); 1229 ctx->mdsthreshold = NULL; 1230 nfs_localio_file_init(&ctx->nfl); 1231 1232 return ctx; 1233 } 1234 EXPORT_SYMBOL_GPL(alloc_nfs_open_context); 1235 1236 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx) 1237 { 1238 if (ctx != NULL && refcount_inc_not_zero(&ctx->lock_context.count)) 1239 return ctx; 1240 return NULL; 1241 } 1242 EXPORT_SYMBOL_GPL(get_nfs_open_context); 1243 1244 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync) 1245 { 1246 struct inode *inode = d_inode(ctx->dentry); 1247 struct super_block *sb = ctx->dentry->d_sb; 1248 1249 if (!refcount_dec_and_test(&ctx->lock_context.count)) 1250 return; 1251 if (!list_empty(&ctx->list)) { 1252 spin_lock(&inode->i_lock); 1253 list_del_rcu(&ctx->list); 1254 spin_unlock(&inode->i_lock); 1255 } 1256 if (inode != NULL) 1257 NFS_PROTO(inode)->close_context(ctx, is_sync); 1258 put_cred(ctx->cred); 1259 dput(ctx->dentry); 1260 nfs_sb_deactive(sb); 1261 put_rpccred(rcu_dereference_protected(ctx->ll_cred, 1)); 1262 kfree(ctx->mdsthreshold); 1263 nfs_close_local_fh(&ctx->nfl); 1264 kfree_rcu(ctx, rcu_head); 1265 } 1266 1267 void put_nfs_open_context(struct nfs_open_context *ctx) 1268 { 1269 __put_nfs_open_context(ctx, 0); 1270 } 1271 EXPORT_SYMBOL_GPL(put_nfs_open_context); 1272 1273 static void put_nfs_open_context_sync(struct nfs_open_context *ctx) 1274 { 1275 __put_nfs_open_context(ctx, 1); 1276 } 1277 1278 /* 1279 * Ensure that mmap has a recent RPC credential for use when writing out 1280 * shared pages 1281 */ 1282 void nfs_inode_attach_open_context(struct nfs_open_context *ctx) 1283 { 1284 struct inode *inode = d_inode(ctx->dentry); 1285 struct nfs_inode *nfsi = NFS_I(inode); 1286 1287 spin_lock(&inode->i_lock); 1288 if (list_empty(&nfsi->open_files) && 1289 nfs_ooo_test(nfsi)) 1290 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA | 1291 NFS_INO_REVAL_FORCED); 1292 list_add_tail_rcu(&ctx->list, &nfsi->open_files); 1293 spin_unlock(&inode->i_lock); 1294 } 1295 EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context); 1296 1297 void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx) 1298 { 1299 filp->private_data = get_nfs_open_context(ctx); 1300 set_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags); 1301 if (list_empty(&ctx->list)) 1302 nfs_inode_attach_open_context(ctx); 1303 } 1304 EXPORT_SYMBOL_GPL(nfs_file_set_open_context); 1305 1306 /* 1307 * Given an inode, search for an open context with the desired characteristics 1308 */ 1309 struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode) 1310 { 1311 struct nfs_inode *nfsi = NFS_I(inode); 1312 struct nfs_open_context *pos, *ctx = NULL; 1313 1314 rcu_read_lock(); 1315 list_for_each_entry_rcu(pos, &nfsi->open_files, list) { 1316 if (cred != NULL && cred_fscmp(pos->cred, cred) != 0) 1317 continue; 1318 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode) 1319 continue; 1320 if (!test_bit(NFS_CONTEXT_FILE_OPEN, &pos->flags)) 1321 continue; 1322 ctx = get_nfs_open_context(pos); 1323 if (ctx) 1324 break; 1325 } 1326 rcu_read_unlock(); 1327 return ctx; 1328 } 1329 1330 void nfs_file_clear_open_context(struct file *filp) 1331 { 1332 struct nfs_open_context *ctx = nfs_file_open_context(filp); 1333 1334 if (ctx) { 1335 struct inode *inode = d_inode(ctx->dentry); 1336 1337 clear_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags); 1338 /* 1339 * We fatal error on write before. Try to writeback 1340 * every page again. 1341 */ 1342 if (ctx->error < 0) 1343 invalidate_inode_pages2(inode->i_mapping); 1344 filp->private_data = NULL; 1345 put_nfs_open_context_sync(ctx); 1346 } 1347 } 1348 1349 /* 1350 * These allocate and release file read/write context information. 1351 */ 1352 int nfs_open(struct inode *inode, struct file *filp) 1353 { 1354 struct nfs_open_context *ctx; 1355 1356 ctx = alloc_nfs_open_context(file_dentry(filp), 1357 flags_to_mode(filp->f_flags), filp); 1358 if (IS_ERR(ctx)) 1359 return PTR_ERR(ctx); 1360 nfs_file_set_open_context(filp, ctx); 1361 put_nfs_open_context(ctx); 1362 nfs_fscache_open_file(inode, filp); 1363 return 0; 1364 } 1365 1366 /* 1367 * This function is called whenever some part of NFS notices that 1368 * the cached attributes have to be refreshed. 1369 */ 1370 int 1371 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 1372 { 1373 int status = -ESTALE; 1374 struct nfs_fattr *fattr = NULL; 1375 struct nfs_inode *nfsi = NFS_I(inode); 1376 1377 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Lu)\n", 1378 inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode)); 1379 1380 trace_nfs_revalidate_inode_enter(inode); 1381 1382 if (is_bad_inode(inode)) 1383 goto out; 1384 if (NFS_STALE(inode)) 1385 goto out; 1386 1387 /* pNFS: Attributes aren't updated until we layoutcommit */ 1388 if (S_ISREG(inode->i_mode)) { 1389 status = pnfs_sync_inode(inode, false); 1390 if (status) 1391 goto out; 1392 } else if (nfs_have_directory_delegation(inode)) { 1393 status = 0; 1394 goto out; 1395 } 1396 1397 status = -ENOMEM; 1398 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode)); 1399 if (fattr == NULL) 1400 goto out; 1401 1402 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE); 1403 1404 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, inode); 1405 if (status != 0) { 1406 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n", 1407 inode->i_sb->s_id, 1408 (unsigned long long)NFS_FILEID(inode), status); 1409 switch (status) { 1410 case -ETIMEDOUT: 1411 /* A soft timeout occurred. Use cached information? */ 1412 if (server->flags & NFS_MOUNT_SOFTREVAL) 1413 status = 0; 1414 break; 1415 case -ESTALE: 1416 if (!S_ISDIR(inode->i_mode)) 1417 nfs_set_inode_stale(inode); 1418 else 1419 nfs_zap_caches(inode); 1420 } 1421 goto out; 1422 } 1423 1424 status = nfs_refresh_inode(inode, fattr); 1425 if (status) { 1426 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n", 1427 inode->i_sb->s_id, 1428 (unsigned long long)NFS_FILEID(inode), status); 1429 goto out; 1430 } 1431 1432 if (nfsi->cache_validity & NFS_INO_INVALID_ACL) 1433 nfs_zap_acl_cache(inode); 1434 1435 nfs_setsecurity(inode, fattr); 1436 1437 dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n", 1438 inode->i_sb->s_id, 1439 (unsigned long long)NFS_FILEID(inode)); 1440 1441 out: 1442 nfs_free_fattr(fattr); 1443 trace_nfs_revalidate_inode_exit(inode, status); 1444 return status; 1445 } 1446 1447 int nfs_attribute_cache_expired(struct inode *inode) 1448 { 1449 if (nfs_have_delegated_attributes(inode)) 1450 return 0; 1451 return nfs_attribute_timeout(inode); 1452 } 1453 1454 /** 1455 * nfs_revalidate_inode - Revalidate the inode attributes 1456 * @inode: pointer to inode struct 1457 * @flags: cache flags to check 1458 * 1459 * Updates inode attribute information by retrieving the data from the server. 1460 */ 1461 int nfs_revalidate_inode(struct inode *inode, unsigned long flags) 1462 { 1463 if (!nfs_check_cache_invalid(inode, flags)) 1464 return NFS_STALE(inode) ? -ESTALE : 0; 1465 return __nfs_revalidate_inode(NFS_SERVER(inode), inode); 1466 } 1467 EXPORT_SYMBOL_GPL(nfs_revalidate_inode); 1468 1469 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping) 1470 { 1471 int ret; 1472 1473 nfs_fscache_invalidate(inode, 0); 1474 if (mapping->nrpages != 0) { 1475 if (S_ISREG(inode->i_mode)) { 1476 ret = nfs_sync_mapping(mapping); 1477 if (ret < 0) 1478 return ret; 1479 } 1480 ret = invalidate_inode_pages2(mapping); 1481 if (ret < 0) 1482 return ret; 1483 } 1484 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE); 1485 1486 dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n", 1487 inode->i_sb->s_id, 1488 (unsigned long long)NFS_FILEID(inode)); 1489 return 0; 1490 } 1491 1492 /** 1493 * nfs_clear_invalid_mapping - Conditionally clear a mapping 1494 * @mapping: pointer to mapping 1495 * 1496 * If the NFS_INO_INVALID_DATA inode flag is set, clear the mapping. 1497 */ 1498 int nfs_clear_invalid_mapping(struct address_space *mapping) 1499 { 1500 struct inode *inode = mapping->host; 1501 struct nfs_inode *nfsi = NFS_I(inode); 1502 unsigned long *bitlock = &nfsi->flags; 1503 int ret = 0; 1504 1505 /* 1506 * We must clear NFS_INO_INVALID_DATA first to ensure that 1507 * invalidations that come in while we're shooting down the mappings 1508 * are respected. But, that leaves a race window where one revalidator 1509 * can clear the flag, and then another checks it before the mapping 1510 * gets invalidated. Fix that by serializing access to this part of 1511 * the function. 1512 * 1513 * At the same time, we need to allow other tasks to see whether we 1514 * might be in the middle of invalidating the pages, so we only set 1515 * the bit lock here if it looks like we're going to be doing that. 1516 */ 1517 for (;;) { 1518 ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING, 1519 nfs_wait_bit_killable, 1520 TASK_KILLABLE|TASK_FREEZABLE_UNSAFE); 1521 if (ret) 1522 goto out; 1523 smp_rmb(); /* pairs with smp_wmb() below */ 1524 if (test_bit(NFS_INO_INVALIDATING, bitlock)) 1525 continue; 1526 /* pairs with nfs_set_cache_invalid()'s smp_store_release() */ 1527 if (!(smp_load_acquire(&nfsi->cache_validity) & NFS_INO_INVALID_DATA)) 1528 goto out; 1529 /* Slow-path that double-checks with spinlock held */ 1530 spin_lock(&inode->i_lock); 1531 if (test_bit(NFS_INO_INVALIDATING, bitlock)) { 1532 spin_unlock(&inode->i_lock); 1533 continue; 1534 } 1535 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 1536 break; 1537 spin_unlock(&inode->i_lock); 1538 goto out; 1539 } 1540 1541 set_bit(NFS_INO_INVALIDATING, bitlock); 1542 smp_wmb(); 1543 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA; 1544 nfs_ooo_clear(nfsi); 1545 spin_unlock(&inode->i_lock); 1546 trace_nfs_invalidate_mapping_enter(inode); 1547 ret = nfs_invalidate_mapping(inode, mapping); 1548 trace_nfs_invalidate_mapping_exit(inode, ret); 1549 1550 clear_bit_unlock(NFS_INO_INVALIDATING, bitlock); 1551 smp_mb__after_atomic(); 1552 wake_up_bit(bitlock, NFS_INO_INVALIDATING); 1553 out: 1554 return ret; 1555 } 1556 1557 bool nfs_mapping_need_revalidate_inode(struct inode *inode) 1558 { 1559 return nfs_check_cache_invalid(inode, NFS_INO_INVALID_CHANGE) || 1560 NFS_STALE(inode); 1561 } 1562 1563 int nfs_revalidate_mapping_rcu(struct inode *inode) 1564 { 1565 struct nfs_inode *nfsi = NFS_I(inode); 1566 unsigned long *bitlock = &nfsi->flags; 1567 int ret = 0; 1568 1569 if (IS_SWAPFILE(inode)) 1570 goto out; 1571 if (nfs_mapping_need_revalidate_inode(inode)) { 1572 ret = -ECHILD; 1573 goto out; 1574 } 1575 spin_lock(&inode->i_lock); 1576 if (test_bit(NFS_INO_INVALIDATING, bitlock) || 1577 (nfsi->cache_validity & NFS_INO_INVALID_DATA)) 1578 ret = -ECHILD; 1579 spin_unlock(&inode->i_lock); 1580 out: 1581 return ret; 1582 } 1583 1584 /** 1585 * nfs_revalidate_mapping - Revalidate the pagecache 1586 * @inode: pointer to host inode 1587 * @mapping: pointer to mapping 1588 */ 1589 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) 1590 { 1591 /* swapfiles are not supposed to be shared. */ 1592 if (IS_SWAPFILE(inode)) 1593 return 0; 1594 1595 if (nfs_mapping_need_revalidate_inode(inode)) { 1596 int ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 1597 if (ret < 0) 1598 return ret; 1599 } 1600 1601 return nfs_clear_invalid_mapping(mapping); 1602 } 1603 1604 static bool nfs_file_has_writers(struct nfs_inode *nfsi) 1605 { 1606 struct inode *inode = &nfsi->vfs_inode; 1607 1608 if (!S_ISREG(inode->i_mode)) 1609 return false; 1610 if (list_empty(&nfsi->open_files)) 1611 return false; 1612 return inode_is_open_for_write(inode); 1613 } 1614 1615 static bool nfs_file_has_buffered_writers(struct nfs_inode *nfsi) 1616 { 1617 return nfs_file_has_writers(nfsi) && nfs_file_io_is_buffered(nfsi); 1618 } 1619 1620 static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1621 { 1622 struct timespec64 ts; 1623 1624 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE) 1625 && (fattr->valid & NFS_ATTR_FATTR_CHANGE) 1626 && inode_eq_iversion_raw(inode, fattr->pre_change_attr)) { 1627 inode_set_iversion_raw(inode, fattr->change_attr); 1628 if (S_ISDIR(inode->i_mode)) 1629 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA); 1630 else if (nfs_server_capable(inode, NFS_CAP_XATTR)) 1631 nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR); 1632 } 1633 /* If we have atomic WCC data, we may update some attributes */ 1634 ts = inode_get_ctime(inode); 1635 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME) 1636 && (fattr->valid & NFS_ATTR_FATTR_CTIME) 1637 && timespec64_equal(&ts, &fattr->pre_ctime)) { 1638 inode_set_ctime_to_ts(inode, fattr->ctime); 1639 } 1640 1641 ts = inode_get_mtime(inode); 1642 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME) 1643 && (fattr->valid & NFS_ATTR_FATTR_MTIME) 1644 && timespec64_equal(&ts, &fattr->pre_mtime)) { 1645 inode_set_mtime_to_ts(inode, fattr->mtime); 1646 } 1647 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE) 1648 && (fattr->valid & NFS_ATTR_FATTR_SIZE) 1649 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size) 1650 && !nfs_have_writebacks(inode)) { 1651 trace_nfs_size_wcc(inode, fattr->size); 1652 i_size_write(inode, nfs_size_to_loff_t(fattr->size)); 1653 } 1654 } 1655 1656 /** 1657 * nfs_check_inode_attributes - verify consistency of the inode attribute cache 1658 * @inode: pointer to inode 1659 * @fattr: updated attributes 1660 * 1661 * Verifies the attribute cache. If we have just changed the attributes, 1662 * so that fattr carries weak cache consistency data, then it may 1663 * also update the ctime/mtime/change_attribute. 1664 */ 1665 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr) 1666 { 1667 struct nfs_inode *nfsi = NFS_I(inode); 1668 loff_t cur_size, new_isize; 1669 unsigned long invalid = 0; 1670 struct timespec64 ts; 1671 1672 if (nfs_have_delegated_attributes(inode)) 1673 return 0; 1674 1675 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) { 1676 /* Only a mounted-on-fileid? Just exit */ 1677 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) 1678 return 0; 1679 /* Has the inode gone and changed behind our back? */ 1680 } else if (nfsi->fileid != fattr->fileid) { 1681 /* Is this perhaps the mounted-on fileid? */ 1682 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) && 1683 nfsi->fileid == fattr->mounted_on_fileid) 1684 return 0; 1685 return -ESTALE; 1686 } 1687 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) 1688 return -ESTALE; 1689 1690 1691 if (!nfs_file_has_buffered_writers(nfsi)) { 1692 /* Verify a few of the more important attributes */ 1693 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && !inode_eq_iversion_raw(inode, fattr->change_attr)) 1694 invalid |= NFS_INO_INVALID_CHANGE; 1695 1696 ts = inode_get_mtime(inode); 1697 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec64_equal(&ts, &fattr->mtime)) 1698 invalid |= NFS_INO_INVALID_MTIME; 1699 1700 ts = inode_get_ctime(inode); 1701 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) && !timespec64_equal(&ts, &fattr->ctime)) 1702 invalid |= NFS_INO_INVALID_CTIME; 1703 1704 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 1705 cur_size = i_size_read(inode); 1706 new_isize = nfs_size_to_loff_t(fattr->size); 1707 if (cur_size != new_isize) 1708 invalid |= NFS_INO_INVALID_SIZE; 1709 } 1710 } 1711 1712 /* Have any file permissions changed? */ 1713 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) 1714 invalid |= NFS_INO_INVALID_MODE; 1715 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid)) 1716 invalid |= NFS_INO_INVALID_OTHER; 1717 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid)) 1718 invalid |= NFS_INO_INVALID_OTHER; 1719 1720 /* Has the link count changed? */ 1721 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink) 1722 invalid |= NFS_INO_INVALID_NLINK; 1723 1724 ts = inode_get_atime(inode); 1725 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec64_equal(&ts, &fattr->atime)) 1726 invalid |= NFS_INO_INVALID_ATIME; 1727 1728 if (invalid != 0) 1729 nfs_set_cache_invalid(inode, invalid); 1730 1731 nfsi->read_cache_jiffies = fattr->time_start; 1732 return 0; 1733 } 1734 1735 static atomic_long_t nfs_attr_generation_counter; 1736 1737 static unsigned long nfs_read_attr_generation_counter(void) 1738 { 1739 return atomic_long_read(&nfs_attr_generation_counter); 1740 } 1741 1742 unsigned long nfs_inc_attr_generation_counter(void) 1743 { 1744 return atomic_long_inc_return(&nfs_attr_generation_counter); 1745 } 1746 EXPORT_SYMBOL_GPL(nfs_inc_attr_generation_counter); 1747 1748 void nfs_fattr_init(struct nfs_fattr *fattr) 1749 { 1750 fattr->valid = 0; 1751 fattr->time_start = jiffies; 1752 fattr->gencount = nfs_inc_attr_generation_counter(); 1753 fattr->owner_name = NULL; 1754 fattr->group_name = NULL; 1755 fattr->mdsthreshold = NULL; 1756 } 1757 EXPORT_SYMBOL_GPL(nfs_fattr_init); 1758 1759 /** 1760 * nfs_fattr_set_barrier 1761 * @fattr: attributes 1762 * 1763 * Used to set a barrier after an attribute was updated. This 1764 * barrier ensures that older attributes from RPC calls that may 1765 * have raced with our update cannot clobber these new values. 1766 * Note that you are still responsible for ensuring that other 1767 * operations which change the attribute on the server do not 1768 * collide. 1769 */ 1770 void nfs_fattr_set_barrier(struct nfs_fattr *fattr) 1771 { 1772 fattr->gencount = nfs_inc_attr_generation_counter(); 1773 } 1774 1775 struct nfs_fattr *nfs_alloc_fattr(void) 1776 { 1777 struct nfs_fattr *fattr; 1778 1779 fattr = kmalloc(sizeof(*fattr), GFP_KERNEL); 1780 if (fattr != NULL) { 1781 nfs_fattr_init(fattr); 1782 fattr->label = NULL; 1783 } 1784 return fattr; 1785 } 1786 EXPORT_SYMBOL_GPL(nfs_alloc_fattr); 1787 1788 struct nfs_fattr *nfs_alloc_fattr_with_label(struct nfs_server *server) 1789 { 1790 struct nfs_fattr *fattr = nfs_alloc_fattr(); 1791 1792 if (!fattr) 1793 return NULL; 1794 1795 fattr->label = nfs4_label_alloc(server, GFP_KERNEL); 1796 if (IS_ERR(fattr->label)) { 1797 kfree(fattr); 1798 return NULL; 1799 } 1800 1801 return fattr; 1802 } 1803 EXPORT_SYMBOL_GPL(nfs_alloc_fattr_with_label); 1804 1805 struct nfs_fh *nfs_alloc_fhandle(void) 1806 { 1807 struct nfs_fh *fh; 1808 1809 fh = kmalloc(sizeof(struct nfs_fh), GFP_KERNEL); 1810 if (fh != NULL) 1811 fh->size = 0; 1812 return fh; 1813 } 1814 EXPORT_SYMBOL_GPL(nfs_alloc_fhandle); 1815 1816 #ifdef NFS_DEBUG 1817 /* 1818 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle 1819 * in the same way that wireshark does 1820 * 1821 * @fh: file handle 1822 * 1823 * For debugging only. 1824 */ 1825 u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh) 1826 { 1827 /* wireshark uses 32-bit AUTODIN crc and does a bitwise 1828 * not on the result */ 1829 return nfs_fhandle_hash(fh); 1830 } 1831 EXPORT_SYMBOL_GPL(_nfs_display_fhandle_hash); 1832 1833 /* 1834 * _nfs_display_fhandle - display an NFS file handle on the console 1835 * 1836 * @fh: file handle to display 1837 * @caption: display caption 1838 * 1839 * For debugging only. 1840 */ 1841 void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption) 1842 { 1843 unsigned short i; 1844 1845 if (fh == NULL || fh->size == 0) { 1846 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh); 1847 return; 1848 } 1849 1850 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n", 1851 caption, fh, fh->size, _nfs_display_fhandle_hash(fh)); 1852 for (i = 0; i < fh->size; i += 16) { 1853 __be32 *pos = (__be32 *)&fh->data[i]; 1854 1855 switch ((fh->size - i - 1) >> 2) { 1856 case 0: 1857 printk(KERN_DEFAULT " %08x\n", 1858 be32_to_cpup(pos)); 1859 break; 1860 case 1: 1861 printk(KERN_DEFAULT " %08x %08x\n", 1862 be32_to_cpup(pos), be32_to_cpup(pos + 1)); 1863 break; 1864 case 2: 1865 printk(KERN_DEFAULT " %08x %08x %08x\n", 1866 be32_to_cpup(pos), be32_to_cpup(pos + 1), 1867 be32_to_cpup(pos + 2)); 1868 break; 1869 default: 1870 printk(KERN_DEFAULT " %08x %08x %08x %08x\n", 1871 be32_to_cpup(pos), be32_to_cpup(pos + 1), 1872 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3)); 1873 } 1874 } 1875 } 1876 EXPORT_SYMBOL_GPL(_nfs_display_fhandle); 1877 #endif 1878 1879 /** 1880 * nfs_inode_attrs_cmp_generic - compare attributes 1881 * @fattr: attributes 1882 * @inode: pointer to inode 1883 * 1884 * Attempt to divine whether or not an RPC call reply carrying stale 1885 * attributes got scheduled after another call carrying updated ones. 1886 * Note also the check for wraparound of 'attr_gencount' 1887 * 1888 * The function returns '1' if it thinks the attributes in @fattr are 1889 * more recent than the ones cached in @inode. Otherwise it returns 1890 * the value '0'. 1891 */ 1892 static int nfs_inode_attrs_cmp_generic(const struct nfs_fattr *fattr, 1893 const struct inode *inode) 1894 { 1895 unsigned long attr_gencount = NFS_I(inode)->attr_gencount; 1896 1897 return (long)(fattr->gencount - attr_gencount) > 0 || 1898 (long)(attr_gencount - nfs_read_attr_generation_counter()) > 0; 1899 } 1900 1901 /** 1902 * nfs_inode_attrs_cmp_monotonic - compare attributes 1903 * @fattr: attributes 1904 * @inode: pointer to inode 1905 * 1906 * Attempt to divine whether or not an RPC call reply carrying stale 1907 * attributes got scheduled after another call carrying updated ones. 1908 * 1909 * We assume that the server observes monotonic semantics for 1910 * the change attribute, so a larger value means that the attributes in 1911 * @fattr are more recent, in which case the function returns the 1912 * value '1'. 1913 * A return value of '0' indicates no measurable change 1914 * A return value of '-1' means that the attributes in @inode are 1915 * more recent. 1916 */ 1917 static int nfs_inode_attrs_cmp_monotonic(const struct nfs_fattr *fattr, 1918 const struct inode *inode) 1919 { 1920 s64 diff = fattr->change_attr - inode_peek_iversion_raw(inode); 1921 if (diff > 0) 1922 return 1; 1923 return diff == 0 ? 0 : -1; 1924 } 1925 1926 /** 1927 * nfs_inode_attrs_cmp_strict_monotonic - compare attributes 1928 * @fattr: attributes 1929 * @inode: pointer to inode 1930 * 1931 * Attempt to divine whether or not an RPC call reply carrying stale 1932 * attributes got scheduled after another call carrying updated ones. 1933 * 1934 * We assume that the server observes strictly monotonic semantics for 1935 * the change attribute, so a larger value means that the attributes in 1936 * @fattr are more recent, in which case the function returns the 1937 * value '1'. 1938 * A return value of '-1' means that the attributes in @inode are 1939 * more recent or unchanged. 1940 */ 1941 static int nfs_inode_attrs_cmp_strict_monotonic(const struct nfs_fattr *fattr, 1942 const struct inode *inode) 1943 { 1944 return nfs_inode_attrs_cmp_monotonic(fattr, inode) > 0 ? 1 : -1; 1945 } 1946 1947 /** 1948 * nfs_inode_attrs_cmp - compare attributes 1949 * @fattr: attributes 1950 * @inode: pointer to inode 1951 * 1952 * This function returns '1' if it thinks the attributes in @fattr are 1953 * more recent than the ones cached in @inode. It returns '-1' if 1954 * the attributes in @inode are more recent than the ones in @fattr, 1955 * and it returns 0 if not sure. 1956 */ 1957 static int nfs_inode_attrs_cmp(const struct nfs_fattr *fattr, 1958 const struct inode *inode) 1959 { 1960 if (nfs_inode_attrs_cmp_generic(fattr, inode) > 0) 1961 return 1; 1962 switch (NFS_SERVER(inode)->change_attr_type) { 1963 case NFS4_CHANGE_TYPE_IS_UNDEFINED: 1964 break; 1965 case NFS4_CHANGE_TYPE_IS_TIME_METADATA: 1966 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE)) 1967 break; 1968 return nfs_inode_attrs_cmp_monotonic(fattr, inode); 1969 default: 1970 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE)) 1971 break; 1972 return nfs_inode_attrs_cmp_strict_monotonic(fattr, inode); 1973 } 1974 return 0; 1975 } 1976 1977 /** 1978 * nfs_inode_finish_partial_attr_update - complete a previous inode update 1979 * @fattr: attributes 1980 * @inode: pointer to inode 1981 * 1982 * Returns '1' if the last attribute update left the inode cached 1983 * attributes in a partially unrevalidated state, and @fattr 1984 * matches the change attribute of that partial update. 1985 * Otherwise returns '0'. 1986 */ 1987 static int nfs_inode_finish_partial_attr_update(const struct nfs_fattr *fattr, 1988 const struct inode *inode) 1989 { 1990 const unsigned long check_valid = 1991 NFS_INO_INVALID_ATIME | NFS_INO_INVALID_CTIME | 1992 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE | 1993 NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_OTHER | 1994 NFS_INO_INVALID_NLINK | NFS_INO_INVALID_BTIME; 1995 unsigned long cache_validity = NFS_I(inode)->cache_validity; 1996 enum nfs4_change_attr_type ctype = NFS_SERVER(inode)->change_attr_type; 1997 1998 if (ctype != NFS4_CHANGE_TYPE_IS_UNDEFINED && 1999 !(cache_validity & NFS_INO_INVALID_CHANGE) && 2000 (cache_validity & check_valid) != 0 && 2001 (fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 2002 nfs_inode_attrs_cmp_monotonic(fattr, inode) == 0) 2003 return 1; 2004 return 0; 2005 } 2006 2007 static void nfs_ooo_merge(struct nfs_inode *nfsi, 2008 u64 start, u64 end) 2009 { 2010 int i, cnt; 2011 2012 if (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER) 2013 /* No point merging anything */ 2014 return; 2015 2016 if (!nfsi->ooo) { 2017 nfsi->ooo = kmalloc(sizeof(*nfsi->ooo), GFP_ATOMIC); 2018 if (!nfsi->ooo) { 2019 nfsi->cache_validity |= NFS_INO_DATA_INVAL_DEFER; 2020 return; 2021 } 2022 nfsi->ooo->cnt = 0; 2023 } 2024 2025 /* add this range, merging if possible */ 2026 cnt = nfsi->ooo->cnt; 2027 for (i = 0; i < cnt; i++) { 2028 if (end == nfsi->ooo->gap[i].start) 2029 end = nfsi->ooo->gap[i].end; 2030 else if (start == nfsi->ooo->gap[i].end) 2031 start = nfsi->ooo->gap[i].start; 2032 else 2033 continue; 2034 /* Remove 'i' from table and loop to insert the new range */ 2035 cnt -= 1; 2036 nfsi->ooo->gap[i] = nfsi->ooo->gap[cnt]; 2037 i = -1; 2038 } 2039 if (start != end) { 2040 if (cnt >= ARRAY_SIZE(nfsi->ooo->gap)) { 2041 nfsi->cache_validity |= NFS_INO_DATA_INVAL_DEFER; 2042 kfree(nfsi->ooo); 2043 nfsi->ooo = NULL; 2044 return; 2045 } 2046 nfsi->ooo->gap[cnt].start = start; 2047 nfsi->ooo->gap[cnt].end = end; 2048 cnt += 1; 2049 } 2050 nfsi->ooo->cnt = cnt; 2051 } 2052 2053 static void nfs_ooo_record(struct nfs_inode *nfsi, 2054 struct nfs_fattr *fattr) 2055 { 2056 /* This reply was out-of-order, so record in the 2057 * pre/post change id, possibly cancelling 2058 * gaps created when iversion was jumpped forward. 2059 */ 2060 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) && 2061 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE)) 2062 nfs_ooo_merge(nfsi, 2063 fattr->change_attr, 2064 fattr->pre_change_attr); 2065 } 2066 2067 static int nfs_refresh_inode_locked(struct inode *inode, 2068 struct nfs_fattr *fattr) 2069 { 2070 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode); 2071 int ret = 0; 2072 2073 trace_nfs_refresh_inode_enter(inode); 2074 2075 if (attr_cmp > 0 || nfs_inode_finish_partial_attr_update(fattr, inode)) 2076 ret = nfs_update_inode(inode, fattr); 2077 else { 2078 nfs_ooo_record(NFS_I(inode), fattr); 2079 2080 if (attr_cmp == 0) 2081 ret = nfs_check_inode_attributes(inode, fattr); 2082 } 2083 2084 trace_nfs_refresh_inode_exit(inode, ret); 2085 return ret; 2086 } 2087 2088 /** 2089 * nfs_refresh_inode - try to update the inode attribute cache 2090 * @inode: pointer to inode 2091 * @fattr: updated attributes 2092 * 2093 * Check that an RPC call that returned attributes has not overlapped with 2094 * other recent updates of the inode metadata, then decide whether it is 2095 * safe to do a full update of the inode attributes, or whether just to 2096 * call nfs_check_inode_attributes. 2097 */ 2098 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr) 2099 { 2100 int status; 2101 2102 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 2103 return 0; 2104 spin_lock(&inode->i_lock); 2105 status = nfs_refresh_inode_locked(inode, fattr); 2106 spin_unlock(&inode->i_lock); 2107 2108 return status; 2109 } 2110 EXPORT_SYMBOL_GPL(nfs_refresh_inode); 2111 2112 static int nfs_post_op_update_inode_locked(struct inode *inode, 2113 struct nfs_fattr *fattr, unsigned int invalid) 2114 { 2115 if (S_ISDIR(inode->i_mode)) 2116 invalid |= NFS_INO_INVALID_DATA; 2117 nfs_set_cache_invalid(inode, invalid); 2118 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 2119 return 0; 2120 return nfs_refresh_inode_locked(inode, fattr); 2121 } 2122 2123 /** 2124 * nfs_post_op_update_inode - try to update the inode attribute cache 2125 * @inode: pointer to inode 2126 * @fattr: updated attributes 2127 * 2128 * After an operation that has changed the inode metadata, mark the 2129 * attribute cache as being invalid, then try to update it. 2130 * 2131 * NB: if the server didn't return any post op attributes, this 2132 * function will force the retrieval of attributes before the next 2133 * NFS request. Thus it should be used only for operations that 2134 * are expected to change one or more attributes, to avoid 2135 * unnecessary NFS requests and trips through nfs_update_inode(). 2136 */ 2137 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr) 2138 { 2139 int status; 2140 2141 spin_lock(&inode->i_lock); 2142 nfs_fattr_set_barrier(fattr); 2143 status = nfs_post_op_update_inode_locked(inode, fattr, 2144 NFS_INO_INVALID_CHANGE 2145 | NFS_INO_INVALID_CTIME 2146 | NFS_INO_REVAL_FORCED); 2147 spin_unlock(&inode->i_lock); 2148 2149 return status; 2150 } 2151 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode); 2152 2153 /** 2154 * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache 2155 * @inode: pointer to inode 2156 * @fattr: updated attributes 2157 * 2158 * After an operation that has changed the inode metadata, mark the 2159 * attribute cache as being invalid, then try to update it. Fake up 2160 * weak cache consistency data, if none exist. 2161 * 2162 * This function is mainly designed to be used by the ->write_done() functions. 2163 */ 2164 int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr) 2165 { 2166 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode); 2167 int status; 2168 2169 /* Don't do a WCC update if these attributes are already stale */ 2170 if (attr_cmp < 0) 2171 return 0; 2172 if ((fattr->valid & NFS_ATTR_FATTR) == 0 || !attr_cmp) { 2173 /* Record the pre/post change info before clearing PRECHANGE */ 2174 nfs_ooo_record(NFS_I(inode), fattr); 2175 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE 2176 | NFS_ATTR_FATTR_PRESIZE 2177 | NFS_ATTR_FATTR_PREMTIME 2178 | NFS_ATTR_FATTR_PRECTIME); 2179 goto out_noforce; 2180 } 2181 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 2182 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) { 2183 fattr->pre_change_attr = inode_peek_iversion_raw(inode); 2184 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE; 2185 } 2186 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 && 2187 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) { 2188 fattr->pre_ctime = inode_get_ctime(inode); 2189 fattr->valid |= NFS_ATTR_FATTR_PRECTIME; 2190 } 2191 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 && 2192 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) { 2193 fattr->pre_mtime = inode_get_mtime(inode); 2194 fattr->valid |= NFS_ATTR_FATTR_PREMTIME; 2195 } 2196 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 && 2197 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) { 2198 fattr->pre_size = i_size_read(inode); 2199 fattr->valid |= NFS_ATTR_FATTR_PRESIZE; 2200 } 2201 out_noforce: 2202 status = nfs_post_op_update_inode_locked(inode, fattr, 2203 NFS_INO_INVALID_CHANGE 2204 | NFS_INO_INVALID_CTIME 2205 | NFS_INO_INVALID_MTIME 2206 | NFS_INO_INVALID_BLOCKS); 2207 return status; 2208 } 2209 2210 /** 2211 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache 2212 * @inode: pointer to inode 2213 * @fattr: updated attributes 2214 * 2215 * After an operation that has changed the inode metadata, mark the 2216 * attribute cache as being invalid, then try to update it. Fake up 2217 * weak cache consistency data, if none exist. 2218 * 2219 * This function is mainly designed to be used by the ->write_done() functions. 2220 */ 2221 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr) 2222 { 2223 int status; 2224 2225 spin_lock(&inode->i_lock); 2226 nfs_fattr_set_barrier(fattr); 2227 status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr); 2228 spin_unlock(&inode->i_lock); 2229 return status; 2230 } 2231 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc); 2232 2233 2234 /* 2235 * Many nfs protocol calls return the new file attributes after 2236 * an operation. Here we update the inode to reflect the state 2237 * of the server's inode. 2238 * 2239 * This is a bit tricky because we have to make sure all dirty pages 2240 * have been sent off to the server before calling invalidate_inode_pages. 2241 * To make sure no other process adds more write requests while we try 2242 * our best to flush them, we make them sleep during the attribute refresh. 2243 * 2244 * A very similar scenario holds for the dir cache. 2245 */ 2246 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 2247 { 2248 struct nfs_server *server = NFS_SERVER(inode); 2249 struct nfs_inode *nfsi = NFS_I(inode); 2250 loff_t cur_isize, new_isize; 2251 u64 fattr_supported = server->fattr_valid; 2252 unsigned long invalid = 0; 2253 unsigned long now = jiffies; 2254 unsigned long save_cache_validity; 2255 bool have_writers = nfs_file_has_buffered_writers(nfsi); 2256 bool cache_revalidated = true; 2257 bool attr_changed = false; 2258 bool have_delegation; 2259 2260 dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%llx)\n", 2261 __func__, inode->i_sb->s_id, inode->i_ino, 2262 nfs_display_fhandle_hash(NFS_FH(inode)), 2263 icount_read(inode), fattr->valid); 2264 2265 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) { 2266 /* Only a mounted-on-fileid? Just exit */ 2267 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) 2268 return 0; 2269 /* Has the inode gone and changed behind our back? */ 2270 } else if (nfsi->fileid != fattr->fileid) { 2271 /* Is this perhaps the mounted-on fileid? */ 2272 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) && 2273 nfsi->fileid == fattr->mounted_on_fileid) 2274 return 0; 2275 printk(KERN_ERR "NFS: server %s error: fileid changed\n" 2276 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n", 2277 NFS_SERVER(inode)->nfs_client->cl_hostname, 2278 inode->i_sb->s_id, (long long)nfsi->fileid, 2279 (long long)fattr->fileid); 2280 goto out_err; 2281 } 2282 2283 /* 2284 * Make sure the inode's type hasn't changed. 2285 */ 2286 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) { 2287 /* 2288 * Big trouble! The inode has become a different object. 2289 */ 2290 printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n", 2291 __func__, inode->i_ino, inode->i_mode, fattr->mode); 2292 goto out_err; 2293 } 2294 2295 /* Update the fsid? */ 2296 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) && 2297 !nfs_fsid_equal(&server->fsid, &fattr->fsid) && 2298 !IS_AUTOMOUNT(inode)) 2299 server->fsid = fattr->fsid; 2300 2301 /* Save the delegation state before clearing cache_validity */ 2302 have_delegation = nfs_have_delegated_attributes(inode); 2303 2304 /* 2305 * Update the read time so we don't revalidate too often. 2306 */ 2307 nfsi->read_cache_jiffies = fattr->time_start; 2308 2309 /* Fix up any delegated attributes in the struct nfs_fattr */ 2310 nfs_fattr_fixup_delegated(inode, fattr); 2311 2312 save_cache_validity = nfsi->cache_validity; 2313 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR 2314 | NFS_INO_INVALID_ATIME 2315 | NFS_INO_REVAL_FORCED 2316 | NFS_INO_INVALID_BLOCKS); 2317 2318 /* Do atomic weak cache consistency updates */ 2319 nfs_wcc_update_inode(inode, fattr); 2320 2321 if (pnfs_layoutcommit_outstanding(inode)) { 2322 nfsi->cache_validity |= 2323 save_cache_validity & 2324 (NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME | 2325 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE | 2326 NFS_INO_INVALID_BLOCKS); 2327 cache_revalidated = false; 2328 } 2329 2330 /* More cache consistency checks */ 2331 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) { 2332 if (!have_writers && nfsi->ooo && nfsi->ooo->cnt == 1 && 2333 nfsi->ooo->gap[0].end == inode_peek_iversion_raw(inode)) { 2334 /* There is one remaining gap that hasn't been 2335 * merged into iversion - do that now. 2336 */ 2337 inode_set_iversion_raw(inode, nfsi->ooo->gap[0].start); 2338 kfree(nfsi->ooo); 2339 nfsi->ooo = NULL; 2340 } 2341 if (!inode_eq_iversion_raw(inode, fattr->change_attr)) { 2342 /* Could it be a race with writeback? */ 2343 if (!(have_writers || have_delegation)) { 2344 invalid |= NFS_INO_INVALID_DATA 2345 | NFS_INO_INVALID_ACCESS 2346 | NFS_INO_INVALID_ACL 2347 | NFS_INO_INVALID_XATTR; 2348 /* Force revalidate of all attributes */ 2349 save_cache_validity |= NFS_INO_INVALID_CTIME 2350 | NFS_INO_INVALID_MTIME 2351 | NFS_INO_INVALID_SIZE 2352 | NFS_INO_INVALID_BLOCKS 2353 | NFS_INO_INVALID_NLINK 2354 | NFS_INO_INVALID_MODE 2355 | NFS_INO_INVALID_OTHER 2356 | NFS_INO_INVALID_BTIME; 2357 if (S_ISDIR(inode->i_mode)) 2358 nfs_force_lookup_revalidate(inode); 2359 attr_changed = true; 2360 dprintk("NFS: change_attr change on server for file %s/%ld\n", 2361 inode->i_sb->s_id, 2362 inode->i_ino); 2363 } else if (!have_delegation) { 2364 nfs_ooo_record(nfsi, fattr); 2365 nfs_ooo_merge(nfsi, inode_peek_iversion_raw(inode), 2366 fattr->change_attr); 2367 } 2368 inode_set_iversion_raw(inode, fattr->change_attr); 2369 } 2370 } else { 2371 nfsi->cache_validity |= 2372 save_cache_validity & NFS_INO_INVALID_CHANGE; 2373 if (!have_delegation || 2374 (nfsi->cache_validity & NFS_INO_INVALID_CHANGE) != 0) 2375 cache_revalidated = false; 2376 } 2377 2378 if (fattr->valid & NFS_ATTR_FATTR_MTIME) 2379 inode_set_mtime_to_ts(inode, fattr->mtime); 2380 else if (fattr_supported & NFS_ATTR_FATTR_MTIME) 2381 nfsi->cache_validity |= 2382 save_cache_validity & NFS_INO_INVALID_MTIME; 2383 2384 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 2385 inode_set_ctime_to_ts(inode, fattr->ctime); 2386 else if (fattr_supported & NFS_ATTR_FATTR_CTIME) 2387 nfsi->cache_validity |= 2388 save_cache_validity & NFS_INO_INVALID_CTIME; 2389 2390 if (fattr->valid & NFS_ATTR_FATTR_BTIME) 2391 nfsi->btime = fattr->btime; 2392 else if (fattr_supported & NFS_ATTR_FATTR_BTIME) 2393 nfsi->cache_validity |= 2394 save_cache_validity & NFS_INO_INVALID_BTIME; 2395 2396 /* Check if our cached file size is stale */ 2397 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 2398 new_isize = nfs_size_to_loff_t(fattr->size); 2399 cur_isize = i_size_read(inode); 2400 if (new_isize != cur_isize && !have_delegation) { 2401 /* Do we perhaps have any outstanding writes, or has 2402 * the file grown beyond our last write? */ 2403 if (!nfs_have_writebacks(inode) || new_isize > cur_isize) { 2404 trace_nfs_size_update(inode, new_isize); 2405 i_size_write(inode, new_isize); 2406 if (!have_writers) 2407 invalid |= NFS_INO_INVALID_DATA; 2408 } 2409 } 2410 if (new_isize == 0 && 2411 !(fattr->valid & (NFS_ATTR_FATTR_SPACE_USED | 2412 NFS_ATTR_FATTR_BLOCKS_USED))) { 2413 fattr->du.nfs3.used = 0; 2414 fattr->valid |= NFS_ATTR_FATTR_SPACE_USED; 2415 } 2416 } else 2417 nfsi->cache_validity |= 2418 save_cache_validity & NFS_INO_INVALID_SIZE; 2419 2420 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 2421 inode_set_atime_to_ts(inode, fattr->atime); 2422 else if (fattr_supported & NFS_ATTR_FATTR_ATIME) 2423 nfsi->cache_validity |= 2424 save_cache_validity & NFS_INO_INVALID_ATIME; 2425 2426 if (fattr->valid & NFS_ATTR_FATTR_MODE) { 2427 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) { 2428 umode_t newmode = inode->i_mode & S_IFMT; 2429 newmode |= fattr->mode & S_IALLUGO; 2430 inode->i_mode = newmode; 2431 invalid |= NFS_INO_INVALID_ACCESS 2432 | NFS_INO_INVALID_ACL; 2433 } 2434 } else if (fattr_supported & NFS_ATTR_FATTR_MODE) 2435 nfsi->cache_validity |= 2436 save_cache_validity & NFS_INO_INVALID_MODE; 2437 2438 if (fattr->valid & NFS_ATTR_FATTR_OWNER) { 2439 if (!uid_eq(inode->i_uid, fattr->uid)) { 2440 invalid |= NFS_INO_INVALID_ACCESS 2441 | NFS_INO_INVALID_ACL; 2442 inode->i_uid = fattr->uid; 2443 } 2444 } else if (fattr_supported & NFS_ATTR_FATTR_OWNER) 2445 nfsi->cache_validity |= 2446 save_cache_validity & NFS_INO_INVALID_OTHER; 2447 2448 if (fattr->valid & NFS_ATTR_FATTR_GROUP) { 2449 if (!gid_eq(inode->i_gid, fattr->gid)) { 2450 invalid |= NFS_INO_INVALID_ACCESS 2451 | NFS_INO_INVALID_ACL; 2452 inode->i_gid = fattr->gid; 2453 } 2454 } else if (fattr_supported & NFS_ATTR_FATTR_GROUP) 2455 nfsi->cache_validity |= 2456 save_cache_validity & NFS_INO_INVALID_OTHER; 2457 2458 if (fattr->valid & NFS_ATTR_FATTR_NLINK) { 2459 if (inode->i_nlink != fattr->nlink) 2460 set_nlink(inode, fattr->nlink); 2461 } else if (fattr_supported & NFS_ATTR_FATTR_NLINK) 2462 nfsi->cache_validity |= 2463 save_cache_validity & NFS_INO_INVALID_NLINK; 2464 2465 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { 2466 /* 2467 * report the blocks in 512byte units 2468 */ 2469 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 2470 } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED) 2471 nfsi->cache_validity |= 2472 save_cache_validity & NFS_INO_INVALID_BLOCKS; 2473 2474 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) 2475 inode->i_blocks = fattr->du.nfs2.blocks; 2476 else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED) 2477 nfsi->cache_validity |= 2478 save_cache_validity & NFS_INO_INVALID_BLOCKS; 2479 2480 /* Update attrtimeo value if we're out of the unstable period */ 2481 if (attr_changed) { 2482 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 2483 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 2484 nfsi->attrtimeo_timestamp = now; 2485 /* Set barrier to be more recent than all outstanding updates */ 2486 nfsi->attr_gencount = nfs_inc_attr_generation_counter(); 2487 } else { 2488 if (cache_revalidated) { 2489 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, 2490 nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) { 2491 nfsi->attrtimeo <<= 1; 2492 if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode)) 2493 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode); 2494 } 2495 nfsi->attrtimeo_timestamp = now; 2496 } 2497 /* Set the barrier to be more recent than this fattr */ 2498 if ((long)(fattr->gencount - nfsi->attr_gencount) > 0) 2499 nfsi->attr_gencount = fattr->gencount; 2500 } 2501 2502 /* Don't invalidate the data if we were to blame */ 2503 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) 2504 || S_ISLNK(inode->i_mode))) 2505 invalid &= ~NFS_INO_INVALID_DATA; 2506 nfs_set_cache_invalid(inode, invalid); 2507 2508 return 0; 2509 out_err: 2510 /* 2511 * No need to worry about unhashing the dentry, as the 2512 * lookup validation will know that the inode is bad. 2513 * (But we fall through to invalidate the caches.) 2514 */ 2515 nfs_set_inode_stale_locked(inode); 2516 return -ESTALE; 2517 } 2518 2519 struct inode *nfs_alloc_inode(struct super_block *sb) 2520 { 2521 struct nfs_inode *nfsi; 2522 nfsi = alloc_inode_sb(sb, nfs_inode_cachep, GFP_KERNEL); 2523 if (!nfsi) 2524 return NULL; 2525 nfsi->flags = 0UL; 2526 nfsi->cache_validity = 0UL; 2527 nfsi->ooo = NULL; 2528 #if IS_ENABLED(CONFIG_NFS_V4) 2529 nfsi->nfs4_acl = NULL; 2530 #endif /* CONFIG_NFS_V4 */ 2531 #ifdef CONFIG_NFS_V4_2 2532 nfsi->xattr_cache = NULL; 2533 #endif 2534 nfs_netfs_inode_init(nfsi); 2535 2536 return &nfsi->vfs_inode; 2537 } 2538 EXPORT_SYMBOL_GPL(nfs_alloc_inode); 2539 2540 void nfs_free_inode(struct inode *inode) 2541 { 2542 kfree(NFS_I(inode)->ooo); 2543 kmem_cache_free(nfs_inode_cachep, NFS_I(inode)); 2544 } 2545 EXPORT_SYMBOL_GPL(nfs_free_inode); 2546 2547 static inline void nfs4_init_once(struct nfs_inode *nfsi) 2548 { 2549 #if IS_ENABLED(CONFIG_NFS_V4) 2550 INIT_LIST_HEAD(&nfsi->open_states); 2551 nfsi->delegation = NULL; 2552 init_rwsem(&nfsi->rwsem); 2553 nfsi->layout = NULL; 2554 #endif 2555 } 2556 2557 static void init_once(void *foo) 2558 { 2559 struct nfs_inode *nfsi = foo; 2560 2561 inode_init_once(&nfsi->vfs_inode); 2562 INIT_LIST_HEAD(&nfsi->open_files); 2563 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru); 2564 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru); 2565 nfs4_init_once(nfsi); 2566 } 2567 2568 static int __init nfs_init_inodecache(void) 2569 { 2570 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", 2571 sizeof(struct nfs_inode), 2572 0, (SLAB_RECLAIM_ACCOUNT| 2573 SLAB_ACCOUNT), 2574 init_once); 2575 if (nfs_inode_cachep == NULL) 2576 return -ENOMEM; 2577 2578 return 0; 2579 } 2580 2581 static void nfs_destroy_inodecache(void) 2582 { 2583 /* 2584 * Make sure all delayed rcu free inodes are flushed before we 2585 * destroy cache. 2586 */ 2587 rcu_barrier(); 2588 kmem_cache_destroy(nfs_inode_cachep); 2589 } 2590 2591 struct workqueue_struct *nfslocaliod_workqueue; 2592 struct workqueue_struct *nfsiod_workqueue; 2593 EXPORT_SYMBOL_GPL(nfsiod_workqueue); 2594 2595 /* 2596 * Destroy the nfsiod workqueues 2597 */ 2598 static void nfsiod_stop(void) 2599 { 2600 struct workqueue_struct *wq; 2601 2602 wq = nfsiod_workqueue; 2603 if (wq != NULL) { 2604 nfsiod_workqueue = NULL; 2605 destroy_workqueue(wq); 2606 } 2607 #if IS_ENABLED(CONFIG_NFS_LOCALIO) 2608 wq = nfslocaliod_workqueue; 2609 if (wq != NULL) { 2610 nfslocaliod_workqueue = NULL; 2611 destroy_workqueue(wq); 2612 } 2613 #endif /* CONFIG_NFS_LOCALIO */ 2614 } 2615 2616 /* 2617 * Start the nfsiod workqueues 2618 */ 2619 static int nfsiod_start(void) 2620 { 2621 dprintk("RPC: creating workqueue nfsiod\n"); 2622 nfsiod_workqueue = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM | WQ_UNBOUND, 0); 2623 if (nfsiod_workqueue == NULL) 2624 return -ENOMEM; 2625 #if IS_ENABLED(CONFIG_NFS_LOCALIO) 2626 /* 2627 * localio writes need to use a normal (non-memreclaim) workqueue. 2628 * When we start getting low on space, XFS goes and calls flush_work() on 2629 * a non-memreclaim work queue, which causes a priority inversion problem. 2630 */ 2631 dprintk("RPC: creating workqueue nfslocaliod\n"); 2632 nfslocaliod_workqueue = alloc_workqueue("nfslocaliod", WQ_UNBOUND, 0); 2633 if (unlikely(nfslocaliod_workqueue == NULL)) { 2634 nfsiod_stop(); 2635 return -ENOMEM; 2636 } 2637 #endif /* CONFIG_NFS_LOCALIO */ 2638 return 0; 2639 } 2640 2641 unsigned int nfs_net_id; 2642 EXPORT_SYMBOL_GPL(nfs_net_id); 2643 2644 static int nfs_net_init(struct net *net) 2645 { 2646 struct nfs_net *nn = net_generic(net, nfs_net_id); 2647 int err; 2648 2649 nfs_clients_init(net); 2650 2651 if (!rpc_proc_register(net, &nn->rpcstats)) { 2652 err = -ENOMEM; 2653 goto err_proc_rpc; 2654 } 2655 2656 err = nfs_fs_proc_net_init(net); 2657 if (err) 2658 goto err_proc_nfs; 2659 2660 return 0; 2661 2662 err_proc_nfs: 2663 rpc_proc_unregister(net, "nfs"); 2664 err_proc_rpc: 2665 nfs_clients_exit(net); 2666 return err; 2667 } 2668 2669 static void nfs_net_exit(struct net *net) 2670 { 2671 rpc_proc_unregister(net, "nfs"); 2672 nfs_fs_proc_net_exit(net); 2673 nfs_clients_exit(net); 2674 } 2675 2676 static struct pernet_operations nfs_net_ops = { 2677 .init = nfs_net_init, 2678 .exit = nfs_net_exit, 2679 .id = &nfs_net_id, 2680 .size = sizeof(struct nfs_net), 2681 }; 2682 2683 #ifdef CONFIG_KEYS 2684 static struct key *nfs_keyring; 2685 2686 static int __init nfs_init_keyring(void) 2687 { 2688 nfs_keyring = keyring_alloc(".nfs", 2689 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 2690 current_cred(), 2691 (KEY_POS_ALL & ~KEY_POS_SETATTR) | 2692 (KEY_USR_ALL & ~KEY_USR_SETATTR), 2693 KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL); 2694 return PTR_ERR_OR_ZERO(nfs_keyring); 2695 } 2696 2697 static void nfs_exit_keyring(void) 2698 { 2699 key_put(nfs_keyring); 2700 } 2701 #else 2702 static inline int nfs_init_keyring(void) 2703 { 2704 return 0; 2705 } 2706 2707 static inline void nfs_exit_keyring(void) 2708 { 2709 } 2710 #endif /* CONFIG_KEYS */ 2711 2712 /* 2713 * Initialize NFS 2714 */ 2715 static int __init init_nfs_fs(void) 2716 { 2717 int err; 2718 2719 err = nfs_init_keyring(); 2720 if (err) 2721 return err; 2722 2723 err = nfs_sysfs_init(); 2724 if (err < 0) 2725 goto out10; 2726 2727 err = register_pernet_subsys(&nfs_net_ops); 2728 if (err < 0) 2729 goto out9; 2730 2731 err = nfsiod_start(); 2732 if (err) 2733 goto out7; 2734 2735 err = nfs_fs_proc_init(); 2736 if (err) 2737 goto out6; 2738 2739 err = nfs_init_nfspagecache(); 2740 if (err) 2741 goto out5; 2742 2743 err = nfs_init_inodecache(); 2744 if (err) 2745 goto out4; 2746 2747 err = nfs_init_readpagecache(); 2748 if (err) 2749 goto out3; 2750 2751 err = nfs_init_writepagecache(); 2752 if (err) 2753 goto out2; 2754 2755 err = nfs_init_directcache(); 2756 if (err) 2757 goto out1; 2758 2759 err = register_nfs_fs(); 2760 if (err) 2761 goto out0; 2762 2763 return 0; 2764 out0: 2765 nfs_destroy_directcache(); 2766 out1: 2767 nfs_destroy_writepagecache(); 2768 out2: 2769 nfs_destroy_readpagecache(); 2770 out3: 2771 nfs_destroy_inodecache(); 2772 out4: 2773 nfs_destroy_nfspagecache(); 2774 out5: 2775 nfs_fs_proc_exit(); 2776 out6: 2777 nfsiod_stop(); 2778 out7: 2779 unregister_pernet_subsys(&nfs_net_ops); 2780 out9: 2781 nfs_sysfs_exit(); 2782 out10: 2783 nfs_exit_keyring(); 2784 return err; 2785 } 2786 2787 static void __exit exit_nfs_fs(void) 2788 { 2789 nfs_destroy_directcache(); 2790 nfs_destroy_writepagecache(); 2791 nfs_destroy_readpagecache(); 2792 nfs_destroy_inodecache(); 2793 nfs_destroy_nfspagecache(); 2794 unregister_pernet_subsys(&nfs_net_ops); 2795 unregister_nfs_fs(); 2796 nfs_fs_proc_exit(); 2797 nfsiod_stop(); 2798 nfs_sysfs_exit(); 2799 nfs_exit_keyring(); 2800 } 2801 2802 /* Not quite true; I just maintain it */ 2803 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 2804 MODULE_DESCRIPTION("NFS client support"); 2805 MODULE_LICENSE("GPL"); 2806 module_param(enable_ino64, bool, 0644); 2807 2808 module_init(init_nfs_fs) 2809 module_exit(exit_nfs_fs) 2810