inode.c 32.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
/*
 *  linux/fs/nfs/inode.c
 *
 *  Copyright (C) 1992  Rick Sladkey
 *
 *  nfs inode and superblock handling functions
 *
 *  Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
 *  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>

#include <linux/time.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/stat.h>
#include <linux/errno.h>
#include <linux/unistd.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/stats.h>
28
#include <linux/sunrpc/metrics.h>
L
Linus Torvalds 已提交
29 30 31 32 33 34 35 36 37
#include <linux/nfs_fs.h>
#include <linux/nfs_mount.h>
#include <linux/nfs4_mount.h>
#include <linux/lockd/bind.h>
#include <linux/smp_lock.h>
#include <linux/seq_file.h>
#include <linux/mount.h>
#include <linux/nfs_idmap.h>
#include <linux/vfs.h>
38 39
#include <linux/inet.h>
#include <linux/nfs_xdr.h>
L
Linus Torvalds 已提交
40 41 42 43

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

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

#define NFSDBG_FACILITY		NFSDBG_VFS
#define NFS_PARANOIA 1

static void nfs_invalidate_inode(struct inode *);
54
static int nfs_update_inode(struct inode *, struct nfs_fattr *);
L
Linus Torvalds 已提交
55

56
static void nfs_zap_acl_cache(struct inode *);
L
Linus Torvalds 已提交
57

D
David Howells 已提交
58
static kmem_cache_t * nfs_inode_cachep;
59

L
Linus Torvalds 已提交
60 61 62 63 64 65
static inline unsigned long
nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
{
	return nfs_fileid_to_ino_t(fattr->fileid);
}

D
David Howells 已提交
66
int nfs_write_inode(struct inode *inode, int sync)
L
Linus Torvalds 已提交
67
{
68
	int flags = sync ? FLUSH_SYNC : 0;
L
Linus Torvalds 已提交
69 70
	int ret;

71
	ret = nfs_commit_inode(inode, flags);
L
Linus Torvalds 已提交
72 73 74 75 76
	if (ret < 0)
		return ret;
	return 0;
}

D
David Howells 已提交
77
void nfs_clear_inode(struct inode *inode)
L
Linus Torvalds 已提交
78
{
T
Trond Myklebust 已提交
79 80 81 82
	/*
	 * The following should never happen...
	 */
	BUG_ON(nfs_have_writebacks(inode));
83 84
	BUG_ON(!list_empty(&NFS_I(inode)->open_files));
	BUG_ON(atomic_read(&NFS_I(inode)->data_updates) != 0);
85
	nfs_zap_acl_cache(inode);
86
	nfs_access_zap_cache(inode);
L
Linus Torvalds 已提交
87 88
}

T
Trond Myklebust 已提交
89 90 91 92 93 94 95 96 97 98
/**
 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
 */
int nfs_sync_mapping(struct address_space *mapping)
{
	int ret;

	if (mapping->nrpages == 0)
		return 0;
	unmap_mapping_range(mapping, 0, 0, 0);
99
	ret = filemap_write_and_wait(mapping);
T
Trond Myklebust 已提交
100 101 102 103 104 105 106
	if (ret != 0)
		goto out;
	ret = nfs_wb_all(mapping->host);
out:
	return ret;
}

L
Linus Torvalds 已提交
107 108 109
/*
 * Invalidate the local caches
 */
110
static void nfs_zap_caches_locked(struct inode *inode)
L
Linus Torvalds 已提交
111 112 113 114
{
	struct nfs_inode *nfsi = NFS_I(inode);
	int mode = inode->i_mode;

C
Chuck Lever 已提交
115 116
	nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);

L
Linus Torvalds 已提交
117 118 119 120 121
	NFS_ATTRTIMEO(inode) = NFS_MINATTRTIMEO(inode);
	NFS_ATTRTIMEO_UPDATE(inode) = jiffies;

	memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode)));
	if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
122
		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 已提交
123
	else
124
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
125
}
126

127 128 129 130
void nfs_zap_caches(struct inode *inode)
{
	spin_lock(&inode->i_lock);
	nfs_zap_caches_locked(inode);
131
	spin_unlock(&inode->i_lock);
132 133 134 135 136 137 138 139 140
}

static void nfs_zap_acl_cache(struct inode *inode)
{
	void (*clear_acl_cache)(struct inode *);

	clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
	if (clear_acl_cache != NULL)
		clear_acl_cache(inode);
141
	spin_lock(&inode->i_lock);
142
	NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
143
	spin_unlock(&inode->i_lock);
L
Linus Torvalds 已提交
144 145 146
}

