inode.c 45.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>
L
Linus Torvalds 已提交
41 42 43 44

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

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

#define NFSDBG_FACILITY		NFSDBG_VFS

56 57 58 59 60
#define NFS_64_BIT_INODE_NUMBERS_ENABLED	1

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

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

64
static struct kmem_cache * nfs_inode_cachep;
65

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

72 73 74 75 76 77 78 79 80 81 82 83
/**
 * 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;
	schedule();
	return 0;
}

84 85 86 87 88 89 90 91 92
/**
 * 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)
{
93 94 95 96 97
#ifdef CONFIG_COMPAT
	compat_ulong_t ino;
#else	
	unsigned long ino;
#endif
98 99 100 101 102 103 104 105 106

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

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

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

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

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

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

C
Chuck Lever 已提交
148 149
	nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);

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

	memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode)));
	if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
155
		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 已提交
156
	else
157
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
158
}
159

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

167 168 169 170 171 172 173 174 175
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);
	}
}

176
void nfs_zap_acl_cache(struct inode *inode)
177 178 179 180 181 182
{
	void (*clear_acl_cache)(struct inode *);

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

188 189 190 191 192 193 194
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 已提交
195
/*
196 197
 * Invalidate, but do not unhash, the inode.
 * NB: must be called with inode->i_lock held!
L
Linus Torvalds 已提交
198
 */
199
static void nfs_invalidate_inode(struct inode *inode)
L
Linus Torvalds 已提交
200
{
B
Benny Halevy 已提交
201
	set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
202
	nfs_zap_caches_locked(inode);
L
Linus Torvalds 已提交
203 204 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
}

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;

238
	set_nfs_fileid(inode, fattr->fileid);
L
Linus Torvalds 已提交
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
	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
	};
254
	struct inode *inode = ERR_PTR(-ENOENT);
L
Linus Torvalds 已提交
255 256
	unsigned long hash;

257 258 259
	nfs_attr_check_mountpoint(sb, fattr);

	if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0 && (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT) == 0)
L
Linus Torvalds 已提交
260
		goto out_no_inode;
261
	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
L
Linus Torvalds 已提交
262 263 264 265
		goto out_no_inode;

	hash = nfs_fattr_to_ino_t(fattr);

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

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

		/* 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;
283 284 285 286 287
		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 已提交
288 289 290
		/* Why so? Because we want revalidate for devices/FIFOs, and
		 * that's precisely what we have in nfs_file_inode_operations.
		 */
291
		inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
L
Linus Torvalds 已提交
292 293 294 295 296
		if (S_ISREG(inode->i_mode)) {
			inode->i_fop = &nfs_file_operations;
			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)) {
297
			inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
L
Linus Torvalds 已提交
298
			inode->i_fop = &nfs_dir_operations;
299
			inode->i_data.a_ops = &nfs_dir_aops;
B
Bryan Schumaker 已提交
300
			if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS))
B
Benny Halevy 已提交
301
				set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
302
			/* Deal with crossing mountpoints */
303 304
			if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
					fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
M
Manoj Naik 已提交
305 306 307 308
				if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
					inode->i_op = &nfs_referral_inode_operations;
				else
					inode->i_op = &nfs_mountpoint_inode_operations;
309
				inode->i_fop = NULL;
310
				inode->i_flags |= S_AUTOMOUNT;
311
			}
L
Linus Torvalds 已提交
312 313 314 315 316
		} else if (S_ISLNK(inode->i_mode))
			inode->i_op = &nfs_symlink_inode_operations;
		else
			init_special_inode(inode, inode->i_mode, fattr->rdev);

317 318 319 320 321 322 323 324 325 326 327
		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));
		nfsi->change_attr = 0;
		inode->i_size = 0;
		inode->i_nlink = 0;
		inode->i_uid = -2;
		inode->i_gid = -2;
		inode->i_blocks = 0;
		memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));

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

D
David Howells 已提交
384 385
		nfs_fscache_init_inode_cookie(inode);

L
Linus Torvalds 已提交
386 387 388 389 390 391 392 393 394 395 396 397
		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:
