inode.c 47.9 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
void nfs_clear_inode(struct inode *inode)
L
Linus Torvalds 已提交
111
{
T
Trond Myklebust 已提交
112 113 114 115
	/*
	 * The following should never happen...
	 */
	BUG_ON(nfs_have_writebacks(inode));
116
	BUG_ON(!list_empty(&NFS_I(inode)->open_files));
117
	nfs_zap_acl_cache(inode);
118
	nfs_access_zap_cache(inode);
D
David Howells 已提交
119
	nfs_fscache_release_inode_cookie(inode);
L
Linus Torvalds 已提交
120
}
B
Bryan Schumaker 已提交
121
EXPORT_SYMBOL_GPL(nfs_clear_inode);
L
Linus Torvalds 已提交
122

123 124 125
void nfs_evict_inode(struct inode *inode)
{
	truncate_inode_pages(&inode->i_data, 0);
126
	clear_inode(inode);
127 128 129
	nfs_clear_inode(inode);
}

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

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

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

C
Chuck Lever 已提交
152 153
	nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);

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

157
	memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
L
Linus Torvalds 已提交
158
	if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
159
		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 已提交
160
	else
161
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
162
}
163

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

171 172 173 174 175 176 177 178 179
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);
	}
}

180
void nfs_zap_acl_cache(struct inode *inode)
181 182 183 184 185 186
{
	void (*clear_acl_cache)(struct inode *);

	clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
	if (clear_acl_cache != NULL)
		clear_acl_cache(inode);
187
	spin_lock(&inode->i_lock);
188
	NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
189
	spin_unlock(&inode->i_lock);
L
Linus Torvalds 已提交
190
}
B
Bryan Schumaker 已提交
191
EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
L
Linus Torvalds 已提交
192

193 194 195 196 197 198
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 已提交
199
EXPORT_SYMBOL_GPL(nfs_invalidate_atime);
200

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

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;

244
	set_nfs_fileid(inode, fattr->fileid);
L
Linus Torvalds 已提交
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
	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
	};
260
	struct inode *inode = ERR_PTR(-ENOENT);
L
Linus Torvalds 已提交
261 262
	unsigned long hash;

263 264
	nfs_attr_check_mountpoint(sb, fattr);

265 266
	if (((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0) &&
	    !nfs_attr_use_mounted_on_fileid(fattr))
L
Linus Torvalds 已提交
267
		goto out_no_inode;
268
	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
L
Linus Torvalds 已提交
269 270 271 272
		goto out_no_inode;

	hash = nfs_fattr_to_ino_t(fattr);

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

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

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

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

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

D
David Howells 已提交
380 381
		nfs_fscache_init_inode_cookie(inode);

L
Linus Torvalds 已提交
382 383 384
		unlock_new_inode(inode);
	} else
		nfs_refresh_inode(inode, fattr);
385
	dprintk("NFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n",
L
Linus Torvalds 已提交
386 387
		inode->i_sb->s_id,
		(long long)NFS_FILEID(inode),
388
		nfs_display_fhandle_hash(fh),
L
Linus Torvalds 已提交
389 390 391 392 393 394
		atomic_read(&inode->i_count));

out:
	return inode;

out_no_inode:
395
	dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
L
Linus Torvalds 已提交
396 397
	goto out;
}
B
Bryan Schumaker 已提交
398
EXPORT_SYMBOL_GPL(nfs_fhget);
L
Linus Torvalds 已提交
399

400
#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 已提交
401 402 403 404 405

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

C
Chuck Lever 已提交
409 410
	nfs_inc_stats(inode, NFSIOS_VFSSETATTR);

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

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

	fattr = nfs_alloc_fattr();
	if (fattr == NULL)
		goto out;
434 435 436 437
	/*
	 * Return any delegations if we're going to change ACLs
	 */
	if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
438
		NFS_PROTO(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
	return error;
}
B
Bryan Schumaker 已提交
446
EXPORT_SYMBOL_GPL(nfs_setattr);
447

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

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

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

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

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

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

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

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

