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 = -ENOMEM; 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 fattr = nfs_alloc_fattr(); 422 if (fattr == NULL) 423 goto out; 424 /* 425 * Return any delegations if we're going to change ACLs 426 */ 427 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) 428 nfs_inode_return_delegation(inode); 429 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr); 430 if (error == 0) 431 nfs_refresh_inode(inode, fattr); 432 nfs_free_fattr(fattr); 433 out: 434 return error; 435 } 436 437 /** 438 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall 439 * @inode: inode of the file used 440 * @offset: file offset to start truncating 441 * 442 * This is a copy of the common vmtruncate, but with the locking 443 * corrected to take into account the fact that NFS requires 444 * inode->i_size to be updated under the inode->i_lock. 445 */ 446 static int nfs_vmtruncate(struct inode * inode, loff_t offset) 447 { 448 loff_t oldsize; 449 int err; 450 451 err = inode_newsize_ok(inode, offset); 452 if (err) 453 goto out; 454 455 spin_lock(&inode->i_lock); 456 oldsize = inode->i_size; 457 i_size_write(inode, offset); 458 spin_unlock(&inode->i_lock); 459 460 truncate_pagecache(inode, oldsize, offset); 461 out: 462 return err; 463 } 464 465 /** 466 * nfs_setattr_update_inode - Update inode metadata after a setattr call. 467 * @inode: pointer to struct inode 468 * @attr: pointer to struct iattr 469 * 470 * Note: we do this in the *proc.c in order to ensure that 471 * it works for things like exclusive creates too. 472 */ 473 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr) 474 { 475 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) { 476 spin_lock(&inode->i_lock); 477 if ((attr->ia_valid & ATTR_MODE) != 0) { 478 int mode = attr->ia_mode & S_IALLUGO; 479 mode |= inode->i_mode & ~S_IALLUGO; 480 inode->i_mode = mode; 481 } 482 if ((attr->ia_valid & ATTR_UID) != 0) 483 inode->i_uid = attr->ia_uid; 484 if ((attr->ia_valid & ATTR_GID) != 0) 485 inode->i_gid = attr->ia_gid; 486 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 487 spin_unlock(&inode->i_lock); 488 } 489 if ((attr->ia_valid & ATTR_SIZE) != 0) { 490 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC); 491 nfs_vmtruncate(inode, attr->ia_size); 492 } 493 } 494 495 int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 496 { 497 struct inode *inode = dentry->d_inode; 498 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME; 499 int err; 500 501 /* Flush out writes to the server in order to update c/mtime. */ 502 if (S_ISREG(inode->i_mode)) { 503 err = filemap_write_and_wait(inode->i_mapping); 504 if (err) 505 goto out; 506 } 507 508 /* 509 * We may force a getattr if the user cares about atime. 510 * 511 * Note that we only have to check the vfsmount flags here: 512 * - NFS always sets S_NOATIME by so checking it would give a 513 * bogus result 514 * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is 515 * no point in checking those. 516 */ 517 if ((mnt->mnt_flags & MNT_NOATIME) || 518 ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))) 519 need_atime = 0; 520 521 if (need_atime) 522 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 523 else 524 err = nfs_revalidate_inode(NFS_SERVER(inode), inode); 525 if (!err) { 526 generic_fillattr(inode, stat); 527 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode)); 528 } 529 out: 530 return err; 531 } 532 533 /** 534 * nfs_close_context - Common close_context() routine NFSv2/v3 535 * @ctx: pointer to context 536 * @is_sync: is this a synchronous close 537 * 538 * always ensure that the attributes are up to date if we're mounted 539 * with close-to-open semantics 540 */ 541 void nfs_close_context(struct nfs_open_context *ctx, int is_sync) 542 { 543 struct inode *inode; 544 struct nfs_server *server; 545 546 if (!(ctx->mode & FMODE_WRITE)) 547 return; 548 if (!is_sync) 549 return; 550 inode = ctx->path.dentry->d_inode; 551 if (!list_empty(&NFS_I(inode)->open_files)) 552 return; 553 server = NFS_SERVER(inode); 554 if (server->flags & NFS_MOUNT_NOCTO) 555 return; 556 nfs_revalidate_inode(server, inode); 557 } 558 559 static struct nfs_open_context *alloc_nfs_open_context(struct path *path, struct rpc_cred *cred) 560 { 561 struct nfs_open_context *ctx; 562 563 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); 564 if (ctx != NULL) { 565 ctx->path = *path; 566 path_get(&ctx->path); 567 ctx->cred = get_rpccred(cred); 568 ctx->state = NULL; 569 ctx->lockowner = current->files; 570 ctx->flags = 0; 571 ctx->error = 0; 572 ctx->dir_cookie = 0; 573 atomic_set(&ctx->count, 1); 574 } 575 return ctx; 576 } 577 578 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx) 579 { 580 if (ctx != NULL) 581 atomic_inc(&ctx->count); 582 return ctx; 583 } 584 585 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync) 586 { 587 struct inode *inode = ctx->path.dentry->d_inode; 588 589 if (!atomic_dec_and_lock(&ctx->count, &inode->i_lock)) 590 return; 591 list_del(&ctx->list); 592 spin_unlock(&inode->i_lock); 593 NFS_PROTO(inode)->close_context(ctx, is_sync); 594 if (ctx->cred != NULL) 595 put_rpccred(ctx->cred); 596 path_put(&ctx->path); 597 kfree(ctx); 598 } 599 600 void put_nfs_open_context(struct nfs_open_context *ctx) 601 { 602 __put_nfs_open_context(ctx, 0); 603 } 604 605 /* 606 * Ensure that mmap has a recent RPC credential for use when writing out 607 * shared pages 608 */ 609 static void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx) 610 { 611 struct inode *inode = filp->f_path.dentry->d_inode; 612 struct nfs_inode *nfsi = NFS_I(inode); 613 614 filp->private_data = get_nfs_open_context(ctx); 615 spin_lock(&inode->i_lock); 616 list_add(&ctx->list, &nfsi->open_files); 617 spin_unlock(&inode->i_lock); 618 } 619 620 /* 621 * Given an inode, search for an open context with the desired characteristics 622 */ 623 struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode) 624 { 625 struct nfs_inode *nfsi = NFS_I(inode); 626 struct nfs_open_context *pos, *ctx = NULL; 627 628 spin_lock(&inode->i_lock); 629 list_for_each_entry(pos, &nfsi->open_files, list) { 630 if (cred != NULL && pos->cred != cred) 631 continue; 632 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode) 633 continue; 634 ctx = get_nfs_open_context(pos); 635 break; 636 } 637 spin_unlock(&inode->i_lock); 638 return ctx; 639 } 640 641 static void nfs_file_clear_open_context(struct file *filp) 642 { 643 struct inode *inode = filp->f_path.dentry->d_inode; 644 struct nfs_open_context *ctx = nfs_file_open_context(filp); 645 646 if (ctx) { 647 filp->private_data = NULL; 648 spin_lock(&inode->i_lock); 649 list_move_tail(&ctx->list, &NFS_I(inode)->open_files); 650 spin_unlock(&inode->i_lock); 651 __put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1); 652 } 653 } 654 655 /* 656 * These allocate and release file read/write context information. 657 */ 658 int nfs_open(struct inode *inode, struct file *filp) 659 { 660 struct nfs_open_context *ctx; 661 struct rpc_cred *cred; 662 663 cred = rpc_lookup_cred(); 664 if (IS_ERR(cred)) 665 return PTR_ERR(cred); 666 ctx = alloc_nfs_open_context(&filp->f_path, cred); 667 put_rpccred(cred); 668 if (ctx == NULL) 669 return -ENOMEM; 670 ctx->mode = filp->f_mode; 671 nfs_file_set_open_context(filp, ctx); 672 put_nfs_open_context(ctx); 673 nfs_fscache_set_inode_cookie(inode, filp); 674 return 0; 675 } 676 677 int nfs_release(struct inode *inode, struct file *filp) 678 { 679 nfs_file_clear_open_context(filp); 680 return 0; 681 } 682 683 /* 684 * This function is called whenever some part of NFS notices that 685 * the cached attributes have to be refreshed. 686 */ 687 int 688 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 689 { 690 int status = -ESTALE; 691 struct nfs_fattr *fattr = NULL; 692 struct nfs_inode *nfsi = NFS_I(inode); 693 694 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n", 695 inode->i_sb->s_id, (long long)NFS_FILEID(inode)); 696 697 if (is_bad_inode(inode)) 698 goto out; 699 if (NFS_STALE(inode)) 700 goto out; 701 702 status = -ENOMEM; 703 fattr = nfs_alloc_fattr(); 704 if (fattr == NULL) 705 goto out; 706 707 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE); 708 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr); 709 if (status != 0) { 710 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n", 711 inode->i_sb->s_id, 712 (long long)NFS_FILEID(inode), status); 713 if (status == -ESTALE) { 714 nfs_zap_caches(inode); 715 if (!S_ISDIR(inode->i_mode)) 716 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 717 } 718 goto out; 719 } 720 721 status = nfs_refresh_inode(inode, fattr); 722 if (status) { 723 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n", 724 inode->i_sb->s_id, 725 (long long)NFS_FILEID(inode), status); 726 goto out; 727 } 728 729 if (nfsi->cache_validity & NFS_INO_INVALID_ACL) 730 nfs_zap_acl_cache(inode); 731 732 dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n", 733 inode->i_sb->s_id, 734 (long long)NFS_FILEID(inode)); 735 736 out: 737 nfs_free_fattr(fattr); 738 return status; 739 } 740 741 int nfs_attribute_timeout(struct inode *inode) 742 { 743 struct nfs_inode *nfsi = NFS_I(inode); 744 745 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo); 746 } 747 748 static int nfs_attribute_cache_expired(struct inode *inode) 749 { 750 if (nfs_have_delegated_attributes(inode)) 751 return 0; 752 return nfs_attribute_timeout(inode); 753 } 754 755 /** 756 * nfs_revalidate_inode - Revalidate the inode attributes 757 * @server - pointer to nfs_server struct 758 * @inode - pointer to inode struct 759 * 760 * Updates inode attribute information by retrieving the data from the server. 761 */ 762 int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 763 { 764 if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR) 765 && !nfs_attribute_cache_expired(inode)) 766 return NFS_STALE(inode) ? -ESTALE : 0; 767 return __nfs_revalidate_inode(server, inode); 768 } 769 770 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping) 771 { 772 struct nfs_inode *nfsi = NFS_I(inode); 773 774 if (mapping->nrpages != 0) { 775 int ret = invalidate_inode_pages2(mapping); 776 if (ret < 0) 777 return ret; 778 } 779 spin_lock(&inode->i_lock); 780 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA; 781 if (S_ISDIR(inode->i_mode)) 782 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf)); 783 spin_unlock(&inode->i_lock); 784 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE); 785 nfs_fscache_reset_inode_cookie(inode); 786 dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n", 787 inode->i_sb->s_id, (long long)NFS_FILEID(inode)); 788 return 0; 789 } 790 791 /** 792 * nfs_revalidate_mapping - Revalidate the pagecache 793 * @inode - pointer to host inode 794 * @mapping - pointer to mapping 795 */ 796 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) 797 { 798 struct nfs_inode *nfsi = NFS_I(inode); 799 int ret = 0; 800 801 if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE) 802 || nfs_attribute_cache_expired(inode) 803 || NFS_STALE(inode)) { 804 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 805 if (ret < 0) 806 goto out; 807 } 808 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 809 ret = nfs_invalidate_mapping(inode, mapping); 810 out: 811 return ret; 812 } 813 814 static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr) 815 { 816 struct nfs_inode *nfsi = NFS_I(inode); 817 818 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE) 819 && (fattr->valid & NFS_ATTR_FATTR_CHANGE) 820 && nfsi->change_attr == fattr->pre_change_attr) { 821 nfsi->change_attr = fattr->change_attr; 822 if (S_ISDIR(inode->i_mode)) 823 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 824 } 825 /* If we have atomic WCC data, we may update some attributes */ 826 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME) 827 && (fattr->valid & NFS_ATTR_FATTR_CTIME) 828 && timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) 829 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); 830 831 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME) 832 && (fattr->valid & NFS_ATTR_FATTR_MTIME) 833 && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) { 834 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); 835 if (S_ISDIR(inode->i_mode)) 836 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 837 } 838 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE) 839 && (fattr->valid & NFS_ATTR_FATTR_SIZE) 840 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size) 841 && nfsi->npages == 0) 842 i_size_write(inode, nfs_size_to_loff_t(fattr->size)); 843 } 844 845 /** 846 * nfs_check_inode_attributes - verify consistency of the inode attribute cache 847 * @inode - pointer to inode 848 * @fattr - updated attributes 849 * 850 * Verifies the attribute cache. If we have just changed the attributes, 851 * so that fattr carries weak cache consistency data, then it may 852 * also update the ctime/mtime/change_attribute. 853 */ 854 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr) 855 { 856 struct nfs_inode *nfsi = NFS_I(inode); 857 loff_t cur_size, new_isize; 858 unsigned long invalid = 0; 859 860 861 /* Has the inode gone and changed behind our back? */ 862 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) 863 return -EIO; 864 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) 865 return -EIO; 866 867 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 868 nfsi->change_attr != fattr->change_attr) 869 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 870 871 /* Verify a few of the more important attributes */ 872 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime)) 873 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 874 875 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 876 cur_size = i_size_read(inode); 877 new_isize = nfs_size_to_loff_t(fattr->size); 878 if (cur_size != new_isize && nfsi->npages == 0) 879 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 880 } 881 882 /* Have any file permissions changed? */ 883 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) 884 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 885 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && inode->i_uid != fattr->uid) 886 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 887 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && inode->i_gid != fattr->gid) 888 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL; 889 890 /* Has the link count changed? */ 891 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink) 892 invalid |= NFS_INO_INVALID_ATTR; 893 894 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime)) 895 invalid |= NFS_INO_INVALID_ATIME; 896 897 if (invalid != 0) 898 nfsi->cache_validity |= invalid; 899 900 nfsi->read_cache_jiffies = fattr->time_start; 901 return 0; 902 } 903 904 static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 905 { 906 if (!(fattr->valid & NFS_ATTR_FATTR_CTIME)) 907 return 0; 908 return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0; 909 } 910 911 static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 912 { 913 if (!(fattr->valid & NFS_ATTR_FATTR_SIZE)) 914 return 0; 915 return nfs_size_to_loff_t(fattr->size) > i_size_read(inode); 916 } 917 918 static atomic_long_t nfs_attr_generation_counter; 919 920 static unsigned long nfs_read_attr_generation_counter(void) 921 { 922 return atomic_long_read(&nfs_attr_generation_counter); 923 } 924 925 unsigned long nfs_inc_attr_generation_counter(void) 926 { 927 return atomic_long_inc_return(&nfs_attr_generation_counter); 928 } 929 930 void nfs_fattr_init(struct nfs_fattr *fattr) 931 { 932 fattr->valid = 0; 933 fattr->time_start = jiffies; 934 fattr->gencount = nfs_inc_attr_generation_counter(); 935 } 936 937 struct nfs_fattr *nfs_alloc_fattr(void) 938 { 939 struct nfs_fattr *fattr; 940 941 fattr = kmalloc(sizeof(*fattr), GFP_NOFS); 942 if (fattr != NULL) 943 nfs_fattr_init(fattr); 944 return fattr; 945 } 946 947 struct nfs_fh *nfs_alloc_fhandle(void) 948 { 949 struct nfs_fh *fh; 950 951 fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS); 952 if (fh != NULL) 953 fh->size = 0; 954 return fh; 955 } 956 957 /** 958 * nfs_inode_attrs_need_update - check if the inode attributes need updating 959 * @inode - pointer to inode 960 * @fattr - attributes 961 * 962 * Attempt to divine whether or not an RPC call reply carrying stale 963 * attributes got scheduled after another call carrying updated ones. 964 * 965 * To do so, the function first assumes that a more recent ctime means 966 * that the attributes in fattr are newer, however it also attempt to 967 * catch the case where ctime either didn't change, or went backwards 968 * (if someone reset the clock on the server) by looking at whether 969 * or not this RPC call was started after the inode was last updated. 970 * Note also the check for wraparound of 'attr_gencount' 971 * 972 * The function returns 'true' if it thinks the attributes in 'fattr' are 973 * more recent than the ones cached in the inode. 974 * 975 */ 976 static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr) 977 { 978 const struct nfs_inode *nfsi = NFS_I(inode); 979 980 return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 || 981 nfs_ctime_need_update(inode, fattr) || 982 nfs_size_need_update(inode, fattr) || 983 ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0); 984 } 985 986 static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr) 987 { 988 if (nfs_inode_attrs_need_update(inode, fattr)) 989 return nfs_update_inode(inode, fattr); 990 return nfs_check_inode_attributes(inode, fattr); 991 } 992 993 /** 994 * nfs_refresh_inode - try to update the inode attribute cache 995 * @inode - pointer to inode 996 * @fattr - updated attributes 997 * 998 * Check that an RPC call that returned attributes has not overlapped with 999 * other recent updates of the inode metadata, then decide whether it is 1000 * safe to do a full update of the inode attributes, or whether just to 1001 * call nfs_check_inode_attributes. 1002 */ 1003 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr) 1004 { 1005 int status; 1006 1007 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 1008 return 0; 1009 spin_lock(&inode->i_lock); 1010 status = nfs_refresh_inode_locked(inode, fattr); 1011 spin_unlock(&inode->i_lock); 1012 1013 return status; 1014 } 1015 1016 static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr) 1017 { 1018 struct nfs_inode *nfsi = NFS_I(inode); 1019 1020 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; 1021 if (S_ISDIR(inode->i_mode)) 1022 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 1023 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 1024 return 0; 1025 return nfs_refresh_inode_locked(inode, fattr); 1026 } 1027 1028 /** 1029 * nfs_post_op_update_inode - try to update the inode attribute cache 1030 * @inode - pointer to inode 1031 * @fattr - updated attributes 1032 * 1033 * After an operation that has changed the inode metadata, mark the 1034 * attribute cache as being invalid, then try to update it. 1035 * 1036 * NB: if the server didn't return any post op attributes, this 1037 * function will force the retrieval of attributes before the next 1038 * NFS request. Thus it should be used only for operations that 1039 * are expected to change one or more attributes, to avoid 1040 * unnecessary NFS requests and trips through nfs_update_inode(). 1041 */ 1042 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1043 { 1044 int status; 1045 1046 spin_lock(&inode->i_lock); 1047 status = nfs_post_op_update_inode_locked(inode, fattr); 1048 spin_unlock(&inode->i_lock); 1049 return status; 1050 } 1051 1052 /** 1053 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache 1054 * @inode - pointer to inode 1055 * @fattr - updated attributes 1056 * 1057 * After an operation that has changed the inode metadata, mark the 1058 * attribute cache as being invalid, then try to update it. Fake up 1059 * weak cache consistency data, if none exist. 1060 * 1061 * This function is mainly designed to be used by the ->write_done() functions. 1062 */ 1063 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr) 1064 { 1065 int status; 1066 1067 spin_lock(&inode->i_lock); 1068 /* Don't do a WCC update if these attributes are already stale */ 1069 if ((fattr->valid & NFS_ATTR_FATTR) == 0 || 1070 !nfs_inode_attrs_need_update(inode, fattr)) { 1071 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE 1072 | NFS_ATTR_FATTR_PRESIZE 1073 | NFS_ATTR_FATTR_PREMTIME 1074 | NFS_ATTR_FATTR_PRECTIME); 1075 goto out_noforce; 1076 } 1077 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && 1078 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) { 1079 fattr->pre_change_attr = NFS_I(inode)->change_attr; 1080 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE; 1081 } 1082 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 && 1083 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) { 1084 memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime)); 1085 fattr->valid |= NFS_ATTR_FATTR_PRECTIME; 1086 } 1087 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 && 1088 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) { 1089 memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime)); 1090 fattr->valid |= NFS_ATTR_FATTR_PREMTIME; 1091 } 1092 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 && 1093 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) { 1094 fattr->pre_size = i_size_read(inode); 1095 fattr->valid |= NFS_ATTR_FATTR_PRESIZE; 1096 } 1097 out_noforce: 1098 status = nfs_post_op_update_inode_locked(inode, fattr); 1099 spin_unlock(&inode->i_lock); 1100 return status; 1101 } 1102 1103 /* 1104 * Many nfs protocol calls return the new file attributes after 1105 * an operation. Here we update the inode to reflect the state 1106 * of the server's inode. 1107 * 1108 * This is a bit tricky because we have to make sure all dirty pages 1109 * have been sent off to the server before calling invalidate_inode_pages. 1110 * To make sure no other process adds more write requests while we try 1111 * our best to flush them, we make them sleep during the attribute refresh. 1112 * 1113 * A very similar scenario holds for the dir cache. 1114 */ 1115 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 1116 { 1117 struct nfs_server *server; 1118 struct nfs_inode *nfsi = NFS_I(inode); 1119 loff_t cur_isize, new_isize; 1120 unsigned long invalid = 0; 1121 unsigned long now = jiffies; 1122 unsigned long save_cache_validity; 1123 1124 dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n", 1125 __func__, inode->i_sb->s_id, inode->i_ino, 1126 atomic_read(&inode->i_count), fattr->valid); 1127 1128 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) 1129 goto out_fileid; 1130 1131 /* 1132 * Make sure the inode's type hasn't changed. 1133 */ 1134 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) 1135 goto out_changed; 1136 1137 server = NFS_SERVER(inode); 1138 /* Update the fsid? */ 1139 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) && 1140 !nfs_fsid_equal(&server->fsid, &fattr->fsid) && 1141 !test_bit(NFS_INO_MOUNTPOINT, &nfsi->flags)) 1142 server->fsid = fattr->fsid; 1143 1144 /* 1145 * Update the read time so we don't revalidate too often. 1146 */ 1147 nfsi->read_cache_jiffies = fattr->time_start; 1148 1149 save_cache_validity = nfsi->cache_validity; 1150 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR 1151 | NFS_INO_INVALID_ATIME 1152 | NFS_INO_REVAL_FORCED 1153 | NFS_INO_REVAL_PAGECACHE); 1154 1155 /* Do atomic weak cache consistency updates */ 1156 nfs_wcc_update_inode(inode, fattr); 1157 1158 /* More cache consistency checks */ 1159 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) { 1160 if (nfsi->change_attr != fattr->change_attr) { 1161 dprintk("NFS: change_attr change on server for file %s/%ld\n", 1162 inode->i_sb->s_id, inode->i_ino); 1163 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1164 if (S_ISDIR(inode->i_mode)) 1165 nfs_force_lookup_revalidate(inode); 1166 nfsi->change_attr = fattr->change_attr; 1167 } 1168 } else if (server->caps & NFS_CAP_CHANGE_ATTR) 1169 invalid |= save_cache_validity; 1170 1171 if (fattr->valid & NFS_ATTR_FATTR_MTIME) { 1172 /* NFSv2/v3: Check if the mtime agrees */ 1173 if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) { 1174 dprintk("NFS: mtime change on server for file %s/%ld\n", 1175 inode->i_sb->s_id, inode->i_ino); 1176 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA; 1177 if (S_ISDIR(inode->i_mode)) 1178 nfs_force_lookup_revalidate(inode); 1179 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); 1180 } 1181 } else if (server->caps & NFS_CAP_MTIME) 1182 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1183 | NFS_INO_INVALID_DATA 1184 | NFS_INO_REVAL_PAGECACHE 1185 | NFS_INO_REVAL_FORCED); 1186 1187 if (fattr->valid & NFS_ATTR_FATTR_CTIME) { 1188 /* If ctime has changed we should definitely clear access+acl caches */ 1189 if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) { 1190 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1191 /* and probably clear data for a directory too as utimes can cause 1192 * havoc with our cache. 1193 */ 1194 if (S_ISDIR(inode->i_mode)) { 1195 invalid |= NFS_INO_INVALID_DATA; 1196 nfs_force_lookup_revalidate(inode); 1197 } 1198 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); 1199 } 1200 } else if (server->caps & NFS_CAP_CTIME) 1201 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1202 | NFS_INO_INVALID_ACCESS 1203 | NFS_INO_INVALID_ACL 1204 | NFS_INO_REVAL_FORCED); 1205 1206 /* Check if our cached file size is stale */ 1207 if (fattr->valid & NFS_ATTR_FATTR_SIZE) { 1208 new_isize = nfs_size_to_loff_t(fattr->size); 1209 cur_isize = i_size_read(inode); 1210 if (new_isize != cur_isize) { 1211 /* Do we perhaps have any outstanding writes, or has 1212 * the file grown beyond our last write? */ 1213 if (nfsi->npages == 0 || new_isize > cur_isize) { 1214 i_size_write(inode, new_isize); 1215 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA; 1216 } 1217 dprintk("NFS: isize change on server for file %s/%ld\n", 1218 inode->i_sb->s_id, inode->i_ino); 1219 } 1220 } else 1221 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1222 | NFS_INO_REVAL_PAGECACHE 1223 | NFS_INO_REVAL_FORCED); 1224 1225 1226 if (fattr->valid & NFS_ATTR_FATTR_ATIME) 1227 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime)); 1228 else if (server->caps & NFS_CAP_ATIME) 1229 invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME 1230 | NFS_INO_REVAL_FORCED); 1231 1232 if (fattr->valid & NFS_ATTR_FATTR_MODE) { 1233 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) { 1234 umode_t newmode = inode->i_mode & S_IFMT; 1235 newmode |= fattr->mode & S_IALLUGO; 1236 inode->i_mode = newmode; 1237 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1238 } 1239 } else if (server->caps & NFS_CAP_MODE) 1240 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1241 | NFS_INO_INVALID_ACCESS 1242 | NFS_INO_INVALID_ACL 1243 | NFS_INO_REVAL_FORCED); 1244 1245 if (fattr->valid & NFS_ATTR_FATTR_OWNER) { 1246 if (inode->i_uid != fattr->uid) { 1247 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1248 inode->i_uid = fattr->uid; 1249 } 1250 } else if (server->caps & NFS_CAP_OWNER) 1251 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1252 | NFS_INO_INVALID_ACCESS 1253 | NFS_INO_INVALID_ACL 1254 | NFS_INO_REVAL_FORCED); 1255 1256 if (fattr->valid & NFS_ATTR_FATTR_GROUP) { 1257 if (inode->i_gid != fattr->gid) { 1258 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 1259 inode->i_gid = fattr->gid; 1260 } 1261 } else if (server->caps & NFS_CAP_OWNER_GROUP) 1262 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1263 | NFS_INO_INVALID_ACCESS 1264 | NFS_INO_INVALID_ACL 1265 | NFS_INO_REVAL_FORCED); 1266 1267 if (fattr->valid & NFS_ATTR_FATTR_NLINK) { 1268 if (inode->i_nlink != fattr->nlink) { 1269 invalid |= NFS_INO_INVALID_ATTR; 1270 if (S_ISDIR(inode->i_mode)) 1271 invalid |= NFS_INO_INVALID_DATA; 1272 inode->i_nlink = fattr->nlink; 1273 } 1274 } else if (server->caps & NFS_CAP_NLINK) 1275 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR 1276 | NFS_INO_REVAL_FORCED); 1277 1278 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { 1279 /* 1280 * report the blocks in 512byte units 1281 */ 1282 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 1283 } 1284 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) 1285 inode->i_blocks = fattr->du.nfs2.blocks; 1286 1287 /* Update attrtimeo value if we're out of the unstable period */ 1288 if (invalid & NFS_INO_INVALID_ATTR) { 1289 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE); 1290 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 1291 nfsi->attrtimeo_timestamp = now; 1292 nfsi->attr_gencount = nfs_inc_attr_generation_counter(); 1293 } else { 1294 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) { 1295 if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode)) 1296 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode); 1297 nfsi->attrtimeo_timestamp = now; 1298 } 1299 } 1300 invalid &= ~NFS_INO_INVALID_ATTR; 1301 /* Don't invalidate the data if we were to blame */ 1302 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) 1303 || S_ISLNK(inode->i_mode))) 1304 invalid &= ~NFS_INO_INVALID_DATA; 1305 if (!nfs_have_delegation(inode, FMODE_READ) || 1306 (save_cache_validity & NFS_INO_REVAL_FORCED)) 1307 nfsi->cache_validity |= invalid; 1308 1309 return 0; 1310 out_changed: 1311 /* 1312 * Big trouble! The inode has become a different object. 1313 */ 1314 printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n", 1315 __func__, inode->i_ino, inode->i_mode, fattr->mode); 1316 out_err: 1317 /* 1318 * No need to worry about unhashing the dentry, as the 1319 * lookup validation will know that the inode is bad. 1320 * (But we fall through to invalidate the caches.) 1321 */ 1322 nfs_invalidate_inode(inode); 1323 return -ESTALE; 1324 1325 out_fileid: 1326 printk(KERN_ERR "NFS: server %s error: fileid changed\n" 1327 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n", 1328 NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id, 1329 (long long)nfsi->fileid, (long long)fattr->fileid); 1330 goto out_err; 1331 } 1332 1333 1334 #ifdef CONFIG_NFS_V4 1335 1336 /* 1337 * Clean out any remaining NFSv4 state that might be left over due 1338 * to open() calls that passed nfs_atomic_lookup, but failed to call 1339 * nfs_open(). 1340 */ 1341 void nfs4_clear_inode(struct inode *inode) 1342 { 1343 /* If we are holding a delegation, return it! */ 1344 nfs_inode_return_delegation_noreclaim(inode); 1345 /* First call standard NFS clear_inode() code */ 1346 nfs_clear_inode(inode); 1347 } 1348 #endif 1349 1350 struct inode *nfs_alloc_inode(struct super_block *sb) 1351 { 1352 struct nfs_inode *nfsi; 1353 nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL); 1354 if (!nfsi) 1355 return NULL; 1356 nfsi->flags = 0UL; 1357 nfsi->cache_validity = 0UL; 1358 #ifdef CONFIG_NFS_V3_ACL 1359 nfsi->acl_access = ERR_PTR(-EAGAIN); 1360 nfsi->acl_default = ERR_PTR(-EAGAIN); 1361 #endif 1362 #ifdef CONFIG_NFS_V4 1363 nfsi->nfs4_acl = NULL; 1364 #endif /* CONFIG_NFS_V4 */ 1365 return &nfsi->vfs_inode; 1366 } 1367 1368 void nfs_destroy_inode(struct inode *inode) 1369 { 1370 kmem_cache_free(nfs_inode_cachep, NFS_I(inode)); 1371 } 1372 1373 static inline void nfs4_init_once(struct nfs_inode *nfsi) 1374 { 1375 #ifdef CONFIG_NFS_V4 1376 INIT_LIST_HEAD(&nfsi->open_states); 1377 nfsi->delegation = NULL; 1378 nfsi->delegation_state = 0; 1379 init_rwsem(&nfsi->rwsem); 1380 #endif 1381 } 1382 1383 static void init_once(void *foo) 1384 { 1385 struct nfs_inode *nfsi = (struct nfs_inode *) foo; 1386 1387 inode_init_once(&nfsi->vfs_inode); 1388 INIT_LIST_HEAD(&nfsi->open_files); 1389 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru); 1390 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru); 1391 INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC); 1392 nfsi->npages = 0; 1393 nfsi->ncommit = 0; 1394 atomic_set(&nfsi->silly_count, 1); 1395 INIT_HLIST_HEAD(&nfsi->silly_list); 1396 init_waitqueue_head(&nfsi->waitqueue); 1397 nfs4_init_once(nfsi); 1398 } 1399 1400 static int __init nfs_init_inodecache(void) 1401 { 1402 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", 1403 sizeof(struct nfs_inode), 1404 0, (SLAB_RECLAIM_ACCOUNT| 1405 SLAB_MEM_SPREAD), 1406 init_once); 1407 if (nfs_inode_cachep == NULL) 1408 return -ENOMEM; 1409 1410 return 0; 1411 } 1412 1413 static void nfs_destroy_inodecache(void) 1414 { 1415 kmem_cache_destroy(nfs_inode_cachep); 1416 } 1417 1418 struct workqueue_struct *nfsiod_workqueue; 1419 1420 /* 1421 * start up the nfsiod workqueue 1422 */ 1423 static int nfsiod_start(void) 1424 { 1425 struct workqueue_struct *wq; 1426 dprintk("RPC: creating workqueue nfsiod\n"); 1427 wq = create_singlethread_workqueue("nfsiod"); 1428 if (wq == NULL) 1429 return -ENOMEM; 1430 nfsiod_workqueue = wq; 1431 return 0; 1432 } 1433 1434 /* 1435 * Destroy the nfsiod workqueue 1436 */ 1437 static void nfsiod_stop(void) 1438 { 1439 struct workqueue_struct *wq; 1440 1441 wq = nfsiod_workqueue; 1442 if (wq == NULL) 1443 return; 1444 nfsiod_workqueue = NULL; 1445 destroy_workqueue(wq); 1446 } 1447 1448 /* 1449 * Initialize NFS 1450 */ 1451 static int __init init_nfs_fs(void) 1452 { 1453 int err; 1454 1455 err = nfs_dns_resolver_init(); 1456 if (err < 0) 1457 goto out8; 1458 1459 err = nfs_fscache_register(); 1460 if (err < 0) 1461 goto out7; 1462 1463 err = nfsiod_start(); 1464 if (err) 1465 goto out6; 1466 1467 err = nfs_fs_proc_init(); 1468 if (err) 1469 goto out5; 1470 1471 err = nfs_init_nfspagecache(); 1472 if (err) 1473 goto out4; 1474 1475 err = nfs_init_inodecache(); 1476 if (err) 1477 goto out3; 1478 1479 err = nfs_init_readpagecache(); 1480 if (err) 1481 goto out2; 1482 1483 err = nfs_init_writepagecache(); 1484 if (err) 1485 goto out1; 1486 1487 err = nfs_init_directcache(); 1488 if (err) 1489 goto out0; 1490 1491 #ifdef CONFIG_PROC_FS 1492 rpc_proc_register(&nfs_rpcstat); 1493 #endif 1494 if ((err = register_nfs_fs()) != 0) 1495 goto out; 1496 return 0; 1497 out: 1498 #ifdef CONFIG_PROC_FS 1499 rpc_proc_unregister("nfs"); 1500 #endif 1501 nfs_destroy_directcache(); 1502 out0: 1503 nfs_destroy_writepagecache(); 1504 out1: 1505 nfs_destroy_readpagecache(); 1506 out2: 1507 nfs_destroy_inodecache(); 1508 out3: 1509 nfs_destroy_nfspagecache(); 1510 out4: 1511 nfs_fs_proc_exit(); 1512 out5: 1513 nfsiod_stop(); 1514 out6: 1515 nfs_fscache_unregister(); 1516 out7: 1517 nfs_dns_resolver_destroy(); 1518 out8: 1519 return err; 1520 } 1521 1522 static void __exit exit_nfs_fs(void) 1523 { 1524 nfs_destroy_directcache(); 1525 nfs_destroy_writepagecache(); 1526 nfs_destroy_readpagecache(); 1527 nfs_destroy_inodecache(); 1528 nfs_destroy_nfspagecache(); 1529 nfs_fscache_unregister(); 1530 nfs_dns_resolver_destroy(); 1531 #ifdef CONFIG_PROC_FS 1532 rpc_proc_unregister("nfs"); 1533 #endif 1534 unregister_nfs_fs(); 1535 nfs_fs_proc_exit(); 1536 nfsiod_stop(); 1537 } 1538 1539 /* Not quite true; I just maintain it */ 1540 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 1541 MODULE_LICENSE("GPL"); 1542 module_param(enable_ino64, bool, 0644); 1543 1544 module_init(init_nfs_fs) 1545 module_exit(exit_nfs_fs) 1546