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