inode.c 48.3 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>
42
#include <linux/crc32.h>
L
Linus Torvalds 已提交
43 44 45

#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
		unlock_new_inode(inode);
	} else
		nfs_refresh_inode(inode, fattr);
392
	dprintk("NFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n",
L
Linus Torvalds 已提交
393 394
		inode->i_sb->s_id,
		(long long)NFS_FILEID(inode),
395
		nfs_display_fhandle_hash(fh),
L
Linus Torvalds 已提交
396 397 398 399 400 401
		atomic_read(&inode->i_count));

out:
	return inode;

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

406
#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 已提交
407 408 409 410 411

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

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

417 418 419 420
	/* 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 已提交
421 422 423 424 425 426 427
	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;
428
	if ((attr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
L
Linus Torvalds 已提交
429 430
		return 0;

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

	fattr = nfs_alloc_fattr();
	if (fattr == NULL)
		goto out;
438 439 440 441 442
	/*
	 * 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);
443
	error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
444
	if (error == 0)
445 446 447
		nfs_refresh_inode(inode, fattr);
	nfs_free_fattr(fattr);
out:
448 449 450
	return error;
}

451 452 453 454 455 456 457 458 459 460 461
/**
 * 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 已提交
462 463
	loff_t oldsize;
	int err;
464

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

N
npiggin@suse.de 已提交
469 470 471 472 473 474 475 476
	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;
477 478
}

479 480 481 482 483 484 485 486 487 488 489
/**
 * 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) {
490
		spin_lock(&inode->i_lock);
L
Linus Torvalds 已提交
491
		if ((attr->ia_valid & ATTR_MODE) != 0) {
492 493
			int mode = attr->ia_mode & S_IALLUGO;
			mode |= inode->i_mode & ~S_IALLUGO;
L
Linus Torvalds 已提交
494 495 496 497 498 499
			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;
500
		NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
501
		spin_unlock(&inode->i_lock);
502 503
	}
	if ((attr->ia_valid & ATTR_SIZE) != 0) {
C
Chuck Lever 已提交
504
		nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
505
		nfs_vmtruncate(inode, attr->ia_size);
506
	}
L
Linus Torvalds 已提交
507 508 509 510 511
}

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

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

	/*
	 * 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 已提交
533
		need_atime = 0;
534

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

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 572
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;
573
	struct inode *inode = ctx->dentry->d_inode;
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 599

	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;
600
	struct inode *inode = ctx->dentry->d_inode;
601 602 603 604 605 606 607 608

	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 已提交
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
/**
 * 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;
626
	inode = ctx->dentry->d_inode;
T
Trond Myklebust 已提交
627 628 629 630 631 632 633 634
	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);
}

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

642
	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
643 644 645
	if (!ctx) {
		put_rpccred(cred);
		return ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
646
	}
647 648 649 650 651 652 653 654 655 656
	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 已提交
657 658 659 660 661 662
	return ctx;
}

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

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

672
	if (!list_empty(&ctx->list)) {
673 674 675 676 677
		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 已提交
678
		return;
679 680
	if (inode != NULL)
		NFS_PROTO(inode)->close_context(ctx, is_sync);
681 682
	if (ctx->cred != NULL)
		put_rpccred(ctx->cred);
683 684
	dput(ctx->dentry);
	nfs_sb_deactive(sb);
685 686 687
	kfree(ctx);
}

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

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

708 709 710
/*
 * Given an inode, search for an open context with the desired characteristics
 */
711
struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
L
Linus Torvalds 已提交
712 713 714 715 716 717
{
	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) {
718 719
		if (cred != NULL && pos->cred != cred)
			continue;
720 721 722 723
		if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
			continue;
		ctx = get_nfs_open_context(pos);
		break;
L
Linus Torvalds 已提交
724 725 726 727 728
	}
	spin_unlock(&inode->i_lock);
	return ctx;
}

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

	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);
739
		__put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1);
L
Linus Torvalds 已提交
740 741 742 743 744 745 746 747 748 749
	}
}

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