/*
147 148
 * Invalidate, but do not unhash, the inode.
 * NB: must be called with inode->i_lock held!
L
Linus Torvalds 已提交
149
 */
150
static void nfs_invalidate_inode(struct inode *inode)
L
Linus Torvalds 已提交
151
{
152 153
	set_bit(NFS_INO_STALE, &NFS_FLAGS(inode));
	nfs_zap_caches_locked(inode);
L
Linus Torvalds 已提交
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
}

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;

	NFS_FILEID(inode) = fattr->fileid;
	nfs_copy_fh(NFS_FH(inode), desc->fh);
	return 0;
}

/* Don't use READDIRPLUS on directories that we believe are too large */
#define NFS_LIMIT_READDIRPLUS (8*PAGE_SIZE)

/*
 * 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
	};
208
	struct inode *inode = ERR_PTR(-ENOENT);
L
Linus Torvalds 已提交
209 210 211 212 213 214 215 216 217 218 219 220
	unsigned long hash;

	if ((fattr->valid & NFS_ATTR_FATTR) == 0)
		goto out_no_inode;

	if (!fattr->nlink) {
		printk("NFS: Buggy server - nlink == 0!\n");
		goto out_no_inode;
	}

	hash = nfs_fattr_to_ino_t(fattr);

221 222 223
	inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
	if (inode == NULL) {
		inode = ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
224
		goto out_no_inode;
225
	}
L
Linus Torvalds 已提交
226 227 228 229 230 231 232 233 234 235 236 237 238 239

	if (inode->i_state & I_NEW) {
		struct nfs_inode *nfsi = NFS_I(inode);

		/* 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;
		/* Why so? Because we want revalidate for devices/FIFOs, and
		 * that's precisely what we have in nfs_file_inode_operations.
		 */
240
		inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
L
Linus Torvalds 已提交
241 242 243 244 245
		if (S_ISREG(inode->i_mode)) {
			inode->i_fop = &nfs_file_operations;
			inode->i_data.a_ops = &nfs_file_aops;
			inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info;
		} else if (S_ISDIR(inode->i_mode)) {
246
			inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
L
Linus Torvalds 已提交
247 248 249
			inode->i_fop = &nfs_dir_operations;
			if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS)
			    && fattr->size <= NFS_LIMIT_READDIRPLUS)
250
				set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode));
251 252
			/* Deal with crossing mountpoints */
			if (!nfs_fsid_equal(&NFS_SB(sb)->fsid, &fattr->fsid)) {
M
Manoj Naik 已提交
253 254 255 256
				if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
					inode->i_op = &nfs_referral_inode_operations;
				else
					inode->i_op = &nfs_mountpoint_inode_operations;
257 258
				inode->i_fop = NULL;
			}
L
Linus Torvalds 已提交
259 260 261 262 263
		} else if (S_ISLNK(inode->i_mode))
			inode->i_op = &nfs_symlink_inode_operations;
		else
			init_special_inode(inode, inode->i_mode, fattr->rdev);

264 265
		nfsi->read_cache_jiffies = fattr->time_start;
		nfsi->last_updated = jiffies;
L
Linus Torvalds 已提交
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
		inode->i_atime = fattr->atime;
		inode->i_mtime = fattr->mtime;
		inode->i_ctime = fattr->ctime;
		if (fattr->valid & NFS_ATTR_FATTR_V4)
			nfsi->change_attr = fattr->change_attr;
		inode->i_size = nfs_size_to_loff_t(fattr->size);
		inode->i_nlink = fattr->nlink;
		inode->i_uid = fattr->uid;
		inode->i_gid = fattr->gid;
		if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
			/*
			 * report the blocks in 512byte units
			 */
			inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
			inode->i_blksize = inode->i_sb->s_blocksize;
		} else {
			inode->i_blocks = fattr->du.nfs2.blocks;
			inode->i_blksize = fattr->du.nfs2.blocksize;
		}
		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
		nfsi->attrtimeo_timestamp = jiffies;
		memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
288
		nfsi->access_cache = RB_ROOT;
L
Linus Torvalds 已提交
289 290 291 292 293 294 295 296 297 298 299 300 301

		unlock_new_inode(inode);
	} else
		nfs_refresh_inode(inode, fattr);
	dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
		inode->i_sb->s_id,
		(long long)NFS_FILEID(inode),
		atomic_read(&inode->i_count));

out:
	return inode;

out_no_inode:
302
	dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
L
Linus Torvalds 已提交
303 304 305 306 307 308 309 310 311 312 313 314
	goto out;
}

#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET)

int
nfs_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
	struct nfs_fattr fattr;
	int error;