398
	dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
L
Linus Torvalds 已提交
399 400 401
	goto out;
}

402
#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE)
L
Linus Torvalds 已提交
403 404 405 406 407

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

C
Chuck Lever 已提交
411 412
	nfs_inc_stats(inode, NFSIOS_VFSSETATTR);

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

427
	/* Write all dirty data */
428
	if (S_ISREG(inode->i_mode))
429
		nfs_wb_all(inode);
430 431 432 433

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

447 448 449 450 451 452 453 454 455 456 457
/**
 * 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 已提交
458 459
	loff_t oldsize;
	int err;
460

N
npiggin@suse.de 已提交
461 462 463
	err = inode_newsize_ok(inode, offset);
	if (err)
		goto out;
464

N
npiggin@suse.de 已提交
465 466 467 468 469 470 471 472
	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;
473 474
}

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

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

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

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

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

543 544 545 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 572 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 599 600 601 602 603 604
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;
	struct inode *inode = ctx->path.dentry->d_inode;

	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;
	struct inode *inode = ctx->path.dentry->d_inode;

	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 已提交
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
/**
 * 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;
	inode = ctx->path.dentry->d_inode;
	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);
}

631
struct nfs_open_context *alloc_nfs_open_context(struct path *path, struct rpc_cred *cred, fmode_t f_mode)
L
Linus Torvalds 已提交
632 633 634
{
	struct nfs_open_context *ctx;

635
	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
L
Linus Torvalds 已提交
636
	if (ctx != NULL) {
637 638
		ctx->path = *path;
		path_get(&ctx->path);
L
Linus Torvalds 已提交
639 640
		ctx->cred = get_rpccred(cred);
		ctx->state = NULL;
641
		ctx->mode = f_mode;
642
		ctx->flags = 0;
L
Linus Torvalds 已提交
643
		ctx->error = 0;
644 645
		nfs_init_lock_context(&ctx->lock_context);
		ctx->lock_context.open_context = ctx;
646
		INIT_LIST_HEAD(&ctx->list);
L
Linus Torvalds 已提交
647 648 649 650 651 652 653
	}
	return ctx;
}

struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
{
	if (ctx != NULL)
654
		atomic_inc(&ctx->lock_context.count);
L
Linus Torvalds 已提交
655 656 657
	return ctx;
}

T
Trond Myklebust 已提交
658
static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
L
Linus Torvalds 已提交
659
{
T
Trond Myklebust 已提交
660
	struct inode *inode = ctx->path.dentry->d_inode;
661

662
	if (!list_empty(&ctx->list)) {
663 664 665 666 667
		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 已提交
668
		return;
669 670
	if (inode != NULL)
		NFS_PROTO(inode)->close_context(ctx, is_sync);
671 672
	if (ctx->cred != NULL)
		put_rpccred(ctx->cred);
J
Jan Blunck 已提交
673
	path_put(&ctx->path);
674 675 676
	kfree(ctx);
}

677 678 679 680 681
void put_nfs_open_context(struct nfs_open_context *ctx)
{
	__put_nfs_open_context(ctx, 0);
}

L
Linus Torvalds 已提交
682 683 684 685
/*
 * Ensure that mmap has a recent RPC credential for use when writing out
 * shared pages
 */
686
void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
L
Linus Torvalds 已提交
687
{
688
	struct inode *inode = filp->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
689 690 691 692 693 694 695 696
	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);
}

697 698 699
/*
 * Given an inode, search for an open context with the desired characteristics
 */
700
struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
L
Linus Torvalds 已提交
701 702 703 704 705 706
{
	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) {
707 708
		if (cred != NULL && pos->cred != cred)
			continue;
709 710 711 712
		if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
			continue;
		ctx = get_nfs_open_context(pos);
		break;
L
Linus Torvalds 已提交
713 714 715 716 717
	}
	spin_unlock(&inode->i_lock);
	return ctx;
}

