inode.c 48.4 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
#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/vfs.h>
36 37
#include <linux/inet.h>
#include <linux/nfs_xdr.h>
38
#include <linux/slab.h>
39
#include <linux/compat.h>
40
#include <linux/freezer.h>
41
#include <linux/crc32.h>
L
Linus Torvalds 已提交
42 43 44

#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"
53
#include "nfs.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
	return 0;
}
B
Bryan Schumaker 已提交
85
EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
86

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

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

110 111 112 113 114 115
int nfs_drop_inode(struct inode *inode)
{
	return NFS_STALE(inode) || generic_drop_inode(inode);
}
EXPORT_SYMBOL_GPL(nfs_drop_inode);

116
void nfs_clear_inode(struct inode *inode)
L
Linus Torvalds 已提交
117
{
T
Trond Myklebust 已提交
118 119 120
	/*
	 * The following should never happen...
	 */
121 122
	WARN_ON_ONCE(nfs_have_writebacks(inode));
	WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files));
123
	nfs_zap_acl_cache(inode);
124
	nfs_access_zap_cache(inode);
D
David Howells 已提交
125
	nfs_fscache_release_inode_cookie(inode);
L
Linus Torvalds 已提交
126
}
B
Bryan Schumaker 已提交
127
EXPORT_SYMBOL_GPL(nfs_clear_inode);
L
Linus Torvalds 已提交
128

129 130 131
void nfs_evict_inode(struct inode *inode)
{
	truncate_inode_pages(&inode->i_data, 0);
132
	clear_inode(inode);
133 134 135
	nfs_clear_inode(inode);
}

T
Trond Myklebust 已提交
136 137 138 139 140
/**
 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
 */
int nfs_sync_mapping(struct address_space *mapping)
{
T
Trond Myklebust 已提交
141
	int ret = 0;
T
Trond Myklebust 已提交
142

T
Trond Myklebust 已提交
143 144 145 146
	if (mapping->nrpages != 0) {
		unmap_mapping_range(mapping, 0, 0, 0);
		ret = nfs_wb_all(mapping->host);
	}
T
Trond Myklebust 已提交
147 148 149
	return ret;
}

L
Linus Torvalds 已提交
150 151 152
/*
 * Invalidate the local caches
 */
153
static void nfs_zap_caches_locked(struct inode *inode)
L
Linus Torvalds 已提交
154 155 156 157
{
	struct nfs_inode *nfsi = NFS_I(inode);
	int mode = inode->i_mode;

C
Chuck Lever 已提交
158 159
	nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);

160 161
	nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
	nfsi->attrtimeo_timestamp = jiffies;
L
Linus Torvalds 已提交
162

163
	memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
D
David Howells 已提交
164
	if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
165
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
D
David Howells 已提交
166 167
		nfs_fscache_invalidate(inode);
	} else {
168
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
D
David Howells 已提交
169
	}
170
}
171

172 173 174 175
void nfs_zap_caches(struct inode *inode)
{
	spin_lock(&inode->i_lock);
	nfs_zap_caches_locked(inode);
176
	spin_unlock(&inode->i_lock);
177 178
}

179 180 181 182 183
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;
D
David Howells 已提交
184
		nfs_fscache_invalidate(inode);
185 186 187 188
		spin_unlock(&inode->i_lock);
	}
}

189
void nfs_zap_acl_cache(struct inode *inode)
190 191 192 193 194 195
{
	void (*clear_acl_cache)(struct inode *);

	clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
	if (clear_acl_cache != NULL)
		clear_acl_cache(inode);
196
	spin_lock(&inode->i_lock);
197
	NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
198
	spin_unlock(&inode->i_lock);
L
Linus Torvalds 已提交
199
}
B
Bryan Schumaker 已提交
200
EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
L
Linus Torvalds 已提交
201

202 203 204 205 206 207
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);
}
B
Bryan Schumaker 已提交
208
EXPORT_SYMBOL_GPL(nfs_invalidate_atime);
209

L
Linus Torvalds 已提交
210
/*
211 212
 * Invalidate, but do not unhash, the inode.
 * NB: must be called with inode->i_lock held!
L
Linus Torvalds 已提交
213
 */
214
static void nfs_invalidate_inode(struct inode *inode)
L
Linus Torvalds 已提交
215
{
B
Benny Halevy 已提交
216
	set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
217
	nfs_zap_caches_locked(inode);
L
Linus Torvalds 已提交
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
}

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;

253
	set_nfs_fileid(inode, fattr->fileid);
L
Linus Torvalds 已提交
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
	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
	};
269
	struct inode *inode = ERR_PTR(-ENOENT);
L
Linus Torvalds 已提交
270 271
	unsigned long hash;

272 273
	nfs_attr_check_mountpoint(sb, fattr);