C
Chuck Lever 已提交
315 316
	nfs_inc_stats(inode, NFSIOS_VFSSETATTR);

L
Linus Torvalds 已提交
317 318 319 320 321 322 323 324 325 326 327 328
	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;
	if (attr->ia_valid == 0)
		return 0;

	lock_kernel();
	nfs_begin_data_update(inode);
329 330 331
	/* Write all dirty data */
	filemap_write_and_wait(inode->i_mapping);
	nfs_wb_all(inode);
332 333 334 335 336
	/*
	 * Return any delegations if we're going to change ACLs
	 */
	if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
		nfs_inode_return_delegation(inode);
L
Linus Torvalds 已提交
337
	error = NFS_PROTO(inode)->setattr(dentry, &fattr, attr);
338
	if (error == 0)
L
Linus Torvalds 已提交
339
		nfs_refresh_inode(inode, &fattr);
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
	nfs_end_data_update(inode);
	unlock_kernel();
	return error;
}

/**
 * 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) {
L
Linus Torvalds 已提交
356
		if ((attr->ia_valid & ATTR_MODE) != 0) {
357 358
			int mode = attr->ia_mode & S_IALLUGO;
			mode |= inode->i_mode & ~S_IALLUGO;
L
Linus Torvalds 已提交
359 360 361 362 363 364
			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;
365
		spin_lock(&inode->i_lock);
366
		NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
367
		spin_unlock(&inode->i_lock);
368 369
	}
	if ((attr->ia_valid & ATTR_SIZE) != 0) {
C
Chuck Lever 已提交
370
		nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
371 372 373
		inode->i_size = attr->ia_size;
		vmtruncate(inode, attr->ia_size);
	}
L
Linus Torvalds 已提交
374 375
}

376 377 378 379 380 381 382 383
static int nfs_wait_schedule(void *word)
{
	if (signal_pending(current))
		return -ERESTARTSYS;
	schedule();
	return 0;
}

L
Linus Torvalds 已提交
384 385 386
/*
 * Wait for the inode to get unlocked.
 */
387
static int nfs_wait_on_inode(struct inode *inode)
L
Linus Torvalds 已提交
388 389 390
{
	struct rpc_clnt	*clnt = NFS_CLIENT(inode);
	struct nfs_inode *nfsi = NFS_I(inode);
391
	sigset_t oldmask;
L
Linus Torvalds 已提交
392
	int error;
393 394 395 396 397 398

	rpc_clnt_sigmask(clnt, &oldmask);
	error = wait_on_bit_lock(&nfsi->flags, NFS_INO_REVALIDATING,
					nfs_wait_schedule, TASK_INTERRUPTIBLE);
	rpc_clnt_sigunmask(clnt, &oldmask);

L
Linus Torvalds 已提交
399 400 401
	return error;
}

402 403 404 405 406 407 408 409 410
static void nfs_wake_up_inode(struct inode *inode)
{
	struct nfs_inode *nfsi = NFS_I(inode);

	clear_bit(NFS_INO_REVALIDATING, &nfsi->flags);
	smp_mb__after_clear_bit();
	wake_up_bit(&nfsi->flags, NFS_INO_REVALIDATING);
}

L
Linus Torvalds 已提交
411 412 413
int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
	struct inode *inode = dentry->d_inode;
414
	int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
L
Linus Torvalds 已提交
415 416
	int err;

417
	/* Flush out writes to the server in order to update c/mtime */
418
	nfs_sync_inode_wait(inode, 0, 0, FLUSH_NOCOMMIT);
419 420 421 422 423 424 425 426 427 428 429 430

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

L
Linus Torvalds 已提交
433 434 435 436 437 438 439 440 441
	if (need_atime)
		err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
	else
		err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
	if (!err)
		generic_fillattr(inode, stat);
	return err;
}

442
static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, struct dentry *dentry, struct rpc_cred *cred)
L
Linus Torvalds 已提交
443 444 445 446 447 448 449
{
	struct nfs_open_context *ctx;

	ctx = (struct nfs_open_context *)kmalloc(sizeof(*ctx), GFP_KERNEL);
	if (ctx != NULL) {
		atomic_set(&ctx->count, 1);
		ctx->dentry = dget(dentry);
450
		ctx->vfsmnt = mntget(mnt);
L
Linus Torvalds 已提交
451 452 453 454
		ctx->cred = get_rpccred(cred);
		ctx->state = NULL;
		ctx->lockowner = current->files;
		ctx->error = 0;
455
		ctx->dir_cookie = 0;
L
Linus Torvalds 已提交
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
	}
	return ctx;
}

struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
{
	if (ctx != NULL)
		atomic_inc(&ctx->count);
	return ctx;
}