718
static void nfs_file_clear_open_context(struct file *filp)
L
Linus Torvalds 已提交
719
{
720
	struct inode *inode = filp->f_path.dentry->d_inode;
721
	struct nfs_open_context *ctx = nfs_file_open_context(filp);
L
Linus Torvalds 已提交
722 723 724 725 726 727

	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);
728
		__put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1);
L
Linus Torvalds 已提交
729 730 731 732 733 734 735 736 737 738 739
	}
}

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

740
	cred = rpc_lookup_cred();
L
Linus Torvalds 已提交
741 742
	if (IS_ERR(cred))
		return PTR_ERR(cred);
743
	ctx = alloc_nfs_open_context(&filp->f_path, cred, filp->f_mode);
L
Linus Torvalds 已提交
744 745 746 747 748
	put_rpccred(cred);
	if (ctx == NULL)
		return -ENOMEM;
	nfs_file_set_open_context(filp, ctx);
	put_nfs_open_context(ctx);
D
David Howells 已提交
749
	nfs_fscache_set_inode_cookie(inode, filp);
L
Linus Torvalds 已提交
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
	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;
767
	struct nfs_fattr *fattr = NULL;
L
Linus Torvalds 已提交
768 769 770 771 772
	struct nfs_inode *nfsi = NFS_I(inode);

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

773
	if (is_bad_inode(inode))
774
		goto out;
L
Linus Torvalds 已提交
775
	if (NFS_STALE(inode))
776
		goto out;
777

778 779 780 781 782
	status = -ENOMEM;
	fattr = nfs_alloc_fattr();
	if (fattr == NULL)
		goto out;

783
	nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
784
	status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr);
L
Linus Torvalds 已提交
785 786 787 788 789 790 791
	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 已提交
792
				set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
L
Linus Torvalds 已提交
793 794 795 796
		}
		goto out;
	}

797
	status = nfs_refresh_inode(inode, fattr);
L
Linus Torvalds 已提交
798 799 800 801 802 803
	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;
	}
804

805
	if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
806
		nfs_zap_acl_cache(inode);
807

L
Linus Torvalds 已提交
808 809 810 811
	dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
		inode->i_sb->s_id,
		(long long)NFS_FILEID(inode));

812
 out:
813
	nfs_free_fattr(fattr);
L
Linus Torvalds 已提交
814 815 816 817 818 819 820
	return status;
}

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

821 822 823 824 825
	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)
{
826
	if (nfs_have_delegated_attributes(inode))
L
Linus Torvalds 已提交
827
		return 0;
828
	return nfs_attribute_timeout(inode);
L
Linus Torvalds 已提交
829 830 831 832 833 834 835 836 837 838 839
}

/**
 * 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)
{
840
	if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
841
			&& !nfs_attribute_cache_expired(inode))
L
Linus Torvalds 已提交
842 843 844 845
		return NFS_STALE(inode) ? -ESTALE : 0;
	return __nfs_revalidate_inode(server, inode);
}

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

877
	if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
878 879
			|| nfs_attribute_cache_expired(inode)
			|| NFS_STALE(inode)) {
880 881 882
		ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
		if (ret < 0)
			goto out;
883
	}
884 885
	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
		ret = nfs_invalidate_mapping(inode, mapping);
886
out:
887
	return ret;
888 889
}

890
static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
891 892
{
	struct nfs_inode *nfsi = NFS_I(inode);
893
	unsigned long ret = 0;
894

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

	if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
			&& (fattr->valid & NFS_ATTR_FATTR_MTIME)
			&& timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
914 915 916 917
		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;
918
	}
919 920 921
	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)
922 923 924 925 926
			&& nfsi->npages == 0) {
		i_size_write(inode, nfs_size_to_loff_t(fattr->size));
		ret |= NFS_INO_INVALID_ATTR;
	}
	return ret;
927 928
}

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

944

945
	/* Has the inode gone and changed behind our back? */
946 947 948
	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))
949 950
		return -EIO;

951
	if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
952
			nfsi->change_attr != fattr->change_attr)
953
		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
L
Linus Torvalds 已提交
954 955

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

959 960 961 962 963 964
	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 已提交
