blob: 57bb31ad7a5ec1c46a5533db711ee6d7d423f68e [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 *
Alan Cox526719b2008-10-27 15:19:48 +00008 * Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * 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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/seq_file.h>
34#include <linux/mount.h>
35#include <linux/nfs_idmap.h>
36#include <linux/vfs.h>
Manoj Naik9cdb3882006-06-09 09:34:28 -040037#include <linux/inet.h>
38#include <linux/nfs_xdr.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090039#include <linux/slab.h>
Frank Filz3fa0b4e2010-12-02 19:31:23 +000040#include <linux/compat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42#include <asm/system.h>
43#include <asm/uaccess.h>
44
Trond Myklebust4ce79712005-06-22 17:16:21 +000045#include "nfs4_fs.h"
Trond Myklebusta72b4422006-01-03 09:55:41 +010046#include "callback.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include "delegation.h"
Chuck Leverd9ef5a82006-03-20 13:44:13 -050048#include "iostat.h"
David Howellsf7b422b2006-06-09 09:34:33 -040049#include "internal.h"
David Howells8ec442a2009-04-03 16:42:42 +010050#include "fscache.h"
Trond Myklebuste571cbf2009-08-19 18:12:27 -040051#include "dns_resolve.h"
Benny Halevye5e94012010-10-20 00:18:01 -040052#include "pnfs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
54#define NFSDBG_FACILITY NFSDBG_VFS
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Trond Myklebustf43bf0b2007-10-09 12:01:04 -040056#define NFS_64_BIT_INODE_NUMBERS_ENABLED 1
57
58/* Default is to see 64-bit inode numbers */
59static int enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
60
Linus Torvalds1da177e2005-04-16 15:20:36 -070061static void nfs_invalidate_inode(struct inode *);
Trond Myklebust24aa1fe2005-12-03 15:20:07 -050062static int nfs_update_inode(struct inode *, struct nfs_fattr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Christoph Lametere18b8902006-12-06 20:33:20 -080064static struct kmem_cache * nfs_inode_cachep;
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +000065
Linus Torvalds1da177e2005-04-16 15:20:36 -070066static inline unsigned long
67nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
68{
69 return nfs_fileid_to_ino_t(fattr->fileid);
70}
71
Trond Myklebustf43bf0b2007-10-09 12:01:04 -040072/**
Trond Myklebust72cb77f2009-03-11 14:10:30 -040073 * nfs_wait_bit_killable - helper for functions that are sleeping on bit locks
74 * @word: long word containing the bit lock
75 */
76int nfs_wait_bit_killable(void *word)
77{
78 if (fatal_signal_pending(current))
79 return -ERESTARTSYS;
80 schedule();
81 return 0;
82}
83
84/**
Trond Myklebustf43bf0b2007-10-09 12:01:04 -040085 * nfs_compat_user_ino64 - returns the user-visible inode number
86 * @fileid: 64-bit fileid
87 *
88 * This function returns a 32-bit inode number if the boot parameter
89 * nfs.enable_ino64 is zero.
90 */
91u64 nfs_compat_user_ino64(u64 fileid)
92{
Frank Filz3fa0b4e2010-12-02 19:31:23 +000093#ifdef CONFIG_COMPAT
94 compat_ulong_t ino;
95#else
96 unsigned long ino;
97#endif
Trond Myklebustf43bf0b2007-10-09 12:01:04 -040098
99 if (enable_ino64)
100 return fileid;
101 ino = fileid;
102 if (sizeof(ino) < sizeof(fileid))
103 ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
104 return ino;
105}
106
Al Virob57922d2010-06-07 14:34:48 -0400107static void nfs_clear_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108{
Trond Myklebustda6d5032006-06-01 17:26:35 -0400109 /*
110 * The following should never happen...
111 */
112 BUG_ON(nfs_have_writebacks(inode));
Trond Myklebust1c3c07e2006-07-25 11:28:18 -0400113 BUG_ON(!list_empty(&NFS_I(inode)->open_files));
Trond Myklebustada70d92005-06-22 17:16:22 +0000114 nfs_zap_acl_cache(inode);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -0400115 nfs_access_zap_cache(inode);
David Howellsef79c092009-04-03 16:42:43 +0100116 nfs_fscache_release_inode_cookie(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117}
118
Al Virob57922d2010-06-07 14:34:48 -0400119void nfs_evict_inode(struct inode *inode)
120{
121 truncate_inode_pages(&inode->i_data, 0);
122 end_writeback(inode);
123 nfs_clear_inode(inode);
124}
125
Trond Myklebust29884df2005-12-13 16:13:54 -0500126/**
127 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
128 */
129int nfs_sync_mapping(struct address_space *mapping)
130{
Trond Myklebust5cf95212010-02-19 17:03:29 -0800131 int ret = 0;
Trond Myklebust29884df2005-12-13 16:13:54 -0500132
Trond Myklebust5cf95212010-02-19 17:03:29 -0800133 if (mapping->nrpages != 0) {
134 unmap_mapping_range(mapping, 0, 0, 0);
135 ret = nfs_wb_all(mapping->host);
136 }
Trond Myklebust29884df2005-12-13 16:13:54 -0500137 return ret;
138}
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140/*
141 * Invalidate the local caches
142 */
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500143static void nfs_zap_caches_locked(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144{
145 struct nfs_inode *nfsi = NFS_I(inode);
146 int mode = inode->i_mode;
147
Chuck Lever91d5b472006-03-20 13:44:14 -0500148 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
149
Trond Myklebustc7c20972007-09-28 19:22:40 -0400150 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
151 nfsi->attrtimeo_timestamp = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode)));
154 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
Chuck Lever55296802005-08-18 11:24:09 -0700155 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 -0700156 else
Chuck Lever55296802005-08-18 11:24:09 -0700157 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 -0500158}
Chuck Leverdc592502005-08-18 11:24:12 -0700159
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500160void nfs_zap_caches(struct inode *inode)
161{
162 spin_lock(&inode->i_lock);
163 nfs_zap_caches_locked(inode);
Chuck Leverdc592502005-08-18 11:24:12 -0700164 spin_unlock(&inode->i_lock);
Trond Myklebustada70d92005-06-22 17:16:22 +0000165}
166
Trond Myklebustcd9ae2b2006-10-19 23:28:40 -0700167void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
168{
169 if (mapping->nrpages != 0) {
170 spin_lock(&inode->i_lock);
171 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
172 spin_unlock(&inode->i_lock);
173 }
174}
175
Trond Myklebustf41f7412008-06-11 17:39:04 -0400176void nfs_zap_acl_cache(struct inode *inode)
Trond Myklebustada70d92005-06-22 17:16:22 +0000177{
178 void (*clear_acl_cache)(struct inode *);
179
180 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
181 if (clear_acl_cache != NULL)
182 clear_acl_cache(inode);
Chuck Leverdc592502005-08-18 11:24:12 -0700183 spin_lock(&inode->i_lock);
Chuck Lever55296802005-08-18 11:24:09 -0700184 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
Chuck Leverdc592502005-08-18 11:24:12 -0700185 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186}
187
Trond Myklebustc4812992007-09-28 17:11:45 -0400188void nfs_invalidate_atime(struct inode *inode)
189{
190 spin_lock(&inode->i_lock);
191 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
192 spin_unlock(&inode->i_lock);
193}
194
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195/*
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500196 * Invalidate, but do not unhash, the inode.
197 * NB: must be called with inode->i_lock held!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 */
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500199static void nfs_invalidate_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200{
Benny Halevy3a10c302008-01-23 08:58:59 +0200201 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500202 nfs_zap_caches_locked(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203}
204
205struct nfs_find_desc {
206 struct nfs_fh *fh;
207 struct nfs_fattr *fattr;
208};
209
210/*
211 * In NFSv3 we can have 64bit inode numbers. In order to support
212 * this, and re-exported directories (also seen in NFSv2)
213 * we are forced to allow 2 different inodes to have the same
214 * i_ino.
215 */
216static int
217nfs_find_actor(struct inode *inode, void *opaque)
218{
219 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
220 struct nfs_fh *fh = desc->fh;
221 struct nfs_fattr *fattr = desc->fattr;
222
223 if (NFS_FILEID(inode) != fattr->fileid)
224 return 0;
225 if (nfs_compare_fh(NFS_FH(inode), fh))
226 return 0;
227 if (is_bad_inode(inode) || NFS_STALE(inode))
228 return 0;
229 return 1;
230}
231
232static int
233nfs_init_locked(struct inode *inode, void *opaque)
234{
235 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
236 struct nfs_fattr *fattr = desc->fattr;
237
Benny Halevy99fadcd2008-01-23 08:59:08 +0200238 set_nfs_fileid(inode, fattr->fileid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 nfs_copy_fh(NFS_FH(inode), desc->fh);
240 return 0;
241}
242
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243/*
244 * This is our front-end to iget that looks up inodes by file handle
245 * instead of inode number.
246 */
247struct inode *
248nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
249{
250 struct nfs_find_desc desc = {
251 .fh = fh,
252 .fattr = fattr
253 };
Trond Myklebust03f28e32006-03-20 13:44:48 -0500254 struct inode *inode = ERR_PTR(-ENOENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 unsigned long hash;
256
Bryan Schumaker7ebb9312011-03-24 17:12:30 +0000257 nfs_attr_check_mountpoint(sb, fattr);
258
259 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0 && (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 goto out_no_inode;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400261 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 goto out_no_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 hash = nfs_fattr_to_ino_t(fattr);
265
Trond Myklebust03f28e32006-03-20 13:44:48 -0500266 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
267 if (inode == NULL) {
268 inode = ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 goto out_no_inode;
Trond Myklebust03f28e32006-03-20 13:44:48 -0500270 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
272 if (inode->i_state & I_NEW) {
273 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebustb0c4fdd2007-02-05 14:44:22 -0800274 unsigned long now = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
276 /* We set i_ino for the few things that still rely on it,
277 * such as stat(2) */
278 inode->i_ino = hash;
279
280 /* We can't support update_atime(), since the server will reset it */
281 inode->i_flags |= S_NOATIME|S_NOCMTIME;
282 inode->i_mode = fattr->mode;
Trond Myklebust62ab4602009-08-09 15:06:19 -0400283 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
284 && nfs_server_capable(inode, NFS_CAP_MODE))
285 nfsi->cache_validity |= NFS_INO_INVALID_ATTR
286 | NFS_INO_INVALID_ACCESS
287 | NFS_INO_INVALID_ACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 /* Why so? Because we want revalidate for devices/FIFOs, and
289 * that's precisely what we have in nfs_file_inode_operations.
290 */
David Howells8fa5c002006-08-22 20:06:12 -0400291 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 if (S_ISREG(inode->i_mode)) {
293 inode->i_fop = &nfs_file_operations;
294 inode->i_data.a_ops = &nfs_file_aops;
295 inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info;
296 } else if (S_ISDIR(inode->i_mode)) {
David Howells8fa5c002006-08-22 20:06:12 -0400297 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 inode->i_fop = &nfs_dir_operations;
Trond Myklebust11de3b12010-12-01 14:17:06 -0500299 inode->i_data.a_ops = &nfs_dir_aops;
Bryan Schumaker0715dc62010-09-24 18:50:01 -0400300 if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS))
Benny Halevy3a10c302008-01-23 08:58:59 +0200301 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
Trond Myklebust55a97592006-06-09 09:34:19 -0400302 /* Deal with crossing mountpoints */
Bryan Schumaker7ebb9312011-03-24 17:12:30 +0000303 if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
304 fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
Manoj Naik6b97fd32006-06-09 09:34:29 -0400305 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
306 inode->i_op = &nfs_referral_inode_operations;
307 else
308 inode->i_op = &nfs_mountpoint_inode_operations;
Trond Myklebust55a97592006-06-09 09:34:19 -0400309 inode->i_fop = NULL;
David Howells36d43a42011-01-14 18:45:42 +0000310 inode->i_flags |= S_AUTOMOUNT;
Trond Myklebust55a97592006-06-09 09:34:19 -0400311 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 } else if (S_ISLNK(inode->i_mode))
313 inode->i_op = &nfs_symlink_inode_operations;
314 else
315 init_special_inode(inode, inode->i_mode, fattr->rdev);
316
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400317 memset(&inode->i_atime, 0, sizeof(inode->i_atime));
318 memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
319 memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
320 nfsi->change_attr = 0;
321 inode->i_size = 0;
322 inode->i_nlink = 0;
323 inode->i_uid = -2;
324 inode->i_gid = -2;
325 inode->i_blocks = 0;
326 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
327
Trond Myklebust33801142005-10-27 22:12:39 -0400328 nfsi->read_cache_jiffies = fattr->time_start;
Trond Myklebust4704f0e2008-10-14 19:16:07 -0400329 nfsi->attr_gencount = fattr->gencount;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400330 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
331 inode->i_atime = fattr->atime;
Trond Myklebust62ab4602009-08-09 15:06:19 -0400332 else if (nfs_server_capable(inode, NFS_CAP_ATIME))
333 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400334 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
335 inode->i_mtime = fattr->mtime;
Trond Myklebust62ab4602009-08-09 15:06:19 -0400336 else if (nfs_server_capable(inode, NFS_CAP_MTIME))
337 nfsi->cache_validity |= NFS_INO_INVALID_ATTR
338 | NFS_INO_INVALID_DATA;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400339 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
340 inode->i_ctime = fattr->ctime;
Trond Myklebust62ab4602009-08-09 15:06:19 -0400341 else if (nfs_server_capable(inode, NFS_CAP_CTIME))
342 nfsi->cache_validity |= NFS_INO_INVALID_ATTR
343 | NFS_INO_INVALID_ACCESS
344 | NFS_INO_INVALID_ACL;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400345 if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 nfsi->change_attr = fattr->change_attr;
Trond Myklebust62ab4602009-08-09 15:06:19 -0400347 else if (nfs_server_capable(inode, NFS_CAP_CHANGE_ATTR))
348 nfsi->cache_validity |= NFS_INO_INVALID_ATTR
349 | NFS_INO_INVALID_DATA;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400350 if (fattr->valid & NFS_ATTR_FATTR_SIZE)
351 inode->i_size = nfs_size_to_loff_t(fattr->size);
Trond Myklebust62ab4602009-08-09 15:06:19 -0400352 else
353 nfsi->cache_validity |= NFS_INO_INVALID_ATTR
354 | NFS_INO_INVALID_DATA
355 | NFS_INO_REVAL_PAGECACHE;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400356 if (fattr->valid & NFS_ATTR_FATTR_NLINK)
357 inode->i_nlink = fattr->nlink;
Trond Myklebust62ab4602009-08-09 15:06:19 -0400358 else if (nfs_server_capable(inode, NFS_CAP_NLINK))
359 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400360 if (fattr->valid & NFS_ATTR_FATTR_OWNER)
361 inode->i_uid = fattr->uid;
Trond Myklebust62ab4602009-08-09 15:06:19 -0400362 else if (nfs_server_capable(inode, NFS_CAP_OWNER))
363 nfsi->cache_validity |= NFS_INO_INVALID_ATTR
364 | NFS_INO_INVALID_ACCESS
365 | NFS_INO_INVALID_ACL;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400366 if (fattr->valid & NFS_ATTR_FATTR_GROUP)
367 inode->i_gid = fattr->gid;
Trond Myklebust62ab4602009-08-09 15:06:19 -0400368 else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP))
369 nfsi->cache_validity |= NFS_INO_INVALID_ATTR
370 | NFS_INO_INVALID_ACCESS
371 | NFS_INO_INVALID_ACL;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400372 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
373 inode->i_blocks = fattr->du.nfs2.blocks;
374 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 /*
376 * report the blocks in 512byte units
377 */
378 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 }
380 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
Trond Myklebustb0c4fdd2007-02-05 14:44:22 -0800381 nfsi->attrtimeo_timestamp = now;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -0400382 nfsi->access_cache = RB_ROOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
David Howellsef79c092009-04-03 16:42:43 +0100384 nfs_fscache_init_inode_cookie(inode);
385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 unlock_new_inode(inode);
387 } else
388 nfs_refresh_inode(inode, fattr);
389 dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
390 inode->i_sb->s_id,
391 (long long)NFS_FILEID(inode),
392 atomic_read(&inode->i_count));
393
394out:
395 return inode;
396
397out_no_inode:
Trond Myklebust03f28e32006-03-20 13:44:48 -0500398 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 goto out;
400}
401
Trond Myklebust659bfcd2008-06-10 19:39:41 -0400402#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
404int
405nfs_setattr(struct dentry *dentry, struct iattr *attr)
406{
407 struct inode *inode = dentry->d_inode;
Trond Myklebust987f8df2010-04-16 16:22:52 -0400408 struct nfs_fattr *fattr;
409 int error = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Chuck Lever91d5b472006-03-20 13:44:14 -0500411 nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
412
Jeff Layton188b95d2007-10-18 03:05:21 -0700413 /* skip mode change if it's just for clearing setuid/setgid */
414 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
415 attr->ia_valid &= ~ATTR_MODE;
416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 if (attr->ia_valid & ATTR_SIZE) {
418 if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode))
419 attr->ia_valid &= ~ATTR_SIZE;
420 }
421
422 /* Optimization: if the end result is no change, don't RPC */
423 attr->ia_valid &= NFS_VALID_ATTRS;
Trond Myklebust659bfcd2008-06-10 19:39:41 -0400424 if ((attr->ia_valid & ~ATTR_FILE) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 return 0;
426
Trond Myklebust755c1e22006-03-20 13:44:06 -0500427 /* Write all dirty data */
Trond Myklebust1b924e52010-07-31 14:29:06 -0400428 if (S_ISREG(inode->i_mode))
Trond Myklebuste1552e12007-04-14 19:07:28 -0400429 nfs_wb_all(inode);
Trond Myklebust987f8df2010-04-16 16:22:52 -0400430
431 fattr = nfs_alloc_fattr();
432 if (fattr == NULL)
433 goto out;
Trond Myklebust642ac542005-10-18 14:20:19 -0700434 /*
435 * Return any delegations if we're going to change ACLs
436 */
437 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
438 nfs_inode_return_delegation(inode);
Trond Myklebust987f8df2010-04-16 16:22:52 -0400439 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
Trond Myklebust65e43082005-08-16 11:49:44 -0400440 if (error == 0)
Trond Myklebust987f8df2010-04-16 16:22:52 -0400441 nfs_refresh_inode(inode, fattr);
442 nfs_free_fattr(fattr);
443out:
Trond Myklebust65e43082005-08-16 11:49:44 -0400444 return error;
445}
446
447/**
Trond Myklebusta3d01452008-06-11 12:21:19 -0400448 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
449 * @inode: inode of the file used
450 * @offset: file offset to start truncating
451 *
452 * This is a copy of the common vmtruncate, but with the locking
453 * corrected to take into account the fact that NFS requires
454 * inode->i_size to be updated under the inode->i_lock.
455 */
456static int nfs_vmtruncate(struct inode * inode, loff_t offset)
457{
npiggin@suse.dec08d3b02009-08-21 02:35:06 +1000458 loff_t oldsize;
459 int err;
Trond Myklebusta3d01452008-06-11 12:21:19 -0400460
npiggin@suse.dec08d3b02009-08-21 02:35:06 +1000461 err = inode_newsize_ok(inode, offset);
462 if (err)
463 goto out;
Trond Myklebusta3d01452008-06-11 12:21:19 -0400464
npiggin@suse.dec08d3b02009-08-21 02:35:06 +1000465 spin_lock(&inode->i_lock);
466 oldsize = inode->i_size;
467 i_size_write(inode, offset);
468 spin_unlock(&inode->i_lock);
Trond Myklebusta3d01452008-06-11 12:21:19 -0400469
npiggin@suse.dec08d3b02009-08-21 02:35:06 +1000470 truncate_pagecache(inode, oldsize, offset);
471out:
472 return err;
Trond Myklebusta3d01452008-06-11 12:21:19 -0400473}
474
475/**
Trond Myklebust65e43082005-08-16 11:49:44 -0400476 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
477 * @inode: pointer to struct inode
478 * @attr: pointer to struct iattr
479 *
480 * Note: we do this in the *proc.c in order to ensure that
481 * it works for things like exclusive creates too.
482 */
483void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
484{
485 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
Trond Myklebust2f28ea62008-10-05 14:26:11 -0400486 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 if ((attr->ia_valid & ATTR_MODE) != 0) {
Trond Myklebust65e43082005-08-16 11:49:44 -0400488 int mode = attr->ia_mode & S_IALLUGO;
489 mode |= inode->i_mode & ~S_IALLUGO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 inode->i_mode = mode;
491 }
492 if ((attr->ia_valid & ATTR_UID) != 0)
493 inode->i_uid = attr->ia_uid;
494 if ((attr->ia_valid & ATTR_GID) != 0)
495 inode->i_gid = attr->ia_gid;
Chuck Lever55296802005-08-18 11:24:09 -0700496 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
Chuck Leverdc592502005-08-18 11:24:12 -0700497 spin_unlock(&inode->i_lock);
Trond Myklebust65e43082005-08-16 11:49:44 -0400498 }
499 if ((attr->ia_valid & ATTR_SIZE) != 0) {
Chuck Lever91d5b472006-03-20 13:44:14 -0500500 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
Trond Myklebusta3d01452008-06-11 12:21:19 -0400501 nfs_vmtruncate(inode, attr->ia_size);
Trond Myklebust65e43082005-08-16 11:49:44 -0400502 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503}
504
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
506{
507 struct inode *inode = dentry->d_inode;
Chuck Lever55296802005-08-18 11:24:09 -0700508 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 int err;
510
Trond Myklebustacdc53b2010-02-19 17:03:26 -0800511 /* Flush out writes to the server in order to update c/mtime. */
Chuck Lever28c494c2007-10-26 13:32:13 -0400512 if (S_ISREG(inode->i_mode)) {
Trond Myklebustacdc53b2010-02-19 17:03:26 -0800513 err = filemap_write_and_wait(inode->i_mapping);
514 if (err)
515 goto out;
Chuck Lever28c494c2007-10-26 13:32:13 -0400516 }
Christoph Hellwigfc33a7b2006-01-09 20:52:17 -0800517
518 /*
519 * We may force a getattr if the user cares about atime.
520 *
521 * Note that we only have to check the vfsmount flags here:
522 * - NFS always sets S_NOATIME by so checking it would give a
523 * bogus result
524 * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
525 * no point in checking those.
526 */
527 if ((mnt->mnt_flags & MNT_NOATIME) ||
528 ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 need_atime = 0;
Christoph Hellwigfc33a7b2006-01-09 20:52:17 -0800530
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 if (need_atime)
532 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
533 else
534 err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
Peter Staubach4e769b92007-08-03 15:07:10 -0400535 if (!err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 generic_fillattr(inode, stat);
Trond Myklebustf43bf0b2007-10-09 12:01:04 -0400537 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
Peter Staubach4e769b92007-08-03 15:07:10 -0400538 }
Trond Myklebustacdc53b2010-02-19 17:03:26 -0800539out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 return err;
541}
542
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400543static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
544{
545 atomic_set(&l_ctx->count, 1);
546 l_ctx->lockowner = current->files;
547 l_ctx->pid = current->tgid;
548 INIT_LIST_HEAD(&l_ctx->list);
549}
550
551static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx)
552{
553 struct nfs_lock_context *pos;
554
555 list_for_each_entry(pos, &ctx->lock_context.list, list) {
556 if (pos->lockowner != current->files)
557 continue;
558 if (pos->pid != current->tgid)
559 continue;
560 atomic_inc(&pos->count);
561 return pos;
562 }
563 return NULL;
564}
565
566struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
567{
568 struct nfs_lock_context *res, *new = NULL;
569 struct inode *inode = ctx->path.dentry->d_inode;
570
571 spin_lock(&inode->i_lock);
572 res = __nfs_find_lock_context(ctx);
573 if (res == NULL) {
574 spin_unlock(&inode->i_lock);
575 new = kmalloc(sizeof(*new), GFP_KERNEL);
576 if (new == NULL)
577 return NULL;
578 nfs_init_lock_context(new);
579 spin_lock(&inode->i_lock);
580 res = __nfs_find_lock_context(ctx);
581 if (res == NULL) {
582 list_add_tail(&new->list, &ctx->lock_context.list);
583 new->open_context = ctx;
584 res = new;
585 new = NULL;
586 }
587 }
588 spin_unlock(&inode->i_lock);
589 kfree(new);
590 return res;
591}
592
593void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
594{
595 struct nfs_open_context *ctx = l_ctx->open_context;
596 struct inode *inode = ctx->path.dentry->d_inode;
597
598 if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock))
599 return;
600 list_del(&l_ctx->list);
601 spin_unlock(&inode->i_lock);
602 kfree(l_ctx);
603}
604
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400605/**
606 * nfs_close_context - Common close_context() routine NFSv2/v3
607 * @ctx: pointer to context
608 * @is_sync: is this a synchronous close
609 *
610 * always ensure that the attributes are up to date if we're mounted
611 * with close-to-open semantics
612 */
613void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
614{
615 struct inode *inode;
616 struct nfs_server *server;
617
618 if (!(ctx->mode & FMODE_WRITE))
619 return;
620 if (!is_sync)
621 return;
622 inode = ctx->path.dentry->d_inode;
623 if (!list_empty(&NFS_I(inode)->open_files))
624 return;
625 server = NFS_SERVER(inode);
626 if (server->flags & NFS_MOUNT_NOCTO)
627 return;
628 nfs_revalidate_inode(server, inode);
629}
630
Trond Myklebustcd9a1c02010-09-17 10:56:50 -0400631struct nfs_open_context *alloc_nfs_open_context(struct path *path, struct rpc_cred *cred, fmode_t f_mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632{
633 struct nfs_open_context *ctx;
634
Panagiotis Issarisf52720c2006-09-27 01:49:39 -0700635 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 if (ctx != NULL) {
Al Viro6eae7972010-01-30 13:44:07 -0500637 ctx->path = *path;
638 path_get(&ctx->path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 ctx->cred = get_rpccred(cred);
640 ctx->state = NULL;
Trond Myklebustcd9a1c02010-09-17 10:56:50 -0400641 ctx->mode = f_mode;
Jeff Layton66d3aac2008-03-31 15:01:58 -0400642 ctx->flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 ctx->error = 0;
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400644 nfs_init_lock_context(&ctx->lock_context);
645 ctx->lock_context.open_context = ctx;
Trond Myklebust5c78f582010-09-27 15:51:20 -0400646 INIT_LIST_HEAD(&ctx->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 }
648 return ctx;
649}
650
651struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
652{
653 if (ctx != NULL)
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400654 atomic_inc(&ctx->lock_context.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 return ctx;
656}
657
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400658static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
Trond Myklebust3bec63d2007-06-17 16:02:44 -0400659{
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400660 struct inode *inode = ctx->path.dentry->d_inode;
Trond Myklebust3bec63d2007-06-17 16:02:44 -0400661
Trond Myklebust5c78f582010-09-27 15:51:20 -0400662 if (!list_empty(&ctx->list)) {
Benny Halevyef843032010-09-23 12:22:09 -0400663 if (!atomic_dec_and_lock(&ctx->lock_context.count, &inode->i_lock))
664 return;
665 list_del(&ctx->list);
666 spin_unlock(&inode->i_lock);
Benny Halevyef843032010-09-23 12:22:09 -0400667 } else if (!atomic_dec_and_test(&ctx->lock_context.count))
Trond Myklebust5e119342007-07-26 12:06:17 -0400668 return;
Trond Myklebust5c78f582010-09-27 15:51:20 -0400669 if (inode != NULL)
670 NFS_PROTO(inode)->close_context(ctx, is_sync);
Trond Myklebust3bec63d2007-06-17 16:02:44 -0400671 if (ctx->cred != NULL)
672 put_rpccred(ctx->cred);
Jan Blunck31f31db12008-05-02 13:42:45 -0700673 path_put(&ctx->path);
Trond Myklebust3bec63d2007-06-17 16:02:44 -0400674 kfree(ctx);
675}
676
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400677void put_nfs_open_context(struct nfs_open_context *ctx)
678{
679 __put_nfs_open_context(ctx, 0);
680}
681
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682/*
683 * Ensure that mmap has a recent RPC credential for use when writing out
684 * shared pages
685 */
Trond Myklebustcd9a1c02010-09-17 10:56:50 -0400686void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687{
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800688 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 struct nfs_inode *nfsi = NFS_I(inode);
690
691 filp->private_data = get_nfs_open_context(ctx);
692 spin_lock(&inode->i_lock);
693 list_add(&ctx->list, &nfsi->open_files);
694 spin_unlock(&inode->i_lock);
695}
696
Trond Myklebustd5308382005-11-04 15:33:38 -0500697/*
698 * Given an inode, search for an open context with the desired characteristics
699 */
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500700struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701{
702 struct nfs_inode *nfsi = NFS_I(inode);
703 struct nfs_open_context *pos, *ctx = NULL;
704
705 spin_lock(&inode->i_lock);
706 list_for_each_entry(pos, &nfsi->open_files, list) {
Trond Myklebustd5308382005-11-04 15:33:38 -0500707 if (cred != NULL && pos->cred != cred)
708 continue;
Trond Myklebust1544fa02010-03-25 13:54:49 -0400709 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
710 continue;
711 ctx = get_nfs_open_context(pos);
712 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 }
714 spin_unlock(&inode->i_lock);
715 return ctx;
716}
717
Trond Myklebustb92dccf2006-03-20 13:44:03 -0500718static void nfs_file_clear_open_context(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719{
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800720 struct inode *inode = filp->f_path.dentry->d_inode;
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400721 struct nfs_open_context *ctx = nfs_file_open_context(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
723 if (ctx) {
724 filp->private_data = NULL;
725 spin_lock(&inode->i_lock);
726 list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
727 spin_unlock(&inode->i_lock);
Chuck Leverf895c532010-02-01 14:17:50 -0500728 __put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 }
730}
731
732/*
733 * These allocate and release file read/write context information.
734 */
735int nfs_open(struct inode *inode, struct file *filp)
736{
737 struct nfs_open_context *ctx;
738 struct rpc_cred *cred;
739
Trond Myklebust98a8e322008-03-12 12:25:28 -0400740 cred = rpc_lookup_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 if (IS_ERR(cred))
742 return PTR_ERR(cred);
Trond Myklebustcd9a1c02010-09-17 10:56:50 -0400743 ctx = alloc_nfs_open_context(&filp->f_path, cred, filp->f_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 put_rpccred(cred);
745 if (ctx == NULL)
746 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 nfs_file_set_open_context(filp, ctx);
748 put_nfs_open_context(ctx);
David Howellsef79c092009-04-03 16:42:43 +0100749 nfs_fscache_set_inode_cookie(inode, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 return 0;
751}
752
753int nfs_release(struct inode *inode, struct file *filp)
754{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 nfs_file_clear_open_context(filp);
756 return 0;
757}
758
759/*
760 * This function is called whenever some part of NFS notices that
761 * the cached attributes have to be refreshed.
762 */
763int
764__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
765{
766 int status = -ESTALE;
Trond Myklebusta3cba2a2010-04-16 16:22:49 -0400767 struct nfs_fattr *fattr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 struct nfs_inode *nfsi = NFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
770 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
771 inode->i_sb->s_id, (long long)NFS_FILEID(inode));
772
Chuck Lever85233a72006-10-19 23:28:42 -0700773 if (is_bad_inode(inode))
Chuck Lever412d5822005-08-18 11:24:11 -0700774 goto out;
Trond Myklebust7fdc49c2007-09-28 19:11:33 -0400775 if (NFS_STALE(inode))
776 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
Trond Myklebusta3cba2a2010-04-16 16:22:49 -0400778 status = -ENOMEM;
779 fattr = nfs_alloc_fattr();
780 if (fattr == NULL)
781 goto out;
782
Trond Myklebust691beb12008-10-05 14:48:22 -0400783 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
Trond Myklebusta3cba2a2010-04-16 16:22:49 -0400784 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 if (status != 0) {
786 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
787 inode->i_sb->s_id,
788 (long long)NFS_FILEID(inode), status);
789 if (status == -ESTALE) {
790 nfs_zap_caches(inode);
791 if (!S_ISDIR(inode->i_mode))
Benny Halevy3a10c302008-01-23 08:58:59 +0200792 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 }
794 goto out;
795 }
796
Trond Myklebusta3cba2a2010-04-16 16:22:49 -0400797 status = nfs_refresh_inode(inode, fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 if (status) {
799 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
800 inode->i_sb->s_id,
801 (long long)NFS_FILEID(inode), status);
802 goto out;
803 }
Chuck Lever55296802005-08-18 11:24:09 -0700804
Trond Myklebust24aa1fe2005-12-03 15:20:07 -0500805 if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
Trond Myklebustada70d92005-06-22 17:16:22 +0000806 nfs_zap_acl_cache(inode);
Chuck Lever55296802005-08-18 11:24:09 -0700807
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
809 inode->i_sb->s_id,
810 (long long)NFS_FILEID(inode));
811
Chuck Lever412d5822005-08-18 11:24:11 -0700812 out:
Trond Myklebusta3cba2a2010-04-16 16:22:49 -0400813 nfs_free_fattr(fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 return status;
815}
816
817int nfs_attribute_timeout(struct inode *inode)
818{
819 struct nfs_inode *nfsi = NFS_I(inode);
820
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -0400821 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
822}
823
824static int nfs_attribute_cache_expired(struct inode *inode)
825{
Trond Myklebustb4d23142010-03-10 15:21:44 -0500826 if (nfs_have_delegated_attributes(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 return 0;
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -0400828 return nfs_attribute_timeout(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829}
830
831/**
832 * nfs_revalidate_inode - Revalidate the inode attributes
833 * @server - pointer to nfs_server struct
834 * @inode - pointer to inode struct
835 *
836 * Updates inode attribute information by retrieving the data from the server.
837 */
838int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
839{
Trond Myklebust44b11872006-05-25 01:40:59 -0400840 if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -0400841 && !nfs_attribute_cache_expired(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 return NFS_STALE(inode) ? -ESTALE : 0;
843 return __nfs_revalidate_inode(server, inode);
844}
845
Trond Myklebust1cda7072010-02-19 17:03:30 -0800846static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
Trond Myklebust717d44e2007-01-24 11:54:55 -0800847{
848 struct nfs_inode *nfsi = NFS_I(inode);
849
850 if (mapping->nrpages != 0) {
851 int ret = invalidate_inode_pages2(mapping);
852 if (ret < 0)
853 return ret;
854 }
855 spin_lock(&inode->i_lock);
856 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
Trond Myklebust2f78e432007-09-30 15:31:19 -0400857 if (S_ISDIR(inode->i_mode))
Trond Myklebust717d44e2007-01-24 11:54:55 -0800858 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
Trond Myklebust717d44e2007-01-24 11:54:55 -0800859 spin_unlock(&inode->i_lock);
860 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
David Howellsef79c092009-04-03 16:42:43 +0100861 nfs_fscache_reset_inode_cookie(inode);
Trond Myklebust717d44e2007-01-24 11:54:55 -0800862 dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
863 inode->i_sb->s_id, (long long)NFS_FILEID(inode));
864 return 0;
865}
866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867/**
Trond Myklebust7d52e862005-06-22 17:16:30 +0000868 * nfs_revalidate_mapping - Revalidate the pagecache
869 * @inode - pointer to host inode
870 * @mapping - pointer to mapping
871 */
Trond Myklebust44b11872006-05-25 01:40:59 -0400872int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
Trond Myklebust7d52e862005-06-22 17:16:30 +0000873{
874 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust44b11872006-05-25 01:40:59 -0400875 int ret = 0;
876
Trond Myklebust44b11872006-05-25 01:40:59 -0400877 if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -0400878 || nfs_attribute_cache_expired(inode)
879 || NFS_STALE(inode)) {
Trond Myklebust44b11872006-05-25 01:40:59 -0400880 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
Trond Myklebust717d44e2007-01-24 11:54:55 -0800881 if (ret < 0)
882 goto out;
Trond Myklebust7d52e862005-06-22 17:16:30 +0000883 }
Trond Myklebust717d44e2007-01-24 11:54:55 -0800884 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
885 ret = nfs_invalidate_mapping(inode, mapping);
Trond Myklebustcd9ae2b2006-10-19 23:28:40 -0700886out:
Trond Myklebust44b11872006-05-25 01:40:59 -0400887 return ret;
Trond Myklebust7d52e862005-06-22 17:16:30 +0000888}
889
Trond Myklebust27dc1cd2011-01-25 15:28:21 -0500890static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
Trond Myklebusta895b4a2006-01-03 09:55:40 +0100891{
892 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust27dc1cd2011-01-25 15:28:21 -0500893 unsigned long ret = 0;
Trond Myklebusta895b4a2006-01-03 09:55:40 +0100894
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400895 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
896 && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
897 && nfsi->change_attr == fattr->pre_change_attr) {
Trond Myklebust70ca8852007-09-30 15:21:24 -0400898 nfsi->change_attr = fattr->change_attr;
899 if (S_ISDIR(inode->i_mode))
900 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
Trond Myklebust27dc1cd2011-01-25 15:28:21 -0500901 ret |= NFS_INO_INVALID_ATTR;
Trond Myklebust70ca8852007-09-30 15:21:24 -0400902 }
Trond Myklebusta895b4a2006-01-03 09:55:40 +0100903 /* If we have atomic WCC data, we may update some attributes */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400904 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
905 && (fattr->valid & NFS_ATTR_FATTR_CTIME)
Trond Myklebust27dc1cd2011-01-25 15:28:21 -0500906 && timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
907 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
908 ret |= NFS_INO_INVALID_ATTR;
909 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400910
911 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
912 && (fattr->valid & NFS_ATTR_FATTR_MTIME)
913 && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
Trond Myklebust27dc1cd2011-01-25 15:28:21 -0500914 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
915 if (S_ISDIR(inode->i_mode))
916 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
917 ret |= NFS_INO_INVALID_ATTR;
Trond Myklebusta895b4a2006-01-03 09:55:40 +0100918 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400919 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
920 && (fattr->valid & NFS_ATTR_FATTR_SIZE)
921 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
Trond Myklebust27dc1cd2011-01-25 15:28:21 -0500922 && nfsi->npages == 0) {
923 i_size_write(inode, nfs_size_to_loff_t(fattr->size));
924 ret |= NFS_INO_INVALID_ATTR;
925 }
926 return ret;
Trond Myklebusta895b4a2006-01-03 09:55:40 +0100927}
928
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929/**
Trond Myklebust33801142005-10-27 22:12:39 -0400930 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 * @inode - pointer to inode
932 * @fattr - updated attributes
933 *
934 * Verifies the attribute cache. If we have just changed the attributes,
935 * so that fattr carries weak cache consistency data, then it may
936 * also update the ctime/mtime/change_attribute.
937 */
Trond Myklebust33801142005-10-27 22:12:39 -0400938static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939{
940 struct nfs_inode *nfsi = NFS_I(inode);
941 loff_t cur_size, new_isize;
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400942 unsigned long invalid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
Chuck Leverdc592502005-08-18 11:24:12 -0700944
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 /* Has the inode gone and changed behind our back? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400946 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 return -EIO;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400948 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
949 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400951 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
Trond Myklebustf1bb0b92006-05-25 01:40:55 -0400952 nfsi->change_attr != fattr->change_attr)
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400953 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 /* Verify a few of the more important attributes */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400956 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400957 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
Trond Myklebustca62b9c2006-03-20 13:44:07 -0500958
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400959 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
960 cur_size = i_size_read(inode);
961 new_isize = nfs_size_to_loff_t(fattr->size);
962 if (cur_size != new_isize && nfsi->npages == 0)
963 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
964 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
966 /* Have any file permissions changed? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400967 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
968 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
969 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && inode->i_uid != fattr->uid)
970 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
971 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && inode->i_gid != fattr->gid)
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400972 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973
974 /* Has the link count changed? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400975 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400976 invalid |= NFS_INO_INVALID_ATTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400978 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -0400979 invalid |= NFS_INO_INVALID_ATIME;
980
981 if (invalid != 0)
982 nfsi->cache_validity |= invalid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
Trond Myklebust33801142005-10-27 22:12:39 -0400984 nfsi->read_cache_jiffies = fattr->time_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 return 0;
986}
987
Trond Myklebusta10ad172008-09-23 17:28:41 -0400988static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
989{
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400990 if (!(fattr->valid & NFS_ATTR_FATTR_CTIME))
991 return 0;
Trond Myklebusta10ad172008-09-23 17:28:41 -0400992 return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0;
993}
994
995static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
996{
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400997 if (!(fattr->valid & NFS_ATTR_FATTR_SIZE))
998 return 0;
Trond Myklebusta10ad172008-09-23 17:28:41 -0400999 return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
1000}
1001
Trond Myklebustae05f262008-10-28 15:21:40 -04001002static atomic_long_t nfs_attr_generation_counter;
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001003
1004static unsigned long nfs_read_attr_generation_counter(void)
1005{
Trond Myklebustae05f262008-10-28 15:21:40 -04001006 return atomic_long_read(&nfs_attr_generation_counter);
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001007}
1008
1009unsigned long nfs_inc_attr_generation_counter(void)
1010{
Trond Myklebustae05f262008-10-28 15:21:40 -04001011 return atomic_long_inc_return(&nfs_attr_generation_counter);
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001012}
1013
1014void nfs_fattr_init(struct nfs_fattr *fattr)
1015{
1016 fattr->valid = 0;
1017 fattr->time_start = jiffies;
1018 fattr->gencount = nfs_inc_attr_generation_counter();
1019}
1020
Trond Myklebust2d36bfde2010-04-16 16:22:45 -04001021struct nfs_fattr *nfs_alloc_fattr(void)
1022{
1023 struct nfs_fattr *fattr;
1024
1025 fattr = kmalloc(sizeof(*fattr), GFP_NOFS);
1026 if (fattr != NULL)
1027 nfs_fattr_init(fattr);
1028 return fattr;
1029}
1030
1031struct nfs_fh *nfs_alloc_fhandle(void)
1032{
1033 struct nfs_fh *fh;
1034
1035 fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS);
1036 if (fh != NULL)
1037 fh->size = 0;
1038 return fh;
1039}
1040
Trond Myklebusta10ad172008-09-23 17:28:41 -04001041/**
1042 * nfs_inode_attrs_need_update - check if the inode attributes need updating
1043 * @inode - pointer to inode
1044 * @fattr - attributes
1045 *
1046 * Attempt to divine whether or not an RPC call reply carrying stale
1047 * attributes got scheduled after another call carrying updated ones.
1048 *
1049 * To do so, the function first assumes that a more recent ctime means
1050 * that the attributes in fattr are newer, however it also attempt to
1051 * catch the case where ctime either didn't change, or went backwards
1052 * (if someone reset the clock on the server) by looking at whether
1053 * or not this RPC call was started after the inode was last updated.
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001054 * Note also the check for wraparound of 'attr_gencount'
Trond Myklebusta10ad172008-09-23 17:28:41 -04001055 *
1056 * The function returns 'true' if it thinks the attributes in 'fattr' are
1057 * more recent than the ones cached in the inode.
1058 *
1059 */
1060static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1061{
1062 const struct nfs_inode *nfsi = NFS_I(inode);
1063
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001064 return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
Trond Myklebust03254e62008-10-09 13:27:55 -04001065 nfs_ctime_need_update(inode, fattr) ||
1066 nfs_size_need_update(inode, fattr) ||
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001067 ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
Trond Myklebusta10ad172008-09-23 17:28:41 -04001068}
1069
Trond Myklebust870a5be2008-10-05 12:07:23 -04001070static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1071{
Trond Myklebusta10ad172008-09-23 17:28:41 -04001072 if (nfs_inode_attrs_need_update(inode, fattr))
Trond Myklebust870a5be2008-10-05 12:07:23 -04001073 return nfs_update_inode(inode, fattr);
1074 return nfs_check_inode_attributes(inode, fattr);
1075}
1076
Trond Myklebust33801142005-10-27 22:12:39 -04001077/**
1078 * nfs_refresh_inode - try to update the inode attribute cache
1079 * @inode - pointer to inode
1080 * @fattr - updated attributes
1081 *
1082 * Check that an RPC call that returned attributes has not overlapped with
1083 * other recent updates of the inode metadata, then decide whether it is
1084 * safe to do a full update of the inode attributes, or whether just to
1085 * call nfs_check_inode_attributes.
1086 */
1087int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1088{
Trond Myklebust33801142005-10-27 22:12:39 -04001089 int status;
1090
1091 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1092 return 0;
1093 spin_lock(&inode->i_lock);
Trond Myklebust870a5be2008-10-05 12:07:23 -04001094 status = nfs_refresh_inode_locked(inode, fattr);
Trond Myklebust33801142005-10-27 22:12:39 -04001095 spin_unlock(&inode->i_lock);
David Howellsef79c092009-04-03 16:42:43 +01001096
Trond Myklebust33801142005-10-27 22:12:39 -04001097 return status;
1098}
1099
Trond Myklebustd65f5572008-10-05 12:27:55 -04001100static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1101{
1102 struct nfs_inode *nfsi = NFS_I(inode);
1103
1104 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
1105 if (S_ISDIR(inode->i_mode))
1106 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
1107 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1108 return 0;
1109 return nfs_refresh_inode_locked(inode, fattr);
1110}
1111
Trond Myklebustdecf4912005-10-27 22:12:39 -04001112/**
1113 * nfs_post_op_update_inode - try to update the inode attribute cache
1114 * @inode - pointer to inode
1115 * @fattr - updated attributes
1116 *
1117 * After an operation that has changed the inode metadata, mark the
1118 * attribute cache as being invalid, then try to update it.
Chuck Leverf551e442006-09-20 14:33:04 -04001119 *
1120 * NB: if the server didn't return any post op attributes, this
1121 * function will force the retrieval of attributes before the next
1122 * NFS request. Thus it should be used only for operations that
1123 * are expected to change one or more attributes, to avoid
1124 * unnecessary NFS requests and trips through nfs_update_inode().
Trond Myklebustdecf4912005-10-27 22:12:39 -04001125 */
1126int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1127{
Trond Myklebustd65f5572008-10-05 12:27:55 -04001128 int status;
Trond Myklebustdecf4912005-10-27 22:12:39 -04001129
Trond Myklebust7668fdb2007-10-01 09:59:15 -04001130 spin_lock(&inode->i_lock);
Trond Myklebustd65f5572008-10-05 12:27:55 -04001131 status = nfs_post_op_update_inode_locked(inode, fattr);
Trond Myklebust7668fdb2007-10-01 09:59:15 -04001132 spin_unlock(&inode->i_lock);
Trond Myklebust870a5be2008-10-05 12:07:23 -04001133 return status;
Trond Myklebustdecf4912005-10-27 22:12:39 -04001134}
1135
Trond Myklebust70ca8852007-09-30 15:21:24 -04001136/**
1137 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
1138 * @inode - pointer to inode
1139 * @fattr - updated attributes
1140 *
1141 * After an operation that has changed the inode metadata, mark the
1142 * attribute cache as being invalid, then try to update it. Fake up
1143 * weak cache consistency data, if none exist.
1144 *
1145 * This function is mainly designed to be used by the ->write_done() functions.
1146 */
1147int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
1148{
Trond Myklebustd65f5572008-10-05 12:27:55 -04001149 int status;
1150
1151 spin_lock(&inode->i_lock);
1152 /* Don't do a WCC update if these attributes are already stale */
1153 if ((fattr->valid & NFS_ATTR_FATTR) == 0 ||
1154 !nfs_inode_attrs_need_update(inode, fattr)) {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001155 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
1156 | NFS_ATTR_FATTR_PRESIZE
1157 | NFS_ATTR_FATTR_PREMTIME
1158 | NFS_ATTR_FATTR_PRECTIME);
Trond Myklebustd65f5572008-10-05 12:27:55 -04001159 goto out_noforce;
1160 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001161 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1162 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
Trond Myklebust70ca8852007-09-30 15:21:24 -04001163 fattr->pre_change_attr = NFS_I(inode)->change_attr;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001164 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001165 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001166 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
1167 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
Trond Myklebust70ca8852007-09-30 15:21:24 -04001168 memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001169 fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
1170 }
1171 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
1172 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
Trond Myklebust70ca8852007-09-30 15:21:24 -04001173 memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001174 fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
1175 }
1176 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
1177 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
Trond Myklebusta3d01452008-06-11 12:21:19 -04001178 fattr->pre_size = i_size_read(inode);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001179 fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001180 }
Trond Myklebustd65f5572008-10-05 12:27:55 -04001181out_noforce:
1182 status = nfs_post_op_update_inode_locked(inode, fattr);
1183 spin_unlock(&inode->i_lock);
1184 return status;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001185}
1186
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187/*
1188 * Many nfs protocol calls return the new file attributes after
1189 * an operation. Here we update the inode to reflect the state
1190 * of the server's inode.
1191 *
1192 * This is a bit tricky because we have to make sure all dirty pages
1193 * have been sent off to the server before calling invalidate_inode_pages.
1194 * To make sure no other process adds more write requests while we try
1195 * our best to flush them, we make them sleep during the attribute refresh.
1196 *
1197 * A very similar scenario holds for the dir cache.
1198 */
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001199static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200{
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -04001201 struct nfs_server *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust951a1432005-06-22 17:16:30 +00001203 loff_t cur_isize, new_isize;
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001204 unsigned long invalid = 0;
Trond Myklebust3e7d9502007-02-05 14:26:28 -08001205 unsigned long now = jiffies;
Trond Myklebust62ab4602009-08-09 15:06:19 -04001206 unsigned long save_cache_validity;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
1208 dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -07001209 __func__, inode->i_sb->s_id, inode->i_ino,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 atomic_read(&inode->i_count), fattr->valid);
1211
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001212 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
Chuck Lever325cfed2005-11-30 18:08:55 -05001213 goto out_fileid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
1215 /*
1216 * Make sure the inode's type hasn't changed.
1217 */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001218 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 goto out_changed;
1220
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -04001221 server = NFS_SERVER(inode);
Trond Myklebusta0356862007-06-05 13:26:15 -04001222 /* Update the fsid? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001223 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
Trond Myklebustc37dcd332008-03-06 12:34:50 -05001224 !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
David Howells36d43a42011-01-14 18:45:42 +00001225 !IS_AUTOMOUNT(inode))
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -04001226 server->fsid = fattr->fsid;
1227
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 /*
1229 * Update the read time so we don't revalidate too often.
1230 */
Trond Myklebust33801142005-10-27 22:12:39 -04001231 nfsi->read_cache_jiffies = fattr->time_start;
Trond Myklebust3e7d9502007-02-05 14:26:28 -08001232
Trond Myklebust62ab4602009-08-09 15:06:19 -04001233 save_cache_validity = nfsi->cache_validity;
1234 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
1235 | NFS_INO_INVALID_ATIME
1236 | NFS_INO_REVAL_FORCED
1237 | NFS_INO_REVAL_PAGECACHE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001239 /* Do atomic weak cache consistency updates */
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001240 invalid |= nfs_wcc_update_inode(inode, fattr);
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001241
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001242 /* More cache consistency checks */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001243 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
1244 if (nfsi->change_attr != fattr->change_attr) {
1245 dprintk("NFS: change_attr change on server for file %s/%ld\n",
1246 inode->i_sb->s_id, inode->i_ino);
1247 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1248 if (S_ISDIR(inode->i_mode))
1249 nfs_force_lookup_revalidate(inode);
1250 nfsi->change_attr = fattr->change_attr;
1251 }
Trond Myklebust62ab4602009-08-09 15:06:19 -04001252 } else if (server->caps & NFS_CAP_CHANGE_ATTR)
1253 invalid |= save_cache_validity;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001254
1255 if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001256 /* NFSv2/v3: Check if the mtime agrees */
1257 if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
1258 dprintk("NFS: mtime change on server for file %s/%ld\n",
1259 inode->i_sb->s_id, inode->i_ino);
1260 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
Trond Myklebustbfc69a42007-10-15 18:18:29 -04001261 if (S_ISDIR(inode->i_mode))
1262 nfs_force_lookup_revalidate(inode);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001263 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001264 }
Trond Myklebust62ab4602009-08-09 15:06:19 -04001265 } else if (server->caps & NFS_CAP_MTIME)
1266 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1267 | NFS_INO_INVALID_DATA
1268 | NFS_INO_REVAL_PAGECACHE
1269 | NFS_INO_REVAL_FORCED);
1270
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001271 if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001272 /* If ctime has changed we should definitely clear access+acl caches */
NeilBrown37d9d762009-03-11 14:10:23 -04001273 if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) {
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001274 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
NeilBrown37d9d762009-03-11 14:10:23 -04001275 /* and probably clear data for a directory too as utimes can cause
1276 * havoc with our cache.
1277 */
1278 if (S_ISDIR(inode->i_mode)) {
1279 invalid |= NFS_INO_INVALID_DATA;
1280 nfs_force_lookup_revalidate(inode);
1281 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001282 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
NeilBrown37d9d762009-03-11 14:10:23 -04001283 }
Trond Myklebust62ab4602009-08-09 15:06:19 -04001284 } else if (server->caps & NFS_CAP_CTIME)
1285 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1286 | NFS_INO_INVALID_ACCESS
1287 | NFS_INO_INVALID_ACL
1288 | NFS_INO_REVAL_FORCED);
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001289
Trond Myklebust951a1432005-06-22 17:16:30 +00001290 /* Check if our cached file size is stale */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001291 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1292 new_isize = nfs_size_to_loff_t(fattr->size);
1293 cur_isize = i_size_read(inode);
1294 if (new_isize != cur_isize) {
1295 /* Do we perhaps have any outstanding writes, or has
1296 * the file grown beyond our last write? */
1297 if (nfsi->npages == 0 || new_isize > cur_isize) {
1298 i_size_write(inode, new_isize);
1299 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1300 }
1301 dprintk("NFS: isize change on server for file %s/%ld\n",
1302 inode->i_sb->s_id, inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 }
Trond Myklebust62ab4602009-08-09 15:06:19 -04001304 } else
1305 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1306 | NFS_INO_REVAL_PAGECACHE
1307 | NFS_INO_REVAL_FORCED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001310 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
1311 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
Trond Myklebust62ab4602009-08-09 15:06:19 -04001312 else if (server->caps & NFS_CAP_ATIME)
1313 invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME
1314 | NFS_INO_REVAL_FORCED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001316 if (fattr->valid & NFS_ATTR_FATTR_MODE) {
1317 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
Trond Myklebust9b4b3512010-02-03 08:27:35 -05001318 umode_t newmode = inode->i_mode & S_IFMT;
1319 newmode |= fattr->mode & S_IALLUGO;
1320 inode->i_mode = newmode;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001321 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001322 }
Trond Myklebust62ab4602009-08-09 15:06:19 -04001323 } else if (server->caps & NFS_CAP_MODE)
1324 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1325 | NFS_INO_INVALID_ACCESS
1326 | NFS_INO_INVALID_ACL
1327 | NFS_INO_REVAL_FORCED);
1328
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001329 if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
1330 if (inode->i_uid != fattr->uid) {
1331 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1332 inode->i_uid = fattr->uid;
1333 }
Trond Myklebust62ab4602009-08-09 15:06:19 -04001334 } else if (server->caps & NFS_CAP_OWNER)
1335 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1336 | NFS_INO_INVALID_ACCESS
1337 | NFS_INO_INVALID_ACL
1338 | NFS_INO_REVAL_FORCED);
1339
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001340 if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
1341 if (inode->i_gid != fattr->gid) {
1342 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1343 inode->i_gid = fattr->gid;
1344 }
Trond Myklebust62ab4602009-08-09 15:06:19 -04001345 } else if (server->caps & NFS_CAP_OWNER_GROUP)
1346 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1347 | NFS_INO_INVALID_ACCESS
1348 | NFS_INO_INVALID_ACL
1349 | NFS_INO_REVAL_FORCED);
Trond Myklebust921615f2008-10-14 19:23:07 -04001350
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001351 if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
1352 if (inode->i_nlink != fattr->nlink) {
1353 invalid |= NFS_INO_INVALID_ATTR;
1354 if (S_ISDIR(inode->i_mode))
1355 invalid |= NFS_INO_INVALID_DATA;
1356 inode->i_nlink = fattr->nlink;
1357 }
Trond Myklebust62ab4602009-08-09 15:06:19 -04001358 } else if (server->caps & NFS_CAP_NLINK)
1359 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1360 | NFS_INO_REVAL_FORCED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001362 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 /*
1364 * report the blocks in 512byte units
1365 */
1366 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001368 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
1369 inode->i_blocks = fattr->du.nfs2.blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
1371 /* Update attrtimeo value if we're out of the unstable period */
1372 if (invalid & NFS_INO_INVALID_ATTR) {
Chuck Lever91d5b472006-03-20 13:44:14 -05001373 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
Trond Myklebust3e7d9502007-02-05 14:26:28 -08001375 nfsi->attrtimeo_timestamp = now;
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001376 nfsi->attr_gencount = nfs_inc_attr_generation_counter();
Trond Myklebust6d2b2962007-10-01 18:57:50 -04001377 } else {
Peter Staubach64672d52008-12-23 15:21:56 -05001378 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
Trond Myklebust6d2b2962007-10-01 18:57:50 -04001379 if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
1380 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
1381 nfsi->attrtimeo_timestamp = now;
1382 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 }
Trond Myklebustf2115dc2007-08-15 12:49:17 -04001384 invalid &= ~NFS_INO_INVALID_ATTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 /* Don't invalidate the data if we were to blame */
1386 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
1387 || S_ISLNK(inode->i_mode)))
1388 invalid &= ~NFS_INO_INVALID_DATA;
Trond Myklebust412c77c2007-07-03 16:10:55 -04001389 if (!nfs_have_delegation(inode, FMODE_READ) ||
Trond Myklebust62ab4602009-08-09 15:06:19 -04001390 (save_cache_validity & NFS_INO_REVAL_FORCED))
Chuck Lever55296802005-08-18 11:24:09 -07001391 nfsi->cache_validity |= invalid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392
1393 return 0;
1394 out_changed:
1395 /*
1396 * Big trouble! The inode has become a different object.
1397 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -07001399 __func__, inode->i_ino, inode->i_mode, fattr->mode);
Trond Myklebustb37b03b2005-11-25 17:10:06 -05001400 out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 /*
1402 * No need to worry about unhashing the dentry, as the
1403 * lookup validation will know that the inode is bad.
1404 * (But we fall through to invalidate the caches.)
1405 */
1406 nfs_invalidate_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 return -ESTALE;
Chuck Lever325cfed2005-11-30 18:08:55 -05001408
1409 out_fileid:
1410 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
1411 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
David Howells54ceac42006-08-22 20:06:13 -04001412 NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id,
Chuck Lever325cfed2005-11-30 18:08:55 -05001413 (long long)nfsi->fileid, (long long)fattr->fileid);
1414 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415}
1416
Trond Myklebust55a97592006-06-09 09:34:19 -04001417
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418#ifdef CONFIG_NFS_V4
1419
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420/*
1421 * Clean out any remaining NFSv4 state that might be left over due
1422 * to open() calls that passed nfs_atomic_lookup, but failed to call
1423 * nfs_open().
1424 */
Al Virob57922d2010-06-07 14:34:48 -04001425void nfs4_evict_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426{
Fred Isaman4541d162011-01-06 11:36:23 +00001427 pnfs_destroy_layout(NFS_I(inode));
Al Virob57922d2010-06-07 14:34:48 -04001428 truncate_inode_pages(&inode->i_data, 0);
1429 end_writeback(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 /* If we are holding a delegation, return it! */
Trond Myklebuste6f81072008-01-24 18:14:34 -05001431 nfs_inode_return_delegation_noreclaim(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 /* First call standard NFS clear_inode() code */
1433 nfs_clear_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435#endif
1436
David Howellsf7b422b2006-06-09 09:34:33 -04001437struct inode *nfs_alloc_inode(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438{
1439 struct nfs_inode *nfsi;
Christoph Lametere94b1762006-12-06 20:33:17 -08001440 nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 if (!nfsi)
1442 return NULL;
Chuck Lever55296802005-08-18 11:24:09 -07001443 nfsi->flags = 0UL;
1444 nfsi->cache_validity = 0UL;
Trond Myklebust458818e2005-06-22 17:16:27 +00001445#ifdef CONFIG_NFS_V3_ACL
1446 nfsi->acl_access = ERR_PTR(-EAGAIN);
1447 nfsi->acl_default = ERR_PTR(-EAGAIN);
1448#endif
J. Bruce Fieldse50a1c22005-06-22 17:16:23 +00001449#ifdef CONFIG_NFS_V4
1450 nfsi->nfs4_acl = NULL;
1451#endif /* CONFIG_NFS_V4 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 return &nfsi->vfs_inode;
1453}
1454
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +11001455static void nfs_i_callback(struct rcu_head *head)
1456{
1457 struct inode *inode = container_of(head, struct inode, i_rcu);
1458 INIT_LIST_HEAD(&inode->i_dentry);
1459 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
1460}
1461
David Howellsf7b422b2006-06-09 09:34:33 -04001462void nfs_destroy_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +11001464 call_rcu(&inode->i_rcu, nfs_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465}
1466
Andrew Mortond75d5412006-06-25 02:41:26 -07001467static inline void nfs4_init_once(struct nfs_inode *nfsi)
1468{
1469#ifdef CONFIG_NFS_V4
1470 INIT_LIST_HEAD(&nfsi->open_states);
1471 nfsi->delegation = NULL;
1472 nfsi->delegation_state = 0;
1473 init_rwsem(&nfsi->rwsem);
Benny Halevye5e94012010-10-20 00:18:01 -04001474 nfsi->layout = NULL;
Fred Isamane0c2b382011-03-23 13:27:53 +00001475 atomic_set(&nfsi->commits_outstanding, 0);
Andrew Mortond75d5412006-06-25 02:41:26 -07001476#endif
1477}
David Howellsf7b422b2006-06-09 09:34:33 -04001478
Alexey Dobriyan51cc5062008-07-25 19:45:34 -07001479static void init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480{
1481 struct nfs_inode *nfsi = (struct nfs_inode *) foo;
1482
Christoph Lametera35afb82007-05-16 22:10:57 -07001483 inode_init_once(&nfsi->vfs_inode);
Christoph Lametera35afb82007-05-16 22:10:57 -07001484 INIT_LIST_HEAD(&nfsi->open_files);
1485 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
1486 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
1487 INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
Christoph Lametera35afb82007-05-16 22:10:57 -07001488 nfsi->npages = 0;
Trond Myklebustff778d02010-02-19 16:53:39 -08001489 nfsi->ncommit = 0;
Trond Myklebust565277f2007-10-15 18:17:53 -04001490 atomic_set(&nfsi->silly_count, 1);
1491 INIT_HLIST_HEAD(&nfsi->silly_list);
1492 init_waitqueue_head(&nfsi->waitqueue);
Christoph Lametera35afb82007-05-16 22:10:57 -07001493 nfs4_init_once(nfsi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494}
Paul Mundt20c2df82007-07-20 10:11:58 +09001495
David Howellsf7b422b2006-06-09 09:34:33 -04001496static int __init nfs_init_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497{
1498 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
1499 sizeof(struct nfs_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -08001500 0, (SLAB_RECLAIM_ACCOUNT|
1501 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +09001502 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 if (nfs_inode_cachep == NULL)
1504 return -ENOMEM;
1505
1506 return 0;
1507}
1508
David Brownell266bee82006-06-27 12:59:15 -07001509static void nfs_destroy_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001511 kmem_cache_destroy(nfs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512}
1513
Trond Myklebust57460062008-02-19 20:04:22 -05001514struct workqueue_struct *nfsiod_workqueue;
1515
1516/*
1517 * start up the nfsiod workqueue
1518 */
1519static int nfsiod_start(void)
1520{
1521 struct workqueue_struct *wq;
1522 dprintk("RPC: creating workqueue nfsiod\n");
Tejun Heoada609e2011-01-25 14:35:54 +01001523 wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
Trond Myklebust57460062008-02-19 20:04:22 -05001524 if (wq == NULL)
1525 return -ENOMEM;
1526 nfsiod_workqueue = wq;
1527 return 0;
1528}
1529
1530/*
1531 * Destroy the nfsiod workqueue
1532 */
1533static void nfsiod_stop(void)
1534{
1535 struct workqueue_struct *wq;
1536
1537 wq = nfsiod_workqueue;
1538 if (wq == NULL)
1539 return;
1540 nfsiod_workqueue = NULL;
1541 destroy_workqueue(wq);
1542}
1543
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544/*
1545 * Initialize NFS
1546 */
1547static int __init init_nfs_fs(void)
1548{
1549 int err;
1550
Bryan Schumaker955a8572010-09-29 15:41:49 -04001551 err = nfs_idmap_init();
1552 if (err < 0)
1553 goto out9;
1554
Trond Myklebuste571cbf2009-08-19 18:12:27 -04001555 err = nfs_dns_resolver_init();
1556 if (err < 0)
1557 goto out8;
1558
David Howells8ec442a2009-04-03 16:42:42 +01001559 err = nfs_fscache_register();
1560 if (err < 0)
1561 goto out7;
1562
Trond Myklebust57460062008-02-19 20:04:22 -05001563 err = nfsiod_start();
1564 if (err)
1565 goto out6;
1566
David Howells6aaca562006-08-22 20:06:13 -04001567 err = nfs_fs_proc_init();
1568 if (err)
1569 goto out5;
1570
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 err = nfs_init_nfspagecache();
1572 if (err)
1573 goto out4;
1574
1575 err = nfs_init_inodecache();
1576 if (err)
1577 goto out3;
1578
1579 err = nfs_init_readpagecache();
1580 if (err)
1581 goto out2;
1582
1583 err = nfs_init_writepagecache();
1584 if (err)
1585 goto out1;
1586
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 err = nfs_init_directcache();
1588 if (err)
1589 goto out0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590
1591#ifdef CONFIG_PROC_FS
1592 rpc_proc_register(&nfs_rpcstat);
1593#endif
David Howellsf7b422b2006-06-09 09:34:33 -04001594 if ((err = register_nfs_fs()) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 goto out;
1596 return 0;
1597out:
1598#ifdef CONFIG_PROC_FS
1599 rpc_proc_unregister("nfs");
1600#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 nfs_destroy_directcache();
Chuck Lever6b59a752005-11-30 18:08:19 -05001602out0:
Chuck Lever6b59a752005-11-30 18:08:19 -05001603 nfs_destroy_writepagecache();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604out1:
1605 nfs_destroy_readpagecache();
1606out2:
1607 nfs_destroy_inodecache();
1608out3:
1609 nfs_destroy_nfspagecache();
1610out4:
David Howells6aaca562006-08-22 20:06:13 -04001611 nfs_fs_proc_exit();
1612out5:
Trond Myklebust57460062008-02-19 20:04:22 -05001613 nfsiod_stop();
1614out6:
David Howells8ec442a2009-04-03 16:42:42 +01001615 nfs_fscache_unregister();
1616out7:
Trond Myklebuste571cbf2009-08-19 18:12:27 -04001617 nfs_dns_resolver_destroy();
1618out8:
Bryan Schumaker955a8572010-09-29 15:41:49 -04001619 nfs_idmap_quit();
1620out9:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 return err;
1622}
1623
1624static void __exit exit_nfs_fs(void)
1625{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 nfs_destroy_directcache();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 nfs_destroy_writepagecache();
1628 nfs_destroy_readpagecache();
1629 nfs_destroy_inodecache();
1630 nfs_destroy_nfspagecache();
David Howells8ec442a2009-04-03 16:42:42 +01001631 nfs_fscache_unregister();
Trond Myklebuste571cbf2009-08-19 18:12:27 -04001632 nfs_dns_resolver_destroy();
Bryan Schumaker955a8572010-09-29 15:41:49 -04001633 nfs_idmap_quit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634#ifdef CONFIG_PROC_FS
1635 rpc_proc_unregister("nfs");
1636#endif
Andy Adamsonf4eecd52011-01-06 02:04:30 +00001637 nfs_cleanup_cb_ident_idr();
David Howellsf7b422b2006-06-09 09:34:33 -04001638 unregister_nfs_fs();
David Howells6aaca562006-08-22 20:06:13 -04001639 nfs_fs_proc_exit();
Trond Myklebust57460062008-02-19 20:04:22 -05001640 nfsiod_stop();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641}
1642
1643/* Not quite true; I just maintain it */
1644MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1645MODULE_LICENSE("GPL");
Trond Myklebustf43bf0b2007-10-09 12:01:04 -04001646module_param(enable_ino64, bool, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
1648module_init(init_nfs_fs)
1649module_exit(exit_nfs_fs)