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