965 966

	/* Have any file permissions changed? */
967 968 969 970 971
	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)
972
		invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
L
Linus Torvalds 已提交
973 974

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

978
	if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
979 980 981 982
		invalid |= NFS_INO_INVALID_ATIME;

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

984
	nfsi->read_cache_jiffies = fattr->time_start;
L
Linus Torvalds 已提交
985 986 987
	return 0;
}

988
static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
989
{
990 991
	if (!(fattr->valid & NFS_ATTR_FATTR_CTIME))
		return 0;
992 993 994 995 996
	return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0;
}

static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
{
997 998
	if (!(fattr->valid & NFS_ATTR_FATTR_SIZE))
		return 0;
999 1000
	return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
}
1001

1002
static atomic_long_t nfs_attr_generation_counter;
1003 1004 1005

static unsigned long nfs_read_attr_generation_counter(void)
{
1006
	return atomic_long_read(&nfs_attr_generation_counter);
1007 1008 1009 1010
}

unsigned long nfs_inc_attr_generation_counter(void)
{
1011
	return atomic_long_inc_return(&nfs_attr_generation_counter);
1012 1013 1014 1015 1016 1017 1018 1019 1020
}

void nfs_fattr_init(struct nfs_fattr *fattr)
{
	fattr->valid = 0;
	fattr->time_start = jiffies;
	fattr->gencount = nfs_inc_attr_generation_counter();
}

1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
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;
}

1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
/**
 * 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.
1054
 * Note also the check for wraparound of 'attr_gencount'
1055 1056 1057 1058 1059 1060 1061 1062 1063
 *
 * 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);

1064
	return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
T
Trond Myklebust 已提交
1065 1066
		nfs_ctime_need_update(inode, fattr) ||
		nfs_size_need_update(inode, fattr) ||
1067
		((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
1068 1069 1070 1071 1072
}

static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
{
	if (nfs_inode_attrs_need_update(inode, fattr))
1073 1074 1075 1076
		return nfs_update_inode(inode, fattr);
	return nfs_check_inode_attributes(inode, fattr);
}

1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
/**
 * 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);
1094
	status = nfs_refresh_inode_locked(inode, fattr);
1095
	spin_unlock(&inode->i_lock);
D
David Howells 已提交
1096

1097 1098 1099
	return status;
}

1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
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);
}

1112 1113 1114 1115 1116 1117 1118
/**
 * 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.
1119 1120 1121 1122 1123 1124
 *
 * 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().
1125 1126 1127
 */
int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
{
1128
	int status;
1129

1130
	spin_lock(&inode->i_lock);
1131
	status = nfs_post_op_update_inode_locked(inode, fattr);
1132
	spin_unlock(&inode->i_lock);
1133
	return status;
1134 1135
}

1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148
/**
 * 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)
{
1149 1150 1151 1152 1153 1154
	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)) {
1155 1156 1157 1158
		fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
				| NFS_ATTR_FATTR_PRESIZE
				| NFS_ATTR_FATTR_PREMTIME
				| NFS_ATTR_FATTR_PRECTIME);
1159 1160
		goto out_noforce;
	}
1161 1162
	if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
1163
		fattr->pre_change_attr = NFS_I(inode)->change_attr;
1164
		fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
1165
	}
1166 1167
	if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
1168
		memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
1169 1170 1171 1172
		fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
	}
	if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
1173
		memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
1174 1175 1176 1177
		fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
	}
	if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
1178
		fattr->pre_size = i_size_read(inode);
1179
		fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
1180
	}
1181 1182 1183 1184
out_noforce:
	status = nfs_post_op_update_inode_locked(inode, fattr);
	spin_unlock(&inode->i_lock);
	return status;
1185 1186
}

L
Linus Torvalds 已提交
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
/*
 * 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.
 */