274 275
	if (((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0) &&
	    !nfs_attr_use_mounted_on_fileid(fattr))
L
Linus Torvalds 已提交
276
		goto out_no_inode;
277
	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
L
Linus Torvalds 已提交
278 279 280 281
		goto out_no_inode;

	hash = nfs_fattr_to_ino_t(fattr);

282 283 284
	inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
	if (inode == NULL) {
		inode = ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
285
		goto out_no_inode;
286
	}
L
Linus Torvalds 已提交
287 288 289

	if (inode->i_state & I_NEW) {
		struct nfs_inode *nfsi = NFS_I(inode);
290
		unsigned long now = jiffies;
L
Linus Torvalds 已提交
291 292 293 294 295 296 297 298

		/* 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;
299 300
		if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
				&& nfs_server_capable(inode, NFS_CAP_MODE))
T
Trond Myklebust 已提交
301
			nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
L
Linus Torvalds 已提交
302 303 304
		/* Why so? Because we want revalidate for devices/FIFOs, and
		 * that's precisely what we have in nfs_file_inode_operations.
		 */
305
		inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
L
Linus Torvalds 已提交
306
		if (S_ISREG(inode->i_mode)) {
307
			inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
L
Linus Torvalds 已提交
308 309 310
			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)) {
311
			inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
L
Linus Torvalds 已提交
312
			inode->i_fop = &nfs_dir_operations;
313
			inode->i_data.a_ops = &nfs_dir_aops;
314
			/* Deal with crossing mountpoints */
315 316
			if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
					fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
M
Manoj Naik 已提交
317 318 319 320
				if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
					inode->i_op = &nfs_referral_inode_operations;
				else
					inode->i_op = &nfs_mountpoint_inode_operations;
321
				inode->i_fop = NULL;
322
				inode->i_flags |= S_AUTOMOUNT;
323
			}
L
Linus Torvalds 已提交
324 325 326 327 328
		} else if (S_ISLNK(inode->i_mode))
			inode->i_op = &nfs_symlink_inode_operations;
		else
			init_special_inode(inode, inode->i_mode, fattr->rdev);

329 330 331
		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));
332
		inode->i_version = 0;
333
		inode->i_size = 0;
334
		clear_nlink(inode);
335 336 337 338
		inode->i_uid = -2;
		inode->i_gid = -2;
		inode->i_blocks = 0;
		memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
339 340
		nfsi->write_io = 0;
		nfsi->read_io = 0;
341

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

D
David Howells 已提交
389 390
		nfs_fscache_init_inode_cookie(inode);

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

out:
	return inode;

out_no_inode:
404
	dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
L
Linus Torvalds 已提交
405 406
	goto out;
}
B
Bryan Schumaker 已提交
407
EXPORT_SYMBOL_GPL(nfs_fhget);
L
Linus Torvalds 已提交
408

409
#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 已提交
410 411 412 413 414

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

C
Chuck Lever 已提交
418 419
	nfs_inc_stats(inode, NFSIOS_VFSSETATTR);

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

434
	/* Write all dirty data */
435 436
	if (S_ISREG(inode->i_mode)) {
		nfs_inode_dio_wait(inode);
437
		nfs_wb_all(inode);
438
	}
439 440 441 442

	fattr = nfs_alloc_fattr();
	if (fattr == NULL)
		goto out;
443 444 445 446
	/*
	 * Return any delegations if we're going to change ACLs
	 */
	if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
447
		NFS_PROTO(inode)->return_delegation(inode);
448
	error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
449
	if (error == 0)
450 451 452
		nfs_refresh_inode(inode, fattr);
	nfs_free_fattr(fattr);
out:
453 454
	return error;
}
B
Bryan Schumaker 已提交
455
EXPORT_SYMBOL_GPL(nfs_setattr);
456

457 458 459 460 461 462 463 464 465 466 467
/**
 * 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 已提交
468 469
	loff_t oldsize;
	int err;
470

N
npiggin@suse.de 已提交
471 472 473
	err = inode_newsize_ok(inode, offset);
	if (err)
		goto out;
474

N
npiggin@suse.de 已提交
475 476 477 478 479 480 481 482
	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;
483 484
}

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

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

522
	/* Flush out writes to the server in order to update c/mtime.  */
523
	if (S_ISREG(inode->i_mode)) {
524
		nfs_inode_dio_wait(inode);
525 526 527
		err = filemap_write_and_wait(inode->i_mapping);
		if (err)
			goto out;
528
	}
529 530 531 532 533 534 535 536 537 538 539 540

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

L
Linus Torvalds 已提交
543 544 545 546
	if (need_atime)
		err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
	else
		err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
P
Peter Staubach 已提交
547
	if (!err) {
L
Linus Torvalds 已提交
548
		generic_fillattr(inode, stat);
549
		stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
P
Peter Staubach 已提交
550
	}
551
out:
L
Linus Torvalds 已提交
552 553
	return err;
}
B
Bryan Schumaker 已提交
554
EXPORT_SYMBOL_GPL(nfs_getattr);
L
Linus Torvalds 已提交
555

556 557 558
static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
{
	atomic_set(&l_ctx->count, 1);
559 560
	l_ctx->lockowner.l_owner = current->files;
	l_ctx->lockowner.l_pid = current->tgid;
561 562 563 564 565 566 567 568
	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) {
569
		if (pos->lockowner.l_owner != current->files)
570
			continue;
571
		if (pos->lockowner.l_pid != current->tgid)
572 573 574 575 576 577 578 579 580 581
			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;
582
	struct inode *inode = ctx->dentry->d_inode;
583 584 585 586 587 588 589

	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)
