blob: 7688436b19ba1c98f72b9016208cda57596f318f [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{
Christoph Hellwig95d9f6c2016-03-02 17:35:55 +0100144 inode_dio_wait(inode);
Trond Myklebust4d346bea2015-03-25 16:38:33 -0400145 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);
Trond Myklebustca0daa22016-06-08 17:08:28 -0400881 if (ctx->mode & FMODE_WRITE)
882 list_add(&ctx->list, &nfsi->open_files);
883 else
884 list_add_tail(&ctx->list, &nfsi->open_files);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 spin_unlock(&inode->i_lock);
886}
Trond Myklebustc45ffdd2013-05-29 13:34:46 -0400887EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context);
888
889void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
890{
891 filp->private_data = get_nfs_open_context(ctx);
892 if (list_empty(&ctx->list))
893 nfs_inode_attach_open_context(ctx);
894}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400895EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Trond Myklebustd5308382005-11-04 15:33:38 -0500897/*
898 * Given an inode, search for an open context with the desired characteristics
899 */
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500900struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901{
902 struct nfs_inode *nfsi = NFS_I(inode);
903 struct nfs_open_context *pos, *ctx = NULL;
904
905 spin_lock(&inode->i_lock);
906 list_for_each_entry(pos, &nfsi->open_files, list) {
Trond Myklebustd5308382005-11-04 15:33:38 -0500907 if (cred != NULL && pos->cred != cred)
908 continue;
Trond Myklebust1544fa02010-03-25 13:54:49 -0400909 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
910 continue;
911 ctx = get_nfs_open_context(pos);
912 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 }
914 spin_unlock(&inode->i_lock);
915 return ctx;
916}
917
Anna Schumakeraff8d8d2015-07-13 14:01:33 -0400918void nfs_file_clear_open_context(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919{
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400920 struct nfs_open_context *ctx = nfs_file_open_context(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
922 if (ctx) {
David Howells2b0143b2015-03-17 22:25:59 +0000923 struct inode *inode = d_inode(ctx->dentry);
Trond Myklebustc45ffdd2013-05-29 13:34:46 -0400924
Peng Tao0bcbf032015-12-05 15:57:31 +0800925 /*
926 * We fatal error on write before. Try to writeback
927 * every page again.
928 */
929 if (ctx->error < 0)
930 invalidate_inode_pages2(inode->i_mapping);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 filp->private_data = NULL;
932 spin_lock(&inode->i_lock);
933 list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
934 spin_unlock(&inode->i_lock);
Trond Myklebust4eae5012015-09-04 15:17:53 -0400935 put_nfs_open_context_sync(ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 }
937}
938
939/*
940 * These allocate and release file read/write context information.
941 */
942int nfs_open(struct inode *inode, struct file *filp)
943{
944 struct nfs_open_context *ctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
Miklos Szeredibe62a1a2016-03-26 16:14:39 -0400946 ctx = alloc_nfs_open_context(file_dentry(filp), filp->f_mode);
Al Viro5ede7b12011-10-23 18:49:54 -0400947 if (IS_ERR(ctx))
948 return PTR_ERR(ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 nfs_file_set_open_context(filp, ctx);
950 put_nfs_open_context(ctx);
David Howellsf1fe29b2013-09-27 11:20:03 +0100951 nfs_fscache_open_file(inode, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 return 0;
953}
954
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955/*
956 * This function is called whenever some part of NFS notices that
957 * the cached attributes have to be refreshed.
958 */
959int
960__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
961{
962 int status = -ESTALE;
David Quigley1775fd32013-05-22 12:50:42 -0400963 struct nfs4_label *label = NULL;
Trond Myklebusta3cba2a2010-04-16 16:22:49 -0400964 struct nfs_fattr *fattr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 struct nfs_inode *nfsi = NFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
Niels de Vos1e8968c2013-12-17 18:20:16 +0100967 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Lu)\n",
968 inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969
Trond Myklebustf4ce1292013-08-19 18:59:33 -0400970 trace_nfs_revalidate_inode_enter(inode);
971
Chuck Lever85233a72006-10-19 23:28:42 -0700972 if (is_bad_inode(inode))
Chuck Lever412d5822005-08-18 11:24:11 -0700973 goto out;
Trond Myklebust7fdc49c2007-09-28 19:11:33 -0400974 if (NFS_STALE(inode))
975 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976
Trond Myklebustac46bd32016-07-05 13:46:53 -0400977 /* pNFS: Attributes aren't updated until we layoutcommit */
978 if (S_ISREG(inode->i_mode)) {
979 status = pnfs_sync_inode(inode, false);
980 if (status)
981 goto out;
982 }
983
Trond Myklebusta3cba2a2010-04-16 16:22:49 -0400984 status = -ENOMEM;
985 fattr = nfs_alloc_fattr();
986 if (fattr == NULL)
987 goto out;
988
Trond Myklebust691beb12008-10-05 14:48:22 -0400989 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
David Quigley14c43f72013-05-22 12:50:43 -0400990
991 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
992 if (IS_ERR(label)) {
993 status = PTR_ERR(label);
994 goto out;
995 }
996
David Quigley1775fd32013-05-22 12:50:42 -0400997 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, label);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 if (status != 0) {
Niels de Vos1e8968c2013-12-17 18:20:16 +0100999 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 inode->i_sb->s_id,
Niels de Vos1e8968c2013-12-17 18:20:16 +01001001 (unsigned long long)NFS_FILEID(inode), status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 if (status == -ESTALE) {
1003 nfs_zap_caches(inode);
1004 if (!S_ISDIR(inode->i_mode))
Benny Halevy3a10c302008-01-23 08:58:59 +02001005 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 }
David Quigley14c43f72013-05-22 12:50:43 -04001007 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 }
1009
Trond Myklebusta3cba2a2010-04-16 16:22:49 -04001010 status = nfs_refresh_inode(inode, fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 if (status) {
Niels de Vos1e8968c2013-12-17 18:20:16 +01001012 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 inode->i_sb->s_id,
Niels de Vos1e8968c2013-12-17 18:20:16 +01001014 (unsigned long long)NFS_FILEID(inode), status);
David Quigley14c43f72013-05-22 12:50:43 -04001015 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 }
Chuck Lever55296802005-08-18 11:24:09 -07001017
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001018 if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
Trond Myklebustada70d92005-06-22 17:16:22 +00001019 nfs_zap_acl_cache(inode);
Chuck Lever55296802005-08-18 11:24:09 -07001020
Jeff Layton3da580a2013-11-02 06:57:18 -04001021 nfs_setsecurity(inode, fattr, label);
1022
Niels de Vos1e8968c2013-12-17 18:20:16 +01001023 dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 inode->i_sb->s_id,
Niels de Vos1e8968c2013-12-17 18:20:16 +01001025 (unsigned long long)NFS_FILEID(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
David Quigley14c43f72013-05-22 12:50:43 -04001027err_out:
1028 nfs4_label_free(label);
1029out:
Trond Myklebusta3cba2a2010-04-16 16:22:49 -04001030 nfs_free_fattr(fattr);
Trond Myklebustf4ce1292013-08-19 18:59:33 -04001031 trace_nfs_revalidate_inode_exit(inode, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 return status;
1033}
1034
1035int nfs_attribute_timeout(struct inode *inode)
1036{
1037 struct nfs_inode *nfsi = NFS_I(inode);
1038
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -04001039 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
1040}
1041
Scott Mayhew43f291c2013-07-05 17:49:30 -04001042int nfs_attribute_cache_expired(struct inode *inode)
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -04001043{
Trond Myklebustb4d23142010-03-10 15:21:44 -05001044 if (nfs_have_delegated_attributes(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 return 0;
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -04001046 return nfs_attribute_timeout(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047}
1048
1049/**
1050 * nfs_revalidate_inode - Revalidate the inode attributes
1051 * @server - pointer to nfs_server struct
1052 * @inode - pointer to inode struct
1053 *
1054 * Updates inode attribute information by retrieving the data from the server.
1055 */
1056int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1057{
Trond Myklebust311324a2014-02-07 17:02:08 -05001058 if (!nfs_need_revalidate_inode(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 return NFS_STALE(inode) ? -ESTALE : 0;
1060 return __nfs_revalidate_inode(server, inode);
1061}
Bryan Schumaker1c606fb2012-07-30 16:05:24 -04001062EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
NeilBrown912a1082014-07-14 11:28:20 +10001064int nfs_revalidate_inode_rcu(struct nfs_server *server, struct inode *inode)
1065{
1066 if (!(NFS_I(inode)->cache_validity &
1067 (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))
1068 && !nfs_attribute_cache_expired(inode))
1069 return NFS_STALE(inode) ? -ESTALE : 0;
1070 return -ECHILD;
1071}
1072
Trond Myklebust1cda7072010-02-19 17:03:30 -08001073static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
Trond Myklebust717d44e2007-01-24 11:54:55 -08001074{
1075 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebustf8806c82013-08-05 13:26:31 -04001076 int ret;
1077
Trond Myklebust717d44e2007-01-24 11:54:55 -08001078 if (mapping->nrpages != 0) {
Trond Myklebustf8806c82013-08-05 13:26:31 -04001079 if (S_ISREG(inode->i_mode)) {
Trond Myklebustef070dc2015-03-03 00:06:35 -05001080 unmap_mapping_range(mapping, 0, 0, 0);
Trond Myklebustf8806c82013-08-05 13:26:31 -04001081 ret = nfs_sync_mapping(mapping);
1082 if (ret < 0)
1083 return ret;
1084 }
1085 ret = invalidate_inode_pages2(mapping);
Trond Myklebust717d44e2007-01-24 11:54:55 -08001086 if (ret < 0)
1087 return ret;
1088 }
Jeff Laytond529ef82014-01-27 13:46:15 -05001089 if (S_ISDIR(inode->i_mode)) {
1090 spin_lock(&inode->i_lock);
Trond Myklebust717d44e2007-01-24 11:54:55 -08001091 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
Jeff Laytond529ef82014-01-27 13:46:15 -05001092 spin_unlock(&inode->i_lock);
1093 }
Trond Myklebust717d44e2007-01-24 11:54:55 -08001094 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
David Howellsde242c02012-12-20 21:52:38 +00001095 nfs_fscache_wait_on_invalidate(inode);
Trond Myklebustf4ce1292013-08-19 18:59:33 -04001096
Niels de Vos1e8968c2013-12-17 18:20:16 +01001097 dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n",
1098 inode->i_sb->s_id,
1099 (unsigned long long)NFS_FILEID(inode));
Trond Myklebust717d44e2007-01-24 11:54:55 -08001100 return 0;
1101}
1102
Trond Myklebustb4b1ead2012-04-29 11:23:50 -04001103static bool nfs_mapping_need_revalidate_inode(struct inode *inode)
1104{
1105 if (nfs_have_delegated_attributes(inode))
1106 return false;
1107 return (NFS_I(inode)->cache_validity & NFS_INO_REVAL_PAGECACHE)
1108 || nfs_attribute_timeout(inode)
1109 || NFS_STALE(inode);
1110}
1111
Al Viro0d0def42015-11-17 21:14:24 -05001112int nfs_revalidate_mapping_rcu(struct inode *inode)
1113{
1114 struct nfs_inode *nfsi = NFS_I(inode);
1115 unsigned long *bitlock = &nfsi->flags;
1116 int ret = 0;
1117
1118 if (IS_SWAPFILE(inode))
1119 goto out;
1120 if (nfs_mapping_need_revalidate_inode(inode)) {
1121 ret = -ECHILD;
1122 goto out;
1123 }
1124 spin_lock(&inode->i_lock);
1125 if (test_bit(NFS_INO_INVALIDATING, bitlock) ||
1126 (nfsi->cache_validity & NFS_INO_INVALID_DATA))
1127 ret = -ECHILD;
1128 spin_unlock(&inode->i_lock);
1129out:
1130 return ret;
1131}
1132
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133/**
Trond Myklebustbe527492016-06-22 08:19:36 -04001134 * nfs_revalidate_mapping - Revalidate the pagecache
Trond Myklebust7d52e862005-06-22 17:16:30 +00001135 * @inode - pointer to host inode
1136 * @mapping - pointer to mapping
1137 */
Trond Myklebustbe527492016-06-22 08:19:36 -04001138int nfs_revalidate_mapping(struct inode *inode,
1139 struct address_space *mapping)
Trond Myklebust7d52e862005-06-22 17:16:30 +00001140{
1141 struct nfs_inode *nfsi = NFS_I(inode);
Jeff Laytond529ef82014-01-27 13:46:15 -05001142 unsigned long *bitlock = &nfsi->flags;
Trond Myklebust44b11872006-05-25 01:40:59 -04001143 int ret = 0;
1144
Mel Gorman29418aa2012-07-31 16:45:10 -07001145 /* swapfiles are not supposed to be shared. */
1146 if (IS_SWAPFILE(inode))
1147 goto out;
1148
Trond Myklebustb4b1ead2012-04-29 11:23:50 -04001149 if (nfs_mapping_need_revalidate_inode(inode)) {
Trond Myklebust44b11872006-05-25 01:40:59 -04001150 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
Trond Myklebust717d44e2007-01-24 11:54:55 -08001151 if (ret < 0)
1152 goto out;
Trond Myklebust7d52e862005-06-22 17:16:30 +00001153 }
Jeff Laytond529ef82014-01-27 13:46:15 -05001154
1155 /*
1156 * We must clear NFS_INO_INVALID_DATA first to ensure that
1157 * invalidations that come in while we're shooting down the mappings
1158 * are respected. But, that leaves a race window where one revalidator
1159 * can clear the flag, and then another checks it before the mapping
1160 * gets invalidated. Fix that by serializing access to this part of
1161 * the function.
1162 *
1163 * At the same time, we need to allow other tasks to see whether we
1164 * might be in the middle of invalidating the pages, so we only set
1165 * the bit lock here if it looks like we're going to be doing that.
1166 */
1167 for (;;) {
NeilBrown74316202014-07-07 15:16:04 +10001168 ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING,
1169 nfs_wait_bit_killable, TASK_KILLABLE);
Jeff Laytond529ef82014-01-27 13:46:15 -05001170 if (ret)
1171 goto out;
Trond Myklebust17dfeb92014-01-28 09:37:16 -05001172 spin_lock(&inode->i_lock);
1173 if (test_bit(NFS_INO_INVALIDATING, bitlock)) {
1174 spin_unlock(&inode->i_lock);
1175 continue;
1176 }
1177 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
Jeff Laytond529ef82014-01-27 13:46:15 -05001178 break;
Trond Myklebust17dfeb92014-01-28 09:37:16 -05001179 spin_unlock(&inode->i_lock);
1180 goto out;
Trond Myklebustf4ce1292013-08-19 18:59:33 -04001181 }
1182
Trond Myklebust17dfeb92014-01-28 09:37:16 -05001183 set_bit(NFS_INO_INVALIDATING, bitlock);
Jeff Layton4db72b42014-01-28 13:47:46 -05001184 smp_wmb();
Trond Myklebust17dfeb92014-01-28 09:37:16 -05001185 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
1186 spin_unlock(&inode->i_lock);
1187 trace_nfs_invalidate_mapping_enter(inode);
Trond Myklebustbe527492016-06-22 08:19:36 -04001188 ret = nfs_invalidate_mapping(inode, mapping);
Trond Myklebust17dfeb92014-01-28 09:37:16 -05001189 trace_nfs_invalidate_mapping_exit(inode, ret);
Trond Myklebust717d44e2007-01-24 11:54:55 -08001190
Jeff Laytond529ef82014-01-27 13:46:15 -05001191 clear_bit_unlock(NFS_INO_INVALIDATING, bitlock);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01001192 smp_mb__after_atomic();
Jeff Laytond529ef82014-01-27 13:46:15 -05001193 wake_up_bit(bitlock, NFS_INO_INVALIDATING);
Trond Myklebustcd9ae2b2006-10-19 23:28:40 -07001194out:
Trond Myklebust44b11872006-05-25 01:40:59 -04001195 return ret;
Trond Myklebust7d52e862005-06-22 17:16:30 +00001196}
1197
Trond Myklebustca0daa22016-06-08 17:08:28 -04001198static bool nfs_file_has_writers(struct nfs_inode *nfsi)
1199{
1200 struct inode *inode = &nfsi->vfs_inode;
1201
1202 assert_spin_locked(&inode->i_lock);
1203
1204 if (!S_ISREG(inode->i_mode))
1205 return false;
1206 if (list_empty(&nfsi->open_files))
1207 return false;
1208 /* Note: This relies on nfsi->open_files being ordered with writers
1209 * being placed at the head of the list.
1210 * See nfs_inode_attach_open_context()
1211 */
1212 return (list_first_entry(&nfsi->open_files,
1213 struct nfs_open_context,
1214 list)->mode & FMODE_WRITE) == FMODE_WRITE;
1215}
1216
Trond Myklebust651b0e72016-06-25 17:24:46 -04001217static bool nfs_file_has_buffered_writers(struct nfs_inode *nfsi)
1218{
1219 return nfs_file_has_writers(nfsi) && nfs_file_io_is_buffered(nfsi);
1220}
1221
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001222static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001223{
1224 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001225 unsigned long ret = 0;
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001226
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001227 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
1228 && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
Trond Myklebusta9a4a872011-10-17 16:08:46 -07001229 && inode->i_version == fattr->pre_change_attr) {
1230 inode->i_version = fattr->change_attr;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001231 if (S_ISDIR(inode->i_mode))
Trond Myklebust6edf9602014-06-20 13:11:01 -04001232 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001233 ret |= NFS_INO_INVALID_ATTR;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001234 }
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001235 /* If we have atomic WCC data, we may update some attributes */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001236 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
1237 && (fattr->valid & NFS_ATTR_FATTR_CTIME)
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001238 && timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
1239 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1240 ret |= NFS_INO_INVALID_ATTR;
1241 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001242
1243 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
1244 && (fattr->valid & NFS_ATTR_FATTR_MTIME)
1245 && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001246 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1247 if (S_ISDIR(inode->i_mode))
Trond Myklebust6edf9602014-06-20 13:11:01 -04001248 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001249 ret |= NFS_INO_INVALID_ATTR;
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001250 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001251 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
1252 && (fattr->valid & NFS_ATTR_FATTR_SIZE)
1253 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
Weston Andros Adamsoncb1410c2014-11-12 12:08:00 -05001254 && nfsi->nrequests == 0) {
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001255 i_size_write(inode, nfs_size_to_loff_t(fattr->size));
1256 ret |= NFS_INO_INVALID_ATTR;
1257 }
David Howellsde242c02012-12-20 21:52:38 +00001258
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001259 return ret;
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001260}
1261
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262/**
Trond Myklebust33801142005-10-27 22:12:39 -04001263 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 * @inode - pointer to inode
1265 * @fattr - updated attributes
1266 *
1267 * Verifies the attribute cache. If we have just changed the attributes,
1268 * so that fattr carries weak cache consistency data, then it may
1269 * also update the ctime/mtime/change_attribute.
1270 */
Trond Myklebust33801142005-10-27 22:12:39 -04001271static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272{
1273 struct nfs_inode *nfsi = NFS_I(inode);
1274 loff_t cur_size, new_isize;
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001275 unsigned long invalid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276
Chuck Leverdc592502005-08-18 11:24:12 -07001277
Trond Myklebust01da47b2012-04-29 12:30:19 -04001278 if (nfs_have_delegated_attributes(inode))
1279 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 /* Has the inode gone and changed behind our back? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001281 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 return -EIO;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001283 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
1284 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
Trond Myklebust651b0e72016-06-25 17:24:46 -04001286 if (!nfs_file_has_buffered_writers(nfsi)) {
Trond Myklebustca0daa22016-06-08 17:08:28 -04001287 /* Verify a few of the more important attributes */
1288 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && inode->i_version != fattr->change_attr)
1289 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_REVAL_PAGECACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290
Trond Myklebustca0daa22016-06-08 17:08:28 -04001291 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))
1292 invalid |= NFS_INO_INVALID_ATTR;
Trond Myklebustca62b9c2006-03-20 13:44:07 -05001293
Trond Myklebustca0daa22016-06-08 17:08:28 -04001294 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) && !timespec_equal(&inode->i_ctime, &fattr->ctime))
1295 invalid |= NFS_INO_INVALID_ATTR;
1296
1297 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1298 cur_size = i_size_read(inode);
1299 new_isize = nfs_size_to_loff_t(fattr->size);
1300 if (cur_size != new_isize)
1301 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
1302 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001303 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304
1305 /* Have any file permissions changed? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001306 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
1307 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
Eric W. Biederman9ff593c2013-02-01 14:26:23 -08001308 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001309 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
Eric W. Biederman9ff593c2013-02-01 14:26:23 -08001310 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001311 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312
1313 /* Has the link count changed? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001314 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001315 invalid |= NFS_INO_INVALID_ATTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001317 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001318 invalid |= NFS_INO_INVALID_ATIME;
1319
1320 if (invalid != 0)
Trond Myklebust6edf9602014-06-20 13:11:01 -04001321 nfs_set_cache_invalid(inode, invalid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322
Trond Myklebust33801142005-10-27 22:12:39 -04001323 nfsi->read_cache_jiffies = fattr->time_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 return 0;
1325}
1326
Trond Myklebustae05f262008-10-28 15:21:40 -04001327static atomic_long_t nfs_attr_generation_counter;
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001328
1329static unsigned long nfs_read_attr_generation_counter(void)
1330{
Trond Myklebustae05f262008-10-28 15:21:40 -04001331 return atomic_long_read(&nfs_attr_generation_counter);
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001332}
1333
1334unsigned long nfs_inc_attr_generation_counter(void)
1335{
Trond Myklebustae05f262008-10-28 15:21:40 -04001336 return atomic_long_inc_return(&nfs_attr_generation_counter);
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001337}
Trond Myklebust3235b402015-02-26 19:52:06 -05001338EXPORT_SYMBOL_GPL(nfs_inc_attr_generation_counter);
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001339
1340void nfs_fattr_init(struct nfs_fattr *fattr)
1341{
1342 fattr->valid = 0;
1343 fattr->time_start = jiffies;
1344 fattr->gencount = nfs_inc_attr_generation_counter();
Trond Myklebust6926afd2012-01-07 13:22:46 -05001345 fattr->owner_name = NULL;
1346 fattr->group_name = NULL;
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001347}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001348EXPORT_SYMBOL_GPL(nfs_fattr_init);
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001349
Trond Myklebust140e0492015-02-26 17:42:42 -05001350/**
1351 * nfs_fattr_set_barrier
1352 * @fattr: attributes
1353 *
1354 * Used to set a barrier after an attribute was updated. This
1355 * barrier ensures that older attributes from RPC calls that may
1356 * have raced with our update cannot clobber these new values.
1357 * Note that you are still responsible for ensuring that other
1358 * operations which change the attribute on the server do not
1359 * collide.
1360 */
1361void nfs_fattr_set_barrier(struct nfs_fattr *fattr)
1362{
1363 fattr->gencount = nfs_inc_attr_generation_counter();
1364}
1365
Trond Myklebust2d36bfde2010-04-16 16:22:45 -04001366struct nfs_fattr *nfs_alloc_fattr(void)
1367{
1368 struct nfs_fattr *fattr;
1369
1370 fattr = kmalloc(sizeof(*fattr), GFP_NOFS);
1371 if (fattr != NULL)
1372 nfs_fattr_init(fattr);
1373 return fattr;
1374}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001375EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
Trond Myklebust2d36bfde2010-04-16 16:22:45 -04001376
1377struct nfs_fh *nfs_alloc_fhandle(void)
1378{
1379 struct nfs_fh *fh;
1380
1381 fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS);
1382 if (fh != NULL)
1383 fh->size = 0;
1384 return fh;
1385}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001386EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
Trond Myklebust2d36bfde2010-04-16 16:22:45 -04001387
Trond Myklebuste27d3592012-03-18 14:07:42 -04001388#ifdef NFS_DEBUG
Weston Andros Adamsond8e05392012-03-06 20:46:43 -05001389/*
1390 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle
1391 * in the same way that wireshark does
1392 *
1393 * @fh: file handle
1394 *
1395 * For debugging only.
1396 */
1397u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
1398{
1399 /* wireshark uses 32-bit AUTODIN crc and does a bitwise
1400 * not on the result */
Trond Myklebust1264a2f2013-08-12 16:06:31 -04001401 return nfs_fhandle_hash(fh);
Weston Andros Adamsond8e05392012-03-06 20:46:43 -05001402}
Chuck Lever9e6ee762013-10-17 14:12:45 -04001403EXPORT_SYMBOL_GPL(_nfs_display_fhandle_hash);
Weston Andros Adamsond8e05392012-03-06 20:46:43 -05001404
1405/*
Chuck Lever20d27e92012-03-01 17:01:31 -05001406 * _nfs_display_fhandle - display an NFS file handle on the console
1407 *
1408 * @fh: file handle to display
1409 * @caption: display caption
1410 *
1411 * For debugging only.
1412 */
Chuck Lever20d27e92012-03-01 17:01:31 -05001413void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
1414{
1415 unsigned short i;
1416
Trond Myklebustfa68a1b2012-03-06 10:14:35 -05001417 if (fh == NULL || fh->size == 0) {
Chuck Lever20d27e92012-03-01 17:01:31 -05001418 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
1419 return;
1420 }
1421
Weston Andros Adamsond8e05392012-03-06 20:46:43 -05001422 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
1423 caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
Chuck Lever20d27e92012-03-01 17:01:31 -05001424 for (i = 0; i < fh->size; i += 16) {
1425 __be32 *pos = (__be32 *)&fh->data[i];
1426
1427 switch ((fh->size - i - 1) >> 2) {
1428 case 0:
1429 printk(KERN_DEFAULT " %08x\n",
1430 be32_to_cpup(pos));
1431 break;
1432 case 1:
1433 printk(KERN_DEFAULT " %08x %08x\n",
1434 be32_to_cpup(pos), be32_to_cpup(pos + 1));
1435 break;
1436 case 2:
1437 printk(KERN_DEFAULT " %08x %08x %08x\n",
1438 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1439 be32_to_cpup(pos + 2));
1440 break;
1441 default:
1442 printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
1443 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1444 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
1445 }
1446 }
1447}
Chuck Lever9e6ee762013-10-17 14:12:45 -04001448EXPORT_SYMBOL_GPL(_nfs_display_fhandle);
Chuck Lever20d27e92012-03-01 17:01:31 -05001449#endif
1450
1451/**
Trond Myklebusta10ad172008-09-23 17:28:41 -04001452 * nfs_inode_attrs_need_update - check if the inode attributes need updating
1453 * @inode - pointer to inode
1454 * @fattr - attributes
1455 *
1456 * Attempt to divine whether or not an RPC call reply carrying stale
1457 * attributes got scheduled after another call carrying updated ones.
1458 *
1459 * To do so, the function first assumes that a more recent ctime means
1460 * that the attributes in fattr are newer, however it also attempt to
1461 * catch the case where ctime either didn't change, or went backwards
1462 * (if someone reset the clock on the server) by looking at whether
1463 * or not this RPC call was started after the inode was last updated.
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001464 * Note also the check for wraparound of 'attr_gencount'
Trond Myklebusta10ad172008-09-23 17:28:41 -04001465 *
1466 * The function returns 'true' if it thinks the attributes in 'fattr' are
1467 * more recent than the ones cached in the inode.
1468 *
1469 */
1470static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1471{
1472 const struct nfs_inode *nfsi = NFS_I(inode);
1473
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001474 return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001475 ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
Trond Myklebusta10ad172008-09-23 17:28:41 -04001476}
1477
Trond Myklebust870a5be2008-10-05 12:07:23 -04001478static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1479{
Trond Myklebustf4ce1292013-08-19 18:59:33 -04001480 int ret;
1481
1482 trace_nfs_refresh_inode_enter(inode);
1483
Trond Myklebusta10ad172008-09-23 17:28:41 -04001484 if (nfs_inode_attrs_need_update(inode, fattr))
Trond Myklebustf4ce1292013-08-19 18:59:33 -04001485 ret = nfs_update_inode(inode, fattr);
1486 else
1487 ret = nfs_check_inode_attributes(inode, fattr);
1488
1489 trace_nfs_refresh_inode_exit(inode, ret);
1490 return ret;
Trond Myklebust870a5be2008-10-05 12:07:23 -04001491}
1492
Trond Myklebust33801142005-10-27 22:12:39 -04001493/**
1494 * nfs_refresh_inode - try to update the inode attribute cache
1495 * @inode - pointer to inode
1496 * @fattr - updated attributes
1497 *
1498 * Check that an RPC call that returned attributes has not overlapped with
1499 * other recent updates of the inode metadata, then decide whether it is
1500 * safe to do a full update of the inode attributes, or whether just to
1501 * call nfs_check_inode_attributes.
1502 */
1503int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1504{
Trond Myklebust33801142005-10-27 22:12:39 -04001505 int status;
1506
1507 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1508 return 0;
1509 spin_lock(&inode->i_lock);
Trond Myklebust870a5be2008-10-05 12:07:23 -04001510 status = nfs_refresh_inode_locked(inode, fattr);
Trond Myklebust33801142005-10-27 22:12:39 -04001511 spin_unlock(&inode->i_lock);
David Howellsef79c092009-04-03 16:42:43 +01001512
Trond Myklebust33801142005-10-27 22:12:39 -04001513 return status;
1514}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001515EXPORT_SYMBOL_GPL(nfs_refresh_inode);
Trond Myklebust33801142005-10-27 22:12:39 -04001516
Trond Myklebustd65f5572008-10-05 12:27:55 -04001517static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1518{
Trond Myklebustca0daa22016-06-08 17:08:28 -04001519 unsigned long invalid = NFS_INO_INVALID_ATTR;
Trond Myklebustd65f5572008-10-05 12:27:55 -04001520
Trond Myklebustaaae3f02015-08-20 18:56:07 -05001521 /*
1522 * Don't revalidate the pagecache if we hold a delegation, but do
1523 * force an attribute update
1524 */
1525 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1526 invalid = NFS_INO_INVALID_ATTR|NFS_INO_REVAL_FORCED;
1527
Trond Myklebust6edf9602014-06-20 13:11:01 -04001528 if (S_ISDIR(inode->i_mode))
1529 invalid |= NFS_INO_INVALID_DATA;
1530 nfs_set_cache_invalid(inode, invalid);
Trond Myklebustd65f5572008-10-05 12:27:55 -04001531 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1532 return 0;
1533 return nfs_refresh_inode_locked(inode, fattr);
1534}
1535
Trond Myklebustdecf4912005-10-27 22:12:39 -04001536/**
1537 * nfs_post_op_update_inode - try to update the inode attribute cache
1538 * @inode - pointer to inode
1539 * @fattr - updated attributes
1540 *
1541 * After an operation that has changed the inode metadata, mark the
1542 * attribute cache as being invalid, then try to update it.
Chuck Leverf551e442006-09-20 14:33:04 -04001543 *
1544 * NB: if the server didn't return any post op attributes, this
1545 * function will force the retrieval of attributes before the next
1546 * NFS request. Thus it should be used only for operations that
1547 * are expected to change one or more attributes, to avoid
1548 * unnecessary NFS requests and trips through nfs_update_inode().
Trond Myklebustdecf4912005-10-27 22:12:39 -04001549 */
1550int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1551{
Trond Myklebustd65f5572008-10-05 12:27:55 -04001552 int status;
Trond Myklebustdecf4912005-10-27 22:12:39 -04001553
Trond Myklebust7668fdb2007-10-01 09:59:15 -04001554 spin_lock(&inode->i_lock);
Trond Myklebust92d64e42015-02-26 19:48:26 -05001555 nfs_fattr_set_barrier(fattr);
Trond Myklebustd65f5572008-10-05 12:27:55 -04001556 status = nfs_post_op_update_inode_locked(inode, fattr);
Trond Myklebust7668fdb2007-10-01 09:59:15 -04001557 spin_unlock(&inode->i_lock);
David Quigleyaa9c2662013-05-22 12:50:44 -04001558
Trond Myklebust870a5be2008-10-05 12:07:23 -04001559 return status;
Trond Myklebustdecf4912005-10-27 22:12:39 -04001560}
Bryan Schumaker1c606fb2012-07-30 16:05:24 -04001561EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
Trond Myklebustdecf4912005-10-27 22:12:39 -04001562
Trond Myklebust70ca8852007-09-30 15:21:24 -04001563/**
Trond Myklebusta08a8cd2015-02-26 17:36:09 -05001564 * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache
Trond Myklebust70ca8852007-09-30 15:21:24 -04001565 * @inode - pointer to inode
1566 * @fattr - updated attributes
1567 *
1568 * After an operation that has changed the inode metadata, mark the
1569 * attribute cache as being invalid, then try to update it. Fake up
1570 * weak cache consistency data, if none exist.
1571 *
1572 * This function is mainly designed to be used by the ->write_done() functions.
1573 */
Trond Myklebusta08a8cd2015-02-26 17:36:09 -05001574int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr)
Trond Myklebust70ca8852007-09-30 15:21:24 -04001575{
Trond Myklebustd65f5572008-10-05 12:27:55 -04001576 int status;
1577
Trond Myklebustd65f5572008-10-05 12:27:55 -04001578 /* Don't do a WCC update if these attributes are already stale */
1579 if ((fattr->valid & NFS_ATTR_FATTR) == 0 ||
1580 !nfs_inode_attrs_need_update(inode, fattr)) {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001581 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
1582 | NFS_ATTR_FATTR_PRESIZE
1583 | NFS_ATTR_FATTR_PREMTIME
1584 | NFS_ATTR_FATTR_PRECTIME);
Trond Myklebustd65f5572008-10-05 12:27:55 -04001585 goto out_noforce;
1586 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001587 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1588 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
Trond Myklebusta9a4a872011-10-17 16:08:46 -07001589 fattr->pre_change_attr = inode->i_version;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001590 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001591 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001592 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
1593 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
Trond Myklebust70ca8852007-09-30 15:21:24 -04001594 memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001595 fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
1596 }
1597 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
1598 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
Trond Myklebust70ca8852007-09-30 15:21:24 -04001599 memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001600 fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
1601 }
1602 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
1603 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
Trond Myklebusta3d01452008-06-11 12:21:19 -04001604 fattr->pre_size = i_size_read(inode);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001605 fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001606 }
Trond Myklebustd65f5572008-10-05 12:27:55 -04001607out_noforce:
1608 status = nfs_post_op_update_inode_locked(inode, fattr);
Trond Myklebusta08a8cd2015-02-26 17:36:09 -05001609 return status;
1610}
1611
1612/**
1613 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
1614 * @inode - pointer to inode
1615 * @fattr - updated attributes
1616 *
1617 * After an operation that has changed the inode metadata, mark the
1618 * attribute cache as being invalid, then try to update it. Fake up
1619 * weak cache consistency data, if none exist.
1620 *
1621 * This function is mainly designed to be used by the ->write_done() functions.
1622 */
1623int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
1624{
1625 int status;
1626
1627 spin_lock(&inode->i_lock);
Trond Myklebust8f8ba1d2015-02-26 17:54:58 -05001628 nfs_fattr_set_barrier(fattr);
Trond Myklebusta08a8cd2015-02-26 17:36:09 -05001629 status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
Trond Myklebustd65f5572008-10-05 12:27:55 -04001630 spin_unlock(&inode->i_lock);
1631 return status;
Trond Myklebust70ca8852007-09-30 15:21:24 -04001632}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001633EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
Trond Myklebust70ca8852007-09-30 15:21:24 -04001634
Anna Schumakerea96d1e2015-04-03 14:35:59 -04001635
1636static inline bool nfs_fileid_valid(struct nfs_inode *nfsi,
1637 struct nfs_fattr *fattr)
1638{
1639 bool ret1 = true, ret2 = true;
1640
1641 if (fattr->valid & NFS_ATTR_FATTR_FILEID)
1642 ret1 = (nfsi->fileid == fattr->fileid);
1643 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
1644 ret2 = (nfsi->fileid == fattr->mounted_on_fileid);
1645 return ret1 || ret2;
1646}
1647
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648/*
1649 * Many nfs protocol calls return the new file attributes after
1650 * an operation. Here we update the inode to reflect the state
1651 * of the server's inode.
1652 *
1653 * This is a bit tricky because we have to make sure all dirty pages
1654 * have been sent off to the server before calling invalidate_inode_pages.
1655 * To make sure no other process adds more write requests while we try
1656 * our best to flush them, we make them sleep during the attribute refresh.
1657 *
1658 * A very similar scenario holds for the dir cache.
1659 */
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001660static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661{
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -04001662 struct nfs_server *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust951a1432005-06-22 17:16:30 +00001664 loff_t cur_isize, new_isize;
Trond Myklebust2a3f5fd2007-10-08 14:26:13 -04001665 unsigned long invalid = 0;
Trond Myklebust3e7d9502007-02-05 14:26:28 -08001666 unsigned long now = jiffies;
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001667 unsigned long save_cache_validity;
Trond Myklebust651b0e72016-06-25 17:24:46 -04001668 bool have_writers = nfs_file_has_buffered_writers(nfsi);
Trond Myklebustade14a72015-12-29 18:55:19 -05001669 bool cache_revalidated = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670
Niels de Vos1e8968c2013-12-17 18:20:16 +01001671 dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%x)\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -07001672 __func__, inode->i_sb->s_id, inode->i_ino,
Weston Andros Adamson4f1abd22012-03-06 21:58:20 -05001673 nfs_display_fhandle_hash(NFS_FH(inode)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 atomic_read(&inode->i_count), fattr->valid);
1675
Anna Schumakerea96d1e2015-04-03 14:35:59 -04001676 if (!nfs_fileid_valid(nfsi, fattr)) {
Matthew Treinishe73e6c92012-04-30 11:32:57 -04001677 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
1678 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
1679 NFS_SERVER(inode)->nfs_client->cl_hostname,
1680 inode->i_sb->s_id, (long long)nfsi->fileid,
1681 (long long)fattr->fileid);
1682 goto out_err;
1683 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684
1685 /*
1686 * Make sure the inode's type hasn't changed.
1687 */
Matthew Treinishe73e6c92012-04-30 11:32:57 -04001688 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
1689 /*
1690 * Big trouble! The inode has become a different object.
1691 */
Niels de Vos1e8968c2013-12-17 18:20:16 +01001692 printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
Matthew Treinishe73e6c92012-04-30 11:32:57 -04001693 __func__, inode->i_ino, inode->i_mode, fattr->mode);
1694 goto out_err;
1695 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -04001697 server = NFS_SERVER(inode);
Trond Myklebusta0356862007-06-05 13:26:15 -04001698 /* Update the fsid? */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001699 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
Trond Myklebustc37dcd332008-03-06 12:34:50 -05001700 !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
David Howells36d43a42011-01-14 18:45:42 +00001701 !IS_AUTOMOUNT(inode))
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -04001702 server->fsid = fattr->fsid;
1703
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 /*
1705 * Update the read time so we don't revalidate too often.
1706 */
Trond Myklebust33801142005-10-27 22:12:39 -04001707 nfsi->read_cache_jiffies = fattr->time_start;
Trond Myklebust3e7d9502007-02-05 14:26:28 -08001708
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001709 save_cache_validity = nfsi->cache_validity;
1710 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
1711 | NFS_INO_INVALID_ATIME
1712 | NFS_INO_REVAL_FORCED
1713 | NFS_INO_REVAL_PAGECACHE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001715 /* Do atomic weak cache consistency updates */
Trond Myklebust27dc1cd2011-01-25 15:28:21 -05001716 invalid |= nfs_wcc_update_inode(inode, fattr);
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001717
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001718 /* More cache consistency checks */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001719 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
Trond Myklebusta9a4a872011-10-17 16:08:46 -07001720 if (inode->i_version != fattr->change_attr) {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001721 dprintk("NFS: change_attr change on server for file %s/%ld\n",
1722 inode->i_sb->s_id, inode->i_ino);
Trond Myklebust38512aa2016-06-07 21:44:08 -04001723 /* Could it be a race with writeback? */
Trond Myklebustca0daa22016-06-08 17:08:28 -04001724 if (!have_writers) {
Trond Myklebust38512aa2016-06-07 21:44:08 -04001725 invalid |= NFS_INO_INVALID_ATTR
1726 | NFS_INO_INVALID_DATA
1727 | NFS_INO_INVALID_ACCESS
1728 | NFS_INO_INVALID_ACL;
1729 if (S_ISDIR(inode->i_mode))
1730 nfs_force_lookup_revalidate(inode);
1731 }
Trond Myklebusta9a4a872011-10-17 16:08:46 -07001732 inode->i_version = fattr->change_attr;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001733 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001734 } else {
Trond Myklebust43b65352014-04-15 10:07:57 -04001735 nfsi->cache_validity |= save_cache_validity;
Trond Myklebustade14a72015-12-29 18:55:19 -05001736 cache_revalidated = false;
1737 }
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001738
1739 if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
Trond Myklebustfee7fe12012-04-27 13:48:18 -04001740 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
Trond Myklebustade14a72015-12-29 18:55:19 -05001741 } else if (server->caps & NFS_CAP_MTIME) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001742 nfsi->cache_validity |= save_cache_validity &
1743 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001744 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001745 cache_revalidated = false;
1746 }
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001747
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001748 if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
Trond Myklebustfee7fe12012-04-27 13:48:18 -04001749 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
Trond Myklebustade14a72015-12-29 18:55:19 -05001750 } else if (server->caps & NFS_CAP_CTIME) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001751 nfsi->cache_validity |= save_cache_validity &
1752 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001753 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001754 cache_revalidated = false;
1755 }
Trond Myklebust47aabaa2007-09-27 15:57:24 -04001756
Trond Myklebust951a1432005-06-22 17:16:30 +00001757 /* Check if our cached file size is stale */
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001758 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1759 new_isize = nfs_size_to_loff_t(fattr->size);
1760 cur_isize = i_size_read(inode);
1761 if (new_isize != cur_isize) {
1762 /* Do we perhaps have any outstanding writes, or has
1763 * the file grown beyond our last write? */
Trond Myklebustca0daa22016-06-08 17:08:28 -04001764 if (nfsi->nrequests == 0 || new_isize > cur_isize) {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001765 i_size_write(inode, new_isize);
Trond Myklebustca0daa22016-06-08 17:08:28 -04001766 if (!have_writers)
1767 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001768 }
Harshula Jayasuriya60c16ea2011-05-23 22:52:11 +10001769 dprintk("NFS: isize change on server for file %s/%ld "
1770 "(%Ld to %Ld)\n",
1771 inode->i_sb->s_id,
1772 inode->i_ino,
1773 (long long)cur_isize,
1774 (long long)new_isize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001776 } else {
Trond Myklebust43b65352014-04-15 10:07:57 -04001777 nfsi->cache_validity |= save_cache_validity &
1778 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001779 | NFS_INO_REVAL_PAGECACHE
1780 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001781 cache_revalidated = false;
1782 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001785 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
1786 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
Trond Myklebustade14a72015-12-29 18:55:19 -05001787 else if (server->caps & NFS_CAP_ATIME) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001788 nfsi->cache_validity |= save_cache_validity &
1789 (NFS_INO_INVALID_ATIME
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001790 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001791 cache_revalidated = false;
1792 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001794 if (fattr->valid & NFS_ATTR_FATTR_MODE) {
1795 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
Trond Myklebust9b4b3512010-02-03 08:27:35 -05001796 umode_t newmode = inode->i_mode & S_IFMT;
1797 newmode |= fattr->mode & S_IALLUGO;
1798 inode->i_mode = newmode;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001799 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001800 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001801 } else if (server->caps & NFS_CAP_MODE) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001802 nfsi->cache_validity |= save_cache_validity &
1803 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001804 | NFS_INO_INVALID_ACCESS
1805 | NFS_INO_INVALID_ACL
1806 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001807 cache_revalidated = false;
1808 }
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001809
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001810 if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
Eric W. Biederman9ff593c2013-02-01 14:26:23 -08001811 if (!uid_eq(inode->i_uid, fattr->uid)) {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001812 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1813 inode->i_uid = fattr->uid;
1814 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001815 } else if (server->caps & NFS_CAP_OWNER) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001816 nfsi->cache_validity |= save_cache_validity &
1817 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001818 | NFS_INO_INVALID_ACCESS
1819 | NFS_INO_INVALID_ACL
1820 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001821 cache_revalidated = false;
1822 }
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001823
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001824 if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
Eric W. Biederman9ff593c2013-02-01 14:26:23 -08001825 if (!gid_eq(inode->i_gid, fattr->gid)) {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001826 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1827 inode->i_gid = fattr->gid;
1828 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001829 } else if (server->caps & NFS_CAP_OWNER_GROUP) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001830 nfsi->cache_validity |= save_cache_validity &
1831 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001832 | NFS_INO_INVALID_ACCESS
1833 | NFS_INO_INVALID_ACL
1834 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001835 cache_revalidated = false;
1836 }
Trond Myklebust921615f2008-10-14 19:23:07 -04001837
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001838 if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
1839 if (inode->i_nlink != fattr->nlink) {
1840 invalid |= NFS_INO_INVALID_ATTR;
1841 if (S_ISDIR(inode->i_mode))
1842 invalid |= NFS_INO_INVALID_DATA;
Miklos Szeredibfe86842011-10-28 14:13:29 +02001843 set_nlink(inode, fattr->nlink);
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001844 }
Trond Myklebustade14a72015-12-29 18:55:19 -05001845 } else if (server->caps & NFS_CAP_NLINK) {
Trond Myklebust43b65352014-04-15 10:07:57 -04001846 nfsi->cache_validity |= save_cache_validity &
1847 (NFS_INO_INVALID_ATTR
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001848 | NFS_INO_REVAL_FORCED);
Trond Myklebustade14a72015-12-29 18:55:19 -05001849 cache_revalidated = false;
1850 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001852 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 /*
1854 * report the blocks in 512byte units
1855 */
1856 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
Trond Myklebustade14a72015-12-29 18:55:19 -05001857 } else if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
Trond Myklebust9e6e70f2009-03-11 14:10:24 -04001858 inode->i_blocks = fattr->du.nfs2.blocks;
Trond Myklebustade14a72015-12-29 18:55:19 -05001859 else
1860 cache_revalidated = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861
1862 /* Update attrtimeo value if we're out of the unstable period */
Trond Myklebustfd1defc2014-02-06 14:38:53 -05001863 if (invalid & NFS_INO_INVALID_ATTR) {
Chuck Lever91d5b472006-03-20 13:44:14 -05001864 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
Trond Myklebust3e7d9502007-02-05 14:26:28 -08001866 nfsi->attrtimeo_timestamp = now;
Trond Myklebustf5062002015-02-26 19:34:32 -05001867 /* Set barrier to be more recent than all outstanding updates */
Trond Myklebust4704f0e2008-10-14 19:16:07 -04001868 nfsi->attr_gencount = nfs_inc_attr_generation_counter();
Trond Myklebust6d2b2962007-10-01 18:57:50 -04001869 } else {
Trond Myklebustade14a72015-12-29 18:55:19 -05001870 if (cache_revalidated) {
1871 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp,
1872 nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
1873 nfsi->attrtimeo <<= 1;
1874 if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode))
1875 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
1876 }
Trond Myklebust6d2b2962007-10-01 18:57:50 -04001877 nfsi->attrtimeo_timestamp = now;
1878 }
Trond Myklebustf5062002015-02-26 19:34:32 -05001879 /* Set the barrier to be more recent than this fattr */
1880 if ((long)fattr->gencount - (long)nfsi->attr_gencount > 0)
1881 nfsi->attr_gencount = fattr->gencount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 }
Jeff Laytonc8120122015-11-25 13:50:11 -05001883
1884 /* Don't declare attrcache up to date if there were no attrs! */
Trond Myklebustade14a72015-12-29 18:55:19 -05001885 if (cache_revalidated)
Jeff Laytonc8120122015-11-25 13:50:11 -05001886 invalid &= ~NFS_INO_INVALID_ATTR;
1887
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 /* Don't invalidate the data if we were to blame */
1889 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
1890 || S_ISLNK(inode->i_mode)))
1891 invalid &= ~NFS_INO_INVALID_DATA;
Bryan Schumaker011e2a72012-06-20 15:53:43 -04001892 if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ) ||
Trond Myklebust62ab460c2009-08-09 15:06:19 -04001893 (save_cache_validity & NFS_INO_REVAL_FORCED))
Trond Myklebust6edf9602014-06-20 13:11:01 -04001894 nfs_set_cache_invalid(inode, invalid);
David Howellsde242c02012-12-20 21:52:38 +00001895
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 return 0;
Trond Myklebustb37b03b2005-11-25 17:10:06 -05001897 out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 /*
1899 * No need to worry about unhashing the dentry, as the
1900 * lookup validation will know that the inode is bad.
1901 * (But we fall through to invalidate the caches.)
1902 */
1903 nfs_invalidate_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 return -ESTALE;
1905}
1906
David Howellsf7b422b2006-06-09 09:34:33 -04001907struct inode *nfs_alloc_inode(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908{
1909 struct nfs_inode *nfsi;
Firo Yangc456aac2015-04-23 17:17:51 +08001910 nfsi = kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 if (!nfsi)
1912 return NULL;
Chuck Lever55296802005-08-18 11:24:09 -07001913 nfsi->flags = 0UL;
1914 nfsi->cache_validity = 0UL;
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001915#if IS_ENABLED(CONFIG_NFS_V4)
J. Bruce Fieldse50a1c22005-06-22 17:16:23 +00001916 nfsi->nfs4_acl = NULL;
1917#endif /* CONFIG_NFS_V4 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 return &nfsi->vfs_inode;
1919}
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001920EXPORT_SYMBOL_GPL(nfs_alloc_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +11001922static void nfs_i_callback(struct rcu_head *head)
1923{
1924 struct inode *inode = container_of(head, struct inode, i_rcu);
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +11001925 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
1926}
1927
David Howellsf7b422b2006-06-09 09:34:33 -04001928void nfs_destroy_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +11001930 call_rcu(&inode->i_rcu, nfs_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931}
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001932EXPORT_SYMBOL_GPL(nfs_destroy_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933
Andrew Mortond75d5412006-06-25 02:41:26 -07001934static inline void nfs4_init_once(struct nfs_inode *nfsi)
1935{
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001936#if IS_ENABLED(CONFIG_NFS_V4)
Andrew Mortond75d5412006-06-25 02:41:26 -07001937 INIT_LIST_HEAD(&nfsi->open_states);
1938 nfsi->delegation = NULL;
Andrew Mortond75d5412006-06-25 02:41:26 -07001939 init_rwsem(&nfsi->rwsem);
Benny Halevye5e94012010-10-20 00:18:01 -04001940 nfsi->layout = NULL;
Andrew Mortond75d5412006-06-25 02:41:26 -07001941#endif
1942}
David Howellsf7b422b2006-06-09 09:34:33 -04001943
Alexey Dobriyan51cc5062008-07-25 19:45:34 -07001944static void init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945{
1946 struct nfs_inode *nfsi = (struct nfs_inode *) foo;
1947
Christoph Lametera35afb82007-05-16 22:10:57 -07001948 inode_init_once(&nfsi->vfs_inode);
Christoph Lametera35afb82007-05-16 22:10:57 -07001949 INIT_LIST_HEAD(&nfsi->open_files);
1950 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
1951 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
Fred Isamanea2cf222012-04-20 14:47:53 -04001952 INIT_LIST_HEAD(&nfsi->commit_info.list);
Weston Andros Adamsoncb1410c2014-11-12 12:08:00 -05001953 nfsi->nrequests = 0;
Fred Isamanea2cf222012-04-20 14:47:53 -04001954 nfsi->commit_info.ncommit = 0;
Trond Myklebust1a0de482012-06-19 18:38:56 -04001955 atomic_set(&nfsi->commit_info.rpcs_out, 0);
Al Viro884be172016-04-28 23:56:31 -04001956 init_rwsem(&nfsi->rmdir_sem);
Christoph Lametera35afb82007-05-16 22:10:57 -07001957 nfs4_init_once(nfsi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958}
Paul Mundt20c2df82007-07-20 10:11:58 +09001959
David Howellsf7b422b2006-06-09 09:34:33 -04001960static int __init nfs_init_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961{
1962 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
1963 sizeof(struct nfs_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -08001964 0, (SLAB_RECLAIM_ACCOUNT|
Vladimir Davydov5d097052016-01-14 15:18:21 -08001965 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
Paul Mundt20c2df82007-07-20 10:11:58 +09001966 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 if (nfs_inode_cachep == NULL)
1968 return -ENOMEM;
1969
1970 return 0;
1971}
1972
David Brownell266bee82006-06-27 12:59:15 -07001973static void nfs_destroy_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974{
Kirill A. Shutemov8c0a8532012-09-26 11:33:07 +10001975 /*
1976 * Make sure all delayed rcu free inodes are flushed before we
1977 * destroy cache.
1978 */
1979 rcu_barrier();
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001980 kmem_cache_destroy(nfs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981}
1982
Trond Myklebust57460062008-02-19 20:04:22 -05001983struct workqueue_struct *nfsiod_workqueue;
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001984EXPORT_SYMBOL_GPL(nfsiod_workqueue);
Trond Myklebust57460062008-02-19 20:04:22 -05001985
1986/*
1987 * start up the nfsiod workqueue
1988 */
1989static int nfsiod_start(void)
1990{
1991 struct workqueue_struct *wq;
1992 dprintk("RPC: creating workqueue nfsiod\n");
Tejun Heoada609e2011-01-25 14:35:54 +01001993 wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
Trond Myklebust57460062008-02-19 20:04:22 -05001994 if (wq == NULL)
1995 return -ENOMEM;
1996 nfsiod_workqueue = wq;
1997 return 0;
1998}
1999
2000/*
2001 * Destroy the nfsiod workqueue
2002 */
2003static void nfsiod_stop(void)
2004{
2005 struct workqueue_struct *wq;
2006
2007 wq = nfsiod_workqueue;
2008 if (wq == NULL)
2009 return;
2010 nfsiod_workqueue = NULL;
2011 destroy_workqueue(wq);
2012}
2013
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002014int nfs_net_id;
Stanislav Kinsbursky9e2e74d2012-01-10 17:04:24 +04002015EXPORT_SYMBOL_GPL(nfs_net_id);
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002016
2017static int nfs_net_init(struct net *net)
2018{
Stanislav Kinsbursky6b131682012-01-23 17:26:05 +00002019 nfs_clients_init(net);
Eric W. Biederman65b38852014-07-31 04:35:20 -07002020 return nfs_fs_proc_net_init(net);
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002021}
2022
2023static void nfs_net_exit(struct net *net)
2024{
Eric W. Biederman65b38852014-07-31 04:35:20 -07002025 nfs_fs_proc_net_exit(net);
Stanislav Kinsbursky28cd1b32012-01-23 17:26:22 +00002026 nfs_cleanup_cb_ident_idr(net);
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002027}
2028
2029static struct pernet_operations nfs_net_ops = {
2030 .init = nfs_net_init,
2031 .exit = nfs_net_exit,
2032 .id = &nfs_net_id,
2033 .size = sizeof(struct nfs_net),
2034};
2035
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036/*
2037 * Initialize NFS
2038 */
2039static int __init init_nfs_fs(void)
2040{
2041 int err;
2042
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002043 err = register_pernet_subsys(&nfs_net_ops);
2044 if (err < 0)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002045 goto out9;
Trond Myklebuste571cbf2009-08-19 18:12:27 -04002046
David Howells8ec442a2009-04-03 16:42:42 +01002047 err = nfs_fscache_register();
2048 if (err < 0)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002049 goto out8;
David Howells8ec442a2009-04-03 16:42:42 +01002050
Trond Myklebust57460062008-02-19 20:04:22 -05002051 err = nfsiod_start();
2052 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002053 goto out7;
Trond Myklebust57460062008-02-19 20:04:22 -05002054
David Howells6aaca562006-08-22 20:06:13 -04002055 err = nfs_fs_proc_init();
2056 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002057 goto out6;
David Howells6aaca562006-08-22 20:06:13 -04002058
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 err = nfs_init_nfspagecache();
2060 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002061 goto out5;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062
2063 err = nfs_init_inodecache();
2064 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002065 goto out4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066
2067 err = nfs_init_readpagecache();
2068 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002069 goto out3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070
2071 err = nfs_init_writepagecache();
2072 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002073 goto out2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075 err = nfs_init_directcache();
2076 if (err)
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002077 goto out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078
Stanislav Kinsburskyec7652a2011-12-06 16:42:40 +03002079 rpc_proc_register(&init_net, &nfs_rpcstat);
Kinglong Meecd738ee2015-07-01 11:58:31 +08002080
2081 err = register_nfs_fs();
2082 if (err)
Bryan Schumaker129d1972012-07-16 16:39:13 -04002083 goto out0;
2084
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 return 0;
Bryan Schumaker129d1972012-07-16 16:39:13 -04002086out0:
Stanislav Kinsburskyec7652a2011-12-06 16:42:40 +03002087 rpc_proc_unregister(&init_net, "nfs");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 nfs_destroy_directcache();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002089out1:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002090 nfs_destroy_writepagecache();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002091out2:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002092 nfs_destroy_readpagecache();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002093out3:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002094 nfs_destroy_inodecache();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002095out4:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002096 nfs_destroy_nfspagecache();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002097out5:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002098 nfs_fs_proc_exit();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002099out6:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002100 nfsiod_stop();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002101out7:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002102 nfs_fscache_unregister();
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002103out8:
Bryan Schumaker129d1972012-07-16 16:39:13 -04002104 unregister_pernet_subsys(&nfs_net_ops);
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002105out9:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 return err;
2107}
2108
2109static void __exit exit_nfs_fs(void)
2110{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 nfs_destroy_directcache();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 nfs_destroy_writepagecache();
2113 nfs_destroy_readpagecache();
2114 nfs_destroy_inodecache();
2115 nfs_destroy_nfspagecache();
David Howells8ec442a2009-04-03 16:42:42 +01002116 nfs_fscache_unregister();
Stanislav Kinsbursky1b340d02011-11-25 17:13:04 +03002117 unregister_pernet_subsys(&nfs_net_ops);
Stanislav Kinsburskyec7652a2011-12-06 16:42:40 +03002118 rpc_proc_unregister(&init_net, "nfs");
David Howellsf7b422b2006-06-09 09:34:33 -04002119 unregister_nfs_fs();
David Howells6aaca562006-08-22 20:06:13 -04002120 nfs_fs_proc_exit();
Trond Myklebust57460062008-02-19 20:04:22 -05002121 nfsiod_stop();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122}
2123
2124/* Not quite true; I just maintain it */
2125MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
2126MODULE_LICENSE("GPL");
Trond Myklebustf43bf0b2007-10-09 12:01:04 -04002127module_param(enable_ino64, bool, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128
2129module_init(init_nfs_fs)
2130module_exit(exit_nfs_fs)