547 548 549
static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
{
	atomic_set(&l_ctx->count, 1);
550 551
	l_ctx->lockowner.l_owner = current->files;
	l_ctx->lockowner.l_pid = current->tgid;
552 553 554 555 556 557 558 559
	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) {
560
		if (pos->lockowner.l_owner != current->files)
561
			continue;
562
		if (pos->lockowner.l_pid != current->tgid)
563 564 565 566 567 568 569 570 571 572
			continue;
		atomic_inc(&pos->count);
		return pos;
	}
	return NULL;
}

struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
{
	struct nfs_lock_context *res, *new = NULL;
573
	struct inode *inode = ctx->dentry->d_inode;
574 575 576 577 578 579 580

	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)
581
			return ERR_PTR(-ENOMEM);
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
		nfs_init_lock_context(new);
		spin_lock(&inode->i_lock);
		res = __nfs_find_lock_context(ctx);
		if (res == NULL) {
			list_add_tail(&new->list, &ctx->lock_context.list);
			new->open_context = ctx;
			res = new;
			new = NULL;
		}
	}
	spin_unlock(&inode->i_lock);
	kfree(new);
	return res;
}

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

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

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

	if (!(ctx->mode & FMODE_WRITE))
		return;
	if (!is_sync)
		return;
626
	inode = ctx->dentry->d_inode;
T
Trond Myklebust 已提交
627 628 629 630 631 632 633
	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 已提交
634
EXPORT_SYMBOL_GPL(nfs_close_context);
T
Trond Myklebust 已提交
635

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

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

struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
{
	if (ctx != NULL)
666
		atomic_inc(&ctx->lock_context.count);
L
Linus Torvalds 已提交
667 668
	return ctx;
}
B
Bryan Schumaker 已提交
669
EXPORT_SYMBOL_GPL(get_nfs_open_context);
L
Linus Torvalds 已提交
670

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

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

693 694 695 696
void put_nfs_open_context(struct nfs_open_context *ctx)
{
	__put_nfs_open_context(ctx, 0);
}
B
Bryan Schumaker 已提交
697
EXPORT_SYMBOL_GPL(put_nfs_open_context);
698

L
Linus Torvalds 已提交
699 700 701 702
/*
 * Ensure that mmap has a recent RPC credential for use when writing out
 * shared pages
 */
703
void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
L
Linus Torvalds 已提交
704
{
705
	struct inode *inode = filp->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
706 707 708 709 710 711 712
	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 已提交
713
EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
L
Linus Torvalds 已提交
714

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

736
static void nfs_file_clear_open_context(struct file *filp)
L
Linus Torvalds 已提交
737
{
738
	struct inode *inode = filp->f_path.dentry->d_inode;
739
	struct nfs_open_context *ctx = nfs_file_open_context(filp);
L
Linus Torvalds 已提交
740 741 742 743 744 745

	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);
746
		__put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1);
L
Linus Torvalds 已提交
747 748 749 750 751 752 753 754 755 756
	}
}

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

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

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

786
	if (is_bad_inode(inode))
787
		goto out;
L
Linus Torvalds 已提交
788
	if (NFS_STALE(inode))
789
		goto out;
790

791 792 793 794 795
	status = -ENOMEM;
	fattr = nfs_alloc_fattr();
	if (fattr == NULL)
		goto out;

796
	nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
797
	status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr);
L
Linus Torvalds 已提交
798 799 800 801 802 803 804
	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 已提交
805
				set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
L
Linus Torvalds 已提交
806 807 808 809
		}
		goto out;
	}

810
	status = nfs_refresh_inode(inode, fattr);
L
Linus Torvalds 已提交
811 812 813 814 815 816
	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;
	}
817

818
	if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
819
		nfs_zap_acl_cache(inode);
820

L
Linus Torvalds 已提交
821 822 823 824
	dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
		inode->i_sb->s_id,
		(long long)NFS_FILEID(inode));