590
			return ERR_PTR(-ENOMEM);
591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
		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;
609
	struct inode *inode = ctx->dentry->d_inode;
610 611 612 613 614 615 616 617

	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 已提交
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
/**
 * 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;
635
	inode = ctx->dentry->d_inode;
T
Trond Myklebust 已提交
636 637 638 639 640 641 642
	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);
}
B
Bryan Schumaker 已提交
643
EXPORT_SYMBOL_GPL(nfs_close_context);
T
Trond Myklebust 已提交
644

645
struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode)
L
Linus Torvalds 已提交
646 647
{
	struct nfs_open_context *ctx;
648 649 650
	struct rpc_cred *cred = rpc_lookup_cred();
	if (IS_ERR(cred))
		return ERR_CAST(cred);
L
Linus Torvalds 已提交
651

652
	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
653 654 655
	if (!ctx) {
		put_rpccred(cred);
		return ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
656
	}
657 658 659 660 661 662 663 664 665 666
	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);
667
	ctx->mdsthreshold = NULL;
L
Linus Torvalds 已提交
668 669
	return ctx;
}
B
Bryan Schumaker 已提交
670
EXPORT_SYMBOL_GPL(alloc_nfs_open_context);
L
Linus Torvalds 已提交
671 672 673 674

struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
{
	if (ctx != NULL)
675
		atomic_inc(&ctx->lock_context.count);
L
Linus Torvalds 已提交
676 677
	return ctx;
}
B
Bryan Schumaker 已提交
678
EXPORT_SYMBOL_GPL(get_nfs_open_context);
L
Linus Torvalds 已提交
679

T
Trond Myklebust 已提交
680
static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
L
Linus Torvalds 已提交
681
{
682 683
	struct inode *inode = ctx->dentry->d_inode;
	struct super_block *sb = ctx->dentry->d_sb;
684

685
	if (!list_empty(&ctx->list)) {
686 687 688 689 690
		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 已提交
691
		return;
692 693
	if (inode != NULL)
		NFS_PROTO(inode)->close_context(ctx, is_sync);
694 695
	if (ctx->cred != NULL)
		put_rpccred(ctx->cred);
696
	dput(ctx->dentry);
697 698 699 700
	if (is_sync)
		nfs_sb_deactive(sb);
	else
		nfs_sb_deactive_async(sb);
701
	kfree(ctx->mdsthreshold);
702 703 704
	kfree(ctx);
}

705 706 707 708
void put_nfs_open_context(struct nfs_open_context *ctx)
{
	__put_nfs_open_context(ctx, 0);
}
B
Bryan Schumaker 已提交
709
EXPORT_SYMBOL_GPL(put_nfs_open_context);
710

L
Linus Torvalds 已提交
711 712 713 714
/*
 * Ensure that mmap has a recent RPC credential for use when writing out
 * shared pages
 */
715
void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
L
Linus Torvalds 已提交
716
{
A
Al Viro 已提交
717
	struct inode *inode = file_inode(filp);
L
Linus Torvalds 已提交
718 719 720 721 722 723 724
	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);
}
B
Bryan Schumaker 已提交
725
EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
L
Linus Torvalds 已提交
726

727 728 729
/*
 * Given an inode, search for an open context with the desired characteristics
 */
730
struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
L
Linus Torvalds 已提交
731 732 733 734 735 736
{
	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) {
737 738
		if (cred != NULL && pos->cred != cred)
			continue;
739 740 741 742
		if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
			continue;
		ctx = get_nfs_open_context(pos);
		break;
L
Linus Torvalds 已提交
743 744 745 746 747
	}
	spin_unlock(&inode->i_lock);
	return ctx;
}

748
static void nfs_file_clear_open_context(struct file *filp)
L
Linus Torvalds 已提交
749
{
A
Al Viro 已提交
750
	struct inode *inode = file_inode(filp);
751
	struct nfs_open_context *ctx = nfs_file_open_context(filp);
L
Linus Torvalds 已提交
752 753 754 755 756 757

	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);
758
		__put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1);
L
Linus Torvalds 已提交
759 760 761 762 763 764 765 766 767 768
	}
}

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

769 770 771
	ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
	if (IS_ERR(ctx))
		return PTR_ERR(ctx);
L
Linus Torvalds 已提交
772 773
	nfs_file_set_open_context(filp, ctx);
	put_nfs_open_context(ctx);
D
David Howells 已提交
774
	nfs_fscache_set_inode_cookie(inode, filp);
L
Linus Torvalds 已提交
775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
	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;
792
	struct nfs_fattr *fattr = NULL;
L
Linus Torvalds 已提交
793 794 795 796 797
	struct nfs_inode *nfsi = NFS_I(inode);

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

798
	if (is_bad_inode(inode))
799
		goto out;
L
Linus Torvalds 已提交
800
	if (NFS_STALE(inode))
801
		goto out;
802

803 804 805 806 807
	status = -ENOMEM;
	fattr = nfs_alloc_fattr();
	if (fattr == NULL)
		goto out;

808
	nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
809
	status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr);
L
Linus Torvalds 已提交
810 811 812 813 814 815 816
	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 已提交