void put_nfs_open_context(struct nfs_open_context *ctx)
{
	if (atomic_dec_and_test(&ctx->count)) {
		if (!list_empty(&ctx->list)) {
			struct inode *inode = ctx->dentry->d_inode;
			spin_lock(&inode->i_lock);
			list_del(&ctx->list);
			spin_unlock(&inode->i_lock);
		}
		if (ctx->state != NULL)
			nfs4_close_state(ctx->state, ctx->mode);
		if (ctx->cred != NULL)
			put_rpccred(ctx->cred);
		dput(ctx->dentry);
481
		mntput(ctx->vfsmnt);
L
Linus Torvalds 已提交
482 483 484 485 486 487 488 489
		kfree(ctx);
	}
}

/*
 * Ensure that mmap has a recent RPC credential for use when writing out
 * shared pages
 */
490
static void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
L
Linus Torvalds 已提交
491 492 493 494 495 496 497 498 499 500
{
	struct inode *inode = filp->f_dentry->d_inode;
	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);
}

501 502 503 504
/*
 * Given an inode, search for an open context with the desired characteristics
 */
struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode)
L
Linus Torvalds 已提交
505 506 507 508 509 510
{
	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) {
511 512
		if (cred != NULL && pos->cred != cred)
			continue;
L
Linus Torvalds 已提交
513 514 515 516 517 518 519 520 521
		if ((pos->mode & mode) == mode) {
			ctx = get_nfs_open_context(pos);
			break;
		}
	}
	spin_unlock(&inode->i_lock);
	return ctx;
}

522
static void nfs_file_clear_open_context(struct file *filp)
L
Linus Torvalds 已提交
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
{
	struct inode *inode = filp->f_dentry->d_inode;
	struct nfs_open_context *ctx = (struct nfs_open_context *)filp->private_data;

	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);
		put_nfs_open_context(ctx);
	}
}

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

	cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0);
	if (IS_ERR(cred))
		return PTR_ERR(cred);
547
	ctx = alloc_nfs_open_context(filp->f_vfsmnt, filp->f_dentry, cred);
L
Linus Torvalds 已提交
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576
	put_rpccred(cred);
	if (ctx == NULL)
		return -ENOMEM;
	ctx->mode = filp->f_mode;
	nfs_file_set_open_context(filp, ctx);
	put_nfs_open_context(ctx);
	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;
	struct nfs_fattr fattr;
	struct nfs_inode *nfsi = NFS_I(inode);

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

577
	nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
L
Linus Torvalds 已提交
578 579 580 581 582 583
	lock_kernel();
	if (!inode || is_bad_inode(inode))
 		goto out_nowait;
	if (NFS_STALE(inode))
 		goto out_nowait;

584 585 586 587 588 589 590
	status = nfs_wait_on_inode(inode);
	if (status < 0)
		goto out;
	if (NFS_STALE(inode)) {
		status = -ESTALE;
		/* Do we trust the cached ESTALE? */
		if (NFS_ATTRTIMEO(inode) != 0) {
591
			if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME)) {
592 593 594 595
				/* no */
			} else
				goto out;
		}
L
Linus Torvalds 已提交
596 597 598 599 600 601 602 603 604 605
	}

	status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), &fattr);
	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))
606
				set_bit(NFS_INO_STALE, &NFS_FLAGS(inode));
L
Linus Torvalds 已提交
607 608 609 610
		}
		goto out;
	}

611
	spin_lock(&inode->i_lock);
612
	status = nfs_update_inode(inode, &fattr);
L
Linus Torvalds 已提交
613
	if (status) {
614
		spin_unlock(&inode->i_lock);
L
Linus Torvalds 已提交
615 616 617 618 619
		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;
	}
620
	spin_unlock(&inode->i_lock);
621

622
	if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
623
		nfs_zap_acl_cache(inode);
624

L
Linus Torvalds 已提交
625 626 627 628
	dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
		inode->i_sb->s_id,
		(long long)NFS_FILEID(inode));

629 630 631
 out:
	nfs_wake_up_inode(inode);

L
Linus Torvalds 已提交
632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
 out_nowait:
	unlock_kernel();
	return status;
}

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

	if (nfs_have_delegation(inode, FMODE_READ))
		return 0;
	return time_after(jiffies, nfsi->read_cache_jiffies+nfsi->attrtimeo);
}

/**
 * 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)
{
655
	if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
L
Linus Torvalds 已提交
656 657 658 659 660
			&& !nfs_attribute_timeout(inode))
		return NFS_STALE(inode) ? -ESTALE : 0;
	return __nfs_revalidate_inode(server, inode);
}

661 662 663 664 665
/**
 * nfs_revalidate_mapping - Revalidate the pagecache
 * @inode - pointer to host inode
 * @mapping - pointer to mapping
 */
