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