blob: 6f88d7c77ac98e1b4bdb5a8f0b347227c271d5ac [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/module.h>
17#include <linux/init.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040018#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#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>
Chuck Lever4ece3a22006-03-20 13:44:22 -050028#include <linux/sunrpc/metrics.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#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>
Manoj Naik9cdb3882006-06-09 09:34:28 -040038#include <linux/inet.h>
39#include <linux/nfs_xdr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
41#include <asm/system.h>
42#include <asm/uaccess.h>
43
Trond Myklebust4ce79712005-06-22 17:16:21 +000044#include "nfs4_fs.h"
Trond Myklebusta72b4422006-01-03 09:55:41 +010045#include "callback.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include "delegation.h"
Chuck Leverd9ef5a82006-03-20 13:44:13 -050047#include "iostat.h"
David Howellsf7b422b2006-06-09 09:34:33 -040048#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50#define NFSDBG_FACILITY NFSDBG_VFS
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Trond Myklebustf43bf0b2007-10-09 12:01:04 -040052#define NFS_64_BIT_INODE_NUMBERS_ENABLED 1
53
54/* Default is to see 64-bit inode numbers */
55static int enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
56
Linus Torvalds1da177e2005-04-16 15:20:36 -070057static void nfs_invalidate_inode(struct inode *);
Trond Myklebust24aa1fe2005-12-03 15:20:07 -050058static int nfs_update_inode(struct inode *, struct nfs_fattr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Trond Myklebustada70d92005-06-22 17:16:22 +000060static void nfs_zap_acl_cache(struct inode *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
Christoph Lametere18b8902006-12-06 20:33:20 -080062static struct kmem_cache * nfs_inode_cachep;
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +000063
Linus Torvalds1da177e2005-04-16 15:20:36 -070064static inline unsigned long
65nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
66{
67 return nfs_fileid_to_ino_t(fattr->fileid);
68}
69
Trond Myklebustf43bf0b2007-10-09 12:01:04 -040070/**
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 */
77u64 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
David Howellsf7b422b2006-06-09 09:34:33 -040089int nfs_write_inode(struct inode *inode, int sync)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090{
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 int ret;
92
Trond Myklebustd30c8342006-12-13 15:23:47 -050093 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103}
104
David Howellsf7b422b2006-06-09 09:34:33 -0400105void nfs_clear_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106{
Trond Myklebustda6d5032006-06-01 17:26:35 -0400107 /*
108 * The following should never happen...
109 */
110 BUG_ON(nfs_have_writebacks(inode));
Trond Myklebust1c3c07e2006-07-25 11:28:18 -0400111 BUG_ON(!list_empty(&NFS_I(inode)->open_files));
Trond Myklebustada70d92005-06-22 17:16:22 +0000112 nfs_zap_acl_cache(inode);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -0400113 nfs_access_zap_cache(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114}
115
Trond Myklebust29884df2005-12-13 16:13:54 -0500116/**
117 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
118 */
119int 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);
OGAWA Hirofumi28fd1292006-01-08 01:02:14 -0800126 ret = filemap_write_and_wait(mapping);
Trond Myklebust29884df2005-12-13 16:13:54 -0500127 if (ret != 0)
128 goto out;
129 ret = nfs_wb_all(mapping->host);
130out:
131 return ret;
132}
133
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134/*
135 * Invalidate the local caches
136 */
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500137static void nfs_zap_caches_locked(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138{
139 struct nfs_inode *nfsi = NFS_I(inode);
140 int mode = inode->i_mode;
141
Chuck Lever91d5b472006-03-20 13:44:14 -0500142 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
143
Trond Myklebustc7c20972007-09-28 19:22:40 -0400144 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
145 nfsi->attrtimeo_timestamp = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
147 memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode)));
148 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
Chuck Lever55296802005-08-18 11:24:09 -0700149 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 else
Chuck Lever55296802005-08-18 11:24:09 -0700151 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500152}
Chuck Leverdc592502005-08-18 11:24:12 -0700153
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500154void nfs_zap_caches(struct inode *inode)
155{
156 spin_lock(&inode->i_lock);
157 nfs_zap_caches_locked(inode);
Chuck Leverdc592502005-08-18 11:24:12 -0700158 spin_unlock(&inode->i_lock);
Trond Myklebustada70d92005-06-22 17:16:22 +0000159}
160
Trond Myklebustcd9ae2b2006-10-19 23:28:40 -0700161void 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
Trond Myklebustada70d92005-06-22 17:16:22 +0000170static 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);
Chuck Leverdc592502005-08-18 11:24:12 -0700177 spin_lock(&inode->i_lock);
Chuck Lever55296802005-08-18 11:24:09 -0700178 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
Chuck Leverdc592502005-08-18 11:24:12 -0700179 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180}
181
Trond Myklebustc4812992007-09-28 17:11:45 -0400182void 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189/*
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500190 * Invalidate, but do not unhash, the inode.
191 * NB: must be called with inode->i_lock held!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 */
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500193static void nfs_invalidate_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194{
Benny Halevy3a10c302008-01-23 08:58:59 +0200195 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500196 nfs_zap_caches_locked(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197}
198
199struct 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 */
210static int
211nfs_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
226static int
227nfs_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
Benny Halevy99fadcd2008-01-23 08:59:08 +0200232 set_nfs_fileid(inode, fattr->fileid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 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 */
244struct inode *
245nfs_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 };
Trond Myklebust03f28e32006-03-20 13:44:48 -0500251 struct inode *inode = ERR_PTR(-ENOENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 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
Trond Myklebust03f28e32006-03-20 13:44:48 -0500264 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
265 if (inode == NULL) {
266 inode = ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 goto out_no_inode;
Trond Myklebust03f28e32006-03-20 13:44:48 -0500268 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
270 if (inode->i_state & I_NEW) {
271 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebustb0c4fdd2007-02-05 14:44:22 -0800272 unsigned long now = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
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 */
David Howells8fa5c002006-08-22 20:06:12 -0400284 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 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)) {
David Howells8fa5c002006-08-22 20:06:12 -0400290 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 inode->i_fop = &nfs_dir_operations;
292 if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS)
293 && fattr->size <= NFS_LIMIT_READDIRPLUS)
Benny Halevy3a10c302008-01-23 08:58:59 +0200294 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
Trond Myklebust55a97592006-06-09 09:34:19 -0400295 /* Deal with crossing mountpoints */
296 if (!nfs_fsid_equal(&NFS_SB(sb)->fsid, &fattr->fsid)) {
Manoj Naik6b97fd32006-06-09 09:34:29 -0400297 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;
Trond Myklebust55a97592006-06-09 09:34:19 -0400301 inode->i_fop = NULL;
Trond Myklebustc37dcd332008-03-06 12:34:50 -0500302 set_bit(NFS_INO_MOUNTPOINT, &nfsi->flags);
Trond Myklebust55a97592006-06-09 09:34:19 -0400303 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 } else if (S_ISLNK(inode->i_mode))
305 inode->i_op = &nfs_symlink_inode_operations;
306 else
307 init_special_inode(inode, inode->i_mode, fattr->rdev);
308
Trond Myklebust33801142005-10-27 22:12:39 -0400309 nfsi->read_cache_jiffies = fattr->time_start;
Trond Myklebustb0c4fdd2007-02-05 14:44:22 -0800310 nfsi->last_updated = now;
311 nfsi->cache_change_attribute = now;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 inode->i_atime = fattr->atime;
313 inode->i_mtime = fattr->mtime;
314 inode->i_ctime = fattr->ctime;
315 if (fattr->valid & NFS_ATTR_FATTR_V4)
316 nfsi->change_attr = fattr->change_attr;
317 inode->i_size = nfs_size_to_loff_t(fattr->size);
318 inode->i_nlink = fattr->nlink;
319 inode->i_uid = fattr->uid;
320 inode->i_gid = fattr->gid;
321 if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
322 /*
323 * report the blocks in 512byte units
324 */
325 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 } else {
327 inode->i_blocks = fattr->du.nfs2.blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 }
329 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
Trond Myklebustb0c4fdd2007-02-05 14:44:22 -0800330 nfsi->attrtimeo_timestamp = now;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
Trond Myklebust1c3c07e2006-07-25 11:28:18 -0400332 nfsi->access_cache = RB_ROOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
334 unlock_new_inode(inode);
335 } else
336 nfs_refresh_inode(inode, fattr);
337 dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
338 inode->i_sb->s_id,
339 (long long)NFS_FILEID(inode),
340 atomic_read(&inode->i_count));
341
342out:
343 return inode;
344
345out_no_inode:
Trond Myklebust03f28e32006-03-20 13:44:48 -0500346 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 goto out;
348}
349
350#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET)
351
352int
353nfs_setattr(struct dentry *dentry, struct iattr *attr)
354{
355 struct inode *inode = dentry->d_inode;
356 struct nfs_fattr fattr;
357 int error;
358
Chuck Lever91d5b472006-03-20 13:44:14 -0500359 nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
360
Jeff Layton188b95d2007-10-18 03:05:21 -0700361 /* skip mode change if it's just for clearing setuid/setgid */
362 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
363 attr->ia_valid &= ~ATTR_MODE;
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 if (attr->ia_valid & ATTR_SIZE) {
366 if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode))
367 attr->ia_valid &= ~ATTR_SIZE;
368 }
369
370 /* Optimization: if the end result is no change, don't RPC */
371 attr->ia_valid &= NFS_VALID_ATTRS;
372 if (attr->ia_valid == 0)
373 return 0;
374
375 lock_kernel();
Trond Myklebust755c1e22006-03-20 13:44:06 -0500376 /* Write all dirty data */
Trond Myklebuste1552e12007-04-14 19:07:28 -0400377 if (S_ISREG(inode->i_mode)) {
378 filemap_write_and_wait(inode->i_mapping);
379 nfs_wb_all(inode);
380 }
Trond Myklebust642ac542005-10-18 14:20:19 -0700381 /*
382 * Return any delegations if we're going to change ACLs
383 */
384 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
385 nfs_inode_return_delegation(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 error = NFS_PROTO(inode)->setattr(dentry, &fattr, attr);
Trond Myklebust65e43082005-08-16 11:49:44 -0400387 if (error == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 nfs_refresh_inode(inode, &fattr);
Trond Myklebust65e43082005-08-16 11:49:44 -0400389 unlock_kernel();
390 return error;
391}
392
393/**
394 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
395 * @inode: pointer to struct inode
396 * @attr: pointer to struct iattr
397 *
398 * Note: we do this in the *proc.c in order to ensure that
399 * it works for things like exclusive creates too.
400 */
401void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
402{
403 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 if ((attr->ia_valid & ATTR_MODE) != 0) {
Trond Myklebust65e43082005-08-16 11:49:44 -0400405 int mode = attr->ia_mode & S_IALLUGO;
406 mode |= inode->i_mode & ~S_IALLUGO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 inode->i_mode = mode;
408 }
409 if ((attr->ia_valid & ATTR_UID) != 0)
410 inode->i_uid = attr->ia_uid;
411 if ((attr->ia_valid & ATTR_GID) != 0)
412 inode->i_gid = attr->ia_gid;
Chuck Leverdc592502005-08-18 11:24:12 -0700413 spin_lock(&inode->i_lock);
Chuck Lever55296802005-08-18 11:24:09 -0700414 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
Chuck Leverdc592502005-08-18 11:24:12 -0700415 spin_unlock(&inode->i_lock);
Trond Myklebust65e43082005-08-16 11:49:44 -0400416 }
417 if ((attr->ia_valid & ATTR_SIZE) != 0) {
Chuck Lever91d5b472006-03-20 13:44:14 -0500418 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
Trond Myklebust65e43082005-08-16 11:49:44 -0400419 inode->i_size = attr->ia_size;
420 vmtruncate(inode, attr->ia_size);
421 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422}
423
Chuck Lever412d5822005-08-18 11:24:11 -0700424static int nfs_wait_schedule(void *word)
425{
426 if (signal_pending(current))
427 return -ERESTARTSYS;
428 schedule();
429 return 0;
430}
431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432/*
433 * Wait for the inode to get unlocked.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 */
Chuck Lever412d5822005-08-18 11:24:11 -0700435static int nfs_wait_on_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 struct nfs_inode *nfsi = NFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 int error;
Chuck Lever412d5822005-08-18 11:24:11 -0700439
Chuck Lever412d5822005-08-18 11:24:11 -0700440 error = wait_on_bit_lock(&nfsi->flags, NFS_INO_REVALIDATING,
Matthew Wilcox150030b2007-12-06 16:24:39 -0500441 nfs_wait_schedule, TASK_KILLABLE);
Chuck Lever412d5822005-08-18 11:24:11 -0700442
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 return error;
444}
445
Chuck Lever412d5822005-08-18 11:24:11 -0700446static void nfs_wake_up_inode(struct inode *inode)
447{
448 struct nfs_inode *nfsi = NFS_I(inode);
449
450 clear_bit(NFS_INO_REVALIDATING, &nfsi->flags);
451 smp_mb__after_clear_bit();
452 wake_up_bit(&nfsi->flags, NFS_INO_REVALIDATING);
453}
454
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
456{
457 struct inode *inode = dentry->d_inode;
Chuck Lever55296802005-08-18 11:24:09 -0700458 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 int err;
460
Chuck Lever28c494c2007-10-26 13:32:13 -0400461 /*
462 * Flush out writes to the server in order to update c/mtime.
463 *
464 * Hold the i_mutex to suspend application writes temporarily;
465 * this prevents long-running writing applications from blocking
466 * nfs_wb_nocommit.
467 */
468 if (S_ISREG(inode->i_mode)) {
469 mutex_lock(&inode->i_mutex);
Trond Myklebusted90ef52007-07-20 13:13:28 -0400470 nfs_wb_nocommit(inode);
Chuck Lever28c494c2007-10-26 13:32:13 -0400471 mutex_unlock(&inode->i_mutex);
472 }
Christoph Hellwigfc33a7b2006-01-09 20:52:17 -0800473
474 /*
475 * We may force a getattr if the user cares about atime.
476 *
477 * Note that we only have to check the vfsmount flags here:
478 * - NFS always sets S_NOATIME by so checking it would give a
479 * bogus result
480 * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
481 * no point in checking those.
482 */
483 if ((mnt->mnt_flags & MNT_NOATIME) ||
484 ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 need_atime = 0;
Christoph Hellwigfc33a7b2006-01-09 20:52:17 -0800486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 if (need_atime)
488 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
489 else
490 err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
Peter Staubach4e769b92007-08-03 15:07:10 -0400491 if (!err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 generic_fillattr(inode, stat);
Trond Myklebustf43bf0b2007-10-09 12:01:04 -0400493 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
Peter Staubach4e769b92007-08-03 15:07:10 -0400494 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 return err;
496}
497
Trond Myklebustb92dccf2006-03-20 13:44:03 -0500498static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, struct dentry *dentry, struct rpc_cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499{
500 struct nfs_open_context *ctx;
501
Panagiotis Issarisf52720c2006-09-27 01:49:39 -0700502 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 if (ctx != NULL) {
Trond Myklebust88be9f92007-06-05 10:42:27 -0400504 ctx->path.dentry = dget(dentry);
505 ctx->path.mnt = mntget(mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 ctx->cred = get_rpccred(cred);
507 ctx->state = NULL;
508 ctx->lockowner = current->files;
Jeff Layton66d3aac2008-03-31 15:01:58 -0400509 ctx->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 ctx->error = 0;
Olivier Galibert00a92642005-06-22 17:16:29 +0000511 ctx->dir_cookie = 0;
Trond Myklebust5e119342007-07-26 12:06:17 -0400512 atomic_set(&ctx->count, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 }
514 return ctx;
515}
516
517struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
518{
519 if (ctx != NULL)
Trond Myklebust5e119342007-07-26 12:06:17 -0400520 atomic_inc(&ctx->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 return ctx;
522}
523
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400524static void __put_nfs_open_context(struct nfs_open_context *ctx, int wait)
Trond Myklebust3bec63d2007-06-17 16:02:44 -0400525{
Trond Myklebust5e119342007-07-26 12:06:17 -0400526 struct inode *inode = ctx->path.dentry->d_inode;
Trond Myklebust3bec63d2007-06-17 16:02:44 -0400527
Trond Myklebust5e119342007-07-26 12:06:17 -0400528 if (!atomic_dec_and_lock(&ctx->count, &inode->i_lock))
529 return;
530 list_del(&ctx->list);
531 spin_unlock(&inode->i_lock);
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400532 if (ctx->state != NULL) {
533 if (wait)
534 nfs4_close_sync(&ctx->path, ctx->state, ctx->mode);
535 else
536 nfs4_close_state(&ctx->path, ctx->state, ctx->mode);
537 }
Trond Myklebust3bec63d2007-06-17 16:02:44 -0400538 if (ctx->cred != NULL)
539 put_rpccred(ctx->cred);
540 dput(ctx->path.dentry);
541 mntput(ctx->path.mnt);
542 kfree(ctx);
543}
544
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400545void put_nfs_open_context(struct nfs_open_context *ctx)
546{
547 __put_nfs_open_context(ctx, 0);
548}
549
550static void put_nfs_open_context_sync(struct nfs_open_context *ctx)
551{
552 __put_nfs_open_context(ctx, 1);
553}
554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555/*
556 * Ensure that mmap has a recent RPC credential for use when writing out
557 * shared pages
558 */
Trond Myklebustb92dccf2006-03-20 13:44:03 -0500559static void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800561 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 struct nfs_inode *nfsi = NFS_I(inode);
563
564 filp->private_data = get_nfs_open_context(ctx);
565 spin_lock(&inode->i_lock);
566 list_add(&ctx->list, &nfsi->open_files);
567 spin_unlock(&inode->i_lock);
568}
569
Trond Myklebustd5308382005-11-04 15:33:38 -0500570/*
571 * Given an inode, search for an open context with the desired characteristics
572 */
573struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574{
575 struct nfs_inode *nfsi = NFS_I(inode);
576 struct nfs_open_context *pos, *ctx = NULL;
577
578 spin_lock(&inode->i_lock);
579 list_for_each_entry(pos, &nfsi->open_files, list) {
Trond Myklebustd5308382005-11-04 15:33:38 -0500580 if (cred != NULL && pos->cred != cred)
581 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 if ((pos->mode & mode) == mode) {
583 ctx = get_nfs_open_context(pos);
584 break;
585 }
586 }
587 spin_unlock(&inode->i_lock);
588 return ctx;
589}
590
Trond Myklebustb92dccf2006-03-20 13:44:03 -0500591static void nfs_file_clear_open_context(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592{
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800593 struct inode *inode = filp->f_path.dentry->d_inode;
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400594 struct nfs_open_context *ctx = nfs_file_open_context(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
596 if (ctx) {
597 filp->private_data = NULL;
598 spin_lock(&inode->i_lock);
599 list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
600 spin_unlock(&inode->i_lock);
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400601 put_nfs_open_context_sync(ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 }
603}
604
605/*
606 * These allocate and release file read/write context information.
607 */
608int nfs_open(struct inode *inode, struct file *filp)
609{
610 struct nfs_open_context *ctx;
611 struct rpc_cred *cred;
612
613 cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0);
614 if (IS_ERR(cred))
615 return PTR_ERR(cred);
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800616 ctx = alloc_nfs_open_context(filp->f_path.mnt, filp->f_path.dentry, cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 put_rpccred(cred);
618 if (ctx == NULL)
619 return -ENOMEM;
620 ctx->mode = filp->f_mode;
621 nfs_file_set_open_context(filp, ctx);
622 put_nfs_open_context(ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 return 0;
624}
625
626int nfs_release(struct inode *inode, struct file *filp)
627{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 nfs_file_clear_open_context(filp);
629 return 0;
630}
631
632/*
633 * This function is called whenever some part of NFS notices that
634 * the cached attributes have to be refreshed.
635 */
636int
637__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
638{
639 int status = -ESTALE;
640 struct nfs_fattr fattr;
641 struct nfs_inode *nfsi = NFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
643 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
644 inode->i_sb->s_id, (long long)NFS_FILEID(inode));
645
Trond Myklebust1842bfb2006-05-25 01:41:01 -0400646 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 lock_kernel();
Chuck Lever85233a72006-10-19 23:28:42 -0700648 if (is_bad_inode(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 goto out_nowait;
650 if (NFS_STALE(inode))
651 goto out_nowait;
652
Chuck Lever412d5822005-08-18 11:24:11 -0700653 status = nfs_wait_on_inode(inode);
654 if (status < 0)
655 goto out;
Trond Myklebust7fdc49c2007-09-28 19:11:33 -0400656
657 status = -ESTALE;
658 if (NFS_STALE(inode))
659 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), &fattr);
662 if (status != 0) {
663 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
664 inode->i_sb->s_id,
665 (long long)NFS_FILEID(inode), status);
666 if (status == -ESTALE) {
667 nfs_zap_caches(inode);
668 if (!S_ISDIR(inode->i_mode))
Benny Halevy3a10c302008-01-23 08:58:59 +0200669 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 }
671 goto out;
672 }
673
Trond Myklebust33801142005-10-27 22:12:39 -0400674 spin_lock(&inode->i_lock);
Trond Myklebust24aa1fe2005-12-03 15:20:07 -0500675 status = nfs_update_inode(inode, &fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 if (status) {
Trond Myklebust33801142005-10-27 22:12:39 -0400677 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
679 inode->i_sb->s_id,
680 (long long)NFS_FILEID(inode), status);
681 goto out;
682 }
Chuck Leverdc592502005-08-18 11:24:12 -0700683 spin_unlock(&inode->i_lock);
Chuck Lever55296802005-08-18 11:24:09 -0700684
Trond Myklebust24aa1fe2005-12-03 15:20:07 -0500685 if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
Trond Myklebustada70d92005-06-22 17:16:22 +0000686 nfs_zap_acl_cache(inode);
Chuck Lever55296802005-08-18 11:24:09 -0700687
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
689 inode->i_sb->s_id,
690 (long long)NFS_FILEID(inode));
691
Chuck Lever412d5822005-08-18 11:24:11 -0700692 out:
693 nfs_wake_up_inode(inode);
694
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 out_nowait:
696 unlock_kernel();
697 return status;
698}
699
700int nfs_attribute_timeout(struct inode *inode)
701{
702 struct nfs_inode *nfsi = NFS_I(inode);
703
704 if (nfs_have_delegation(inode, FMODE_READ))
705 return 0;
Fabio Olive Leitec7e15962007-07-26 22:59:00 -0300706 return !time_in_range(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707}
708
709/**
710 * nfs_revalidate_inode - Revalidate the inode attributes
711 * @server - pointer to nfs_server struct
712 * @inode - pointer to inode struct
713 *
714 * Updates inode attribute information by retrieving the data from the server.
715 */
716int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
717{
Trond Myklebust44b11872006-05-25 01:40:59 -0400718 if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 && !nfs_attribute_timeout(inode))
720 return NFS_STALE(inode) ? -ESTALE : 0;
721 return __nfs_revalidate_inode(server, inode);
722}
723
Trond Myklebust717d44e2007-01-24 11:54:55 -0800724static int nfs_invalidate_mapping_nolock(struct inode *inode, struct address_space *mapping)
725{
726 struct nfs_inode *nfsi = NFS_I(inode);
727
728 if (mapping->nrpages != 0) {
729 int ret = invalidate_inode_pages2(mapping);
730 if (ret < 0)
731 return ret;
732 }
733 spin_lock(&inode->i_lock);
734 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
Trond Myklebust2f78e432007-09-30 15:31:19 -0400735 if (S_ISDIR(inode->i_mode))
Trond Myklebust717d44e2007-01-24 11:54:55 -0800736 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
Trond Myklebust717d44e2007-01-24 11:54:55 -0800737 spin_unlock(&inode->i_lock);
738 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
739 dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
740 inode->i_sb->s_id, (long long)NFS_FILEID(inode));
741 return 0;
742}
743
744static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
745{
746 int ret = 0;
747
748 mutex_lock(&inode->i_mutex);
749 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_DATA) {
750 ret = nfs_sync_mapping(mapping);
751 if (ret == 0)
752 ret = nfs_invalidate_mapping_nolock(inode, mapping);
753 }
754 mutex_unlock(&inode->i_mutex);
755 return ret;
756}
757
758/**
759 * nfs_revalidate_mapping_nolock - Revalidate the pagecache
760 * @inode - pointer to host inode
761 * @mapping - pointer to mapping
762 */
763int nfs_revalidate_mapping_nolock(struct inode *inode, struct address_space *mapping)
764{
765 struct nfs_inode *nfsi = NFS_I(inode);
766 int ret = 0;
767
768 if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
769 || nfs_attribute_timeout(inode) || NFS_STALE(inode)) {
770 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
771 if (ret < 0)
772 goto out;
773 }
774 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
775 ret = nfs_invalidate_mapping_nolock(inode, mapping);
776out:
777 return ret;
778}
779
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780/**
Trond Myklebust7d52e862005-06-22 17:16:30 +0000781 * nfs_revalidate_mapping - Revalidate the pagecache
782 * @inode - pointer to host inode
783 * @mapping - pointer to mapping
Trond Myklebust717d44e2007-01-24 11:54:55 -0800784 *
785 * This version of the function will take the inode->i_mutex and attempt to
786 * flush out all dirty data if it needs to invalidate the page cache.
Trond Myklebust7d52e862005-06-22 17:16:30 +0000787 */
Trond Myklebust44b11872006-05-25 01:40:59 -0400788int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
Trond Myklebust7d52e862005-06-22 17:16:30 +0000789{
790 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust44b11872006-05-25 01:40:59 -0400791 int ret = 0;
792
Trond Myklebust44b11872006-05-25 01:40:59 -0400793 if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
Trond Myklebust717d44e2007-01-24 11:54:55 -0800794 || nfs_attribute_timeout(inode) || NFS_STALE(inode)) {
Trond Myklebust44b11872006-05-25 01:40:59 -0400795 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
Trond Myklebust717d44e2007-01-24 11:54:55 -0800796 if (ret < 0)
797 goto out;
Trond Myklebust7d52e862005-06-22 17:16:30 +0000798 }
Trond Myklebust717d44e2007-01-24 11:54:55 -0800799 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
800 ret = nfs_invalidate_mapping(inode, mapping);
Trond Myklebustcd9ae2b2006-10-19 23:28:40 -0700801out:
Trond Myklebust44b11872006-05-25 01:40:59 -0400802 return ret;
Trond Myklebust7d52e862005-06-22 17:16:30 +0000803}
804
Trond Myklebusta895b4a2006-01-03 09:55:40 +0100805static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
806{
807 struct nfs_inode *nfsi = NFS_I(inode);
808
Trond Myklebust70ca8852007-09-30 15:21:24 -0400809 if ((fattr->valid & NFS_ATTR_WCC_V4) != 0 &&
810 nfsi->change_attr == fattr->pre_change_attr) {
811 nfsi->change_attr = fattr->change_attr;
812 if (S_ISDIR(inode->i_mode))
813 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
814 }
Trond Myklebusta895b4a2006-01-03 09:55:40 +0100815 /* If we have atomic WCC data, we may update some attributes */
816 if ((fattr->valid & NFS_ATTR_WCC) != 0) {
Trond Myklebust17cadc92007-09-27 10:07:31 -0400817 if (timespec_equal(&inode->i_ctime, &fattr->pre_ctime))
Trond Myklebusta895b4a2006-01-03 09:55:40 +0100818 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
Trond Myklebusta895b4a2006-01-03 09:55:40 +0100819 if (timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
820 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
Trond Myklebuste323ea42007-09-30 17:03:25 -0400821 if (S_ISDIR(inode->i_mode))
822 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
Trond Myklebusta895b4a2006-01-03 09:55:40 +0100823 }
Chuck Lever8a8c74b2007-10-26 13:31:47 -0400824 if (inode->i_size == nfs_size_to_loff_t(fattr->pre_size) &&
825 nfsi->npages == 0)
826 inode->i_size = nfs_size_to_loff_t(fattr->size);
Trond Myklebusta895b4a2006-01-03 09:55:40 +0100827 }
828}
829
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830/**
Trond Myklebust33801142005-10-27 22:12:39 -0400831 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 * @inode - pointer to inode
833 * @fattr - updated attributes
834 *
835 * Verifies the attribute cache. If we have just changed the attributes,
836 * so that fattr carries weak cache consistency data, then it may
837 * also update the ctime/mtime/change_attribute.
838 */
Trond Myklebust33801142005-10-27 22:12:39 -0400839static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840{
841 struct nfs_inode *nfsi = NFS_I(inode);
842 loff_t cur_size, new_isize;
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400843 unsigned long invalid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
Chuck Leverdc592502005-08-18 11:24:12 -0700845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 /* Has the inode gone and changed behind our back? */
847 if (nfsi->fileid != fattr->fileid
Chuck Leverdc592502005-08-18 11:24:12 -0700848 || (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 return -EIO;
Chuck Leverdc592502005-08-18 11:24:12 -0700850 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
Trond Myklebustca62b9c2006-03-20 13:44:07 -0500852 /* Do atomic weak cache consistency updates */
853 nfs_wcc_update_inode(inode, fattr);
854
Trond Myklebust9d1e9232006-05-25 01:40:46 -0400855 if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
Trond Myklebustf1bb0b92006-05-25 01:40:55 -0400856 nfsi->change_attr != fattr->change_attr)
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400857 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 /* Verify a few of the more important attributes */
Trond Myklebustf1bb0b92006-05-25 01:40:55 -0400860 if (!timespec_equal(&inode->i_mtime, &fattr->mtime))
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400861 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
Trond Myklebustca62b9c2006-03-20 13:44:07 -0500862
863 cur_size = i_size_read(inode);
864 new_isize = nfs_size_to_loff_t(fattr->size);
Trond Myklebustfb374d22006-03-20 13:44:08 -0500865 if (cur_size != new_isize && nfsi->npages == 0)
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400866 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
868 /* Have any file permissions changed? */
869 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)
870 || inode->i_uid != fattr->uid
871 || inode->i_gid != fattr->gid)
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400872 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
874 /* Has the link count changed? */
875 if (inode->i_nlink != fattr->nlink)
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400876 invalid |= NFS_INO_INVALID_ATTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
878 if (!timespec_equal(&inode->i_atime, &fattr->atime))
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400879 invalid |= NFS_INO_INVALID_ATIME;
880
881 if (invalid != 0)
882 nfsi->cache_validity |= invalid;
883 else
884 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
885 | NFS_INO_INVALID_ATIME
886 | NFS_INO_REVAL_PAGECACHE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
Trond Myklebust33801142005-10-27 22:12:39 -0400888 nfsi->read_cache_jiffies = fattr->time_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 return 0;
890}
891
Trond Myklebust33801142005-10-27 22:12:39 -0400892/**
893 * nfs_refresh_inode - try to update the inode attribute cache
894 * @inode - pointer to inode
895 * @fattr - updated attributes
896 *
897 * Check that an RPC call that returned attributes has not overlapped with
898 * other recent updates of the inode metadata, then decide whether it is
899 * safe to do a full update of the inode attributes, or whether just to
900 * call nfs_check_inode_attributes.
901 */
902int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
903{
904 struct nfs_inode *nfsi = NFS_I(inode);
905 int status;
906
907 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
908 return 0;
909 spin_lock(&inode->i_lock);
Trond Myklebust33801142005-10-27 22:12:39 -0400910 if (time_after(fattr->time_start, nfsi->last_updated))
Trond Myklebust24aa1fe2005-12-03 15:20:07 -0500911 status = nfs_update_inode(inode, fattr);
Trond Myklebust33801142005-10-27 22:12:39 -0400912 else
913 status = nfs_check_inode_attributes(inode, fattr);
914
915 spin_unlock(&inode->i_lock);
916 return status;
917}
918
Trond Myklebustdecf4912005-10-27 22:12:39 -0400919/**
920 * nfs_post_op_update_inode - try to update the inode attribute cache
921 * @inode - pointer to inode
922 * @fattr - updated attributes
923 *
924 * After an operation that has changed the inode metadata, mark the
925 * attribute cache as being invalid, then try to update it.
Chuck Leverf551e442006-09-20 14:33:04 -0400926 *
927 * NB: if the server didn't return any post op attributes, this
928 * function will force the retrieval of attributes before the next
929 * NFS request. Thus it should be used only for operations that
930 * are expected to change one or more attributes, to avoid
931 * unnecessary NFS requests and trips through nfs_update_inode().
Trond Myklebustdecf4912005-10-27 22:12:39 -0400932 */
933int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
934{
935 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400936
Trond Myklebust7668fdb2007-10-01 09:59:15 -0400937 spin_lock(&inode->i_lock);
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400938 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
Trond Myklebust40d24702007-10-08 09:24:22 -0400939 if (S_ISDIR(inode->i_mode))
940 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
Trond Myklebust7668fdb2007-10-01 09:59:15 -0400941 spin_unlock(&inode->i_lock);
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400942 return nfs_refresh_inode(inode, fattr);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400943}
944
Trond Myklebust70ca8852007-09-30 15:21:24 -0400945/**
946 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
947 * @inode - pointer to inode
948 * @fattr - updated attributes
949 *
950 * After an operation that has changed the inode metadata, mark the
951 * attribute cache as being invalid, then try to update it. Fake up
952 * weak cache consistency data, if none exist.
953 *
954 * This function is mainly designed to be used by the ->write_done() functions.
955 */
956int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
957{
958 if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
959 (fattr->valid & NFS_ATTR_WCC_V4) == 0) {
960 fattr->pre_change_attr = NFS_I(inode)->change_attr;
961 fattr->valid |= NFS_ATTR_WCC_V4;
962 }
963 if ((fattr->valid & NFS_ATTR_FATTR) != 0 &&
964 (fattr->valid & NFS_ATTR_WCC) == 0) {
965 memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
966 memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
967 fattr->pre_size = inode->i_size;
968 fattr->valid |= NFS_ATTR_WCC;
969 }
970 return nfs_post_op_update_inode(inode, fattr);
971}
972
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973/*
974 * Many nfs protocol calls return the new file attributes after
975 * an operation. Here we update the inode to reflect the state
976 * of the server's inode.
977 *
978 * This is a bit tricky because we have to make sure all dirty pages
979 * have been sent off to the server before calling invalidate_inode_pages.
980 * To make sure no other process adds more write requests while we try
981 * our best to flush them, we make them sleep during the attribute refresh.
982 *
983 * A very similar scenario holds for the dir cache.
984 */
Trond Myklebust24aa1fe2005-12-03 15:20:07 -0500985static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986{
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -0400987 struct nfs_server *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust951a1432005-06-22 17:16:30 +0000989 loff_t cur_isize, new_isize;
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400990 unsigned long invalid = 0;
Trond Myklebust3e7d9502007-02-05 14:26:28 -0800991 unsigned long now = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
993 dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
994 __FUNCTION__, inode->i_sb->s_id, inode->i_ino,
995 atomic_read(&inode->i_count), fattr->valid);
996
Chuck Lever325cfed2005-11-30 18:08:55 -0500997 if (nfsi->fileid != fattr->fileid)
998 goto out_fileid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999
1000 /*
1001 * Make sure the inode's type hasn't changed.
1002 */
Trond Myklebust33801142005-10-27 22:12:39 -04001003 if ((inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 goto out_changed;
1005
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -04001006 server = NFS_SERVER(inode);
Trond Myklebusta0356862007-06-05 13:26:15 -04001007 /* Update the fsid? */
Trond Myklebustc37dcd332008-03-06 12:34:50 -05001008 if (S_ISDIR(inode->i_mode) &&
1009 !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
1010 !test_bit(NFS_INO_MOUNTPOINT, &nfsi->flags))
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -04001011 server->fsid = fattr->fsid;
1012
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 /*
1014 * Update the read time so we don't revalidate too often.
1015 */
Trond Myklebust33801142005-10-27 22:12:39 -04001016 nfsi->read_cache_jiffies = fattr->time_start;
Trond Myklebust3e7d9502007-02-05 14:26:28 -08001017
Trond Myklebustf2115dc2007-08-15 12:49:17 -04001018 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ATIME
1019 | NFS_INO_REVAL_PAGECACHE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001021 /* Do atomic weak cache consistency updates */
1022 nfs_wcc_update_inode(inode, fattr);
1023
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001024 /* More cache consistency checks */
1025 if (!(fattr->valid & NFS_ATTR_FATTR_V4)) {
1026 /* NFSv2/v3: Check if the mtime agrees */
1027 if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
1028 dprintk("NFS: mtime change on server for file %s/%ld\n",
1029 inode->i_sb->s_id, inode->i_ino);
1030 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
Trond Myklebustbfc69a42007-10-15 18:18:29 -04001031 if (S_ISDIR(inode->i_mode))
1032 nfs_force_lookup_revalidate(inode);
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001033 }
1034 /* If ctime has changed we should definitely clear access+acl caches */
Trond Myklebust12b373e2007-10-01 09:56:59 -04001035 if (!timespec_equal(&inode->i_ctime, &fattr->ctime))
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001036 invalid |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001037 } else if (nfsi->change_attr != fattr->change_attr) {
1038 dprintk("NFS: change_attr change on server for file %s/%ld\n",
1039 inode->i_sb->s_id, inode->i_ino);
1040 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
Trond Myklebustbfc69a42007-10-15 18:18:29 -04001041 if (S_ISDIR(inode->i_mode))
1042 nfs_force_lookup_revalidate(inode);
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001043 }
1044
Trond Myklebust951a1432005-06-22 17:16:30 +00001045 /* Check if our cached file size is stale */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 new_isize = nfs_size_to_loff_t(fattr->size);
1047 cur_isize = i_size_read(inode);
Trond Myklebust951a1432005-06-22 17:16:30 +00001048 if (new_isize != cur_isize) {
Trond Myklebustb64e8a52007-09-30 15:13:17 -04001049 /* Do we perhaps have any outstanding writes, or has
1050 * the file grown beyond our last write? */
1051 if (nfsi->npages == 0 || new_isize > cur_isize) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 inode->i_size = new_isize;
1053 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1054 }
Trond Myklebust951a1432005-06-22 17:16:30 +00001055 dprintk("NFS: isize change on server for file %s/%ld\n",
1056 inode->i_sb->s_id, inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 }
1058
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001060 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1061 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001063 nfsi->change_attr = fattr->change_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
1065 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO) ||
1066 inode->i_uid != fattr->uid ||
1067 inode->i_gid != fattr->gid)
Trond Myklebustada70d92005-06-22 17:16:22 +00001068 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069
1070 inode->i_mode = fattr->mode;
1071 inode->i_nlink = fattr->nlink;
1072 inode->i_uid = fattr->uid;
1073 inode->i_gid = fattr->gid;
1074
1075 if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
1076 /*
1077 * report the blocks in 512byte units
1078 */
1079 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 } else {
1081 inode->i_blocks = fattr->du.nfs2.blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 }
1083
1084 /* Update attrtimeo value if we're out of the unstable period */
1085 if (invalid & NFS_INO_INVALID_ATTR) {
Chuck Lever91d5b472006-03-20 13:44:14 -05001086 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
Trond Myklebust3e7d9502007-02-05 14:26:28 -08001088 nfsi->attrtimeo_timestamp = now;
Trond Myklebust6d2b2962007-10-01 18:57:50 -04001089 nfsi->last_updated = now;
1090 } else {
1091 if (!time_in_range(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
1092 if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
1093 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
1094 nfsi->attrtimeo_timestamp = now;
1095 }
1096 /*
1097 * Avoid jiffy wraparound issues with nfsi->last_updated
1098 */
1099 if (!time_in_range(nfsi->last_updated, nfsi->read_cache_jiffies, now))
1100 nfsi->last_updated = nfsi->read_cache_jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 }
Trond Myklebustf2115dc2007-08-15 12:49:17 -04001102 invalid &= ~NFS_INO_INVALID_ATTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 /* Don't invalidate the data if we were to blame */
1104 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
1105 || S_ISLNK(inode->i_mode)))
1106 invalid &= ~NFS_INO_INVALID_DATA;
Trond Myklebust412c77c2007-07-03 16:10:55 -04001107 if (!nfs_have_delegation(inode, FMODE_READ) ||
1108 (nfsi->cache_validity & NFS_INO_REVAL_FORCED))
Chuck Lever55296802005-08-18 11:24:09 -07001109 nfsi->cache_validity |= invalid;
Trond Myklebust412c77c2007-07-03 16:10:55 -04001110 nfsi->cache_validity &= ~NFS_INO_REVAL_FORCED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
1112 return 0;
1113 out_changed:
1114 /*
1115 * Big trouble! The inode has become a different object.
1116 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
1118 __FUNCTION__, inode->i_ino, inode->i_mode, fattr->mode);
Trond Myklebustb37b03b2005-11-25 17:10:06 -05001119 out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 /*
1121 * No need to worry about unhashing the dentry, as the
1122 * lookup validation will know that the inode is bad.
1123 * (But we fall through to invalidate the caches.)
1124 */
1125 nfs_invalidate_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 return -ESTALE;
Chuck Lever325cfed2005-11-30 18:08:55 -05001127
1128 out_fileid:
1129 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
1130 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
David Howells54ceac42006-08-22 20:06:13 -04001131 NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id,
Chuck Lever325cfed2005-11-30 18:08:55 -05001132 (long long)nfsi->fileid, (long long)fattr->fileid);
1133 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134}
1135
Trond Myklebust55a97592006-06-09 09:34:19 -04001136
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137#ifdef CONFIG_NFS_V4
1138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139/*
1140 * Clean out any remaining NFSv4 state that might be left over due
1141 * to open() calls that passed nfs_atomic_lookup, but failed to call
1142 * nfs_open().
1143 */
David Howellsf7b422b2006-06-09 09:34:33 -04001144void nfs4_clear_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 /* If we are holding a delegation, return it! */
Trond Myklebuste6f81072008-01-24 18:14:34 -05001147 nfs_inode_return_delegation_noreclaim(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 /* First call standard NFS clear_inode() code */
1149 nfs_clear_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151#endif
1152
David Howellsf7b422b2006-06-09 09:34:33 -04001153struct inode *nfs_alloc_inode(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154{
1155 struct nfs_inode *nfsi;
Christoph Lametere94b1762006-12-06 20:33:17 -08001156 nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 if (!nfsi)
1158 return NULL;
Chuck Lever55296802005-08-18 11:24:09 -07001159 nfsi->flags = 0UL;
1160 nfsi->cache_validity = 0UL;
Trond Myklebust458818e2005-06-22 17:16:27 +00001161#ifdef CONFIG_NFS_V3_ACL
1162 nfsi->acl_access = ERR_PTR(-EAGAIN);
1163 nfsi->acl_default = ERR_PTR(-EAGAIN);
1164#endif
J. Bruce Fieldse50a1c22005-06-22 17:16:23 +00001165#ifdef CONFIG_NFS_V4
1166 nfsi->nfs4_acl = NULL;
1167#endif /* CONFIG_NFS_V4 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 return &nfsi->vfs_inode;
1169}
1170
David Howellsf7b422b2006-06-09 09:34:33 -04001171void nfs_destroy_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172{
1173 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
1174}
1175
Andrew Mortond75d5412006-06-25 02:41:26 -07001176static inline void nfs4_init_once(struct nfs_inode *nfsi)
1177{
1178#ifdef CONFIG_NFS_V4
1179 INIT_LIST_HEAD(&nfsi->open_states);
1180 nfsi->delegation = NULL;
1181 nfsi->delegation_state = 0;
1182 init_rwsem(&nfsi->rwsem);
1183#endif
1184}
David Howellsf7b422b2006-06-09 09:34:33 -04001185
Christoph Lameter4ba9b9d2007-10-16 23:25:51 -07001186static void init_once(struct kmem_cache * cachep, void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187{
1188 struct nfs_inode *nfsi = (struct nfs_inode *) foo;
1189
Christoph Lametera35afb82007-05-16 22:10:57 -07001190 inode_init_once(&nfsi->vfs_inode);
Christoph Lametera35afb82007-05-16 22:10:57 -07001191 INIT_LIST_HEAD(&nfsi->open_files);
1192 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
1193 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
1194 INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
Christoph Lametera35afb82007-05-16 22:10:57 -07001195 nfsi->ncommit = 0;
1196 nfsi->npages = 0;
Trond Myklebust565277f2007-10-15 18:17:53 -04001197 atomic_set(&nfsi->silly_count, 1);
1198 INIT_HLIST_HEAD(&nfsi->silly_list);
1199 init_waitqueue_head(&nfsi->waitqueue);
Christoph Lametera35afb82007-05-16 22:10:57 -07001200 nfs4_init_once(nfsi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201}
Paul Mundt20c2df82007-07-20 10:11:58 +09001202
David Howellsf7b422b2006-06-09 09:34:33 -04001203static int __init nfs_init_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204{
1205 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
1206 sizeof(struct nfs_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -08001207 0, (SLAB_RECLAIM_ACCOUNT|
1208 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +09001209 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 if (nfs_inode_cachep == NULL)
1211 return -ENOMEM;
1212
1213 return 0;
1214}
1215
David Brownell266bee82006-06-27 12:59:15 -07001216static void nfs_destroy_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001218 kmem_cache_destroy(nfs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219}
1220
1221/*
1222 * Initialize NFS
1223 */
1224static int __init init_nfs_fs(void)
1225{
1226 int err;
1227
David Howells6aaca562006-08-22 20:06:13 -04001228 err = nfs_fs_proc_init();
1229 if (err)
1230 goto out5;
1231
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 err = nfs_init_nfspagecache();
1233 if (err)
1234 goto out4;
1235
1236 err = nfs_init_inodecache();
1237 if (err)
1238 goto out3;
1239
1240 err = nfs_init_readpagecache();
1241 if (err)
1242 goto out2;
1243
1244 err = nfs_init_writepagecache();
1245 if (err)
1246 goto out1;
1247
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 err = nfs_init_directcache();
1249 if (err)
1250 goto out0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251
1252#ifdef CONFIG_PROC_FS
1253 rpc_proc_register(&nfs_rpcstat);
1254#endif
David Howellsf7b422b2006-06-09 09:34:33 -04001255 if ((err = register_nfs_fs()) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 goto out;
1257 return 0;
1258out:
1259#ifdef CONFIG_PROC_FS
1260 rpc_proc_unregister("nfs");
1261#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 nfs_destroy_directcache();
Chuck Lever6b59a752005-11-30 18:08:19 -05001263out0:
Chuck Lever6b59a752005-11-30 18:08:19 -05001264 nfs_destroy_writepagecache();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265out1:
1266 nfs_destroy_readpagecache();
1267out2:
1268 nfs_destroy_inodecache();
1269out3:
1270 nfs_destroy_nfspagecache();
1271out4:
David Howells6aaca562006-08-22 20:06:13 -04001272 nfs_fs_proc_exit();
1273out5:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 return err;
1275}
1276
1277static void __exit exit_nfs_fs(void)
1278{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 nfs_destroy_directcache();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 nfs_destroy_writepagecache();
1281 nfs_destroy_readpagecache();
1282 nfs_destroy_inodecache();
1283 nfs_destroy_nfspagecache();
1284#ifdef CONFIG_PROC_FS
1285 rpc_proc_unregister("nfs");
1286#endif
David Howellsf7b422b2006-06-09 09:34:33 -04001287 unregister_nfs_fs();
David Howells6aaca562006-08-22 20:06:13 -04001288 nfs_fs_proc_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289}
1290
1291/* Not quite true; I just maintain it */
1292MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1293MODULE_LICENSE("GPL");
Trond Myklebustf43bf0b2007-10-09 12:01:04 -04001294module_param(enable_ino64, bool, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295
1296module_init(init_nfs_fs)
1297module_exit(exit_nfs_fs)