750 751 752
	ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
	if (IS_ERR(ctx))
		return PTR_ERR(ctx);
L
Linus Torvalds 已提交
753 754
	nfs_file_set_open_context(filp, ctx);
	put_nfs_open_context(ctx);
D
David Howells 已提交
755
	nfs_fscache_set_inode_cookie(inode, filp);
L
Linus Torvalds 已提交
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
	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;
773
	struct nfs_fattr *fattr = NULL;
L
Linus Torvalds 已提交
774 775 776 777 778
	struct nfs_inode *nfsi = NFS_I(inode);

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

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

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

789
	nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
790
	status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr);
L
Linus Torvalds 已提交
791 792 793 794 795 796 797
	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 已提交
798
				set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
L
Linus Torvalds 已提交
799 800 801 802
		}
		goto out;
	}

803
	status = nfs_refresh_inode(inode, fattr);
L
Linus Torvalds 已提交
804 805 806 807 808 809
	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;
	}
810

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

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

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

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

827 828 829 830 831
	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)
{
832
	if (nfs_have_delegated_attributes(inode))
L
Linus Torvalds 已提交
833
		return 0;
834
	return nfs_attribute_timeout(inode);
L
Linus Torvalds 已提交
835 836 837 838 839 840 841 842 843 844 845
}

/**
 * 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)
{
846
	if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
847
			&& !nfs_attribute_cache_expired(inode))
L
Linus Torvalds 已提交
848 849 850 851
		return NFS_STALE(inode) ? -ESTALE : 0;
	return __nfs_revalidate_inode(server, inode);
}

852
static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
853 854 855 856 857 858 859 860 861 862
{
	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;
863
	if (S_ISDIR(inode->i_mode))
864 865 866
		memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
	spin_unlock(&inode->i_lock);
	nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
D
David Howells 已提交
867
	nfs_fscache_reset_inode_cookie(inode);
868 869 870 871 872 873 874 875 876 877 878 879 880 881
	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;
882

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

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

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

	if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
			&& (fattr->valid & NFS_ATTR_FATTR_MTIME)
			&& timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
920 921 922 923
		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;
924
	}
925 926 927
	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)
928 929 930 931 932
			&& nfsi->npages == 0) {
		i_size_write(inode, nfs_size_to_loff_t(fattr->size));
		ret |= NFS_INO_INVALID_ATTR;
	}
	return ret;
933 934
}

L
Linus Torvalds 已提交
935
/**
936
 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
L
Linus Torvalds 已提交
937 938 939 940 941 942 943
 * @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.
 */
944
static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
L
Linus Torvalds 已提交
945 946 947
{
	struct nfs_inode *nfsi = NFS_I(inode);
	loff_t cur_size, new_isize;
948
	unsigned long invalid = 0;
L
Linus Torvalds 已提交
949

950

951
	/* Has the inode gone and changed behind our back? */
952 953 954
	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))
955 956
		return -EIO;

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

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

965 966 967 968 969 970
	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 已提交
971 972

	/* Have any file permissions changed? */
973 974 975 976 977
	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)
978
		invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
L
Linus Torvalds 已提交
979 980

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

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

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

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

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

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

1008
static atomic_long_t nfs_attr_generation_counter;
1009 1010 1011

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

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

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

1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
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;
}

1049
#ifdef NFS_DEBUG
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
/*
 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle
 *                             in the same way that wireshark does
 *
 * @fh: file handle
 *
 * For debugging only.
 */
u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
{
	/* wireshark uses 32-bit AUTODIN crc and does a bitwise
	 * not on the result */
	return ~crc32(0xFFFFFFFF, &fh->data[0], fh->size);
}

/*
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
 * _nfs_display_fhandle - display an NFS file handle on the console
 *
 * @fh: file handle to display
 * @caption: display caption
 *
 * For debugging only.
 */