1199
static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
L
Linus Torvalds 已提交
1200
{
1201
	struct nfs_server *server;
L
Linus Torvalds 已提交
1202
	struct nfs_inode *nfsi = NFS_I(inode);
1203
	loff_t cur_isize, new_isize;
1204
	unsigned long invalid = 0;
1205
	unsigned long now = jiffies;
1206
	unsigned long save_cache_validity;
L
Linus Torvalds 已提交
1207 1208

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

1212
	if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
1213
		goto out_fileid;
L
Linus Torvalds 已提交
1214 1215 1216 1217

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

1221
	server = NFS_SERVER(inode);
T
Trond Myklebust 已提交
1222
	/* Update the fsid? */
1223
	if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
1224
			!nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
1225
			!IS_AUTOMOUNT(inode))
1226 1227
		server->fsid = fattr->fsid;

L
Linus Torvalds 已提交
1228 1229 1230
	/*
	 * Update the read time so we don't revalidate too often.
	 */
1231
	nfsi->read_cache_jiffies = fattr->time_start;
1232

1233 1234 1235 1236 1237
	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 已提交
1238

1239
	/* Do atomic weak cache consistency updates */
1240
	invalid |= nfs_wcc_update_inode(inode, fattr);
1241

1242
	/* More cache consistency checks */
1243 1244 1245 1246 1247 1248 1249 1250 1251
	if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
		if (nfsi->change_attr != fattr->change_attr) {
			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);
			nfsi->change_attr = fattr->change_attr;
		}
1252 1253
	} else if (server->caps & NFS_CAP_CHANGE_ATTR)
		invalid |= save_cache_validity;
1254 1255

	if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
1256 1257 1258 1259 1260
		/* 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;
1261 1262
			if (S_ISDIR(inode->i_mode))
				nfs_force_lookup_revalidate(inode);
1263
			memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1264
		}
1265 1266 1267 1268 1269 1270
	} 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);

1271
	if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
1272
		/* If ctime has changed we should definitely clear access+acl caches */
1273
		if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) {
1274
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1275 1276 1277 1278 1279 1280 1281
			/* 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);
			}
1282
			memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1283
		}
1284 1285 1286 1287 1288
	} 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);
1289

1290
	/* Check if our cached file size is stale */
1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
	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? */
			if (nfsi->npages == 0 || new_isize > cur_isize) {
				i_size_write(inode, new_isize);
				invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
			}
			dprintk("NFS: isize change on server for file %s/%ld\n",
					inode->i_sb->s_id, inode->i_ino);
L
Linus Torvalds 已提交
1303
		}
1304 1305 1306 1307
	} else
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_PAGECACHE
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1308 1309


1310 1311
	if (fattr->valid & NFS_ATTR_FATTR_ATIME)
		memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
1312 1313 1314
	else if (server->caps & NFS_CAP_ATIME)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1315

1316 1317
	if (fattr->valid & NFS_ATTR_FATTR_MODE) {
		if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
1318 1319 1320
			umode_t newmode = inode->i_mode & S_IFMT;
			newmode |= fattr->mode & S_IALLUGO;
			inode->i_mode = newmode;
1321 1322
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
		}
1323 1324 1325 1326 1327 1328
	} 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);

1329 1330 1331 1332 1333
	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;
		}
1334 1335 1336 1337 1338 1339
	} 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);

1340 1341 1342 1343 1344
	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;
		}
1345 1346 1347 1348 1349
	} 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);
1350

1351 1352 1353 1354 1355 1356 1357
	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;
			inode->i_nlink = fattr->nlink;
		}
1358 1359 1360
	} else if (server->caps & NFS_CAP_NLINK)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1361

1362
	if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
L
Linus Torvalds 已提交
1363 1364 1365 1366 1367
		/*
		 * report the blocks in 512byte units
		 */
		inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
 	}
1368 1369
	if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
		inode->i_blocks = fattr->du.nfs2.blocks;
L
Linus Torvalds 已提交
1370 1371 1372

	/* Update attrtimeo value if we're out of the unstable period */
	if (invalid & NFS_INO_INVALID_ATTR) {
C
Chuck Lever 已提交
1373
		nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
L
Linus Torvalds 已提交
1374
		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
1375
		nfsi->attrtimeo_timestamp = now;
1376
		nfsi->attr_gencount = nfs_inc_attr_generation_counter();
1377
	} else {
1378
		if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
1379 1380 1381 1382
			if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
				nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
			nfsi->attrtimeo_timestamp = now;
		}