817
				set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
L
Linus Torvalds 已提交
818 819 820 821
		}
		goto out;
	}

822
	status = nfs_refresh_inode(inode, fattr);
L
Linus Torvalds 已提交
823 824 825 826 827 828
	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;
	}
829

830
	if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
831
		nfs_zap_acl_cache(inode);
832

L
Linus Torvalds 已提交
833 834 835 836
	dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
		inode->i_sb->s_id,
		(long long)NFS_FILEID(inode));

837
 out:
838
	nfs_free_fattr(fattr);
L
Linus Torvalds 已提交
839 840 841 842 843 844 845
	return status;
}

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

846 847 848 849 850
	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)
{
851
	if (nfs_have_delegated_attributes(inode))
L
Linus Torvalds 已提交
852
		return 0;
853
	return nfs_attribute_timeout(inode);
L
Linus Torvalds 已提交
854 855 856 857 858 859 860 861 862 863 864
}

/**
 * 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)
{
865
	if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
866
			&& !nfs_attribute_cache_expired(inode))
L
Linus Torvalds 已提交
867 868 869
		return NFS_STALE(inode) ? -ESTALE : 0;
	return __nfs_revalidate_inode(server, inode);
}
B
Bryan Schumaker 已提交
870
EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
L
Linus Torvalds 已提交
871

872
static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
873 874 875 876 877 878 879 880 881 882
{
	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;
883
	if (S_ISDIR(inode->i_mode))
884 885 886
		memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
	spin_unlock(&inode->i_lock);
	nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
D
David Howells 已提交
887
	nfs_fscache_wait_on_invalidate(inode);
888 889 890 891 892
	dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
			inode->i_sb->s_id, (long long)NFS_FILEID(inode));
	return 0;
}

893 894 895 896 897 898 899 900 901
static bool nfs_mapping_need_revalidate_inode(struct inode *inode)
{
	if (nfs_have_delegated_attributes(inode))
		return false;
	return (NFS_I(inode)->cache_validity & NFS_INO_REVAL_PAGECACHE)
		|| nfs_attribute_timeout(inode)
		|| NFS_STALE(inode);
}

902 903 904 905 906 907 908 909 910
/**
 * 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;
911

912 913 914 915
	/* swapfiles are not supposed to be shared. */
	if (IS_SWAPFILE(inode))
		goto out;

916
	if (nfs_mapping_need_revalidate_inode(inode)) {
917 918 919
		ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
		if (ret < 0)
			goto out;
920
	}
921 922
	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
		ret = nfs_invalidate_mapping(inode, mapping);
923
out:
924
	return ret;
925 926
}

927
static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
928 929
{
	struct nfs_inode *nfsi = NFS_I(inode);
930
	unsigned long ret = 0;
931

932 933
	if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
			&& (fattr->valid & NFS_ATTR_FATTR_CHANGE)
934 935
			&& inode->i_version == fattr->pre_change_attr) {
		inode->i_version = fattr->change_attr;
936 937
		if (S_ISDIR(inode->i_mode))
			nfsi->cache_validity |= NFS_INO_INVALID_DATA;
938
		ret |= NFS_INO_INVALID_ATTR;
939
	}
940
	/* If we have atomic WCC data, we may update some attributes */
941 942
	if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
			&& (fattr->valid & NFS_ATTR_FATTR_CTIME)
943 944 945 946
			&& timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
		memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
		ret |= NFS_INO_INVALID_ATTR;
	}
947 948 949 950

	if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
			&& (fattr->valid & NFS_ATTR_FATTR_MTIME)
			&& timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
951 952 953 954
		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;
955
	}
956 957 958
	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)
959 960 961 962
			&& nfsi->npages == 0) {
		i_size_write(inode, nfs_size_to_loff_t(fattr->size));
		ret |= NFS_INO_INVALID_ATTR;
	}
D
David Howells 已提交
963 964 965 966

	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
		nfs_fscache_invalidate(inode);

967
	return ret;
968 969
}

L
Linus Torvalds 已提交
970
/**
971
 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
L
Linus Torvalds 已提交
972 973 974 975 976 977 978
 * @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.
 */
979
static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
L
Linus Torvalds 已提交
980 981 982
{
	struct nfs_inode *nfsi = NFS_I(inode);
	loff_t cur_size, new_isize;
983
	unsigned long invalid = 0;
L
Linus Torvalds 已提交
984

985

986 987
	if (nfs_have_delegated_attributes(inode))
		return 0;
988
	/* Has the inode gone and changed behind our back? */
989 990 991
	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))
992 993
		return -EIO;

994
	if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
995
			inode->i_version != fattr->change_attr)
996
		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
L
Linus Torvalds 已提交
997 998

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

1002 1003 1004 1005 1006 1007
	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 已提交
1008 1009

	/* Have any file permissions changed? */
1010 1011 1012 1013 1014
	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)
1015
		invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
L
Linus Torvalds 已提交
1016 1017

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

1021
	if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
1022 1023 1024 1025
		invalid |= NFS_INO_INVALID_ATIME;

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

1027
	nfsi->read_cache_jiffies = fattr->time_start;