825
 out:
826
	nfs_free_fattr(fattr);
L
Linus Torvalds 已提交
827 828 829 830 831 832 833
	return status;
}

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

834 835 836 837 838
	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)
{
839
	if (nfs_have_delegated_attributes(inode))
L
Linus Torvalds 已提交
840
		return 0;
841
	return nfs_attribute_timeout(inode);
L
Linus Torvalds 已提交
842 843 844 845 846 847 848 849 850 851 852
}

/**
 * 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)
{
853
	if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
854
			&& !nfs_attribute_cache_expired(inode))
L
Linus Torvalds 已提交
855 856 857
		return NFS_STALE(inode) ? -ESTALE : 0;
	return __nfs_revalidate_inode(server, inode);
}
B
Bryan Schumaker 已提交
858
EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
L
Linus Torvalds 已提交
859

860
static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
861 862 863 864 865 866 867 868 869 870
{
	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;
871
	if (S_ISDIR(inode->i_mode))
872 873 874
		memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
	spin_unlock(&inode->i_lock);
	nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
D
David Howells 已提交
875
	nfs_fscache_reset_inode_cookie(inode);
876 877 878 879 880
	dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
			inode->i_sb->s_id, (long long)NFS_FILEID(inode));
	return 0;
}

881 882 883 884 885 886 887 888 889
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);
}

890 891 892 893 894 895 896 897 898
/**
 * 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;
899

900 901 902 903
	/* swapfiles are not supposed to be shared. */
	if (IS_SWAPFILE(inode))
		goto out;

904
	if (nfs_mapping_need_revalidate_inode(inode)) {
905 906 907
		ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
		if (ret < 0)
			goto out;
908
	}
909 910
	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
		ret = nfs_invalidate_mapping(inode, mapping);
911
out:
912
	return ret;
913 914
}

915
static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
916 917
{
	struct nfs_inode *nfsi = NFS_I(inode);
918
	unsigned long ret = 0;
919

920 921
	if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
			&& (fattr->valid & NFS_ATTR_FATTR_CHANGE)
922 923
			&& inode->i_version == fattr->pre_change_attr) {
		inode->i_version = fattr->change_attr;
924 925
		if (S_ISDIR(inode->i_mode))
			nfsi->cache_validity |= NFS_INO_INVALID_DATA;
926
		ret |= NFS_INO_INVALID_ATTR;
927
	}
928
	/* If we have atomic WCC data, we may update some attributes */
929 930
	if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
			&& (fattr->valid & NFS_ATTR_FATTR_CTIME)
931 932 933 934
			&& timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
		memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
		ret |= NFS_INO_INVALID_ATTR;
	}
935 936 937 938

	if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
			&& (fattr->valid & NFS_ATTR_FATTR_MTIME)
			&& timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
939 940 941 942
		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;
943
	}
944 945 946
	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)
947 948 949 950 951
			&& nfsi->npages == 0) {
		i_size_write(inode, nfs_size_to_loff_t(fattr->size));
		ret |= NFS_INO_INVALID_ATTR;
	}
	return ret;
952 953
}

L
Linus Torvalds 已提交
954
/**
955
 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
L
Linus Torvalds 已提交
956 957 958 959 960 961 962
 * @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.
 */
963
static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
L
Linus Torvalds 已提交
964 965 966
{
	struct nfs_inode *nfsi = NFS_I(inode);
	loff_t cur_size, new_isize;
967
	unsigned long invalid = 0;
L
Linus Torvalds 已提交
968

969

970 971
	if (nfs_have_delegated_attributes(inode))
		return 0;
972
	/* Has the inode gone and changed behind our back? */
973 974 975
	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))
976 977
		return -EIO;

978
	if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
979
			inode->i_version != fattr->change_attr)
980
		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
L
Linus Torvalds 已提交
981 982

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

986 987 988 989 990 991
	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 已提交
992 993

	/* Have any file permissions changed? */
994 995 996 997 998
	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)
999
		invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