666
int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
667 668
{
	struct nfs_inode *nfsi = NFS_I(inode);
669 670 671 672 673 674 675
	int ret = 0;

	if (NFS_STALE(inode))
		ret = -ESTALE;
	if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
			|| nfs_attribute_timeout(inode))
		ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
676

677
	if (nfsi->cache_validity & NFS_INO_INVALID_DATA) {
C
Chuck Lever 已提交
678
		nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
T
Trond Myklebust 已提交
679 680
		if (S_ISREG(inode->i_mode))
			nfs_sync_mapping(mapping);
681
		invalidate_inode_pages2(mapping);
682 683

		spin_lock(&inode->i_lock);
684
		nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
685 686 687
		if (S_ISDIR(inode->i_mode)) {
			memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
			/* This ensures we revalidate child dentries */
688
			nfsi->cache_change_attribute = jiffies;
689
		}
690 691
		spin_unlock(&inode->i_lock);

692 693 694 695
		dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
				inode->i_sb->s_id,
				(long long)NFS_FILEID(inode));
	}
696
	return ret;
697 698
}

L
Linus Torvalds 已提交
699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
/**
 * nfs_begin_data_update
 * @inode - pointer to inode
 * Declare that a set of operations will update file data on the server
 */
void nfs_begin_data_update(struct inode *inode)
{
	atomic_inc(&NFS_I(inode)->data_updates);
}

/**
 * nfs_end_data_update
 * @inode - pointer to inode
 * Declare end of the operations that will update file data
 * This will mark the inode as immediately needing revalidation
 * of its attribute cache.
 */
void nfs_end_data_update(struct inode *inode)
{
	struct nfs_inode *nfsi = NFS_I(inode);

720 721 722 723 724
	/* Directories: invalidate page cache */
	if (S_ISDIR(inode->i_mode)) {
		spin_lock(&inode->i_lock);
		nfsi->cache_validity |= NFS_INO_INVALID_DATA;
		spin_unlock(&inode->i_lock);
L
Linus Torvalds 已提交
725
	}
726
	nfsi->cache_change_attribute = jiffies;
L
Linus Torvalds 已提交
727 728 729
	atomic_dec(&nfsi->data_updates);
}

730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750
static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
{
	struct nfs_inode *nfsi = NFS_I(inode);

	/* If we have atomic WCC data, we may update some attributes */
	if ((fattr->valid & NFS_ATTR_WCC) != 0) {
		if (timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
			memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
			nfsi->cache_change_attribute = jiffies;
		}
		if (timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
			memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
			nfsi->cache_change_attribute = jiffies;
		}
		if (inode->i_size == fattr->pre_size && nfsi->npages == 0) {
			inode->i_size = fattr->size;
			nfsi->cache_change_attribute = jiffies;
		}
	}
}

L
Linus Torvalds 已提交
751
/**
752
 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
L
Linus Torvalds 已提交
753 754 755 756 757 758 759
 * @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.
 */
760
static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
L
Linus Torvalds 已提交
761 762 763 764 765
{
	struct nfs_inode *nfsi = NFS_I(inode);
	loff_t cur_size, new_isize;
	int data_unstable;

766

767 768 769 770 771 772
	/* Has the inode gone and changed behind our back? */
	if (nfsi->fileid != fattr->fileid
			|| (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
		return -EIO;
	}

L
Linus Torvalds 已提交
773 774 775
	/* Are we in the process of updating data on the server? */
	data_unstable = nfs_caches_unstable(inode);

776 777
	/* Do atomic weak cache consistency updates */
	nfs_wcc_update_inode(inode, fattr);
L
Linus Torvalds 已提交
778

779
	if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
780 781
			nfsi->change_attr != fattr->change_attr)
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
L
Linus Torvalds 已提交
782 783

	/* Verify a few of the more important attributes */
784 785
	if (!timespec_equal(&inode->i_mtime, &fattr->mtime))
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
786 787 788

	cur_size = i_size_read(inode);
 	new_isize = nfs_size_to_loff_t(fattr->size);
789 790
	if (cur_size != new_isize && nfsi->npages == 0)
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
L
Linus Torvalds 已提交
791 792 793 794 795

	/* Have any file permissions changed? */
	if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)
			|| inode->i_uid != fattr->uid
			|| inode->i_gid != fattr->gid)
796
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
L
Linus Torvalds 已提交
797 798 799

	/* Has the link count changed? */
	if (inode->i_nlink != fattr->nlink)
