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