L
Linus Torvalds 已提交
1000 1001

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

1005
	if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
1006 1007 1008 1009
		invalid |= NFS_INO_INVALID_ATIME;

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

1011
	nfsi->read_cache_jiffies = fattr->time_start;
L
Linus Torvalds 已提交
1012 1013 1014
	return 0;
}

1015
static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1016
{
1017 1018
	if (!(fattr->valid & NFS_ATTR_FATTR_CTIME))
		return 0;
1019 1020 1021 1022 1023
	return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0;
}

static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
{
1024 1025
	if (!(fattr->valid & NFS_ATTR_FATTR_SIZE))
		return 0;
1026 1027
	return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
}
1028

1029
static atomic_long_t nfs_attr_generation_counter;
1030 1031 1032

static unsigned long nfs_read_attr_generation_counter(void)
{
1033
	return atomic_long_read(&nfs_attr_generation_counter);
1034 1035 1036 1037
}

unsigned long nfs_inc_attr_generation_counter(void)
{
1038
	return atomic_long_inc_return(&nfs_attr_generation_counter);
1039 1040 1041 1042 1043 1044 1045
}

void nfs_fattr_init(struct nfs_fattr *fattr)
{
	fattr->valid = 0;
	fattr->time_start = jiffies;
	fattr->gencount = nfs_inc_attr_generation_counter();
1046 1047
	fattr->owner_name = NULL;
	fattr->group_name = NULL;
1048
}
B
Bryan Schumaker 已提交
1049
EXPORT_SYMBOL_GPL(nfs_fattr_init);
1050

1051 1052 1053 1054 1055 1056 1057 1058 1059
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 已提交
1060
EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070

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 已提交
1071
EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
1072

1073
#ifdef NFS_DEBUG
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
/*
 * _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);
}

/*
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
 * _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;

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

1106 1107
	printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
	       caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
	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

1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
/**
 * 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.
1147
 * Note also the check for wraparound of 'attr_gencount'
1148 1149 1150 1151 1152 1153 1154 1155 1156
 *
 * 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);

1157
	return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
T
Trond Myklebust 已提交
1158 1159
		nfs_ctime_need_update(inode, fattr) ||
		nfs_size_need_update(inode, fattr) ||
1160
		((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
1161 1162 1163 1164 1165
}

static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
{
	if (nfs_inode_attrs_need_update(inode, fattr))
1166 1167 1168 1169
		return nfs_update_inode(inode, fattr);
	return nfs_check_inode_attributes(inode, fattr);
}

1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
/**
 * 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);
1187
	status = nfs_refresh_inode_locked(inode, fattr);
1188
	spin_unlock(&inode->i_lock);
D
David Howells 已提交
1189

1190 1191
	return status;
}
B
Bryan Schumaker 已提交
1192
EXPORT_SYMBOL_GPL(nfs_refresh_inode);
1193

1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
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);
}

1206 1207 1208 1209 1210 1211 1212
/**
 * 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.
1213 1214 1215 1216 1217 1218
 *
 * 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().
1219 1220 1221
 */
int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
{
1222
	int status;
1223

1224
	spin_lock(&inode->i_lock);
1225
	status = nfs_post_op_update_inode_locked(inode, fattr);
1226
	spin_unlock(&inode->i_lock);
1227
	return status;
1228
}
B
Bryan Schumaker 已提交
1229
EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
1230

1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
/**
 * 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)
{
1244 1245 1246 1247 1248 1249
	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)) {
1250 1251 1252 1253
		fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
				| NFS_ATTR_FATTR_PRESIZE
				| NFS_ATTR_FATTR_PREMTIME
				| NFS_ATTR_FATTR_PRECTIME);
1254 1255
		goto out_noforce;
	}
1256 1257
	if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
1258
		fattr->pre_change_attr = inode->i_version;
1259
		fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
1260
	}
1261 1262
	if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
1263
		memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
1264 1265 1266 1267
		fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
	}
	if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
1268
		memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
1269 1270 1271 1272
		fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
	}
	if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
			(fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
1273
		fattr->pre_size = i_size_read(inode);
1274
		fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
1275
	}
1276 1277 1278 1279
out_noforce:
	status = nfs_post_op_update_inode_locked(inode, fattr);
	spin_unlock(&inode->i_lock);
	return status;
1280
}
B
Bryan Schumaker 已提交
1281
EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
1282

L
Linus Torvalds 已提交
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
/*
 * 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.
 */