800
		nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
L
Linus Torvalds 已提交
801 802

	if (!timespec_equal(&inode->i_atime, &fattr->atime))
803
		nfsi->cache_validity |= NFS_INO_INVALID_ATIME;
L
Linus Torvalds 已提交
804

805
	nfsi->read_cache_jiffies = fattr->time_start;
L
Linus Torvalds 已提交
806 807 808
	return 0;
}

809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
/**
 * 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)
{
	struct nfs_inode *nfsi = NFS_I(inode);
	int status;

	if ((fattr->valid & NFS_ATTR_FATTR) == 0)
		return 0;
	spin_lock(&inode->i_lock);
	if (time_after(fattr->time_start, nfsi->last_updated))
828
		status = nfs_update_inode(inode, fattr);
829 830 831 832 833 834 835
	else
		status = nfs_check_inode_attributes(inode, fattr);

	spin_unlock(&inode->i_lock);
	return status;
}

836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
/**
 * 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.
 */
int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
{
	struct nfs_inode *nfsi = NFS_I(inode);
	int status = 0;

	spin_lock(&inode->i_lock);
	if (unlikely((fattr->valid & NFS_ATTR_FATTR) == 0)) {
851
		nfsi->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
852 853
		goto out;
	}
854
	status = nfs_update_inode(inode, fattr);
855 856 857 858 859
out:
	spin_unlock(&inode->i_lock);
	return status;
}

L
Linus Torvalds 已提交
860 861 862 863 864 865 866 867 868 869 870 871
/*
 * 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.
 */
872
static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
L
Linus Torvalds 已提交
873
{
874
	struct nfs_server *server;
L
Linus Torvalds 已提交
875
	struct nfs_inode *nfsi = NFS_I(inode);
876
	loff_t cur_isize, new_isize;
L
Linus Torvalds 已提交
877
	unsigned int	invalid = 0;
878
	int data_stable;
L
Linus Torvalds 已提交
879 880 881 882 883

	dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
			__FUNCTION__, inode->i_sb->s_id, inode->i_ino,
			atomic_read(&inode->i_count), fattr->valid);

884 885
	if (nfsi->fileid != fattr->fileid)
		goto out_fileid;
L
Linus Torvalds 已提交
886 887 888 889

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

893 894 895 896 897 898
	server = NFS_SERVER(inode);
	/* Update the fsid if and only if this is the root directory */
	if (inode == inode->i_sb->s_root->d_inode
			&& !nfs_fsid_equal(&server->fsid, &fattr->fsid))
		server->fsid = fattr->fsid;

L
Linus Torvalds 已提交
899 900 901
	/*
	 * Update the read time so we don't revalidate too often.
	 */
902 903
	nfsi->read_cache_jiffies = fattr->time_start;
	nfsi->last_updated = jiffies;
L
Linus Torvalds 已提交
904 905

	/* Are we racing with known updates of the metadata on the server? */
906 907
	data_stable = nfs_verify_change_attribute(inode, fattr->time_start);
	if (data_stable)
908
		nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_ATIME);
L
Linus Torvalds 已提交
909

910 911 912
	/* Do atomic weak cache consistency updates */
	nfs_wcc_update_inode(inode, fattr);

913
	/* Check if our cached file size is stale */
L
Linus Torvalds 已提交
914 915
 	new_isize = nfs_size_to_loff_t(fattr->size);
	cur_isize = i_size_read(inode);
916 917 918 919
	if (new_isize != cur_isize) {
		/* Do we perhaps have any outstanding writes? */
		if (nfsi->npages == 0) {
			/* No, but did we race with nfs_end_data_update()? */
920
			if (data_stable) {
L
Linus Torvalds 已提交
921
				inode->i_size = new_isize;
922
				invalid |= NFS_INO_INVALID_DATA;
L
Linus Torvalds 已提交
923
			}
924 925
			invalid |= NFS_INO_INVALID_ATTR;
		} else if (new_isize > cur_isize) {
L
Linus Torvalds 已提交
926 927 928
			inode->i_size = new_isize;
			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
		}
929
		nfsi->cache_change_attribute = jiffies;
930 931
		dprintk("NFS: isize change on server for file %s/%ld\n",
				inode->i_sb->s_id, inode->i_ino);
L
Linus Torvalds 已提交
932 933
	}

934
	/* Check if the mtime agrees */
L
Linus Torvalds 已提交
935 936
	if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
		memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
937 938
		dprintk("NFS: mtime change on server for file %s/%ld\n",
				inode->i_sb->s_id, inode->i_ino);