L
Linus Torvalds 已提交
1028 1029 1030
	return 0;
}

1031
static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1032
{
1033 1034
	if (!(fattr->valid & NFS_ATTR_FATTR_CTIME))
		return 0;
1035 1036 1037 1038 1039
	return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0;
}

static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
{
1040 1041
	if (!(fattr->valid & NFS_ATTR_FATTR_SIZE))
		return 0;
1042 1043
	return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
}
1044

1045
static atomic_long_t nfs_attr_generation_counter;
1046 1047 1048

static unsigned long nfs_read_attr_generation_counter(void)
{
1049
	return atomic_long_read(&nfs_attr_generation_counter);
1050 1051 1052 1053
}

unsigned long nfs_inc_attr_generation_counter(void)
{
1054
	return atomic_long_inc_return(&nfs_attr_generation_counter);
1055 1056 1057 1058 1059 1060 1061
}

void nfs_fattr_init(struct nfs_fattr *fattr)
{
	fattr->valid = 0;
	fattr->time_start = jiffies;
	fattr->gencount = nfs_inc_attr_generation_counter();
1062 1063
	fattr->owner_name = NULL;
	fattr->group_name = NULL;
1064
}
B
Bryan Schumaker 已提交
1065
EXPORT_SYMBOL_GPL(nfs_fattr_init);
1066

1067 1068 1069 1070 1071 1072 1073 1074 1075
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;
}
B
Bryan Schumaker 已提交
1076
EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086

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;
}
B
Bryan Schumaker 已提交
1087
EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
1088

1089
#ifdef NFS_DEBUG
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
/*
 * _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);
}

/*
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
 * _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;

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

1122 1123
	printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
	       caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
	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

1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
/**
 * 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.
1163
 * Note also the check for wraparound of 'attr_gencount'
1164 1165 1166 1167 1168 1169 1170 1171 1172
 *
 * 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);

1173
	return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
T
Trond Myklebust 已提交
1174 1175
		nfs_ctime_need_update(inode, fattr) ||
		nfs_size_need_update(inode, fattr) ||
1176
		((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
1177 1178 1179 1180 1181
}

static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
{
	if (nfs_inode_attrs_need_update(inode, fattr))
1182 1183 1184 1185
		return nfs_update_inode(inode, fattr);
	return nfs_check_inode_attributes(inode, fattr);
}

1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
/**
 * 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);
1203
	status = nfs_refresh_inode_locked(inode, fattr);
1204
	spin_unlock(&inode->i_lock);
D
David Howells 已提交
1205

1206 1207
	return status;
}
B
Bryan Schumaker 已提交
1208
EXPORT_SYMBOL_GPL(nfs_refresh_inode);
1209

1210 1211 1212 1213 1214
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;
D
David Howells 已提交
1215
	if (S_ISDIR(inode->i_mode)) {
1216
		nfsi->cache_validity |= NFS_INO_INVALID_DATA;
D
David Howells 已提交
1217 1218
		nfs_fscache_invalidate(inode);
	}
1219 1220 1221 1222 1223
	if ((fattr->valid & NFS_ATTR_FATTR) == 0)
		return 0;
	return nfs_refresh_inode_locked(inode, fattr);
}

1224 1225 1226 1227 1228 1229 1230
/**
 * 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.
1231 1232 1233 1234 1235 1236
 *
 * 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().
1237 1238 1239
 */
int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
{
1240
	int status;
1241

1242
	spin_lock(&inode->i_lock);
1243
	status = nfs_post_op_update_inode_locked(inode, fattr);
1244
	spin_unlock(&inode->i_lock);
1245
	return status;
1246
}
B
Bryan Schumaker 已提交
1247
EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
1248

1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
/**
 * 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)
{
1262 1263 1264 1265 1266 1267
	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)) {
1268 1269 1270 1271
		fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
				| NFS_ATTR_FATTR_PRESIZE
				| NFS_ATTR_FATTR_PREMTIME
				| NFS_ATTR_FATTR_PRECTIME);
1272 1273
		goto out_noforce;
	}
1274 1275
	if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
1276
		fattr->pre_change_attr = inode->i_version;
1277
		fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
1278
	}
1279 1280
	if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
1281
		memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
1282 1283 1284 1285
		fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
	}
	if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
1286
		memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
1287 1288 1289 1290
		fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
	}
	if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
1291
		fattr->pre_size = i_size_read(inode);
1292
		fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
1293
	}
1294 1295 1296 1297
out_noforce:
	status = nfs_post_op_update_inode_locked(inode, fattr);
	spin_unlock(&inode->i_lock);
	return status;
1298
}
B
Bryan Schumaker 已提交
1299
EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
1300

L
Linus Torvalds 已提交
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
/*
 * 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.
 */
1313
static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
L
Linus Torvalds 已提交
1314
{
1315
	struct nfs_server *server;
L
Linus Torvalds 已提交
1316
	struct nfs_inode *nfsi = NFS_I(inode);
1317
	loff_t cur_isize, new_isize;
1318
	unsigned long invalid = 0;
1319
	unsigned long now = jiffies;
1320
	unsigned long save_cache_validity;
L
Linus Torvalds 已提交
1321

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

1327 1328 1329 1330 1331 1332 1333 1334
	if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) {
		printk(KERN_ERR "NFS: server %s error: fileid changed\n"
			"fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
			NFS_SERVER(inode)->nfs_client->cl_hostname,
			inode->i_sb->s_id, (long long)nfsi->fileid,
			(long long)fattr->fileid);
		goto out_err;
	}