1295
static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
L
Linus Torvalds 已提交
1296
{
1297
	struct nfs_server *server;
L
Linus Torvalds 已提交
1298
	struct nfs_inode *nfsi = NFS_I(inode);
1299
	loff_t cur_isize, new_isize;
1300
	unsigned long invalid = 0;
1301
	unsigned long now = jiffies;
1302
	unsigned long save_cache_validity;
L
Linus Torvalds 已提交
1303

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

1309 1310 1311 1312 1313 1314 1315 1316
	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 已提交
1317 1318 1319 1320

	/*
	 * Make sure the inode's type hasn't changed.
	 */
1321 1322 1323 1324 1325 1326 1327 1328
	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 已提交
1329

1330
	server = NFS_SERVER(inode);
T
Trond Myklebust 已提交
1331
	/* Update the fsid? */
1332
	if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
1333
			!nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
1334
			!IS_AUTOMOUNT(inode))
1335 1336
		server->fsid = fattr->fsid;

L
Linus Torvalds 已提交
1337 1338 1339
	/*
	 * Update the read time so we don't revalidate too often.
	 */
1340
	nfsi->read_cache_jiffies = fattr->time_start;
1341

1342 1343 1344 1345 1346
	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 已提交
1347

1348
	/* Do atomic weak cache consistency updates */
1349
	invalid |= nfs_wcc_update_inode(inode, fattr);
1350

1351
	/* More cache consistency checks */
1352
	if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
1353
		if (inode->i_version != fattr->change_attr) {
1354 1355
			dprintk("NFS: change_attr change on server for file %s/%ld\n",
					inode->i_sb->s_id, inode->i_ino);
1356 1357 1358 1359 1360
			invalid |= NFS_INO_INVALID_ATTR
				| NFS_INO_INVALID_DATA
				| NFS_INO_INVALID_ACCESS
				| NFS_INO_INVALID_ACL
				| NFS_INO_REVAL_PAGECACHE;
1361 1362
			if (S_ISDIR(inode->i_mode))
				nfs_force_lookup_revalidate(inode);
1363
			inode->i_version = fattr->change_attr;
1364
		}
1365 1366
	} else if (server->caps & NFS_CAP_CHANGE_ATTR)
		invalid |= save_cache_validity;
1367 1368

	if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
1369
		memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1370 1371 1372 1373
	} else if (server->caps & NFS_CAP_MTIME)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_FORCED);

1374
	if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
1375
		memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1376 1377 1378
	} else if (server->caps & NFS_CAP_CTIME)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_FORCED);
1379

1380
	/* Check if our cached file size is stale */
1381 1382 1383 1384 1385 1386
	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? */
1387 1388
			if ((nfsi->npages == 0 && !test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) ||
			     new_isize > cur_isize) {
1389 1390 1391
				i_size_write(inode, new_isize);
				invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
			}
1392 1393 1394 1395 1396 1397
			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 已提交
1398
		}
1399 1400 1401 1402
	} else
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_PAGECACHE
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1403 1404


1405 1406
	if (fattr->valid & NFS_ATTR_FATTR_ATIME)
		memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
1407 1408 1409
	else if (server->caps & NFS_CAP_ATIME)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1410

1411 1412
	if (fattr->valid & NFS_ATTR_FATTR_MODE) {
		if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
1413 1414 1415
			umode_t newmode = inode->i_mode & S_IFMT;
			newmode |= fattr->mode & S_IALLUGO;
			inode->i_mode = newmode;
1416 1417
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
		}
