inode.c 47.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/*
 *  linux/fs/nfs/inode.c
 *
 *  Copyright (C) 1992  Rick Sladkey
 *
 *  nfs inode and superblock handling functions
 *
A
Alan Cox 已提交
8
 *  Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
L
Linus Torvalds 已提交
9 10 11 12 13 14 15 16 17
 *  experimental NFS changes. Modularisation taken straight from SYS5 fs.
 *
 *  Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
 *  J.S.Peatfield@damtp.cam.ac.uk
 *
 */

#include <linux/module.h>
#include <linux/init.h>
A
Alexey Dobriyan 已提交
18
#include <linux/sched.h>
L
Linus Torvalds 已提交
19 20 21 22 23 24 25 26 27
#include <linux/time.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/stat.h>
#include <linux/errno.h>
#include <linux/unistd.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/stats.h>
28
#include <linux/sunrpc/metrics.h>
L
Linus Torvalds 已提交
29 30 31 32 33 34 35 36
#include <linux/nfs_fs.h>
#include <linux/nfs_mount.h>
#include <linux/nfs4_mount.h>
#include <linux/lockd/bind.h>
#include <linux/seq_file.h>
#include <linux/mount.h>
#include <linux/nfs_idmap.h>
#include <linux/vfs.h>
37 38
#include <linux/inet.h>
#include <linux/nfs_xdr.h>
39
#include <linux/slab.h>
40
#include <linux/compat.h>
41
#include <linux/freezer.h>
L
Linus Torvalds 已提交
42 43 44 45

#include <asm/system.h>
#include <asm/uaccess.h>

46
#include "nfs4_fs.h"
47
#include "callback.h"
L
Linus Torvalds 已提交
48
#include "delegation.h"
49
#include "iostat.h"
D
David Howells 已提交
50
#include "internal.h"
51
#include "fscache.h"
52
#include "dns_resolve.h"
53
#include "pnfs.h"
54
#include "netns.h"
L
Linus Torvalds 已提交
55 56 57

#define NFSDBG_FACILITY		NFSDBG_VFS

58 59 60
#define NFS_64_BIT_INODE_NUMBERS_ENABLED	1

/* Default is to see 64-bit inode numbers */
61
static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
62

L
Linus Torvalds 已提交
63
static void nfs_invalidate_inode(struct inode *);
64
static int nfs_update_inode(struct inode *, struct nfs_fattr *);
L
Linus Torvalds 已提交
65

66
static struct kmem_cache * nfs_inode_cachep;
67

L
Linus Torvalds 已提交
68 69 70 71 72 73
static inline unsigned long
nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
{
	return nfs_fileid_to_ino_t(fattr->fileid);
}

74 75 76 77 78 79 80 81
/**
 * nfs_wait_bit_killable - helper for functions that are sleeping on bit locks
 * @word: long word containing the bit lock
 */
int nfs_wait_bit_killable(void *word)
{
	if (fatal_signal_pending(current))
		return -ERESTARTSYS;
82
	freezable_schedule();
83 84 85
	return 0;
}

86 87 88 89 90 91 92 93 94
/**
 * nfs_compat_user_ino64 - returns the user-visible inode number
 * @fileid: 64-bit fileid
 *
 * This function returns a 32-bit inode number if the boot parameter
 * nfs.enable_ino64 is zero.
 */
u64 nfs_compat_user_ino64(u64 fileid)
{
95 96 97 98 99
#ifdef CONFIG_COMPAT
	compat_ulong_t ino;
#else	
	unsigned long ino;
#endif
100 101 102 103 104 105 106 107 108

	if (enable_ino64)
		return fileid;
	ino = fileid;
	if (sizeof(ino) < sizeof(fileid))
		ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
	return ino;
}

109
static void nfs_clear_inode(struct inode *inode)
L
Linus Torvalds 已提交
110
{
T
Trond Myklebust 已提交
111 112 113 114
	/*
	 * The following should never happen...
	 */
	BUG_ON(nfs_have_writebacks(inode));
115
	BUG_ON(!list_empty(&NFS_I(inode)->open_files));
116
	nfs_zap_acl_cache(inode);
117
	nfs_access_zap_cache(inode);
D
David Howells 已提交
118
	nfs_fscache_release_inode_cookie(inode);
L
Linus Torvalds 已提交
119 120
}

121 122 123 124 125 126 127
void nfs_evict_inode(struct inode *inode)
{
	truncate_inode_pages(&inode->i_data, 0);
	end_writeback(inode);
	nfs_clear_inode(inode);
}

T
Trond Myklebust 已提交
128 129 130 131 132
/**
 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
 */
int nfs_sync_mapping(struct address_space *mapping)
{
T
Trond Myklebust 已提交
133
	int ret = 0;
T
Trond Myklebust 已提交
134

T
Trond Myklebust 已提交
135 136 137 138
	if (mapping->nrpages != 0) {
		unmap_mapping_range(mapping, 0, 0, 0);
		ret = nfs_wb_all(mapping->host);
	}
T
Trond Myklebust 已提交
139 140 141
	return ret;
}

L
Linus Torvalds 已提交
142 143 144
/*
 * Invalidate the local caches
 */
145
static void nfs_zap_caches_locked(struct inode *inode)
L
Linus Torvalds 已提交
146 147 148 149
{
	struct nfs_inode *nfsi = NFS_I(inode);
	int mode = inode->i_mode;

C
Chuck Lever 已提交
150 151
	nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);

152 153
	nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
	nfsi->attrtimeo_timestamp = jiffies;
L
Linus Torvalds 已提交
154 155 156

	memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode)));
	if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
157
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
L
Linus Torvalds 已提交
158
	else
159
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
160
}
161

162 163 164 165
void nfs_zap_caches(struct inode *inode)
{
	spin_lock(&inode->i_lock);
	nfs_zap_caches_locked(inode);
166
	spin_unlock(&inode->i_lock);
167 168
}

169 170 171 172 173 174 175 176 177
void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
{
	if (mapping->nrpages != 0) {
		spin_lock(&inode->i_lock);
		NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
		spin_unlock(&inode->i_lock);
	}
}

178
void nfs_zap_acl_cache(struct inode *inode)
179 180 181 182 183 184
{
	void (*clear_acl_cache)(struct inode *);

	clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
	if (clear_acl_cache != NULL)
		clear_acl_cache(inode);
185
	spin_lock(&inode->i_lock);
186
	NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
187
	spin_unlock(&inode->i_lock);
L
Linus Torvalds 已提交
188 189
}

190 191 192 193 194 195 196
void nfs_invalidate_atime(struct inode *inode)
{
	spin_lock(&inode->i_lock);
	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
	spin_unlock(&inode->i_lock);
}

L
Linus Torvalds 已提交
197
/*
198 199
 * Invalidate, but do not unhash, the inode.
 * NB: must be called with inode->i_lock held!
L
Linus Torvalds 已提交
200
 */
201
static void nfs_invalidate_inode(struct inode *inode)
L
Linus Torvalds 已提交
202
{
B
Benny Halevy 已提交
203
	set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
204
	nfs_zap_caches_locked(inode);
L
Linus Torvalds 已提交
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
}

struct nfs_find_desc {
	struct nfs_fh		*fh;
	struct nfs_fattr	*fattr;
};

/*
 * In NFSv3 we can have 64bit inode numbers. In order to support
 * this, and re-exported directories (also seen in NFSv2)
 * we are forced to allow 2 different inodes to have the same
 * i_ino.
 */
static int
nfs_find_actor(struct inode *inode, void *opaque)
{
	struct nfs_find_desc	*desc = (struct nfs_find_desc *)opaque;
	struct nfs_fh		*fh = desc->fh;
	struct nfs_fattr	*fattr = desc->fattr;

	if (NFS_FILEID(inode) != fattr->fileid)
		return 0;
	if (nfs_compare_fh(NFS_FH(inode), fh))
		return 0;
	if (is_bad_inode(inode) || NFS_STALE(inode))
		return 0;
	return 1;
}