L
Linus Torvalds 已提交
1335 1336 1337 1338

	/*
	 * Make sure the inode's type hasn't changed.
	 */
1339 1340 1341 1342 1343 1344 1345 1346
	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
		/*
		* Big trouble! The inode has become a different object.
		*/
		printk(KERN_DEBUG "NFS: %s: inode %ld mode changed, %07o to %07o\n",
				__func__, inode->i_ino, inode->i_mode, fattr->mode);
		goto out_err;
	}
L
Linus Torvalds 已提交
1347

1348
	server = NFS_SERVER(inode);
T
Trond Myklebust 已提交
1349
	/* Update the fsid? */
1350
	if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
1351
			!nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
1352
			!IS_AUTOMOUNT(inode))
1353 1354
		server->fsid = fattr->fsid;

L
Linus Torvalds 已提交
1355 1356 1357
	/*
	 * Update the read time so we don't revalidate too often.
	 */
1358
	nfsi->read_cache_jiffies = fattr->time_start;
1359

1360 1361 1362 1363 1364
	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 已提交
1365

1366
	/* Do atomic weak cache consistency updates */
1367
	invalid |= nfs_wcc_update_inode(inode, fattr);
1368

1369
	/* More cache consistency checks */
1370
	if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
1371
		if (inode->i_version != fattr->change_attr) {
1372 1373
			dprintk("NFS: change_attr change on server for file %s/%ld\n",
					inode->i_sb->s_id, inode->i_ino);
1374 1375 1376 1377 1378
			invalid |= NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_DATA
				| NFS_INO_INVALID_ACCESS
				| NFS_INO_INVALID_ACL
				| NFS_INO_REVAL_PAGECACHE;
1379 1380
			if (S_ISDIR(inode->i_mode))
				nfs_force_lookup_revalidate(inode);
1381
			inode->i_version = fattr->change_attr;
1382
		}
1383 1384
	} else if (server->caps & NFS_CAP_CHANGE_ATTR)
		invalid |= save_cache_validity;
1385 1386

	if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
1387
		memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1388 1389 1390 1391
	} else if (server->caps & NFS_CAP_MTIME)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_FORCED);

1392
	if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
1393
		memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1394 1395 1396
	} else if (server->caps & NFS_CAP_CTIME)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_FORCED);
1397

1398
	/* Check if our cached file size is stale */
1399 1400 1401 1402 1403 1404
	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? */
1405 1406
			if ((nfsi->npages == 0 && !test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) ||
			     new_isize > cur_isize) {
1407 1408 1409
				i_size_write(inode, new_isize);
				invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
			}
1410 1411 1412 1413 1414 1415
			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 已提交
1416
		}
1417 1418 1419 1420
	} else
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_PAGECACHE
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1421 1422


1423 1424
	if (fattr->valid & NFS_ATTR_FATTR_ATIME)
		memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
1425 1426 1427
	else if (server->caps & NFS_CAP_ATIME)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1428

1429 1430
	if (fattr->valid & NFS_ATTR_FATTR_MODE) {
		if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
1431 1432 1433
			umode_t newmode = inode->i_mode & S_IFMT;
			newmode |= fattr->mode & S_IALLUGO;
			inode->i_mode = newmode;
1434 1435
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
		}
1436 1437 1438 1439 1440 1441
	} 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);

1442 1443 1444 1445 1446
	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;
		}
1447 1448 1449 1450 1451 1452
	} 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);

1453 1454 1455 1456 1457
	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;
		}
1458 1459 1460 1461 1462
	} 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);
1463

1464 1465 1466 1467 1468
	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 已提交
1469
			set_nlink(inode, fattr->nlink);
1470
		}
1471 1472 1473
	} else if (server->caps & NFS_CAP_NLINK)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1474

1475
	if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
L
Linus Torvalds 已提交
1476 1477 1478 1479 1480
		/*
		 * report the blocks in 512byte units
		 */
		inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
 	}
1481 1482
	if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
		inode->i_blocks = fattr->du.nfs2.blocks;
L
Linus Torvalds 已提交
1483 1484 1485

	/* Update attrtimeo value if we're out of the unstable period */
	if (invalid & NFS_INO_INVALID_ATTR) {
C
Chuck Lever 已提交
1486
		nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
L
Linus Torvalds 已提交
1487
		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
1488
		nfsi->attrtimeo_timestamp = now;
1489
		nfsi->attr_gencount = nfs_inc_attr_generation_counter();
1490
	} else {
1491
		if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
1492 1493 1494 1495
			if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
				nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
			nfsi->attrtimeo_timestamp = now;
		}
L
Linus Torvalds 已提交
1496
	}
1497
	invalid &= ~NFS_INO_INVALID_ATTR;