1418 1419 1420 1421 1422 1423
	} 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);

1424 1425 1426 1427 1428
	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;
		}
1429 1430 1431 1432 1433 1434
	} 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);

1435 1436 1437 1438 1439
	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;
		}
1440 1441 1442 1443 1444
	} 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);
1445

1446 1447 1448 1449 1450
	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 已提交
1451
			set_nlink(inode, fattr->nlink);
1452
		}
1453 1454 1455
	} else if (server->caps & NFS_CAP_NLINK)
		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
				| NFS_INO_REVAL_FORCED);
L
Linus Torvalds 已提交
1456

1457
	if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
L
Linus Torvalds 已提交
1458 1459 1460 1461 1462
		/*
		 * report the blocks in 512byte units
		 */
		inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
 	}
1463 1464
	if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
		inode->i_blocks = fattr->du.nfs2.blocks;
L
Linus Torvalds 已提交
1465 1466 1467

	/* Update attrtimeo value if we're out of the unstable period */
	if (invalid & NFS_INO_INVALID_ATTR) {
C
Chuck Lever 已提交
1468
		nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
L
Linus Torvalds 已提交
1469
		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
1470
		nfsi->attrtimeo_timestamp = now;
1471
		nfsi->attr_gencount = nfs_inc_attr_generation_counter();
1472
	} else {
1473
		if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
1474 1475 1476 1477
			if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
				nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
			nfsi->attrtimeo_timestamp = now;
		}
L
Linus Torvalds 已提交
1478
	}
1479
	invalid &= ~NFS_INO_INVALID_ATTR;
L
Linus Torvalds 已提交
1480 1481 1482 1483
	/* 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;
1484
	if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ) ||
1485
			(save_cache_validity & NFS_INO_REVAL_FORCED))
1486
		nfsi->cache_validity |= invalid;
L
Linus Torvalds 已提交
1487 1488

	return 0;
1489
 out_err:
L
Linus Torvalds 已提交
1490 1491 1492 1493 1494 1495 1496 1497 1498
	/*
	 * 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 已提交
1499
struct inode *nfs_alloc_inode(struct super_block *sb)
L
Linus Torvalds 已提交
1500 1501
{
	struct nfs_inode *nfsi;
1502
	nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
1503 1504
	if (!nfsi)
		return NULL;
1505 1506
	nfsi->flags = 0UL;
	nfsi->cache_validity = 0UL;
1507 1508 1509 1510
#ifdef CONFIG_NFS_V3_ACL
	nfsi->acl_access = ERR_PTR(-EAGAIN);
	nfsi->acl_default = ERR_PTR(-EAGAIN);
#endif
B
Bryan Schumaker 已提交
1511
#if IS_ENABLED(CONFIG_NFS_V4)
1512 1513
	nfsi->nfs4_acl = NULL;
#endif /* CONFIG_NFS_V4 */
L
Linus Torvalds 已提交
1514 1515
	return &nfsi->vfs_inode;
}
B
Bryan Schumaker 已提交
1516
EXPORT_SYMBOL_GPL(nfs_alloc_inode);
L
Linus Torvalds 已提交
1517

N
Nick Piggin 已提交
1518
static void nfs_i_callback(struct rcu_head *head)
L
Linus Torvalds 已提交
1519
{
N
Nick Piggin 已提交
1520
	struct inode *inode = container_of(head, struct inode, i_rcu);
L
Linus Torvalds 已提交
1521 1522 1523
	kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
}

N
Nick Piggin 已提交
1524 1525 1526 1527
void nfs_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, nfs_i_callback);
}
B
Bryan Schumaker 已提交
1528
EXPORT_SYMBOL_GPL(nfs_destroy_inode);
N
Nick Piggin 已提交
1529