static int
nfs_init_locked(struct inode *inode, void *opaque)
{
	struct nfs_find_desc	*desc = (struct nfs_find_desc *)opaque;
	struct nfs_fattr	*fattr = desc->fattr;

240
	set_nfs_fileid(inode, fattr->fileid);
L
Linus Torvalds 已提交
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
	nfs_copy_fh(NFS_FH(inode), desc->fh);
	return 0;
}

/*
 * This is our front-end to iget that looks up inodes by file handle
 * instead of inode number.
 */
struct inode *
nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
{
	struct nfs_find_desc desc = {
		.fh	= fh,
		.fattr	= fattr
	};
256
	struct inode *inode = ERR_PTR(-ENOENT);
L
Linus Torvalds 已提交
257 258
	unsigned long hash;

259 260
	nfs_attr_check_mountpoint(sb, fattr);

261 262
	if (((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0) &&
	    !nfs_attr_use_mounted_on_fileid(fattr))
L
Linus Torvalds 已提交
263
		goto out_no_inode;
264
	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
L
Linus Torvalds 已提交
265 266 267 268
		goto out_no_inode;

	hash = nfs_fattr_to_ino_t(fattr);

269 270 271
	inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
	if (inode == NULL) {
		inode = ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
272
		goto out_no_inode;
273
	}
L
Linus Torvalds 已提交
274 275 276

	if (inode->i_state & I_NEW) {
		struct nfs_inode *nfsi = NFS_I(inode);
277
		unsigned long now = jiffies;
L
Linus Torvalds 已提交
278 279 280 281 282 283 284 285

		/* We set i_ino for the few things that still rely on it,
		 * such as stat(2) */
		inode->i_ino = hash;

		/* We can't support update_atime(), since the server will reset it */
		inode->i_flags |= S_NOATIME|S_NOCMTIME;
		inode->i_mode = fattr->mode;
286 287 288 289 290
		if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
				&& nfs_server_capable(inode, NFS_CAP_MODE))
			nfsi->cache_validity |= NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_ACCESS
				| NFS_INO_INVALID_ACL;
L
Linus Torvalds 已提交
291 292 293
		/* Why so? Because we want revalidate for devices/FIFOs, and
		 * that's precisely what we have in nfs_file_inode_operations.
		 */
294
		inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
L
Linus Torvalds 已提交
295
		if (S_ISREG(inode->i_mode)) {
296
			inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
L
Linus Torvalds 已提交
297 298 299
			inode->i_data.a_ops = &nfs_file_aops;
			inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info;
		} else if (S_ISDIR(inode->i_mode)) {
300
			inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
L
Linus Torvalds 已提交
301
			inode->i_fop = &nfs_dir_operations;
302
			inode->i_data.a_ops = &nfs_dir_aops;
B
Bryan Schumaker 已提交
303
			if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS))
B
Benny Halevy 已提交
304
				set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
305
			/* Deal with crossing mountpoints */
306 307
			if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
					fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
M
Manoj Naik 已提交
308 309 310 311
				if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
					inode->i_op = &nfs_referral_inode_operations;
				else
					inode->i_op = &nfs_mountpoint_inode_operations;
312
				inode->i_fop = NULL;
313
				inode->i_flags |= S_AUTOMOUNT;
314
			}
L
Linus Torvalds 已提交
315 316 317 318 319
		} else if (S_ISLNK(inode->i_mode))
			inode->i_op = &nfs_symlink_inode_operations;
		else
			init_special_inode(inode, inode->i_mode, fattr->rdev);

320 321 322
		memset(&inode->i_atime, 0, sizeof(inode->i_atime));
		memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
		memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
323
		inode->i_version = 0;
324
		inode->i_size = 0;
325
		clear_nlink(inode);
326 327 328 329 330
		inode->i_uid = -2;
		inode->i_gid = -2;
		inode->i_blocks = 0;
		memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));

331
		nfsi->read_cache_jiffies = fattr->time_start;
332
		nfsi->attr_gencount = fattr->gencount;
333 334
		if (fattr->valid & NFS_ATTR_FATTR_ATIME)
			inode->i_atime = fattr->atime;
335 336
		else if (nfs_server_capable(inode, NFS_CAP_ATIME))
			nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
337 338
		if (fattr->valid & NFS_ATTR_FATTR_MTIME)
			inode->i_mtime = fattr->mtime;
339 340 341
		else if (nfs_server_capable(inode, NFS_CAP_MTIME))
			nfsi->cache_validity |= NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_DATA;
342 343
		if (fattr->valid & NFS_ATTR_FATTR_CTIME)
			inode->i_ctime = fattr->ctime;
344 345 346 347
		else if (nfs_server_capable(inode, NFS_CAP_CTIME))
			nfsi->cache_validity |= NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_ACCESS
				| NFS_INO_INVALID_ACL;
348
		if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
349
			inode->i_version = fattr->change_attr;
350 351 352
		else if (nfs_server_capable(inode, NFS_CAP_CHANGE_ATTR))
			nfsi->cache_validity |= NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_DATA;
353 354
		if (fattr->valid & NFS_ATTR_FATTR_SIZE)
			inode->i_size = nfs_size_to_loff_t(fattr->size);
355 356 357 358
		else
			nfsi->cache_validity |= NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_DATA
				| NFS_INO_REVAL_PAGECACHE;
359
		if (fattr->valid & NFS_ATTR_FATTR_NLINK)
M
Miklos Szeredi 已提交
360
			set_nlink(inode, fattr->nlink);
361 362
		else if (nfs_server_capable(inode, NFS_CAP_NLINK))
			nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
363 364
		if (fattr->valid & NFS_ATTR_FATTR_OWNER)
			inode->i_uid = fattr->uid;
365 366 367 368
		else if (nfs_server_capable(inode, NFS_CAP_OWNER))
			nfsi->cache_validity |= NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_ACCESS
				| NFS_INO_INVALID_ACL;
369 370
		if (fattr->valid & NFS_ATTR_FATTR_GROUP)
			inode->i_gid = fattr->gid;
371 372 373 374
		else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP))
			nfsi->cache_validity |= NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_ACCESS
				| NFS_INO_INVALID_ACL;
375 376 377
		if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
			inode->i_blocks = fattr->du.nfs2.blocks;
		if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
L
Linus Torvalds 已提交
378 379 380 381 382 383
			/*
			 * report the blocks in 512byte units
			 */
			inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
		}
		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
384
		nfsi->attrtimeo_timestamp = now;
385
		nfsi->access_cache = RB_ROOT;
L
Linus Torvalds 已提交
386

D
David Howells 已提交
387 388
		nfs_fscache_init_inode_cookie(inode);

L
Linus Torvalds 已提交
389 390 391 392 393 394 395 396 397 398 399 400
		unlock_new_inode(inode);
	} else
		nfs_refresh_inode(inode, fattr);
	dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
		inode->i_sb->s_id,
		(long long)NFS_FILEID(inode),
		atomic_read(&inode->i_count));

out:
	return inode;

out_no_inode:
401
	dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
L
Linus Torvalds 已提交
402 403 404
	goto out;
}

405
#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)
L
Linus Torvalds 已提交
406 407 408 409 410

int
nfs_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
411 412
	struct nfs_fattr *fattr;
	int error = -ENOMEM;
L
Linus Torvalds 已提交
413

C
Chuck Lever 已提交
414 415
	nfs_inc_stats(inode, NFSIOS_VFSSETATTR);

416 417 418 419
	/* skip mode change if it's just for clearing setuid/setgid */
	if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
		attr->ia_valid &= ~ATTR_MODE;

