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