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