void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
{
	unsigned short i;

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

1082 1083
	printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
	       caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
	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

1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
/**
 * 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.
1123
 * Note also the check for wraparound of 'attr_gencount'
1124 1125 1126 1127 1128 1129 1130 1131 1132
 *
 * 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);

1133
	return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
T
Trond Myklebust 已提交
1134 1135
		nfs_ctime_need_update(inode, fattr) ||
		nfs_size_need_update(inode, fattr) ||
1136
		((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
1137 1138 1139 1140 1141
}

static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
{
	if (nfs_inode_attrs_need_update(inode, fattr))
1142 1143 1144 1145
		return nfs_update_inode(inode, fattr);
	return nfs_check_inode_attributes(inode, fattr);
}

1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
/**
 * 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);
1163
	status = nfs_refresh_inode_locked(inode, fattr);
1164
	spin_unlock(&inode->i_lock);
D
David Howells 已提交
1165

1166 1167 1168
	return status;
}

1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
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);
}

1181 1182 1183 1184 1185 1186 1187
/**
 * 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.
1188 1189 1190 1191 1192 1193
 *
 * 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().
1194 1195 1196
 */
int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
{
1197
	int status;
1198

1199
	spin_lock(&inode->i_lock);
1200
	status = nfs_post_op_update_inode_locked(inode, fattr);
1201
	spin_unlock(&inode->i_lock);
1202
	return status;
1203 1204
}

1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
/**
 * 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)
{
1218 1219 1220 1221 1222 1223
	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)) {
1224 1225 1226 1227
		fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
				| NFS_ATTR_FATTR_PRESIZE
				| NFS_ATTR_FATTR_PREMTIME
				| NFS_ATTR_FATTR_PRECTIME);
1228 1229
		goto out_noforce;
	}
1230 1231
	if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
1232
		fattr->pre_change_attr = inode->i_version;
1233
		fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
1234
	}
1235 1236
	if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
1237
		memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
1238 1239 1240 1241
		fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
	}
	if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
1242
		memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
1243 1244 1245 1246
		fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
	}
	if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
1247
		fattr->pre_size = i_size_read(inode);
1248
		fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
1249
	}
1250 1251 1252 1253
out_noforce:
	status = nfs_post_op_update_inode_locked(inode, fattr);
	spin_unlock(&inode->i_lock);
	return status;
1254 1255
}

L
Linus Torvalds 已提交
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
/*
 * 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.
 */
1268
static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
L
Linus Torvalds 已提交
1269
{
1270
	struct nfs_server *server;
L
Linus Torvalds 已提交
1271
	struct nfs_inode *nfsi = NFS_I(inode);
1272
	loff_t cur_isize, new_isize;
1273
	unsigned long invalid = 0;
1274
	unsigned long now = jiffies;
1275
	unsigned long save_cache_validity;
L
Linus Torvalds 已提交
1276

1277
	dfprintk(VFS, "NFS: %s(%s/%ld fh_crc=0x%08x ct=%d info=0x%x)\n",
1278
			__func__, inode->i_sb->s_id, inode->i_ino,
1279
			nfs_display_fhandle_hash(NFS_FH(inode)),
L
Linus Torvalds 已提交
1280 1281
			atomic_read(&inode->i_count), fattr->valid);

1282
	if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
1283
		goto out_fileid;
L
Linus Torvalds 已提交
1284 1285 1286 1287

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

1291
	server = NFS_SERVER(inode);
T
Trond Myklebust 已提交
1292
	/* Update the fsid? */
1293
	if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
1294
			!nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
1295
			!IS_AUTOMOUNT(inode))
1296 1297
		server->fsid = fattr->fsid;

L
Linus Torvalds 已提交
1298 1299 1300
	/*
	 * Update the read time so we don't revalidate too often.
	 */
1301
	nfsi->read_cache_jiffies = fattr->time_start;
1302

1303 1304 1305 1306 1307
	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 已提交
1308

1309
	/* Do atomic weak cache consistency updates */
1310
	invalid |= nfs_wcc_update_inode(inode, fattr);
1311

1312
	/* More cache consistency checks */
1313
	if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
1314
		if (inode->i_version != fattr->change_attr) {
1315 1316 1317 1318 1319
			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);
1320
			inode->i_version = fattr->change_attr;
1321
		}