L
Linus Torvalds 已提交
420 421 422 423 424 425 426
	if (attr->ia_valid & ATTR_SIZE) {
		if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode))
			attr->ia_valid &= ~ATTR_SIZE;
	}

	/* Optimization: if the end result is no change, don't RPC */
	attr->ia_valid &= NFS_VALID_ATTRS;
427
	if ((attr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
L
Linus Torvalds 已提交
428 429
		return 0;

430
	/* Write all dirty data */
431
	if (S_ISREG(inode->i_mode))
432
		nfs_wb_all(inode);
433 434 435 436

	fattr = nfs_alloc_fattr();
	if (fattr == NULL)
		goto out;
437 438 439 440 441
	/*
	 * Return any delegations if we're going to change ACLs
	 */
	if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
		nfs_inode_return_delegation(inode);
442
	error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
443
	if (error == 0)
444 445 446
		nfs_refresh_inode(inode, fattr);
	nfs_free_fattr(fattr);
out:
447 448 449
	return error;
}

450 451 452 453 454 455 456 457 458 459 460
/**
 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
 * @inode: inode of the file used
 * @offset: file offset to start truncating
 *
 * This is a copy of the common vmtruncate, but with the locking
 * corrected to take into account the fact that NFS requires
 * inode->i_size to be updated under the inode->i_lock.
 */
static int nfs_vmtruncate(struct inode * inode, loff_t offset)
{
N
npiggin@suse.de 已提交
461 462
	loff_t oldsize;
	int err;
463

N
npiggin@suse.de 已提交
464 465 466
	err = inode_newsize_ok(inode, offset);
	if (err)
		goto out;
467

N
npiggin@suse.de 已提交
468 469 470 471 472 473 474 475
	spin_lock(&inode->i_lock);
	oldsize = inode->i_size;
	i_size_write(inode, offset);
	spin_unlock(&inode->i_lock);

	truncate_pagecache(inode, oldsize, offset);
out:
	return err;
476 477
}

478 479 480 481 482 483 484 485 486 487 488
/**
 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
 * @inode: pointer to struct inode
 * @attr: pointer to struct iattr
 *
 * Note: we do this in the *proc.c in order to ensure that
 *       it works for things like exclusive creates too.
 */
void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
{
	if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
489
		spin_lock(&inode->i_lock);
L
Linus Torvalds 已提交
490
		if ((attr->ia_valid & ATTR_MODE) != 0) {
491 492
			int mode = attr->ia_mode & S_IALLUGO;
			mode |= inode->i_mode & ~S_IALLUGO;
L
Linus Torvalds 已提交
493 494 495 496 497 498
			inode->i_mode = mode;
		}
		if ((attr->ia_valid & ATTR_UID) != 0)
			inode->i_uid = attr->ia_uid;
		if ((attr->ia_valid & ATTR_GID) != 0)
			inode->i_gid = attr->ia_gid;
499
		NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
500
		spin_unlock(&inode->i_lock);
501 502
	}
	if ((attr->ia_valid & ATTR_SIZE) != 0) {
C
Chuck Lever 已提交
503
		nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
504
		nfs_vmtruncate(inode, attr->ia_size);
505
	}
L
Linus Torvalds 已提交
506 507 508 509 510
}

int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
	struct inode *inode = dentry->d_inode;
511
	int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
L
Linus Torvalds 已提交
512 513
	int err;

514
	/* Flush out writes to the server in order to update c/mtime.  */
515
	if (S_ISREG(inode->i_mode)) {
516 517 518
		err = filemap_write_and_wait(inode->i_mapping);
		if (err)
			goto out;
519
	}
520 521 522 523 524 525 526 527 528 529 530 531

	/*
	 * We may force a getattr if the user cares about atime.
	 *
	 * Note that we only have to check the vfsmount flags here:
	 *  - NFS always sets S_NOATIME by so checking it would give a
	 *    bogus result
	 *  - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
	 *    no point in checking those.
	 */
 	if ((mnt->mnt_flags & MNT_NOATIME) ||
 	    ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
L
Linus Torvalds 已提交
532
		need_atime = 0;
533

L
Linus Torvalds 已提交
534 535 536 537
	if (need_atime)
		err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
	else
		err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
P
Peter Staubach 已提交
538
	if (!err) {
L
Linus Torvalds 已提交
539
		generic_fillattr(inode, stat);
540
		stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
P
Peter Staubach 已提交
541
	}
542
out:
L
Linus Torvalds 已提交
543 544 545
	return err;
}

546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
{
	atomic_set(&l_ctx->count, 1);
	l_ctx->lockowner = current->files;
	l_ctx->pid = current->tgid;
	INIT_LIST_HEAD(&l_ctx->list);
}

static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx)
{
	struct nfs_lock_context *pos;

	list_for_each_entry(pos, &ctx->lock_context.list, list) {
		if (pos->lockowner != current->files)
			continue;
		if (pos->pid != current->tgid)
			continue;
		atomic_inc(&pos->count);
		return pos;
	}
	return NULL;
}

struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
{
	struct nfs_lock_context *res, *new = NULL;
572
	struct inode *inode = ctx->dentry->d_inode;
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598

	spin_lock(&inode->i_lock);
	res = __nfs_find_lock_context(ctx);
	if (res == NULL) {
		spin_unlock(&inode->i_lock);
		new = kmalloc(sizeof(*new), GFP_KERNEL);
		if (new == NULL)
			return NULL;
		nfs_init_lock_context(new);
		spin_lock(&inode->i_lock);
		res = __nfs_find_lock_context(ctx);
		if (res == NULL) {
			list_add_tail(&new->list, &ctx->lock_context.list);
			new->open_context = ctx;
			res = new;
			new = NULL;
		}
	}
	spin_unlock(&inode->i_lock);
	kfree(new);
	return res;
}

void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
{
	struct nfs_open_context *ctx = l_ctx->open_context;
599
	struct inode *inode = ctx->dentry->d_inode;
600 601 602 603 604 605 606 607

	if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock))
		return;
	list_del(&l_ctx->list);
	spin_unlock(&inode->i_lock);
	kfree(l_ctx);
}

T
Trond Myklebust 已提交
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624
/**
 * nfs_close_context - Common close_context() routine NFSv2/v3
 * @ctx: pointer to context
 * @is_sync: is this a synchronous close
 *
 * always ensure that the attributes are up to date if we're mounted
 * with close-to-open semantics
 */
void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
{
	struct inode *inode;
	struct nfs_server *server;

	if (!(ctx->mode & FMODE_WRITE))
		return;
	if (!is_sync)
		return;
625
	inode = ctx->dentry->d_inode;
T
Trond Myklebust 已提交
626 627 628 629 630 631 632 633
	if (!list_empty(&NFS_I(inode)->open_files))
		return;
	server = NFS_SERVER(inode);
	if (server->flags & NFS_MOUNT_NOCTO)
		return;
	nfs_revalidate_inode(server, inode);
}

634
struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode)
L
Linus Torvalds 已提交
635 636
{
	struct nfs_open_context *ctx;
637 638 639
	struct rpc_cred *cred = rpc_lookup_cred();
	if (IS_ERR(cred))
		return ERR_CAST(cred);
L
Linus Torvalds 已提交
640

641
	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
642 643 644
	if (!ctx) {
		put_rpccred(cred);
		return ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
645
	}
646 647 648 649 650 651 652 653 654 655
	nfs_sb_active(dentry->d_sb);
	ctx->dentry = dget(dentry);
	ctx->cred = cred;
	ctx->state = NULL;
	ctx->mode = f_mode;
	ctx->flags = 0;
	ctx->error = 0;
	nfs_init_lock_context(&ctx->lock_context);
	ctx->lock_context.open_context = ctx;
	INIT_LIST_HEAD(&ctx->list);
L
Linus Torvalds 已提交
656 657 658 659 660 661
	return ctx;
}

struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
{
	if (ctx != NULL)
662
		atomic_inc(&ctx->lock_context.count);
L
Linus Torvalds 已提交
663 664 665
	return ctx;
}

T
Trond Myklebust 已提交
666
static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
L
Linus Torvalds 已提交
667
{
668 669
	struct inode *inode = ctx->dentry->d_inode;
	struct super_block *sb = ctx->dentry->d_sb;
670

671
	if (!list_empty(&ctx->list)) {
672 673 674 675 676
		if (!atomic_dec_and_lock(&ctx->lock_context.count, &inode->i_lock))
			return;
		list_del(&ctx->list);
		spin_unlock(&inode->i_lock);
	} else if (!atomic_dec_and_test(&ctx->lock_context.count))
T
Trond Myklebust 已提交
677
		return;
678 679
	if (inode != NULL)
		NFS_PROTO(inode)->close_context(ctx, is_sync);
680 681
	if (ctx->cred != NULL)
		put_rpccred(ctx->cred);
682 683
	dput(ctx->dentry);
	nfs_sb_deactive(sb);
684 685 686
	kfree(ctx);
}

687 688 689 690 691
void put_nfs_open_context(struct nfs_open_context *ctx)
{
	__put_nfs_open_context(ctx, 0);
}

L
Linus Torvalds 已提交
692 693 694 695
/*
 * Ensure that mmap has a recent RPC credential for use when writing out
 * shared pages
 */
696
void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
L
Linus Torvalds 已提交
697
{
698
	struct inode *inode = filp->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
699 700 701 702 703 704 705 706
	struct nfs_inode *nfsi = NFS_I(inode);

	filp->private_data = get_nfs_open_context(ctx);
	spin_lock(&inode->i_lock);
	list_add(&ctx->list, &nfsi->open_files);
	spin_unlock(&inode->i_lock);
}

707 708 709
/*
 * Given an inode, search for an open context with the desired characteristics
 */
710
struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
L
Linus Torvalds 已提交
711 712 713 714 715 716
{
	struct nfs_inode *nfsi = NFS_I(inode);
	struct nfs_open_context *pos, *ctx = NULL;

	spin_lock(&inode->i_lock);
	list_for_each_entry(pos, &nfsi->open_files, list) {
717 718
		if (cred != NULL && pos->cred != cred)
			continue;
719 720 721 722
		if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
			continue;
		ctx = get_nfs_open_context(pos);
		break;
L
Linus Torvalds 已提交
723 724 725 726 727
	}
	spin_unlock(&inode->i_lock);
	return ctx;
}

728
static void nfs_file_clear_open_context(struct file *filp)
L
Linus Torvalds 已提交
729
{
730
	struct inode *inode = filp->f_path.dentry->d_inode;
731
	struct nfs_open_context *ctx = nfs_file_open_context(filp);
L
Linus Torvalds 已提交
732 733 734 735 736 737

	if (ctx) {
		filp->private_data = NULL;
		spin_lock(&inode->i_lock);
		list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
		spin_unlock(&inode->i_lock);
738
		__put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1);
L
Linus Torvalds 已提交
739 740 741 742 743 744 745 746 747 748
	}
}

/*
 * These allocate and release file read/write context information.
 */
int nfs_open(struct inode *inode, struct file *filp)
{
	struct nfs_open_context *ctx;

749 750 751
	ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
	if (IS_ERR(ctx))
		return PTR_ERR(ctx);
L
Linus Torvalds 已提交
752 753
	nfs_file_set_open_context(filp, ctx);
	put_nfs_open_context(ctx);
D
David Howells 已提交
754
	nfs_fscache_set_inode_cookie(inode, filp);
L
Linus Torvalds 已提交
755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771
	return 0;
}

int nfs_release(struct inode *inode, struct file *filp)
{
	nfs_file_clear_open_context(filp);
	return 0;
}

/*
 * This function is called whenever some part of NFS notices that
 * the cached attributes have to be refreshed.
 */
int
__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
{
	int		 status = -ESTALE;
772
	struct nfs_fattr *fattr = NULL;
L
Linus Torvalds 已提交
773 774 775 776 777
	struct nfs_inode *nfsi = NFS_I(inode);

	dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
		inode->i_sb->s_id, (long long)NFS_FILEID(inode));

778
	if (is_bad_inode(inode))
779
		goto out;
L
Linus Torvalds 已提交
780
	if (NFS_STALE(inode))
781
		goto out;
782

783 784 785 786 787
	status = -ENOMEM;
	fattr = nfs_alloc_fattr();
	if (fattr == NULL)
		goto out;

788
	nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
789
	status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr);
L
Linus Torvalds 已提交
790 791 792 793 794 795 796
	if (status != 0) {
		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
			 inode->i_sb->s_id,
			 (long long)NFS_FILEID(inode), status);
		if (status == -ESTALE) {
			nfs_zap_caches(inode);
			if (!S_ISDIR(inode->i_mode))
B
Benny Halevy 已提交
797
				set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
L
Linus Torvalds 已提交
798 799 800 801
		}
		goto out;
	}

802
	status = nfs_refresh_inode(inode, fattr);
L
Linus Torvalds 已提交
803 804 805 806 807 808
	if (status) {
		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
			 inode->i_sb->s_id,
			 (long long)NFS_FILEID(inode), status);
		goto out;
	}
809

810
	if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
811
		nfs_zap_acl_cache(inode);
812

L
Linus Torvalds 已提交
813 814 815 816
	dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
		inode->i_sb->s_id,
		(long long)NFS_FILEID(inode));

817
 out:
818
	nfs_free_fattr(fattr);
L
Linus Torvalds 已提交
819 820 821 822 823 824 825
	return status;
}

int nfs_attribute_timeout(struct inode *inode)
{
	struct nfs_inode *nfsi = NFS_I(inode);

826 827 828 829 830
	return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
}

static int nfs_attribute_cache_expired(struct inode *inode)
{
831
	if (nfs_have_delegated_attributes(inode))
L
Linus Torvalds 已提交
832
		return 0;
833
	return nfs_attribute_timeout(inode);
L
Linus Torvalds 已提交
834 835 836 837 838 839 840 841 842 843 844
}

/**
 * nfs_revalidate_inode - Revalidate the inode attributes
 * @server - pointer to nfs_server struct
 * @inode - pointer to inode struct
 *
 * Updates inode attribute information by retrieving the data from the server.
 */
int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
{
845
	if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
846
			&& !nfs_attribute_cache_expired(inode))
L
Linus Torvalds 已提交
847 848 849 850
		return NFS_STALE(inode) ? -ESTALE : 0;
	return __nfs_revalidate_inode(server, inode);
}

851
static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
852 853 854 855 856 857 858 859 860 861
{
	struct nfs_inode *nfsi = NFS_I(inode);
	
	if (mapping->nrpages != 0) {
		int ret = invalidate_inode_pages2(mapping);
		if (ret < 0)
			return ret;
	}
	spin_lock(&inode->i_lock);
	nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
862
	if (S_ISDIR(inode->i_mode))
863 864 865
		memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
	spin_unlock(&inode->i_lock);
	nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
D
David Howells 已提交
866
	nfs_fscache_reset_inode_cookie(inode);
867 868 869 870 871 872 873 874 875 876 877 878 879 880
	dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
			inode->i_sb->s_id, (long long)NFS_FILEID(inode));
	return 0;
}

/**
 * nfs_revalidate_mapping - Revalidate the pagecache
 * @inode - pointer to host inode
 * @mapping - pointer to mapping
 */