A
Andrew Morton 已提交
1530 1531
static inline void nfs4_init_once(struct nfs_inode *nfsi)
{
B
Bryan Schumaker 已提交
1532
#if IS_ENABLED(CONFIG_NFS_V4)
A
Andrew Morton 已提交
1533 1534 1535 1536
	INIT_LIST_HEAD(&nfsi->open_states);
	nfsi->delegation = NULL;
	nfsi->delegation_state = 0;
	init_rwsem(&nfsi->rwsem);
1537
	nfsi->layout = NULL;
A
Andrew Morton 已提交
1538 1539
#endif
}
D
David Howells 已提交
1540

1541
static void init_once(void *foo)
L
Linus Torvalds 已提交
1542 1543 1544
{
	struct nfs_inode *nfsi = (struct nfs_inode *) foo;

C
Christoph Lameter 已提交
1545 1546 1547 1548
	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 已提交
1549
	INIT_LIST_HEAD(&nfsi->commit_info.list);
C
Christoph Lameter 已提交
1550
	nfsi->npages = 0;
F
Fred Isaman 已提交
1551
	nfsi->commit_info.ncommit = 0;
1552
	atomic_set(&nfsi->commit_info.rpcs_out, 0);
T
Trond Myklebust 已提交
1553 1554 1555
	atomic_set(&nfsi->silly_count, 1);
	INIT_HLIST_HEAD(&nfsi->silly_list);
	init_waitqueue_head(&nfsi->waitqueue);
C
Christoph Lameter 已提交
1556
	nfs4_init_once(nfsi);
L
Linus Torvalds 已提交
1557
}
1558

D
David Howells 已提交
1559
static int __init nfs_init_inodecache(void)
L
Linus Torvalds 已提交
1560 1561 1562
{
	nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
					     sizeof(struct nfs_inode),
1563 1564
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
1565
					     init_once);
L
Linus Torvalds 已提交
1566 1567 1568 1569 1570 1571
	if (nfs_inode_cachep == NULL)
		return -ENOMEM;

	return 0;
}

1572
static void nfs_destroy_inodecache(void)
L
Linus Torvalds 已提交
1573
{
1574 1575 1576 1577 1578
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
1579
	kmem_cache_destroy(nfs_inode_cachep);
L
Linus Torvalds 已提交
1580 1581
}

T
Trond Myklebust 已提交
1582
struct workqueue_struct *nfsiod_workqueue;
B
Bryan Schumaker 已提交
1583
EXPORT_SYMBOL_GPL(nfsiod_workqueue);
T
Trond Myklebust 已提交
1584 1585 1586 1587 1588 1589 1590 1591

/*
 * start up the nfsiod workqueue
 */
static int nfsiod_start(void)
{
	struct workqueue_struct *wq;
	dprintk("RPC:       creating workqueue nfsiod\n");
1592
	wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
T
Trond Myklebust 已提交
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612
	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);
}

1613
int nfs_net_id;
1614
EXPORT_SYMBOL_GPL(nfs_net_id);
1615 1616 1617

static int nfs_net_init(struct net *net)
{
1618
	nfs_clients_init(net);
1619 1620 1621 1622 1623 1624
	return nfs_dns_resolver_cache_init(net);
}

static void nfs_net_exit(struct net *net)
{
	nfs_dns_resolver_cache_destroy(net);
1625
	nfs_cleanup_cb_ident_idr(net);
1626 1627 1628 1629 1630 1631 1632 1633 1634
}

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 已提交
1635 1636 1637 1638 1639 1640 1641
/*
 * Initialize NFS
 */
