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->i_state & 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 } 1393 1394 status = -ENOMEM; 1395 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode)); 1396 if (fattr == NULL) 1397 goto out; 1398 1399 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE); 1400 1401 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, inode); 1402 if (status != 0) { 1403 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n", 1404 inode->i_sb->s_id, 1405 (unsigned long long)NFS_FILEID(inode), status); 1406 switch (status) { 1407 case -ETIMEDOUT: 1408 /* A soft timeout occurred. Use cached information? */ 1409 if (server->flags & NFS_MOUNT_SOFTREVAL) 1410 status = 0; 1411 break; 1412 case -ESTALE: 1413 if (!S_ISDIR(inode->i_mode)) 1414 nfs_set_inode_stale(inode); 1415 else 1416 nfs_zap_caches(inode); 1417 } 1418 goto out; 1419 } 1420 1421 status = nfs_refresh_inode(inode, fattr); 1422 if (status) { 1423 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n", 1424 inode->i_sb->s_id, 1425 (unsigned long long)NFS_FILEID(inode), status); 1426 goto out; 1427 } 1428 1429 if (nfsi->cache_validity & NFS_INO_INVALID_ACL) 1430 nfs_zap_acl_cache(inode); 1431 1432 nfs_setsecurity(inode, fattr); 1433 1434 dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n", 1435 inode->i_sb->s_id, 1436 (unsigned long long)NFS_FILEID(inode)); 1437 1438 out: 1439 nfs_free_fattr(fattr); 1440 trace_nfs_revalidate_inode_exit(inode, status); 1441 return status; 1442 } 1443 1444 int nfs_attribute_cache_expired(struct inode *inode) 1445 { 1446 if (nfs_have_delegated_attributes(inode)) 1447 return 0; 1448 return nfs_attribute_timeout(inode); 1449 } 1450 1451 /** 1452 * nfs_revalidate_inode - Revalidate the inode attributes 1453 * @inode: pointer to inode struct 1454 * @flags: cache flags to check 1455 * 1456 * Updates inode attribute information by retrieving the data from the server. 1457 */ 1458 int nfs_revalidate_inode(struct inode *inode, unsigned long flags) 1459 { 1460 if (!nfs_check_cache_invalid(inode, flags)) 1461 return NFS_STALE(inode) ? -ESTALE : 0; 1462 return __nfs_revalidate_inode(NFS_SERVER(inode), inode); 1463 } 1464 EXPORT_SYMBOL_GPL(nfs_revalidate_inode); 1465 1466 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping) 1467 { 1468 int ret; 1469 1470 nfs_fscache_invalidate(inode, 0); 1471 if (mapping->nrpages != 0) { 1472 if (S_ISREG(inode->i_mode)) { 1473 ret = nfs_sync_mapping(mapping); 1474 if (ret < 0) 1475 return ret; 1476 } 1477 ret = invalidate_inode_pages2(mapping); 1478 if (ret < 0) 1479 return ret; 1480 } 1481 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE); 1482 1483 dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n", 1484 inode->i_sb->s_id, 1485 (unsigned long long)NFS_FILEID(inode)); 1486 return 0; 1487 } 1488 1489 /** 1490 * nfs_clear_invalid_mapping - Conditionally clear a mapping 1491 * @mapping: pointer to mapping 1492 * 1493 * If the NFS_INO_INVALID_DATA inode flag is set, clear the mapping. 1494 */ 1495 int nfs_clear_invalid_mapping(struct address_space *mapping) 1496 { 1497 struct inode *inode = mapping->host; 1498 struct nfs_inode *nfsi = NFS_I(inode); 1499 unsigned long *bitlock = &nfsi->flags; 1500 int ret = 0; 1501 1502 /* 1503 * We must clear NFS_INO_INVALID_DATA first to ensure that 1504 * invalidations that come in while we're shooting down the mappings 1505 * are respected. But, that leaves a race window where one revalidator 1506 * can clear the flag, and then another checks it before the mapping 1507 * gets invalidated. Fix that by serializing access to this part of 1508 * the function. 1509 * 1510 * At the same time, we need to allow other tasks to see whether we 1511 * might be in the middle of invalidating the pages, so we only set 1512 * the bit lock here if it looks like we're going to be doing that. 1513 */ 1514 for (;;) { 1515 ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING, 1516 nfs_wait_bit_killable, 1517 TASK_KILLABLE|TASK_FREEZABLE_UNSAFE); 1518 if (ret) 1519 goto out; 1520 smp_rmb(); /* pairs with smp_wmb() below */ 1521 if (test_bit(NFS_INO_INVALIDATING, bitlock)) 1522 continue; 1523 /* pairs with nfs_set_cache_invalid()'s smp_store_release() */ 1524 if (!(smp_load_acquire(&nfsi->cache_validity) & NFS_INO_INVALID_DATA)) 1525 goto out; 1526 /* Slow-path that double-checks with spinlock held */ 1527 spin_lock(&inode->i_lock); 1528 if (test_bit(NFS_INO_INVALIDATING, bitlock)) { 1529 spin_unlock(&inode->i_lock); 1530 continue; 1531 } 1532 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 1533 break; 1534 spin_unlock(&inode->i_lock); 1535 goto out; 1536 } 1537 1538 set_bit(NFS_INO_INVALIDATING, bitlock); 1539 smp_wmb(); 1540 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA; 1541 nfs_ooo_clear(nfsi); 1542 spin_unlock(&inode->i_lock); 1543 trace_nfs_invalidate_mapping_enter(inode); 1544 ret = nfs_invalidate_mapping(inode, mapping); 1545 trace_nfs_invalidate_mapping_exit(inode, ret); 1546 1547 clear_bit_unlock(NFS_INO_INVALIDATING, bitlock); 1548 smp_mb__after_atomic(); 1549 wake_up_bit(bitlock, NFS_INO_INVALIDATING); 1550 out: 1551 return ret; 1552 } 1553 1554 bool nfs_mapping_need_revalidate_inode(struct inode *inode) 1555 { 1556 return nfs_check_cache_invalid(inode, NFS_INO_INVALID_CHANGE) || 1557 NFS_STALE(inode); 1558 } 1559 1560 int nfs_revalidate_mapping_rcu(struct inode *inode) 1561 { 1562 struct nfs_inode *nfsi = NFS_I(inode); 1563 unsigned long *bitlock = &nfsi->flags; 1564 int ret = 0; 1565 1566 if (IS_SWAPFILE(inode)) 1567 goto out; 1568 if (nfs_mapping_need_revalidate_inode(inode)) { 1569 ret = -ECHILD; 1570 goto out; 1571 } 1572 spin_lock(&inode->i_lock); 1573 if (test_bit(NFS_INO_INVALIDATING, bitlock) || 1574 (nfsi->cache_validity & NFS_INO_INVALID_DATA)) 1575 ret = -ECHILD; 1576 spin_unlock(&inode->i_lock); 1577 out: 1578 return ret; 1579 } 1580 1581 /** 1582 * nfs_revalidate_mapping - Revalidate the pagecache 1583 * @inode: pointer to host inode 1584 * @mapping: pointer to mapping 1585 */ 1586 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) 1587 { 1588 /* swapfiles are not supposed to be shared. */ 1589 if (IS_SWAPFILE(inode)) 1590 return 0; 1591 1592 if (nfs_mapping_need_revalidate_inode(inode)) { 1593 int ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 1594 if (ret < 0) 1595 return ret; 1596 } 1597 1598 return nfs_clear_invalid_mapping(mapping); 1599 } 1600 1601 static bool nfs_file_has_writers(struct nfs_inode *nfsi) 1602 { 1603 struct inode *inode = &nfsi->vfs_inode; 1604 1605 if (!S_ISREG(inode->i_mode)) 1606 return false; 1607 if (list_empty(&nfsi->open_files)) 1608 return false; 1609 return inode_is_open_for_write(inode); 1610 } 1611 1612 static bool nfs_file_has_buffered_writers(struct nfs_inode *nfsi) 1613 { 1614 return nfs_file_has_writers(nfsi) && nfs_file_io_is_buffered(nfsi); 1615 } 1616 1617 static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1618 { 1619 struct timespec64 ts; 1620 1621 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE) 1622 && (fattr->valid & NFS_ATTR_FATTR_CHANGE) 1623 && inode_eq_iversion_raw(inode, fattr->pre_change_attr)) { 1624 inode_set_iversion_raw(inode, fattr->change_attr); 1625 if (S_ISDIR(inode->i_mode)) 1626 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA); 1627 else if (nfs_server_capable(inode, NFS_CAP_XATTR)) 1628 nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR); 1629 } 1630 /* If we have atomic WCC data, we may update some attributes */ 1631 ts = inode_get_ctime(inode); 1632 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME) 1633 && (fattr->valid & NFS_ATTR_FATTR_CTIME) 1634 && timespec64_equal(&ts, &fattr->pre_ctime)) { 1635 inode_set_ctime_to_ts(inode, fattr->ctime); 1636 } 1637 1638 ts = inode_get_mtime(inode); 1639 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME) 1640 && (fattr->valid & NFS_ATTR_FATTR_MTIME) 1641 && timespec64_equal(&ts, &fattr->pre_mtime)) { 1642 inode_set_mtime_to_ts(inode, fattr->mtime); 1643 } 1644 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE) 1645 && (fattr->valid & NFS_ATTR_FATTR_SIZE) 1646 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size) 1647 && !nfs_have_writebacks(inode)) { 1648 trace_nfs_size_wcc(inode, fattr->size); 1649 i_size_write(inode, nfs_size_to_loff_t(fattr->size)); 1650 } 1651 } 1652 1653 /** 1654 * nfs_check_inode_attributes - verify consistency of the inode attribute cache 1655 * @inode: pointer to inode 1656 * @fattr: updated attributes 1657 * 1658 * Verifies the attribute cache. If we have just changed the attributes, 1659 * so that fattr carries weak cache consistency data, then it may 1660 * also update the ctime/mtime/change_attribute. 1661 */ 1662 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr) 1663 { 1664 struct nfs_inode *nfsi = NFS_I(inode); 1665 loff_t cur_size, new_isize; 1666 unsigned long invalid = 0; 1667 struct timespec64 ts; 1668 1669 if (nfs_have_delegated_attributes(inode)) 1670 return 0; 1671 1672 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) { 1673 /* Only a mounted-on-fileid? Just exit */ 1674 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) 1675 return 0; 1676 /* Has the inode gone and changed behind our back? */ 1677 } else if (nfsi->fileid != fattr->fileid) { 1678 /* Is this perhaps the mounted-on fileid? */ 1679 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) && 1680 nfsi->fileid == fattr->mounted_on_fileid) 1681 return 0; 1682 return -ESTALE; 1683 } 1684 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) 1685 return -ESTALE; 1686 1687 1688 if (!nfs_file_has_buffered_writers(nfsi)) { 1689 /* Verify a few of the more important attributes */ 1690 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && !inode_eq_iversion_raw(inode, fattr->change_attr)) 1691 invalid |= NFS_INO_INVALID_CHANGE; 1692 1693 ts = inode_get_mtime(inode); 1694 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec64_equal(&ts, &fattr->mtime)) 1695 invalid |= NFS_INO_INVALID_MTIME; 1696 1697 ts = inode_get_ctime(inode); 1698 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) && !timespec64_equal(&ts, &fattr->ctime)) 1699 invalid |= NFS_INO_INVALID_CTIME; 1700 1701 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 1702 cur_size = i_size_read(inode); 1703 new_isize = nfs_size_to_loff_t(fattr->size); 1704 if (cur_size != new_isize) 1705 invalid |= NFS_INO_INVALID_SIZE; 1706 } 1707 } 1708 1709 /* Have any file permissions changed? */ 1710 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) 1711 invalid |= NFS_INO_INVALID_MODE; 1712 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid)) 1713 invalid |= NFS_INO_INVALID_OTHER; 1714 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid)) 1715 invalid |= NFS_INO_INVALID_OTHER; 1716 1717 /* Has the link count changed? */ 1718 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink) 1719 invalid |= NFS_INO_INVALID_NLINK; 1720 1721 ts = inode_get_atime(inode); 1722 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec64_equal(&ts, &fattr->atime)) 1723 invalid |= NFS_INO_INVALID_ATIME; 1724 1725 if (invalid != 0) 1726 nfs_set_cache_invalid(inode, invalid); 1727 1728 nfsi->read_cache_jiffies = fattr->time_start; 1729 return 0; 1730 } 1731 1732 static atomic_long_t nfs_attr_generation_counter; 1733 1734 static unsigned long nfs_read_attr_generation_counter(void) 1735 { 1736 return atomic_long_read(&nfs_attr_generation_counter); 1737 } 1738 1739 unsigned long nfs_inc_attr_generation_counter(void) 1740 { 1741 return atomic_long_inc_return(&nfs_attr_generation_counter); 1742 } 1743 EXPORT_SYMBOL_GPL(nfs_inc_attr_generation_counter); 1744 1745 void nfs_fattr_init(struct nfs_fattr *fattr) 1746 { 1747 fattr->valid = 0; 1748 fattr->time_start = jiffies; 1749 fattr->gencount = nfs_inc_attr_generation_counter(); 1750 fattr->owner_name = NULL; 1751 fattr->group_name = NULL; 1752 fattr->mdsthreshold = NULL; 1753 } 1754 EXPORT_SYMBOL_GPL(nfs_fattr_init); 1755 1756 /** 1757 * nfs_fattr_set_barrier 1758 * @fattr: attributes 1759 * 1760 * Used to set a barrier after an attribute was updated. This 1761 * barrier ensures that older attributes from RPC calls that may 1762 * have raced with our update cannot clobber these new values. 1763 * Note that you are still responsible for ensuring that other 1764 * operations which change the attribute on the server do not 1765 * collide. 1766 */ 1767 void nfs_fattr_set_barrier(struct nfs_fattr *fattr) 1768 { 1769 fattr->gencount = nfs_inc_attr_generation_counter(); 1770 } 1771 1772 struct nfs_fattr *nfs_alloc_fattr(void) 1773 { 1774 struct nfs_fattr *fattr; 1775 1776 fattr = kmalloc(sizeof(*fattr), GFP_KERNEL); 1777 if (fattr != NULL) { 1778 nfs_fattr_init(fattr); 1779 fattr->label = NULL; 1780 } 1781 return fattr; 1782 } 1783 EXPORT_SYMBOL_GPL(nfs_alloc_fattr); 1784 1785 struct nfs_fattr *nfs_alloc_fattr_with_label(struct nfs_server *server) 1786 { 1787 struct nfs_fattr *fattr = nfs_alloc_fattr(); 1788 1789 if (!fattr) 1790 return NULL; 1791 1792 fattr->label = nfs4_label_alloc(server, GFP_KERNEL); 1793 if (IS_ERR(fattr->label)) { 1794 kfree(fattr); 1795 return NULL; 1796 } 1797 1798 return fattr; 1799 } 1800 EXPORT_SYMBOL_GPL(nfs_alloc_fattr_with_label); 1801 1802 struct nfs_fh *nfs_alloc_fhandle(void) 1803 { 1804 struct nfs_fh *fh; 1805 1806 fh = kmalloc(sizeof(struct nfs_fh), GFP_KERNEL); 1807 if (fh != NULL) 1808 fh->size = 0; 1809 return fh; 1810 } 1811 EXPORT_SYMBOL_GPL(nfs_alloc_fhandle); 1812 1813 #ifdef NFS_DEBUG 1814 /* 1815 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle 1816 * in the same way that wireshark does 1817 * 1818 * @fh: file handle 1819 * 1820 * For debugging only. 1821 */ 1822 u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh) 1823 { 1824 /* wireshark uses 32-bit AUTODIN crc and does a bitwise 1825 * not on the result */ 1826 return nfs_fhandle_hash(fh); 1827 } 1828 EXPORT_SYMBOL_GPL(_nfs_display_fhandle_hash); 1829 1830 /* 1831 * _nfs_display_fhandle - display an NFS file handle on the console 1832 * 1833 * @fh: file handle to display 1834 * @caption: display caption 1835 * 1836 * For debugging only. 1837 */ 1838 void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption) 1839 { 1840 unsigned short i; 1841 1842 if (fh == NULL || fh->size == 0) { 1843 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh); 1844 return; 1845 } 1846 1847 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n", 1848 caption, fh, fh->size, _nfs_display_fhandle_hash(fh)); 1849 for (i = 0; i < fh->size; i += 16) { 1850 __be32 *pos = (__be32 *)&fh->data[i]; 1851 1852 switch ((fh->size - i - 1) >> 2) { 1853 case 0: 1854 printk(KERN_DEFAULT " %08x\n", 1855 be32_to_cpup(pos)); 1856 break; 1857 case 1: 1858 printk(KERN_DEFAULT " %08x %08x\n", 1859 be32_to_cpup(pos), be32_to_cpup(pos + 1)); 1860 break; 1861 case 2: 1862 printk(KERN_DEFAULT " %08x %08x %08x\n", 1863 be32_to_cpup(pos), be32_to_cpup(pos + 1), 1864 be32_to_cpup(pos + 2)); 1865 break; 1866 default: 1867 printk(KERN_DEFAULT " %08x %08x %08x %08x\n", 1868 be32_to_cpup(pos), be32_to_cpup(pos + 1), 1869 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3)); 1870 } 1871 } 1872 } 1873 EXPORT_SYMBOL_GPL(_nfs_display_fhandle); 1874 #endif 1875 1876 /** 1877 * nfs_inode_attrs_cmp_generic - compare attributes 1878 * @fattr: attributes 1879 * @inode: pointer to inode 1880 * 1881 * Attempt to divine whether or not an RPC call reply carrying stale 1882 * attributes got scheduled after another call carrying updated ones. 1883 * Note also the check for wraparound of 'attr_gencount' 1884 * 1885 * The function returns '1' if it thinks the attributes in @fattr are 1886 * more recent than the ones cached in @inode. Otherwise it returns 1887 * the value '0'. 1888 */ 1889 static int nfs_inode_attrs_cmp_generic(const struct nfs_fattr *fattr, 1890 const struct inode *inode) 1891 { 1892 unsigned long attr_gencount = NFS_I(inode)->attr_gencount; 1893 1894 return (long)(fattr->gencount - attr_gencount) > 0 || 1895 (long)(attr_gencount - nfs_read_attr_generation_counter()) > 0; 1896 } 1897 1898 /** 1899 * nfs_inode_attrs_cmp_monotonic - compare attributes 1900 * @fattr: attributes 1901 * @inode: pointer to inode 1902 * 1903 * Attempt to divine whether or not an RPC call reply carrying stale 1904 * attributes got scheduled after another call carrying updated ones. 1905 * 1906 * We assume that the server observes monotonic semantics for 1907 * the change attribute, so a larger value means that the attributes in 1908 * @fattr are more recent, in which case the function returns the 1909 * value '1'. 1910 * A return value of '0' indicates no measurable change 1911 * A return value of '-1' means that the attributes in @inode are 1912 * more recent. 1913 */ 1914 static int nfs_inode_attrs_cmp_monotonic(const struct nfs_fattr *fattr, 1915 const struct inode *inode) 1916 { 1917 s64 diff = fattr->change_attr - inode_peek_iversion_raw(inode); 1918 if (diff > 0) 1919 return 1; 1920 return diff == 0 ? 0 : -1; 1921 } 1922 1923 /** 1924 * nfs_inode_attrs_cmp_strict_monotonic - compare attributes 1925 * @fattr: attributes 1926 * @inode: pointer to inode 1927 * 1928 * Attempt to divine whether or not an RPC call reply carrying stale 1929 * attributes got scheduled after another call carrying updated ones. 1930 * 1931 * We assume that the server observes strictly monotonic semantics for 1932 * the change attribute, so a larger value means that the attributes in 1933 * @fattr are more recent, in which case the function returns the 1934 * value '1'. 1935 * A return value of '-1' means that the attributes in @inode are 1936 * more recent or unchanged. 1937 */ 1938 static int nfs_inode_attrs_cmp_strict_monotonic(const struct nfs_fattr *fattr, 1939 const struct inode *inode) 1940 { 1941 return nfs_inode_attrs_cmp_monotonic(fattr, inode) > 0 ? 1 : -1; 1942 } 1943 1944 /** 1945 * nfs_inode_attrs_cmp - compare attributes 1946 * @fattr: attributes 1947 * @inode: pointer to inode 1948 * 1949 * This function returns '1' if it thinks the attributes in @fattr are 1950 * more recent than the ones cached in @inode. It returns '-1' if 1951 * the attributes in @inode are more recent than the ones in @fattr, 1952 * and it returns 0 if not sure. 1953 */ 1954 static int nfs_inode_attrs_cmp(const struct nfs_fattr *fattr, 1955 const struct inode *inode) 1956 { 1957 if (nfs_inode_attrs_cmp_generic(fattr, inode) > 0) 1958 return 1; 1959 switch (NFS_SERVER(inode)->change_attr_type) { 1960 case NFS4_CHANGE_TYPE_IS_UNDEFINED: 1961 break; 1962 case NFS4_CHANGE_TYPE_IS_TIME_METADATA: 1963 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE)) 1964 break; 1965 return nfs_inode_attrs_cmp_monotonic(fattr, inode); 1966 default: 1967 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE)) 1968 break; 1969 return nfs_inode_attrs_cmp_strict_monotonic(fattr, inode); 1970 } 1971 return 0; 1972 } 1973 1974 /** 1975 * nfs_inode_finish_partial_attr_update - complete a previous inode update 1976 * @fattr: attributes 1977 * @inode: pointer to inode 1978 * 1979 * Returns '1' if the last attribute update left the inode cached 1980 * attributes in a partially unrevalidated state, and @fattr 1981 * matches the change attribute of that partial update. 1982 * Otherwise returns '0'. 1983 */ 1984 static int nfs_inode_finish_partial_attr_update(const struct nfs_fattr *fattr, 1985 const struct inode *inode) 1986 { 1987 const unsigned long check_valid = 1988 NFS_INO_INVALID_ATIME | NFS_INO_INVALID_CTIME | 1989 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE | 1990 NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_OTHER | 1991 NFS_INO_INVALID_NLINK | NFS_INO_INVALID_BTIME; 1992 unsigned long cache_validity = NFS_I(inode)->cache_validity; 1993 enum nfs4_change_attr_type ctype = NFS_SERVER(inode)->change_attr_type; 1994 1995 if (ctype != NFS4_CHANGE_TYPE_IS_UNDEFINED && 1996 !(cache_validity & NFS_INO_INVALID_CHANGE) && 1997 (cache_validity & check_valid) != 0 && 1998 (fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 1999 nfs_inode_attrs_cmp_monotonic(fattr, inode) == 0) 2000 return 1; 2001 return 0; 2002 } 2003 2004 static void nfs_ooo_merge(struct nfs_inode *nfsi, 2005 u64 start, u64 end) 2006 { 2007 int i, cnt; 2008 2009 if (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER) 2010 /* No point merging anything */ 2011 return; 2012 2013 if (!nfsi->ooo) { 2014 nfsi->ooo = kmalloc(sizeof(*nfsi->ooo), GFP_ATOMIC); 2015 if (!nfsi->ooo) { 2016 nfsi->cache_validity |= NFS_INO_DATA_INVAL_DEFER; 2017 return; 2018 } 2019 nfsi->ooo->cnt = 0; 2020 } 2021 2022 /* add this range, merging if possible */ 2023 cnt = nfsi->ooo->cnt; 2024 for (i = 0; i < cnt; i++) { 2025 if (end == nfsi->ooo->gap[i].start) 2026 end = nfsi->ooo->gap[i].end; 2027 else if (start == nfsi->ooo->gap[i].end) 2028 start = nfsi->ooo->gap[i].start; 2029 else 2030 continue; 2031 /* Remove 'i' from table and loop to insert the new range */ 2032 cnt -= 1; 2033 nfsi->ooo->gap[i] = nfsi->ooo->gap[cnt]; 2034 i = -1; 2035 } 2036 if (start != end) { 2037 if (cnt >= ARRAY_SIZE(nfsi->ooo->gap)) { 2038 nfsi->cache_validity |= NFS_INO_DATA_INVAL_DEFER; 2039 kfree(nfsi->ooo); 2040 nfsi->ooo = NULL; 2041 return; 2042 } 2043 nfsi->ooo->gap[cnt].start = start; 2044 nfsi->ooo->gap[cnt].end = end; 2045 cnt += 1; 2046 } 2047 nfsi->ooo->cnt = cnt; 2048 } 2049 2050 static void nfs_ooo_record(struct nfs_inode *nfsi, 2051 struct nfs_fattr *fattr) 2052 { 2053 /* This reply was out-of-order, so record in the 2054 * pre/post change id, possibly cancelling 2055 * gaps created when iversion was jumpped forward. 2056 */ 2057 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) && 2058 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE)) 2059 nfs_ooo_merge(nfsi, 2060 fattr->change_attr, 2061 fattr->pre_change_attr); 2062 } 2063 2064 static int nfs_refresh_inode_locked(struct inode *inode, 2065 struct nfs_fattr *fattr) 2066 { 2067 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode); 2068 int ret = 0; 2069 2070 trace_nfs_refresh_inode_enter(inode); 2071 2072 if (attr_cmp > 0 || nfs_inode_finish_partial_attr_update(fattr, inode)) 2073 ret = nfs_update_inode(inode, fattr); 2074 else { 2075 nfs_ooo_record(NFS_I(inode), fattr); 2076 2077 if (attr_cmp == 0) 2078 ret = nfs_check_inode_attributes(inode, fattr); 2079 } 2080 2081 trace_nfs_refresh_inode_exit(inode, ret); 2082 return ret; 2083 } 2084 2085 /** 2086 * nfs_refresh_inode - try to update the inode attribute cache 2087 * @inode: pointer to inode 2088 * @fattr: updated attributes 2089 * 2090 * Check that an RPC call that returned attributes has not overlapped with 2091 * other recent updates of the inode metadata, then decide whether it is 2092 * safe to do a full update of the inode attributes, or whether just to 2093 * call nfs_check_inode_attributes. 2094 */ 2095 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr) 2096 { 2097 int status; 2098 2099 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 2100 return 0; 2101 spin_lock(&inode->i_lock); 2102 status = nfs_refresh_inode_locked(inode, fattr); 2103 spin_unlock(&inode->i_lock); 2104 2105 return status; 2106 } 2107 EXPORT_SYMBOL_GPL(nfs_refresh_inode); 2108 2109 static int nfs_post_op_update_inode_locked(struct inode *inode, 2110 struct nfs_fattr *fattr, unsigned int invalid) 2111 { 2112 if (S_ISDIR(inode->i_mode)) 2113 invalid |= NFS_INO_INVALID_DATA; 2114 nfs_set_cache_invalid(inode, invalid); 2115 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 2116 return 0; 2117 return nfs_refresh_inode_locked(inode, fattr); 2118 } 2119 2120 /** 2121 * nfs_post_op_update_inode - try to update the inode attribute cache 2122 * @inode: pointer to inode 2123 * @fattr: updated attributes 2124 * 2125 * After an operation that has changed the inode metadata, mark the 2126 * attribute cache as being invalid, then try to update it. 2127 * 2128 * NB: if the server didn't return any post op attributes, this 2129 * function will force the retrieval of attributes before the next 2130 * NFS request. Thus it should be used only for operations that 2131 * are expected to change one or more attributes, to avoid 2132 * unnecessary NFS requests and trips through nfs_update_inode(). 2133 */ 2134 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr) 2135 { 2136 int status; 2137 2138 spin_lock(&inode->i_lock); 2139 nfs_fattr_set_barrier(fattr); 2140 status = nfs_post_op_update_inode_locked(inode, fattr, 2141 NFS_INO_INVALID_CHANGE 2142 | NFS_INO_INVALID_CTIME 2143 | NFS_INO_REVAL_FORCED); 2144 spin_unlock(&inode->i_lock); 2145 2146 return status; 2147 } 2148 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode); 2149 2150 /** 2151 * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache 2152 * @inode: pointer to inode 2153 * @fattr: updated attributes 2154 * 2155 * After an operation that has changed the inode metadata, mark the 2156 * attribute cache as being invalid, then try to update it. Fake up 2157 * weak cache consistency data, if none exist. 2158 * 2159 * This function is mainly designed to be used by the ->write_done() functions. 2160 */ 2161 int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr) 2162 { 2163 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode); 2164 int status; 2165 2166 /* Don't do a WCC update if these attributes are already stale */ 2167 if (attr_cmp < 0) 2168 return 0; 2169 if ((fattr->valid & NFS_ATTR_FATTR) == 0 || !attr_cmp) { 2170 /* Record the pre/post change info before clearing PRECHANGE */ 2171 nfs_ooo_record(NFS_I(inode), fattr); 2172 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE 2173 | NFS_ATTR_FATTR_PRESIZE 2174 | NFS_ATTR_FATTR_PREMTIME 2175 | NFS_ATTR_FATTR_PRECTIME); 2176 goto out_noforce; 2177 } 2178 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 2179 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) { 2180 fattr->pre_change_attr = inode_peek_iversion_raw(inode); 2181 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE; 2182 } 2183 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 && 2184 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) { 2185 fattr->pre_ctime = inode_get_ctime(inode); 2186 fattr->valid |= NFS_ATTR_FATTR_PRECTIME; 2187 } 2188 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 && 2189 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) { 2190 fattr->pre_mtime = inode_get_mtime(inode); 2191 fattr->valid |= NFS_ATTR_FATTR_PREMTIME; 2192 } 2193 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 && 2194 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) { 2195 fattr->pre_size = i_size_read(inode); 2196 fattr->valid |= NFS_ATTR_FATTR_PRESIZE; 2197 } 2198 out_noforce: 2199 status = nfs_post_op_update_inode_locked(inode, fattr, 2200 NFS_INO_INVALID_CHANGE 2201 | NFS_INO_INVALID_CTIME 2202 | NFS_INO_INVALID_MTIME 2203 | NFS_INO_INVALID_BLOCKS); 2204 return status; 2205 } 2206 2207 /** 2208 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache 2209 * @inode: pointer to inode 2210 * @fattr: updated attributes 2211 * 2212 * After an operation that has changed the inode metadata, mark the 2213 * attribute cache as being invalid, then try to update it. Fake up 2214 * weak cache consistency data, if none exist. 2215 * 2216 * This function is mainly designed to be used by the ->write_done() functions. 2217 */ 2218 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr) 2219 { 2220 int status; 2221 2222 spin_lock(&inode->i_lock); 2223 nfs_fattr_set_barrier(fattr); 2224 status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr); 2225 spin_unlock(&inode->i_lock); 2226 return status; 2227 } 2228 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc); 2229 2230 2231 /* 2232 * Many nfs protocol calls return the new file attributes after 2233 * an operation. Here we update the inode to reflect the state 2234 * of the server's inode. 2235 * 2236 * This is a bit tricky because we have to make sure all dirty pages 2237 * have been sent off to the server before calling invalidate_inode_pages. 2238 * To make sure no other process adds more write requests while we try 2239 * our best to flush them, we make them sleep during the attribute refresh. 2240 * 2241 * A very similar scenario holds for the dir cache. 2242 */ 2243 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 2244 { 2245 struct nfs_server *server = NFS_SERVER(inode); 2246 struct nfs_inode *nfsi = NFS_I(inode); 2247 loff_t cur_isize, new_isize; 2248 u64 fattr_supported = server->fattr_valid; 2249 unsigned long invalid = 0; 2250 unsigned long now = jiffies; 2251 unsigned long save_cache_validity; 2252 bool have_writers = nfs_file_has_buffered_writers(nfsi); 2253 bool cache_revalidated = true; 2254 bool attr_changed = false; 2255 bool have_delegation; 2256 2257 dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%llx)\n", 2258 __func__, inode->i_sb->s_id, inode->i_ino, 2259 nfs_display_fhandle_hash(NFS_FH(inode)), 2260 icount_read(inode), fattr->valid); 2261 2262 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) { 2263 /* Only a mounted-on-fileid? Just exit */ 2264 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) 2265 return 0; 2266 /* Has the inode gone and changed behind our back? */ 2267 } else if (nfsi->fileid != fattr->fileid) { 2268 /* Is this perhaps the mounted-on fileid? */ 2269 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) && 2270 nfsi->fileid == fattr->mounted_on_fileid) 2271 return 0; 2272 printk(KERN_ERR "NFS: server %s error: fileid changed\n" 2273 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n", 2274 NFS_SERVER(inode)->nfs_client->cl_hostname, 2275 inode->i_sb->s_id, (long long)nfsi->fileid, 2276 (long long)fattr->fileid); 2277 goto out_err; 2278 } 2279 2280 /* 2281 * Make sure the inode's type hasn't changed. 2282 */ 2283 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) { 2284 /* 2285 * Big trouble! The inode has become a different object. 2286 */ 2287 printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n", 2288 __func__, inode->i_ino, inode->i_mode, fattr->mode); 2289 goto out_err; 2290 } 2291 2292 /* Update the fsid? */ 2293 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) && 2294 !nfs_fsid_equal(&server->fsid, &fattr->fsid) && 2295 !IS_AUTOMOUNT(inode)) 2296 server->fsid = fattr->fsid; 2297 2298 /* Save the delegation state before clearing cache_validity */ 2299 have_delegation = nfs_have_delegated_attributes(inode); 2300 2301 /* 2302 * Update the read time so we don't revalidate too often. 2303 */ 2304 nfsi->read_cache_jiffies = fattr->time_start; 2305 2306 /* Fix up any delegated attributes in the struct nfs_fattr */ 2307 nfs_fattr_fixup_delegated(inode, fattr); 2308 2309 save_cache_validity = nfsi->cache_validity; 2310 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR 2311 | NFS_INO_INVALID_ATIME 2312 | NFS_INO_REVAL_FORCED 2313 | NFS_INO_INVALID_BLOCKS); 2314 2315 /* Do atomic weak cache consistency updates */ 2316 nfs_wcc_update_inode(inode, fattr); 2317 2318 if (pnfs_layoutcommit_outstanding(inode)) { 2319 nfsi->cache_validity |= 2320 save_cache_validity & 2321 (NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME | 2322 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE | 2323 NFS_INO_INVALID_BLOCKS); 2324 cache_revalidated = false; 2325 } 2326 2327 /* More cache consistency checks */ 2328 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) { 2329 if (!have_writers && nfsi->ooo && nfsi->ooo->cnt == 1 && 2330 nfsi->ooo->gap[0].end == inode_peek_iversion_raw(inode)) { 2331 /* There is one remaining gap that hasn't been 2332 * merged into iversion - do that now. 2333 */ 2334 inode_set_iversion_raw(inode, nfsi->ooo->gap[0].start); 2335 kfree(nfsi->ooo); 2336 nfsi->ooo = NULL; 2337 } 2338 if (!inode_eq_iversion_raw(inode, fattr->change_attr)) { 2339 /* Could it be a race with writeback? */ 2340 if (!(have_writers || have_delegation)) { 2341 invalid |= NFS_INO_INVALID_DATA 2342 | NFS_INO_INVALID_ACCESS 2343 | NFS_INO_INVALID_ACL 2344 | NFS_INO_INVALID_XATTR; 2345 /* Force revalidate of all attributes */ 2346 save_cache_validity |= NFS_INO_INVALID_CTIME 2347 | NFS_INO_INVALID_MTIME 2348 | NFS_INO_INVALID_SIZE 2349 | NFS_INO_INVALID_BLOCKS 2350 | NFS_INO_INVALID_NLINK 2351 | NFS_INO_INVALID_MODE 2352 | NFS_INO_INVALID_OTHER 2353 | NFS_INO_INVALID_BTIME; 2354 if (S_ISDIR(inode->i_mode)) 2355 nfs_force_lookup_revalidate(inode); 2356 attr_changed = true; 2357 dprintk("NFS: change_attr change on server for file %s/%ld\n", 2358 inode->i_sb->s_id, 2359 inode->i_ino); 2360 } else if (!have_delegation) { 2361 nfs_ooo_record(nfsi, fattr); 2362 nfs_ooo_merge(nfsi, inode_peek_iversion_raw(inode), 2363 fattr->change_attr); 2364 } 2365 inode_set_iversion_raw(inode, fattr->change_attr); 2366 } 2367 } else { 2368 nfsi->cache_validity |= 2369 save_cache_validity & NFS_INO_INVALID_CHANGE; 2370 if (!have_delegation || 2371 (nfsi->cache_validity & NFS_INO_INVALID_CHANGE) != 0) 2372 cache_revalidated = false; 2373 } 2374 2375 if (fattr->valid & NFS_ATTR_FATTR_MTIME) 2376 inode_set_mtime_to_ts(inode, fattr->mtime); 2377 else if (fattr_supported & NFS_ATTR_FATTR_MTIME) 2378 nfsi->cache_validity |= 2379 save_cache_validity & NFS_INO_INVALID_MTIME; 2380 2381 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 2382 inode_set_ctime_to_ts(inode, fattr->ctime); 2383 else if (fattr_supported & NFS_ATTR_FATTR_CTIME) 2384 nfsi->cache_validity |= 2385 save_cache_validity & NFS_INO_INVALID_CTIME; 2386 2387 if (fattr->valid & NFS_ATTR_FATTR_BTIME) 2388 nfsi->btime = fattr->btime; 2389 else if (fattr_supported & NFS_ATTR_FATTR_BTIME) 2390 nfsi->cache_validity |= 2391 save_cache_validity & NFS_INO_INVALID_BTIME; 2392 2393 /* Check if our cached file size is stale */ 2394 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 2395 new_isize = nfs_size_to_loff_t(fattr->size); 2396 cur_isize = i_size_read(inode); 2397 if (new_isize != cur_isize && !have_delegation) { 2398 /* Do we perhaps have any outstanding writes, or has 2399 * the file grown beyond our last write? */ 2400 if (!nfs_have_writebacks(inode) || new_isize > cur_isize) { 2401 trace_nfs_size_update(inode, new_isize); 2402 i_size_write(inode, new_isize); 2403 if (!have_writers) 2404 invalid |= NFS_INO_INVALID_DATA; 2405 } 2406 } 2407 if (new_isize == 0 && 2408 !(fattr->valid & (NFS_ATTR_FATTR_SPACE_USED | 2409 NFS_ATTR_FATTR_BLOCKS_USED))) { 2410 fattr->du.nfs3.used = 0; 2411 fattr->valid |= NFS_ATTR_FATTR_SPACE_USED; 2412 } 2413 } else 2414 nfsi->cache_validity |= 2415 save_cache_validity & NFS_INO_INVALID_SIZE; 2416 2417 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 2418 inode_set_atime_to_ts(inode, fattr->atime); 2419 else if (fattr_supported & NFS_ATTR_FATTR_ATIME) 2420 nfsi->cache_validity |= 2421 save_cache_validity & NFS_INO_INVALID_ATIME; 2422 2423 if (fattr->valid & NFS_ATTR_FATTR_MODE) { 2424 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) { 2425 umode_t newmode = inode->i_mode & S_IFMT; 2426 newmode |= fattr->mode & S_IALLUGO; 2427 inode->i_mode = newmode; 2428 invalid |= NFS_INO_INVALID_ACCESS 2429 | NFS_INO_INVALID_ACL; 2430 } 2431 } else if (fattr_supported & NFS_ATTR_FATTR_MODE) 2432 nfsi->cache_validity |= 2433 save_cache_validity & NFS_INO_INVALID_MODE; 2434 2435 if (fattr->valid & NFS_ATTR_FATTR_OWNER) { 2436 if (!uid_eq(inode->i_uid, fattr->uid)) { 2437 invalid |= NFS_INO_INVALID_ACCESS 2438 | NFS_INO_INVALID_ACL; 2439 inode->i_uid = fattr->uid; 2440 } 2441 } else if (fattr_supported & NFS_ATTR_FATTR_OWNER) 2442 nfsi->cache_validity |= 2443 save_cache_validity & NFS_INO_INVALID_OTHER; 2444 2445 if (fattr->valid & NFS_ATTR_FATTR_GROUP) { 2446 if (!gid_eq(inode->i_gid, fattr->gid)) { 2447 invalid |= NFS_INO_INVALID_ACCESS 2448 | NFS_INO_INVALID_ACL; 2449 inode->i_gid = fattr->gid; 2450 } 2451 } else if (fattr_supported & NFS_ATTR_FATTR_GROUP) 2452 nfsi->cache_validity |= 2453 save_cache_validity & NFS_INO_INVALID_OTHER; 2454 2455 if (fattr->valid & NFS_ATTR_FATTR_NLINK) { 2456 if (inode->i_nlink != fattr->nlink) 2457 set_nlink(inode, fattr->nlink); 2458 } else if (fattr_supported & NFS_ATTR_FATTR_NLINK) 2459 nfsi->cache_validity |= 2460 save_cache_validity & NFS_INO_INVALID_NLINK; 2461 2462 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { 2463 /* 2464 * report the blocks in 512byte units 2465 */ 2466 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 2467 } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED) 2468 nfsi->cache_validity |= 2469 save_cache_validity & NFS_INO_INVALID_BLOCKS; 2470 2471 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) 2472 inode->i_blocks = fattr->du.nfs2.blocks; 2473 else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED) 2474 nfsi->cache_validity |= 2475 save_cache_validity & NFS_INO_INVALID_BLOCKS; 2476 2477 /* Update attrtimeo value if we're out of the unstable period */ 2478 if (attr_changed) { 2479 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 2480 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 2481 nfsi->attrtimeo_timestamp = now; 2482 /* Set barrier to be more recent than all outstanding updates */ 2483 nfsi->attr_gencount = nfs_inc_attr_generation_counter(); 2484 } else { 2485 if (cache_revalidated) { 2486 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, 2487 nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) { 2488 nfsi->attrtimeo <<= 1; 2489 if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode)) 2490 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode); 2491 } 2492 nfsi->attrtimeo_timestamp = now; 2493 } 2494 /* Set the barrier to be more recent than this fattr */ 2495 if ((long)(fattr->gencount - nfsi->attr_gencount) > 0) 2496 nfsi->attr_gencount = fattr->gencount; 2497 } 2498 2499 /* Don't invalidate the data if we were to blame */ 2500 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) 2501 || S_ISLNK(inode->i_mode))) 2502 invalid &= ~NFS_INO_INVALID_DATA; 2503 nfs_set_cache_invalid(inode, invalid); 2504 2505 return 0; 2506 out_err: 2507 /* 2508 * No need to worry about unhashing the dentry, as the 2509 * lookup validation will know that the inode is bad. 2510 * (But we fall through to invalidate the caches.) 2511 */ 2512 nfs_set_inode_stale_locked(inode); 2513 return -ESTALE; 2514 } 2515 2516 struct inode *nfs_alloc_inode(struct super_block *sb) 2517 { 2518 struct nfs_inode *nfsi; 2519 nfsi = alloc_inode_sb(sb, nfs_inode_cachep, GFP_KERNEL); 2520 if (!nfsi) 2521 return NULL; 2522 nfsi->flags = 0UL; 2523 nfsi->cache_validity = 0UL; 2524 nfsi->ooo = NULL; 2525 #if IS_ENABLED(CONFIG_NFS_V4) 2526 nfsi->nfs4_acl = NULL; 2527 #endif /* CONFIG_NFS_V4 */ 2528 #ifdef CONFIG_NFS_V4_2 2529 nfsi->xattr_cache = NULL; 2530 #endif 2531 nfs_netfs_inode_init(nfsi); 2532 2533 return &nfsi->vfs_inode; 2534 } 2535 EXPORT_SYMBOL_GPL(nfs_alloc_inode); 2536 2537 void nfs_free_inode(struct inode *inode) 2538 { 2539 kfree(NFS_I(inode)->ooo); 2540 kmem_cache_free(nfs_inode_cachep, NFS_I(inode)); 2541 } 2542 EXPORT_SYMBOL_GPL(nfs_free_inode); 2543 2544 static inline void nfs4_init_once(struct nfs_inode *nfsi) 2545 { 2546 #if IS_ENABLED(CONFIG_NFS_V4) 2547 INIT_LIST_HEAD(&nfsi->open_states); 2548 nfsi->delegation = NULL; 2549 init_rwsem(&nfsi->rwsem); 2550 nfsi->layout = NULL; 2551 #endif 2552 } 2553 2554 static void init_once(void *foo) 2555 { 2556 struct nfs_inode *nfsi = foo; 2557 2558 inode_init_once(&nfsi->vfs_inode); 2559 INIT_LIST_HEAD(&nfsi->open_files); 2560 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru); 2561 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru); 2562 nfs4_init_once(nfsi); 2563 } 2564 2565 static int __init nfs_init_inodecache(void) 2566 { 2567 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", 2568 sizeof(struct nfs_inode), 2569 0, (SLAB_RECLAIM_ACCOUNT| 2570 SLAB_ACCOUNT), 2571 init_once); 2572 if (nfs_inode_cachep == NULL) 2573 return -ENOMEM; 2574 2575 return 0; 2576 } 2577 2578 static void nfs_destroy_inodecache(void) 2579 { 2580 /* 2581 * Make sure all delayed rcu free inodes are flushed before we 2582 * destroy cache. 2583 */ 2584 rcu_barrier(); 2585 kmem_cache_destroy(nfs_inode_cachep); 2586 } 2587 2588 struct workqueue_struct *nfslocaliod_workqueue; 2589 struct workqueue_struct *nfsiod_workqueue; 2590 EXPORT_SYMBOL_GPL(nfsiod_workqueue); 2591 2592 /* 2593 * Destroy the nfsiod workqueues 2594 */ 2595 static void nfsiod_stop(void) 2596 { 2597 struct workqueue_struct *wq; 2598 2599 wq = nfsiod_workqueue; 2600 if (wq != NULL) { 2601 nfsiod_workqueue = NULL; 2602 destroy_workqueue(wq); 2603 } 2604 #if IS_ENABLED(CONFIG_NFS_LOCALIO) 2605 wq = nfslocaliod_workqueue; 2606 if (wq != NULL) { 2607 nfslocaliod_workqueue = NULL; 2608 destroy_workqueue(wq); 2609 } 2610 #endif /* CONFIG_NFS_LOCALIO */ 2611 } 2612 2613 /* 2614 * Start the nfsiod workqueues 2615 */ 2616 static int nfsiod_start(void) 2617 { 2618 dprintk("RPC: creating workqueue nfsiod\n"); 2619 nfsiod_workqueue = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM | WQ_UNBOUND, 0); 2620 if (nfsiod_workqueue == NULL) 2621 return -ENOMEM; 2622 #if IS_ENABLED(CONFIG_NFS_LOCALIO) 2623 /* 2624 * localio writes need to use a normal (non-memreclaim) workqueue. 2625 * When we start getting low on space, XFS goes and calls flush_work() on 2626 * a non-memreclaim work queue, which causes a priority inversion problem. 2627 */ 2628 dprintk("RPC: creating workqueue nfslocaliod\n"); 2629 nfslocaliod_workqueue = alloc_workqueue("nfslocaliod", WQ_UNBOUND, 0); 2630 if (unlikely(nfslocaliod_workqueue == NULL)) { 2631 nfsiod_stop(); 2632 return -ENOMEM; 2633 } 2634 #endif /* CONFIG_NFS_LOCALIO */ 2635 return 0; 2636 } 2637 2638 unsigned int nfs_net_id; 2639 EXPORT_SYMBOL_GPL(nfs_net_id); 2640 2641 static int nfs_net_init(struct net *net) 2642 { 2643 struct nfs_net *nn = net_generic(net, nfs_net_id); 2644 int err; 2645 2646 nfs_clients_init(net); 2647 2648 if (!rpc_proc_register(net, &nn->rpcstats)) { 2649 err = -ENOMEM; 2650 goto err_proc_rpc; 2651 } 2652 2653 err = nfs_fs_proc_net_init(net); 2654 if (err) 2655 goto err_proc_nfs; 2656 2657 return 0; 2658 2659 err_proc_nfs: 2660 rpc_proc_unregister(net, "nfs"); 2661 err_proc_rpc: 2662 nfs_clients_exit(net); 2663 return err; 2664 } 2665 2666 static void nfs_net_exit(struct net *net) 2667 { 2668 rpc_proc_unregister(net, "nfs"); 2669 nfs_fs_proc_net_exit(net); 2670 nfs_clients_exit(net); 2671 } 2672 2673 static struct pernet_operations nfs_net_ops = { 2674 .init = nfs_net_init, 2675 .exit = nfs_net_exit, 2676 .id = &nfs_net_id, 2677 .size = sizeof(struct nfs_net), 2678 }; 2679 2680 #ifdef CONFIG_KEYS 2681 static struct key *nfs_keyring; 2682 2683 static int __init nfs_init_keyring(void) 2684 { 2685 nfs_keyring = keyring_alloc(".nfs", 2686 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 2687 current_cred(), 2688 (KEY_POS_ALL & ~KEY_POS_SETATTR) | 2689 (KEY_USR_ALL & ~KEY_USR_SETATTR), 2690 KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL); 2691 return PTR_ERR_OR_ZERO(nfs_keyring); 2692 } 2693 2694 static void nfs_exit_keyring(void) 2695 { 2696 key_put(nfs_keyring); 2697 } 2698 #else 2699 static inline int nfs_init_keyring(void) 2700 { 2701 return 0; 2702 } 2703 2704 static inline void nfs_exit_keyring(void) 2705 { 2706 } 2707 #endif /* CONFIG_KEYS */ 2708 2709 /* 2710 * Initialize NFS 2711 */ 2712 static int __init init_nfs_fs(void) 2713 { 2714 int err; 2715 2716 err = nfs_init_keyring(); 2717 if (err) 2718 return err; 2719 2720 err = nfs_sysfs_init(); 2721 if (err < 0) 2722 goto out10; 2723 2724 err = register_pernet_subsys(&nfs_net_ops); 2725 if (err < 0) 2726 goto out9; 2727 2728 err = nfsiod_start(); 2729 if (err) 2730 goto out7; 2731 2732 err = nfs_fs_proc_init(); 2733 if (err) 2734 goto out6; 2735 2736 err = nfs_init_nfspagecache(); 2737 if (err) 2738 goto out5; 2739 2740 err = nfs_init_inodecache(); 2741 if (err) 2742 goto out4; 2743 2744 err = nfs_init_readpagecache(); 2745 if (err) 2746 goto out3; 2747 2748 err = nfs_init_writepagecache(); 2749 if (err) 2750 goto out2; 2751 2752 err = nfs_init_directcache(); 2753 if (err) 2754 goto out1; 2755 2756 err = register_nfs_fs(); 2757 if (err) 2758 goto out0; 2759 2760 return 0; 2761 out0: 2762 nfs_destroy_directcache(); 2763 out1: 2764 nfs_destroy_writepagecache(); 2765 out2: 2766 nfs_destroy_readpagecache(); 2767 out3: 2768 nfs_destroy_inodecache(); 2769 out4: 2770 nfs_destroy_nfspagecache(); 2771 out5: 2772 nfs_fs_proc_exit(); 2773 out6: 2774 nfsiod_stop(); 2775 out7: 2776 unregister_pernet_subsys(&nfs_net_ops); 2777 out9: 2778 nfs_sysfs_exit(); 2779 out10: 2780 nfs_exit_keyring(); 2781 return err; 2782 } 2783 2784 static void __exit exit_nfs_fs(void) 2785 { 2786 nfs_destroy_directcache(); 2787 nfs_destroy_writepagecache(); 2788 nfs_destroy_readpagecache(); 2789 nfs_destroy_inodecache(); 2790 nfs_destroy_nfspagecache(); 2791 unregister_pernet_subsys(&nfs_net_ops); 2792 unregister_nfs_fs(); 2793 nfs_fs_proc_exit(); 2794 nfsiod_stop(); 2795 nfs_sysfs_exit(); 2796 nfs_exit_keyring(); 2797 } 2798 2799 /* Not quite true; I just maintain it */ 2800 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 2801 MODULE_DESCRIPTION("NFS client support"); 2802 MODULE_LICENSE("GPL"); 2803 module_param(enable_ino64, bool, 0644); 2804 2805 module_init(init_nfs_fs) 2806 module_exit(exit_nfs_fs) 2807