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