1322 1323
	} else if (server->caps & NFS_CAP_CHANGE_ATTR)
		invalid |= save_cache_validity;
1324 1325

	if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
1326 1327 1328 1329 1330
		/* 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;
1331 1332
			if (S_ISDIR(inode->i_mode))
				nfs_force_lookup_revalidate(inode);
1333
			memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1334
		}
1335 1336 1337 1338 1339 1340
	} 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);

1341
	if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
1342
		/* If ctime has changed we should definitely clear access+acl caches */
1343
		if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) {
1344
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1345 1346 1347 1348 1349 1350 1351
			/* 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);
			}
1352
			memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1353
		}
1354 1355 1356 1357 1358
	} 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);
1359

1360
	/* Check if our cached file size is stale */
1361 1362 1363 1364 1365 1366
	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? */
1367 1368
			if ((nfsi->npages == 0 && !test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) ||
			     new_isize > cur_isize) {
1369 1370 1371
				i_size_write(inode, new_isize);
				invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
			}
1372 1373 1374 1375 1376 1377
			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 已提交
1378
		}
1379 1380 1381 1382
	} else
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_PAGECACHE
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1383 1384


1385 1386
	if (fattr->valid & NFS_ATTR_FATTR_ATIME)
		memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
1387 1388 1389
	else if (server->caps & NFS_CAP_ATIME)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1390

1391 1392
	if (fattr->valid & NFS_ATTR_FATTR_MODE) {
		if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
1393 1394 1395
			umode_t newmode = inode->i_mode & S_IFMT;
			newmode |= fattr->mode & S_IALLUGO;
			inode->i_mode = newmode;
1396 1397
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
		}
1398 1399 1400 1401 1402 1403
	} 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);

1404 1405 1406 1407 1408
	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;
		}
1409 1410 1411 1412 1413 1414
	} 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);

1415 1416 1417 1418 1419
	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;
		}
1420 1421 1422 1423 1424
	} 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);
1425

1426 1427 1428 1429 1430
	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 已提交
1431
			set_nlink(inode, fattr->nlink);
1432
		}
1433 1434 1435
	} else if (server->caps & NFS_CAP_NLINK)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1436

1437
	if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
L
Linus Torvalds 已提交
1438 1439 1440 1441 1442
		/*
		 * report the blocks in 512byte units
		 */
		inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
 	}
1443 1444
	if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
		inode->i_blocks = fattr->du.nfs2.blocks;
L
Linus Torvalds 已提交
1445 1446 1447

	/* Update attrtimeo value if we're out of the unstable period */
	if (invalid & NFS_INO_INVALID_ATTR) {
C
Chuck Lever 已提交
1448
		nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
L
Linus Torvalds 已提交
1449
		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
1450
		nfsi->attrtimeo_timestamp = now;
1451
		nfsi->attr_gencount = nfs_inc_attr_generation_counter();
1452
	} else {
1453
		if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
1454 1455 1456 1457
			if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
				nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
			nfsi->attrtimeo_timestamp = now;
		}
L
Linus Torvalds 已提交
1458
	}
1459
	invalid &= ~NFS_INO_INVALID_ATTR;
L
Linus Torvalds 已提交
1460 1461 1462 1463
	/* 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;
1464
	if (!nfs_have_delegation(inode, FMODE_READ) ||
1465
			(save_cache_validity & NFS_INO_REVAL_FORCED))
1466
		nfsi->cache_validity |= invalid;
L
Linus Torvalds 已提交
1467 1468 1469 1470 1471 1472

	return 0;
 out_changed:
	/*
	 * Big trouble! The inode has become a different object.
	 */
1473
	printk(KERN_DEBUG "NFS: %s: inode %ld mode changed, %07o to %07o\n",
1474
			__func__, inode->i_ino, inode->i_mode, fattr->mode);
1475
 out_err:
L
Linus Torvalds 已提交
1476 1477 1478 1479 1480 1481 1482
	/*
	 * 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;
1483 1484 1485 1486

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

1492

L
Linus Torvalds 已提交
1493 1494 1495 1496 1497 1498 1499
#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().
 */