L
Linus Torvalds 已提交
1498 1499 1500 1501
	/* 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;
1502
	if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ) ||
1503
			(save_cache_validity & NFS_INO_REVAL_FORCED))
1504
		nfsi->cache_validity |= invalid;
L
Linus Torvalds 已提交
1505

D
David Howells 已提交
1506 1507 1508
	if (invalid & NFS_INO_INVALID_DATA)
		nfs_fscache_invalidate(inode);

L
Linus Torvalds 已提交
1509
	return 0;
1510
 out_err:
L
Linus Torvalds 已提交
1511 1512 1513 1514 1515 1516 1517 1518 1519
	/*
	 * 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;
}

D
David Howells 已提交
1520
struct inode *nfs_alloc_inode(struct super_block *sb)
L
Linus Torvalds 已提交
1521 1522
{
	struct nfs_inode *nfsi;
1523
	nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
1524 1525
	if (!nfsi)
		return NULL;
1526 1527
	nfsi->flags = 0UL;
	nfsi->cache_validity = 0UL;
1528 1529 1530 1531
#ifdef CONFIG_NFS_V3_ACL
	nfsi->acl_access = ERR_PTR(-EAGAIN);
	nfsi->acl_default = ERR_PTR(-EAGAIN);
#endif
B
Bryan Schumaker 已提交
1532
#if IS_ENABLED(CONFIG_NFS_V4)
1533 1534
	nfsi->nfs4_acl = NULL;
#endif /* CONFIG_NFS_V4 */
L
Linus Torvalds 已提交
1535 1536
	return &nfsi->vfs_inode;
}
B
Bryan Schumaker 已提交
1537
EXPORT_SYMBOL_GPL(nfs_alloc_inode);
L
Linus Torvalds 已提交
1538

N
Nick Piggin 已提交
1539
static void nfs_i_callback(struct rcu_head *head)
L
Linus Torvalds 已提交
1540
{
N
Nick Piggin 已提交
1541
	struct inode *inode = container_of(head, struct inode, i_rcu);
L
Linus Torvalds 已提交
1542 1543 1544
	kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
}

N
Nick Piggin 已提交
1545 1546 1547 1548
void nfs_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, nfs_i_callback);
}
B
Bryan Schumaker 已提交
1549
EXPORT_SYMBOL_GPL(nfs_destroy_inode);
N
Nick Piggin 已提交
1550

A
Andrew Morton 已提交
1551 1552
static inline void nfs4_init_once(struct nfs_inode *nfsi)
{
B
Bryan Schumaker 已提交
1553
#if IS_ENABLED(CONFIG_NFS_V4)
A
Andrew Morton 已提交
1554 1555 1556 1557
	INIT_LIST_HEAD(&nfsi->open_states);
	nfsi->delegation = NULL;
	nfsi->delegation_state = 0;
	init_rwsem(&nfsi->rwsem);
1558
	nfsi->layout = NULL;
A
Andrew Morton 已提交
1559 1560
#endif
}
D
David Howells 已提交
1561

1562
static void init_once(void *foo)
L
Linus Torvalds 已提交
1563 1564 1565
{
	struct nfs_inode *nfsi = (struct nfs_inode *) foo;

C
Christoph Lameter 已提交
1566 1567 1568 1569
	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 已提交
1570
	INIT_LIST_HEAD(&nfsi->commit_info.list);
C
Christoph Lameter 已提交
1571
	nfsi->npages = 0;
F
Fred Isaman 已提交
1572
	nfsi->commit_info.ncommit = 0;
1573
	atomic_set(&nfsi->commit_info.rpcs_out, 0);
T
Trond Myklebust 已提交
1574 1575 1576
	atomic_set(&nfsi->silly_count, 1);
	INIT_HLIST_HEAD(&nfsi->silly_list);
	init_waitqueue_head(&nfsi->waitqueue);
C
Christoph Lameter 已提交
1577
	nfs4_init_once(nfsi);
L
Linus Torvalds 已提交
1578
}
1579

D
David Howells 已提交
1580
static int __init nfs_init_inodecache(void)
L
Linus Torvalds 已提交
1581 1582 1583
{
	nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
					     sizeof(struct nfs_inode),
1584 1585
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
1586
					     init_once);
L
Linus Torvalds 已提交
1587 1588 1589 1590 1591 1592
	if (nfs_inode_cachep == NULL)
		return -ENOMEM;

	return 0;
}

1593
static void nfs_destroy_inodecache(void)
L
Linus Torvalds 已提交
1594
{
1595 1596 1597 1598 1599
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
1600
	kmem_cache_destroy(nfs_inode_cachep);
L
Linus Torvalds 已提交
1601 1602
}

T
Trond Myklebust 已提交
1603
struct workqueue_struct *nfsiod_workqueue;
B
Bryan Schumaker 已提交
1604
EXPORT_SYMBOL_GPL(nfsiod_workqueue);
T
Trond Myklebust 已提交
1605 1606 1607 1608 1609 1610 1611 1612

/*
 * start up the nfsiod workqueue
 */
static int nfsiod_start(void)
{
	struct workqueue_struct *wq;
	dprintk("RPC:       creating workqueue nfsiod\n");
1613
	wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
T
Trond Myklebust 已提交
1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
	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);
}