L
Linus Torvalds 已提交
1383
	}
1384
	invalid &= ~NFS_INO_INVALID_ATTR;
L
Linus Torvalds 已提交
1385 1386 1387 1388
	/* 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;
1389
	if (!nfs_have_delegation(inode, FMODE_READ) ||
1390
			(save_cache_validity & NFS_INO_REVAL_FORCED))
1391
		nfsi->cache_validity |= invalid;
L
Linus Torvalds 已提交
1392 1393 1394 1395 1396 1397 1398

	return 0;
 out_changed:
	/*
	 * Big trouble! The inode has become a different object.
	 */
	printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
1399
			__func__, inode->i_ino, inode->i_mode, fattr->mode);
1400
 out_err:
L
Linus Torvalds 已提交
1401 1402 1403 1404 1405 1406 1407
	/*
	 * 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;
1408 1409 1410 1411

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

1417

L
Linus Torvalds 已提交
1418 1419 1420 1421 1422 1423 1424
#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().
 */
1425
void nfs4_evict_inode(struct inode *inode)
L
Linus Torvalds 已提交
1426
{
1427
	pnfs_destroy_layout(NFS_I(inode));
1428 1429
	truncate_inode_pages(&inode->i_data, 0);
	end_writeback(inode);
L
Linus Torvalds 已提交
1430
	/* If we are holding a delegation, return it! */
1431
	nfs_inode_return_delegation_noreclaim(inode);
L
Linus Torvalds 已提交
1432 1433 1434 1435 1436
	/* First call standard NFS clear_inode() code */
	nfs_clear_inode(inode);
}
#endif

D
David Howells 已提交
1437
struct inode *nfs_alloc_inode(struct super_block *sb)
L
Linus Torvalds 已提交
1438 1439
{
	struct nfs_inode *nfsi;
1440
	nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
1441 1442
	if (!nfsi)
		return NULL;
1443 1444
	nfsi->flags = 0UL;
	nfsi->cache_validity = 0UL;
1445 1446 1447 1448
#ifdef CONFIG_NFS_V3_ACL
	nfsi->acl_access = ERR_PTR(-EAGAIN);
	nfsi->acl_default = ERR_PTR(-EAGAIN);
#endif
1449 1450 1451
#ifdef CONFIG_NFS_V4
	nfsi->nfs4_acl = NULL;
#endif /* CONFIG_NFS_V4 */
L
Linus Torvalds 已提交
1452 1453 1454
	return &nfsi->vfs_inode;
}

N
Nick Piggin 已提交
1455
static void nfs_i_callback(struct rcu_head *head)
L
Linus Torvalds 已提交
1456
{
N
Nick Piggin 已提交
1457 1458
	struct inode *inode = container_of(head, struct inode, i_rcu);
	INIT_LIST_HEAD(&inode->i_dentry);
L
Linus Torvalds 已提交
1459 1460 1461
	kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
}

N
Nick Piggin 已提交
1462 1463 1464 1465 1466
void nfs_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, nfs_i_callback);
}

A
Andrew Morton 已提交
1467 1468 1469 1470 1471 1472 1473
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);
1474
	nfsi->layout = NULL;
1475
	atomic_set(&nfsi->commits_outstanding, 0);
A
Andrew Morton 已提交
1476 1477
#endif
}
D
David Howells 已提交
1478

1479
static void init_once(void *foo)
L
Linus Torvalds 已提交
1480 1481 1482
{
	struct nfs_inode *nfsi = (struct nfs_inode *) foo;

C
Christoph Lameter 已提交
1483 1484 1485 1486 1487 1488
	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;
1489
	nfsi->ncommit = 0;
T
Trond Myklebust 已提交
1490 1491 1492
	atomic_set(&nfsi->silly_count, 1);
	INIT_HLIST_HEAD(&nfsi->silly_list);
	init_waitqueue_head(&nfsi->waitqueue);
C
Christoph Lameter 已提交
1493
	nfs4_init_once(nfsi);
L
Linus Torvalds 已提交
1494
}
1495