1500
void nfs4_evict_inode(struct inode *inode)
L
Linus Torvalds 已提交
1501
{
1502 1503
	truncate_inode_pages(&inode->i_data, 0);
	end_writeback(inode);
B
Benny Halevy 已提交
1504 1505
	pnfs_return_layout(inode);
	pnfs_destroy_layout(NFS_I(inode));
L
Linus Torvalds 已提交
1506
	/* If we are holding a delegation, return it! */
1507
	nfs_inode_return_delegation_noreclaim(inode);
L
Linus Torvalds 已提交
1508 1509 1510 1511 1512
	/* First call standard NFS clear_inode() code */
	nfs_clear_inode(inode);
}
#endif

D
David Howells 已提交
1513
struct inode *nfs_alloc_inode(struct super_block *sb)
L
Linus Torvalds 已提交
1514 1515
{
	struct nfs_inode *nfsi;
1516
	nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
1517 1518
	if (!nfsi)
		return NULL;
1519 1520
	nfsi->flags = 0UL;
	nfsi->cache_validity = 0UL;
1521 1522 1523 1524
#ifdef CONFIG_NFS_V3_ACL
	nfsi->acl_access = ERR_PTR(-EAGAIN);
	nfsi->acl_default = ERR_PTR(-EAGAIN);
#endif
1525 1526 1527
#ifdef CONFIG_NFS_V4
	nfsi->nfs4_acl = NULL;
#endif /* CONFIG_NFS_V4 */
L
Linus Torvalds 已提交
1528 1529 1530
	return &nfsi->vfs_inode;
}

N
Nick Piggin 已提交
1531
static void nfs_i_callback(struct rcu_head *head)
L
Linus Torvalds 已提交
1532
{
N
Nick Piggin 已提交
1533
	struct inode *inode = container_of(head, struct inode, i_rcu);
L
Linus Torvalds 已提交
1534 1535 1536
	kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
}

N
Nick Piggin 已提交
1537 1538 1539 1540 1541
void nfs_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, nfs_i_callback);
}

A
Andrew Morton 已提交
1542 1543 1544 1545 1546 1547 1548
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);
1549
	nfsi->layout = NULL;
1550
	atomic_set(&nfsi->commits_outstanding, 0);
A
Andrew Morton 已提交
1551 1552
#endif
}
D
David Howells 已提交
1553

1554
static void init_once(void *foo)
L
Linus Torvalds 已提交
1555 1556 1557
{
	struct nfs_inode *nfsi = (struct nfs_inode *) foo;

C
Christoph Lameter 已提交
1558 1559 1560 1561
	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);
F
Fred Isaman 已提交
1562
	INIT_LIST_HEAD(&nfsi->commit_list);
C
Christoph Lameter 已提交
1563
	nfsi->npages = 0;
1564
	nfsi->ncommit = 0;
T
Trond Myklebust 已提交
1565 1566 1567
	atomic_set(&nfsi->silly_count, 1);
	INIT_HLIST_HEAD(&nfsi->silly_list);
	init_waitqueue_head(&nfsi->waitqueue);
C
Christoph Lameter 已提交
1568
	nfs4_init_once(nfsi);
L
Linus Torvalds 已提交
1569
}
1570

D
David Howells 已提交
1571
static int __init nfs_init_inodecache(void)
L
Linus Torvalds 已提交
1572 1573 1574
{
	nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
					     sizeof(struct nfs_inode),
1575 1576
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
1577
					     init_once);
L
Linus Torvalds 已提交
1578 1579 1580 1581 1582 1583
	if (nfs_inode_cachep == NULL)
		return -ENOMEM;

	return 0;
}

1584
static void nfs_destroy_inodecache(void)
L
Linus Torvalds 已提交
1585
{
1586
	kmem_cache_destroy(nfs_inode_cachep);
L
Linus Torvalds 已提交
1587 1588
}

T
Trond Myklebust 已提交
1589 1590 1591 1592 1593 1594 1595 1596 1597
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");
1598
	wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
T
Trond Myklebust 已提交
1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
	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);
}

