blob: 86faecf8f328f2639bab1c5f7391df6d659610f2 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/vfs.h>
Manoj Naik9cdb3882006-06-09 09:34:28 -040036#include <linux/inet.h>
37#include <linux/nfs_xdr.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090038#include <linux/slab.h>
Frank Filz3fa0b4e2010-12-02 19:31:23 +000039#include <linux/compat.h>
Jeff Laytond3103102011-12-01 22:44:39 +010040#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <asm/uaccess.h>
43
Trond Myklebust4ce79712005-06-22 17:16:21 +000044#include "nfs4_fs.h"
Trond Myklebusta72b4422006-01-03 09:55:41 +010045#include "callback.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include "delegation.h"
Chuck Leverd9ef5a82006-03-20 13:44:13 -050047#include "iostat.h"
David Howellsf7b422b2006-06-09 09:34:33 -040048#include "internal.h"
David Howells8ec442a2009-04-03 16:42:42 +010049#include "fscache.h"
Benny Halevye5e94012010-10-20 00:18:01 -040050#include "pnfs.h"
Bryan Schumakerab7017a2012-07-30 16:05:16 -040051#include "nfs.h"
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +030052#include "netns.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Trond Myklebustf4ce1292013-08-19 18:59:33 -040054#include "nfstrace.h"
55
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#define NFSDBG_FACILITY NFSDBG_VFS
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
Trond Myklebustf43bf0b2007-10-09 12:01:04 -040058#define NFS_64_BIT_INODE_NUMBERS_ENABLED 1
59
60/* Default is to see 64-bit inode numbers */
Rusty Russell90ab5ee2012-01-13 09:32:20 +103061static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
Trond Myklebustf43bf0b2007-10-09 12:01:04 -040062
Linus Torvalds1da177e2005-04-16 15:20:36 -070063static void nfs_invalidate_inode(struct inode *);
Trond Myklebust24aa1fe2005-12-03 15:20:07 -050064static int nfs_update_inode(struct inode *, struct nfs_fattr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Christoph Lametere18b8902006-12-06 20:33:20 -080066static struct kmem_cache * nfs_inode_cachep;
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +000067
Linus Torvalds1da177e2005-04-16 15:20:36 -070068static inline unsigned long
69nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
70{
71 return nfs_fileid_to_ino_t(fattr->fileid);
72}
73
Benjamin Coddington210c7c12016-01-06 10:40:18 -050074static int nfs_wait_killable(int mode)
Trond Myklebust72cb77f2009-03-11 14:10:30 -040075{
Colin Cross416ad3c2013-05-06 23:50:06 +000076 freezable_schedule_unsafe();
Peter Zijlstradfd01f02015-12-13 22:11:16 +010077 if (signal_pending_state(mode, current))
78 return -ERESTARTSYS;
Trond Myklebust72cb77f2009-03-11 14:10:30 -040079 return 0;
80}
Benjamin Coddington210c7c12016-01-06 10:40:18 -050081
82int nfs_wait_bit_killable(struct wait_bit_key *key, int mode)
83{
84 return nfs_wait_killable(mode);
85}
Bryan Schumaker89d77c82012-07-30 16:05:25 -040086EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
Trond Myklebust72cb77f2009-03-11 14:10:30 -040087
Benjamin Coddington210c7c12016-01-06 10:40:18 -050088int nfs_wait_atomic_killable(atomic_t *p)
89{
90 return nfs_wait_killable(TASK_KILLABLE);
91}
92
Trond Myklebust72cb77f2009-03-11 14:10:30 -040093/**
Trond Myklebustf43bf0b2007-10-09 12:01:04 -040094 * nfs_compat_user_ino64 - returns the user-visible inode number
95 * @fileid: 64-bit fileid
96 *
97 * This function returns a 32-bit inode number if the boot parameter
98 * nfs.enable_ino64 is zero.
99 */
100u64 nfs_compat_user_ino64(u64 fileid)
101{
Frank Filz3fa0b4e2010-12-02 19:31:23 +0000102#ifdef CONFIG_COMPAT
103 compat_ulong_t ino;
104#else
105 unsigned long ino;
106#endif
Trond Myklebustf43bf0b2007-10-09 12:01:04 -0400107
108 if (enable_ino64)
109 return fileid;
110 ino = fileid;
111 if (sizeof(ino) < sizeof(fileid))
112 ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
113 return ino;
114}
115
Trond Myklebusteed99352012-12-14 14:36:36 -0500116int nfs_drop_inode(struct inode *inode)
117{
118 return NFS_STALE(inode) || generic_drop_inode(inode);
119}
120EXPORT_SYMBOL_GPL(nfs_drop_inode);
121
Bryan Schumaker19d87ca2012-07-30 16:05:21 -0400122void nfs_clear_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123{
Trond Myklebustda6d5032006-06-01 17:26:35 -0400124 /*
125 * The following should never happen...
126 */
Trond Myklebustf48407d2012-10-15 16:19:30 -0400127 WARN_ON_ONCE(nfs_have_writebacks(inode));
128 WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files));
Trond Myklebustada70d92005-06-22 17:16:22 +0000129 nfs_zap_acl_cache(inode);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -0400130 nfs_access_zap_cache(inode);
David Howellsf1fe29b2013-09-27 11:20:03 +0100131 nfs_fscache_clear_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400133EXPORT_SYMBOL_GPL(nfs_clear_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
Al Virob57922d2010-06-07 14:34:48 -0400135void nfs_evict_inode(struct inode *inode)
136{
Johannes Weiner91b0abe2014-04-03 14:47:49 -0700137 truncate_inode_pages_final(&inode->i_data);
Jan Karadbd57682012-05-03 14:48:02 +0200138 clear_inode(inode);
Al Virob57922d2010-06-07 14:34:48 -0400139 nfs_clear_inode(inode);
140}
141
Trond Myklebust9e1681c2015-03-25 17:23:31 -0400142int nfs_sync_inode(struct inode *inode)
Trond Myklebust4d346bea2015-03-25 16:38:33 -0400143{
144 nfs_inode_dio_wait(inode);
145 return nfs_wb_all(inode);
146}
Trond Myklebust9e1681c2015-03-25 17:23:31 -0400147EXPORT_SYMBOL_GPL(nfs_sync_inode);
Trond Myklebust4d346bea2015-03-25 16:38:33 -0400148
Trond Myklebust29884df2005-12-13 16:13:54 -0500149/**
150 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
151 */
152int nfs_sync_mapping(struct address_space *mapping)
153{
Trond Myklebust5cf95212010-02-19 17:03:29 -0800154 int ret = 0;
Trond Myklebust29884df2005-12-13 16:13:54 -0500155
Trond Myklebust5cf95212010-02-19 17:03:29 -0800156 if (mapping->nrpages != 0) {
157 unmap_mapping_range(mapping, 0, 0, 0);
158 ret = nfs_wb_all(mapping->host);
159 }
Trond Myklebust29884df2005-12-13 16:13:54 -0500160 return ret;
161}
162
Trond Myklebust6edf9602014-06-20 13:11:01 -0400163static void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
164{
165 struct nfs_inode *nfsi = NFS_I(inode);
166
167 if (inode->i_mapping->nrpages == 0)
168 flags &= ~NFS_INO_INVALID_DATA;
169 nfsi->cache_validity |= flags;
170 if (flags & NFS_INO_INVALID_DATA)
171 nfs_fscache_invalidate(inode);
172}
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174/*
175 * Invalidate the local caches
176 */
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500177static void nfs_zap_caches_locked(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
179 struct nfs_inode *nfsi = NFS_I(inode);
180 int mode = inode->i_mode;
181
Chuck Lever91d5b472006-03-20 13:44:14 -0500182 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
183
Trond Myklebustc7c20972007-09-28 19:22:40 -0400184 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
185 nfsi->attrtimeo_timestamp = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Trond Myklebustc3f52af2012-09-03 14:56:02 -0400187 memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
David Howellsde242c02012-12-20 21:52:38 +0000188 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
Trond Myklebust6edf9602014-06-20 13:11:01 -0400189 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
David Quigleyaa9c2662013-05-22 12:50:44 -0400190 | NFS_INO_INVALID_DATA
191 | NFS_INO_INVALID_ACCESS
192 | NFS_INO_INVALID_ACL
Trond Myklebust6edf9602014-06-20 13:11:01 -0400193 | NFS_INO_REVAL_PAGECACHE);
David Quigleyaa9c2662013-05-22 12:50:44 -0400194 } else
Trond Myklebust6edf9602014-06-20 13:11:01 -0400195 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
David Quigleyaa9c2662013-05-22 12:50:44 -0400196 | NFS_INO_INVALID_ACCESS
197 | NFS_INO_INVALID_ACL
Trond Myklebust6edf9602014-06-20 13:11:01 -0400198 | NFS_INO_REVAL_PAGECACHE);
Trond Myklebustfd1defc2014-02-06 14:38:53 -0500199 nfs_zap_label_cache_locked(nfsi);
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500200}
Chuck Leverdc592502005-08-18 11:24:12 -0700201
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500202void nfs_zap_caches(struct inode *inode)
203{
204 spin_lock(&inode->i_lock);
205 nfs_zap_caches_locked(inode);
Chuck Leverdc592502005-08-18 11:24:12 -0700206 spin_unlock(&inode->i_lock);
Trond Myklebustada70d92005-06-22 17:16:22 +0000207}
208
Trond Myklebustcd9ae2b2006-10-19 23:28:40 -0700209void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
210{
211 if (mapping->nrpages != 0) {
212 spin_lock(&inode->i_lock);
Trond Myklebust6edf9602014-06-20 13:11:01 -0400213 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
Trond Myklebustcd9ae2b2006-10-19 23:28:40 -0700214 spin_unlock(&inode->i_lock);
215 }
216}
217
Trond Myklebustf41f7412008-06-11 17:39:04 -0400218void nfs_zap_acl_cache(struct inode *inode)
Trond Myklebustada70d92005-06-22 17:16:22 +0000219{
220 void (*clear_acl_cache)(struct inode *);
221
222 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
223 if (clear_acl_cache != NULL)
224 clear_acl_cache(inode);
Chuck Leverdc592502005-08-18 11:24:12 -0700225 spin_lock(&inode->i_lock);
Chuck Lever55296802005-08-18 11:24:09 -0700226 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
Chuck Leverdc592502005-08-18 11:24:12 -0700227 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228}
Bryan Schumaker1c606fb2012-07-30 16:05:24 -0400229EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Trond Myklebustc4812992007-09-28 17:11:45 -0400231void nfs_invalidate_atime(struct inode *inode)
232{
233 spin_lock(&inode->i_lock);
Trond Myklebust6edf9602014-06-20 13:11:01 -0400234 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
Trond Myklebustc4812992007-09-28 17:11:45 -0400235 spin_unlock(&inode->i_lock);
236}
Bryan Schumakerddda8e02012-07-30 16:05:23 -0400237EXPORT_SYMBOL_GPL(nfs_invalidate_atime);
Trond Myklebustc4812992007-09-28 17:11:45 -0400238
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239/*
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500240 * Invalidate, but do not unhash, the inode.
241 * NB: must be called with inode->i_lock held!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 */
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500243static void nfs_invalidate_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244{
Benny Halevy3a10c302008-01-23 08:58:59 +0200245 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500246 nfs_zap_caches_locked(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247}
248
249struct nfs_find_desc {
250 struct nfs_fh *fh;
251 struct nfs_fattr *fattr;
252};
253
254/*
255 * In NFSv3 we can have 64bit inode numbers. In order to support
256 * this, and re-exported directories (also seen in NFSv2)
257 * we are forced to allow 2 different inodes to have the same
258 * i_ino.
259 */
260static int
261nfs_find_actor(struct inode *inode, void *opaque)
262{
263 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
264 struct nfs_fh *fh = desc->fh;
265 struct nfs_fattr *fattr = desc->fattr;
266
267 if (NFS_FILEID(inode) != fattr->fileid)
268 return 0;
Jeff Laytonf6488c92013-02-27 20:10:34 -0500269 if ((S_IFMT & inode->i_mode) != (S_IFMT & fattr->mode))
270 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 if (nfs_compare_fh(NFS_FH(inode), fh))
272 return 0;
273 if (is_bad_inode(inode) || NFS_STALE(inode))
274 return 0;
275 return 1;
276}
277
278static int
279nfs_init_locked(struct inode *inode, void *opaque)
280{
281 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
282 struct nfs_fattr *fattr = desc->fattr;
283
Benny Halevy99fadcd2008-01-23 08:59:08 +0200284 set_nfs_fileid(inode, fattr->fileid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 nfs_copy_fh(NFS_FH(inode), desc->fh);
286 return 0;
287}
288
Steve Dicksone058f702013-05-22 12:50:40 -0400289#ifdef CONFIG_NFS_V4_SECURITY_LABEL
Trond Myklebustfd1defc2014-02-06 14:38:53 -0500290static void nfs_clear_label_invalid(struct inode *inode)
291{
292 spin_lock(&inode->i_lock);
293 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_LABEL;
294 spin_unlock(&inode->i_lock);
295}
296
David Quigleyaa9c2662013-05-22 12:50:44 -0400297void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
298 struct nfs4_label *label)
299{
300 int error;
301
302 if (label == NULL)
303 return;
304
David Quigleyaa9c2662013-05-22 12:50:44 -0400305 if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) && inode->i_security) {
306 error = security_inode_notifysecctx(inode, label->label,
307 label->len);
308 if (error)
309 printk(KERN_ERR "%s() %s %d "
310 "security_inode_notifysecctx() %d\n",
311 __func__,
312 (char *)label->label,
313 label->len, error);
Trond Myklebustfd1defc2014-02-06 14:38:53 -0500314 nfs_clear_label_invalid(inode);
David Quigleyaa9c2662013-05-22 12:50:44 -0400315 }
316}
317
Steve Dicksone058f702013-05-22 12:50:40 -0400318struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
319{
320 struct nfs4_label *label = NULL;
321 int minor_version = server->nfs_client->cl_minorversion;
322
323 if (minor_version < 2)
324 return label;
325
326 if (!(server->caps & NFS_CAP_SECURITY_LABEL))
327 return label;
328
329 label = kzalloc(sizeof(struct nfs4_label), flags);
330 if (label == NULL)
331 return ERR_PTR(-ENOMEM);
332
333 label->label = kzalloc(NFS4_MAXLABELLEN, flags);
334 if (label->label == NULL) {
335 kfree(label);
336 return ERR_PTR(-ENOMEM);
337 }
338 label->len = NFS4_MAXLABELLEN;
339
340 return label;
341}
342EXPORT_SYMBOL_GPL(nfs4_label_alloc);
David Quigleyaa9c2662013-05-22 12:50:44 -0400343#else
Trond Myklebust829e57d2013-11-18 14:33:50 -0500344void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
David Quigleyaa9c2662013-05-22 12:50:44 -0400345 struct nfs4_label *label)
346{
347}
Steve Dicksone058f702013-05-22 12:50:40 -0400348#endif
David Quigleyaa9c2662013-05-22 12:50:44 -0400349EXPORT_SYMBOL_GPL(nfs_setsecurity);
Steve Dicksone058f702013-05-22 12:50:40 -0400350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351/*
352 * This is our front-end to iget that looks up inodes by file handle
353 * instead of inode number.
354 */
355struct inode *
David Quigley1775fd32013-05-22 12:50:42 -0400356nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, struct nfs4_label *label)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357{
358 struct nfs_find_desc desc = {
359 .fh = fh,
360 .fattr = fattr
361 };
Trond Myklebust03f28e32006-03-20 13:44:48 -0500362 struct inode *inode = ERR_PTR(-ENOENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 unsigned long hash;
364
Bryan Schumaker7ebb9312011-03-24 17:12:30 +0000365 nfs_attr_check_mountpoint(sb, fattr);
366
Anna Schumaker2ef47eb2014-12-09 16:19:16 -0500367 if (nfs_attr_use_mounted_on_fileid(fattr))
368 fattr->fileid = fattr->mounted_on_fileid;
369 else if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 goto out_no_inode;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400371 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 goto out_no_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
374 hash = nfs_fattr_to_ino_t(fattr);
375
Trond Myklebust03f28e32006-03-20 13:44:48 -0500376 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
377 if (inode == NULL) {
378 inode = ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 goto out_no_inode;
Trond Myklebust03f28e32006-03-20 13:44:48 -0500380 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
382 if (inode->i_state & I_NEW) {
383 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebustb0c4fdd2007-02-05 14:44:22 -0800384 unsigned long now = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
386 /* We set i_ino for the few things that still rely on it,
387 * such as stat(2) */
388 inode->i_ino = hash;
389
390 /* We can't support update_atime(), since the server will reset it */
391 inode->i_flags |= S_NOATIME|S_NOCMTIME;
392 inode->i_mode = fattr->mode;
Trond Myklebust62ab460c2009-08-09 15:06:19 -0400393 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
394 && nfs_server_capable(inode, NFS_CAP_MODE))
Trond Myklebust6edf9602014-06-20 13:11:01 -0400395 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 /* Why so? Because we want revalidate for devices/FIFOs, and
397 * that's precisely what we have in nfs_file_inode_operations.
398 */
David Howells8fa5c002006-08-22 20:06:12 -0400399 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 if (S_ISREG(inode->i_mode)) {
Jeff Layton1788ea62011-11-04 13:31:21 -0400401 inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 inode->i_data.a_ops = &nfs_file_aops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 } else if (S_ISDIR(inode->i_mode)) {
David Howells8fa5c002006-08-22 20:06:12 -0400404 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 inode->i_fop = &nfs_dir_operations;
Trond Myklebust11de3b12010-12-01 14:17:06 -0500406 inode->i_data.a_ops = &nfs_dir_aops;
Trond Myklebust55a97592006-06-09 09:34:19 -0400407 /* Deal with crossing mountpoints */
Bryan Schumaker7ebb9312011-03-24 17:12:30 +0000408 if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
409 fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
Manoj Naik6b97fd32006-06-09 09:34:29 -0400410 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
411 inode->i_op = &nfs_referral_inode_operations;
412 else
413 inode->i_op = &nfs_mountpoint_inode_operations;
Trond Myklebust55a97592006-06-09 09:34:19 -0400414 inode->i_fop = NULL;
David Howells36d43a42011-01-14 18:45:42 +0000415 inode->i_flags |= S_AUTOMOUNT;
Trond Myklebust55a97592006-06-09 09:34:19 -0400416 }
Al Viro21fc61c2015-11-17 01:07:57 -0500417 } else if (S_ISLNK(inode->i_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 inode->i_op = &nfs_symlink_inode_operations;
Al Viro21fc61c2015-11-17 01:07:57 -0500419 inode_nohighmem(inode);
420 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 init_special_inode(inode, inode->i_mode, fattr->rdev);
422
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400423 memset(&inode->i_atime, 0, sizeof(inode->i_atime));
424 memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
425 memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
Trond Myklebusta9a4a872011-10-17 16:08:46 -0700426 inode->i_version = 0;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400427 inode->i_size = 0;
Miklos Szeredi6d6b77f2011-10-28 14:13:28 +0200428 clear_nlink(inode);
Eric W. Biederman9ff593c2013-02-01 14:26:23 -0800429 inode->i_uid = make_kuid(&init_user_ns, -2);
430 inode->i_gid = make_kgid(&init_user_ns, -2);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400431 inode->i_blocks = 0;
432 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
Andy Adamson2701d082012-05-24 13:13:24 -0400433 nfsi->write_io = 0;
434 nfsi->read_io = 0;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400435
Trond Myklebust33801142005-10-27 22:12:39 -0400436 nfsi->read_cache_jiffies = fattr->time_start;
Trond Myklebust4704f0e2008-10-14 19:16:07 -0400437 nfsi->attr_gencount = fattr->gencount;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400438 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
439 inode->i_atime = fattr->atime;
Trond Myklebust62ab460c2009-08-09 15:06:19 -0400440 else if (nfs_server_capable(inode, NFS_CAP_ATIME))
Trond Myklebust6edf9602014-06-20 13:11:01 -0400441 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400442 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
443 inode->i_mtime = fattr->mtime;
Trond Myklebust62ab460c2009-08-09 15:06:19 -0400444 else if (nfs_server_capable(inode, NFS_CAP_MTIME))
Trond Myklebust6edf9602014-06-20 13:11:01 -0400445 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400446 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
447 inode->i_ctime = fattr->ctime;
Trond Myklebust62ab460c2009-08-09 15:06:19 -0400448 else if (nfs_server_capable(inode, NFS_CAP_CTIME))
Trond Myklebust6edf9602014-06-20 13:11:01 -0400449 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400450 if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
Trond Myklebusta9a4a872011-10-17 16:08:46 -0700451 inode->i_version = fattr->change_attr;
Trond Myklebustcd812592015-07-05 11:12:07 -0400452 else
Trond Myklebust5c675d62015-07-05 16:07:04 -0400453 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
454 | NFS_INO_REVAL_PAGECACHE);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400455 if (fattr->valid & NFS_ATTR_FATTR_SIZE)
456 inode->i_size = nfs_size_to_loff_t(fattr->size);
Trond Myklebust62ab460c2009-08-09 15:06:19 -0400457 else
Trond Myklebust6edf9602014-06-20 13:11:01 -0400458 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
459 | NFS_INO_REVAL_PAGECACHE);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400460 if (fattr->valid & NFS_ATTR_FATTR_NLINK)
Miklos Szeredibfe86842011-10-28 14:13:29 +0200461 set_nlink(inode, fattr->nlink);
Trond Myklebust62ab460c2009-08-09 15:06:19 -0400462 else if (nfs_server_capable(inode, NFS_CAP_NLINK))
Trond Myklebust6edf9602014-06-20 13:11:01 -0400463 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400464 if (fattr->valid & NFS_ATTR_FATTR_OWNER)
465 inode->i_uid = fattr->uid;
Trond Myklebust62ab460c2009-08-09 15:06:19 -0400466 else if (nfs_server_capable(inode, NFS_CAP_OWNER))
Trond Myklebust6edf9602014-06-20 13:11:01 -0400467 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400468 if (fattr->valid & NFS_ATTR_FATTR_GROUP)
469 inode->i_gid = fattr->gid;
Trond Myklebust62ab460c2009-08-09 15:06:19 -0400470 else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP))
Trond Myklebust6edf9602014-06-20 13:11:01 -0400471 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400472 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
473 inode->i_blocks = fattr->du.nfs2.blocks;
474 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 /*
476 * report the blocks in 512byte units
477 */
478 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 }
David Quigleyaa9c2662013-05-22 12:50:44 -0400480
481 nfs_setsecurity(inode, fattr, label);
482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
Trond Myklebustb0c4fdd2007-02-05 14:44:22 -0800484 nfsi->attrtimeo_timestamp = now;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -0400485 nfsi->access_cache = RB_ROOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
David Howellsf1fe29b2013-09-27 11:20:03 +0100487 nfs_fscache_init_inode(inode);
David Howellsef79c092009-04-03 16:42:43 +0100488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 unlock_new_inode(inode);
490 } else
491 nfs_refresh_inode(inode, fattr);
Niels de Vos1e8968c2013-12-17 18:20:16 +0100492 dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 inode->i_sb->s_id,
Niels de Vos1e8968c2013-12-17 18:20:16 +0100494 (unsigned long long)NFS_FILEID(inode),
Weston Andros Adamson4f1abd22012-03-06 21:58:20 -0500495 nfs_display_fhandle_hash(fh),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 atomic_read(&inode->i_count));
497
498out:
499 return inode;
500
501out_no_inode:
Trond Myklebust03f28e32006-03-20 13:44:48 -0500502 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 goto out;
504}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400505EXPORT_SYMBOL_GPL(nfs_fhget);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Trond Myklebust536e43d2012-01-17 22:04:26 -0500507#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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
509int
510nfs_setattr(struct dentry *dentry, struct iattr *attr)
511{
David Howells2b0143b2015-03-17 22:25:59 +0000512 struct inode *inode = d_inode(dentry);
Trond Myklebust987f8df2010-04-16 16:22:52 -0400513 struct nfs_fattr *fattr;
Kinglong Meeae57ca02015-08-26 21:10:55 +0800514 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
Chuck Lever91d5b472006-03-20 13:44:14 -0500516 nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
517
Jeff Layton188b95d2007-10-18 03:05:21 -0700518 /* skip mode change if it's just for clearing setuid/setgid */
519 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
520 attr->ia_valid &= ~ATTR_MODE;
521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 if (attr->ia_valid & ATTR_SIZE) {
Christoph Hellwig08a899d2014-09-07 08:36:40 -0700523 BUG_ON(!S_ISREG(inode->i_mode));
524
Kinglong Meeae57ca02015-08-26 21:10:55 +0800525 error = inode_newsize_ok(inode, attr->ia_size);
526 if (error)
527 return error;
528
529 if (attr->ia_size == i_size_read(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 attr->ia_valid &= ~ATTR_SIZE;
531 }
532
533 /* Optimization: if the end result is no change, don't RPC */
534 attr->ia_valid &= NFS_VALID_ATTRS;
Trond Myklebust536e43d2012-01-17 22:04:26 -0500535 if ((attr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 return 0;
537
Trond Myklebustf4ce1292013-08-19 18:59:33 -0400538 trace_nfs_setattr_enter(inode);
539
Trond Myklebust755c1e22006-03-20 13:44:06 -0500540 /* Write all dirty data */
Trond Myklebust4d346bea2015-03-25 16:38:33 -0400541 if (S_ISREG(inode->i_mode))
542 nfs_sync_inode(inode);
Trond Myklebust987f8df2010-04-16 16:22:52 -0400543
544 fattr = nfs_alloc_fattr();
Kinglong Meeae57ca02015-08-26 21:10:55 +0800545 if (fattr == NULL) {
546 error = -ENOMEM;
Trond Myklebust987f8df2010-04-16 16:22:52 -0400547 goto out;
Kinglong Meeae57ca02015-08-26 21:10:55 +0800548 }
549
Trond Myklebust642ac542005-10-18 14:20:19 -0700550 /*
551 * Return any delegations if we're going to change ACLs
552 */
553 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
Bryan Schumaker57ec14c2012-06-20 15:53:44 -0400554 NFS_PROTO(inode)->return_delegation(inode);
Trond Myklebust987f8df2010-04-16 16:22:52 -0400555 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
Trond Myklebust65e43082005-08-16 11:49:44 -0400556 if (error == 0)
David Quigleyaa9c2662013-05-22 12:50:44 -0400557 error = nfs_refresh_inode(inode, fattr);
Trond Myklebust987f8df2010-04-16 16:22:52 -0400558 nfs_free_fattr(fattr);
559out:
Trond Myklebustf4ce1292013-08-19 18:59:33 -0400560 trace_nfs_setattr_exit(inode, error);
Trond Myklebust65e43082005-08-16 11:49:44 -0400561 return error;
562}
Bryan Schumakerddda8e02012-07-30 16:05:23 -0400563EXPORT_SYMBOL_GPL(nfs_setattr);
Trond Myklebust65e43082005-08-16 11:49:44 -0400564
565/**
Trond Myklebusta3d01452008-06-11 12:21:19 -0400566 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
567 * @inode: inode of the file used
568 * @offset: file offset to start truncating
569 *
570 * This is a copy of the common vmtruncate, but with the locking
571 * corrected to take into account the fact that NFS requires
572 * inode->i_size to be updated under the inode->i_lock.
Trond Myklebustf0446362015-02-26 16:09:04 -0500573 * Note: must be called with inode->i_lock held!
Trond Myklebusta3d01452008-06-11 12:21:19 -0400574 */
575static int nfs_vmtruncate(struct inode * inode, loff_t offset)
576{
npiggin@suse.dec08d3b02009-08-21 02:35:06 +1000577 int err;
Trond Myklebusta3d01452008-06-11 12:21:19 -0400578
npiggin@suse.dec08d3b02009-08-21 02:35:06 +1000579 err = inode_newsize_ok(inode, offset);
580 if (err)
581 goto out;
Trond Myklebusta3d01452008-06-11 12:21:19 -0400582
npiggin@suse.dec08d3b02009-08-21 02:35:06 +1000583 i_size_write(inode, offset);
Trond Myklebust6edf9602014-06-20 13:11:01 -0400584 /* Optimisation */
585 if (offset == 0)
586 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_DATA;
Trond Myklebusta3d01452008-06-11 12:21:19 -0400587
Trond Myklebustf0446362015-02-26 16:09:04 -0500588 spin_unlock(&inode->i_lock);
Kirill A. Shutemov7caef262013-09-12 15:13:56 -0700589 truncate_pagecache(inode, offset);
Trond Myklebustf0446362015-02-26 16:09:04 -0500590 spin_lock(&inode->i_lock);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +1000591out:
592 return err;
Trond Myklebusta3d01452008-06-11 12:21:19 -0400593}
594
595/**
Trond Myklebust65e43082005-08-16 11:49:44 -0400596 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
597 * @inode: pointer to struct inode
598 * @attr: pointer to struct iattr
599 *
600 * Note: we do this in the *proc.c in order to ensure that
601 * it works for things like exclusive creates too.
602 */
Trond Myklebustf0446362015-02-26 16:09:04 -0500603void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr,
604 struct nfs_fattr *fattr)
Trond Myklebust65e43082005-08-16 11:49:44 -0400605{
Trond Myklebustf0446362015-02-26 16:09:04 -0500606 /* Barrier: bump the attribute generation count. */
607 nfs_fattr_set_barrier(fattr);
608
609 spin_lock(&inode->i_lock);
610 NFS_I(inode)->attr_gencount = fattr->gencount;
Trond Myklebust65e43082005-08-16 11:49:44 -0400611 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 if ((attr->ia_valid & ATTR_MODE) != 0) {
Trond Myklebust65e43082005-08-16 11:49:44 -0400613 int mode = attr->ia_mode & S_IALLUGO;
614 mode |= inode->i_mode & ~S_IALLUGO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 inode->i_mode = mode;
616 }
617 if ((attr->ia_valid & ATTR_UID) != 0)
618 inode->i_uid = attr->ia_uid;
619 if ((attr->ia_valid & ATTR_GID) != 0)
620 inode->i_gid = attr->ia_gid;
Trond Myklebust6edf9602014-06-20 13:11:01 -0400621 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ACCESS
622 | NFS_INO_INVALID_ACL);
Trond Myklebust65e43082005-08-16 11:49:44 -0400623 }
624 if ((attr->ia_valid & ATTR_SIZE) != 0) {
Chuck Lever91d5b472006-03-20 13:44:14 -0500625 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
Trond Myklebusta3d01452008-06-11 12:21:19 -0400626 nfs_vmtruncate(inode, attr->ia_size);
Trond Myklebust65e43082005-08-16 11:49:44 -0400627 }
Jeff Layton616c3192015-11-25 13:50:45 -0500628 if (fattr->valid)
629 nfs_update_inode(inode, fattr);
630 else
631 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
Trond Myklebustf0446362015-02-26 16:09:04 -0500632 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633}
Bryan Schumakerddda8e02012-07-30 16:05:23 -0400634EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635
Trond Myklebust311324a2014-02-07 17:02:08 -0500636static void nfs_request_parent_use_readdirplus(struct dentry *dentry)
637{
638 struct dentry *parent;
639
640 parent = dget_parent(dentry);
David Howells2b0143b2015-03-17 22:25:59 +0000641 nfs_force_use_readdirplus(d_inode(parent));
Trond Myklebust311324a2014-02-07 17:02:08 -0500642 dput(parent);
643}
644
645static bool nfs_need_revalidate_inode(struct inode *inode)
646{
647 if (NFS_I(inode)->cache_validity &
648 (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))
649 return true;
650 if (nfs_attribute_cache_expired(inode))
651 return true;
652 return false;
653}
654
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
656{
David Howells2b0143b2015-03-17 22:25:59 +0000657 struct inode *inode = d_inode(dentry);
Chuck Lever55296802005-08-18 11:24:09 -0700658 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
Jan Kara16caf5b2014-10-23 14:02:47 +0200659 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
Trond Myklebustf4ce1292013-08-19 18:59:33 -0400661 trace_nfs_getattr_enter(inode);
Trond Myklebustacdc53b2010-02-19 17:03:26 -0800662 /* Flush out writes to the server in order to update c/mtime. */
Chuck Lever28c494c2007-10-26 13:32:13 -0400663 if (S_ISREG(inode->i_mode)) {
Al Viro59551022016-01-22 15:40:57 -0500664 inode_lock(inode);
Trond Myklebust4d346bea2015-03-25 16:38:33 -0400665 err = nfs_sync_inode(inode);
Al Viro59551022016-01-22 15:40:57 -0500666 inode_unlock(inode);
Trond Myklebustacdc53b2010-02-19 17:03:26 -0800667 if (err)
668 goto out;
Chuck Lever28c494c2007-10-26 13:32:13 -0400669 }
Christoph Hellwigfc33a7b2006-01-09 20:52:17 -0800670
671 /*
672 * We may force a getattr if the user cares about atime.
673 *
674 * Note that we only have to check the vfsmount flags here:
675 * - NFS always sets S_NOATIME by so checking it would give a
676 * bogus result
677 * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
678 * no point in checking those.
679 */
680 if ((mnt->mnt_flags & MNT_NOATIME) ||
681 ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 need_atime = 0;
Christoph Hellwigfc33a7b2006-01-09 20:52:17 -0800683
Trond Myklebust311324a2014-02-07 17:02:08 -0500684 if (need_atime || nfs_need_revalidate_inode(inode)) {
685 struct nfs_server *server = NFS_SERVER(inode);
686
687 if (server->caps & NFS_CAP_READDIRPLUS)
688 nfs_request_parent_use_readdirplus(dentry);
689 err = __nfs_revalidate_inode(server, inode);
690 }
Peter Staubach4e769b92007-08-03 15:07:10 -0400691 if (!err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 generic_fillattr(inode, stat);
Trond Myklebustf43bf0b2007-10-09 12:01:04 -0400693 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
NeilBrown7ef5ca42015-05-08 13:10:40 +1000694 if (S_ISDIR(inode->i_mode))
695 stat->blksize = NFS_SERVER(inode)->dtsize;
Peter Staubach4e769b92007-08-03 15:07:10 -0400696 }
Trond Myklebustacdc53b2010-02-19 17:03:26 -0800697out:
Trond Myklebustf4ce1292013-08-19 18:59:33 -0400698 trace_nfs_getattr_exit(inode, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 return err;
700}
Bryan Schumakerddda8e02012-07-30 16:05:23 -0400701EXPORT_SYMBOL_GPL(nfs_getattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400703static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
704{
705 atomic_set(&l_ctx->count, 1);
Trond Myklebust2a369152012-08-13 18:54:45 -0400706 l_ctx->lockowner.l_owner = current->files;
707 l_ctx->lockowner.l_pid = current->tgid;
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400708 INIT_LIST_HEAD(&l_ctx->list);
Benjamin Coddington210c7c12016-01-06 10:40:18 -0500709 atomic_set(&l_ctx->io_count, 0);
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400710}
711
712static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx)
713{
Trond Myklebust8c868992013-03-15 18:11:31 -0400714 struct nfs_lock_context *head = &ctx->lock_context;
715 struct nfs_lock_context *pos = head;
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400716
Trond Myklebust8c868992013-03-15 18:11:31 -0400717 do {
Trond Myklebust2a369152012-08-13 18:54:45 -0400718 if (pos->lockowner.l_owner != current->files)
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400719 continue;
Trond Myklebust2a369152012-08-13 18:54:45 -0400720 if (pos->lockowner.l_pid != current->tgid)
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400721 continue;
722 atomic_inc(&pos->count);
723 return pos;
Trond Myklebust8c868992013-03-15 18:11:31 -0400724 } while ((pos = list_entry(pos->list.next, typeof(*pos), list)) != head);
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400725 return NULL;
726}
727
728struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
729{
730 struct nfs_lock_context *res, *new = NULL;
David Howells2b0143b2015-03-17 22:25:59 +0000731 struct inode *inode = d_inode(ctx->dentry);
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400732
733 spin_lock(&inode->i_lock);
734 res = __nfs_find_lock_context(ctx);
735 if (res == NULL) {
736 spin_unlock(&inode->i_lock);
737 new = kmalloc(sizeof(*new), GFP_KERNEL);
738 if (new == NULL)
Trond Myklebustb3c54de2012-08-13 17:15:50 -0400739 return ERR_PTR(-ENOMEM);
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400740 nfs_init_lock_context(new);
741 spin_lock(&inode->i_lock);
742 res = __nfs_find_lock_context(ctx);
743 if (res == NULL) {
744 list_add_tail(&new->list, &ctx->lock_context.list);
745 new->open_context = ctx;
746 res = new;
747 new = NULL;
748 }
749 }
750 spin_unlock(&inode->i_lock);
751 kfree(new);
752 return res;
753}
Anna Schumaker1c6dcbe2014-09-26 13:58:48 -0400754EXPORT_SYMBOL_GPL(nfs_get_lock_context);
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400755
756void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
757{
758 struct nfs_open_context *ctx = l_ctx->open_context;
David Howells2b0143b2015-03-17 22:25:59 +0000759 struct inode *inode = d_inode(ctx->dentry);
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400760
761 if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock))
762 return;
763 list_del(&l_ctx->list);
764 spin_unlock(&inode->i_lock);
765 kfree(l_ctx);
766}
Anna Schumaker1c6dcbe2014-09-26 13:58:48 -0400767EXPORT_SYMBOL_GPL(nfs_put_lock_context);
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400768
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400769/**
770 * nfs_close_context - Common close_context() routine NFSv2/v3
771 * @ctx: pointer to context
772 * @is_sync: is this a synchronous close
773 *
Trond Myklebust5cf9d702015-09-04 15:07:37 -0400774 * Ensure that the attributes are up to date if we're mounted
775 * with close-to-open semantics and we have cached data that will
776 * need to be revalidated on open.
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400777 */
778void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
779{
Trond Myklebust5cf9d702015-09-04 15:07:37 -0400780 struct nfs_inode *nfsi;
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400781 struct inode *inode;
782 struct nfs_server *server;
783
784 if (!(ctx->mode & FMODE_WRITE))
785 return;
786 if (!is_sync)
787 return;
David Howells2b0143b2015-03-17 22:25:59 +0000788 inode = d_inode(ctx->dentry);
Trond Myklebust5cf9d702015-09-04 15:07:37 -0400789 nfsi = NFS_I(inode);
790 if (inode->i_mapping->nrpages == 0)
791 return;
792 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
793 return;
794 if (!list_empty(&nfsi->open_files))
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400795 return;
796 server = NFS_SERVER(inode);
797 if (server->flags & NFS_MOUNT_NOCTO)
798 return;
799 nfs_revalidate_inode(server, inode);
800}
Bryan Schumakerddda8e02012-07-30 16:05:23 -0400801EXPORT_SYMBOL_GPL(nfs_close_context);
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400802
Al Viro5ede7b12011-10-23 18:49:54 -0400803struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804{
805 struct nfs_open_context *ctx;
Al Viro5ede7b12011-10-23 18:49:54 -0400806 struct rpc_cred *cred = rpc_lookup_cred();
807 if (IS_ERR(cred))
808 return ERR_CAST(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
Panagiotis Issarisf52720c2006-09-27 01:49:39 -0700810 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
Al Viro5ede7b12011-10-23 18:49:54 -0400811 if (!ctx) {
812 put_rpccred(cred);
813 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 }
Al Viro5ede7b12011-10-23 18:49:54 -0400815 nfs_sb_active(dentry->d_sb);
816 ctx->dentry = dget(dentry);
817 ctx->cred = cred;
818 ctx->state = NULL;
819 ctx->mode = f_mode;
820 ctx->flags = 0;
821 ctx->error = 0;
822 nfs_init_lock_context(&ctx->lock_context);
823 ctx->lock_context.open_context = ctx;
824 INIT_LIST_HEAD(&ctx->list);
Andy Adamson82be4172012-05-23 05:02:35 -0400825 ctx->mdsthreshold = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 return ctx;
827}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400828EXPORT_SYMBOL_GPL(alloc_nfs_open_context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
830struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
831{
832 if (ctx != NULL)
Trond Myklebustf11ac8d2010-06-25 16:35:53 -0400833 atomic_inc(&ctx->lock_context.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 return ctx;
835}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400836EXPORT_SYMBOL_GPL(get_nfs_open_context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400838static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
Trond Myklebust3bec63d2007-06-17 16:02:44 -0400839{
David Howells2b0143b2015-03-17 22:25:59 +0000840 struct inode *inode = d_inode(ctx->dentry);
Al Viro3d4ff432011-06-22 18:40:12 -0400841 struct super_block *sb = ctx->dentry->d_sb;
Trond Myklebust3bec63d2007-06-17 16:02:44 -0400842
Trond Myklebust5c78f582010-09-27 15:51:20 -0400843 if (!list_empty(&ctx->list)) {
Benny Halevyef843032010-09-23 12:22:09 -0400844 if (!atomic_dec_and_lock(&ctx->lock_context.count, &inode->i_lock))
845 return;
846 list_del(&ctx->list);
847 spin_unlock(&inode->i_lock);
Benny Halevyef843032010-09-23 12:22:09 -0400848 } else if (!atomic_dec_and_test(&ctx->lock_context.count))
Trond Myklebust5e119342007-07-26 12:06:17 -0400849 return;
Trond Myklebust5c78f582010-09-27 15:51:20 -0400850 if (inode != NULL)
851 NFS_PROTO(inode)->close_context(ctx, is_sync);
Trond Myklebust3bec63d2007-06-17 16:02:44 -0400852 if (ctx->cred != NULL)
853 put_rpccred(ctx->cred);
Al Viro3d4ff432011-06-22 18:40:12 -0400854 dput(ctx->dentry);
Trond Myklebust322b2b92013-01-11 16:39:51 -0500855 nfs_sb_deactive(sb);
Andy Adamson82be4172012-05-23 05:02:35 -0400856 kfree(ctx->mdsthreshold);
Trond Myklebust3bec63d2007-06-17 16:02:44 -0400857 kfree(ctx);
858}
859
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400860void put_nfs_open_context(struct nfs_open_context *ctx)
861{
862 __put_nfs_open_context(ctx, 0);
863}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400864EXPORT_SYMBOL_GPL(put_nfs_open_context);
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400865
Trond Myklebust4eae5012015-09-04 15:17:53 -0400866static void put_nfs_open_context_sync(struct nfs_open_context *ctx)
867{
868 __put_nfs_open_context(ctx, 1);
869}
870
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871/*
872 * Ensure that mmap has a recent RPC credential for use when writing out
873 * shared pages
874 */
Trond Myklebustc45ffdd2013-05-29 13:34:46 -0400875void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876{
David Howells2b0143b2015-03-17 22:25:59 +0000877 struct inode *inode = d_inode(ctx->dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 struct nfs_inode *nfsi = NFS_I(inode);
879
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 spin_lock(&inode->i_lock);
881 list_add(&ctx->list, &nfsi->open_files);
882 spin_unlock(&inode->i_lock);
883}
Trond Myklebustc45ffdd2013-05-29 13:34:46 -0400884EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context);
885
886void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
887{
888 filp->private_data = get_nfs_open_context(ctx);
889 if (list_empty(&ctx->list))
890 nfs_inode_attach_open_context(ctx);
891}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400892EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
Trond Myklebustd5308382005-11-04 15:33:38 -0500894/*
895 * Given an inode, search for an open context with the desired characteristics
896 */
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500897struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898{
899 struct nfs_inode *nfsi = NFS_I(inode);
900 struct nfs_open_context *pos, *ctx = NULL;
901
902 spin_lock(&inode->i_lock);
903 list_for_each_entry(pos, &nfsi->open_files, list) {
Trond Myklebustd5308382005-11-04 15:33:38 -0500904 if (cred != NULL && pos->cred != cred)
905 continue;
Trond Myklebust1544fa02010-03-25 13:54:49 -0400906 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
907 continue;
908 ctx = get_nfs_open_context(pos);
909 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 }
911 spin_unlock(&inode->i_lock);
912 return ctx;
913}
914
Anna Schumakeraff8d8d2015-07-13 14:01:33 -0400915void nfs_file_clear_open_context(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916{
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400917 struct nfs_open_context *ctx = nfs_file_open_context(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
919 if (ctx) {
David Howells2b0143b2015-03-17 22:25:59 +0000920 struct inode *inode = d_inode(ctx->dentry);
Trond Myklebustc45ffdd2013-05-29 13:34:46 -0400921
Peng Tao0bcbf032015-12-05 15:57:31 +0800922 /*
923 * We fatal error on write before. Try to writeback
924 * every page again.
925 */
926 if (ctx->error < 0)
927 invalidate_inode_pages2(inode->i_mapping);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 filp->private_data = NULL;
929 spin_lock(&inode->i_lock);
930 list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
931 spin_unlock(&inode->i_lock);
Trond Myklebust4eae5012015-09-04 15:17:53 -0400932 put_nfs_open_context_sync(ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 }
934}
935
936/*
937 * These allocate and release file read/write context information.
938 */
939int nfs_open(struct inode *inode, struct file *filp)
940{
941 struct nfs_open_context *ctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
Al Viro5ede7b12011-10-23 18:49:54 -0400943 ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
944 if (IS_ERR(ctx))
945 return PTR_ERR(ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 nfs_file_set_open_context(filp, ctx);
947 put_nfs_open_context(ctx);
David Howellsf1fe29b2013-09-27 11:20:03 +0100948 nfs_fscache_open_file(inode, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 return 0;
950}
951
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952/*
953 * This function is called whenever some part of NFS notices that
954 * the cached attributes have to be refreshed.
955 */
956int
957__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
958{
959 int status = -ESTALE;
David Quigley1775fd32013-05-22 12:50:42 -0400960 struct nfs4_label *label = NULL;
Trond Myklebusta3cba2a2010-04-16 16:22:49 -0400961 struct nfs_fattr *fattr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 struct nfs_inode *nfsi = NFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
Niels de Vos1e8968c2013-12-17 18:20:16 +0100964 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Lu)\n",
965 inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
Trond Myklebustf4ce1292013-08-19 18:59:33 -0400967 trace_nfs_revalidate_inode_enter(inode);
968
Chuck Lever85233a72006-10-19 23:28:42 -0700969 if (is_bad_inode(inode))
Chuck Lever412d5822005-08-18 11:24:11 -0700970 goto out;
Trond Myklebust7fdc49c2007-09-28 19:11:33 -0400971 if (NFS_STALE(inode))
972 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973
Trond Myklebusta3cba2a2010-04-16 16:22:49 -0400974 status = -ENOMEM;
975 fattr = nfs_alloc_fattr();
976 if (fattr == NULL)
977 goto out;
978
Trond Myklebust691beb12008-10-05 14:48:22 -0400979 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
David Quigley14c43f72013-05-22 12:50:43 -0400980
981 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
982 if (IS_ERR(label)) {
983 status = PTR_ERR(label);
984 goto out;
985 }
986
David Quigley1775fd32013-05-22 12:50:42 -0400987 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, label);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 if (status != 0) {
Niels de Vos1e8968c2013-12-17 18:20:16 +0100989 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 inode->i_sb->s_id,
Niels de Vos1e8968c2013-12-17 18:20:16 +0100991 (unsigned long long)NFS_FILEID(inode), status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 if (status == -ESTALE) {
993 nfs_zap_caches(inode);
994 if (!S_ISDIR(inode->i_mode))
Benny Halevy3a10c302008-01-23 08:58:59 +0200995 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 }
David Quigley14c43f72013-05-22 12:50:43 -0400997 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 }
999
Trond Myklebusta3cba2a2010-04-16 16:22:49 -04001000 status = nfs_refresh_inode(inode, fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 if (status) {
Niels de Vos1e8968c2013-12-17 18:20:16 +01001002 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 inode->i_sb->s_id,
Niels de Vos1e8968c2013-12-17 18:20:16 +01001004 (unsigned long long)NFS_FILEID(inode), status);
David Quigley14c43f72013-05-22 12:50:43 -04001005 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 }
Chuck Lever55296802005-08-18 11:24:09 -07001007
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001008 if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
Trond Myklebustada70d92005-06-22 17:16:22 +00001009 nfs_zap_acl_cache(inode);
Chuck Lever55296802005-08-18 11:24:09 -07001010
Jeff Layton3da580a2013-11-02 06:57:18 -04001011 nfs_setsecurity(inode, fattr, label);
1012
Niels de Vos1e8968c2013-12-17 18:20:16 +01001013 dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 inode->i_sb->s_id,
Niels de Vos1e8968c2013-12-17 18:20:16 +01001015 (unsigned long long)NFS_FILEID(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016
David Quigley14c43f72013-05-22 12:50:43 -04001017err_out:
1018 nfs4_label_free(label);
1019out:
Trond Myklebusta3cba2a2010-04-16 16:22:49 -04001020 nfs_free_fattr(fattr);
Trond Myklebustf4ce1292013-08-19 18:59:33 -04001021 trace_nfs_revalidate_inode_exit(inode, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 return status;
1023}
1024
1025int nfs_attribute_timeout(struct inode *inode)
1026{
1027 struct nfs_inode *nfsi = NFS_I(inode);
1028
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -04001029 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
1030}
1031
Scott Mayhew43f291c2013-07-05 17:49:30 -04001032int nfs_attribute_cache_expired(struct inode *inode)
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -04001033{
Trond Myklebustb4d23142010-03-10 15:21:44 -05001034 if (nfs_have_delegated_attributes(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 return 0;
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -04001036 return nfs_attribute_timeout(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037}
1038
1039/**
1040 * nfs_revalidate_inode - Revalidate the inode attributes
1041 * @server - pointer to nfs_server struct
1042 * @inode - pointer to inode struct
1043 *
1044 * Updates inode attribute information by retrieving the data from the server.
1045 */
1046int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1047{
Trond Myklebust311324a2014-02-07 17:02:08 -05001048 if (!nfs_need_revalidate_inode(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 return NFS_STALE(inode) ? -ESTALE : 0;
1050 return __nfs_revalidate_inode(server, inode);
1051}
Bryan Schumaker1c606fb2012-07-30 16:05:24 -04001052EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
NeilBrown912a1082014-07-14 11:28:20 +10001054int nfs_revalidate_inode_rcu(struct nfs_server *server, struct inode *inode)
1055{
1056 if (!(NFS_I(inode)->cache_validity &
1057 (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))
1058 && !nfs_attribute_cache_expired(inode))
1059 return NFS_STALE(inode) ? -ESTALE : 0;
1060 return -ECHILD;
1061}
1062
Trond Myklebust1cda7072010-02-19 17:03:30 -08001063static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
Trond Myklebust717d44e2007-01-24 11:54:55 -08001064{
1065 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebustf8806c82013-08-05 13:26:31 -04001066 int ret;
1067
Trond Myklebust717d44e2007-01-24 11:54:55 -08001068 if (mapping->nrpages != 0) {
Trond Myklebustf8806c82013-08-05 13:26:31 -04001069 if (S_ISREG(inode->i_mode)) {
Trond Myklebustef070dc2015-03-03 00:06:35 -05001070 unmap_mapping_range(mapping, 0, 0, 0);
Trond Myklebustf8806c82013-08-05 13:26:31 -04001071 ret = nfs_sync_mapping(mapping);
1072 if (ret < 0)
1073 return ret;
1074 }
1075 ret = invalidate_inode_pages2(mapping);
Trond Myklebust717d44e2007-01-24 11:54:55 -08001076 if (ret < 0)
1077 return ret;
1078 }
Jeff Laytond529ef82014-01-27 13:46:15 -05001079 if (S_ISDIR(inode->i_mode)) {
1080 spin_lock(&inode->i_lock);
Trond Myklebust717d44e2007-01-24 11:54:55 -08001081 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
Jeff Laytond529ef82014-01-27 13:46:15 -05001082 spin_unlock(&inode->i_lock);
1083 }
Trond Myklebust717d44e2007-01-24 11:54:55 -08001084 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
David Howellsde242c02012-12-20 21:52:38 +00001085 nfs_fscache_wait_on_invalidate(inode);
Trond Myklebustf4ce1292013-08-19 18:59:33 -04001086
Niels de Vos1e8968c2013-12-17 18:20:16 +01001087 dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n",
1088 inode->i_sb->s_id,
1089 (unsigned long long)NFS_FILEID(inode));
Trond Myklebust717d44e2007-01-24 11:54:55 -08001090 return 0;
1091}
1092
Trond Myklebustb4b1ead2012-04-29 11:23:50 -04001093static bool nfs_mapping_need_revalidate_inode(struct inode *inode)
1094{
1095 if (nfs_have_delegated_attributes(inode))
1096 return false;
1097 return (NFS_I(inode)->cache_validity & NFS_INO_REVAL_PAGECACHE)
1098 || nfs_attribute_timeout(inode)
1099 || NFS_STALE(inode);
1100}
1101
Al Viro0d0def42015-11-17 21:14:24 -05001102int nfs_revalidate_mapping_rcu(struct inode *inode)
1103{
1104 struct nfs_inode *nfsi = NFS_I(inode);
1105 unsigned long *bitlock = &nfsi->flags;
1106 int ret = 0;
1107
1108 if (IS_SWAPFILE(inode))
1109 goto out;
1110 if (nfs_mapping_need_revalidate_inode(inode)) {
1111 ret = -ECHILD;
1112 goto out;
1113 }
1114 spin_lock(&inode->i_lock);
1115 if (test_bit(NFS_INO_INVALIDATING, bitlock) ||
1116 (nfsi->cache_validity & NFS_INO_INVALID_DATA))
1117 ret = -ECHILD;
1118 spin_unlock(&inode->i_lock);
1119out:
1120 return ret;
1121}
1122
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123/**
Trond Myklebust874f9462015-03-02 23:32:08 -05001124 * __nfs_revalidate_mapping - Revalidate the pagecache
Trond Myklebust7d52e862005-06-22 17:16:30 +00001125 * @inode - pointer to host inode
1126 * @mapping - pointer to mapping
Trond Myklebust874f9462015-03-02 23:32:08 -05001127 * @may_lock - take inode->i_mutex?
Trond Myklebust7d52e862005-06-22 17:16:30 +00001128 */
Trond Myklebust874f9462015-03-02 23:32:08 -05001129static int __nfs_revalidate_mapping(struct inode *inode,
1130 struct address_space *mapping,
1131 bool may_lock)
Trond Myklebust7d52e862005-06-22 17:16:30 +00001132{
1133 struct nfs_inode *nfsi = NFS_I(inode);
Jeff Laytond529ef82014-01-27 13:46:15 -05001134 unsigned long *bitlock = &nfsi->flags;
Trond Myklebust44b11872006-05-25 01:40:59 -04001135 int ret = 0;
1136
Mel Gorman29418aa2012-07-31 16:45:10 -07001137 /* swapfiles are not supposed to be shared. */
1138 if (IS_SWAPFILE(inode))
1139 goto out;
1140
Trond Myklebustb4b1ead2012-04-29 11:23:50 -04001141 if (nfs_mapping_need_revalidate_inode(inode)) {
Trond Myklebust44b11872006-05-25 01:40:59 -04001142 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
Trond Myklebust717d44e2007-01-24 11:54:55 -08001143 if (ret < 0)
1144 goto out;
Trond Myklebust7d52e862005-06-22 17:16:30 +00001145 }
Jeff Laytond529ef82014-01-27 13:46:15 -05001146
1147 /*
1148 * We must clear NFS_INO_INVALID_DATA first to ensure that
1149 * invalidations that come in while we're shooting down the mappings
1150 * are respected. But, that leaves a race window where one revalidator
1151 * can clear the flag, and then another checks it before the mapping
1152 * gets invalidated. Fix that by serializing access to this part of
1153 * the function.
1154 *
1155 * At the same time, we need to allow other tasks to see whether we
1156 * might be in the middle of invalidating the pages, so we only set
1157 * the bit lock here if it looks like we're going to be doing that.
1158 */
1159 for (;;) {
NeilBrown74316202014-07-07 15:16:04 +10001160 ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING,
1161 nfs_wait_bit_killable, TASK_KILLABLE);
Jeff Laytond529ef82014-01-27 13:46:15 -05001162 if (ret)
1163 goto out;
Trond Myklebust17dfeb92014-01-28 09:37:16 -05001164 spin_lock(&inode->i_lock);
1165 if (test_bit(NFS_INO_INVALIDATING, bitlock)) {
1166 spin_unlock(&inode->i_lock);
1167 continue;
1168 }
1169 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
Jeff Laytond529ef82014-01-27 13:46:15 -05001170 break;
Trond Myklebust17dfeb92014-01-28 09:37:16 -05001171 spin_unlock(&inode->i_lock);
1172 goto out;
Trond Myklebustf4ce1292013-08-19 18:59:33 -04001173 }
1174
Trond Myklebust17dfeb92014-01-28 09:37:16 -05001175 set_bit(NFS_INO_INVALIDATING, bitlock);
Jeff Layton4db72b42014-01-28 13:47:46 -05001176 smp_wmb();
Trond Myklebust17dfeb92014-01-28 09:37:16 -05001177 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
1178 spin_unlock(&inode->i_lock);
1179 trace_nfs_invalidate_mapping_enter(inode);
Trond Myklebust874f9462015-03-02 23:32:08 -05001180 if (may_lock) {
Al Viro59551022016-01-22 15:40:57 -05001181 inode_lock(inode);
Trond Myklebust874f9462015-03-02 23:32:08 -05001182 ret = nfs_invalidate_mapping(inode, mapping);
Al Viro59551022016-01-22 15:40:57 -05001183 inode_unlock(inode);
Trond Myklebust874f9462015-03-02 23:32:08 -05001184 } else
1185 ret = nfs_invalidate_mapping(inode, mapping);
Trond Myklebust17dfeb92014-01-28 09:37:16 -05001186 trace_nfs_invalidate_mapping_exit(inode, ret);
Trond Myklebust717d44e2007-01-24 11:54:55 -08001187
Jeff Laytond529ef82014-01-27 13:46:15 -05001188 clear_bit_unlock(NFS_INO_INVALIDATING, bitlock);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01001189 smp_mb__after_atomic();
Jeff Laytond529ef82014-01-27 13:46:15 -05001190 wake_up_bit(bitlock, NFS_INO_INVALIDATING);
Trond Myklebustcd9ae2b2006-10-19 23:28:40 -07001191out:
Trond Myklebust44b11872006-05-25 01:40:59 -04001192 return ret;
Trond Myklebust7d52e862005-06-22 17:16:30 +00001193}
1194
Trond Myklebust874f9462015-03-02 23:32:08 -05001195/**
1196 * nfs_revalidate_mapping - Revalidate the pagecache
1197 * @inode - pointer to host inode
1198 * @mapping - pointer to mapping
1199 */
1200int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
1201{
1202 return __nfs_revalidate_mapping(inode, mapping, false);
1203}
1204
1205/**
1206 * nfs_revalidate_mapping_protected - Revalidate the pagecache
1207 * @inode - pointer to host inode
1208 * @mapping - pointer to mapping
1209 *
1210 * Differs from nfs_revalidate_mapping() in that it grabs the inode->i_mutex
1211 * while invalidating the mapping.
1212 */
1213int nfs_revalidate_mapping_protected(struct inode *inode, struct address_space *mapping)
1214{
1215 return __nfs_revalidate_mapping(inode, mapping, true);
1216}
1217
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001218static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001219{
1220 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001221 unsigned long ret = 0;
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001222
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001223 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
1224 && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
Trond Myklebusta9a4a872011-10-17 16:08:46 -07001225 && inode->i_version == fattr->pre_change_attr) {
1226 inode->i_version = fattr->change_attr;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001227 if (S_ISDIR(inode->i_mode))
Trond Myklebust6edf9602014-06-20 13:11:01 -04001228 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001229 ret |= NFS_INO_INVALID_ATTR;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001230 }
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001231 /* If we have atomic WCC data, we may update some attributes */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001232 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
1233 && (fattr->valid & NFS_ATTR_FATTR_CTIME)
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001234 && timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
1235 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1236 ret |= NFS_INO_INVALID_ATTR;
1237 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001238
1239 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
1240 && (fattr->valid & NFS_ATTR_FATTR_MTIME)
1241 && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001242 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1243 if (S_ISDIR(inode->i_mode))
Trond Myklebust6edf9602014-06-20 13:11:01 -04001244 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001245 ret |= NFS_INO_INVALID_ATTR;
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001246 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001247 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
1248 && (fattr->valid & NFS_ATTR_FATTR_SIZE)
1249 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
Weston Andros Adamsoncb1410c2014-11-12 12:08:00 -05001250 && nfsi->nrequests == 0) {
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001251 i_size_write(inode, nfs_size_to_loff_t(fattr->size));
1252 ret |= NFS_INO_INVALID_ATTR;
1253 }
David Howellsde242c02012-12-20 21:52:38 +00001254
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001255 return ret;
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001256}
1257
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258/**
Trond Myklebust33801142005-10-27 22:12:39 -04001259 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 * @inode - pointer to inode
1261 * @fattr - updated attributes
1262 *
1263 * Verifies the attribute cache. If we have just changed the attributes,
1264 * so that fattr carries weak cache consistency data, then it may
1265 * also update the ctime/mtime/change_attribute.
1266 */
Trond Myklebust33801142005-10-27 22:12:39 -04001267static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268{
1269 struct nfs_inode *nfsi = NFS_I(inode);
1270 loff_t cur_size, new_isize;
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001271 unsigned long invalid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272
Chuck Leverdc592502005-08-18 11:24:12 -07001273
Trond Myklebust01da47b2012-04-29 12:30:19 -04001274 if (nfs_have_delegated_attributes(inode))
1275 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 /* Has the inode gone and changed behind our back? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001277 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 return -EIO;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001279 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
1280 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001282 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
Trond Myklebusta9a4a872011-10-17 16:08:46 -07001283 inode->i_version != fattr->change_attr)
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001284 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 /* Verify a few of the more important attributes */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001287 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))
Trond Myklebustfee7fe12012-04-27 13:48:18 -04001288 invalid |= NFS_INO_INVALID_ATTR;
Trond Myklebustca62b9c2006-03-20 13:44:07 -05001289
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001290 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1291 cur_size = i_size_read(inode);
1292 new_isize = nfs_size_to_loff_t(fattr->size);
Trond Myklebust85a23ce2015-07-05 11:02:53 -04001293 if (cur_size != new_isize)
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001294 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
1295 }
Trond Myklebust85a23ce2015-07-05 11:02:53 -04001296 if (nfsi->nrequests != 0)
1297 invalid &= ~NFS_INO_REVAL_PAGECACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
1299 /* Have any file permissions changed? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001300 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
1301 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
Eric W. Biederman9ff593c2013-02-01 14:26:23 -08001302 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001303 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
Eric W. Biederman9ff593c2013-02-01 14:26:23 -08001304 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001305 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
1307 /* Has the link count changed? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001308 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001309 invalid |= NFS_INO_INVALID_ATTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001311 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001312 invalid |= NFS_INO_INVALID_ATIME;
1313
1314 if (invalid != 0)
Trond Myklebust6edf9602014-06-20 13:11:01 -04001315 nfs_set_cache_invalid(inode, invalid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
Trond Myklebust33801142005-10-27 22:12:39 -04001317 nfsi->read_cache_jiffies = fattr->time_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 return 0;
1319}
1320
Trond Myklebustae05f262008-10-28 15:21:40 -04001321static atomic_long_t nfs_attr_generation_counter;
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001322
1323static unsigned long nfs_read_attr_generation_counter(void)
1324{
Trond Myklebustae05f262008-10-28 15:21:40 -04001325 return atomic_long_read(&nfs_attr_generation_counter);
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001326}
1327
1328unsigned long nfs_inc_attr_generation_counter(void)
1329{
Trond Myklebustae05f262008-10-28 15:21:40 -04001330 return atomic_long_inc_return(&nfs_attr_generation_counter);
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001331}
Trond Myklebust3235b402015-02-26 19:52:06 -05001332EXPORT_SYMBOL_GPL(nfs_inc_attr_generation_counter);
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001333
1334void nfs_fattr_init(struct nfs_fattr *fattr)
1335{
1336 fattr->valid = 0;
1337 fattr->time_start = jiffies;
1338 fattr->gencount = nfs_inc_attr_generation_counter();
Trond Myklebust6926afd2012-01-07 13:22:46 -05001339 fattr->owner_name = NULL;
1340 fattr->group_name = NULL;
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001341}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001342EXPORT_SYMBOL_GPL(nfs_fattr_init);
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001343
Trond Myklebust140e0492015-02-26 17:42:42 -05001344/**
1345 * nfs_fattr_set_barrier
1346 * @fattr: attributes
1347 *
1348 * Used to set a barrier after an attribute was updated. This
1349 * barrier ensures that older attributes from RPC calls that may
1350 * have raced with our update cannot clobber these new values.
1351 * Note that you are still responsible for ensuring that other
1352 * operations which change the attribute on the server do not
1353 * collide.
1354 */
1355void nfs_fattr_set_barrier(struct nfs_fattr *fattr)
1356{
1357 fattr->gencount = nfs_inc_attr_generation_counter();
1358}
1359
Trond Myklebust2d36bfde2010-04-16 16:22:45 -04001360struct nfs_fattr *nfs_alloc_fattr(void)
1361{
1362 struct nfs_fattr *fattr;
1363
1364 fattr = kmalloc(sizeof(*fattr), GFP_NOFS);
1365 if (fattr != NULL)
1366 nfs_fattr_init(fattr);
1367 return fattr;
1368}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001369EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
Trond Myklebust2d36bfde2010-04-16 16:22:45 -04001370
1371struct nfs_fh *nfs_alloc_fhandle(void)
1372{
1373 struct nfs_fh *fh;
1374
1375 fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS);
1376 if (fh != NULL)
1377 fh->size = 0;
1378 return fh;
1379}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001380EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
Trond Myklebust2d36bfde2010-04-16 16:22:45 -04001381
Trond Myklebuste27d3592012-03-18 14:07:42 -04001382#ifdef NFS_DEBUG
Weston Andros Adamsond8e05392012-03-06 20:46:43 -05001383/*
1384 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle
1385 * in the same way that wireshark does
1386 *
1387 * @fh: file handle
1388 *
1389 * For debugging only.
1390 */
1391u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
1392{
1393 /* wireshark uses 32-bit AUTODIN crc and does a bitwise
1394 * not on the result */
Trond Myklebust1264a2f2013-08-12 16:06:31 -04001395 return nfs_fhandle_hash(fh);
Weston Andros Adamsond8e05392012-03-06 20:46:43 -05001396}
Chuck Lever9e6ee762013-10-17 14:12:45 -04001397EXPORT_SYMBOL_GPL(_nfs_display_fhandle_hash);
Weston Andros Adamsond8e05392012-03-06 20:46:43 -05001398
1399/*
Chuck Lever20d27e92012-03-01 17:01:31 -05001400 * _nfs_display_fhandle - display an NFS file handle on the console
1401 *
1402 * @fh: file handle to display
1403 * @caption: display caption
1404 *
1405 * For debugging only.
1406 */
Chuck Lever20d27e92012-03-01 17:01:31 -05001407void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
1408{
1409 unsigned short i;
1410
Trond Myklebustfa68a1b2012-03-06 10:14:35 -05001411 if (fh == NULL || fh->size == 0) {
Chuck Lever20d27e92012-03-01 17:01:31 -05001412 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
1413 return;
1414 }
1415
Weston Andros Adamsond8e05392012-03-06 20:46:43 -05001416 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
1417 caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
Chuck Lever20d27e92012-03-01 17:01:31 -05001418 for (i = 0; i < fh->size; i += 16) {
1419 __be32 *pos = (__be32 *)&fh->data[i];
1420
1421 switch ((fh->size - i - 1) >> 2) {
1422 case 0:
1423 printk(KERN_DEFAULT " %08x\n",
1424 be32_to_cpup(pos));
1425 break;
1426 case 1:
1427 printk(KERN_DEFAULT " %08x %08x\n",
1428 be32_to_cpup(pos), be32_to_cpup(pos + 1));
1429 break;
1430 case 2:
1431 printk(KERN_DEFAULT " %08x %08x %08x\n",
1432 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1433 be32_to_cpup(pos + 2));
1434 break;
1435 default:
1436 printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
1437 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1438 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
1439 }
1440 }
1441}
Chuck Lever9e6ee762013-10-17 14:12:45 -04001442EXPORT_SYMBOL_GPL(_nfs_display_fhandle);
Chuck Lever20d27e92012-03-01 17:01:31 -05001443#endif
1444
1445/**
Trond Myklebusta10ad172008-09-23 17:28:41 -04001446 * nfs_inode_attrs_need_update - check if the inode attributes need updating
1447 * @inode - pointer to inode
1448 * @fattr - attributes
1449 *
1450 * Attempt to divine whether or not an RPC call reply carrying stale
1451 * attributes got scheduled after another call carrying updated ones.
1452 *
1453 * To do so, the function first assumes that a more recent ctime means
1454 * that the attributes in fattr are newer, however it also attempt to
1455 * catch the case where ctime either didn't change, or went backwards
1456 * (if someone reset the clock on the server) by looking at whether
1457 * or not this RPC call was started after the inode was last updated.
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001458 * Note also the check for wraparound of 'attr_gencount'
Trond Myklebusta10ad172008-09-23 17:28:41 -04001459 *
1460 * The function returns 'true' if it thinks the attributes in 'fattr' are
1461 * more recent than the ones cached in the inode.
1462 *
1463 */
1464static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1465{
1466 const struct nfs_inode *nfsi = NFS_I(inode);
1467
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001468 return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001469 ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
Trond Myklebusta10ad172008-09-23 17:28:41 -04001470}
1471
Trond Myklebustd8c951c2014-01-13 12:08:11 -05001472/*
1473 * Don't trust the change_attribute, mtime, ctime or size if
1474 * a pnfs LAYOUTCOMMIT is outstanding
1475 */
1476static void nfs_inode_attrs_handle_layoutcommit(struct inode *inode,
1477 struct nfs_fattr *fattr)
1478{
1479 if (pnfs_layoutcommit_outstanding(inode))
1480 fattr->valid &= ~(NFS_ATTR_FATTR_CHANGE |
1481 NFS_ATTR_FATTR_MTIME |
1482 NFS_ATTR_FATTR_CTIME |
1483 NFS_ATTR_FATTR_SIZE);
1484}
1485
Trond Myklebust870a5be2008-10-05 12:07:23 -04001486static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1487{
Trond Myklebustf4ce1292013-08-19 18:59:33 -04001488 int ret;
1489
1490 trace_nfs_refresh_inode_enter(inode);
1491
Trond Myklebustd8c951c2014-01-13 12:08:11 -05001492 nfs_inode_attrs_handle_layoutcommit(inode, fattr);
1493
Trond Myklebusta10ad172008-09-23 17:28:41 -04001494 if (nfs_inode_attrs_need_update(inode, fattr))
Trond Myklebustf4ce1292013-08-19 18:59:33 -04001495 ret = nfs_update_inode(inode, fattr);
1496 else
1497 ret = nfs_check_inode_attributes(inode, fattr);
1498
1499 trace_nfs_refresh_inode_exit(inode, ret);
1500 return ret;
Trond Myklebust870a5be2008-10-05 12:07:23 -04001501}
1502
Trond Myklebust33801142005-10-27 22:12:39 -04001503/**
1504 * nfs_refresh_inode - try to update the inode attribute cache
1505 * @inode - pointer to inode
1506 * @fattr - updated attributes
1507 *
1508 * Check that an RPC call that returned attributes has not overlapped with
1509 * other recent updates of the inode metadata, then decide whether it is
1510 * safe to do a full update of the inode attributes, or whether just to
1511 * call nfs_check_inode_attributes.
1512 */
1513int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1514{
Trond Myklebust33801142005-10-27 22:12:39 -04001515 int status;
1516
1517 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1518 return 0;
1519 spin_lock(&inode->i_lock);
Trond Myklebust870a5be2008-10-05 12:07:23 -04001520 status = nfs_refresh_inode_locked(inode, fattr);
Trond Myklebust33801142005-10-27 22:12:39 -04001521 spin_unlock(&inode->i_lock);
David Howellsef79c092009-04-03 16:42:43 +01001522
Trond Myklebust33801142005-10-27 22:12:39 -04001523 return status;
1524}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001525EXPORT_SYMBOL_GPL(nfs_refresh_inode);
Trond Myklebust33801142005-10-27 22:12:39 -04001526
Trond Myklebustd65f5572008-10-05 12:27:55 -04001527static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1528{
Trond Myklebust6edf9602014-06-20 13:11:01 -04001529 unsigned long invalid = NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
Trond Myklebustd65f5572008-10-05 12:27:55 -04001530
Trond Myklebustaaae3f02015-08-20 18:56:07 -05001531 /*
1532 * Don't revalidate the pagecache if we hold a delegation, but do
1533 * force an attribute update
1534 */
1535 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1536 invalid = NFS_INO_INVALID_ATTR|NFS_INO_REVAL_FORCED;
1537
Trond Myklebust6edf9602014-06-20 13:11:01 -04001538 if (S_ISDIR(inode->i_mode))
1539 invalid |= NFS_INO_INVALID_DATA;
1540 nfs_set_cache_invalid(inode, invalid);
Trond Myklebustd65f5572008-10-05 12:27:55 -04001541 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1542 return 0;
1543 return nfs_refresh_inode_locked(inode, fattr);
1544}
1545
Trond Myklebustdecf4912005-10-27 22:12:39 -04001546/**
1547 * nfs_post_op_update_inode - try to update the inode attribute cache
1548 * @inode - pointer to inode
1549 * @fattr - updated attributes
1550 *
1551 * After an operation that has changed the inode metadata, mark the
1552 * attribute cache as being invalid, then try to update it.
Chuck Leverf551e442006-09-20 14:33:04 -04001553 *
1554 * NB: if the server didn't return any post op attributes, this
1555 * function will force the retrieval of attributes before the next
1556 * NFS request. Thus it should be used only for operations that
1557 * are expected to change one or more attributes, to avoid
1558 * unnecessary NFS requests and trips through nfs_update_inode().
Trond Myklebustdecf4912005-10-27 22:12:39 -04001559 */
1560int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1561{
Trond Myklebustd65f5572008-10-05 12:27:55 -04001562 int status;
Trond Myklebustdecf4912005-10-27 22:12:39 -04001563
Trond Myklebust7668fdb2007-10-01 09:59:15 -04001564 spin_lock(&inode->i_lock);
Trond Myklebust92d64e42015-02-26 19:48:26 -05001565 nfs_fattr_set_barrier(fattr);
Trond Myklebustd65f5572008-10-05 12:27:55 -04001566 status = nfs_post_op_update_inode_locked(inode, fattr);
Trond Myklebust7668fdb2007-10-01 09:59:15 -04001567 spin_unlock(&inode->i_lock);
David Quigleyaa9c2662013-05-22 12:50:44 -04001568
Trond Myklebust870a5be2008-10-05 12:07:23 -04001569 return status;
Trond Myklebustdecf4912005-10-27 22:12:39 -04001570}
Bryan Schumaker1c606fb2012-07-30 16:05:24 -04001571EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
Trond Myklebustdecf4912005-10-27 22:12:39 -04001572
Trond Myklebust70ca8852007-09-30 15:21:24 -04001573/**
Trond Myklebusta08a8cd2015-02-26 17:36:09 -05001574 * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache
Trond Myklebust70ca8852007-09-30 15:21:24 -04001575 * @inode - pointer to inode
1576 * @fattr - updated attributes
1577 *
1578 * After an operation that has changed the inode metadata, mark the
1579 * attribute cache as being invalid, then try to update it. Fake up
1580 * weak cache consistency data, if none exist.
1581 *
1582 * This function is mainly designed to be used by the ->write_done() functions.
1583 */
Trond Myklebusta08a8cd2015-02-26 17:36:09 -05001584int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr)
Trond Myklebust70ca8852007-09-30 15:21:24 -04001585{
Trond Myklebustd65f5572008-10-05 12:27:55 -04001586 int status;
1587
Trond Myklebustd65f5572008-10-05 12:27:55 -04001588 /* Don't do a WCC update if these attributes are already stale */
1589 if ((fattr->valid & NFS_ATTR_FATTR) == 0 ||
1590 !nfs_inode_attrs_need_update(inode, fattr)) {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001591 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
1592 | NFS_ATTR_FATTR_PRESIZE
1593 | NFS_ATTR_FATTR_PREMTIME
1594 | NFS_ATTR_FATTR_PRECTIME);
Trond Myklebustd65f5572008-10-05 12:27:55 -04001595 goto out_noforce;
1596 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001597 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1598 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
Trond Myklebusta9a4a872011-10-17 16:08:46 -07001599 fattr->pre_change_attr = inode->i_version;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001600 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001601 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001602 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
1603 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
Trond Myklebust70ca8852007-09-30 15:21:24 -04001604 memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001605 fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
1606 }
1607 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
1608 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
Trond Myklebust70ca8852007-09-30 15:21:24 -04001609 memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001610 fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
1611 }
1612 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
1613 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
Trond Myklebusta3d01452008-06-11 12:21:19 -04001614 fattr->pre_size = i_size_read(inode);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001615 fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001616 }
Trond Myklebustd65f5572008-10-05 12:27:55 -04001617out_noforce:
1618 status = nfs_post_op_update_inode_locked(inode, fattr);
Trond Myklebusta08a8cd2015-02-26 17:36:09 -05001619 return status;
1620}
1621
1622/**
1623 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
1624 * @inode - pointer to inode
1625 * @fattr - updated attributes
1626 *
1627 * After an operation that has changed the inode metadata, mark the
1628 * attribute cache as being invalid, then try to update it. Fake up
1629 * weak cache consistency data, if none exist.
1630 *
1631 * This function is mainly designed to be used by the ->write_done() functions.
1632 */
1633int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
1634{
1635 int status;
1636
1637 spin_lock(&inode->i_lock);
Trond Myklebust8f8ba1d2015-02-26 17:54:58 -05001638 nfs_fattr_set_barrier(fattr);
Trond Myklebusta08a8cd2015-02-26 17:36:09 -05001639 status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
Trond Myklebustd65f5572008-10-05 12:27:55 -04001640 spin_unlock(&inode->i_lock);
1641 return status;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001642}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001643EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
Trond Myklebust70ca8852007-09-30 15:21:24 -04001644
Anna Schumakerea96d1e2015-04-03 14:35:59 -04001645
1646static inline bool nfs_fileid_valid(struct nfs_inode *nfsi,
1647 struct nfs_fattr *fattr)
1648{
1649 bool ret1 = true, ret2 = true;
1650
1651 if (fattr->valid & NFS_ATTR_FATTR_FILEID)
1652 ret1 = (nfsi->fileid == fattr->fileid);
1653 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
1654 ret2 = (nfsi->fileid == fattr->mounted_on_fileid);
1655 return ret1 || ret2;
1656}
1657
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658/*
1659 * Many nfs protocol calls return the new file attributes after
1660 * an operation. Here we update the inode to reflect the state
1661 * of the server's inode.
1662 *
1663 * This is a bit tricky because we have to make sure all dirty pages
1664 * have been sent off to the server before calling invalidate_inode_pages.
1665 * To make sure no other process adds more write requests while we try
1666 * our best to flush them, we make them sleep during the attribute refresh.
1667 *
1668 * A very similar scenario holds for the dir cache.
1669 */
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001670static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671{
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -04001672 struct nfs_server *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust951a1432005-06-22 17:16:30 +00001674 loff_t cur_isize, new_isize;
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001675 unsigned long invalid = 0;
Trond Myklebust3e7d9502007-02-05 14:26:28 -08001676 unsigned long now = jiffies;
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001677 unsigned long save_cache_validity;
Trond Myklebustade14a72015-12-29 18:55:19 -05001678 bool cache_revalidated = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
Niels de Vos1e8968c2013-12-17 18:20:16 +01001680 dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%x)\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -07001681 __func__, inode->i_sb->s_id, inode->i_ino,
Weston Andros Adamson4f1abd22012-03-06 21:58:20 -05001682 nfs_display_fhandle_hash(NFS_FH(inode)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 atomic_read(&inode->i_count), fattr->valid);
1684
Anna Schumakerea96d1e2015-04-03 14:35:59 -04001685 if (!nfs_fileid_valid(nfsi, fattr)) {
Matthew Treinishe73e6c92012-04-30 11:32:57 -04001686 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
1687 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
1688 NFS_SERVER(inode)->nfs_client->cl_hostname,
1689 inode->i_sb->s_id, (long long)nfsi->fileid,
1690 (long long)fattr->fileid);
1691 goto out_err;
1692 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693
1694 /*
1695 * Make sure the inode's type hasn't changed.
1696 */
Matthew Treinishe73e6c92012-04-30 11:32:57 -04001697 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
1698 /*
1699 * Big trouble! The inode has become a different object.
1700 */
Niels de Vos1e8968c2013-12-17 18:20:16 +01001701 printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
Matthew Treinishe73e6c92012-04-30 11:32:57 -04001702 __func__, inode->i_ino, inode->i_mode, fattr->mode);
1703 goto out_err;
1704 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -04001706 server = NFS_SERVER(inode);
Trond Myklebusta0356862007-06-05 13:26:15 -04001707 /* Update the fsid? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001708 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
Trond Myklebustc37dcd332008-03-06 12:34:50 -05001709 !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
David Howells36d43a42011-01-14 18:45:42 +00001710 !IS_AUTOMOUNT(inode))
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -04001711 server->fsid = fattr->fsid;
1712
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 /*
1714 * Update the read time so we don't revalidate too often.
1715 */
Trond Myklebust33801142005-10-27 22:12:39 -04001716 nfsi->read_cache_jiffies = fattr->time_start;
Trond Myklebust3e7d9502007-02-05 14:26:28 -08001717
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001718 save_cache_validity = nfsi->cache_validity;
1719 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
1720 | NFS_INO_INVALID_ATIME
1721 | NFS_INO_REVAL_FORCED
1722 | NFS_INO_REVAL_PAGECACHE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001724 /* Do atomic weak cache consistency updates */
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001725 invalid |= nfs_wcc_update_inode(inode, fattr);
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001726
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001727 /* More cache consistency checks */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001728 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
Trond Myklebusta9a4a872011-10-17 16:08:46 -07001729 if (inode->i_version != fattr->change_attr) {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001730 dprintk("NFS: change_attr change on server for file %s/%ld\n",
1731 inode->i_sb->s_id, inode->i_ino);
Trond Myklebust6a4506c2012-04-27 13:48:17 -04001732 invalid |= NFS_INO_INVALID_ATTR
1733 | NFS_INO_INVALID_DATA
1734 | NFS_INO_INVALID_ACCESS
Trond Myklebust85a23ce2015-07-05 11:02:53 -04001735 | NFS_INO_INVALID_ACL;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001736 if (S_ISDIR(inode->i_mode))
1737 nfs_force_lookup_revalidate(inode);
Trond Myklebusta9a4a872011-10-17 16:08:46 -07001738 inode->i_version = fattr->change_attr;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001739 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001740 } else {
Trond Myklebust43b65352014-04-15 10:07:57 -04001741 nfsi->cache_validity |= save_cache_validity;
Trond Myklebustade14a72015-12-29 18:55:19 -05001742 cache_revalidated = false;
1743 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001744
1745 if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
Trond Myklebustfee7fe12012-04-27 13:48:18 -04001746 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
Trond Myklebustade14a72015-12-29 18:55:19 -05001747 } else if (server->caps & NFS_CAP_MTIME) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001748 nfsi->cache_validity |= save_cache_validity &
1749 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001750 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001751 cache_revalidated = false;
1752 }
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001753
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001754 if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
Trond Myklebustfee7fe12012-04-27 13:48:18 -04001755 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
Trond Myklebustade14a72015-12-29 18:55:19 -05001756 } else if (server->caps & NFS_CAP_CTIME) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001757 nfsi->cache_validity |= save_cache_validity &
1758 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001759 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001760 cache_revalidated = false;
1761 }
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001762
Trond Myklebust951a1432005-06-22 17:16:30 +00001763 /* Check if our cached file size is stale */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001764 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1765 new_isize = nfs_size_to_loff_t(fattr->size);
1766 cur_isize = i_size_read(inode);
1767 if (new_isize != cur_isize) {
1768 /* Do we perhaps have any outstanding writes, or has
1769 * the file grown beyond our last write? */
Weston Andros Adamsoncb1410c2014-11-12 12:08:00 -05001770 if ((nfsi->nrequests == 0) || new_isize > cur_isize) {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001771 i_size_write(inode, new_isize);
1772 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1773 }
Harshula Jayasuriya60c16ea2011-05-23 22:52:11 +10001774 dprintk("NFS: isize change on server for file %s/%ld "
1775 "(%Ld to %Ld)\n",
1776 inode->i_sb->s_id,
1777 inode->i_ino,
1778 (long long)cur_isize,
1779 (long long)new_isize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001781 } else {
Trond Myklebust43b65352014-04-15 10:07:57 -04001782 nfsi->cache_validity |= save_cache_validity &
1783 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001784 | NFS_INO_REVAL_PAGECACHE
1785 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001786 cache_revalidated = false;
1787 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001790 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
1791 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
Trond Myklebustade14a72015-12-29 18:55:19 -05001792 else if (server->caps & NFS_CAP_ATIME) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001793 nfsi->cache_validity |= save_cache_validity &
1794 (NFS_INO_INVALID_ATIME
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001795 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001796 cache_revalidated = false;
1797 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001799 if (fattr->valid & NFS_ATTR_FATTR_MODE) {
1800 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
Trond Myklebust9b4b3512010-02-03 08:27:35 -05001801 umode_t newmode = inode->i_mode & S_IFMT;
1802 newmode |= fattr->mode & S_IALLUGO;
1803 inode->i_mode = newmode;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001804 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001805 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001806 } else if (server->caps & NFS_CAP_MODE) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001807 nfsi->cache_validity |= save_cache_validity &
1808 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001809 | NFS_INO_INVALID_ACCESS
1810 | NFS_INO_INVALID_ACL
1811 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001812 cache_revalidated = false;
1813 }
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001814
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001815 if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
Eric W. Biederman9ff593c2013-02-01 14:26:23 -08001816 if (!uid_eq(inode->i_uid, fattr->uid)) {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001817 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1818 inode->i_uid = fattr->uid;
1819 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001820 } else if (server->caps & NFS_CAP_OWNER) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001821 nfsi->cache_validity |= save_cache_validity &
1822 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001823 | NFS_INO_INVALID_ACCESS
1824 | NFS_INO_INVALID_ACL
1825 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001826 cache_revalidated = false;
1827 }
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001828
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001829 if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
Eric W. Biederman9ff593c2013-02-01 14:26:23 -08001830 if (!gid_eq(inode->i_gid, fattr->gid)) {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001831 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1832 inode->i_gid = fattr->gid;
1833 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001834 } else if (server->caps & NFS_CAP_OWNER_GROUP) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001835 nfsi->cache_validity |= save_cache_validity &
1836 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001837 | NFS_INO_INVALID_ACCESS
1838 | NFS_INO_INVALID_ACL
1839 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001840 cache_revalidated = false;
1841 }
Trond Myklebust921615f2008-10-14 19:23:07 -04001842
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001843 if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
1844 if (inode->i_nlink != fattr->nlink) {
1845 invalid |= NFS_INO_INVALID_ATTR;
1846 if (S_ISDIR(inode->i_mode))
1847 invalid |= NFS_INO_INVALID_DATA;
Miklos Szeredibfe86842011-10-28 14:13:29 +02001848 set_nlink(inode, fattr->nlink);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001849 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001850 } else if (server->caps & NFS_CAP_NLINK) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001851 nfsi->cache_validity |= save_cache_validity &
1852 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001853 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001854 cache_revalidated = false;
1855 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001857 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 /*
1859 * report the blocks in 512byte units
1860 */
1861 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
Trond Myklebustade14a72015-12-29 18:55:19 -05001862 } else if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001863 inode->i_blocks = fattr->du.nfs2.blocks;
Trond Myklebustade14a72015-12-29 18:55:19 -05001864 else
1865 cache_revalidated = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866
1867 /* Update attrtimeo value if we're out of the unstable period */
Trond Myklebustfd1defc2014-02-06 14:38:53 -05001868 if (invalid & NFS_INO_INVALID_ATTR) {
Chuck Lever91d5b472006-03-20 13:44:14 -05001869 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
Trond Myklebust3e7d9502007-02-05 14:26:28 -08001871 nfsi->attrtimeo_timestamp = now;
Trond Myklebustf5062002015-02-26 19:34:32 -05001872 /* Set barrier to be more recent than all outstanding updates */
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001873 nfsi->attr_gencount = nfs_inc_attr_generation_counter();
Trond Myklebust6d2b2962007-10-01 18:57:50 -04001874 } else {
Trond Myklebustade14a72015-12-29 18:55:19 -05001875 if (cache_revalidated) {
1876 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp,
1877 nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
1878 nfsi->attrtimeo <<= 1;
1879 if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode))
1880 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
1881 }
Trond Myklebust6d2b2962007-10-01 18:57:50 -04001882 nfsi->attrtimeo_timestamp = now;
1883 }
Trond Myklebustf5062002015-02-26 19:34:32 -05001884 /* Set the barrier to be more recent than this fattr */
1885 if ((long)fattr->gencount - (long)nfsi->attr_gencount > 0)
1886 nfsi->attr_gencount = fattr->gencount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 }
Jeff Laytonc8120122015-11-25 13:50:11 -05001888
1889 /* Don't declare attrcache up to date if there were no attrs! */
Trond Myklebustade14a72015-12-29 18:55:19 -05001890 if (cache_revalidated)
Jeff Laytonc8120122015-11-25 13:50:11 -05001891 invalid &= ~NFS_INO_INVALID_ATTR;
1892
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 /* Don't invalidate the data if we were to blame */
1894 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
1895 || S_ISLNK(inode->i_mode)))
1896 invalid &= ~NFS_INO_INVALID_DATA;
Bryan Schumaker011e2a72012-06-20 15:53:43 -04001897 if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ) ||
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001898 (save_cache_validity & NFS_INO_REVAL_FORCED))
Trond Myklebust6edf9602014-06-20 13:11:01 -04001899 nfs_set_cache_invalid(inode, invalid);
David Howellsde242c02012-12-20 21:52:38 +00001900
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 return 0;
Trond Myklebustb37b03b2005-11-25 17:10:06 -05001902 out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 /*
1904 * No need to worry about unhashing the dentry, as the
1905 * lookup validation will know that the inode is bad.
1906 * (But we fall through to invalidate the caches.)
1907 */
1908 nfs_invalidate_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 return -ESTALE;
1910}
1911
David Howellsf7b422b2006-06-09 09:34:33 -04001912struct inode *nfs_alloc_inode(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913{
1914 struct nfs_inode *nfsi;
Firo Yangc456aac2015-04-23 17:17:51 +08001915 nfsi = kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 if (!nfsi)
1917 return NULL;
Chuck Lever55296802005-08-18 11:24:09 -07001918 nfsi->flags = 0UL;
1919 nfsi->cache_validity = 0UL;
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001920#if IS_ENABLED(CONFIG_NFS_V4)
J. Bruce Fieldse50a1c22005-06-22 17:16:23 +00001921 nfsi->nfs4_acl = NULL;
1922#endif /* CONFIG_NFS_V4 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 return &nfsi->vfs_inode;
1924}
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001925EXPORT_SYMBOL_GPL(nfs_alloc_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +11001927static void nfs_i_callback(struct rcu_head *head)
1928{
1929 struct inode *inode = container_of(head, struct inode, i_rcu);
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +11001930 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
1931}
1932
David Howellsf7b422b2006-06-09 09:34:33 -04001933void nfs_destroy_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +11001935 call_rcu(&inode->i_rcu, nfs_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936}
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001937EXPORT_SYMBOL_GPL(nfs_destroy_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938
Andrew Mortond75d5412006-06-25 02:41:26 -07001939static inline void nfs4_init_once(struct nfs_inode *nfsi)
1940{
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001941#if IS_ENABLED(CONFIG_NFS_V4)
Andrew Mortond75d5412006-06-25 02:41:26 -07001942 INIT_LIST_HEAD(&nfsi->open_states);
1943 nfsi->delegation = NULL;
Andrew Mortond75d5412006-06-25 02:41:26 -07001944 init_rwsem(&nfsi->rwsem);
Benny Halevye5e94012010-10-20 00:18:01 -04001945 nfsi->layout = NULL;
Andrew Mortond75d5412006-06-25 02:41:26 -07001946#endif
1947}
David Howellsf7b422b2006-06-09 09:34:33 -04001948
Alexey Dobriyan51cc5062008-07-25 19:45:34 -07001949static void init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950{
1951 struct nfs_inode *nfsi = (struct nfs_inode *) foo;
1952
Christoph Lametera35afb82007-05-16 22:10:57 -07001953 inode_init_once(&nfsi->vfs_inode);
Christoph Lametera35afb82007-05-16 22:10:57 -07001954 INIT_LIST_HEAD(&nfsi->open_files);
1955 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
1956 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
Fred Isamanea2cf222012-04-20 14:47:53 -04001957 INIT_LIST_HEAD(&nfsi->commit_info.list);
Weston Andros Adamsoncb1410c2014-11-12 12:08:00 -05001958 nfsi->nrequests = 0;
Fred Isamanea2cf222012-04-20 14:47:53 -04001959 nfsi->commit_info.ncommit = 0;
Trond Myklebust1a0de482012-06-19 18:38:56 -04001960 atomic_set(&nfsi->commit_info.rpcs_out, 0);
Trond Myklebust565277f2007-10-15 18:17:53 -04001961 atomic_set(&nfsi->silly_count, 1);
1962 INIT_HLIST_HEAD(&nfsi->silly_list);
1963 init_waitqueue_head(&nfsi->waitqueue);
Christoph Lametera35afb82007-05-16 22:10:57 -07001964 nfs4_init_once(nfsi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965}
Paul Mundt20c2df82007-07-20 10:11:58 +09001966
David Howellsf7b422b2006-06-09 09:34:33 -04001967static int __init nfs_init_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968{
1969 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
1970 sizeof(struct nfs_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -08001971 0, (SLAB_RECLAIM_ACCOUNT|
Vladimir Davydov5d097052016-01-14 15:18:21 -08001972 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
Paul Mundt20c2df82007-07-20 10:11:58 +09001973 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 if (nfs_inode_cachep == NULL)
1975 return -ENOMEM;
1976
1977 return 0;
1978}
1979
David Brownell266bee82006-06-27 12:59:15 -07001980static void nfs_destroy_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981{
Kirill A. Shutemov8c0a8532012-09-26 11:33:07 +10001982 /*
1983 * Make sure all delayed rcu free inodes are flushed before we
1984 * destroy cache.
1985 */
1986 rcu_barrier();
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001987 kmem_cache_destroy(nfs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988}
1989
Trond Myklebust57460062008-02-19 20:04:22 -05001990struct workqueue_struct *nfsiod_workqueue;
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001991EXPORT_SYMBOL_GPL(nfsiod_workqueue);
Trond Myklebust57460062008-02-19 20:04:22 -05001992
1993/*
1994 * start up the nfsiod workqueue
1995 */
1996static int nfsiod_start(void)
1997{
1998 struct workqueue_struct *wq;
1999 dprintk("RPC: creating workqueue nfsiod\n");
Tejun Heoada609e2011-01-25 14:35:54 +01002000 wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
Trond Myklebust57460062008-02-19 20:04:22 -05002001 if (wq == NULL)
2002 return -ENOMEM;
2003 nfsiod_workqueue = wq;
2004 return 0;
2005}
2006
2007/*
2008 * Destroy the nfsiod workqueue
2009 */
2010static void nfsiod_stop(void)
2011{
2012 struct workqueue_struct *wq;
2013
2014 wq = nfsiod_workqueue;
2015 if (wq == NULL)
2016 return;
2017 nfsiod_workqueue = NULL;
2018 destroy_workqueue(wq);
2019}
2020
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002021int nfs_net_id;
Stanislav Kinsbursky9e2e74d2012-01-10 17:04:24 +04002022EXPORT_SYMBOL_GPL(nfs_net_id);
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002023
2024static int nfs_net_init(struct net *net)
2025{
Stanislav Kinsbursky6b131682012-01-23 17:26:05 +00002026 nfs_clients_init(net);
Eric W. Biederman65b38852014-07-31 04:35:20 -07002027 return nfs_fs_proc_net_init(net);
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002028}
2029
2030static void nfs_net_exit(struct net *net)
2031{
Eric W. Biederman65b38852014-07-31 04:35:20 -07002032 nfs_fs_proc_net_exit(net);
Stanislav Kinsbursky28cd1b32012-01-23 17:26:22 +00002033 nfs_cleanup_cb_ident_idr(net);
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002034}
2035
2036static struct pernet_operations nfs_net_ops = {
2037 .init = nfs_net_init,
2038 .exit = nfs_net_exit,
2039 .id = &nfs_net_id,
2040 .size = sizeof(struct nfs_net),
2041};
2042
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043/*
2044 * Initialize NFS
2045 */
2046static int __init init_nfs_fs(void)
2047{
2048 int err;
2049
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002050 err = register_pernet_subsys(&nfs_net_ops);
2051 if (err < 0)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002052 goto out9;
Trond Myklebuste571cbf2009-08-19 18:12:27 -04002053
David Howells8ec442a2009-04-03 16:42:42 +01002054 err = nfs_fscache_register();
2055 if (err < 0)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002056 goto out8;
David Howells8ec442a2009-04-03 16:42:42 +01002057
Trond Myklebust57460062008-02-19 20:04:22 -05002058 err = nfsiod_start();
2059 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002060 goto out7;
Trond Myklebust57460062008-02-19 20:04:22 -05002061
David Howells6aaca562006-08-22 20:06:13 -04002062 err = nfs_fs_proc_init();
2063 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002064 goto out6;
David Howells6aaca562006-08-22 20:06:13 -04002065
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066 err = nfs_init_nfspagecache();
2067 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002068 goto out5;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069
2070 err = nfs_init_inodecache();
2071 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002072 goto out4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073
2074 err = nfs_init_readpagecache();
2075 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002076 goto out3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077
2078 err = nfs_init_writepagecache();
2079 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002080 goto out2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 err = nfs_init_directcache();
2083 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002084 goto out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085
Stanislav Kinsburskyec7652a2011-12-06 16:42:40 +03002086 rpc_proc_register(&init_net, &nfs_rpcstat);
Kinglong Meecd738ee2015-07-01 11:58:31 +08002087
2088 err = register_nfs_fs();
2089 if (err)
Bryan Schumaker129d1972012-07-16 16:39:13 -04002090 goto out0;
2091
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 return 0;
Bryan Schumaker129d1972012-07-16 16:39:13 -04002093out0:
Stanislav Kinsburskyec7652a2011-12-06 16:42:40 +03002094 rpc_proc_unregister(&init_net, "nfs");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 nfs_destroy_directcache();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002096out1:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002097 nfs_destroy_writepagecache();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002098out2:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002099 nfs_destroy_readpagecache();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002100out3:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002101 nfs_destroy_inodecache();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002102out4:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002103 nfs_destroy_nfspagecache();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002104out5:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002105 nfs_fs_proc_exit();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002106out6:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002107 nfsiod_stop();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002108out7:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002109 nfs_fscache_unregister();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002110out8:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002111 unregister_pernet_subsys(&nfs_net_ops);
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002112out9:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113 return err;
2114}
2115
2116static void __exit exit_nfs_fs(void)
2117{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 nfs_destroy_directcache();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 nfs_destroy_writepagecache();
2120 nfs_destroy_readpagecache();
2121 nfs_destroy_inodecache();
2122 nfs_destroy_nfspagecache();
David Howells8ec442a2009-04-03 16:42:42 +01002123 nfs_fscache_unregister();
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002124 unregister_pernet_subsys(&nfs_net_ops);
Stanislav Kinsburskyec7652a2011-12-06 16:42:40 +03002125 rpc_proc_unregister(&init_net, "nfs");
David Howellsf7b422b2006-06-09 09:34:33 -04002126 unregister_nfs_fs();
David Howells6aaca562006-08-22 20:06:13 -04002127 nfs_fs_proc_exit();
Trond Myklebust57460062008-02-19 20:04:22 -05002128 nfsiod_stop();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129}
2130
2131/* Not quite true; I just maintain it */
2132MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
2133MODULE_LICENSE("GPL");
Trond Myklebustf43bf0b2007-10-09 12:01:04 -04002134module_param(enable_ino64, bool, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135
2136module_init(init_nfs_fs)
2137module_exit(exit_nfs_fs)