1 /* 2 * linux/fs/nfs/inode.c 3 * 4 * Copyright (C) 1992 Rick Sladkey 5 * 6 * nfs inode and superblock handling functions 7 * 8 * Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some 9 * experimental NFS changes. Modularisation taken straight from SYS5 fs. 10 * 11 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts. 12 * J.S.Peatfield@damtp.cam.ac.uk 13 * 14 */ 15 16 #include <linux/module.h> 17 #include <linux/init.h> 18 #include <linux/sched.h> 19 #include <linux/time.h> 20 #include <linux/kernel.h> 21 #include <linux/mm.h> 22 #include <linux/string.h> 23 #include <linux/stat.h> 24 #include <linux/errno.h> 25 #include <linux/unistd.h> 26 #include <linux/sunrpc/clnt.h> 27 #include <linux/sunrpc/stats.h> 28 #include <linux/sunrpc/metrics.h> 29 #include <linux/nfs_fs.h> 30 #include <linux/nfs_mount.h> 31 #include <linux/nfs4_mount.h> 32 #include <linux/lockd/bind.h> 33 #include <linux/seq_file.h> 34 #include <linux/mount.h> 35 #include <linux/nfs_idmap.h> 36 #include <linux/vfs.h> 37 #include <linux/inet.h> 38 #include <linux/nfs_xdr.h> 39 40 #include <asm/system.h> 41 #include <asm/uaccess.h> 42 43 #include "nfs4_fs.h" 44 #include "callback.h" 45 #include "delegation.h" 46 #include "iostat.h" 47 #include "internal.h" 48 #include "fscache.h" 49 #include "dns_resolve.h" 50 51 #define NFSDBG_FACILITY NFSDBG_VFS 52 53 #define NFS_64_BIT_INODE_NUMBERS_ENABLED 1 54 55 /* Default is to see 64-bit inode numbers */ 56 static int enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED; 57 58 static void nfs_invalidate_inode(struct inode *); 59 static int nfs_update_inode(struct inode *, struct nfs_fattr *); 60 61 static struct kmem_cache * nfs_inode_cachep; 62 63 static inline unsigned long 64 nfs_fattr_to_ino_t(struct nfs_fattr *fattr) 65 { 66 return nfs_fileid_to_ino_t(fattr->fileid); 67 } 68 69 /** 70 * nfs_wait_bit_killable - helper for functions that are sleeping on bit locks 71 * @word: long word containing the bit lock 72 */ 73 int nfs_wait_bit_killable(void *word) 74 { 75 if (fatal_signal_pending(current)) 76 return -ERESTARTSYS; 77 schedule(); 78 return 0; 79 } 80 81 /** 82 * nfs_compat_user_ino64 - returns the user-visible inode number 83 * @fileid: 64-bit fileid 84 * 85 * This function returns a 32-bit inode number if the boot parameter 86 * nfs.enable_ino64 is zero. 87 */ 88 u64 nfs_compat_user_ino64(u64 fileid) 89 { 90 int ino; 91 92 if (enable_ino64) 93 return fileid; 94 ino = fileid; 95 if (sizeof(ino) < sizeof(fileid)) 96 ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8; 97 return ino; 98 } 99 100 int nfs_write_inode(struct inode *inode, int sync) 101 { 102 int ret; 103 104 if (sync) { 105 ret = filemap_fdatawait(inode->i_mapping); 106 if (ret == 0) 107 ret = nfs_commit_inode(inode, FLUSH_SYNC); 108 } else 109 ret = nfs_commit_inode(inode, 0); 110 if (ret >= 0) 111 return 0; 112 __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 113 return ret; 114 } 115 116 void nfs_clear_inode(struct inode *inode) 117 { 118 /* 119 * The following should never happen... 120 */ 121 BUG_ON(nfs_have_writebacks(inode)); 122 BUG_ON(!list_empty(&NFS_I(inode)->open_files)); 123 nfs_zap_acl_cache(inode); 124 nfs_access_zap_cache(inode); 125 nfs_fscache_release_inode_cookie(inode); 126 } 127 128 /** 129 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk 130 */ 131 int nfs_sync_mapping(struct address_space *mapping) 132 { 133 int ret; 134 135 if (mapping->nrpages == 0) 136 return 0; 137 unmap_mapping_range(mapping, 0, 0, 0); 138 ret = filemap_write_and_wait(mapping); 139 if (ret != 0) 140 goto out; 141 ret = nfs_wb_all(mapping->host); 142 out: 143 return ret; 144 } 145 146 /* 147 * Invalidate the local caches 148 */ 149 static void nfs_zap_caches_locked(struct inode *inode) 150 { 151 struct nfs_inode *nfsi = NFS_I(inode); 152 int mode = inode->i_mode; 153 154 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 155 156 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 157 nfsi->attrtimeo_timestamp = jiffies; 158 159 memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode))); 160 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) 161 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE; 162 else 163 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE; 164 } 165 166 void nfs_zap_caches(struct inode *inode) 167 { 168 spin_lock(&inode->i_lock); 169 nfs_zap_caches_locked(inode); 170 spin_unlock(&inode->i_lock); 171 } 172 173 void nfs_zap_mapping(struct inode *inode, struct address_space *mapping) 174 { 175 if (mapping->nrpages != 0) { 176 spin_lock(&inode->i_lock); 177 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA; 178 spin_unlock(&inode->i_lock); 179 } 180 } 181 182 void nfs_zap_acl_cache(struct inode *inode) 183 { 184 void (*clear_acl_cache)(struct inode *); 185 186 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache; 187 if (clear_acl_cache != NULL) 188 clear_acl_cache(inode); 189 spin_lock(&inode->i_lock); 190 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL; 191 spin_unlock(&inode->i_lock); 192 } 193 194 void nfs_invalidate_atime(struct inode *inode) 195 { 196 spin_lock(&inode->i_lock); 197 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME; 198 spin_unlock(&inode->i_lock); 199 } 200 201 /* 202 * Invalidate, but do not unhash, the inode. 203 * NB: must be called with inode->i_lock held! 204 */ 205 static void nfs_invalidate_inode(struct inode *inode) 206 { 207 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 208 nfs_zap_caches_locked(inode); 209 } 210 211 struct nfs_find_desc { 212 struct nfs_fh *fh; 213 struct nfs_fattr *fattr; 214 }; 215 216 /* 217 * In NFSv3 we can have 64bit inode numbers. In order to support 218 * this, and re-exported directories (also seen in NFSv2) 219 * we are forced to allow 2 different inodes to have the same 220 * i_ino. 221 */ 222 static int 223 nfs_find_actor(struct inode *inode, void *opaque) 224 { 225 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque; 226 struct nfs_fh *fh = desc->fh; 227 struct nfs_fattr *fattr = desc->fattr; 228 229 if (NFS_FILEID(inode) != fattr->fileid) 230 return 0; 231 if (nfs_compare_fh(NFS_FH(inode), fh)) 232 return 0; 233 if (is_bad_inode(inode) || NFS_STALE(inode)) 234 return 0; 235 return 1; 236 } 237 238 static int 239 nfs_init_locked(struct inode *inode, void *opaque) 240 { 241 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque; 242 struct nfs_fattr *fattr = desc->fattr; 243 244 set_nfs_fileid(inode, fattr->fileid); 245 nfs_copy_fh(NFS_FH(inode), desc->fh); 246 return 0; 247 } 248 249 /* Don't use READDIRPLUS on directories that we believe are too large */ 250 #define NFS_LIMIT_READDIRPLUS (8*PAGE_SIZE) 251 252 /* 253 * This is our front-end to iget that looks up inodes by file handle 254 * instead of inode number. 255 */ 256 struct inode * 257 nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr) 258 { 259 struct nfs_find_desc desc = { 260 .fh = fh, 261 .fattr = fattr 262 }; 263 struct inode *inode = ERR_PTR(-ENOENT); 264 unsigned long hash; 265 266 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0) 267 goto out_no_inode; 268 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0) 269 goto out_no_inode; 270 271 hash = nfs_fattr_to_ino_t(fattr); 272 273 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc); 274 if (inode == NULL) { 275 inode = ERR_PTR(-ENOMEM); 276 goto out_no_inode; 277 } 278 279 if (inode->i_state & I_NEW) { 280 struct nfs_inode *nfsi = NFS_I(inode); 281 unsigned long now = jiffies; 282 283 /* We set i_ino for the few things that still rely on it, 284 * such as stat(2) */ 285 inode->i_ino = hash; 286 287 /* We can't support update_atime(), since the server will reset it */ 288 inode->i_flags |= S_NOATIME|S_NOCMTIME; 289 inode->i_mode = fattr->mode; 290 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0 291 && nfs_server_capable(inode, NFS_CAP_MODE)) 292 nfsi->cache_validity |= NFS_INO_INVALID_ATTR 293 | NFS_INO_INVALID_ACCESS 294 | NFS_INO_INVALID_ACL; 295 /* Why so? Because we want revalidate for devices/FIFOs, and 296 * that's precisely what we have in nfs_file_inode_operations. 297 */ 298 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops; 299 if (S_ISREG(inode->i_mode)) { 300 inode->i_fop = &nfs_file_operations; 301 inode->i_data.a_ops = &nfs_file_aops; 302 inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info; 303 } else if (S_ISDIR(inode->i_mode)) { 304 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops; 305 inode->i_fop = &nfs_dir_operations; 306 if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS) 307 && fattr->size <= NFS_LIMIT_READDIRPLUS) 308 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 309 /* Deal with crossing mountpoints */ 310 if ((fattr->valid & NFS_ATTR_FATTR_FSID) 311 && !nfs_fsid_equal(&NFS_SB(sb)->fsid, &fattr->fsid)) { 312 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) 313 inode->i_op = &nfs_referral_inode_operations; 314 else 315 inode->i_op = &nfs_mountpoint_inode_operations; 316 inode->i_fop = NULL; 317 set_bit(NFS_INO_MOUNTPOINT, &nfsi->flags); 318 } 319 } else if (S_ISLNK(inode->i_mode)) 320 inode->i_op = &nfs_symlink_inode_operations; 321 else 322 init_special_inode(inode, inode->i_mode, fattr->rdev); 323 324 memset(&inode->i_atime, 0, sizeof(inode->i_atime)); 325 memset(&inode->i_mtime, 0, sizeof(inode->i_mtime)); 326 memset(&inode->i_ctime, 0, sizeof(inode->i_ctime)); 327 nfsi->change_attr = 0; 328 inode->i_size = 0; 329 inode->i_nlink = 0; 330 inode->i_uid = -2; 331 inode->i_gid = -2; 332 inode->i_blocks = 0; 333 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf)); 334 335 nfsi->read_cache_jiffies = fattr->time_start; 336 nfsi->attr_gencount = fattr->gencount; 337 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 338 inode->i_atime = fattr->atime; 339 else if (nfs_server_capable(inode, NFS_CAP_ATIME)) 340 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 341 if (fattr->valid & NFS_ATTR_FATTR_MTIME) 342 inode->i_mtime = fattr->mtime; 343 else if (nfs_server_capable(inode, NFS_CAP_MTIME)) 344 nfsi->cache_validity |= NFS_INO_INVALID_ATTR 345 | NFS_INO_INVALID_DATA; 346 if (fattr->valid & NFS_ATTR_FATTR_CTIME) 347 inode->i_ctime = fattr->ctime; 348 else if (nfs_server_capable(inode, NFS_CAP_CTIME)) 349 nfsi->cache_validity |= NFS_INO_INVALID_ATTR 350 | NFS_INO_INVALID_ACCESS 351 | NFS_INO_INVALID_ACL; 352 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) 353 nfsi->change_attr = fattr->change_attr; 354 else if (nfs_server_capable(inode, NFS_CAP_CHANGE_ATTR)) 355 nfsi->cache_validity |= NFS_INO_INVALID_ATTR 356 | NFS_INO_INVALID_DATA; 357 if (fattr->valid & NFS_ATTR_FATTR_SIZE) 358 inode->i_size = nfs_size_to_loff_t(fattr->size); 359 else 360 nfsi->cache_validity |= NFS_INO_INVALID_ATTR 361 | NFS_INO_INVALID_DATA 362 | NFS_INO_REVAL_PAGECACHE; 363 if (fattr->valid & NFS_ATTR_FATTR_NLINK) 364 inode->i_nlink = fattr->nlink; 365 else if (nfs_server_capable(inode, NFS_CAP_NLINK)) 366 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 367 if (fattr->valid & NFS_ATTR_FATTR_OWNER) 368 inode->i_uid = fattr->uid; 369 else if (nfs_server_capable(inode, NFS_CAP_OWNER)) 370 nfsi->cache_validity |= NFS_INO_INVALID_ATTR 371 | NFS_INO_INVALID_ACCESS 372 | NFS_INO_INVALID_ACL; 373 if (fattr->valid & NFS_ATTR_FATTR_GROUP) 374 inode->i_gid = fattr->gid; 375 else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP)) 376 nfsi->cache_validity |= NFS_INO_INVALID_ATTR 377 | NFS_INO_INVALID_ACCESS 378 | NFS_INO_INVALID_ACL; 379 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) 380 inode->i_blocks = fattr->du.nfs2.blocks; 381 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { 382 /* 383 * report the blocks in 512byte units 384 */ 385 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 386 } 387 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 388 nfsi->attrtimeo_timestamp = now; 389 nfsi->access_cache = RB_ROOT; 390 391 nfs_fscache_init_inode_cookie(inode); 392 393 unlock_new_inode(inode); 394 } else 395 nfs_refresh_inode(inode, fattr); 396 dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n", 397 inode->i_sb->s_id, 398 (long long)NFS_FILEID(inode), 399 atomic_read(&inode->i_count)); 400 401 out: 402 return inode; 403 404 out_no_inode: 405 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode)); 406 goto out; 407 } 408 409 #define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE) 410 411 int 412 nfs_setattr(struct dentry *dentry, struct iattr *attr) 413 { 414 struct inode *inode = dentry->d_inode; 415 struct nfs_fattr fattr; 416 int error; 417 418 nfs_inc_stats(inode, NFSIOS_VFSSETATTR); 419 420 /* skip mode change if it's just for clearing setuid/setgid */ 421 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) 422 attr->ia_valid &= ~ATTR_MODE; 423 424 if (attr->ia_valid & ATTR_SIZE) { 425 if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode)) 426 attr->ia_valid &= ~ATTR_SIZE; 427 } 428 429 /* Optimization: if the end result is no change, don't RPC */ 430 attr->ia_valid &= NFS_VALID_ATTRS; 431 if ((attr->ia_valid & ~ATTR_FILE) == 0) 432 return 0; 433 434 /* Write all dirty data */ 435 if (S_ISREG(inode->i_mode)) { 436 filemap_write_and_wait(inode->i_mapping); 437 nfs_wb_all(inode); 438 } 439 /* 440 * Return any delegations if we're going to change ACLs 441 */ 442 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) 443 nfs_inode_return_delegation(inode); 444 error = NFS_PROTO(inode)->setattr(dentry, &fattr, attr); 445 if (error == 0) 446 nfs_refresh_inode(inode, &fattr); 447 return error; 448 } 449 450 /** 451 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall 452 * @inode: inode of the file used 453 * @offset: file offset to start truncating 454 * 455 * This is a copy of the common vmtruncate, but with the locking 456 * corrected to take into account the fact that NFS requires 457 * inode->i_size to be updated under the inode->i_lock. 458 */ 459 static int nfs_vmtruncate(struct inode * inode, loff_t offset) 460 { 461 loff_t oldsize; 462 int err; 463 464 err = inode_newsize_ok(inode, offset); 465 if (err) 466 goto out; 467 468 spin_lock(&inode->i_lock); 469 oldsize = inode->i_size; 470 i_size_write(inode, offset); 471 spin_unlock(&inode->i_lock); 472 473 truncate_pagecache(inode, oldsize, offset); 474 out: 475 return err; 476 } 477 478 /** 479 * nfs_setattr_update_inode - Update inode metadata after a setattr call. 480 * @inode: pointer to struct inode 481 * @attr: pointer to struct iattr 482 * 483 * Note: we do this in the *proc.c in order to ensure that 484 * it works for things like exclusive creates too. 485 */ 486 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr) 487 { 488 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) { 489 spin_lock(&inode->i_lock); 490 if ((attr->ia_valid & ATTR_MODE) != 0) { 491 int mode = attr->ia_mode & S_IALLUGO; 492 mode |= inode->i_mode & ~S_IALLUGO; 493 inode->i_mode = mode; 494 } 495 if ((attr->ia_valid & ATTR_UID) != 0) 496 inode->i_uid = attr->ia_uid; 497 if ((attr->ia_valid & ATTR_GID) != 0) 498 inode->i_gid = attr->ia_gid; 499 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 500 spin_unlock(&inode->i_lock); 501 } 502 if ((attr->ia_valid & ATTR_SIZE) != 0) { 503 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC); 504 nfs_vmtruncate(inode, attr->ia_size); 505 } 506 } 507 508 int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 509 { 510 struct inode *inode = dentry->d_inode; 511 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME; 512 int err; 513 514 /* 515 * Flush out writes to the server in order to update c/mtime. 516 * 517 * Hold the i_mutex to suspend application writes temporarily; 518 * this prevents long-running writing applications from blocking 519 * nfs_wb_nocommit. 520 */ 521 if (S_ISREG(inode->i_mode)) { 522 mutex_lock(&inode->i_mutex); 523 nfs_wb_nocommit(inode); 524 mutex_unlock(&inode->i_mutex); 525 } 526 527 /* 528 * We may force a getattr if the user cares about atime. 529 * 530 * Note that we only have to check the vfsmount flags here: 531 * - NFS always sets S_NOATIME by so checking it would give a 532 * bogus result 533 * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is 534 * no point in checking those. 535 */ 536 if ((mnt->mnt_flags & MNT_NOATIME) || 537 ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))) 538 need_atime = 0; 539 540 if (need_atime) 541 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 542 else 543 err = nfs_revalidate_inode(NFS_SERVER(inode), inode); 544 if (!err) { 545 generic_fillattr(inode, stat); 546 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode)); 547 } 548 return err; 549 } 550 551 /** 552 * nfs_close_context - Common close_context() routine NFSv2/v3 553 * @ctx: pointer to context 554 * @is_sync: is this a synchronous close 555 * 556 * always ensure that the attributes are up to date if we're mounted 557 * with close-to-open semantics 558 */ 559 void nfs_close_context(struct nfs_open_context *ctx, int is_sync) 560 { 561 struct inode *inode; 562 struct nfs_server *server; 563 564 if (!(ctx->mode & FMODE_WRITE)) 565 return; 566 if (!is_sync) 567 return; 568 inode = ctx->path.dentry->d_inode; 569 if (!list_empty(&NFS_I(inode)->open_files)) 570 return; 571 server = NFS_SERVER(inode); 572 if (server->flags & NFS_MOUNT_NOCTO) 573 return; 574 nfs_revalidate_inode(server, inode); 575 } 576 577 static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, struct dentry *dentry, struct rpc_cred *cred) 578 { 579 struct nfs_open_context *ctx; 580 581 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); 582 if (ctx != NULL) { 583 ctx->path.dentry = dget(dentry); 584 ctx->path.mnt = mntget(mnt); 585 ctx->cred = get_rpccred(cred); 586 ctx->state = NULL; 587 ctx->lockowner = current->files; 588 ctx->flags = 0; 589 ctx->error = 0; 590 ctx->dir_cookie = 0; 591 atomic_set(&ctx->count, 1); 592 } 593 return ctx; 594 } 595 596 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx) 597 { 598 if (ctx != NULL) 599 atomic_inc(&ctx->count); 600 return ctx; 601 } 602 603 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync) 604 { 605 struct inode *inode = ctx->path.dentry->d_inode; 606 607 if (!atomic_dec_and_lock(&ctx->count, &inode->i_lock)) 608 return; 609 list_del(&ctx->list); 610 spin_unlock(&inode->i_lock); 611 NFS_PROTO(inode)->close_context(ctx, is_sync); 612 if (ctx->cred != NULL) 613 put_rpccred(ctx->cred); 614 path_put(&ctx->path); 615 kfree(ctx); 616 } 617 618 void put_nfs_open_context(struct nfs_open_context *ctx) 619 { 620 __put_nfs_open_context(ctx, 0); 621 } 622 623 static void put_nfs_open_context_sync(struct nfs_open_context *ctx) 624 { 625 __put_nfs_open_context(ctx, 1); 626 } 627 628 /* 629 * Ensure that mmap has a recent RPC credential for use when writing out 630 * shared pages 631 */ 632 static void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx) 633 { 634 struct inode *inode = filp->f_path.dentry->d_inode; 635 struct nfs_inode *nfsi = NFS_I(inode); 636 637 filp->private_data = get_nfs_open_context(ctx); 638 spin_lock(&inode->i_lock); 639 list_add(&ctx->list, &nfsi->open_files); 640 spin_unlock(&inode->i_lock); 641 } 642 643 /* 644 * Given an inode, search for an open context with the desired characteristics 645 */ 646 struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode) 647 { 648 struct nfs_inode *nfsi = NFS_I(inode); 649 struct nfs_open_context *pos, *ctx = NULL; 650 651 spin_lock(&inode->i_lock); 652 list_for_each_entry(pos, &nfsi->open_files, list) { 653 if (cred != NULL && pos->cred != cred) 654 continue; 655 if ((pos->mode & mode) == mode) { 656 ctx = get_nfs_open_context(pos); 657 break; 658 } 659 } 660 spin_unlock(&inode->i_lock); 661 return ctx; 662 } 663 664 static void nfs_file_clear_open_context(struct file *filp) 665 { 666 struct inode *inode = filp->f_path.dentry->d_inode; 667 struct nfs_open_context *ctx = nfs_file_open_context(filp); 668 669 if (ctx) { 670 filp->private_data = NULL; 671 spin_lock(&inode->i_lock); 672 list_move_tail(&ctx->list, &NFS_I(inode)->open_files); 673 spin_unlock(&inode->i_lock); 674 put_nfs_open_context_sync(ctx); 675 } 676 } 677 678 /* 679 * These allocate and release file read/write context information. 680 */ 681 int nfs_open(struct inode *inode, struct file *filp) 682 { 683 struct nfs_open_context *ctx; 684 struct rpc_cred *cred; 685 686 cred = rpc_lookup_cred(); 687 if (IS_ERR(cred)) 688 return PTR_ERR(cred); 689 ctx = alloc_nfs_open_context(filp->f_path.mnt, filp->f_path.dentry, cred); 690 put_rpccred(cred); 691 if (ctx == NULL) 692 return -ENOMEM; 693 ctx->mode = filp->f_mode; 694 nfs_file_set_open_context(filp, ctx); 695 put_nfs_open_context(ctx); 696 nfs_fscache_set_inode_cookie(inode, filp); 697 return 0; 698 } 699 700 int nfs_release(struct inode *inode, struct file *filp) 701 { 702 nfs_file_clear_open_context(filp); 703 return 0; 704 } 705 706 /* 707 * This function is called whenever some part of NFS notices that 708 * the cached attributes have to be refreshed. 709 */ 710 int 711 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 712 { 713 int status = -ESTALE; 714 struct nfs_fattr fattr; 715 struct nfs_inode *nfsi = NFS_I(inode); 716 717 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n", 718 inode->i_sb->s_id, (long long)NFS_FILEID(inode)); 719 720 if (is_bad_inode(inode)) 721 goto out; 722 if (NFS_STALE(inode)) 723 goto out; 724 725 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE); 726 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), &fattr); 727 if (status != 0) { 728 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n", 729 inode->i_sb->s_id, 730 (long long)NFS_FILEID(inode), status); 731 if (status == -ESTALE) { 732 nfs_zap_caches(inode); 733 if (!S_ISDIR(inode->i_mode)) 734 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 735 } 736 goto out; 737 } 738 739 status = nfs_refresh_inode(inode, &fattr); 740 if (status) { 741 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n", 742 inode->i_sb->s_id, 743 (long long)NFS_FILEID(inode), status); 744 goto out; 745 } 746 747 if (nfsi->cache_validity & NFS_INO_INVALID_ACL) 748 nfs_zap_acl_cache(inode); 749 750 dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n", 751 inode->i_sb->s_id, 752 (long long)NFS_FILEID(inode)); 753 754 out: 755 return status; 756 } 757 758 int nfs_attribute_timeout(struct inode *inode) 759 { 760 struct nfs_inode *nfsi = NFS_I(inode); 761 762 if (nfs_have_delegation(inode, FMODE_READ)) 763 return 0; 764 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo); 765 } 766 767 /** 768 * nfs_revalidate_inode - Revalidate the inode attributes 769 * @server - pointer to nfs_server struct 770 * @inode - pointer to inode struct 771 * 772 * Updates inode attribute information by retrieving the data from the server. 773 */ 774 int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 775 { 776 if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR) 777 && !nfs_attribute_timeout(inode)) 778 return NFS_STALE(inode) ? -ESTALE : 0; 779 return __nfs_revalidate_inode(server, inode); 780 } 781 782 static int nfs_invalidate_mapping_nolock(struct inode *inode, struct address_space *mapping) 783 { 784 struct nfs_inode *nfsi = NFS_I(inode); 785 786 if (mapping->nrpages != 0) { 787 int ret = invalidate_inode_pages2(mapping); 788 if (ret < 0) 789 return ret; 790 } 791 spin_lock(&inode->i_lock); 792 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA; 793 if (S_ISDIR(inode->i_mode)) 794 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf)); 795 spin_unlock(&inode->i_lock); 796 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE); 797 nfs_fscache_reset_inode_cookie(inode); 798 dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n", 799 inode->i_sb->s_id, (long long)NFS_FILEID(inode)); 800 return 0; 801 } 802 803 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping) 804 { 805 int ret = 0; 806 807 mutex_lock(&inode->i_mutex); 808 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_DATA) { 809 ret = nfs_sync_mapping(mapping); 810 if (ret == 0) 811 ret = nfs_invalidate_mapping_nolock(inode, mapping); 812 } 813 mutex_unlock(&inode->i_mutex); 814 return ret; 815 } 816 817 /** 818 * nfs_revalidate_mapping_nolock - Revalidate the pagecache 819 * @inode - pointer to host inode 820 * @mapping - pointer to mapping 821 */ 822 int nfs_revalidate_mapping_nolock(struct inode *inode, struct address_space *mapping) 823 { 824 struct nfs_inode *nfsi = NFS_I(inode); 825 int ret = 0; 826 827 if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE) 828 || nfs_attribute_timeout(inode) || NFS_STALE(inode)) { 829 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 830 if (ret < 0) 831 goto out; 832 } 833 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 834 ret = nfs_invalidate_mapping_nolock(inode, mapping); 835 out: 836 return ret; 837 } 838 839 /** 840 * nfs_revalidate_mapping - Revalidate the pagecache 841 * @inode - pointer to host inode 842 * @mapping - pointer to mapping 843 * 844 * This version of the function will take the inode->i_mutex and attempt to 845 * flush out all dirty data if it needs to invalidate the page cache. 846 */ 847 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) 848 { 849 struct nfs_inode *nfsi = NFS_I(inode); 850 int ret = 0; 851 852 if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE) 853 || nfs_attribute_timeout(inode) || NFS_STALE(inode)) { 854 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 855 if (ret < 0) 856 goto out; 857 } 858 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 859 ret = nfs_invalidate_mapping(inode, mapping); 860 out: 861 return ret; 862 } 863 864 static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr) 865 { 866 struct nfs_inode *nfsi = NFS_I(inode); 867 868 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE) 869 && (fattr->valid & NFS_ATTR_FATTR_CHANGE) 870 && nfsi->change_attr == fattr->pre_change_attr) { 871 nfsi->change_attr = fattr->change_attr; 872 if (S_ISDIR(inode->i_mode)) 873 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 874 } 875 /* If we have atomic WCC data, we may update some attributes */ 876 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME) 877 && (fattr->valid & NFS_ATTR_FATTR_CTIME) 878 && timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) 879 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); 880 881 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME) 882 && (fattr->valid & NFS_ATTR_FATTR_MTIME) 883 && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) { 884 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); 885 if (S_ISDIR(inode->i_mode)) 886 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 887 } 888 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE) 889 && (fattr->valid & NFS_ATTR_FATTR_SIZE) 890 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size) 891 && nfsi->npages == 0) 892 i_size_write(inode, nfs_size_to_loff_t(fattr->size)); 893 } 894 895 /** 896 * nfs_check_inode_attributes - verify consistency of the inode attribute cache 897 * @inode - pointer to inode 898 * @fattr - updated attributes 899 * 900 * Verifies the attribute cache. If we have just changed the attributes, 901 * so that fattr carries weak cache consistency data, then it may 902 * also update the ctime/mtime/change_attribute. 903 */ 904 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr) 905 { 906 struct nfs_inode *nfsi = NFS_I(inode); 907 loff_t cur_size, new_isize; 908 unsigned long invalid = 0; 909 910 911 /* Has the inode gone and changed behind our back? */ 912 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) 913 return -EIO; 914 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) 915 return -EIO; 916 917 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 918 nfsi->change_attr != fattr->change_attr) 919 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 920 921 /* Verify a few of the more important attributes */ 922 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime)) 923 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 924 925 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 926 cur_size = i_size_read(inode); 927 new_isize = nfs_size_to_loff_t(fattr->size); 928 if (cur_size != new_isize && nfsi->npages == 0) 929 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 930 } 931 932 /* Have any file permissions changed? */ 933 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) 934 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 935 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && inode->i_uid != fattr->uid) 936 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 937 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && inode->i_gid != fattr->gid) 938 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 939 940 /* Has the link count changed? */ 941 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink) 942 invalid |= NFS_INO_INVALID_ATTR; 943 944 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime)) 945 invalid |= NFS_INO_INVALID_ATIME; 946 947 if (invalid != 0) 948 nfsi->cache_validity |= invalid; 949 950 nfsi->read_cache_jiffies = fattr->time_start; 951 return 0; 952 } 953 954 static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 955 { 956 if (!(fattr->valid & NFS_ATTR_FATTR_CTIME)) 957 return 0; 958 return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0; 959 } 960 961 static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 962 { 963 if (!(fattr->valid & NFS_ATTR_FATTR_SIZE)) 964 return 0; 965 return nfs_size_to_loff_t(fattr->size) > i_size_read(inode); 966 } 967 968 static atomic_long_t nfs_attr_generation_counter; 969 970 static unsigned long nfs_read_attr_generation_counter(void) 971 { 972 return atomic_long_read(&nfs_attr_generation_counter); 973 } 974 975 unsigned long nfs_inc_attr_generation_counter(void) 976 { 977 return atomic_long_inc_return(&nfs_attr_generation_counter); 978 } 979 980 void nfs_fattr_init(struct nfs_fattr *fattr) 981 { 982 fattr->valid = 0; 983 fattr->time_start = jiffies; 984 fattr->gencount = nfs_inc_attr_generation_counter(); 985 } 986 987 /** 988 * nfs_inode_attrs_need_update - check if the inode attributes need updating 989 * @inode - pointer to inode 990 * @fattr - attributes 991 * 992 * Attempt to divine whether or not an RPC call reply carrying stale 993 * attributes got scheduled after another call carrying updated ones. 994 * 995 * To do so, the function first assumes that a more recent ctime means 996 * that the attributes in fattr are newer, however it also attempt to 997 * catch the case where ctime either didn't change, or went backwards 998 * (if someone reset the clock on the server) by looking at whether 999 * or not this RPC call was started after the inode was last updated. 1000 * Note also the check for wraparound of 'attr_gencount' 1001 * 1002 * The function returns 'true' if it thinks the attributes in 'fattr' are 1003 * more recent than the ones cached in the inode. 1004 * 1005 */ 1006 static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 1007 { 1008 const struct nfs_inode *nfsi = NFS_I(inode); 1009 1010 return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 || 1011 nfs_ctime_need_update(inode, fattr) || 1012 nfs_size_need_update(inode, fattr) || 1013 ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0); 1014 } 1015 1016 static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr) 1017 { 1018 if (nfs_inode_attrs_need_update(inode, fattr)) 1019 return nfs_update_inode(inode, fattr); 1020 return nfs_check_inode_attributes(inode, fattr); 1021 } 1022 1023 /** 1024 * nfs_refresh_inode - try to update the inode attribute cache 1025 * @inode - pointer to inode 1026 * @fattr - updated attributes 1027 * 1028 * Check that an RPC call that returned attributes has not overlapped with 1029 * other recent updates of the inode metadata, then decide whether it is 1030 * safe to do a full update of the inode attributes, or whether just to 1031 * call nfs_check_inode_attributes. 1032 */ 1033 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr) 1034 { 1035 int status; 1036 1037 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 1038 return 0; 1039 spin_lock(&inode->i_lock); 1040 status = nfs_refresh_inode_locked(inode, fattr); 1041 spin_unlock(&inode->i_lock); 1042 1043 return status; 1044 } 1045 1046 static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr) 1047 { 1048 struct nfs_inode *nfsi = NFS_I(inode); 1049 1050 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 1051 if (S_ISDIR(inode->i_mode)) 1052 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 1053 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 1054 return 0; 1055 return nfs_refresh_inode_locked(inode, fattr); 1056 } 1057 1058 /** 1059 * nfs_post_op_update_inode - try to update the inode attribute cache 1060 * @inode - pointer to inode 1061 * @fattr - updated attributes 1062 * 1063 * After an operation that has changed the inode metadata, mark the 1064 * attribute cache as being invalid, then try to update it. 1065 * 1066 * NB: if the server didn't return any post op attributes, this 1067 * function will force the retrieval of attributes before the next 1068 * NFS request. Thus it should be used only for operations that 1069 * are expected to change one or more attributes, to avoid 1070 * unnecessary NFS requests and trips through nfs_update_inode(). 1071 */ 1072 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1073 { 1074 int status; 1075 1076 spin_lock(&inode->i_lock); 1077 status = nfs_post_op_update_inode_locked(inode, fattr); 1078 spin_unlock(&inode->i_lock); 1079 return status; 1080 } 1081 1082 /** 1083 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache 1084 * @inode - pointer to inode 1085 * @fattr - updated attributes 1086 * 1087 * After an operation that has changed the inode metadata, mark the 1088 * attribute cache as being invalid, then try to update it. Fake up 1089 * weak cache consistency data, if none exist. 1090 * 1091 * This function is mainly designed to be used by the ->write_done() functions. 1092 */ 1093 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr) 1094 { 1095 int status; 1096 1097 spin_lock(&inode->i_lock); 1098 /* Don't do a WCC update if these attributes are already stale */ 1099 if ((fattr->valid & NFS_ATTR_FATTR) == 0 || 1100 !nfs_inode_attrs_need_update(inode, fattr)) { 1101 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE 1102 | NFS_ATTR_FATTR_PRESIZE 1103 | NFS_ATTR_FATTR_PREMTIME 1104 | NFS_ATTR_FATTR_PRECTIME); 1105 goto out_noforce; 1106 } 1107 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 1108 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) { 1109 fattr->pre_change_attr = NFS_I(inode)->change_attr; 1110 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE; 1111 } 1112 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 && 1113 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) { 1114 memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime)); 1115 fattr->valid |= NFS_ATTR_FATTR_PRECTIME; 1116 } 1117 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 && 1118 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) { 1119 memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime)); 1120 fattr->valid |= NFS_ATTR_FATTR_PREMTIME; 1121 } 1122 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 && 1123 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) { 1124 fattr->pre_size = i_size_read(inode); 1125 fattr->valid |= NFS_ATTR_FATTR_PRESIZE; 1126 } 1127 out_noforce: 1128 status = nfs_post_op_update_inode_locked(inode, fattr); 1129 spin_unlock(&inode->i_lock); 1130 return status; 1131 } 1132 1133 /* 1134 * Many nfs protocol calls return the new file attributes after 1135 * an operation. Here we update the inode to reflect the state 1136 * of the server's inode. 1137 * 1138 * This is a bit tricky because we have to make sure all dirty pages 1139 * have been sent off to the server before calling invalidate_inode_pages. 1140 * To make sure no other process adds more write requests while we try 1141 * our best to flush them, we make them sleep during the attribute refresh. 1142 * 1143 * A very similar scenario holds for the dir cache. 1144 */ 1145 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1146 { 1147 struct nfs_server *server; 1148 struct nfs_inode *nfsi = NFS_I(inode); 1149 loff_t cur_isize, new_isize; 1150 unsigned long invalid = 0; 1151 unsigned long now = jiffies; 1152 unsigned long save_cache_validity; 1153 1154 dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n", 1155 __func__, inode->i_sb->s_id, inode->i_ino, 1156 atomic_read(&inode->i_count), fattr->valid); 1157 1158 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) 1159 goto out_fileid; 1160 1161 /* 1162 * Make sure the inode's type hasn't changed. 1163 */ 1164 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) 1165 goto out_changed; 1166 1167 server = NFS_SERVER(inode); 1168 /* Update the fsid? */ 1169 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) && 1170 !nfs_fsid_equal(&server->fsid, &fattr->fsid) && 1171 !test_bit(NFS_INO_MOUNTPOINT, &nfsi->flags)) 1172 server->fsid = fattr->fsid; 1173 1174 /* 1175 * Update the read time so we don't revalidate too often. 1176 */ 1177 nfsi->read_cache_jiffies = fattr->time_start; 1178 1179 save_cache_validity = nfsi->cache_validity; 1180 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR 1181 | NFS_INO_INVALID_ATIME 1182 | NFS_INO_REVAL_FORCED 1183 | NFS_INO_REVAL_PAGECACHE); 1184 1185 /* Do atomic weak cache consistency updates */ 1186 nfs_wcc_update_inode(inode, fattr); 1187 1188 /* More cache consistency checks */ 1189 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) { 1190 if (nfsi->change_attr != fattr->change_attr) { 1191 dprintk("NFS: change_attr change on server for file %s/%ld\n", 1192 inode->i_sb->s_id, inode->i_ino); 1193 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1194 if (S_ISDIR(inode->i_mode)) 1195 nfs_force_lookup_revalidate(inode); 1196 nfsi->change_attr = fattr->change_attr; 1197 } 1198 } else if (server->caps & NFS_CAP_CHANGE_ATTR) 1199 invalid |= save_cache_validity; 1200 1201 if (fattr->valid & NFS_ATTR_FATTR_MTIME) { 1202 /* NFSv2/v3: Check if the mtime agrees */ 1203 if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) { 1204 dprintk("NFS: mtime change on server for file %s/%ld\n", 1205 inode->i_sb->s_id, inode->i_ino); 1206 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA; 1207 if (S_ISDIR(inode->i_mode)) 1208 nfs_force_lookup_revalidate(inode); 1209 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); 1210 } 1211 } else if (server->caps & NFS_CAP_MTIME) 1212 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1213 | NFS_INO_INVALID_DATA 1214 | NFS_INO_REVAL_PAGECACHE 1215 | NFS_INO_REVAL_FORCED); 1216 1217 if (fattr->valid & NFS_ATTR_FATTR_CTIME) { 1218 /* If ctime has changed we should definitely clear access+acl caches */ 1219 if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) { 1220 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1221 /* and probably clear data for a directory too as utimes can cause 1222 * havoc with our cache. 1223 */ 1224 if (S_ISDIR(inode->i_mode)) { 1225 invalid |= NFS_INO_INVALID_DATA; 1226 nfs_force_lookup_revalidate(inode); 1227 } 1228 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); 1229 } 1230 } else if (server->caps & NFS_CAP_CTIME) 1231 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1232 | NFS_INO_INVALID_ACCESS 1233 | NFS_INO_INVALID_ACL 1234 | NFS_INO_REVAL_FORCED); 1235 1236 /* Check if our cached file size is stale */ 1237 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 1238 new_isize = nfs_size_to_loff_t(fattr->size); 1239 cur_isize = i_size_read(inode); 1240 if (new_isize != cur_isize) { 1241 /* Do we perhaps have any outstanding writes, or has 1242 * the file grown beyond our last write? */ 1243 if (nfsi->npages == 0 || new_isize > cur_isize) { 1244 i_size_write(inode, new_isize); 1245 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA; 1246 } 1247 dprintk("NFS: isize change on server for file %s/%ld\n", 1248 inode->i_sb->s_id, inode->i_ino); 1249 } 1250 } else 1251 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1252 | NFS_INO_REVAL_PAGECACHE 1253 | NFS_INO_REVAL_FORCED); 1254 1255 1256 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 1257 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime)); 1258 else if (server->caps & NFS_CAP_ATIME) 1259 invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME 1260 | NFS_INO_REVAL_FORCED); 1261 1262 if (fattr->valid & NFS_ATTR_FATTR_MODE) { 1263 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) { 1264 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1265 inode->i_mode = fattr->mode; 1266 } 1267 } else if (server->caps & NFS_CAP_MODE) 1268 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1269 | NFS_INO_INVALID_ACCESS 1270 | NFS_INO_INVALID_ACL 1271 | NFS_INO_REVAL_FORCED); 1272 1273 if (fattr->valid & NFS_ATTR_FATTR_OWNER) { 1274 if (inode->i_uid != fattr->uid) { 1275 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1276 inode->i_uid = fattr->uid; 1277 } 1278 } else if (server->caps & NFS_CAP_OWNER) 1279 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1280 | NFS_INO_INVALID_ACCESS 1281 | NFS_INO_INVALID_ACL 1282 | NFS_INO_REVAL_FORCED); 1283 1284 if (fattr->valid & NFS_ATTR_FATTR_GROUP) { 1285 if (inode->i_gid != fattr->gid) { 1286 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1287 inode->i_gid = fattr->gid; 1288 } 1289 } else if (server->caps & NFS_CAP_OWNER_GROUP) 1290 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1291 | NFS_INO_INVALID_ACCESS 1292 | NFS_INO_INVALID_ACL 1293 | NFS_INO_REVAL_FORCED); 1294 1295 if (fattr->valid & NFS_ATTR_FATTR_NLINK) { 1296 if (inode->i_nlink != fattr->nlink) { 1297 invalid |= NFS_INO_INVALID_ATTR; 1298 if (S_ISDIR(inode->i_mode)) 1299 invalid |= NFS_INO_INVALID_DATA; 1300 inode->i_nlink = fattr->nlink; 1301 } 1302 } else if (server->caps & NFS_CAP_NLINK) 1303 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1304 | NFS_INO_REVAL_FORCED); 1305 1306 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { 1307 /* 1308 * report the blocks in 512byte units 1309 */ 1310 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 1311 } 1312 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) 1313 inode->i_blocks = fattr->du.nfs2.blocks; 1314 1315 /* Update attrtimeo value if we're out of the unstable period */ 1316 if (invalid & NFS_INO_INVALID_ATTR) { 1317 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 1318 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 1319 nfsi->attrtimeo_timestamp = now; 1320 nfsi->attr_gencount = nfs_inc_attr_generation_counter(); 1321 } else { 1322 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) { 1323 if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode)) 1324 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode); 1325 nfsi->attrtimeo_timestamp = now; 1326 } 1327 } 1328 invalid &= ~NFS_INO_INVALID_ATTR; 1329 /* Don't invalidate the data if we were to blame */ 1330 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) 1331 || S_ISLNK(inode->i_mode))) 1332 invalid &= ~NFS_INO_INVALID_DATA; 1333 if (!nfs_have_delegation(inode, FMODE_READ) || 1334 (save_cache_validity & NFS_INO_REVAL_FORCED)) 1335 nfsi->cache_validity |= invalid; 1336 1337 return 0; 1338 out_changed: 1339 /* 1340 * Big trouble! The inode has become a different object. 1341 */ 1342 printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n", 1343 __func__, inode->i_ino, inode->i_mode, fattr->mode); 1344 out_err: 1345 /* 1346 * No need to worry about unhashing the dentry, as the 1347 * lookup validation will know that the inode is bad. 1348 * (But we fall through to invalidate the caches.) 1349 */ 1350 nfs_invalidate_inode(inode); 1351 return -ESTALE; 1352 1353 out_fileid: 1354 printk(KERN_ERR "NFS: server %s error: fileid changed\n" 1355 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n", 1356 NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id, 1357 (long long)nfsi->fileid, (long long)fattr->fileid); 1358 goto out_err; 1359 } 1360 1361 1362 #ifdef CONFIG_NFS_V4 1363 1364 /* 1365 * Clean out any remaining NFSv4 state that might be left over due 1366 * to open() calls that passed nfs_atomic_lookup, but failed to call 1367 * nfs_open(). 1368 */ 1369 void nfs4_clear_inode(struct inode *inode) 1370 { 1371 /* If we are holding a delegation, return it! */ 1372 nfs_inode_return_delegation_noreclaim(inode); 1373 /* First call standard NFS clear_inode() code */ 1374 nfs_clear_inode(inode); 1375 } 1376 #endif 1377 1378 struct inode *nfs_alloc_inode(struct super_block *sb) 1379 { 1380 struct nfs_inode *nfsi; 1381 nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL); 1382 if (!nfsi) 1383 return NULL; 1384 nfsi->flags = 0UL; 1385 nfsi->cache_validity = 0UL; 1386 #ifdef CONFIG_NFS_V3_ACL 1387 nfsi->acl_access = ERR_PTR(-EAGAIN); 1388 nfsi->acl_default = ERR_PTR(-EAGAIN); 1389 #endif 1390 #ifdef CONFIG_NFS_V4 1391 nfsi->nfs4_acl = NULL; 1392 #endif /* CONFIG_NFS_V4 */ 1393 return &nfsi->vfs_inode; 1394 } 1395 1396 void nfs_destroy_inode(struct inode *inode) 1397 { 1398 kmem_cache_free(nfs_inode_cachep, NFS_I(inode)); 1399 } 1400 1401 static inline void nfs4_init_once(struct nfs_inode *nfsi) 1402 { 1403 #ifdef CONFIG_NFS_V4 1404 INIT_LIST_HEAD(&nfsi->open_states); 1405 nfsi->delegation = NULL; 1406 nfsi->delegation_state = 0; 1407 init_rwsem(&nfsi->rwsem); 1408 #endif 1409 } 1410 1411 static void init_once(void *foo) 1412 { 1413 struct nfs_inode *nfsi = (struct nfs_inode *) foo; 1414 1415 inode_init_once(&nfsi->vfs_inode); 1416 INIT_LIST_HEAD(&nfsi->open_files); 1417 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru); 1418 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru); 1419 INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC); 1420 nfsi->npages = 0; 1421 atomic_set(&nfsi->silly_count, 1); 1422 INIT_HLIST_HEAD(&nfsi->silly_list); 1423 init_waitqueue_head(&nfsi->waitqueue); 1424 nfs4_init_once(nfsi); 1425 } 1426 1427 static int __init nfs_init_inodecache(void) 1428 { 1429 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", 1430 sizeof(struct nfs_inode), 1431 0, (SLAB_RECLAIM_ACCOUNT| 1432 SLAB_MEM_SPREAD), 1433 init_once); 1434 if (nfs_inode_cachep == NULL) 1435 return -ENOMEM; 1436 1437 return 0; 1438 } 1439 1440 static void nfs_destroy_inodecache(void) 1441 { 1442 kmem_cache_destroy(nfs_inode_cachep); 1443 } 1444 1445 struct workqueue_struct *nfsiod_workqueue; 1446 1447 /* 1448 * start up the nfsiod workqueue 1449 */ 1450 static int nfsiod_start(void) 1451 { 1452 struct workqueue_struct *wq; 1453 dprintk("RPC: creating workqueue nfsiod\n"); 1454 wq = create_singlethread_workqueue("nfsiod"); 1455 if (wq == NULL) 1456 return -ENOMEM; 1457 nfsiod_workqueue = wq; 1458 return 0; 1459 } 1460 1461 /* 1462 * Destroy the nfsiod workqueue 1463 */ 1464 static void nfsiod_stop(void) 1465 { 1466 struct workqueue_struct *wq; 1467 1468 wq = nfsiod_workqueue; 1469 if (wq == NULL) 1470 return; 1471 nfsiod_workqueue = NULL; 1472 destroy_workqueue(wq); 1473 } 1474 1475 /* 1476 * Initialize NFS 1477 */ 1478 static int __init init_nfs_fs(void) 1479 { 1480 int err; 1481 1482 err = nfs_dns_resolver_init(); 1483 if (err < 0) 1484 goto out8; 1485 1486 err = nfs_fscache_register(); 1487 if (err < 0) 1488 goto out7; 1489 1490 err = nfsiod_start(); 1491 if (err) 1492 goto out6; 1493 1494 err = nfs_fs_proc_init(); 1495 if (err) 1496 goto out5; 1497 1498 err = nfs_init_nfspagecache(); 1499 if (err) 1500 goto out4; 1501 1502 err = nfs_init_inodecache(); 1503 if (err) 1504 goto out3; 1505 1506 err = nfs_init_readpagecache(); 1507 if (err) 1508 goto out2; 1509 1510 err = nfs_init_writepagecache(); 1511 if (err) 1512 goto out1; 1513 1514 err = nfs_init_directcache(); 1515 if (err) 1516 goto out0; 1517 1518 #ifdef CONFIG_PROC_FS 1519 rpc_proc_register(&nfs_rpcstat); 1520 #endif 1521 if ((err = register_nfs_fs()) != 0) 1522 goto out; 1523 return 0; 1524 out: 1525 #ifdef CONFIG_PROC_FS 1526 rpc_proc_unregister("nfs"); 1527 #endif 1528 nfs_destroy_directcache(); 1529 out0: 1530 nfs_destroy_writepagecache(); 1531 out1: 1532 nfs_destroy_readpagecache(); 1533 out2: 1534 nfs_destroy_inodecache(); 1535 out3: 1536 nfs_destroy_nfspagecache(); 1537 out4: 1538 nfs_fs_proc_exit(); 1539 out5: 1540 nfsiod_stop(); 1541 out6: 1542 nfs_fscache_unregister(); 1543 out7: 1544 nfs_dns_resolver_destroy(); 1545 out8: 1546 return err; 1547 } 1548 1549 static void __exit exit_nfs_fs(void) 1550 { 1551 nfs_destroy_directcache(); 1552 nfs_destroy_writepagecache(); 1553 nfs_destroy_readpagecache(); 1554 nfs_destroy_inodecache(); 1555 nfs_destroy_nfspagecache(); 1556 nfs_fscache_unregister(); 1557 nfs_dns_resolver_destroy(); 1558 #ifdef CONFIG_PROC_FS 1559 rpc_proc_unregister("nfs"); 1560 #endif 1561 unregister_nfs_fs(); 1562 nfs_fs_proc_exit(); 1563 nfsiod_stop(); 1564 } 1565 1566 /* Not quite true; I just maintain it */ 1567 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 1568 MODULE_LICENSE("GPL"); 1569 module_param(enable_ino64, bool, 0644); 1570 1571 module_init(init_nfs_fs) 1572 module_exit(exit_nfs_fs) 1573