1634
int nfs_net_id;
1635
EXPORT_SYMBOL_GPL(nfs_net_id);
1636 1637 1638

static int nfs_net_init(struct net *net)
{
1639
	nfs_clients_init(net);
1640 1641 1642 1643 1644 1645
	return nfs_dns_resolver_cache_init(net);
}

static void nfs_net_exit(struct net *net)
{
	nfs_dns_resolver_cache_destroy(net);
1646
	nfs_cleanup_cb_ident_idr(net);
1647 1648 1649 1650 1651 1652 1653 1654 1655
}

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 已提交
1656 1657 1658 1659 1660 1661 1662
/*
 * Initialize NFS
 */
static int __init init_nfs_fs(void)
{
	int err;

1663
	err = nfs_dns_resolver_init();
1664
	if (err < 0)
B
Bryan Schumaker 已提交
1665
		goto out10;;
1666 1667

	err = register_pernet_subsys(&nfs_net_ops);
1668
	if (err < 0)
B
Bryan Schumaker 已提交
1669
		goto out9;
1670

1671 1672
	err = nfs_fscache_register();
	if (err < 0)
B
Bryan Schumaker 已提交
1673
		goto out8;
1674

T
Trond Myklebust 已提交
1675 1676
	err = nfsiod_start();
	if (err)
B
Bryan Schumaker 已提交
1677
		goto out7;
T
Trond Myklebust 已提交
1678

1679 1680
	err = nfs_fs_proc_init();
	if (err)
B
Bryan Schumaker 已提交
1681
		goto out6;
1682

L
Linus Torvalds 已提交
1683 1684
	err = nfs_init_nfspagecache();
	if (err)
B
Bryan Schumaker 已提交
1685
		goto out5;
L
Linus Torvalds 已提交
1686 1687 1688

	err = nfs_init_inodecache();
	if (err)
B
Bryan Schumaker 已提交
1689
		goto out4;
L
Linus Torvalds 已提交
1690 1691 1692

	err = nfs_init_readpagecache();
	if (err)
B
Bryan Schumaker 已提交
1693
		goto out3;
L
Linus Torvalds 已提交
1694 1695 1696

	err = nfs_init_writepagecache();
	if (err)
B
Bryan Schumaker 已提交
1697
		goto out2;
L
Linus Torvalds 已提交
1698 1699 1700

	err = nfs_init_directcache();
	if (err)
B
Bryan Schumaker 已提交
1701
		goto out1;
L
Linus Torvalds 已提交
1702 1703

#ifdef CONFIG_PROC_FS
1704
	rpc_proc_register(&init_net, &nfs_rpcstat);
L
Linus Torvalds 已提交
1705
#endif
D
David Howells 已提交
1706
	if ((err = register_nfs_fs()) != 0)
1707 1708
		goto out0;

L
Linus Torvalds 已提交
1709
	return 0;
1710
out0:
L
Linus Torvalds 已提交
1711
#ifdef CONFIG_PROC_FS
1712
	rpc_proc_unregister(&init_net, "nfs");
L
Linus Torvalds 已提交
1713 1714
#endif
	nfs_destroy_directcache();
B
Bryan Schumaker 已提交
1715
out1:
1716
	nfs_destroy_writepagecache();
B
Bryan Schumaker 已提交
1717
out2:
1718
	nfs_destroy_readpagecache();
B
Bryan Schumaker 已提交
1719
out3:
1720
	nfs_destroy_inodecache();
B
Bryan Schumaker 已提交
1721
out4:
1722
	nfs_destroy_nfspagecache();
B
Bryan Schumaker 已提交
1723
out5:
1724
	nfs_fs_proc_exit();
B
Bryan Schumaker 已提交
1725
out6:
1726
	nfsiod_stop();
B
Bryan Schumaker 已提交
1727
out7:
1728
	nfs_fscache_unregister();
B
Bryan Schumaker 已提交
1729
out8:
1730
	unregister_pernet_subsys(&nfs_net_ops);
B
Bryan Schumaker 已提交
1731
out9:
1732
	nfs_dns_resolver_destroy();
B
Bryan Schumaker 已提交
1733
out10:
L
Linus Torvalds 已提交
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
	return err;
}

static void __exit exit_nfs_fs(void)
{
	nfs_destroy_directcache();
	nfs_destroy_writepagecache();
	nfs_destroy_readpagecache();
	nfs_destroy_inodecache();
	nfs_destroy_nfspagecache();
1744
	nfs_fscache_unregister();
1745
	unregister_pernet_subsys(&nfs_net_ops);
1746
	nfs_dns_resolver_destroy();
L
Linus Torvalds 已提交
1747
#ifdef CONFIG_PROC_FS
1748
	rpc_proc_unregister(&init_net, "nfs");
L
Linus Torvalds 已提交
1749
#endif
D
David Howells 已提交
1750
	unregister_nfs_fs();
1751
	nfs_fs_proc_exit();
T
Trond Myklebust 已提交
1752
	nfsiod_stop();
L
Linus Torvalds 已提交
1753 1754 1755 1756 1757
}

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

module_init(init_nfs_fs)
module_exit(exit_nfs_fs)