int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
{
	struct nfs_inode *nfsi = NFS_I(inode);
	int ret = 0;
881

882
	if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
883 884
			|| nfs_attribute_cache_expired(inode)
			|| NFS_STALE(inode)) {
885 886 887
		ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
		if (ret < 0)
			goto out;
888
	}
889 890
	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
		ret = nfs_invalidate_mapping(inode, mapping);
891
out:
892
	return ret;
893 894
}

895
static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
896 897
{
	struct nfs_inode *nfsi = NFS_I(inode);
898
	unsigned long ret = 0;
899

900 901
	if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
			&& (fattr->valid & NFS_ATTR_FATTR_CHANGE)
902 903
			&& inode->i_version == fattr->pre_change_attr) {
		inode->i_version = fattr->change_attr;
904 905
		if (S_ISDIR(inode->i_mode))
			nfsi->cache_validity |= NFS_INO_INVALID_DATA;
906
		ret |= NFS_INO_INVALID_ATTR;
907
	}
908
	/* If we have atomic WCC data, we may update some attributes */
909 910
	if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
			&& (fattr->valid & NFS_ATTR_FATTR_CTIME)
911 912 913 914
			&& timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
		memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
		ret |= NFS_INO_INVALID_ATTR;
	}
915 916 917 918

	if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
			&& (fattr->valid & NFS_ATTR_FATTR_MTIME)
			&& timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
919 920 921 922
		memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
		if (S_ISDIR(inode->i_mode))
			nfsi->cache_validity |= NFS_INO_INVALID_DATA;
		ret |= NFS_INO_INVALID_ATTR;
923
	}
924 925 926
	if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
			&& (fattr->valid & NFS_ATTR_FATTR_SIZE)
			&& i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
927 928 929 930 931
			&& nfsi->npages == 0) {
		i_size_write(inode, nfs_size_to_loff_t(fattr->size));
		ret |= NFS_INO_INVALID_ATTR;
	}
	return ret;
932 933
}

L
Linus Torvalds 已提交
934
/**
935
 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
L
Linus Torvalds 已提交
936 937 938 939 940 941 942
 * @inode - pointer to inode
 * @fattr - updated attributes
 *
 * Verifies the attribute cache. If we have just changed the attributes,
 * so that fattr carries weak cache consistency data, then it may
 * also update the ctime/mtime/change_attribute.
 */
943
static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
L
Linus Torvalds 已提交
944 945 946
{
	struct nfs_inode *nfsi = NFS_I(inode);
	loff_t cur_size, new_isize;
947
	unsigned long invalid = 0;
L
Linus Torvalds 已提交
948

949

950
	/* Has the inode gone and changed behind our back? */
951 952 953
	if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
		return -EIO;
	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
954 955
		return -EIO;

956
	if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
957
			inode->i_version != fattr->change_attr)
958
		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
L
Linus Torvalds 已提交
959 960

	/* Verify a few of the more important attributes */
961
	if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))
962
		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
963

964 965 966 967 968 969
	if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
		cur_size = i_size_read(inode);
		new_isize = nfs_size_to_loff_t(fattr->size);
		if (cur_size != new_isize && nfsi->npages == 0)
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
	}
L
Linus Torvalds 已提交
970 971

	/* Have any file permissions changed? */
972 973 974 975 976
	if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
		invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
	if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && inode->i_uid != fattr->uid)
		invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
	if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && inode->i_gid != fattr->gid)
977
		invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
L
Linus Torvalds 已提交
978 979

	/* Has the link count changed? */
980
	if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
981
		invalid |= NFS_INO_INVALID_ATTR;
L
Linus Torvalds 已提交
982

983
	if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
984 985 986 987
		invalid |= NFS_INO_INVALID_ATIME;

	if (invalid != 0)
		nfsi->cache_validity |= invalid;
L
Linus Torvalds 已提交
988

989
	nfsi->read_cache_jiffies = fattr->time_start;
L
Linus Torvalds 已提交
990 991 992
	return 0;
}

993
static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
994
{
995 996
	if (!(fattr->valid & NFS_ATTR_FATTR_CTIME))
		return 0;
997 998 999 1000 1001
	return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0;
}

static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
{
1002 1003
	if (!(fattr->valid & NFS_ATTR_FATTR_SIZE))
		return 0;
1004 1005
	return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
}
1006

1007
static atomic_long_t nfs_attr_generation_counter;
1008 1009 1010

static unsigned long nfs_read_attr_generation_counter(void)
{
1011
	return atomic_long_read(&nfs_attr_generation_counter);
1012 1013 1014 1015
}

unsigned long nfs_inc_attr_generation_counter(void)
{
1016
	return atomic_long_inc_return(&nfs_attr_generation_counter);
1017 1018 1019 1020 1021 1022 1023
}

void nfs_fattr_init(struct nfs_fattr *fattr)
{
	fattr->valid = 0;
	fattr->time_start = jiffies;
	fattr->gencount = nfs_inc_attr_generation_counter();
1024 1025
	fattr->owner_name = NULL;
	fattr->group_name = NULL;
1026 1027
}

1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
struct nfs_fattr *nfs_alloc_fattr(void)
{
	struct nfs_fattr *fattr;

	fattr = kmalloc(sizeof(*fattr), GFP_NOFS);
	if (fattr != NULL)
		nfs_fattr_init(fattr);
	return fattr;
}

struct nfs_fh *nfs_alloc_fhandle(void)
{
	struct nfs_fh *fh;

	fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS);
	if (fh != NULL)
		fh->size = 0;
	return fh;
}

1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
/**
 * _nfs_display_fhandle - display an NFS file handle on the console
 *
 * @fh: file handle to display
 * @caption: display caption
 *
 * For debugging only.
 */
#ifdef RPC_DEBUG
void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
{
	unsigned short i;

	if (fh->size == 0 || fh == NULL) {
		printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
		return;
	}

	printk(KERN_DEFAULT "%s at %p is %u bytes:\n", caption, fh, fh->size);
	for (i = 0; i < fh->size; i += 16) {
		__be32 *pos = (__be32 *)&fh->data[i];

		switch ((fh->size - i - 1) >> 2) {
		case 0:
			printk(KERN_DEFAULT " %08x\n",
				be32_to_cpup(pos));
			break;
		case 1:
			printk(KERN_DEFAULT " %08x %08x\n",
				be32_to_cpup(pos), be32_to_cpup(pos + 1));
			break;
		case 2:
			printk(KERN_DEFAULT " %08x %08x %08x\n",
				be32_to_cpup(pos), be32_to_cpup(pos + 1),
				be32_to_cpup(pos + 2));
			break;
		default:
			printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
				be32_to_cpup(pos), be32_to_cpup(pos + 1),
				be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
		}
	}
}
#endif

1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
/**
 * nfs_inode_attrs_need_update - check if the inode attributes need updating
 * @inode - pointer to inode
 * @fattr - attributes
 *
 * Attempt to divine whether or not an RPC call reply carrying stale
 * attributes got scheduled after another call carrying updated ones.
 *
 * To do so, the function first assumes that a more recent ctime means
 * that the attributes in fattr are newer, however it also attempt to
 * catch the case where ctime either didn't change, or went backwards
 * (if someone reset the clock on the server) by looking at whether
 * or not this RPC call was started after the inode was last updated.
1106
 * Note also the check for wraparound of 'attr_gencount'
1107 1108 1109 1110 1111 1112 1113 1114 1115
 *
 * The function returns 'true' if it thinks the attributes in 'fattr' are
 * more recent than the ones cached in the inode.
 *
 */