D
David Howells 已提交
1496
static int __init nfs_init_inodecache(void)
L
Linus Torvalds 已提交
1497 1498 1499
{
	nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
					     sizeof(struct nfs_inode),
1500 1501
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
1502
					     init_once);
L
Linus Torvalds 已提交
1503 1504 1505 1506 1507 1508
	if (nfs_inode_cachep == NULL)
		return -ENOMEM;

	return 0;
}

1509
static void nfs_destroy_inodecache(void)
L
Linus Torvalds 已提交
1510
{
1511
	kmem_cache_destroy(nfs_inode_cachep);
L
Linus Torvalds 已提交
1512 1513
}

T
Trond Myklebust 已提交
1514 1515 1516 1517 1518 1519 1520 1521 1522
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");
1523
	wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
T
Trond Myklebust 已提交
1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
	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);
}

L
Linus Torvalds 已提交
1544 1545 1546 1547 1548 1549 1550
/*
 * Initialize NFS
 */
static int __init init_nfs_fs(void)
{
	int err;

B
Bryan Schumaker 已提交
1551 1552 1553 1554
	err = nfs_idmap_init();
	if (err < 0)
		goto out9;

1555 1556 1557 1558
	err = nfs_dns_resolver_init();
	if (err < 0)
		goto out8;

1559 1560 1561 1562
	err = nfs_fscache_register();
	if (err < 0)
		goto out7;

T
Trond Myklebust 已提交
1563 1564 1565 1566
	err = nfsiod_start();
	if (err)
		goto out6;

1567 1568 1569 1570
	err = nfs_fs_proc_init();
	if (err)
		goto out5;

L
Linus Torvalds 已提交
1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
	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
	rpc_proc_register(&nfs_rpcstat);
#endif
D
David Howells 已提交
1594
	if ((err = register_nfs_fs()) != 0)
L
Linus Torvalds 已提交
1595 1596 1597 1598 1599 1600 1601
		goto out;
	return 0;
out:
#ifdef CONFIG_PROC_FS
	rpc_proc_unregister("nfs");
#endif
	nfs_destroy_directcache();
1602 1603
out0:
	nfs_destroy_writepagecache();
L
Linus Torvalds 已提交
1604 1605 1606 1607 1608 1609 1610
out1:
	nfs_destroy_readpagecache();
out2:
	nfs_destroy_inodecache();
out3:
	nfs_destroy_nfspagecache();
out4:
1611 1612
	nfs_fs_proc_exit();
out5:
T
Trond Myklebust 已提交
1613 1614
	nfsiod_stop();
out6:
1615 1616
	nfs_fscache_unregister();
out7:
1617 1618
	nfs_dns_resolver_destroy();
out8:
B
Bryan Schumaker 已提交
1619 1620
	nfs_idmap_quit();
out9:
L
Linus Torvalds 已提交
1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
	return err;
}

static void __exit exit_nfs_fs(void)
{
	nfs_destroy_directcache();
	nfs_destroy_writepagecache();
	nfs_destroy_readpagecache();
	nfs_destroy_inodecache();
	nfs_destroy_nfspagecache();
1631
	nfs_fscache_unregister();
1632
	nfs_dns_resolver_destroy();
B
Bryan Schumaker 已提交
1633
	nfs_idmap_quit();
L
Linus Torvalds 已提交
1634 1635 1636
#ifdef CONFIG_PROC_FS
	rpc_proc_unregister("nfs");
#endif
A
Andy Adamson 已提交
1637
	nfs_cleanup_cb_ident_idr();
D
David Howells 已提交
1638
	unregister_nfs_fs();
1639
	nfs_fs_proc_exit();
T
Trond Myklebust 已提交
1640
	nfsiod_stop();
L
Linus Torvalds 已提交
1641 1642 1643 1644 1645
}

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

module_init(init_nfs_fs)
module_exit(exit_nfs_fs)