static int __init init_nfs_fs(void)
{
	int err;

1642
	err = nfs_dns_resolver_init();
1643
	if (err < 0)
B
Bryan Schumaker 已提交
1644
		goto out10;;
1645 1646

	err = register_pernet_subsys(&nfs_net_ops);
1647
	if (err < 0)
B
Bryan Schumaker 已提交
1648
		goto out9;
1649

1650 1651
	err = nfs_fscache_register();
	if (err < 0)
B
Bryan Schumaker 已提交
1652
		goto out8;
1653

T
Trond Myklebust 已提交
1654 1655
	err = nfsiod_start();
	if (err)
B
Bryan Schumaker 已提交
1656
		goto out7;
T
Trond Myklebust 已提交
1657

1658 1659
	err = nfs_fs_proc_init();
	if (err)
B
Bryan Schumaker 已提交
1660
		goto out6;
1661

L
Linus Torvalds 已提交
1662 1663
	err = nfs_init_nfspagecache();
	if (err)
B
Bryan Schumaker 已提交
1664
		goto out5;
L
Linus Torvalds 已提交
1665 1666 1667

	err = nfs_init_inodecache();
	if (err)
B
Bryan Schumaker 已提交
1668
		goto out4;
L
Linus Torvalds 已提交
1669 1670 1671

	err = nfs_init_readpagecache();
	if (err)
B
Bryan Schumaker 已提交
1672
		goto out3;
L
Linus Torvalds 已提交
1673 1674 1675

	err = nfs_init_writepagecache();
	if (err)
B
Bryan Schumaker 已提交
1676
		goto out2;
L
Linus Torvalds 已提交
1677 1678 1679

	err = nfs_init_directcache();
	if (err)
B
Bryan Schumaker 已提交
1680
		goto out1;
L
Linus Torvalds 已提交
1681 1682

#ifdef CONFIG_PROC_FS
1683
	rpc_proc_register(&init_net, &nfs_rpcstat);
L
Linus Torvalds 已提交
1684
#endif
D
David Howells 已提交
1685
	if ((err = register_nfs_fs()) != 0)
1686 1687
		goto out0;

L
Linus Torvalds 已提交
1688
	return 0;
1689
out0:
L
Linus Torvalds 已提交
1690
#ifdef CONFIG_PROC_FS
1691
	rpc_proc_unregister(&init_net, "nfs");
L
Linus Torvalds 已提交
1692 1693
#endif
	nfs_destroy_directcache();
B
Bryan Schumaker 已提交
1694
out1:
1695
	nfs_destroy_writepagecache();
B
Bryan Schumaker 已提交
1696
out2:
1697
	nfs_destroy_readpagecache();
B
Bryan Schumaker 已提交
1698
out3:
1699
	nfs_destroy_inodecache();
B
Bryan Schumaker 已提交
1700
out4:
1701
	nfs_destroy_nfspagecache();
B
Bryan Schumaker 已提交
1702
out5:
1703
	nfs_fs_proc_exit();
B
Bryan Schumaker 已提交
1704
out6:
1705
	nfsiod_stop();
B
Bryan Schumaker 已提交
1706
out7:
1707
	nfs_fscache_unregister();
B
Bryan Schumaker 已提交
1708
out8:
1709
	unregister_pernet_subsys(&nfs_net_ops);
B
Bryan Schumaker 已提交
1710
out9:
1711
	nfs_dns_resolver_destroy();
B
Bryan Schumaker 已提交
1712
out10:
L
Linus Torvalds 已提交
1713 1714 1715 1716 1717 1718 1719 1720 1721 1722
	return err;
}

static void __exit exit_nfs_fs(void)
{
	nfs_destroy_directcache();
	nfs_destroy_writepagecache();
	nfs_destroy_readpagecache();
	nfs_destroy_inodecache();
	nfs_destroy_nfspagecache();
1723
	nfs_fscache_unregister();
1724
	unregister_pernet_subsys(&nfs_net_ops);
1725
	nfs_dns_resolver_destroy();
L
Linus Torvalds 已提交
1726
#ifdef CONFIG_PROC_FS
1727
	rpc_proc_unregister(&init_net, "nfs");
L
Linus Torvalds 已提交
1728
#endif
D
David Howells 已提交
1729
	unregister_nfs_fs();
1730
	nfs_fs_proc_exit();
T
Trond Myklebust 已提交
1731
	nfsiod_stop();
L
Linus Torvalds 已提交
1732 1733 1734 1735 1736
}

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

module_init(init_nfs_fs)
module_exit(exit_nfs_fs)