static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
{
	const struct nfs_inode *nfsi = NFS_I(inode);

1116
	return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
T
Trond Myklebust 已提交
1117 1118
		nfs_ctime_need_update(inode, fattr) ||
		nfs_size_need_update(inode, fattr) ||
1119
		((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
1120 1121 1122 1123 1124
}

static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
{
	if (nfs_inode_attrs_need_update(inode, fattr))
1125 1126 1127 1128
		return nfs_update_inode(inode, fattr);
	return nfs_check_inode_attributes(inode, fattr);
}

1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
/**
 * nfs_refresh_inode - try to update the inode attribute cache
 * @inode - pointer to inode
 * @fattr - updated attributes
 *
 * Check that an RPC call that returned attributes has not overlapped with
 * other recent updates of the inode metadata, then decide whether it is
 * safe to do a full update of the inode attributes, or whether just to
 * call nfs_check_inode_attributes.
 */
int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
{
	int status;

	if ((fattr->valid & NFS_ATTR_FATTR) == 0)
		return 0;
	spin_lock(&inode->i_lock);
1146
	status = nfs_refresh_inode_locked(inode, fattr);
1147
	spin_unlock(&inode->i_lock);
D
David Howells 已提交
1148

1149 1150 1151
	return status;
}

1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
{
	struct nfs_inode *nfsi = NFS_I(inode);

	nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
	if (S_ISDIR(inode->i_mode))
		nfsi->cache_validity |= NFS_INO_INVALID_DATA;
	if ((fattr->valid & NFS_ATTR_FATTR) == 0)
		return 0;
	return nfs_refresh_inode_locked(inode, fattr);
}

1164 1165 1166 1167 1168 1169 1170
/**
 * nfs_post_op_update_inode - try to update the inode attribute cache
 * @inode - pointer to inode
 * @fattr - updated attributes
 *
 * After an operation that has changed the inode metadata, mark the
 * attribute cache as being invalid, then try to update it.
1171 1172 1173 1174 1175 1176
 *
 * NB: if the server didn't return any post op attributes, this
 * function will force the retrieval of attributes before the next
 * NFS request.  Thus it should be used only for operations that
 * are expected to change one or more attributes, to avoid
 * unnecessary NFS requests and trips through nfs_update_inode().
1177 1178 1179
 */
int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
{
1180
	int status;
1181

1182
	spin_lock(&inode->i_lock);
1183
	status = nfs_post_op_update_inode_locked(inode, fattr);
1184
	spin_unlock(&inode->i_lock);
1185
	return status;
1186 1187
}

1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
/**
 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
 * @inode - pointer to inode
 * @fattr - updated attributes
 *
 * After an operation that has changed the inode metadata, mark the
 * attribute cache as being invalid, then try to update it. Fake up
 * weak cache consistency data, if none exist.
 *
 * This function is mainly designed to be used by the ->write_done() functions.
 */
int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
{
1201 1202 1203 1204 1205 1206
	int status;

	spin_lock(&inode->i_lock);
	/* Don't do a WCC update if these attributes are already stale */
	if ((fattr->valid & NFS_ATTR_FATTR) == 0 ||
			!nfs_inode_attrs_need_update(inode, fattr)) {
1207 1208 1209 1210
		fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
				| NFS_ATTR_FATTR_PRESIZE
				| NFS_ATTR_FATTR_PREMTIME
				| NFS_ATTR_FATTR_PRECTIME);
1211 1212
		goto out_noforce;
	}
1213 1214
	if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
1215
		fattr->pre_change_attr = inode->i_version;
1216
		fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
1217
	}
1218 1219
	if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
1220
		memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
1221 1222 1223 1224
		fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
	}
	if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
1225
		memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
1226 1227 1228 1229
		fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
	}
	if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
1230
		fattr->pre_size = i_size_read(inode);
1231
		fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
1232
	}
1233 1234 1235 1236
out_noforce:
	status = nfs_post_op_update_inode_locked(inode, fattr);
	spin_unlock(&inode->i_lock);
	return status;
1237 1238
}

L
Linus Torvalds 已提交
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
/*
 * Many nfs protocol calls return the new file attributes after
 * an operation.  Here we update the inode to reflect the state
 * of the server's inode.
 *
 * This is a bit tricky because we have to make sure all dirty pages
 * have been sent off to the server before calling invalidate_inode_pages.
 * To make sure no other process adds more write requests while we try
 * our best to flush them, we make them sleep during the attribute refresh.
 *
 * A very similar scenario holds for the dir cache.
 */
1251
static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
L
Linus Torvalds 已提交
1252
{
1253
	struct nfs_server *server;
L
Linus Torvalds 已提交
1254
	struct nfs_inode *nfsi = NFS_I(inode);
1255
	loff_t cur_isize, new_isize;
1256
	unsigned long invalid = 0;
1257
	unsigned long now = jiffies;
1258
	unsigned long save_cache_validity;
L
Linus Torvalds 已提交
1259 1260

	dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
1261
			__func__, inode->i_sb->s_id, inode->i_ino,
L
Linus Torvalds 已提交
1262 1263
			atomic_read(&inode->i_count), fattr->valid);

1264
	if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
1265
		goto out_fileid;
L
Linus Torvalds 已提交
1266 1267 1268 1269

	/*
	 * Make sure the inode's type hasn't changed.
	 */
1270
	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
L
Linus Torvalds 已提交
1271 1272
		goto out_changed;

1273
	server = NFS_SERVER(inode);
T
Trond Myklebust 已提交
1274
	/* Update the fsid? */
1275
	if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
1276
			!nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
1277
			!IS_AUTOMOUNT(inode))
1278 1279
		server->fsid = fattr->fsid;

L
Linus Torvalds 已提交
1280 1281 1282
	/*
	 * Update the read time so we don't revalidate too often.
	 */
1283
	nfsi->read_cache_jiffies = fattr->time_start;
1284

1285 1286 1287 1288 1289
	save_cache_validity = nfsi->cache_validity;
	nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
			| NFS_INO_INVALID_ATIME
			| NFS_INO_REVAL_FORCED
			| NFS_INO_REVAL_PAGECACHE);
L
Linus Torvalds 已提交
1290

1291
	/* Do atomic weak cache consistency updates */
1292
	invalid |= nfs_wcc_update_inode(inode, fattr);
1293

1294
	/* More cache consistency checks */
1295
	if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
1296
		if (inode->i_version != fattr->change_attr) {
1297 1298 1299 1300 1301
			dprintk("NFS: change_attr change on server for file %s/%ld\n",
					inode->i_sb->s_id, inode->i_ino);
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
			if (S_ISDIR(inode->i_mode))
				nfs_force_lookup_revalidate(inode);
1302
			inode->i_version = fattr->change_attr;
1303
		}
1304 1305
	} else if (server->caps & NFS_CAP_CHANGE_ATTR)
		invalid |= save_cache_validity;
1306 1307

	if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
1308 1309 1310 1311 1312
		/* NFSv2/v3: Check if the mtime agrees */
		if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
			dprintk("NFS: mtime change on server for file %s/%ld\n",
					inode->i_sb->s_id, inode->i_ino);
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1313 1314
			if (S_ISDIR(inode->i_mode))
				nfs_force_lookup_revalidate(inode);
1315
			memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1316
		}
1317 1318 1319 1320 1321 1322
	} else if (server->caps & NFS_CAP_MTIME)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_DATA
				| NFS_INO_REVAL_PAGECACHE
				| NFS_INO_REVAL_FORCED);

1323
	if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
1324
		/* If ctime has changed we should definitely clear access+acl caches */
1325
		if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) {
1326
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1327 1328 1329 1330 1331 1332 1333
			/* and probably clear data for a directory too as utimes can cause
			 * havoc with our cache.
			 */
			if (S_ISDIR(inode->i_mode)) {
				invalid |= NFS_INO_INVALID_DATA;
				nfs_force_lookup_revalidate(inode);
			}
1334
			memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1335
		}
