]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - fs/nfs/inode.c
kmemcg: account certain kmem allocations to memcg
[mirror_ubuntu-hirsute-kernel.git] / fs / nfs / inode.c
CommitLineData
1da177e4
LT
1/*
2 * linux/fs/nfs/inode.c
3 *
4 * Copyright (C) 1992 Rick Sladkey
5 *
6 * nfs inode and superblock handling functions
7 *
526719ba 8 * Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
1da177e4
LT
9 * experimental NFS changes. Modularisation taken straight from SYS5 fs.
10 *
11 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
12 * J.S.Peatfield@damtp.cam.ac.uk
13 *
14 */
15
1da177e4
LT
16#include <linux/module.h>
17#include <linux/init.h>
e8edc6e0 18#include <linux/sched.h>
1da177e4
LT
19#include <linux/time.h>
20#include <linux/kernel.h>
21#include <linux/mm.h>
22#include <linux/string.h>
23#include <linux/stat.h>
24#include <linux/errno.h>
25#include <linux/unistd.h>
26#include <linux/sunrpc/clnt.h>
27#include <linux/sunrpc/stats.h>
4ece3a2d 28#include <linux/sunrpc/metrics.h>
1da177e4
LT
29#include <linux/nfs_fs.h>
30#include <linux/nfs_mount.h>
31#include <linux/nfs4_mount.h>
32#include <linux/lockd/bind.h>
1da177e4
LT
33#include <linux/seq_file.h>
34#include <linux/mount.h>
1da177e4 35#include <linux/vfs.h>
9cdb3883
MN
36#include <linux/inet.h>
37#include <linux/nfs_xdr.h>
5a0e3ad6 38#include <linux/slab.h>
3fa0b4e2 39#include <linux/compat.h>
d310310c 40#include <linux/freezer.h>
1da177e4 41
1da177e4
LT
42#include <asm/uaccess.h>
43
4ce79717 44#include "nfs4_fs.h"
a72b4422 45#include "callback.h"
1da177e4 46#include "delegation.h"
d9ef5a8c 47#include "iostat.h"
f7b422b1 48#include "internal.h"
8ec442ae 49#include "fscache.h"
e5e94017 50#include "pnfs.h"
ab7017a3 51#include "nfs.h"
1b340d01 52#include "netns.h"
1da177e4 53
f4ce1299
TM
54#include "nfstrace.h"
55
1da177e4 56#define NFSDBG_FACILITY NFSDBG_VFS
1da177e4 57
f43bf0be
TM
58#define NFS_64_BIT_INODE_NUMBERS_ENABLED 1
59
60/* Default is to see 64-bit inode numbers */
90ab5ee9 61static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
f43bf0be 62
1da177e4 63static void nfs_invalidate_inode(struct inode *);
24aa1fe6 64static int nfs_update_inode(struct inode *, struct nfs_fattr *);
1da177e4 65
e18b890b 66static struct kmem_cache * nfs_inode_cachep;
b7fa0554 67
1da177e4
LT
68static inline unsigned long
69nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
70{
71 return nfs_fileid_to_ino_t(fattr->fileid);
72}
73
72cb77f4
TM
74/**
75 * nfs_wait_bit_killable - helper for functions that are sleeping on bit locks
76 * @word: long word containing the bit lock
77 */
dfd01f02 78int nfs_wait_bit_killable(struct wait_bit_key *key, int mode)
72cb77f4 79{
416ad3c9 80 freezable_schedule_unsafe();
dfd01f02
PZ
81 if (signal_pending_state(mode, current))
82 return -ERESTARTSYS;
72cb77f4
TM
83 return 0;
84}
89d77c8f 85EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
72cb77f4 86
f43bf0be
TM
87/**
88 * nfs_compat_user_ino64 - returns the user-visible inode number
89 * @fileid: 64-bit fileid
90 *
91 * This function returns a 32-bit inode number if the boot parameter
92 * nfs.enable_ino64 is zero.
93 */
94u64 nfs_compat_user_ino64(u64 fileid)
95{
3fa0b4e2
FF
96#ifdef CONFIG_COMPAT
97 compat_ulong_t ino;
98#else
99 unsigned long ino;
100#endif
f43bf0be
TM
101
102 if (enable_ino64)
103 return fileid;
104 ino = fileid;
105 if (sizeof(ino) < sizeof(fileid))
106 ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
107 return ino;
108}
109
eed99357
TM
110int nfs_drop_inode(struct inode *inode)
111{
112 return NFS_STALE(inode) || generic_drop_inode(inode);
113}
114EXPORT_SYMBOL_GPL(nfs_drop_inode);
115
19d87ca3 116void nfs_clear_inode(struct inode *inode)
1da177e4 117{
da6d503a
TM
118 /*
119 * The following should never happen...
120 */
f48407dd
TM
121 WARN_ON_ONCE(nfs_have_writebacks(inode));
122 WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files));
ada70d94 123 nfs_zap_acl_cache(inode);
1c3c07e9 124 nfs_access_zap_cache(inode);
f1fe29b4 125 nfs_fscache_clear_inode(inode);
1da177e4 126}
89d77c8f 127EXPORT_SYMBOL_GPL(nfs_clear_inode);
1da177e4 128
b57922d9
AV
129void nfs_evict_inode(struct inode *inode)
130{
91b0abe3 131 truncate_inode_pages_final(&inode->i_data);
dbd5768f 132 clear_inode(inode);
b57922d9
AV
133 nfs_clear_inode(inode);
134}
135
9e1681c2 136int nfs_sync_inode(struct inode *inode)
4d346bea
TM
137{
138 nfs_inode_dio_wait(inode);
139 return nfs_wb_all(inode);
140}
9e1681c2 141EXPORT_SYMBOL_GPL(nfs_sync_inode);
4d346bea 142
29884df0
TM
143/**
144 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
145 */
146int nfs_sync_mapping(struct address_space *mapping)
147{
5cf95214 148 int ret = 0;
29884df0 149
5cf95214
TM
150 if (mapping->nrpages != 0) {
151 unmap_mapping_range(mapping, 0, 0, 0);
152 ret = nfs_wb_all(mapping->host);
153 }
29884df0
TM
154 return ret;
155}
156
6edf9609
TM
157static void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
158{
159 struct nfs_inode *nfsi = NFS_I(inode);
160
161 if (inode->i_mapping->nrpages == 0)
162 flags &= ~NFS_INO_INVALID_DATA;
163 nfsi->cache_validity |= flags;
164 if (flags & NFS_INO_INVALID_DATA)
165 nfs_fscache_invalidate(inode);
166}
167
1da177e4
LT
168/*
169 * Invalidate the local caches
170 */
b37b03b7 171static void nfs_zap_caches_locked(struct inode *inode)
1da177e4
LT
172{
173 struct nfs_inode *nfsi = NFS_I(inode);
174 int mode = inode->i_mode;
175
91d5b470
CL
176 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
177
c7c20973
TM
178 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
179 nfsi->attrtimeo_timestamp = jiffies;
1da177e4 180
c3f52af3 181 memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
de242c0b 182 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
6edf9609 183 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
aa9c2669
DQ
184 | NFS_INO_INVALID_DATA
185 | NFS_INO_INVALID_ACCESS
186 | NFS_INO_INVALID_ACL
6edf9609 187 | NFS_INO_REVAL_PAGECACHE);
aa9c2669 188 } else
6edf9609 189 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
aa9c2669
DQ
190 | NFS_INO_INVALID_ACCESS
191 | NFS_INO_INVALID_ACL
6edf9609 192 | NFS_INO_REVAL_PAGECACHE);
fd1defc2 193 nfs_zap_label_cache_locked(nfsi);
b37b03b7 194}
dc59250c 195
b37b03b7
TM
196void nfs_zap_caches(struct inode *inode)
197{
198 spin_lock(&inode->i_lock);
199 nfs_zap_caches_locked(inode);
dc59250c 200 spin_unlock(&inode->i_lock);
ada70d94
TM
201}
202
cd9ae2b6
TM
203void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
204{
205 if (mapping->nrpages != 0) {
206 spin_lock(&inode->i_lock);
6edf9609 207 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
cd9ae2b6
TM
208 spin_unlock(&inode->i_lock);
209 }
210}
211
f41f7418 212void nfs_zap_acl_cache(struct inode *inode)
ada70d94
TM
213{
214 void (*clear_acl_cache)(struct inode *);
215
216 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
217 if (clear_acl_cache != NULL)
218 clear_acl_cache(inode);
dc59250c 219 spin_lock(&inode->i_lock);
55296809 220 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
dc59250c 221 spin_unlock(&inode->i_lock);
1da177e4 222}
1c606fb7 223EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
1da177e4 224
c4812998
TM
225void nfs_invalidate_atime(struct inode *inode)
226{
227 spin_lock(&inode->i_lock);
6edf9609 228 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
c4812998
TM
229 spin_unlock(&inode->i_lock);
230}
ddda8e0a 231EXPORT_SYMBOL_GPL(nfs_invalidate_atime);
c4812998 232
1da177e4 233/*
b37b03b7
TM
234 * Invalidate, but do not unhash, the inode.
235 * NB: must be called with inode->i_lock held!
1da177e4 236 */
b37b03b7 237static void nfs_invalidate_inode(struct inode *inode)
1da177e4 238{
3a10c30a 239 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
b37b03b7 240 nfs_zap_caches_locked(inode);
1da177e4
LT
241}
242
243struct nfs_find_desc {
244 struct nfs_fh *fh;
245 struct nfs_fattr *fattr;
246};
247
248/*
249 * In NFSv3 we can have 64bit inode numbers. In order to support
250 * this, and re-exported directories (also seen in NFSv2)
251 * we are forced to allow 2 different inodes to have the same
252 * i_ino.
253 */
254static int
255nfs_find_actor(struct inode *inode, void *opaque)
256{
257 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
258 struct nfs_fh *fh = desc->fh;
259 struct nfs_fattr *fattr = desc->fattr;
260
261 if (NFS_FILEID(inode) != fattr->fileid)
262 return 0;
f6488c9b
JL
263 if ((S_IFMT & inode->i_mode) != (S_IFMT & fattr->mode))
264 return 0;
1da177e4
LT
265 if (nfs_compare_fh(NFS_FH(inode), fh))
266 return 0;
267 if (is_bad_inode(inode) || NFS_STALE(inode))
268 return 0;
269 return 1;
270}
271
272static int
273nfs_init_locked(struct inode *inode, void *opaque)
274{
275 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
276 struct nfs_fattr *fattr = desc->fattr;
277
99fadcd7 278 set_nfs_fileid(inode, fattr->fileid);
1da177e4
LT
279 nfs_copy_fh(NFS_FH(inode), desc->fh);
280 return 0;
281}
282
e058f70b 283#ifdef CONFIG_NFS_V4_SECURITY_LABEL
fd1defc2
TM
284static void nfs_clear_label_invalid(struct inode *inode)
285{
286 spin_lock(&inode->i_lock);
287 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_LABEL;
288 spin_unlock(&inode->i_lock);
289}
290
aa9c2669
DQ
291void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
292 struct nfs4_label *label)
293{
294 int error;
295
296 if (label == NULL)
297 return;
298
aa9c2669
DQ
299 if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) && inode->i_security) {
300 error = security_inode_notifysecctx(inode, label->label,
301 label->len);
302 if (error)
303 printk(KERN_ERR "%s() %s %d "
304 "security_inode_notifysecctx() %d\n",
305 __func__,
306 (char *)label->label,
307 label->len, error);
fd1defc2 308 nfs_clear_label_invalid(inode);
aa9c2669
DQ
309 }
310}
311
e058f70b
SD
312struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
313{
314 struct nfs4_label *label = NULL;
315 int minor_version = server->nfs_client->cl_minorversion;
316
317 if (minor_version < 2)
318 return label;
319
320 if (!(server->caps & NFS_CAP_SECURITY_LABEL))
321 return label;
322
323 label = kzalloc(sizeof(struct nfs4_label), flags);
324 if (label == NULL)
325 return ERR_PTR(-ENOMEM);
326
327 label->label = kzalloc(NFS4_MAXLABELLEN, flags);
328 if (label->label == NULL) {
329 kfree(label);
330 return ERR_PTR(-ENOMEM);
331 }
332 label->len = NFS4_MAXLABELLEN;
333
334 return label;
335}
336EXPORT_SYMBOL_GPL(nfs4_label_alloc);
aa9c2669 337#else
829e57d7 338void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
aa9c2669
DQ
339 struct nfs4_label *label)
340{
341}
e058f70b 342#endif
aa9c2669 343EXPORT_SYMBOL_GPL(nfs_setsecurity);
e058f70b 344
1da177e4
LT
345/*
346 * This is our front-end to iget that looks up inodes by file handle
347 * instead of inode number.
348 */
349struct inode *
1775fd3e 350nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, struct nfs4_label *label)
1da177e4
LT
351{
352 struct nfs_find_desc desc = {
353 .fh = fh,
354 .fattr = fattr
355 };
03f28e3a 356 struct inode *inode = ERR_PTR(-ENOENT);
1da177e4
LT
357 unsigned long hash;
358
7ebb9315
BS
359 nfs_attr_check_mountpoint(sb, fattr);
360
2ef47eb1
AS
361 if (nfs_attr_use_mounted_on_fileid(fattr))
362 fattr->fileid = fattr->mounted_on_fileid;
363 else if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0)
1da177e4 364 goto out_no_inode;
9e6e70f8 365 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
1da177e4 366 goto out_no_inode;
1da177e4
LT
367
368 hash = nfs_fattr_to_ino_t(fattr);
369
03f28e3a
TM
370 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
371 if (inode == NULL) {
372 inode = ERR_PTR(-ENOMEM);
1da177e4 373 goto out_no_inode;
03f28e3a 374 }
1da177e4
LT
375
376 if (inode->i_state & I_NEW) {
377 struct nfs_inode *nfsi = NFS_I(inode);
b0c4fddc 378 unsigned long now = jiffies;
1da177e4
LT
379
380 /* We set i_ino for the few things that still rely on it,
381 * such as stat(2) */
382 inode->i_ino = hash;
383
384 /* We can't support update_atime(), since the server will reset it */
385 inode->i_flags |= S_NOATIME|S_NOCMTIME;
386 inode->i_mode = fattr->mode;
62ab460c
TM
387 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
388 && nfs_server_capable(inode, NFS_CAP_MODE))
6edf9609 389 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
1da177e4
LT
390 /* Why so? Because we want revalidate for devices/FIFOs, and
391 * that's precisely what we have in nfs_file_inode_operations.
392 */
8fa5c000 393 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
1da177e4 394 if (S_ISREG(inode->i_mode)) {
1788ea6e 395 inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
1da177e4 396 inode->i_data.a_ops = &nfs_file_aops;
1da177e4 397 } else if (S_ISDIR(inode->i_mode)) {
8fa5c000 398 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
1da177e4 399 inode->i_fop = &nfs_dir_operations;
11de3b11 400 inode->i_data.a_ops = &nfs_dir_aops;
55a97593 401 /* Deal with crossing mountpoints */
7ebb9315
BS
402 if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
403 fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
6b97fd3d
MN
404 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
405 inode->i_op = &nfs_referral_inode_operations;
406 else
407 inode->i_op = &nfs_mountpoint_inode_operations;
55a97593 408 inode->i_fop = NULL;
36d43a43 409 inode->i_flags |= S_AUTOMOUNT;
55a97593 410 }
21fc61c7 411 } else if (S_ISLNK(inode->i_mode)) {
1da177e4 412 inode->i_op = &nfs_symlink_inode_operations;
21fc61c7
AV
413 inode_nohighmem(inode);
414 } else
1da177e4
LT
415 init_special_inode(inode, inode->i_mode, fattr->rdev);
416
9e6e70f8
TM
417 memset(&inode->i_atime, 0, sizeof(inode->i_atime));
418 memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
419 memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
a9a4a87a 420 inode->i_version = 0;
9e6e70f8 421 inode->i_size = 0;
6d6b77f1 422 clear_nlink(inode);
9ff593c4
EB
423 inode->i_uid = make_kuid(&init_user_ns, -2);
424 inode->i_gid = make_kgid(&init_user_ns, -2);
9e6e70f8
TM
425 inode->i_blocks = 0;
426 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
2701d086
AA
427 nfsi->write_io = 0;
428 nfsi->read_io = 0;
9e6e70f8 429
33801147 430 nfsi->read_cache_jiffies = fattr->time_start;
4704f0e2 431 nfsi->attr_gencount = fattr->gencount;
9e6e70f8
TM
432 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
433 inode->i_atime = fattr->atime;
62ab460c 434 else if (nfs_server_capable(inode, NFS_CAP_ATIME))
6edf9609 435 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
9e6e70f8
TM
436 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
437 inode->i_mtime = fattr->mtime;
62ab460c 438 else if (nfs_server_capable(inode, NFS_CAP_MTIME))
6edf9609 439 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
9e6e70f8
TM
440 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
441 inode->i_ctime = fattr->ctime;
62ab460c 442 else if (nfs_server_capable(inode, NFS_CAP_CTIME))
6edf9609 443 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
9e6e70f8 444 if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
a9a4a87a 445 inode->i_version = fattr->change_attr;
cd812599 446 else
5c675d64
TM
447 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
448 | NFS_INO_REVAL_PAGECACHE);
9e6e70f8
TM
449 if (fattr->valid & NFS_ATTR_FATTR_SIZE)
450 inode->i_size = nfs_size_to_loff_t(fattr->size);
62ab460c 451 else
6edf9609
TM
452 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
453 | NFS_INO_REVAL_PAGECACHE);
9e6e70f8 454 if (fattr->valid & NFS_ATTR_FATTR_NLINK)
bfe86848 455 set_nlink(inode, fattr->nlink);
62ab460c 456 else if (nfs_server_capable(inode, NFS_CAP_NLINK))
6edf9609 457 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
9e6e70f8
TM
458 if (fattr->valid & NFS_ATTR_FATTR_OWNER)
459 inode->i_uid = fattr->uid;
62ab460c 460 else if (nfs_server_capable(inode, NFS_CAP_OWNER))
6edf9609 461 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
9e6e70f8
TM
462 if (fattr->valid & NFS_ATTR_FATTR_GROUP)
463 inode->i_gid = fattr->gid;
62ab460c 464 else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP))
6edf9609 465 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
9e6e70f8
TM
466 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
467 inode->i_blocks = fattr->du.nfs2.blocks;
468 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
1da177e4
LT
469 /*
470 * report the blocks in 512byte units
471 */
472 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
1da177e4 473 }
aa9c2669
DQ
474
475 nfs_setsecurity(inode, fattr, label);
476
1da177e4 477 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
b0c4fddc 478 nfsi->attrtimeo_timestamp = now;
1c3c07e9 479 nfsi->access_cache = RB_ROOT;
1da177e4 480
f1fe29b4 481 nfs_fscache_init_inode(inode);
ef79c097 482
1da177e4
LT
483 unlock_new_inode(inode);
484 } else
485 nfs_refresh_inode(inode, fattr);
1e8968c5 486 dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n",
1da177e4 487 inode->i_sb->s_id,
1e8968c5 488 (unsigned long long)NFS_FILEID(inode),
4f1abd22 489 nfs_display_fhandle_hash(fh),
1da177e4
LT
490 atomic_read(&inode->i_count));
491
492out:
493 return inode;
494
495out_no_inode:
03f28e3a 496 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
1da177e4
LT
497 goto out;
498}
89d77c8f 499EXPORT_SYMBOL_GPL(nfs_fhget);
1da177e4 500
536e43d1 501#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE|ATTR_OPEN)
1da177e4
LT
502
503int
504nfs_setattr(struct dentry *dentry, struct iattr *attr)
505{
2b0143b5 506 struct inode *inode = d_inode(dentry);
987f8dfc 507 struct nfs_fattr *fattr;
ae57ca0f 508 int error = 0;
1da177e4 509
91d5b470
CL
510 nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
511
188b95dd
JL
512 /* skip mode change if it's just for clearing setuid/setgid */
513 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
514 attr->ia_valid &= ~ATTR_MODE;
515
1da177e4 516 if (attr->ia_valid & ATTR_SIZE) {
08a899d5
CH
517 BUG_ON(!S_ISREG(inode->i_mode));
518
ae57ca0f
KM
519 error = inode_newsize_ok(inode, attr->ia_size);
520 if (error)
521 return error;
522
523 if (attr->ia_size == i_size_read(inode))
1da177e4
LT
524 attr->ia_valid &= ~ATTR_SIZE;
525 }
526
527 /* Optimization: if the end result is no change, don't RPC */
528 attr->ia_valid &= NFS_VALID_ATTRS;
536e43d1 529 if ((attr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
1da177e4
LT
530 return 0;
531
f4ce1299
TM
532 trace_nfs_setattr_enter(inode);
533
755c1e20 534 /* Write all dirty data */
4d346bea
TM
535 if (S_ISREG(inode->i_mode))
536 nfs_sync_inode(inode);
987f8dfc
TM
537
538 fattr = nfs_alloc_fattr();
ae57ca0f
KM
539 if (fattr == NULL) {
540 error = -ENOMEM;
987f8dfc 541 goto out;
ae57ca0f
KM
542 }
543
642ac549
TM
544 /*
545 * Return any delegations if we're going to change ACLs
546 */
547 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
57ec14c5 548 NFS_PROTO(inode)->return_delegation(inode);
987f8dfc 549 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
65e4308d 550 if (error == 0)
aa9c2669 551 error = nfs_refresh_inode(inode, fattr);
987f8dfc
TM
552 nfs_free_fattr(fattr);
553out:
f4ce1299 554 trace_nfs_setattr_exit(inode, error);
65e4308d
TM
555 return error;
556}
ddda8e0a 557EXPORT_SYMBOL_GPL(nfs_setattr);
65e4308d 558
a3d01454
TM
559/**
560 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
561 * @inode: inode of the file used
562 * @offset: file offset to start truncating
563 *
564 * This is a copy of the common vmtruncate, but with the locking
565 * corrected to take into account the fact that NFS requires
566 * inode->i_size to be updated under the inode->i_lock.
f044636d 567 * Note: must be called with inode->i_lock held!
a3d01454
TM
568 */
569static int nfs_vmtruncate(struct inode * inode, loff_t offset)
570{
c08d3b0e 571 int err;
a3d01454 572
c08d3b0e 573 err = inode_newsize_ok(inode, offset);
574 if (err)
575 goto out;
a3d01454 576
c08d3b0e 577 i_size_write(inode, offset);
6edf9609
TM
578 /* Optimisation */
579 if (offset == 0)
580 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_DATA;
c08d3b0e 581
f044636d 582 spin_unlock(&inode->i_lock);
7caef267 583 truncate_pagecache(inode, offset);
f044636d 584 spin_lock(&inode->i_lock);
c08d3b0e 585out:
586 return err;
a3d01454
TM
587}
588
65e4308d
TM
589/**
590 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
591 * @inode: pointer to struct inode
592 * @attr: pointer to struct iattr
593 *
594 * Note: we do this in the *proc.c in order to ensure that
595 * it works for things like exclusive creates too.
596 */
f044636d
TM
597void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr,
598 struct nfs_fattr *fattr)
65e4308d 599{
f044636d
TM
600 /* Barrier: bump the attribute generation count. */
601 nfs_fattr_set_barrier(fattr);
602
603 spin_lock(&inode->i_lock);
604 NFS_I(inode)->attr_gencount = fattr->gencount;
65e4308d 605 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
1da177e4 606 if ((attr->ia_valid & ATTR_MODE) != 0) {
65e4308d
TM
607 int mode = attr->ia_mode & S_IALLUGO;
608 mode |= inode->i_mode & ~S_IALLUGO;
1da177e4
LT
609 inode->i_mode = mode;
610 }
611 if ((attr->ia_valid & ATTR_UID) != 0)
612 inode->i_uid = attr->ia_uid;
613 if ((attr->ia_valid & ATTR_GID) != 0)
614 inode->i_gid = attr->ia_gid;
6edf9609
TM
615 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ACCESS
616 | NFS_INO_INVALID_ACL);
65e4308d
TM
617 }
618 if ((attr->ia_valid & ATTR_SIZE) != 0) {
91d5b470 619 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
a3d01454 620 nfs_vmtruncate(inode, attr->ia_size);
65e4308d 621 }
616c3196
JL
622 if (fattr->valid)
623 nfs_update_inode(inode, fattr);
624 else
625 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
f044636d 626 spin_unlock(&inode->i_lock);
1da177e4 627}
ddda8e0a 628EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);
1da177e4 629
311324ad
TM
630static void nfs_request_parent_use_readdirplus(struct dentry *dentry)
631{
632 struct dentry *parent;
633
634 parent = dget_parent(dentry);
2b0143b5 635 nfs_force_use_readdirplus(d_inode(parent));
311324ad
TM
636 dput(parent);
637}
638
639static bool nfs_need_revalidate_inode(struct inode *inode)
640{
641 if (NFS_I(inode)->cache_validity &
642 (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))
643 return true;
644 if (nfs_attribute_cache_expired(inode))
645 return true;
646 return false;
647}
648
1da177e4
LT
649int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
650{
2b0143b5 651 struct inode *inode = d_inode(dentry);
55296809 652 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
16caf5b6 653 int err = 0;
1da177e4 654
f4ce1299 655 trace_nfs_getattr_enter(inode);
acdc53b2 656 /* Flush out writes to the server in order to update c/mtime. */
28c494c5 657 if (S_ISREG(inode->i_mode)) {
8c18d76b 658 mutex_lock(&inode->i_mutex);
4d346bea 659 err = nfs_sync_inode(inode);
8c18d76b 660 mutex_unlock(&inode->i_mutex);
acdc53b2
TM
661 if (err)
662 goto out;
28c494c5 663 }
fc33a7bb
CH
664
665 /*
666 * We may force a getattr if the user cares about atime.
667 *
668 * Note that we only have to check the vfsmount flags here:
669 * - NFS always sets S_NOATIME by so checking it would give a
670 * bogus result
671 * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
672 * no point in checking those.
673 */
674 if ((mnt->mnt_flags & MNT_NOATIME) ||
675 ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
1da177e4 676 need_atime = 0;
fc33a7bb 677
311324ad
TM
678 if (need_atime || nfs_need_revalidate_inode(inode)) {
679 struct nfs_server *server = NFS_SERVER(inode);
680
681 if (server->caps & NFS_CAP_READDIRPLUS)
682 nfs_request_parent_use_readdirplus(dentry);
683 err = __nfs_revalidate_inode(server, inode);
684 }
4e769b93 685 if (!err) {
1da177e4 686 generic_fillattr(inode, stat);
f43bf0be 687 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
7ef5ca4f
N
688 if (S_ISDIR(inode->i_mode))
689 stat->blksize = NFS_SERVER(inode)->dtsize;
4e769b93 690 }
acdc53b2 691out:
f4ce1299 692 trace_nfs_getattr_exit(inode, err);
1da177e4
LT
693 return err;
694}
ddda8e0a 695EXPORT_SYMBOL_GPL(nfs_getattr);
1da177e4 696
f11ac8db
TM
697static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
698{
699 atomic_set(&l_ctx->count, 1);
2a369153
TM
700 l_ctx->lockowner.l_owner = current->files;
701 l_ctx->lockowner.l_pid = current->tgid;
f11ac8db 702 INIT_LIST_HEAD(&l_ctx->list);
577b4232 703 nfs_iocounter_init(&l_ctx->io_count);
f11ac8db
TM
704}
705
706static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx)
707{
8c86899f
TM
708 struct nfs_lock_context *head = &ctx->lock_context;
709 struct nfs_lock_context *pos = head;
f11ac8db 710
8c86899f 711 do {
2a369153 712 if (pos->lockowner.l_owner != current->files)
f11ac8db 713 continue;
2a369153 714 if (pos->lockowner.l_pid != current->tgid)
f11ac8db
TM
715 continue;
716 atomic_inc(&pos->count);
717 return pos;
8c86899f 718 } while ((pos = list_entry(pos->list.next, typeof(*pos), list)) != head);
f11ac8db
TM
719 return NULL;
720}
721
722struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
723{
724 struct nfs_lock_context *res, *new = NULL;
2b0143b5 725 struct inode *inode = d_inode(ctx->dentry);
f11ac8db
TM
726
727 spin_lock(&inode->i_lock);
728 res = __nfs_find_lock_context(ctx);
729 if (res == NULL) {
730 spin_unlock(&inode->i_lock);
731 new = kmalloc(sizeof(*new), GFP_KERNEL);
732 if (new == NULL)
b3c54de6 733 return ERR_PTR(-ENOMEM);
f11ac8db
TM
734 nfs_init_lock_context(new);
735 spin_lock(&inode->i_lock);
736 res = __nfs_find_lock_context(ctx);
737 if (res == NULL) {
738 list_add_tail(&new->list, &ctx->lock_context.list);
739 new->open_context = ctx;
740 res = new;
741 new = NULL;
742 }
743 }
744 spin_unlock(&inode->i_lock);
745 kfree(new);
746 return res;
747}
1c6dcbe5 748EXPORT_SYMBOL_GPL(nfs_get_lock_context);
f11ac8db
TM
749
750void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
751{
752 struct nfs_open_context *ctx = l_ctx->open_context;
2b0143b5 753 struct inode *inode = d_inode(ctx->dentry);
f11ac8db
TM
754
755 if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock))
756 return;
757 list_del(&l_ctx->list);
758 spin_unlock(&inode->i_lock);
759 kfree(l_ctx);
760}
1c6dcbe5 761EXPORT_SYMBOL_GPL(nfs_put_lock_context);
f11ac8db 762
7fe5c398
TM
763/**
764 * nfs_close_context - Common close_context() routine NFSv2/v3
765 * @ctx: pointer to context
766 * @is_sync: is this a synchronous close
767 *
5cf9d706
TM
768 * Ensure that the attributes are up to date if we're mounted
769 * with close-to-open semantics and we have cached data that will
770 * need to be revalidated on open.
7fe5c398
TM
771 */
772void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
773{
5cf9d706 774 struct nfs_inode *nfsi;
7fe5c398
TM
775 struct inode *inode;
776 struct nfs_server *server;
777
778 if (!(ctx->mode & FMODE_WRITE))
779 return;
780 if (!is_sync)
781 return;
2b0143b5 782 inode = d_inode(ctx->dentry);
5cf9d706
TM
783 nfsi = NFS_I(inode);
784 if (inode->i_mapping->nrpages == 0)
785 return;
786 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
787 return;
788 if (!list_empty(&nfsi->open_files))
7fe5c398
TM
789 return;
790 server = NFS_SERVER(inode);
791 if (server->flags & NFS_MOUNT_NOCTO)
792 return;
793 nfs_revalidate_inode(server, inode);
794}
ddda8e0a 795EXPORT_SYMBOL_GPL(nfs_close_context);
7fe5c398 796
5ede7b1c 797struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode)
1da177e4
LT
798{
799 struct nfs_open_context *ctx;
5ede7b1c
AV
800 struct rpc_cred *cred = rpc_lookup_cred();
801 if (IS_ERR(cred))
802 return ERR_CAST(cred);
1da177e4 803
f52720ca 804 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
5ede7b1c
AV
805 if (!ctx) {
806 put_rpccred(cred);
807 return ERR_PTR(-ENOMEM);
1da177e4 808 }
5ede7b1c
AV
809 nfs_sb_active(dentry->d_sb);
810 ctx->dentry = dget(dentry);
811 ctx->cred = cred;
812 ctx->state = NULL;
813 ctx->mode = f_mode;
814 ctx->flags = 0;
815 ctx->error = 0;
816 nfs_init_lock_context(&ctx->lock_context);
817 ctx->lock_context.open_context = ctx;
818 INIT_LIST_HEAD(&ctx->list);
82be417a 819 ctx->mdsthreshold = NULL;
1da177e4
LT
820 return ctx;
821}
89d77c8f 822EXPORT_SYMBOL_GPL(alloc_nfs_open_context);
1da177e4
LT
823
824struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
825{
826 if (ctx != NULL)
f11ac8db 827 atomic_inc(&ctx->lock_context.count);
1da177e4
LT
828 return ctx;
829}
89d77c8f 830EXPORT_SYMBOL_GPL(get_nfs_open_context);
1da177e4 831
7fe5c398 832static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
1da177e4 833{
2b0143b5 834 struct inode *inode = d_inode(ctx->dentry);
3d4ff43d 835 struct super_block *sb = ctx->dentry->d_sb;
3bec63db 836
5c78f58e 837 if (!list_empty(&ctx->list)) {
ef84303e
BH
838 if (!atomic_dec_and_lock(&ctx->lock_context.count, &inode->i_lock))
839 return;
840 list_del(&ctx->list);
841 spin_unlock(&inode->i_lock);
ef84303e 842 } else if (!atomic_dec_and_test(&ctx->lock_context.count))
5e11934d 843 return;
5c78f58e
TM
844 if (inode != NULL)
845 NFS_PROTO(inode)->close_context(ctx, is_sync);
3bec63db
TM
846 if (ctx->cred != NULL)
847 put_rpccred(ctx->cred);
3d4ff43d 848 dput(ctx->dentry);
322b2b90 849 nfs_sb_deactive(sb);
82be417a 850 kfree(ctx->mdsthreshold);
3bec63db
TM
851 kfree(ctx);
852}
853
a49c3c77
TM
854void put_nfs_open_context(struct nfs_open_context *ctx)
855{
856 __put_nfs_open_context(ctx, 0);
857}
89d77c8f 858EXPORT_SYMBOL_GPL(put_nfs_open_context);
a49c3c77 859
4eae5014
TM
860static void put_nfs_open_context_sync(struct nfs_open_context *ctx)
861{
862 __put_nfs_open_context(ctx, 1);
863}
864
1da177e4
LT
865/*
866 * Ensure that mmap has a recent RPC credential for use when writing out
867 * shared pages
868 */
c45ffdd2 869void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
1da177e4 870{
2b0143b5 871 struct inode *inode = d_inode(ctx->dentry);
1da177e4
LT
872 struct nfs_inode *nfsi = NFS_I(inode);
873
1da177e4
LT
874 spin_lock(&inode->i_lock);
875 list_add(&ctx->list, &nfsi->open_files);
876 spin_unlock(&inode->i_lock);
877}
c45ffdd2
TM
878EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context);
879
880void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
881{
882 filp->private_data = get_nfs_open_context(ctx);
883 if (list_empty(&ctx->list))
884 nfs_inode_attach_open_context(ctx);
885}
89d77c8f 886EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
1da177e4 887
d530838b
TM
888/*
889 * Given an inode, search for an open context with the desired characteristics
890 */
dc0b027d 891struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
1da177e4
LT
892{
893 struct nfs_inode *nfsi = NFS_I(inode);
894 struct nfs_open_context *pos, *ctx = NULL;
895
896 spin_lock(&inode->i_lock);
897 list_for_each_entry(pos, &nfsi->open_files, list) {
d530838b
TM
898 if (cred != NULL && pos->cred != cred)
899 continue;
1544fa0f
TM
900 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
901 continue;
902 ctx = get_nfs_open_context(pos);
903 break;
1da177e4
LT
904 }
905 spin_unlock(&inode->i_lock);
906 return ctx;
907}
908
aff8d8dc 909void nfs_file_clear_open_context(struct file *filp)
1da177e4 910{
cd3758e3 911 struct nfs_open_context *ctx = nfs_file_open_context(filp);
1da177e4
LT
912
913 if (ctx) {
2b0143b5 914 struct inode *inode = d_inode(ctx->dentry);
c45ffdd2 915
1da177e4
LT
916 filp->private_data = NULL;
917 spin_lock(&inode->i_lock);
918 list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
919 spin_unlock(&inode->i_lock);
4eae5014 920 put_nfs_open_context_sync(ctx);
1da177e4
LT
921 }
922}
923
924/*
925 * These allocate and release file read/write context information.
926 */
927int nfs_open(struct inode *inode, struct file *filp)
928{
929 struct nfs_open_context *ctx;
1da177e4 930
5ede7b1c
AV
931 ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
932 if (IS_ERR(ctx))
933 return PTR_ERR(ctx);
1da177e4
LT
934 nfs_file_set_open_context(filp, ctx);
935 put_nfs_open_context(ctx);
f1fe29b4 936 nfs_fscache_open_file(inode, filp);
1da177e4
LT
937 return 0;
938}
939
1da177e4
LT
940/*
941 * This function is called whenever some part of NFS notices that
942 * the cached attributes have to be refreshed.
943 */
944int
945__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
946{
947 int status = -ESTALE;
1775fd3e 948 struct nfs4_label *label = NULL;
a3cba2aa 949 struct nfs_fattr *fattr = NULL;
1da177e4 950 struct nfs_inode *nfsi = NFS_I(inode);
1da177e4 951
1e8968c5
NV
952 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Lu)\n",
953 inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode));
1da177e4 954
f4ce1299
TM
955 trace_nfs_revalidate_inode_enter(inode);
956
85233a7a 957 if (is_bad_inode(inode))
691beb13 958 goto out;
1da177e4 959 if (NFS_STALE(inode))
412d582e 960 goto out;
7fdc49c4 961
a3cba2aa
TM
962 status = -ENOMEM;
963 fattr = nfs_alloc_fattr();
964 if (fattr == NULL)
965 goto out;
966
691beb13 967 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
14c43f76
DQ
968
969 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
970 if (IS_ERR(label)) {
971 status = PTR_ERR(label);
972 goto out;
973 }
974
1775fd3e 975 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, label);
1da177e4 976 if (status != 0) {
1e8968c5 977 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n",
1da177e4 978 inode->i_sb->s_id,
1e8968c5 979 (unsigned long long)NFS_FILEID(inode), status);
1da177e4
LT
980 if (status == -ESTALE) {
981 nfs_zap_caches(inode);
982 if (!S_ISDIR(inode->i_mode))
3a10c30a 983 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
1da177e4 984 }
14c43f76 985 goto err_out;
1da177e4
LT
986 }
987
a3cba2aa 988 status = nfs_refresh_inode(inode, fattr);
1da177e4 989 if (status) {
1e8968c5 990 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n",
1da177e4 991 inode->i_sb->s_id,
1e8968c5 992 (unsigned long long)NFS_FILEID(inode), status);
14c43f76 993 goto err_out;
1da177e4 994 }
55296809 995
24aa1fe6 996 if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
ada70d94 997 nfs_zap_acl_cache(inode);
55296809 998
3da580aa
JL
999 nfs_setsecurity(inode, fattr, label);
1000
1e8968c5 1001 dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n",
1da177e4 1002 inode->i_sb->s_id,
1e8968c5 1003 (unsigned long long)NFS_FILEID(inode));
1da177e4 1004
14c43f76
DQ
1005err_out:
1006 nfs4_label_free(label);
1007out:
a3cba2aa 1008 nfs_free_fattr(fattr);
f4ce1299 1009 trace_nfs_revalidate_inode_exit(inode, status);
1da177e4
LT
1010 return status;
1011}
1012
1013int nfs_attribute_timeout(struct inode *inode)
1014{
1015 struct nfs_inode *nfsi = NFS_I(inode);
1016
d7cf8dd0
TM
1017 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
1018}
1019
43f291cd 1020int nfs_attribute_cache_expired(struct inode *inode)
d7cf8dd0 1021{
b4d2314b 1022 if (nfs_have_delegated_attributes(inode))
1da177e4 1023 return 0;
d7cf8dd0 1024 return nfs_attribute_timeout(inode);
1da177e4
LT
1025}
1026
1027/**
1028 * nfs_revalidate_inode - Revalidate the inode attributes
1029 * @server - pointer to nfs_server struct
1030 * @inode - pointer to inode struct
1031 *
1032 * Updates inode attribute information by retrieving the data from the server.
1033 */
1034int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1035{
311324ad 1036 if (!nfs_need_revalidate_inode(inode))
1da177e4
LT
1037 return NFS_STALE(inode) ? -ESTALE : 0;
1038 return __nfs_revalidate_inode(server, inode);
1039}
1c606fb7 1040EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
1da177e4 1041
912a108d
N
1042int nfs_revalidate_inode_rcu(struct nfs_server *server, struct inode *inode)
1043{
1044 if (!(NFS_I(inode)->cache_validity &
1045 (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))
1046 && !nfs_attribute_cache_expired(inode))
1047 return NFS_STALE(inode) ? -ESTALE : 0;
1048 return -ECHILD;
1049}
1050
1cda707d 1051static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
717d44e8
TM
1052{
1053 struct nfs_inode *nfsi = NFS_I(inode);
f8806c84
TM
1054 int ret;
1055
717d44e8 1056 if (mapping->nrpages != 0) {
f8806c84 1057 if (S_ISREG(inode->i_mode)) {
ef070dcb 1058 unmap_mapping_range(mapping, 0, 0, 0);
f8806c84
TM
1059 ret = nfs_sync_mapping(mapping);
1060 if (ret < 0)
1061 return ret;
1062 }
1063 ret = invalidate_inode_pages2(mapping);
717d44e8
TM
1064 if (ret < 0)
1065 return ret;
1066 }
d529ef83
JL
1067 if (S_ISDIR(inode->i_mode)) {
1068 spin_lock(&inode->i_lock);
717d44e8 1069 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
d529ef83
JL
1070 spin_unlock(&inode->i_lock);
1071 }
717d44e8 1072 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
de242c0b 1073 nfs_fscache_wait_on_invalidate(inode);
f4ce1299 1074
1e8968c5
NV
1075 dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n",
1076 inode->i_sb->s_id,
1077 (unsigned long long)NFS_FILEID(inode));
717d44e8
TM
1078 return 0;
1079}
1080
b4b1eadf
TM
1081static bool nfs_mapping_need_revalidate_inode(struct inode *inode)
1082{
1083 if (nfs_have_delegated_attributes(inode))
1084 return false;
1085 return (NFS_I(inode)->cache_validity & NFS_INO_REVAL_PAGECACHE)
1086 || nfs_attribute_timeout(inode)
1087 || NFS_STALE(inode);
1088}
1089
0d0def49
AV
1090int nfs_revalidate_mapping_rcu(struct inode *inode)
1091{
1092 struct nfs_inode *nfsi = NFS_I(inode);
1093 unsigned long *bitlock = &nfsi->flags;
1094 int ret = 0;
1095
1096 if (IS_SWAPFILE(inode))
1097 goto out;
1098 if (nfs_mapping_need_revalidate_inode(inode)) {
1099 ret = -ECHILD;
1100 goto out;
1101 }
1102 spin_lock(&inode->i_lock);
1103 if (test_bit(NFS_INO_INVALIDATING, bitlock) ||
1104 (nfsi->cache_validity & NFS_INO_INVALID_DATA))
1105 ret = -ECHILD;
1106 spin_unlock(&inode->i_lock);
1107out:
1108 return ret;
1109}
1110
717d44e8 1111/**
874f9463 1112 * __nfs_revalidate_mapping - Revalidate the pagecache
717d44e8
TM
1113 * @inode - pointer to host inode
1114 * @mapping - pointer to mapping
874f9463 1115 * @may_lock - take inode->i_mutex?
717d44e8 1116 */
874f9463
TM
1117static int __nfs_revalidate_mapping(struct inode *inode,
1118 struct address_space *mapping,
1119 bool may_lock)
717d44e8
TM
1120{
1121 struct nfs_inode *nfsi = NFS_I(inode);
d529ef83 1122 unsigned long *bitlock = &nfsi->flags;
717d44e8 1123 int ret = 0;
dc59250c 1124
29418aa4
MG
1125 /* swapfiles are not supposed to be shared. */
1126 if (IS_SWAPFILE(inode))
1127 goto out;
1128
b4b1eadf 1129 if (nfs_mapping_need_revalidate_inode(inode)) {
717d44e8
TM
1130 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1131 if (ret < 0)
1132 goto out;
7d52e862 1133 }
d529ef83
JL
1134
1135 /*
1136 * We must clear NFS_INO_INVALID_DATA first to ensure that
1137 * invalidations that come in while we're shooting down the mappings
1138 * are respected. But, that leaves a race window where one revalidator
1139 * can clear the flag, and then another checks it before the mapping
1140 * gets invalidated. Fix that by serializing access to this part of
1141 * the function.
1142 *
1143 * At the same time, we need to allow other tasks to see whether we
1144 * might be in the middle of invalidating the pages, so we only set
1145 * the bit lock here if it looks like we're going to be doing that.
1146 */
1147 for (;;) {
74316201
N
1148 ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING,
1149 nfs_wait_bit_killable, TASK_KILLABLE);
d529ef83
JL
1150 if (ret)
1151 goto out;
17dfeb91
TM
1152 spin_lock(&inode->i_lock);
1153 if (test_bit(NFS_INO_INVALIDATING, bitlock)) {
1154 spin_unlock(&inode->i_lock);
1155 continue;
1156 }
1157 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
d529ef83 1158 break;
d529ef83 1159 spin_unlock(&inode->i_lock);
17dfeb91 1160 goto out;
f4ce1299
TM
1161 }
1162
17dfeb91 1163 set_bit(NFS_INO_INVALIDATING, bitlock);
4db72b40 1164 smp_wmb();
17dfeb91
TM
1165 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
1166 spin_unlock(&inode->i_lock);
1167 trace_nfs_invalidate_mapping_enter(inode);
874f9463
TM
1168 if (may_lock) {
1169 mutex_lock(&inode->i_mutex);
1170 ret = nfs_invalidate_mapping(inode, mapping);
1171 mutex_unlock(&inode->i_mutex);
1172 } else
1173 ret = nfs_invalidate_mapping(inode, mapping);
17dfeb91
TM
1174 trace_nfs_invalidate_mapping_exit(inode, ret);
1175
d529ef83 1176 clear_bit_unlock(NFS_INO_INVALIDATING, bitlock);
4e857c58 1177 smp_mb__after_atomic();
d529ef83 1178 wake_up_bit(bitlock, NFS_INO_INVALIDATING);
cd9ae2b6 1179out:
44b11874 1180 return ret;
7d52e862
TM
1181}
1182
874f9463
TM
1183/**
1184 * nfs_revalidate_mapping - Revalidate the pagecache
1185 * @inode - pointer to host inode
1186 * @mapping - pointer to mapping
1187 */
1188int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
1189{
1190 return __nfs_revalidate_mapping(inode, mapping, false);
1191}
1192
1193/**
1194 * nfs_revalidate_mapping_protected - Revalidate the pagecache
1195 * @inode - pointer to host inode
1196 * @mapping - pointer to mapping
1197 *
1198 * Differs from nfs_revalidate_mapping() in that it grabs the inode->i_mutex
1199 * while invalidating the mapping.
1200 */
1201int nfs_revalidate_mapping_protected(struct inode *inode, struct address_space *mapping)
1202{
1203 return __nfs_revalidate_mapping(inode, mapping, true);
1204}
1205
27dc1cd3 1206static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
a895b4a1
TM
1207{
1208 struct nfs_inode *nfsi = NFS_I(inode);
27dc1cd3 1209 unsigned long ret = 0;
a895b4a1 1210
9e6e70f8
TM
1211 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
1212 && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
a9a4a87a
TM
1213 && inode->i_version == fattr->pre_change_attr) {
1214 inode->i_version = fattr->change_attr;
70ca8852 1215 if (S_ISDIR(inode->i_mode))
6edf9609 1216 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
27dc1cd3 1217 ret |= NFS_INO_INVALID_ATTR;
70ca8852 1218 }
a895b4a1 1219 /* If we have atomic WCC data, we may update some attributes */
9e6e70f8
TM
1220 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
1221 && (fattr->valid & NFS_ATTR_FATTR_CTIME)
27dc1cd3
TM
1222 && timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
1223 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1224 ret |= NFS_INO_INVALID_ATTR;
1225 }
9e6e70f8
TM
1226
1227 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
1228 && (fattr->valid & NFS_ATTR_FATTR_MTIME)
1229 && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
27dc1cd3
TM
1230 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1231 if (S_ISDIR(inode->i_mode))
6edf9609 1232 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
27dc1cd3 1233 ret |= NFS_INO_INVALID_ATTR;
a895b4a1 1234 }
9e6e70f8
TM
1235 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
1236 && (fattr->valid & NFS_ATTR_FATTR_SIZE)
1237 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
cb1410c7 1238 && nfsi->nrequests == 0) {
27dc1cd3
TM
1239 i_size_write(inode, nfs_size_to_loff_t(fattr->size));
1240 ret |= NFS_INO_INVALID_ATTR;
1241 }
de242c0b 1242
27dc1cd3 1243 return ret;
a895b4a1
TM
1244}
1245
1da177e4 1246/**
33801147 1247 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
1da177e4
LT
1248 * @inode - pointer to inode
1249 * @fattr - updated attributes
1250 *
1251 * Verifies the attribute cache. If we have just changed the attributes,
1252 * so that fattr carries weak cache consistency data, then it may
1253 * also update the ctime/mtime/change_attribute.
1254 */
33801147 1255static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
1da177e4
LT
1256{
1257 struct nfs_inode *nfsi = NFS_I(inode);
1258 loff_t cur_size, new_isize;
2a3f5fd4 1259 unsigned long invalid = 0;
1da177e4 1260
dc59250c 1261
01da47bd
TM
1262 if (nfs_have_delegated_attributes(inode))
1263 return 0;
ca62b9c3 1264 /* Has the inode gone and changed behind our back? */
9e6e70f8
TM
1265 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
1266 return -EIO;
1267 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
ca62b9c3 1268 return -EIO;
ca62b9c3 1269
9e6e70f8 1270 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
a9a4a87a 1271 inode->i_version != fattr->change_attr)
2a3f5fd4 1272 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
1da177e4 1273
1da177e4 1274 /* Verify a few of the more important attributes */
9e6e70f8 1275 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))
fee7fe19 1276 invalid |= NFS_INO_INVALID_ATTR;
ca62b9c3 1277
9e6e70f8
TM
1278 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1279 cur_size = i_size_read(inode);
1280 new_isize = nfs_size_to_loff_t(fattr->size);
85a23cee 1281 if (cur_size != new_isize)
9e6e70f8
TM
1282 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
1283 }
85a23cee
TM
1284 if (nfsi->nrequests != 0)
1285 invalid &= ~NFS_INO_REVAL_PAGECACHE;
1da177e4
LT
1286
1287 /* Have any file permissions changed? */
9e6e70f8
TM
1288 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
1289 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
9ff593c4 1290 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))
9e6e70f8 1291 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
9ff593c4 1292 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))
2a3f5fd4 1293 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
1da177e4
LT
1294
1295 /* Has the link count changed? */
9e6e70f8 1296 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
2a3f5fd4 1297 invalid |= NFS_INO_INVALID_ATTR;
1da177e4 1298
9e6e70f8 1299 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
2a3f5fd4
TM
1300 invalid |= NFS_INO_INVALID_ATIME;
1301
1302 if (invalid != 0)
6edf9609 1303 nfs_set_cache_invalid(inode, invalid);
1da177e4 1304
33801147 1305 nfsi->read_cache_jiffies = fattr->time_start;
1da177e4
LT
1306 return 0;
1307}
1308
ae05f269 1309static atomic_long_t nfs_attr_generation_counter;
4704f0e2
TM
1310
1311static unsigned long nfs_read_attr_generation_counter(void)
1312{
ae05f269 1313 return atomic_long_read(&nfs_attr_generation_counter);
4704f0e2
TM
1314}
1315
1316unsigned long nfs_inc_attr_generation_counter(void)
1317{
ae05f269 1318 return atomic_long_inc_return(&nfs_attr_generation_counter);
4704f0e2 1319}
3235b403 1320EXPORT_SYMBOL_GPL(nfs_inc_attr_generation_counter);
4704f0e2
TM
1321
1322void nfs_fattr_init(struct nfs_fattr *fattr)
1323{
1324 fattr->valid = 0;
1325 fattr->time_start = jiffies;
1326 fattr->gencount = nfs_inc_attr_generation_counter();
6926afd1
TM
1327 fattr->owner_name = NULL;
1328 fattr->group_name = NULL;
4704f0e2 1329}
ddda8e0a 1330EXPORT_SYMBOL_GPL(nfs_fattr_init);
4704f0e2 1331
140e049c
TM
1332/**
1333 * nfs_fattr_set_barrier
1334 * @fattr: attributes
1335 *
1336 * Used to set a barrier after an attribute was updated. This
1337 * barrier ensures that older attributes from RPC calls that may
1338 * have raced with our update cannot clobber these new values.
1339 * Note that you are still responsible for ensuring that other
1340 * operations which change the attribute on the server do not
1341 * collide.
1342 */
1343void nfs_fattr_set_barrier(struct nfs_fattr *fattr)
1344{
1345 fattr->gencount = nfs_inc_attr_generation_counter();
1346}
1347
2d36bfde
TM
1348struct nfs_fattr *nfs_alloc_fattr(void)
1349{
1350 struct nfs_fattr *fattr;
1351
1352 fattr = kmalloc(sizeof(*fattr), GFP_NOFS);
1353 if (fattr != NULL)
1354 nfs_fattr_init(fattr);
1355 return fattr;
1356}
ddda8e0a 1357EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
2d36bfde
TM
1358
1359struct nfs_fh *nfs_alloc_fhandle(void)
1360{
1361 struct nfs_fh *fh;
1362
1363 fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS);
1364 if (fh != NULL)
1365 fh->size = 0;
1366 return fh;
1367}
ddda8e0a 1368EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
2d36bfde 1369
e27d359e 1370#ifdef NFS_DEBUG
d8e0539e
WAA
1371/*
1372 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle
1373 * in the same way that wireshark does
1374 *
1375 * @fh: file handle
1376 *
1377 * For debugging only.
1378 */
1379u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
1380{
1381 /* wireshark uses 32-bit AUTODIN crc and does a bitwise
1382 * not on the result */
1264a2f0 1383 return nfs_fhandle_hash(fh);
d8e0539e 1384}
9e6ee76d 1385EXPORT_SYMBOL_GPL(_nfs_display_fhandle_hash);
d8e0539e
WAA
1386
1387/*
20d27e92
CL
1388 * _nfs_display_fhandle - display an NFS file handle on the console
1389 *
1390 * @fh: file handle to display
1391 * @caption: display caption
1392 *
1393 * For debugging only.
1394 */
20d27e92
CL
1395void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
1396{
1397 unsigned short i;
1398
fa68a1ba 1399 if (fh == NULL || fh->size == 0) {
20d27e92
CL
1400 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
1401 return;
1402 }
1403
d8e0539e
WAA
1404 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
1405 caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
20d27e92
CL
1406 for (i = 0; i < fh->size; i += 16) {
1407 __be32 *pos = (__be32 *)&fh->data[i];
1408
1409 switch ((fh->size - i - 1) >> 2) {
1410 case 0:
1411 printk(KERN_DEFAULT " %08x\n",
1412 be32_to_cpup(pos));
1413 break;
1414 case 1:
1415 printk(KERN_DEFAULT " %08x %08x\n",
1416 be32_to_cpup(pos), be32_to_cpup(pos + 1));
1417 break;
1418 case 2:
1419 printk(KERN_DEFAULT " %08x %08x %08x\n",
1420 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1421 be32_to_cpup(pos + 2));
1422 break;
1423 default:
1424 printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
1425 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1426 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
1427 }
1428 }
1429}
9e6ee76d 1430EXPORT_SYMBOL_GPL(_nfs_display_fhandle);
20d27e92
CL
1431#endif
1432
a10ad176
TM
1433/**
1434 * nfs_inode_attrs_need_update - check if the inode attributes need updating
1435 * @inode - pointer to inode
1436 * @fattr - attributes
1437 *
1438 * Attempt to divine whether or not an RPC call reply carrying stale
1439 * attributes got scheduled after another call carrying updated ones.
1440 *
1441 * To do so, the function first assumes that a more recent ctime means
1442 * that the attributes in fattr are newer, however it also attempt to
1443 * catch the case where ctime either didn't change, or went backwards
1444 * (if someone reset the clock on the server) by looking at whether
1445 * or not this RPC call was started after the inode was last updated.
4704f0e2 1446 * Note also the check for wraparound of 'attr_gencount'
a10ad176
TM
1447 *
1448 * The function returns 'true' if it thinks the attributes in 'fattr' are
1449 * more recent than the ones cached in the inode.
1450 *
1451 */
1452static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1453{
1454 const struct nfs_inode *nfsi = NFS_I(inode);
1455
4704f0e2 1456 return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
4704f0e2 1457 ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
a10ad176
TM
1458}
1459
d8c951c3
TM
1460/*
1461 * Don't trust the change_attribute, mtime, ctime or size if
1462 * a pnfs LAYOUTCOMMIT is outstanding
1463 */
1464static void nfs_inode_attrs_handle_layoutcommit(struct inode *inode,
1465 struct nfs_fattr *fattr)
1466{
1467 if (pnfs_layoutcommit_outstanding(inode))
1468 fattr->valid &= ~(NFS_ATTR_FATTR_CHANGE |
1469 NFS_ATTR_FATTR_MTIME |
1470 NFS_ATTR_FATTR_CTIME |
1471 NFS_ATTR_FATTR_SIZE);
1472}
1473
a10ad176
TM
1474static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1475{
f4ce1299
TM
1476 int ret;
1477
1478 trace_nfs_refresh_inode_enter(inode);
1479
d8c951c3
TM
1480 nfs_inode_attrs_handle_layoutcommit(inode, fattr);
1481
a10ad176 1482 if (nfs_inode_attrs_need_update(inode, fattr))
f4ce1299
TM
1483 ret = nfs_update_inode(inode, fattr);
1484 else
1485 ret = nfs_check_inode_attributes(inode, fattr);
1486
1487 trace_nfs_refresh_inode_exit(inode, ret);
1488 return ret;
870a5be8
TM
1489}
1490
33801147
TM
1491/**
1492 * nfs_refresh_inode - try to update the inode attribute cache
1493 * @inode - pointer to inode
1494 * @fattr - updated attributes
1495 *
1496 * Check that an RPC call that returned attributes has not overlapped with
1497 * other recent updates of the inode metadata, then decide whether it is
1498 * safe to do a full update of the inode attributes, or whether just to
1499 * call nfs_check_inode_attributes.
1500 */
1501int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1502{
33801147
TM
1503 int status;
1504
1505 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1506 return 0;
1507 spin_lock(&inode->i_lock);
870a5be8 1508 status = nfs_refresh_inode_locked(inode, fattr);
33801147 1509 spin_unlock(&inode->i_lock);
ef79c097 1510
33801147
TM
1511 return status;
1512}
ddda8e0a 1513EXPORT_SYMBOL_GPL(nfs_refresh_inode);
33801147 1514
d65f557f
TM
1515static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1516{
6edf9609 1517 unsigned long invalid = NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
d65f557f 1518
aaae3f00
TM
1519 /*
1520 * Don't revalidate the pagecache if we hold a delegation, but do
1521 * force an attribute update
1522 */
1523 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1524 invalid = NFS_INO_INVALID_ATTR|NFS_INO_REVAL_FORCED;
1525
6edf9609
TM
1526 if (S_ISDIR(inode->i_mode))
1527 invalid |= NFS_INO_INVALID_DATA;
1528 nfs_set_cache_invalid(inode, invalid);
d65f557f
TM
1529 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1530 return 0;
1531 return nfs_refresh_inode_locked(inode, fattr);
1532}
1533
decf491f
TM
1534/**
1535 * nfs_post_op_update_inode - try to update the inode attribute cache
1536 * @inode - pointer to inode
1537 * @fattr - updated attributes
1538 *
1539 * After an operation that has changed the inode metadata, mark the
1540 * attribute cache as being invalid, then try to update it.
f551e44f
CL
1541 *
1542 * NB: if the server didn't return any post op attributes, this
1543 * function will force the retrieval of attributes before the next
1544 * NFS request. Thus it should be used only for operations that
1545 * are expected to change one or more attributes, to avoid
1546 * unnecessary NFS requests and trips through nfs_update_inode().
decf491f
TM
1547 */
1548int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1549{
d65f557f 1550 int status;
decf491f 1551
7668fdbe 1552 spin_lock(&inode->i_lock);
92d64e47 1553 nfs_fattr_set_barrier(fattr);
d65f557f 1554 status = nfs_post_op_update_inode_locked(inode, fattr);
7668fdbe 1555 spin_unlock(&inode->i_lock);
aa9c2669 1556
870a5be8 1557 return status;
decf491f 1558}
1c606fb7 1559EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
decf491f 1560
70ca8852 1561/**
a08a8cd3 1562 * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache
70ca8852
TM
1563 * @inode - pointer to inode
1564 * @fattr - updated attributes
1565 *
1566 * After an operation that has changed the inode metadata, mark the
1567 * attribute cache as being invalid, then try to update it. Fake up
1568 * weak cache consistency data, if none exist.
1569 *
1570 * This function is mainly designed to be used by the ->write_done() functions.
1571 */
a08a8cd3 1572int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr)
70ca8852 1573{
d65f557f
TM
1574 int status;
1575
d65f557f
TM
1576 /* Don't do a WCC update if these attributes are already stale */
1577 if ((fattr->valid & NFS_ATTR_FATTR) == 0 ||
1578 !nfs_inode_attrs_need_update(inode, fattr)) {
9e6e70f8
TM
1579 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
1580 | NFS_ATTR_FATTR_PRESIZE
1581 | NFS_ATTR_FATTR_PREMTIME
1582 | NFS_ATTR_FATTR_PRECTIME);
d65f557f
TM
1583 goto out_noforce;
1584 }
9e6e70f8
TM
1585 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1586 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
a9a4a87a 1587 fattr->pre_change_attr = inode->i_version;
9e6e70f8 1588 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
70ca8852 1589 }
9e6e70f8
TM
1590 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
1591 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
70ca8852 1592 memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
9e6e70f8
TM
1593 fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
1594 }
1595 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
1596 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
70ca8852 1597 memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
9e6e70f8
TM
1598 fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
1599 }
1600 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
1601 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
a3d01454 1602 fattr->pre_size = i_size_read(inode);
9e6e70f8 1603 fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
70ca8852 1604 }
d65f557f
TM
1605out_noforce:
1606 status = nfs_post_op_update_inode_locked(inode, fattr);
a08a8cd3
TM
1607 return status;
1608}
1609
1610/**
1611 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
1612 * @inode - pointer to inode
1613 * @fattr - updated attributes
1614 *
1615 * After an operation that has changed the inode metadata, mark the
1616 * attribute cache as being invalid, then try to update it. Fake up
1617 * weak cache consistency data, if none exist.
1618 *
1619 * This function is mainly designed to be used by the ->write_done() functions.
1620 */
1621int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
1622{
1623 int status;
1624
1625 spin_lock(&inode->i_lock);
8f8ba1d7 1626 nfs_fattr_set_barrier(fattr);
a08a8cd3 1627 status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
d65f557f
TM
1628 spin_unlock(&inode->i_lock);
1629 return status;
70ca8852 1630}
ddda8e0a 1631EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
70ca8852 1632
ea96d1ec
AS
1633
1634static inline bool nfs_fileid_valid(struct nfs_inode *nfsi,
1635 struct nfs_fattr *fattr)
1636{
1637 bool ret1 = true, ret2 = true;
1638
1639 if (fattr->valid & NFS_ATTR_FATTR_FILEID)
1640 ret1 = (nfsi->fileid == fattr->fileid);
1641 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
1642 ret2 = (nfsi->fileid == fattr->mounted_on_fileid);
1643 return ret1 || ret2;
1644}
1645
1da177e4
LT
1646/*
1647 * Many nfs protocol calls return the new file attributes after
1648 * an operation. Here we update the inode to reflect the state
1649 * of the server's inode.
1650 *
1651 * This is a bit tricky because we have to make sure all dirty pages
1652 * have been sent off to the server before calling invalidate_inode_pages.
1653 * To make sure no other process adds more write requests while we try
1654 * our best to flush them, we make them sleep during the attribute refresh.
1655 *
1656 * A very similar scenario holds for the dir cache.
1657 */
24aa1fe6 1658static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1da177e4 1659{
8b4bdcf8 1660 struct nfs_server *server;
1da177e4 1661 struct nfs_inode *nfsi = NFS_I(inode);
951a143b 1662 loff_t cur_isize, new_isize;
2a3f5fd4 1663 unsigned long invalid = 0;
3e7d950a 1664 unsigned long now = jiffies;
62ab460c 1665 unsigned long save_cache_validity;
1da177e4 1666
1e8968c5 1667 dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%x)\n",
3110ff80 1668 __func__, inode->i_sb->s_id, inode->i_ino,
4f1abd22 1669 nfs_display_fhandle_hash(NFS_FH(inode)),
1da177e4
LT
1670 atomic_read(&inode->i_count), fattr->valid);
1671
ea96d1ec 1672 if (!nfs_fileid_valid(nfsi, fattr)) {
e73e6c9e
MT
1673 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
1674 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
1675 NFS_SERVER(inode)->nfs_client->cl_hostname,
1676 inode->i_sb->s_id, (long long)nfsi->fileid,
1677 (long long)fattr->fileid);
1678 goto out_err;
1679 }
1da177e4
LT
1680
1681 /*
1682 * Make sure the inode's type hasn't changed.
1683 */
e73e6c9e
MT
1684 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
1685 /*
1686 * Big trouble! The inode has become a different object.
1687 */
1e8968c5 1688 printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
e73e6c9e
MT
1689 __func__, inode->i_ino, inode->i_mode, fattr->mode);
1690 goto out_err;
1691 }
1da177e4 1692
8b4bdcf8 1693 server = NFS_SERVER(inode);
a0356862 1694 /* Update the fsid? */
9e6e70f8 1695 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
c37dcd33 1696 !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
36d43a43 1697 !IS_AUTOMOUNT(inode))
8b4bdcf8
TM
1698 server->fsid = fattr->fsid;
1699
1da177e4
LT
1700 /*
1701 * Update the read time so we don't revalidate too often.
1702 */
33801147 1703 nfsi->read_cache_jiffies = fattr->time_start;
3e7d950a 1704
62ab460c
TM
1705 save_cache_validity = nfsi->cache_validity;
1706 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
1707 | NFS_INO_INVALID_ATIME
1708 | NFS_INO_REVAL_FORCED
1709 | NFS_INO_REVAL_PAGECACHE);
1da177e4 1710
a895b4a1 1711 /* Do atomic weak cache consistency updates */
27dc1cd3 1712 invalid |= nfs_wcc_update_inode(inode, fattr);
a895b4a1 1713
47aabaa7 1714 /* More cache consistency checks */
9e6e70f8 1715 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
a9a4a87a 1716 if (inode->i_version != fattr->change_attr) {
9e6e70f8
TM
1717 dprintk("NFS: change_attr change on server for file %s/%ld\n",
1718 inode->i_sb->s_id, inode->i_ino);
6a4506c0
TM
1719 invalid |= NFS_INO_INVALID_ATTR
1720 | NFS_INO_INVALID_DATA
1721 | NFS_INO_INVALID_ACCESS
85a23cee 1722 | NFS_INO_INVALID_ACL;
9e6e70f8
TM
1723 if (S_ISDIR(inode->i_mode))
1724 nfs_force_lookup_revalidate(inode);
a9a4a87a 1725 inode->i_version = fattr->change_attr;
9e6e70f8 1726 }
cd812599 1727 } else
43b6535e 1728 nfsi->cache_validity |= save_cache_validity;
9e6e70f8
TM
1729
1730 if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
fee7fe19 1731 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
62ab460c 1732 } else if (server->caps & NFS_CAP_MTIME)
43b6535e
TM
1733 nfsi->cache_validity |= save_cache_validity &
1734 (NFS_INO_INVALID_ATTR
62ab460c
TM
1735 | NFS_INO_REVAL_FORCED);
1736
9e6e70f8 1737 if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
fee7fe19 1738 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
62ab460c 1739 } else if (server->caps & NFS_CAP_CTIME)
43b6535e
TM
1740 nfsi->cache_validity |= save_cache_validity &
1741 (NFS_INO_INVALID_ATTR
62ab460c 1742 | NFS_INO_REVAL_FORCED);
47aabaa7 1743
951a143b 1744 /* Check if our cached file size is stale */
9e6e70f8
TM
1745 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1746 new_isize = nfs_size_to_loff_t(fattr->size);
1747 cur_isize = i_size_read(inode);
1748 if (new_isize != cur_isize) {
1749 /* Do we perhaps have any outstanding writes, or has
1750 * the file grown beyond our last write? */
cb1410c7 1751 if ((nfsi->nrequests == 0) || new_isize > cur_isize) {
9e6e70f8
TM
1752 i_size_write(inode, new_isize);
1753 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1754 }
60c16ea8
HJ
1755 dprintk("NFS: isize change on server for file %s/%ld "
1756 "(%Ld to %Ld)\n",
1757 inode->i_sb->s_id,
1758 inode->i_ino,
1759 (long long)cur_isize,
1760 (long long)new_isize);
1da177e4 1761 }
62ab460c 1762 } else
43b6535e
TM
1763 nfsi->cache_validity |= save_cache_validity &
1764 (NFS_INO_INVALID_ATTR
62ab460c
TM
1765 | NFS_INO_REVAL_PAGECACHE
1766 | NFS_INO_REVAL_FORCED);
1da177e4 1767
1da177e4 1768
9e6e70f8
TM
1769 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
1770 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
62ab460c 1771 else if (server->caps & NFS_CAP_ATIME)
43b6535e
TM
1772 nfsi->cache_validity |= save_cache_validity &
1773 (NFS_INO_INVALID_ATIME
62ab460c 1774 | NFS_INO_REVAL_FORCED);
1da177e4 1775
9e6e70f8
TM
1776 if (fattr->valid & NFS_ATTR_FATTR_MODE) {
1777 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
9b4b3513
TM
1778 umode_t newmode = inode->i_mode & S_IFMT;
1779 newmode |= fattr->mode & S_IALLUGO;
1780 inode->i_mode = newmode;
9e6e70f8 1781 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
9e6e70f8 1782 }
62ab460c 1783 } else if (server->caps & NFS_CAP_MODE)
43b6535e
TM
1784 nfsi->cache_validity |= save_cache_validity &
1785 (NFS_INO_INVALID_ATTR
62ab460c
TM
1786 | NFS_INO_INVALID_ACCESS
1787 | NFS_INO_INVALID_ACL
1788 | NFS_INO_REVAL_FORCED);
1789
9e6e70f8 1790 if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
9ff593c4 1791 if (!uid_eq(inode->i_uid, fattr->uid)) {
9e6e70f8
TM
1792 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1793 inode->i_uid = fattr->uid;
1794 }
62ab460c 1795 } else if (server->caps & NFS_CAP_OWNER)
43b6535e
TM
1796 nfsi->cache_validity |= save_cache_validity &
1797 (NFS_INO_INVALID_ATTR
62ab460c
TM
1798 | NFS_INO_INVALID_ACCESS
1799 | NFS_INO_INVALID_ACL
1800 | NFS_INO_REVAL_FORCED);
1801
9e6e70f8 1802 if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
9ff593c4 1803 if (!gid_eq(inode->i_gid, fattr->gid)) {
9e6e70f8
TM
1804 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1805 inode->i_gid = fattr->gid;
1806 }
62ab460c 1807 } else if (server->caps & NFS_CAP_OWNER_GROUP)
43b6535e
TM
1808 nfsi->cache_validity |= save_cache_validity &
1809 (NFS_INO_INVALID_ATTR
62ab460c
TM
1810 | NFS_INO_INVALID_ACCESS
1811 | NFS_INO_INVALID_ACL
1812 | NFS_INO_REVAL_FORCED);
921615f1 1813
9e6e70f8
TM
1814 if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
1815 if (inode->i_nlink != fattr->nlink) {
1816 invalid |= NFS_INO_INVALID_ATTR;
1817 if (S_ISDIR(inode->i_mode))
1818 invalid |= NFS_INO_INVALID_DATA;
bfe86848 1819 set_nlink(inode, fattr->nlink);
9e6e70f8 1820 }
62ab460c 1821 } else if (server->caps & NFS_CAP_NLINK)
43b6535e
TM
1822 nfsi->cache_validity |= save_cache_validity &
1823 (NFS_INO_INVALID_ATTR
62ab460c 1824 | NFS_INO_REVAL_FORCED);
1da177e4 1825
9e6e70f8 1826 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
1da177e4
LT
1827 /*
1828 * report the blocks in 512byte units
1829 */
1830 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
1da177e4 1831 }
9e6e70f8
TM
1832 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
1833 inode->i_blocks = fattr->du.nfs2.blocks;
1da177e4
LT
1834
1835 /* Update attrtimeo value if we're out of the unstable period */
fd1defc2 1836 if (invalid & NFS_INO_INVALID_ATTR) {
91d5b470 1837 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
1da177e4 1838 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
3e7d950a 1839 nfsi->attrtimeo_timestamp = now;
f5062003 1840 /* Set barrier to be more recent than all outstanding updates */
4704f0e2 1841 nfsi->attr_gencount = nfs_inc_attr_generation_counter();
6d2b2966 1842 } else {
64672d55 1843 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
6d2b2966
TM
1844 if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
1845 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
1846 nfsi->attrtimeo_timestamp = now;
1847 }
f5062003
TM
1848 /* Set the barrier to be more recent than this fattr */
1849 if ((long)fattr->gencount - (long)nfsi->attr_gencount > 0)
1850 nfsi->attr_gencount = fattr->gencount;
1da177e4 1851 }
c812012f
JL
1852
1853 /* Don't declare attrcache up to date if there were no attrs! */
1854 if (fattr->valid != 0)
1855 invalid &= ~NFS_INO_INVALID_ATTR;
1856
1da177e4
LT
1857 /* Don't invalidate the data if we were to blame */
1858 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
1859 || S_ISLNK(inode->i_mode)))
1860 invalid &= ~NFS_INO_INVALID_DATA;
011e2a7f 1861 if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ) ||
62ab460c 1862 (save_cache_validity & NFS_INO_REVAL_FORCED))
6edf9609 1863 nfs_set_cache_invalid(inode, invalid);
de242c0b 1864
1da177e4 1865 return 0;
b37b03b7 1866 out_err:
1da177e4
LT
1867 /*
1868 * No need to worry about unhashing the dentry, as the
1869 * lookup validation will know that the inode is bad.
1870 * (But we fall through to invalidate the caches.)
1871 */
1872 nfs_invalidate_inode(inode);
1da177e4
LT
1873 return -ESTALE;
1874}
1875
f7b422b1 1876struct inode *nfs_alloc_inode(struct super_block *sb)
1da177e4
LT
1877{
1878 struct nfs_inode *nfsi;
c456aacf 1879 nfsi = kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
1da177e4
LT
1880 if (!nfsi)
1881 return NULL;
55296809
CL
1882 nfsi->flags = 0UL;
1883 nfsi->cache_validity = 0UL;
89d77c8f 1884#if IS_ENABLED(CONFIG_NFS_V4)
e50a1c2e
BF
1885 nfsi->nfs4_acl = NULL;
1886#endif /* CONFIG_NFS_V4 */
1da177e4
LT
1887 return &nfsi->vfs_inode;
1888}
89d77c8f 1889EXPORT_SYMBOL_GPL(nfs_alloc_inode);
1da177e4 1890
fa0d7e3d 1891static void nfs_i_callback(struct rcu_head *head)
1da177e4 1892{
fa0d7e3d 1893 struct inode *inode = container_of(head, struct inode, i_rcu);
1da177e4
LT
1894 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
1895}
1896
fa0d7e3d
NP
1897void nfs_destroy_inode(struct inode *inode)
1898{
1899 call_rcu(&inode->i_rcu, nfs_i_callback);
1900}
89d77c8f 1901EXPORT_SYMBOL_GPL(nfs_destroy_inode);
fa0d7e3d 1902
d75d5414
AM
1903static inline void nfs4_init_once(struct nfs_inode *nfsi)
1904{
89d77c8f 1905#if IS_ENABLED(CONFIG_NFS_V4)
d75d5414
AM
1906 INIT_LIST_HEAD(&nfsi->open_states);
1907 nfsi->delegation = NULL;
d75d5414 1908 init_rwsem(&nfsi->rwsem);
e5e94017 1909 nfsi->layout = NULL;
d75d5414
AM
1910#endif
1911}
f7b422b1 1912
51cc5068 1913static void init_once(void *foo)
1da177e4
LT
1914{
1915 struct nfs_inode *nfsi = (struct nfs_inode *) foo;
1916
a35afb83 1917 inode_init_once(&nfsi->vfs_inode);
a35afb83
CL
1918 INIT_LIST_HEAD(&nfsi->open_files);
1919 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
1920 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
ea2cf228 1921 INIT_LIST_HEAD(&nfsi->commit_info.list);
cb1410c7 1922 nfsi->nrequests = 0;
ea2cf228 1923 nfsi->commit_info.ncommit = 0;
1a0de48a 1924 atomic_set(&nfsi->commit_info.rpcs_out, 0);
565277f6
TM
1925 atomic_set(&nfsi->silly_count, 1);
1926 INIT_HLIST_HEAD(&nfsi->silly_list);
1927 init_waitqueue_head(&nfsi->waitqueue);
a35afb83 1928 nfs4_init_once(nfsi);
1da177e4 1929}
20c2df83 1930
f7b422b1 1931static int __init nfs_init_inodecache(void)
1da177e4
LT
1932{
1933 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
1934 sizeof(struct nfs_inode),
fffb60f9 1935 0, (SLAB_RECLAIM_ACCOUNT|
5d097056 1936 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
20c2df83 1937 init_once);
1da177e4
LT
1938 if (nfs_inode_cachep == NULL)
1939 return -ENOMEM;
1940
1941 return 0;
1942}
1943
266bee88 1944static void nfs_destroy_inodecache(void)
1da177e4 1945{
8c0a8537
KS
1946 /*
1947 * Make sure all delayed rcu free inodes are flushed before we
1948 * destroy cache.
1949 */
1950 rcu_barrier();
1a1d92c1 1951 kmem_cache_destroy(nfs_inode_cachep);
1da177e4
LT
1952}
1953
5746006f 1954struct workqueue_struct *nfsiod_workqueue;
89d77c8f 1955EXPORT_SYMBOL_GPL(nfsiod_workqueue);
5746006f
TM
1956
1957/*
1958 * start up the nfsiod workqueue
1959 */
1960static int nfsiod_start(void)
1961{
1962 struct workqueue_struct *wq;
1963 dprintk("RPC: creating workqueue nfsiod\n");
ada609ee 1964 wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
5746006f
TM
1965 if (wq == NULL)
1966 return -ENOMEM;
1967 nfsiod_workqueue = wq;
1968 return 0;
1969}
1970
1971/*
1972 * Destroy the nfsiod workqueue
1973 */
1974static void nfsiod_stop(void)
1975{
1976 struct workqueue_struct *wq;
1977
1978 wq = nfsiod_workqueue;
1979 if (wq == NULL)
1980 return;
1981 nfsiod_workqueue = NULL;
1982 destroy_workqueue(wq);
1983}
1984
1b340d01 1985int nfs_net_id;
9e2e74db 1986EXPORT_SYMBOL_GPL(nfs_net_id);
1b340d01
SK
1987
1988static int nfs_net_init(struct net *net)
1989{
6b13168b 1990 nfs_clients_init(net);
65b38851 1991 return nfs_fs_proc_net_init(net);
1b340d01
SK
1992}
1993
1994static void nfs_net_exit(struct net *net)
1995{
65b38851 1996 nfs_fs_proc_net_exit(net);
28cd1b3f 1997 nfs_cleanup_cb_ident_idr(net);
1b340d01
SK
1998}
1999
2000static struct pernet_operations nfs_net_ops = {
2001 .init = nfs_net_init,
2002 .exit = nfs_net_exit,
2003 .id = &nfs_net_id,
2004 .size = sizeof(struct nfs_net),
2005};
2006
1da177e4
LT
2007/*
2008 * Initialize NFS
2009 */
2010static int __init init_nfs_fs(void)
2011{
2012 int err;
2013
1b340d01 2014 err = register_pernet_subsys(&nfs_net_ops);
e571cbf1 2015 if (err < 0)
89d77c8f 2016 goto out9;
e571cbf1 2017
8ec442ae
DH
2018 err = nfs_fscache_register();
2019 if (err < 0)
89d77c8f 2020 goto out8;
8ec442ae 2021
5746006f
TM
2022 err = nfsiod_start();
2023 if (err)
89d77c8f 2024 goto out7;
5746006f 2025
6aaca566
DH
2026 err = nfs_fs_proc_init();
2027 if (err)
89d77c8f 2028 goto out6;
6aaca566 2029
1da177e4
LT
2030 err = nfs_init_nfspagecache();
2031 if (err)
89d77c8f 2032 goto out5;
1da177e4
LT
2033
2034 err = nfs_init_inodecache();
2035 if (err)
89d77c8f 2036 goto out4;
1da177e4
LT
2037
2038 err = nfs_init_readpagecache();
2039 if (err)
89d77c8f 2040 goto out3;
1da177e4
LT
2041
2042 err = nfs_init_writepagecache();
2043 if (err)
89d77c8f 2044 goto out2;
1da177e4 2045
1da177e4
LT
2046 err = nfs_init_directcache();
2047 if (err)
89d77c8f 2048 goto out1;
1da177e4 2049
ec7652aa 2050 rpc_proc_register(&init_net, &nfs_rpcstat);
cd738ee9
KM
2051
2052 err = register_nfs_fs();
2053 if (err)
129d1977
BS
2054 goto out0;
2055
1da177e4 2056 return 0;
129d1977 2057out0:
ec7652aa 2058 rpc_proc_unregister(&init_net, "nfs");
1da177e4 2059 nfs_destroy_directcache();
89d77c8f 2060out1:
129d1977 2061 nfs_destroy_writepagecache();
89d77c8f 2062out2:
129d1977 2063 nfs_destroy_readpagecache();
89d77c8f 2064out3:
129d1977 2065 nfs_destroy_inodecache();
89d77c8f 2066out4:
129d1977 2067 nfs_destroy_nfspagecache();
89d77c8f 2068out5:
129d1977 2069 nfs_fs_proc_exit();
89d77c8f 2070out6:
129d1977 2071 nfsiod_stop();
89d77c8f 2072out7:
129d1977 2073 nfs_fscache_unregister();
89d77c8f 2074out8:
129d1977 2075 unregister_pernet_subsys(&nfs_net_ops);
89d77c8f 2076out9:
1da177e4
LT
2077 return err;
2078}
2079
2080static void __exit exit_nfs_fs(void)
2081{
1da177e4 2082 nfs_destroy_directcache();
1da177e4
LT
2083 nfs_destroy_writepagecache();
2084 nfs_destroy_readpagecache();
2085 nfs_destroy_inodecache();
2086 nfs_destroy_nfspagecache();
8ec442ae 2087 nfs_fscache_unregister();
1b340d01 2088 unregister_pernet_subsys(&nfs_net_ops);
ec7652aa 2089 rpc_proc_unregister(&init_net, "nfs");
f7b422b1 2090 unregister_nfs_fs();
6aaca566 2091 nfs_fs_proc_exit();
5746006f 2092 nfsiod_stop();
1da177e4
LT
2093}
2094
2095/* Not quite true; I just maintain it */
2096MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
2097MODULE_LICENSE("GPL");
f43bf0be 2098module_param(enable_ino64, bool, 0644);
1da177e4
LT
2099
2100module_init(init_nfs_fs)
2101module_exit(exit_nfs_fs)