939 940
		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
		nfsi->cache_change_attribute = jiffies;
L
Linus Torvalds 已提交
941 942
	}

943 944
	/* If ctime has changed we should definitely clear access+acl caches */
	if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) {
945
		invalid |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
946
		memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
947
		nfsi->cache_change_attribute = jiffies;
948
	}
L
Linus Torvalds 已提交
949 950 951 952 953
	memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));

	if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO) ||
	    inode->i_uid != fattr->uid ||
	    inode->i_gid != fattr->gid)
954
		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
L
Linus Torvalds 已提交
955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971

	inode->i_mode = fattr->mode;
	inode->i_nlink = fattr->nlink;
	inode->i_uid = fattr->uid;
	inode->i_gid = fattr->gid;

	if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
		/*
		 * report the blocks in 512byte units
		 */
		inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
		inode->i_blksize = inode->i_sb->s_blocksize;
 	} else {
 		inode->i_blocks = fattr->du.nfs2.blocks;
 		inode->i_blksize = fattr->du.nfs2.blocksize;
 	}

972 973 974 975 976 977 978
	if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
			nfsi->change_attr != fattr->change_attr) {
		dprintk("NFS: change_attr change on server for file %s/%ld\n",
				inode->i_sb->s_id, inode->i_ino);
		nfsi->change_attr = fattr->change_attr;
		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
		nfsi->cache_change_attribute = jiffies;
979 980
	}

L
Linus Torvalds 已提交
981 982
	/* Update attrtimeo value if we're out of the unstable period */
	if (invalid & NFS_INO_INVALID_ATTR) {
C
Chuck Lever 已提交
983
		nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
L
Linus Torvalds 已提交
984 985 986 987 988 989 990 991 992 993 994
		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
		nfsi->attrtimeo_timestamp = jiffies;
	} else if (time_after(jiffies, nfsi->attrtimeo_timestamp+nfsi->attrtimeo)) {
		if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
			nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
		nfsi->attrtimeo_timestamp = jiffies;
	}
	/* 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;
995 996
	if (data_stable)
		invalid &= ~(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME|NFS_INO_REVAL_PAGECACHE);
L
Linus Torvalds 已提交
997
	if (!nfs_have_delegation(inode, FMODE_READ))
998
		nfsi->cache_validity |= invalid;
L
Linus Torvalds 已提交
999 1000 1001 1002 1003 1004 1005 1006 1007 1008

	return 0;
 out_changed:
	/*
	 * Big trouble! The inode has become a different object.
	 */
#ifdef NFS_PARANOIA
	printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
			__FUNCTION__, inode->i_ino, inode->i_mode, fattr->mode);
#endif
1009
 out_err:
L
Linus Torvalds 已提交
1010 1011 1012 1013 1014 1015 1016
	/*
	 * 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;
1017 1018 1019 1020

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

1026

L
Linus Torvalds 已提交
1027 1028 1029 1030 1031 1032 1033
#ifdef CONFIG_NFS_V4

/*
 * Clean out any remaining NFSv4 state that might be left over due
 * to open() calls that passed nfs_atomic_lookup, but failed to call
 * nfs_open().
 */
D
David Howells 已提交
1034
void nfs4_clear_inode(struct inode *inode)
L
Linus Torvalds 已提交
1035 1036 1037 1038
{
	struct nfs_inode *nfsi = NFS_I(inode);

	/* If we are holding a delegation, return it! */
1039
	nfs_inode_return_delegation(inode);
L
Linus Torvalds 已提交
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
	/* First call standard NFS clear_inode() code */
	nfs_clear_inode(inode);
	/* Now clear out any remaining state */
	while (!list_empty(&nfsi->open_states)) {
		struct nfs4_state *state;
		
		state = list_entry(nfsi->open_states.next,
				struct nfs4_state,
				inode_states);
		dprintk("%s(%s/%Ld): found unclaimed NFSv4 state %p\n",
				__FUNCTION__,
				inode->i_sb->s_id,
				(long long)NFS_FILEID(inode),
				state);
		BUG_ON(atomic_read(&state->count) != 1);
		nfs4_close_state(state, state->state);
	}
}
#endif

D
David Howells 已提交
1060
struct inode *nfs_alloc_inode(struct super_block *sb)
L
Linus Torvalds 已提交
1061 1062 1063 1064 1065
{
	struct nfs_inode *nfsi;
	nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, SLAB_KERNEL);
	if (!nfsi)
		return NULL;
1066 1067
	nfsi->flags = 0UL;
	nfsi->cache_validity = 0UL;
1068
	nfsi->cache_change_attribute = jiffies;