1336 1337 1338 1339 1340
	} else if (server->caps & NFS_CAP_CTIME)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_ACCESS
				| NFS_INO_INVALID_ACL
				| NFS_INO_REVAL_FORCED);
1341

1342
	/* Check if our cached file size is stale */
1343 1344 1345 1346 1347 1348
	if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
		new_isize = nfs_size_to_loff_t(fattr->size);
		cur_isize = i_size_read(inode);
		if (new_isize != cur_isize) {
			/* Do we perhaps have any outstanding writes, or has
			 * the file grown beyond our last write? */
1349 1350
			if ((nfsi->npages == 0 && !test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) ||
			     new_isize > cur_isize) {
1351 1352 1353
				i_size_write(inode, new_isize);
				invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
			}
1354 1355 1356 1357 1358 1359
			dprintk("NFS: isize change on server for file %s/%ld "
					"(%Ld to %Ld)\n",
					inode->i_sb->s_id,
					inode->i_ino,
					(long long)cur_isize,
					(long long)new_isize);
L
Linus Torvalds 已提交
1360
		}
1361 1362 1363 1364
	} else
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_PAGECACHE
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1365 1366


1367 1368
	if (fattr->valid & NFS_ATTR_FATTR_ATIME)
		memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
1369 1370 1371
	else if (server->caps & NFS_CAP_ATIME)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1372

1373 1374
	if (fattr->valid & NFS_ATTR_FATTR_MODE) {
		if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
1375 1376 1377
			umode_t newmode = inode->i_mode & S_IFMT;
			newmode |= fattr->mode & S_IALLUGO;
			inode->i_mode = newmode;
1378 1379
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
		}
1380 1381 1382 1383 1384 1385
	} else if (server->caps & NFS_CAP_MODE)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_ACCESS
				| NFS_INO_INVALID_ACL
				| NFS_INO_REVAL_FORCED);

1386 1387 1388 1389 1390
	if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
		if (inode->i_uid != fattr->uid) {
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
			inode->i_uid = fattr->uid;
		}
1391 1392 1393 1394 1395 1396
	} else if (server->caps & NFS_CAP_OWNER)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_ACCESS
				| NFS_INO_INVALID_ACL
				| NFS_INO_REVAL_FORCED);

1397 1398 1399 1400 1401
	if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
		if (inode->i_gid != fattr->gid) {
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
			inode->i_gid = fattr->gid;
		}
1402 1403 1404 1405 1406
	} else if (server->caps & NFS_CAP_OWNER_GROUP)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_ACCESS
				| NFS_INO_INVALID_ACL
				| NFS_INO_REVAL_FORCED);
1407

1408 1409 1410 1411 1412
	if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
		if (inode->i_nlink != fattr->nlink) {
			invalid |= NFS_INO_INVALID_ATTR;
			if (S_ISDIR(inode->i_mode))
				invalid |= NFS_INO_INVALID_DATA;
M
Miklos Szeredi 已提交
1413
			set_nlink(inode, fattr->nlink);
1414
		}
1415 1416 1417
	} else if (server->caps & NFS_CAP_NLINK)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1418

1419
	if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
L
Linus Torvalds 已提交
1420 1421 1422 1423 1424
		/*
		 * report the blocks in 512byte units
		 */
		inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
 	}
1425 1426
	if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
		inode->i_blocks = fattr->du.nfs2.blocks;
L
Linus Torvalds 已提交
1427 1428 1429

	/* Update attrtimeo value if we're out of the unstable period */
	if (invalid & NFS_INO_INVALID_ATTR) {
C
Chuck Lever 已提交
1430
		nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
L
Linus Torvalds 已提交
1431
		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
1432
		nfsi->attrtimeo_timestamp = now;
1433
		nfsi->attr_gencount = nfs_inc_attr_generation_counter();
1434
	} else {
1435
		if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
1436 1437 1438 1439
			if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
				nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
			nfsi->attrtimeo_timestamp = now;
		}
L
Linus Torvalds 已提交
1440
	}
1441
	invalid &= ~NFS_INO_INVALID_ATTR;
L
Linus Torvalds 已提交
1442 1443 1444 1445
	/* Don't invalidate the data if we were to blame */
	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
				|| S_ISLNK(inode->i_mode)))
		invalid &= ~NFS_INO_INVALID_DATA;
1446
	if (!nfs_have_delegation(inode, FMODE_READ) ||
1447
			(save_cache_validity & NFS_INO_REVAL_FORCED))
1448
		nfsi->cache_validity |= invalid;
L
Linus Torvalds 已提交
1449 1450 1451 1452 1453 1454

	return 0;
 out_changed:
	/*
	 * Big trouble! The inode has become a different object.
	 */
1455
	printk(KERN_DEBUG "NFS: %s: inode %ld mode changed, %07o to %07o\n",
1456
			__func__, inode->i_ino, inode->i_mode, fattr->mode);
1457
 out_err:
L
Linus Torvalds 已提交
1458 1459 1460 1461 1462 1463 1464
	/*
	 * No need to worry about unhashing the dentry, as the
	 * lookup validation will know that the inode is bad.
	 * (But we fall through to invalidate the caches.)
	 */
	nfs_invalidate_inode(inode);
	return -ESTALE;
1465 1466 1467 1468

 out_fileid:
	printk(KERN_ERR "NFS: server %s error: fileid changed\n"
		"fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
1469
		NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id,
1470 1471
		(long long)nfsi->fileid, (long long)fattr->fileid);
	goto out_err;
L
Linus Torvalds 已提交
1472 1473
}

1474

L
Linus Torvalds 已提交
1475 1476 1477 1478 1479 1480 1481
#ifdef CONFIG_NFS_V4

/*
 * Clean out any remaining NFSv4 state that might be left over due
 * to open() calls that passed nfs_atomic_lookup, but failed to call
 * nfs_open().
 */
1482
void nfs4_evict_inode(struct inode *inode)
L
Linus Torvalds 已提交
1483
{
1484 1485
	truncate_inode_pages(&inode->i_data, 0);
	end_writeback(inode);
B
Benny Halevy 已提交
1486 1487
	pnfs_return_layout(inode);
	pnfs_destroy_layout(NFS_I(inode));
L
Linus Torvalds 已提交
1488
	/* If we are holding a delegation, return it! */
1489
	nfs_inode_return_delegation_noreclaim(inode);
L
Linus Torvalds 已提交
1490 1491 1492 1493 1494
	/* First call standard NFS clear_inode() code */
	nfs_clear_inode(inode);
}
#endif

D
David Howells 已提交
1495
struct inode *nfs_alloc_inode(struct super_block *sb)
L
Linus Torvalds 已提交
1496 1497
{
	struct nfs_inode *nfsi;
1498
	nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
1499 1500
	if (!nfsi)
		return NULL;
1501 1502
	nfsi->flags = 0UL;
	nfsi->cache_validity = 0UL;
1503 1504 1505 1506
#ifdef CONFIG_NFS_V3_ACL
	nfsi->acl_access = ERR_PTR(-EAGAIN);
	nfsi->acl_default = ERR_PTR(-EAGAIN);
#endif
1507 1508 1509
#ifdef CONFIG_NFS_V4
	nfsi->nfs4_acl = NULL;
#endif /* CONFIG_NFS_V4 */
L
Linus Torvalds 已提交
1510 1511 1512
	return &nfsi->vfs_inode;
}

N
Nick Piggin 已提交
1513
static void nfs_i_callback(struct rcu_head *head)
L
Linus Torvalds 已提交
1514
{
N
Nick Piggin 已提交
1515
	struct inode *inode = container_of(head, struct inode, i_rcu);
L
Linus Torvalds 已提交
1516 1517 1518
	kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
}