1619
int nfs_net_id;
1620
EXPORT_SYMBOL_GPL(nfs_net_id);
1621 1622 1623

static int nfs_net_init(struct net *net)
{
1624
	nfs_clients_init(net);
1625 1626 1627 1628 1629 1630
	return nfs_dns_resolver_cache_init(net);
}

static void nfs_net_exit(struct net *net)
{
	nfs_dns_resolver_cache_destroy(net);
1631
	nfs_cleanup_cb_ident_idr(net);
1632 1633 1634 1635 1636 1637 1638 1639 1640
}

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 已提交
1641 1642 1643 1644 1645 1646 1647
/*
 * Initialize NFS
 */
static int __init init_nfs_fs(void)
{
	int err;

B
Bryan Schumaker 已提交
1648 1649
	err = nfs_idmap_init();
	if (err < 0)
1650
		goto out10;
B
Bryan Schumaker 已提交
1651

1652
	err = nfs_dns_resolver_init();
1653 1654 1655 1656
	if (err < 0)
		goto out9;

	err = register_pernet_subsys(&nfs_net_ops);
1657 1658 1659
	if (err < 0)
		goto out8;

1660 1661 1662 1663
	err = nfs_fscache_register();
	if (err < 0)
		goto out7;

T
Trond Myklebust 已提交
1664 1665 1666 1667
	err = nfsiod_start();
	if (err)
		goto out6;

1668 1669 1670 1671
	err = nfs_fs_proc_init();
	if (err)
		goto out5;

L
Linus Torvalds 已提交
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692
	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
1693
	rpc_proc_register(&init_net, &nfs_rpcstat);
L
Linus Torvalds 已提交
1694
#endif
D
David Howells 已提交
1695
	if ((err = register_nfs_fs()) != 0)
L
Linus Torvalds 已提交
1696 1697 1698 1699
		goto out;
	return 0;
out:
#ifdef CONFIG_PROC_FS
1700
	rpc_proc_unregister(&init_net, "nfs");
L
Linus Torvalds 已提交
1701 1702
#endif
	nfs_destroy_directcache();
1703 1704
out0:
	nfs_destroy_writepagecache();
L
Linus Torvalds 已提交
1705 1706 1707 1708 1709 1710 1711
out1:
	nfs_destroy_readpagecache();
out2:
	nfs_destroy_inodecache();
out3:
	nfs_destroy_nfspagecache();
out4:
1712 1713
	nfs_fs_proc_exit();
out5:
T
Trond Myklebust 已提交
1714 1715
	nfsiod_stop();
out6:
1716 1717
	nfs_fscache_unregister();
out7:
1718
	unregister_pernet_subsys(&nfs_net_ops);
1719
out8:
1720
	nfs_dns_resolver_destroy();
B
Bryan Schumaker 已提交
1721
out9:
1722 1723
	nfs_idmap_quit();
out10:
L
Linus Torvalds 已提交
1724 1725 1726 1727 1728 1729 1730 1731 1732 1733
	return err;
}

static void __exit exit_nfs_fs(void)
{
	nfs_destroy_directcache();
	nfs_destroy_writepagecache();
	nfs_destroy_readpagecache();
	nfs_destroy_inodecache();
	nfs_destroy_nfspagecache();
1734
	nfs_fscache_unregister();
1735
	unregister_pernet_subsys(&nfs_net_ops);
1736
	nfs_dns_resolver_destroy();
B
Bryan Schumaker 已提交
1737
	nfs_idmap_quit();
L
Linus Torvalds 已提交
1738
#ifdef CONFIG_PROC_FS
1739
	rpc_proc_unregister(&init_net, "nfs");
L
Linus Torvalds 已提交
1740
#endif
D
David Howells 已提交
1741
	unregister_nfs_fs();
1742
	nfs_fs_proc_exit();
T
Trond Myklebust 已提交
1743
	nfsiod_stop();
L
Linus Torvalds 已提交
1744 1745 1746 1747 1748
}

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

module_init(init_nfs_fs)
module_exit(exit_nfs_fs)