1069 1070 1071 1072
#ifdef CONFIG_NFS_V3_ACL
	nfsi->acl_access = ERR_PTR(-EAGAIN);
	nfsi->acl_default = ERR_PTR(-EAGAIN);
#endif
1073 1074 1075
#ifdef CONFIG_NFS_V4
	nfsi->nfs4_acl = NULL;
#endif /* CONFIG_NFS_V4 */
L
Linus Torvalds 已提交
1076 1077 1078
	return &nfsi->vfs_inode;
}

D
David Howells 已提交
1079
void nfs_destroy_inode(struct inode *inode)
L
Linus Torvalds 已提交
1080 1081 1082 1083
{
	kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
}

A
Andrew Morton 已提交
1084 1085 1086 1087 1088 1089 1090 1091 1092
static inline void nfs4_init_once(struct nfs_inode *nfsi)
{
#ifdef CONFIG_NFS_V4
	INIT_LIST_HEAD(&nfsi->open_states);
	nfsi->delegation = NULL;
	nfsi->delegation_state = 0;
	init_rwsem(&nfsi->rwsem);
#endif
}
D
David Howells 已提交
1093

L
Linus Torvalds 已提交
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
{
	struct nfs_inode *nfsi = (struct nfs_inode *) foo;

	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
	    SLAB_CTOR_CONSTRUCTOR) {
		inode_init_once(&nfsi->vfs_inode);
		spin_lock_init(&nfsi->req_lock);
		INIT_LIST_HEAD(&nfsi->dirty);
		INIT_LIST_HEAD(&nfsi->commit);
		INIT_LIST_HEAD(&nfsi->open_files);
1105 1106
		INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
		INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
L
Linus Torvalds 已提交
1107 1108 1109 1110 1111 1112 1113 1114 1115
		INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
		atomic_set(&nfsi->data_updates, 0);
		nfsi->ndirty = 0;
		nfsi->ncommit = 0;
		nfsi->npages = 0;
		nfs4_init_once(nfsi);
	}
}
 
D
David Howells 已提交
1116
static int __init nfs_init_inodecache(void)
L
Linus Torvalds 已提交
1117 1118 1119
{
	nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
					     sizeof(struct nfs_inode),
1120 1121
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
L
Linus Torvalds 已提交
1122 1123 1124 1125 1126 1127 1128
					     init_once, NULL);
	if (nfs_inode_cachep == NULL)
		return -ENOMEM;

	return 0;
}

1129
static void nfs_destroy_inodecache(void)
L
Linus Torvalds 已提交
1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
{
	if (kmem_cache_destroy(nfs_inode_cachep))
		printk(KERN_INFO "nfs_inode_cache: not all structures were freed\n");
}

/*
 * Initialize NFS
 */
static int __init init_nfs_fs(void)
{
	int err;

1142 1143 1144 1145
	err = nfs_fs_proc_init();
	if (err)
		goto out5;

L
Linus Torvalds 已提交
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
	err = nfs_init_nfspagecache();
	if (err)
		goto out4;

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

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

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

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

#ifdef CONFIG_PROC_FS
	rpc_proc_register(&nfs_rpcstat);
#endif
D
David Howells 已提交
1169
	if ((err = register_nfs_fs()) != 0)
L
Linus Torvalds 已提交
1170 1171 1172 1173 1174 1175 1176
		goto out;
	return 0;
out:
#ifdef CONFIG_PROC_FS
	rpc_proc_unregister("nfs");
#endif
	nfs_destroy_directcache();
1177 1178
out0:
	nfs_destroy_writepagecache();
L
Linus Torvalds 已提交
1179 1180 1181 1182 1183 1184 1185
out1:
	nfs_destroy_readpagecache();
out2:
	nfs_destroy_inodecache();
out3:
	nfs_destroy_nfspagecache();
out4:
1186 1187
	nfs_fs_proc_exit();
out5:
L
Linus Torvalds 已提交
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
	return err;
}

static void __exit exit_nfs_fs(void)
{
	nfs_destroy_directcache();
	nfs_destroy_writepagecache();
	nfs_destroy_readpagecache();
	nfs_destroy_inodecache();
	nfs_destroy_nfspagecache();
#ifdef CONFIG_PROC_FS
	rpc_proc_unregister("nfs");
#endif
D
David Howells 已提交
1201
	unregister_nfs_fs();
1202
	nfs_fs_proc_exit();
L
Linus Torvalds 已提交
1203 1204 1205 1206 1207 1208 1209 1210
}

/* Not quite true; I just maintain it */
MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
MODULE_LICENSE("GPL");

module_init(init_nfs_fs)
module_exit(exit_nfs_fs)