N
Nick Piggin 已提交
1519 1520 1521 1522 1523
void nfs_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, nfs_i_callback);
}

A
Andrew Morton 已提交
1524 1525 1526 1527 1528 1529 1530
static inline void nfs4_init_once(struct nfs_inode *nfsi)
{
#ifdef CONFIG_NFS_V4
	INIT_LIST_HEAD(&nfsi->open_states);
	nfsi->delegation = NULL;
	nfsi->delegation_state = 0;
	init_rwsem(&nfsi->rwsem);
1531
	nfsi->layout = NULL;
1532
	atomic_set(&nfsi->commits_outstanding, 0);
A
Andrew Morton 已提交
1533 1534
#endif
}
D
David Howells 已提交
1535

1536
static void init_once(void *foo)
L
Linus Torvalds 已提交
1537 1538 1539
{
	struct nfs_inode *nfsi = (struct nfs_inode *) foo;

C
Christoph Lameter 已提交
1540 1541 1542 1543 1544 1545
	inode_init_once(&nfsi->vfs_inode);
	INIT_LIST_HEAD(&nfsi->open_files);
	INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
	INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
	INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
	nfsi->npages = 0;
1546
	nfsi->ncommit = 0;
T
Trond Myklebust 已提交
1547 1548 1549
	atomic_set(&nfsi->silly_count, 1);
	INIT_HLIST_HEAD(&nfsi->silly_list);
	init_waitqueue_head(&nfsi->waitqueue);
C
Christoph Lameter 已提交
1550
	nfs4_init_once(nfsi);
L
Linus Torvalds 已提交
1551
}
1552

D
David Howells 已提交
1553
static int __init nfs_init_inodecache(void)
L
Linus Torvalds 已提交
1554 1555 1556
{
	nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
					     sizeof(struct nfs_inode),
1557 1558
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
1559
					     init_once);
L
Linus Torvalds 已提交
1560 1561 1562 1563 1564 1565
	if (nfs_inode_cachep == NULL)
		return -ENOMEM;

	return 0;
}

1566
static void nfs_destroy_inodecache(void)
L
Linus Torvalds 已提交
1567
{
1568
	kmem_cache_destroy(nfs_inode_cachep);
L
Linus Torvalds 已提交
1569 1570
}

T
Trond Myklebust 已提交
1571 1572 1573 1574 1575 1576 1577 1578 1579
struct workqueue_struct *nfsiod_workqueue;

/*
 * start up the nfsiod workqueue
 */
static int nfsiod_start(void)
{
	struct workqueue_struct *wq;
	dprintk("RPC:       creating workqueue nfsiod\n");
1580
	wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
T
Trond Myklebust 已提交
1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600
	if (wq == NULL)
		return -ENOMEM;
	nfsiod_workqueue = wq;
	return 0;
}

/*
 * Destroy the nfsiod workqueue
 */
static void nfsiod_stop(void)
{
	struct workqueue_struct *wq;

	wq = nfsiod_workqueue;
	if (wq == NULL)
		return;
	nfsiod_workqueue = NULL;
	destroy_workqueue(wq);
}

1601
int nfs_net_id;
1602
EXPORT_SYMBOL_GPL(nfs_net_id);
1603 1604 1605

static int nfs_net_init(struct net *net)
{
1606
	nfs_clients_init(net);
1607 1608 1609 1610 1611 1612
	return nfs_dns_resolver_cache_init(net);
}

static void nfs_net_exit(struct net *net)
{
	nfs_dns_resolver_cache_destroy(net);
1613
	nfs_cleanup_cb_ident_idr(net);
1614 1615 1616 1617 1618 1619 1620 1621 1622
}

static struct pernet_operations nfs_net_ops = {
	.init = nfs_net_init,
	.exit = nfs_net_exit,
	.id   = &nfs_net_id,
	.size = sizeof(struct nfs_net),
};

L
Linus Torvalds 已提交
1623 1624 1625 1626 1627 1628 1629
/*
 * Initialize NFS
 */
static int __init init_nfs_fs(void)
{
	int err;

B
Bryan Schumaker 已提交
1630 1631
	err = nfs_idmap_init();
	if (err < 0)
1632
		goto out10;
B
Bryan Schumaker 已提交
1633

1634
	err = nfs_dns_resolver_init();
1635 1636 1637 1638
	if (err < 0)
		goto out9;

	err = register_pernet_subsys(&nfs_net_ops);
1639 1640 1641
	if (err < 0)
		goto out8;

1642 1643 1644 1645
	err = nfs_fscache_register();
	if (err < 0)
		goto out7;

T
Trond Myklebust 已提交
1646 1647 1648 1649
	err = nfsiod_start();
	if (err)
		goto out6;

1650 1651 1652 1653
	err = nfs_fs_proc_init();
	if (err)
		goto out5;

L
Linus Torvalds 已提交
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674
	err = nfs_init_nfspagecache();
	if (err)
		goto out4;

	err = nfs_init_inodecache();
	if (err)
		goto out3;

	err = nfs_init_readpagecache();
	if (err)
		goto out2;

	err = nfs_init_writepagecache();
	if (err)
		goto out1;

	err = nfs_init_directcache();
	if (err)
		goto out0;

#ifdef CONFIG_PROC_FS
1675
	rpc_proc_register(&init_net, &nfs_rpcstat);
L
Linus Torvalds 已提交
1676
#endif
D
David Howells 已提交
1677
	if ((err = register_nfs_fs()) != 0)
L
Linus Torvalds 已提交
1678 1679 1680 1681
		goto out;
	return 0;
out:
#ifdef CONFIG_PROC_FS
1682
	rpc_proc_unregister(&init_net, "nfs");
L
Linus Torvalds 已提交
1683 1684
#endif
	nfs_destroy_directcache();
1685 1686
out0:
	nfs_destroy_writepagecache();
L
Linus Torvalds 已提交
1687 1688 1689 1690 1691 1692 1693
out1:
	nfs_destroy_readpagecache();
out2:
	nfs_destroy_inodecache();
out3:
	nfs_destroy_nfspagecache();
out4:
1694 1695
	nfs_fs_proc_exit();
out5:
T
Trond Myklebust 已提交
1696 1697
	nfsiod_stop();
out6:
1698 1699
	nfs_fscache_unregister();
out7:
1700
	unregister_pernet_subsys(&nfs_net_ops);
1701
out8:
1702
	nfs_dns_resolver_destroy();
B
Bryan Schumaker 已提交
1703
out9:
1704 1705
	nfs_idmap_quit();
out10:
L
Linus Torvalds 已提交
1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
	return err;
}

static void __exit exit_nfs_fs(void)
{
	nfs_destroy_directcache();
	nfs_destroy_writepagecache();
	nfs_destroy_readpagecache();
	nfs_destroy_inodecache();
	nfs_destroy_nfspagecache();
1716
	nfs_fscache_unregister();
1717
	unregister_pernet_subsys(&nfs_net_ops);
1718
	nfs_dns_resolver_destroy();
B
Bryan Schumaker 已提交
1719
	nfs_idmap_quit();
L
Linus Torvalds 已提交
1720
#ifdef CONFIG_PROC_FS
1721
	rpc_proc_unregister(&init_net, "nfs");
L
Linus Torvalds 已提交
1722
#endif
D
David Howells 已提交
1723
	unregister_nfs_fs();
1724
	nfs_fs_proc_exit();
T
Trond Myklebust 已提交
1725
	nfsiod_stop();
L
Linus Torvalds 已提交
1726 1727 1728 1729 1730
}

/* Not quite true; I just maintain it */
MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
MODULE_LICENSE("GPL");
1731
module_param(enable_ino64, bool, 0644);
L
Linus Torvalds 已提交
1732 1733 1734

module_init(init_nfs_fs)
module_exit(exit_nfs_fs)