xref: /openbmc/linux/fs/nfs/inode.c (revision 643d1f7f)
1 /*
2  *  linux/fs/nfs/inode.c
3  *
4  *  Copyright (C) 1992  Rick Sladkey
5  *
6  *  nfs inode and superblock handling functions
7  *
8  *  Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
9  *  experimental NFS changes. Modularisation taken straight from SYS5 fs.
10  *
11  *  Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
12  *  J.S.Peatfield@damtp.cam.ac.uk
13  *
14  */
15 
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/sched.h>
19 #include <linux/time.h>
20 #include <linux/kernel.h>
21 #include <linux/mm.h>
22 #include <linux/string.h>
23 #include <linux/stat.h>
24 #include <linux/errno.h>
25 #include <linux/unistd.h>
26 #include <linux/sunrpc/clnt.h>
27 #include <linux/sunrpc/stats.h>
28 #include <linux/sunrpc/metrics.h>
29 #include <linux/nfs_fs.h>
30 #include <linux/nfs_mount.h>
31 #include <linux/nfs4_mount.h>
32 #include <linux/lockd/bind.h>
33 #include <linux/smp_lock.h>
34 #include <linux/seq_file.h>
35 #include <linux/mount.h>
36 #include <linux/nfs_idmap.h>
37 #include <linux/vfs.h>
38 #include <linux/inet.h>
39 #include <linux/nfs_xdr.h>
40 
41 #include <asm/system.h>
42 #include <asm/uaccess.h>
43 
44 #include "nfs4_fs.h"
45 #include "callback.h"
46 #include "delegation.h"
47 #include "iostat.h"
48 #include "internal.h"
49 
50 #define NFSDBG_FACILITY		NFSDBG_VFS
51 
52 #define NFS_64_BIT_INODE_NUMBERS_ENABLED	1
53 
54 /* Default is to see 64-bit inode numbers */
55 static int enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
56 
57 static void nfs_invalidate_inode(struct inode *);
58 static int nfs_update_inode(struct inode *, struct nfs_fattr *);
59 
60 static void nfs_zap_acl_cache(struct inode *);
61 
62 static struct kmem_cache * nfs_inode_cachep;
63 
64 static inline unsigned long
65 nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
66 {
67 	return nfs_fileid_to_ino_t(fattr->fileid);
68 }
69 
70 /**
71  * nfs_compat_user_ino64 - returns the user-visible inode number
72  * @fileid: 64-bit fileid
73  *
74  * This function returns a 32-bit inode number if the boot parameter
75  * nfs.enable_ino64 is zero.
76  */
77 u64 nfs_compat_user_ino64(u64 fileid)
78 {
79 	int ino;
80 
81 	if (enable_ino64)
82 		return fileid;
83 	ino = fileid;
84 	if (sizeof(ino) < sizeof(fileid))
85 		ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
86 	return ino;
87 }
88 
89 int nfs_write_inode(struct inode *inode, int sync)
90 {
91 	int ret;
92 
93 	if (sync) {
94 		ret = filemap_fdatawait(inode->i_mapping);
95 		if (ret == 0)
96 			ret = nfs_commit_inode(inode, FLUSH_SYNC);
97 	} else
98 		ret = nfs_commit_inode(inode, 0);
99 	if (ret >= 0)
100 		return 0;
101 	__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
102 	return ret;
103 }
104 
105 void nfs_clear_inode(struct inode *inode)
106 {
107 	/*
108 	 * The following should never happen...
109 	 */
110 	BUG_ON(nfs_have_writebacks(inode));
111 	BUG_ON(!list_empty(&NFS_I(inode)->open_files));
112 	nfs_zap_acl_cache(inode);
113 	nfs_access_zap_cache(inode);
114 }
115 
116 /**
117  * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
118  */
119 int nfs_sync_mapping(struct address_space *mapping)
120 {
121 	int ret;
122 
123 	if (mapping->nrpages == 0)
124 		return 0;
125 	unmap_mapping_range(mapping, 0, 0, 0);
126 	ret = filemap_write_and_wait(mapping);
127 	if (ret != 0)
128 		goto out;
129 	ret = nfs_wb_all(mapping->host);
130 out:
131 	return ret;
132 }
133 
134 /*
135  * Invalidate the local caches
136  */
137 static void nfs_zap_caches_locked(struct inode *inode)
138 {
139 	struct nfs_inode *nfsi = NFS_I(inode);
140 	int mode = inode->i_mode;
141 
142 	nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
143 
144 	nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
145 	nfsi->attrtimeo_timestamp = jiffies;
146 
147 	memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode)));
148 	if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
149 		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
150 	else
151 		nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
152 }
153 
154 void nfs_zap_caches(struct inode *inode)
155 {
156 	spin_lock(&inode->i_lock);
157 	nfs_zap_caches_locked(inode);
158 	spin_unlock(&inode->i_lock);
159 }
160 
161 void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
162 {
163 	if (mapping->nrpages != 0) {
164 		spin_lock(&inode->i_lock);
165 		NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
166 		spin_unlock(&inode->i_lock);
167 	}
168 }
169 
170 static void nfs_zap_acl_cache(struct inode *inode)
171 {
172 	void (*clear_acl_cache)(struct inode *);
173 
174 	clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
175 	if (clear_acl_cache != NULL)
176 		clear_acl_cache(inode);
177 	spin_lock(&inode->i_lock);
178 	NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
179 	spin_unlock(&inode->i_lock);
180 }
181 
182 void nfs_invalidate_atime(struct inode *inode)
183 {
184 	spin_lock(&inode->i_lock);
185 	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
186 	spin_unlock(&inode->i_lock);
187 }
188 
189 /*
190  * Invalidate, but do not unhash, the inode.
191  * NB: must be called with inode->i_lock held!
192  */
193 static void nfs_invalidate_inode(struct inode *inode)
194 {
195 	set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
196 	nfs_zap_caches_locked(inode);
197 }
198 
199 struct nfs_find_desc {
200 	struct nfs_fh		*fh;
201 	struct nfs_fattr	*fattr;
202 };
203 
204 /*
205  * In NFSv3 we can have 64bit inode numbers. In order to support
206  * this, and re-exported directories (also seen in NFSv2)
207  * we are forced to allow 2 different inodes to have the same
208  * i_ino.
209  */
210 static int
211 nfs_find_actor(struct inode *inode, void *opaque)
212 {
213 	struct nfs_find_desc	*desc = (struct nfs_find_desc *)opaque;
214 	struct nfs_fh		*fh = desc->fh;
215 	struct nfs_fattr	*fattr = desc->fattr;
216 
217 	if (NFS_FILEID(inode) != fattr->fileid)
218 		return 0;
219 	if (nfs_compare_fh(NFS_FH(inode), fh))
220 		return 0;
221 	if (is_bad_inode(inode) || NFS_STALE(inode))
222 		return 0;
223 	return 1;
224 }
225 
226 static int
227 nfs_init_locked(struct inode *inode, void *opaque)
228 {
229 	struct nfs_find_desc	*desc = (struct nfs_find_desc *)opaque;
230 	struct nfs_fattr	*fattr = desc->fattr;
231 
232 	set_nfs_fileid(inode, fattr->fileid);
233 	nfs_copy_fh(NFS_FH(inode), desc->fh);
234 	return 0;
235 }
236 
237 /* Don't use READDIRPLUS on directories that we believe are too large */
238 #define NFS_LIMIT_READDIRPLUS (8*PAGE_SIZE)
239 
240 /*
241  * This is our front-end to iget that looks up inodes by file handle
242  * instead of inode number.
243  */
244 struct inode *
245 nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
246 {
247 	struct nfs_find_desc desc = {
248 		.fh	= fh,
249 		.fattr	= fattr
250 	};
251 	struct inode *inode = ERR_PTR(-ENOENT);
252 	unsigned long hash;
253 
254 	if ((fattr->valid & NFS_ATTR_FATTR) == 0)
255 		goto out_no_inode;
256 
257 	if (!fattr->nlink) {
258 		printk("NFS: Buggy server - nlink == 0!\n");
259 		goto out_no_inode;
260 	}
261 
262 	hash = nfs_fattr_to_ino_t(fattr);
263 
264 	inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
265 	if (inode == NULL) {
266 		inode = ERR_PTR(-ENOMEM);
267 		goto out_no_inode;
268 	}
269 
270 	if (inode->i_state & I_NEW) {
271 		struct nfs_inode *nfsi = NFS_I(inode);
272 		unsigned long now = jiffies;
273 
274 		/* We set i_ino for the few things that still rely on it,
275 		 * such as stat(2) */
276 		inode->i_ino = hash;
277 
278 		/* We can't support update_atime(), since the server will reset it */
279 		inode->i_flags |= S_NOATIME|S_NOCMTIME;
280 		inode->i_mode = fattr->mode;
281 		/* Why so? Because we want revalidate for devices/FIFOs, and
282 		 * that's precisely what we have in nfs_file_inode_operations.
283 		 */
284 		inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
285 		if (S_ISREG(inode->i_mode)) {
286 			inode->i_fop = &nfs_file_operations;
287 			inode->i_data.a_ops = &nfs_file_aops;
288 			inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info;
289 		} else if (S_ISDIR(inode->i_mode)) {
290 			inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
291 			inode->i_fop = &nfs_dir_operations;
292 			if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS)
293 			    && fattr->size <= NFS_LIMIT_READDIRPLUS)
294 				set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
295 			/* Deal with crossing mountpoints */
296 			if (!nfs_fsid_equal(&NFS_SB(sb)->fsid, &fattr->fsid)) {
297 				if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
298 					inode->i_op = &nfs_referral_inode_operations;
299 				else
300 					inode->i_op = &nfs_mountpoint_inode_operations;
301 				inode->i_fop = NULL;
302 			}
303 		} else if (S_ISLNK(inode->i_mode))
304 			inode->i_op = &nfs_symlink_inode_operations;
305 		else
306 			init_special_inode(inode, inode->i_mode, fattr->rdev);
307 
308 		nfsi->read_cache_jiffies = fattr->time_start;
309 		nfsi->last_updated = now;
310 		nfsi->cache_change_attribute = now;
311 		inode->i_atime = fattr->atime;
312 		inode->i_mtime = fattr->mtime;
313 		inode->i_ctime = fattr->ctime;
314 		if (fattr->valid & NFS_ATTR_FATTR_V4)
315 			nfsi->change_attr = fattr->change_attr;
316 		inode->i_size = nfs_size_to_loff_t(fattr->size);
317 		inode->i_nlink = fattr->nlink;
318 		inode->i_uid = fattr->uid;
319 		inode->i_gid = fattr->gid;
320 		if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
321 			/*
322 			 * report the blocks in 512byte units
323 			 */
324 			inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
325 		} else {
326 			inode->i_blocks = fattr->du.nfs2.blocks;
327 		}
328 		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
329 		nfsi->attrtimeo_timestamp = now;
330 		memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
331 		nfsi->access_cache = RB_ROOT;
332 
333 		unlock_new_inode(inode);
334 	} else
335 		nfs_refresh_inode(inode, fattr);
336 	dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
337 		inode->i_sb->s_id,
338 		(long long)NFS_FILEID(inode),
339 		atomic_read(&inode->i_count));
340 
341 out:
342 	return inode;
343 
344 out_no_inode:
345 	dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
346 	goto out;
347 }
348 
349 #define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET)
350 
351 int
352 nfs_setattr(struct dentry *dentry, struct iattr *attr)
353 {
354 	struct inode *inode = dentry->d_inode;
355 	struct nfs_fattr fattr;
356 	int error;
357 
358 	nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
359 
360 	/* skip mode change if it's just for clearing setuid/setgid */
361 	if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
362 		attr->ia_valid &= ~ATTR_MODE;
363 
364 	if (attr->ia_valid & ATTR_SIZE) {
365 		if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode))
366 			attr->ia_valid &= ~ATTR_SIZE;
367 	}
368 
369 	/* Optimization: if the end result is no change, don't RPC */
370 	attr->ia_valid &= NFS_VALID_ATTRS;
371 	if (attr->ia_valid == 0)
372 		return 0;
373 
374 	lock_kernel();
375 	/* Write all dirty data */
376 	if (S_ISREG(inode->i_mode)) {
377 		filemap_write_and_wait(inode->i_mapping);
378 		nfs_wb_all(inode);
379 	}
380 	/*
381 	 * Return any delegations if we're going to change ACLs
382 	 */
383 	if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
384 		nfs_inode_return_delegation(inode);
385 	error = NFS_PROTO(inode)->setattr(dentry, &fattr, attr);
386 	if (error == 0)
387 		nfs_refresh_inode(inode, &fattr);
388 	unlock_kernel();
389 	return error;
390 }
391 
392 /**
393  * nfs_setattr_update_inode - Update inode metadata after a setattr call.
394  * @inode: pointer to struct inode
395  * @attr: pointer to struct iattr
396  *
397  * Note: we do this in the *proc.c in order to ensure that
398  *       it works for things like exclusive creates too.
399  */
400 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
401 {
402 	if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
403 		if ((attr->ia_valid & ATTR_MODE) != 0) {
404 			int mode = attr->ia_mode & S_IALLUGO;
405 			mode |= inode->i_mode & ~S_IALLUGO;
406 			inode->i_mode = mode;
407 		}
408 		if ((attr->ia_valid & ATTR_UID) != 0)
409 			inode->i_uid = attr->ia_uid;
410 		if ((attr->ia_valid & ATTR_GID) != 0)
411 			inode->i_gid = attr->ia_gid;
412 		spin_lock(&inode->i_lock);
413 		NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
414 		spin_unlock(&inode->i_lock);
415 	}
416 	if ((attr->ia_valid & ATTR_SIZE) != 0) {
417 		nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
418 		inode->i_size = attr->ia_size;
419 		vmtruncate(inode, attr->ia_size);
420 	}
421 }
422 
423 static int nfs_wait_schedule(void *word)
424 {
425 	if (signal_pending(current))
426 		return -ERESTARTSYS;
427 	schedule();
428 	return 0;
429 }
430 
431 /*
432  * Wait for the inode to get unlocked.
433  */
434 static int nfs_wait_on_inode(struct inode *inode)
435 {
436 	struct nfs_inode *nfsi = NFS_I(inode);
437 	int error;
438 
439 	error = wait_on_bit_lock(&nfsi->flags, NFS_INO_REVALIDATING,
440 					nfs_wait_schedule, TASK_KILLABLE);
441 
442 	return error;
443 }
444 
445 static void nfs_wake_up_inode(struct inode *inode)
446 {
447 	struct nfs_inode *nfsi = NFS_I(inode);
448 
449 	clear_bit(NFS_INO_REVALIDATING, &nfsi->flags);
450 	smp_mb__after_clear_bit();
451 	wake_up_bit(&nfsi->flags, NFS_INO_REVALIDATING);
452 }
453 
454 int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
455 {
456 	struct inode *inode = dentry->d_inode;
457 	int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
458 	int err;
459 
460 	/*
461 	 * Flush out writes to the server in order to update c/mtime.
462 	 *
463 	 * Hold the i_mutex to suspend application writes temporarily;
464 	 * this prevents long-running writing applications from blocking
465 	 * nfs_wb_nocommit.
466 	 */
467 	if (S_ISREG(inode->i_mode)) {
468 		mutex_lock(&inode->i_mutex);
469 		nfs_wb_nocommit(inode);
470 		mutex_unlock(&inode->i_mutex);
471 	}
472 
473 	/*
474 	 * We may force a getattr if the user cares about atime.
475 	 *
476 	 * Note that we only have to check the vfsmount flags here:
477 	 *  - NFS always sets S_NOATIME by so checking it would give a
478 	 *    bogus result
479 	 *  - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
480 	 *    no point in checking those.
481 	 */
482  	if ((mnt->mnt_flags & MNT_NOATIME) ||
483  	    ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
484 		need_atime = 0;
485 
486 	if (need_atime)
487 		err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
488 	else
489 		err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
490 	if (!err) {
491 		generic_fillattr(inode, stat);
492 		stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
493 	}
494 	return err;
495 }
496 
497 static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, struct dentry *dentry, struct rpc_cred *cred)
498 {
499 	struct nfs_open_context *ctx;
500 
501 	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
502 	if (ctx != NULL) {
503 		ctx->path.dentry = dget(dentry);
504 		ctx->path.mnt = mntget(mnt);
505 		ctx->cred = get_rpccred(cred);
506 		ctx->state = NULL;
507 		ctx->lockowner = current->files;
508 		ctx->error = 0;
509 		ctx->dir_cookie = 0;
510 		atomic_set(&ctx->count, 1);
511 	}
512 	return ctx;
513 }
514 
515 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
516 {
517 	if (ctx != NULL)
518 		atomic_inc(&ctx->count);
519 	return ctx;
520 }
521 
522 static void __put_nfs_open_context(struct nfs_open_context *ctx, int wait)
523 {
524 	struct inode *inode = ctx->path.dentry->d_inode;
525 
526 	if (!atomic_dec_and_lock(&ctx->count, &inode->i_lock))
527 		return;
528 	list_del(&ctx->list);
529 	spin_unlock(&inode->i_lock);
530 	if (ctx->state != NULL) {
531 		if (wait)
532 			nfs4_close_sync(&ctx->path, ctx->state, ctx->mode);
533 		else
534 			nfs4_close_state(&ctx->path, ctx->state, ctx->mode);
535 	}
536 	if (ctx->cred != NULL)
537 		put_rpccred(ctx->cred);
538 	dput(ctx->path.dentry);
539 	mntput(ctx->path.mnt);
540 	kfree(ctx);
541 }
542 
543 void put_nfs_open_context(struct nfs_open_context *ctx)
544 {
545 	__put_nfs_open_context(ctx, 0);
546 }
547 
548 static void put_nfs_open_context_sync(struct nfs_open_context *ctx)
549 {
550 	__put_nfs_open_context(ctx, 1);
551 }
552 
553 /*
554  * Ensure that mmap has a recent RPC credential for use when writing out
555  * shared pages
556  */
557 static void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
558 {
559 	struct inode *inode = filp->f_path.dentry->d_inode;
560 	struct nfs_inode *nfsi = NFS_I(inode);
561 
562 	filp->private_data = get_nfs_open_context(ctx);
563 	spin_lock(&inode->i_lock);
564 	list_add(&ctx->list, &nfsi->open_files);
565 	spin_unlock(&inode->i_lock);
566 }
567 
568 /*
569  * Given an inode, search for an open context with the desired characteristics
570  */
571 struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode)
572 {
573 	struct nfs_inode *nfsi = NFS_I(inode);
574 	struct nfs_open_context *pos, *ctx = NULL;
575 
576 	spin_lock(&inode->i_lock);
577 	list_for_each_entry(pos, &nfsi->open_files, list) {
578 		if (cred != NULL && pos->cred != cred)
579 			continue;
580 		if ((pos->mode & mode) == mode) {
581 			ctx = get_nfs_open_context(pos);
582 			break;
583 		}
584 	}
585 	spin_unlock(&inode->i_lock);
586 	return ctx;
587 }
588 
589 static void nfs_file_clear_open_context(struct file *filp)
590 {
591 	struct inode *inode = filp->f_path.dentry->d_inode;
592 	struct nfs_open_context *ctx = nfs_file_open_context(filp);
593 
594 	if (ctx) {
595 		filp->private_data = NULL;
596 		spin_lock(&inode->i_lock);
597 		list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
598 		spin_unlock(&inode->i_lock);
599 		put_nfs_open_context_sync(ctx);
600 	}
601 }
602 
603 /*
604  * These allocate and release file read/write context information.
605  */
606 int nfs_open(struct inode *inode, struct file *filp)
607 {
608 	struct nfs_open_context *ctx;
609 	struct rpc_cred *cred;
610 
611 	cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0);
612 	if (IS_ERR(cred))
613 		return PTR_ERR(cred);
614 	ctx = alloc_nfs_open_context(filp->f_path.mnt, filp->f_path.dentry, cred);
615 	put_rpccred(cred);
616 	if (ctx == NULL)
617 		return -ENOMEM;
618 	ctx->mode = filp->f_mode;
619 	nfs_file_set_open_context(filp, ctx);
620 	put_nfs_open_context(ctx);
621 	return 0;
622 }
623 
624 int nfs_release(struct inode *inode, struct file *filp)
625 {
626 	nfs_file_clear_open_context(filp);
627 	return 0;
628 }
629 
630 /*
631  * This function is called whenever some part of NFS notices that
632  * the cached attributes have to be refreshed.
633  */
634 int
635 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
636 {
637 	int		 status = -ESTALE;
638 	struct nfs_fattr fattr;
639 	struct nfs_inode *nfsi = NFS_I(inode);
640 
641 	dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
642 		inode->i_sb->s_id, (long long)NFS_FILEID(inode));
643 
644 	nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
645 	lock_kernel();
646 	if (is_bad_inode(inode))
647  		goto out_nowait;
648 	if (NFS_STALE(inode))
649  		goto out_nowait;
650 
651 	status = nfs_wait_on_inode(inode);
652 	if (status < 0)
653 		goto out;
654 
655 	status = -ESTALE;
656 	if (NFS_STALE(inode))
657 		goto out;
658 
659 	status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), &fattr);
660 	if (status != 0) {
661 		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
662 			 inode->i_sb->s_id,
663 			 (long long)NFS_FILEID(inode), status);
664 		if (status == -ESTALE) {
665 			nfs_zap_caches(inode);
666 			if (!S_ISDIR(inode->i_mode))
667 				set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
668 		}
669 		goto out;
670 	}
671 
672 	spin_lock(&inode->i_lock);
673 	status = nfs_update_inode(inode, &fattr);
674 	if (status) {
675 		spin_unlock(&inode->i_lock);
676 		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
677 			 inode->i_sb->s_id,
678 			 (long long)NFS_FILEID(inode), status);
679 		goto out;
680 	}
681 	spin_unlock(&inode->i_lock);
682 
683 	if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
684 		nfs_zap_acl_cache(inode);
685 
686 	dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
687 		inode->i_sb->s_id,
688 		(long long)NFS_FILEID(inode));
689 
690  out:
691 	nfs_wake_up_inode(inode);
692 
693  out_nowait:
694 	unlock_kernel();
695 	return status;
696 }
697 
698 int nfs_attribute_timeout(struct inode *inode)
699 {
700 	struct nfs_inode *nfsi = NFS_I(inode);
701 
702 	if (nfs_have_delegation(inode, FMODE_READ))
703 		return 0;
704 	return !time_in_range(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
705 }
706 
707 /**
708  * nfs_revalidate_inode - Revalidate the inode attributes
709  * @server - pointer to nfs_server struct
710  * @inode - pointer to inode struct
711  *
712  * Updates inode attribute information by retrieving the data from the server.
713  */
714 int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
715 {
716 	if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
717 			&& !nfs_attribute_timeout(inode))
718 		return NFS_STALE(inode) ? -ESTALE : 0;
719 	return __nfs_revalidate_inode(server, inode);
720 }
721 
722 static int nfs_invalidate_mapping_nolock(struct inode *inode, struct address_space *mapping)
723 {
724 	struct nfs_inode *nfsi = NFS_I(inode);
725 
726 	if (mapping->nrpages != 0) {
727 		int ret = invalidate_inode_pages2(mapping);
728 		if (ret < 0)
729 			return ret;
730 	}
731 	spin_lock(&inode->i_lock);
732 	nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
733 	if (S_ISDIR(inode->i_mode))
734 		memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
735 	spin_unlock(&inode->i_lock);
736 	nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
737 	dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
738 			inode->i_sb->s_id, (long long)NFS_FILEID(inode));
739 	return 0;
740 }
741 
742 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
743 {
744 	int ret = 0;
745 
746 	mutex_lock(&inode->i_mutex);
747 	if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_DATA) {
748 		ret = nfs_sync_mapping(mapping);
749 		if (ret == 0)
750 			ret = nfs_invalidate_mapping_nolock(inode, mapping);
751 	}
752 	mutex_unlock(&inode->i_mutex);
753 	return ret;
754 }
755 
756 /**
757  * nfs_revalidate_mapping_nolock - Revalidate the pagecache
758  * @inode - pointer to host inode
759  * @mapping - pointer to mapping
760  */
761 int nfs_revalidate_mapping_nolock(struct inode *inode, struct address_space *mapping)
762 {
763 	struct nfs_inode *nfsi = NFS_I(inode);
764 	int ret = 0;
765 
766 	if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
767 			|| nfs_attribute_timeout(inode) || NFS_STALE(inode)) {
768 		ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
769 		if (ret < 0)
770 			goto out;
771 	}
772 	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
773 		ret = nfs_invalidate_mapping_nolock(inode, mapping);
774 out:
775 	return ret;
776 }
777 
778 /**
779  * nfs_revalidate_mapping - Revalidate the pagecache
780  * @inode - pointer to host inode
781  * @mapping - pointer to mapping
782  *
783  * This version of the function will take the inode->i_mutex and attempt to
784  * flush out all dirty data if it needs to invalidate the page cache.
785  */
786 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
787 {
788 	struct nfs_inode *nfsi = NFS_I(inode);
789 	int ret = 0;
790 
791 	if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
792 			|| nfs_attribute_timeout(inode) || NFS_STALE(inode)) {
793 		ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
794 		if (ret < 0)
795 			goto out;
796 	}
797 	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
798 		ret = nfs_invalidate_mapping(inode, mapping);
799 out:
800 	return ret;
801 }
802 
803 static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
804 {
805 	struct nfs_inode *nfsi = NFS_I(inode);
806 
807 	if ((fattr->valid & NFS_ATTR_WCC_V4) != 0 &&
808 			nfsi->change_attr == fattr->pre_change_attr) {
809 		nfsi->change_attr = fattr->change_attr;
810 		if (S_ISDIR(inode->i_mode))
811 			nfsi->cache_validity |= NFS_INO_INVALID_DATA;
812 	}
813 	/* If we have atomic WCC data, we may update some attributes */
814 	if ((fattr->valid & NFS_ATTR_WCC) != 0) {
815 		if (timespec_equal(&inode->i_ctime, &fattr->pre_ctime))
816 			memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
817 		if (timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
818 			memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
819 			if (S_ISDIR(inode->i_mode))
820 				nfsi->cache_validity |= NFS_INO_INVALID_DATA;
821 		}
822 		if (inode->i_size == nfs_size_to_loff_t(fattr->pre_size) &&
823 		    nfsi->npages == 0)
824 			inode->i_size = nfs_size_to_loff_t(fattr->size);
825 	}
826 }
827 
828 /**
829  * nfs_check_inode_attributes - verify consistency of the inode attribute cache
830  * @inode - pointer to inode
831  * @fattr - updated attributes
832  *
833  * Verifies the attribute cache. If we have just changed the attributes,
834  * so that fattr carries weak cache consistency data, then it may
835  * also update the ctime/mtime/change_attribute.
836  */
837 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
838 {
839 	struct nfs_inode *nfsi = NFS_I(inode);
840 	loff_t cur_size, new_isize;
841 	unsigned long invalid = 0;
842 
843 
844 	/* Has the inode gone and changed behind our back? */
845 	if (nfsi->fileid != fattr->fileid
846 			|| (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
847 		return -EIO;
848 	}
849 
850 	/* Do atomic weak cache consistency updates */
851 	nfs_wcc_update_inode(inode, fattr);
852 
853 	if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
854 			nfsi->change_attr != fattr->change_attr)
855 		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
856 
857 	/* Verify a few of the more important attributes */
858 	if (!timespec_equal(&inode->i_mtime, &fattr->mtime))
859 		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
860 
861 	cur_size = i_size_read(inode);
862  	new_isize = nfs_size_to_loff_t(fattr->size);
863 	if (cur_size != new_isize && nfsi->npages == 0)
864 		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
865 
866 	/* Have any file permissions changed? */
867 	if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)
868 			|| inode->i_uid != fattr->uid
869 			|| inode->i_gid != fattr->gid)
870 		invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
871 
872 	/* Has the link count changed? */
873 	if (inode->i_nlink != fattr->nlink)
874 		invalid |= NFS_INO_INVALID_ATTR;
875 
876 	if (!timespec_equal(&inode->i_atime, &fattr->atime))
877 		invalid |= NFS_INO_INVALID_ATIME;
878 
879 	if (invalid != 0)
880 		nfsi->cache_validity |= invalid;
881 	else
882 		nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
883 				| NFS_INO_INVALID_ATIME
884 				| NFS_INO_REVAL_PAGECACHE);
885 
886 	nfsi->read_cache_jiffies = fattr->time_start;
887 	return 0;
888 }
889 
890 /**
891  * nfs_refresh_inode - try to update the inode attribute cache
892  * @inode - pointer to inode
893  * @fattr - updated attributes
894  *
895  * Check that an RPC call that returned attributes has not overlapped with
896  * other recent updates of the inode metadata, then decide whether it is
897  * safe to do a full update of the inode attributes, or whether just to
898  * call nfs_check_inode_attributes.
899  */
900 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
901 {
902 	struct nfs_inode *nfsi = NFS_I(inode);
903 	int status;
904 
905 	if ((fattr->valid & NFS_ATTR_FATTR) == 0)
906 		return 0;
907 	spin_lock(&inode->i_lock);
908 	if (time_after(fattr->time_start, nfsi->last_updated))
909 		status = nfs_update_inode(inode, fattr);
910 	else
911 		status = nfs_check_inode_attributes(inode, fattr);
912 
913 	spin_unlock(&inode->i_lock);
914 	return status;
915 }
916 
917 /**
918  * nfs_post_op_update_inode - try to update the inode attribute cache
919  * @inode - pointer to inode
920  * @fattr - updated attributes
921  *
922  * After an operation that has changed the inode metadata, mark the
923  * attribute cache as being invalid, then try to update it.
924  *
925  * NB: if the server didn't return any post op attributes, this
926  * function will force the retrieval of attributes before the next
927  * NFS request.  Thus it should be used only for operations that
928  * are expected to change one or more attributes, to avoid
929  * unnecessary NFS requests and trips through nfs_update_inode().
930  */
931 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
932 {
933 	struct nfs_inode *nfsi = NFS_I(inode);
934 
935 	spin_lock(&inode->i_lock);
936 	nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
937 	if (S_ISDIR(inode->i_mode))
938 		nfsi->cache_validity |= NFS_INO_INVALID_DATA;
939 	spin_unlock(&inode->i_lock);
940 	return nfs_refresh_inode(inode, fattr);
941 }
942 
943 /**
944  * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
945  * @inode - pointer to inode
946  * @fattr - updated attributes
947  *
948  * After an operation that has changed the inode metadata, mark the
949  * attribute cache as being invalid, then try to update it. Fake up
950  * weak cache consistency data, if none exist.
951  *
952  * This function is mainly designed to be used by the ->write_done() functions.
953  */
954 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
955 {
956 	if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
957 			(fattr->valid & NFS_ATTR_WCC_V4) == 0) {
958 		fattr->pre_change_attr = NFS_I(inode)->change_attr;
959 		fattr->valid |= NFS_ATTR_WCC_V4;
960 	}
961 	if ((fattr->valid & NFS_ATTR_FATTR) != 0 &&
962 			(fattr->valid & NFS_ATTR_WCC) == 0) {
963 		memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
964 		memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
965 		fattr->pre_size = inode->i_size;
966 		fattr->valid |= NFS_ATTR_WCC;
967 	}
968 	return nfs_post_op_update_inode(inode, fattr);
969 }
970 
971 /*
972  * Many nfs protocol calls return the new file attributes after
973  * an operation.  Here we update the inode to reflect the state
974  * of the server's inode.
975  *
976  * This is a bit tricky because we have to make sure all dirty pages
977  * have been sent off to the server before calling invalidate_inode_pages.
978  * To make sure no other process adds more write requests while we try
979  * our best to flush them, we make them sleep during the attribute refresh.
980  *
981  * A very similar scenario holds for the dir cache.
982  */
983 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
984 {
985 	struct nfs_server *server;
986 	struct nfs_inode *nfsi = NFS_I(inode);
987 	loff_t cur_isize, new_isize;
988 	unsigned long invalid = 0;
989 	unsigned long now = jiffies;
990 
991 	dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
992 			__FUNCTION__, inode->i_sb->s_id, inode->i_ino,
993 			atomic_read(&inode->i_count), fattr->valid);
994 
995 	if (nfsi->fileid != fattr->fileid)
996 		goto out_fileid;
997 
998 	/*
999 	 * Make sure the inode's type hasn't changed.
1000 	 */
1001 	if ((inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
1002 		goto out_changed;
1003 
1004 	server = NFS_SERVER(inode);
1005 	/* Update the fsid? */
1006 	if (S_ISDIR(inode->i_mode)
1007 			&& !nfs_fsid_equal(&server->fsid, &fattr->fsid))
1008 		server->fsid = fattr->fsid;
1009 
1010 	/*
1011 	 * Update the read time so we don't revalidate too often.
1012 	 */
1013 	nfsi->read_cache_jiffies = fattr->time_start;
1014 
1015 	nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ATIME
1016 			| NFS_INO_REVAL_PAGECACHE);
1017 
1018 	/* Do atomic weak cache consistency updates */
1019 	nfs_wcc_update_inode(inode, fattr);
1020 
1021 	/* More cache consistency checks */
1022 	if (!(fattr->valid & NFS_ATTR_FATTR_V4)) {
1023 		/* NFSv2/v3: Check if the mtime agrees */
1024 		if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
1025 			dprintk("NFS: mtime change on server for file %s/%ld\n",
1026 					inode->i_sb->s_id, inode->i_ino);
1027 			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1028 			if (S_ISDIR(inode->i_mode))
1029 				nfs_force_lookup_revalidate(inode);
1030 		}
1031 		/* If ctime has changed we should definitely clear access+acl caches */
1032 		if (!timespec_equal(&inode->i_ctime, &fattr->ctime))
1033 			invalid |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1034 	} else if (nfsi->change_attr != fattr->change_attr) {
1035 		dprintk("NFS: change_attr change on server for file %s/%ld\n",
1036 				inode->i_sb->s_id, inode->i_ino);
1037 		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1038 		if (S_ISDIR(inode->i_mode))
1039 			nfs_force_lookup_revalidate(inode);
1040 	}
1041 
1042 	/* Check if our cached file size is stale */
1043  	new_isize = nfs_size_to_loff_t(fattr->size);
1044 	cur_isize = i_size_read(inode);
1045 	if (new_isize != cur_isize) {
1046 		/* Do we perhaps have any outstanding writes, or has
1047 		 * the file grown beyond our last write? */
1048 		if (nfsi->npages == 0 || new_isize > cur_isize) {
1049 			inode->i_size = new_isize;
1050 			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1051 		}
1052 		dprintk("NFS: isize change on server for file %s/%ld\n",
1053 				inode->i_sb->s_id, inode->i_ino);
1054 	}
1055 
1056 
1057 	memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1058 	memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1059 	memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
1060 	nfsi->change_attr = fattr->change_attr;
1061 
1062 	if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO) ||
1063 	    inode->i_uid != fattr->uid ||
1064 	    inode->i_gid != fattr->gid)
1065 		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1066 
1067 	inode->i_mode = fattr->mode;
1068 	inode->i_nlink = fattr->nlink;
1069 	inode->i_uid = fattr->uid;
1070 	inode->i_gid = fattr->gid;
1071 
1072 	if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
1073 		/*
1074 		 * report the blocks in 512byte units
1075 		 */
1076 		inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
1077  	} else {
1078  		inode->i_blocks = fattr->du.nfs2.blocks;
1079  	}
1080 
1081 	/* Update attrtimeo value if we're out of the unstable period */
1082 	if (invalid & NFS_INO_INVALID_ATTR) {
1083 		nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
1084 		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
1085 		nfsi->attrtimeo_timestamp = now;
1086 		nfsi->last_updated = now;
1087 	} else {
1088 		if (!time_in_range(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
1089 			if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
1090 				nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
1091 			nfsi->attrtimeo_timestamp = now;
1092 		}
1093 		/*
1094 		 * Avoid jiffy wraparound issues with nfsi->last_updated
1095 		 */
1096 		if (!time_in_range(nfsi->last_updated, nfsi->read_cache_jiffies, now))
1097 			nfsi->last_updated = nfsi->read_cache_jiffies;
1098 	}
1099 	invalid &= ~NFS_INO_INVALID_ATTR;
1100 	/* Don't invalidate the data if we were to blame */
1101 	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
1102 				|| S_ISLNK(inode->i_mode)))
1103 		invalid &= ~NFS_INO_INVALID_DATA;
1104 	if (!nfs_have_delegation(inode, FMODE_READ) ||
1105 			(nfsi->cache_validity & NFS_INO_REVAL_FORCED))
1106 		nfsi->cache_validity |= invalid;
1107 	nfsi->cache_validity &= ~NFS_INO_REVAL_FORCED;
1108 
1109 	return 0;
1110  out_changed:
1111 	/*
1112 	 * Big trouble! The inode has become a different object.
1113 	 */
1114 	printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
1115 			__FUNCTION__, inode->i_ino, inode->i_mode, fattr->mode);
1116  out_err:
1117 	/*
1118 	 * No need to worry about unhashing the dentry, as the
1119 	 * lookup validation will know that the inode is bad.
1120 	 * (But we fall through to invalidate the caches.)
1121 	 */
1122 	nfs_invalidate_inode(inode);
1123 	return -ESTALE;
1124 
1125  out_fileid:
1126 	printk(KERN_ERR "NFS: server %s error: fileid changed\n"
1127 		"fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
1128 		NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id,
1129 		(long long)nfsi->fileid, (long long)fattr->fileid);
1130 	goto out_err;
1131 }
1132 
1133 
1134 #ifdef CONFIG_NFS_V4
1135 
1136 /*
1137  * Clean out any remaining NFSv4 state that might be left over due
1138  * to open() calls that passed nfs_atomic_lookup, but failed to call
1139  * nfs_open().
1140  */
1141 void nfs4_clear_inode(struct inode *inode)
1142 {
1143 	/* If we are holding a delegation, return it! */
1144 	nfs_inode_return_delegation_noreclaim(inode);
1145 	/* First call standard NFS clear_inode() code */
1146 	nfs_clear_inode(inode);
1147 }
1148 #endif
1149 
1150 struct inode *nfs_alloc_inode(struct super_block *sb)
1151 {
1152 	struct nfs_inode *nfsi;
1153 	nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
1154 	if (!nfsi)
1155 		return NULL;
1156 	nfsi->flags = 0UL;
1157 	nfsi->cache_validity = 0UL;
1158 #ifdef CONFIG_NFS_V3_ACL
1159 	nfsi->acl_access = ERR_PTR(-EAGAIN);
1160 	nfsi->acl_default = ERR_PTR(-EAGAIN);
1161 #endif
1162 #ifdef CONFIG_NFS_V4
1163 	nfsi->nfs4_acl = NULL;
1164 #endif /* CONFIG_NFS_V4 */
1165 	return &nfsi->vfs_inode;
1166 }
1167 
1168 void nfs_destroy_inode(struct inode *inode)
1169 {
1170 	kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
1171 }
1172 
1173 static inline void nfs4_init_once(struct nfs_inode *nfsi)
1174 {
1175 #ifdef CONFIG_NFS_V4
1176 	INIT_LIST_HEAD(&nfsi->open_states);
1177 	nfsi->delegation = NULL;
1178 	nfsi->delegation_state = 0;
1179 	init_rwsem(&nfsi->rwsem);
1180 #endif
1181 }
1182 
1183 static void init_once(struct kmem_cache * cachep, void *foo)
1184 {
1185 	struct nfs_inode *nfsi = (struct nfs_inode *) foo;
1186 
1187 	inode_init_once(&nfsi->vfs_inode);
1188 	INIT_LIST_HEAD(&nfsi->open_files);
1189 	INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
1190 	INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
1191 	INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
1192 	nfsi->ncommit = 0;
1193 	nfsi->npages = 0;
1194 	atomic_set(&nfsi->silly_count, 1);
1195 	INIT_HLIST_HEAD(&nfsi->silly_list);
1196 	init_waitqueue_head(&nfsi->waitqueue);
1197 	nfs4_init_once(nfsi);
1198 }
1199 
1200 static int __init nfs_init_inodecache(void)
1201 {
1202 	nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
1203 					     sizeof(struct nfs_inode),
1204 					     0, (SLAB_RECLAIM_ACCOUNT|
1205 						SLAB_MEM_SPREAD),
1206 					     init_once);
1207 	if (nfs_inode_cachep == NULL)
1208 		return -ENOMEM;
1209 
1210 	return 0;
1211 }
1212 
1213 static void nfs_destroy_inodecache(void)
1214 {
1215 	kmem_cache_destroy(nfs_inode_cachep);
1216 }
1217 
1218 /*
1219  * Initialize NFS
1220  */
1221 static int __init init_nfs_fs(void)
1222 {
1223 	int err;
1224 
1225 	err = nfs_fs_proc_init();
1226 	if (err)
1227 		goto out5;
1228 
1229 	err = nfs_init_nfspagecache();
1230 	if (err)
1231 		goto out4;
1232 
1233 	err = nfs_init_inodecache();
1234 	if (err)
1235 		goto out3;
1236 
1237 	err = nfs_init_readpagecache();
1238 	if (err)
1239 		goto out2;
1240 
1241 	err = nfs_init_writepagecache();
1242 	if (err)
1243 		goto out1;
1244 
1245 	err = nfs_init_directcache();
1246 	if (err)
1247 		goto out0;
1248 
1249 #ifdef CONFIG_PROC_FS
1250 	rpc_proc_register(&nfs_rpcstat);
1251 #endif
1252 	if ((err = register_nfs_fs()) != 0)
1253 		goto out;
1254 	return 0;
1255 out:
1256 #ifdef CONFIG_PROC_FS
1257 	rpc_proc_unregister("nfs");
1258 #endif
1259 	nfs_destroy_directcache();
1260 out0:
1261 	nfs_destroy_writepagecache();
1262 out1:
1263 	nfs_destroy_readpagecache();
1264 out2:
1265 	nfs_destroy_inodecache();
1266 out3:
1267 	nfs_destroy_nfspagecache();
1268 out4:
1269 	nfs_fs_proc_exit();
1270 out5:
1271 	return err;
1272 }
1273 
1274 static void __exit exit_nfs_fs(void)
1275 {
1276 	nfs_destroy_directcache();
1277 	nfs_destroy_writepagecache();
1278 	nfs_destroy_readpagecache();
1279 	nfs_destroy_inodecache();
1280 	nfs_destroy_nfspagecache();
1281 #ifdef CONFIG_PROC_FS
1282 	rpc_proc_unregister("nfs");
1283 #endif
1284 	unregister_nfs_fs();
1285 	nfs_fs_proc_exit();
1286 }
1287 
1288 /* Not quite true; I just maintain it */
1289 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1290 MODULE_LICENSE("GPL");
1291 module_param(enable_ino64, bool, 0644);
1292 
1293 module_init(init_nfs_fs)
1294 module_exit(exit_nfs_fs)
1295