xref: /openbmc/linux/fs/nfs/inode.c (revision cf26e043)
1  // SPDX-License-Identifier: GPL-2.0-only
2  /*
3   *  linux/fs/nfs/inode.c
4   *
5   *  Copyright (C) 1992  Rick Sladkey
6   *
7   *  nfs inode and superblock handling functions
8   *
9   *  Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
10   *  experimental NFS changes. Modularisation taken straight from SYS5 fs.
11   *
12   *  Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
13   *  J.S.Peatfield@damtp.cam.ac.uk
14   *
15   */
16  
17  #include <linux/module.h>
18  #include <linux/init.h>
19  #include <linux/sched/signal.h>
20  #include <linux/time.h>
21  #include <linux/kernel.h>
22  #include <linux/mm.h>
23  #include <linux/string.h>
24  #include <linux/stat.h>
25  #include <linux/errno.h>
26  #include <linux/unistd.h>
27  #include <linux/sunrpc/clnt.h>
28  #include <linux/sunrpc/stats.h>
29  #include <linux/sunrpc/metrics.h>
30  #include <linux/nfs_fs.h>
31  #include <linux/nfs_mount.h>
32  #include <linux/nfs4_mount.h>
33  #include <linux/lockd/bind.h>
34  #include <linux/seq_file.h>
35  #include <linux/mount.h>
36  #include <linux/vfs.h>
37  #include <linux/inet.h>
38  #include <linux/nfs_xdr.h>
39  #include <linux/slab.h>
40  #include <linux/compat.h>
41  #include <linux/freezer.h>
42  #include <linux/uaccess.h>
43  #include <linux/iversion.h>
44  
45  #include "nfs4_fs.h"
46  #include "callback.h"
47  #include "delegation.h"
48  #include "iostat.h"
49  #include "internal.h"
50  #include "fscache.h"
51  #include "pnfs.h"
52  #include "nfs.h"
53  #include "netns.h"
54  #include "sysfs.h"
55  
56  #include "nfstrace.h"
57  
58  #define NFSDBG_FACILITY		NFSDBG_VFS
59  
60  #define NFS_64_BIT_INODE_NUMBERS_ENABLED	1
61  
62  /* Default is to see 64-bit inode numbers */
63  static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
64  
65  static int nfs_update_inode(struct inode *, struct nfs_fattr *);
66  
67  static struct kmem_cache * nfs_inode_cachep;
68  
69  static inline unsigned long
70  nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
71  {
72  	return nfs_fileid_to_ino_t(fattr->fileid);
73  }
74  
75  int nfs_wait_bit_killable(struct wait_bit_key *key, int mode)
76  {
77  	schedule();
78  	if (signal_pending_state(mode, current))
79  		return -ERESTARTSYS;
80  	return 0;
81  }
82  EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
83  
84  /**
85   * nfs_compat_user_ino64 - returns the user-visible inode number
86   * @fileid: 64-bit fileid
87   *
88   * This function returns a 32-bit inode number if the boot parameter
89   * nfs.enable_ino64 is zero.
90   */
91  u64 nfs_compat_user_ino64(u64 fileid)
92  {
93  #ifdef CONFIG_COMPAT
94  	compat_ulong_t ino;
95  #else
96  	unsigned long ino;
97  #endif
98  
99  	if (enable_ino64)
100  		return fileid;
101  	ino = fileid;
102  	if (sizeof(ino) < sizeof(fileid))
103  		ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
104  	return ino;
105  }
106  
107  int nfs_drop_inode(struct inode *inode)
108  {
109  	return NFS_STALE(inode) || generic_drop_inode(inode);
110  }
111  EXPORT_SYMBOL_GPL(nfs_drop_inode);
112  
113  void nfs_clear_inode(struct inode *inode)
114  {
115  	/*
116  	 * The following should never happen...
117  	 */
118  	WARN_ON_ONCE(nfs_have_writebacks(inode));
119  	WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files));
120  	nfs_zap_acl_cache(inode);
121  	nfs_access_zap_cache(inode);
122  	nfs_fscache_clear_inode(inode);
123  }
124  EXPORT_SYMBOL_GPL(nfs_clear_inode);
125  
126  void nfs_evict_inode(struct inode *inode)
127  {
128  	truncate_inode_pages_final(&inode->i_data);
129  	clear_inode(inode);
130  	nfs_clear_inode(inode);
131  }
132  
133  int nfs_sync_inode(struct inode *inode)
134  {
135  	inode_dio_wait(inode);
136  	return nfs_wb_all(inode);
137  }
138  EXPORT_SYMBOL_GPL(nfs_sync_inode);
139  
140  /**
141   * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
142   * @mapping: pointer to struct address_space
143   */
144  int nfs_sync_mapping(struct address_space *mapping)
145  {
146  	int ret = 0;
147  
148  	if (mapping->nrpages != 0) {
149  		unmap_mapping_range(mapping, 0, 0, 0);
150  		ret = nfs_wb_all(mapping->host);
151  	}
152  	return ret;
153  }
154  
155  static int nfs_attribute_timeout(struct inode *inode)
156  {
157  	struct nfs_inode *nfsi = NFS_I(inode);
158  
159  	return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
160  }
161  
162  static bool nfs_check_cache_flags_invalid(struct inode *inode,
163  					  unsigned long flags)
164  {
165  	unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
166  
167  	return (cache_validity & flags) != 0;
168  }
169  
170  bool nfs_check_cache_invalid(struct inode *inode, unsigned long flags)
171  {
172  	if (nfs_check_cache_flags_invalid(inode, flags))
173  		return true;
174  	return nfs_attribute_cache_expired(inode);
175  }
176  EXPORT_SYMBOL_GPL(nfs_check_cache_invalid);
177  
178  #ifdef CONFIG_NFS_V4_2
179  static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi)
180  {
181  	return nfsi->xattr_cache != NULL;
182  }
183  #else
184  static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi)
185  {
186  	return false;
187  }
188  #endif
189  
190  void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
191  {
192  	struct nfs_inode *nfsi = NFS_I(inode);
193  	bool have_delegation = NFS_PROTO(inode)->have_delegation(inode, FMODE_READ);
194  
195  	if (have_delegation) {
196  		if (!(flags & NFS_INO_REVAL_FORCED))
197  			flags &= ~(NFS_INO_INVALID_MODE |
198  				   NFS_INO_INVALID_OTHER |
199  				   NFS_INO_INVALID_XATTR);
200  		flags &= ~(NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE);
201  	}
202  
203  	if (!nfs_has_xattr_cache(nfsi))
204  		flags &= ~NFS_INO_INVALID_XATTR;
205  	if (flags & NFS_INO_INVALID_DATA)
206  		nfs_fscache_invalidate(inode, 0);
207  	flags &= ~NFS_INO_REVAL_FORCED;
208  
209  	nfsi->cache_validity |= flags;
210  
211  	if (inode->i_mapping->nrpages == 0)
212  		nfsi->cache_validity &= ~(NFS_INO_INVALID_DATA |
213  					  NFS_INO_DATA_INVAL_DEFER);
214  	else if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
215  		nfsi->cache_validity &= ~NFS_INO_DATA_INVAL_DEFER;
216  	trace_nfs_set_cache_invalid(inode, 0);
217  }
218  EXPORT_SYMBOL_GPL(nfs_set_cache_invalid);
219  
220  /*
221   * Invalidate the local caches
222   */
223  static void nfs_zap_caches_locked(struct inode *inode)
224  {
225  	struct nfs_inode *nfsi = NFS_I(inode);
226  	int mode = inode->i_mode;
227  
228  	nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
229  
230  	nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
231  	nfsi->attrtimeo_timestamp = jiffies;
232  
233  	if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
234  		nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR |
235  						     NFS_INO_INVALID_DATA |
236  						     NFS_INO_INVALID_ACCESS |
237  						     NFS_INO_INVALID_ACL |
238  						     NFS_INO_INVALID_XATTR);
239  	else
240  		nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR |
241  						     NFS_INO_INVALID_ACCESS |
242  						     NFS_INO_INVALID_ACL |
243  						     NFS_INO_INVALID_XATTR);
244  	nfs_zap_label_cache_locked(nfsi);
245  }
246  
247  void nfs_zap_caches(struct inode *inode)
248  {
249  	spin_lock(&inode->i_lock);
250  	nfs_zap_caches_locked(inode);
251  	spin_unlock(&inode->i_lock);
252  }
253  
254  void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
255  {
256  	if (mapping->nrpages != 0) {
257  		spin_lock(&inode->i_lock);
258  		nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
259  		spin_unlock(&inode->i_lock);
260  	}
261  }
262  
263  void nfs_zap_acl_cache(struct inode *inode)
264  {
265  	void (*clear_acl_cache)(struct inode *);
266  
267  	clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
268  	if (clear_acl_cache != NULL)
269  		clear_acl_cache(inode);
270  	spin_lock(&inode->i_lock);
271  	NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
272  	spin_unlock(&inode->i_lock);
273  }
274  EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
275  
276  void nfs_invalidate_atime(struct inode *inode)
277  {
278  	spin_lock(&inode->i_lock);
279  	nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
280  	spin_unlock(&inode->i_lock);
281  }
282  EXPORT_SYMBOL_GPL(nfs_invalidate_atime);
283  
284  /*
285   * Invalidate, but do not unhash, the inode.
286   * NB: must be called with inode->i_lock held!
287   */
288  static void nfs_set_inode_stale_locked(struct inode *inode)
289  {
290  	set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
291  	nfs_zap_caches_locked(inode);
292  	trace_nfs_set_inode_stale(inode);
293  }
294  
295  void nfs_set_inode_stale(struct inode *inode)
296  {
297  	spin_lock(&inode->i_lock);
298  	nfs_set_inode_stale_locked(inode);
299  	spin_unlock(&inode->i_lock);
300  }
301  
302  struct nfs_find_desc {
303  	struct nfs_fh		*fh;
304  	struct nfs_fattr	*fattr;
305  };
306  
307  /*
308   * In NFSv3 we can have 64bit inode numbers. In order to support
309   * this, and re-exported directories (also seen in NFSv2)
310   * we are forced to allow 2 different inodes to have the same
311   * i_ino.
312   */
313  static int
314  nfs_find_actor(struct inode *inode, void *opaque)
315  {
316  	struct nfs_find_desc	*desc = opaque;
317  	struct nfs_fh		*fh = desc->fh;
318  	struct nfs_fattr	*fattr = desc->fattr;
319  
320  	if (NFS_FILEID(inode) != fattr->fileid)
321  		return 0;
322  	if (inode_wrong_type(inode, fattr->mode))
323  		return 0;
324  	if (nfs_compare_fh(NFS_FH(inode), fh))
325  		return 0;
326  	if (is_bad_inode(inode) || NFS_STALE(inode))
327  		return 0;
328  	return 1;
329  }
330  
331  static int
332  nfs_init_locked(struct inode *inode, void *opaque)
333  {
334  	struct nfs_find_desc	*desc = opaque;
335  	struct nfs_fattr	*fattr = desc->fattr;
336  
337  	set_nfs_fileid(inode, fattr->fileid);
338  	inode->i_mode = fattr->mode;
339  	nfs_copy_fh(NFS_FH(inode), desc->fh);
340  	return 0;
341  }
342  
343  #ifdef CONFIG_NFS_V4_SECURITY_LABEL
344  static void nfs_clear_label_invalid(struct inode *inode)
345  {
346  	spin_lock(&inode->i_lock);
347  	NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_LABEL;
348  	spin_unlock(&inode->i_lock);
349  }
350  
351  void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr)
352  {
353  	int error;
354  
355  	if (fattr->label == NULL)
356  		return;
357  
358  	if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) && inode->i_security) {
359  		error = security_inode_notifysecctx(inode, fattr->label->label,
360  				fattr->label->len);
361  		if (error)
362  			printk(KERN_ERR "%s() %s %d "
363  					"security_inode_notifysecctx() %d\n",
364  					__func__,
365  					(char *)fattr->label->label,
366  					fattr->label->len, error);
367  		nfs_clear_label_invalid(inode);
368  	}
369  }
370  
371  struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
372  {
373  	struct nfs4_label *label;
374  
375  	if (!(server->caps & NFS_CAP_SECURITY_LABEL))
376  		return NULL;
377  
378  	label = kzalloc(sizeof(struct nfs4_label), flags);
379  	if (label == NULL)
380  		return ERR_PTR(-ENOMEM);
381  
382  	label->label = kzalloc(NFS4_MAXLABELLEN, flags);
383  	if (label->label == NULL) {
384  		kfree(label);
385  		return ERR_PTR(-ENOMEM);
386  	}
387  	label->len = NFS4_MAXLABELLEN;
388  
389  	return label;
390  }
391  EXPORT_SYMBOL_GPL(nfs4_label_alloc);
392  #else
393  void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr)
394  {
395  }
396  #endif
397  EXPORT_SYMBOL_GPL(nfs_setsecurity);
398  
399  /* Search for inode identified by fh, fileid and i_mode in inode cache. */
400  struct inode *
401  nfs_ilookup(struct super_block *sb, struct nfs_fattr *fattr, struct nfs_fh *fh)
402  {
403  	struct nfs_find_desc desc = {
404  		.fh	= fh,
405  		.fattr	= fattr,
406  	};
407  	struct inode *inode;
408  	unsigned long hash;
409  
410  	if (!(fattr->valid & NFS_ATTR_FATTR_FILEID) ||
411  	    !(fattr->valid & NFS_ATTR_FATTR_TYPE))
412  		return NULL;
413  
414  	hash = nfs_fattr_to_ino_t(fattr);
415  	inode = ilookup5(sb, hash, nfs_find_actor, &desc);
416  
417  	dprintk("%s: returning %p\n", __func__, inode);
418  	return inode;
419  }
420  
421  static void nfs_inode_init_regular(struct nfs_inode *nfsi)
422  {
423  	atomic_long_set(&nfsi->nrequests, 0);
424  	atomic_long_set(&nfsi->redirtied_pages, 0);
425  	INIT_LIST_HEAD(&nfsi->commit_info.list);
426  	atomic_long_set(&nfsi->commit_info.ncommit, 0);
427  	atomic_set(&nfsi->commit_info.rpcs_out, 0);
428  	mutex_init(&nfsi->commit_mutex);
429  }
430  
431  static void nfs_inode_init_dir(struct nfs_inode *nfsi)
432  {
433  	nfsi->cache_change_attribute = 0;
434  	memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
435  	init_rwsem(&nfsi->rmdir_sem);
436  }
437  
438  /*
439   * This is our front-end to iget that looks up inodes by file handle
440   * instead of inode number.
441   */
442  struct inode *
443  nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
444  {
445  	struct nfs_find_desc desc = {
446  		.fh	= fh,
447  		.fattr	= fattr
448  	};
449  	struct inode *inode = ERR_PTR(-ENOENT);
450  	u64 fattr_supported = NFS_SB(sb)->fattr_valid;
451  	unsigned long hash;
452  
453  	nfs_attr_check_mountpoint(sb, fattr);
454  
455  	if (nfs_attr_use_mounted_on_fileid(fattr))
456  		fattr->fileid = fattr->mounted_on_fileid;
457  	else if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0)
458  		goto out_no_inode;
459  	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
460  		goto out_no_inode;
461  
462  	hash = nfs_fattr_to_ino_t(fattr);
463  
464  	inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
465  	if (inode == NULL) {
466  		inode = ERR_PTR(-ENOMEM);
467  		goto out_no_inode;
468  	}
469  
470  	if (inode->i_state & I_NEW) {
471  		struct nfs_inode *nfsi = NFS_I(inode);
472  		unsigned long now = jiffies;
473  
474  		/* We set i_ino for the few things that still rely on it,
475  		 * such as stat(2) */
476  		inode->i_ino = hash;
477  
478  		/* We can't support update_atime(), since the server will reset it */
479  		inode->i_flags |= S_NOATIME|S_NOCMTIME;
480  		inode->i_mode = fattr->mode;
481  		nfsi->cache_validity = 0;
482  		if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
483  				&& (fattr_supported & NFS_ATTR_FATTR_MODE))
484  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_MODE);
485  		/* Why so? Because we want revalidate for devices/FIFOs, and
486  		 * that's precisely what we have in nfs_file_inode_operations.
487  		 */
488  		inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
489  		if (S_ISREG(inode->i_mode)) {
490  			inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
491  			inode->i_data.a_ops = &nfs_file_aops;
492  			nfs_inode_init_regular(nfsi);
493  		} else if (S_ISDIR(inode->i_mode)) {
494  			inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
495  			inode->i_fop = &nfs_dir_operations;
496  			inode->i_data.a_ops = &nfs_dir_aops;
497  			nfs_inode_init_dir(nfsi);
498  			/* Deal with crossing mountpoints */
499  			if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
500  					fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
501  				if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
502  					inode->i_op = &nfs_referral_inode_operations;
503  				else
504  					inode->i_op = &nfs_mountpoint_inode_operations;
505  				inode->i_fop = NULL;
506  				inode->i_flags |= S_AUTOMOUNT;
507  			}
508  		} else if (S_ISLNK(inode->i_mode)) {
509  			inode->i_op = &nfs_symlink_inode_operations;
510  			inode_nohighmem(inode);
511  		} else
512  			init_special_inode(inode, inode->i_mode, fattr->rdev);
513  
514  		memset(&inode->i_atime, 0, sizeof(inode->i_atime));
515  		memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
516  		memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
517  		inode_set_iversion_raw(inode, 0);
518  		inode->i_size = 0;
519  		clear_nlink(inode);
520  		inode->i_uid = make_kuid(&init_user_ns, -2);
521  		inode->i_gid = make_kgid(&init_user_ns, -2);
522  		inode->i_blocks = 0;
523  		nfsi->write_io = 0;
524  		nfsi->read_io = 0;
525  
526  		nfsi->read_cache_jiffies = fattr->time_start;
527  		nfsi->attr_gencount = fattr->gencount;
528  		if (fattr->valid & NFS_ATTR_FATTR_ATIME)
529  			inode->i_atime = fattr->atime;
530  		else if (fattr_supported & NFS_ATTR_FATTR_ATIME)
531  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
532  		if (fattr->valid & NFS_ATTR_FATTR_MTIME)
533  			inode->i_mtime = fattr->mtime;
534  		else if (fattr_supported & NFS_ATTR_FATTR_MTIME)
535  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
536  		if (fattr->valid & NFS_ATTR_FATTR_CTIME)
537  			inode->i_ctime = fattr->ctime;
538  		else if (fattr_supported & NFS_ATTR_FATTR_CTIME)
539  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_CTIME);
540  		if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
541  			inode_set_iversion_raw(inode, fattr->change_attr);
542  		else
543  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE);
544  		if (fattr->valid & NFS_ATTR_FATTR_SIZE)
545  			inode->i_size = nfs_size_to_loff_t(fattr->size);
546  		else
547  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_SIZE);
548  		if (fattr->valid & NFS_ATTR_FATTR_NLINK)
549  			set_nlink(inode, fattr->nlink);
550  		else if (fattr_supported & NFS_ATTR_FATTR_NLINK)
551  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_NLINK);
552  		if (fattr->valid & NFS_ATTR_FATTR_OWNER)
553  			inode->i_uid = fattr->uid;
554  		else if (fattr_supported & NFS_ATTR_FATTR_OWNER)
555  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
556  		if (fattr->valid & NFS_ATTR_FATTR_GROUP)
557  			inode->i_gid = fattr->gid;
558  		else if (fattr_supported & NFS_ATTR_FATTR_GROUP)
559  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
560  		if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
561  			inode->i_blocks = fattr->du.nfs2.blocks;
562  		else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED &&
563  			 fattr->size != 0)
564  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
565  		if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
566  			/*
567  			 * report the blocks in 512byte units
568  			 */
569  			inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
570  		} else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED &&
571  			   fattr->size != 0)
572  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
573  
574  		nfs_setsecurity(inode, fattr);
575  
576  		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
577  		nfsi->attrtimeo_timestamp = now;
578  		nfsi->access_cache = RB_ROOT;
579  
580  		nfs_fscache_init_inode(inode);
581  
582  		unlock_new_inode(inode);
583  	} else {
584  		int err = nfs_refresh_inode(inode, fattr);
585  		if (err < 0) {
586  			iput(inode);
587  			inode = ERR_PTR(err);
588  			goto out_no_inode;
589  		}
590  	}
591  	dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n",
592  		inode->i_sb->s_id,
593  		(unsigned long long)NFS_FILEID(inode),
594  		nfs_display_fhandle_hash(fh),
595  		atomic_read(&inode->i_count));
596  
597  out:
598  	return inode;
599  
600  out_no_inode:
601  	dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
602  	goto out;
603  }
604  EXPORT_SYMBOL_GPL(nfs_fhget);
605  
606  #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)
607  
608  int
609  nfs_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
610  	    struct iattr *attr)
611  {
612  	struct inode *inode = d_inode(dentry);
613  	struct nfs_fattr *fattr;
614  	int error = 0;
615  
616  	nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
617  
618  	/* skip mode change if it's just for clearing setuid/setgid */
619  	if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
620  		attr->ia_valid &= ~ATTR_MODE;
621  
622  	if (attr->ia_valid & ATTR_SIZE) {
623  		BUG_ON(!S_ISREG(inode->i_mode));
624  
625  		error = inode_newsize_ok(inode, attr->ia_size);
626  		if (error)
627  			return error;
628  
629  		if (attr->ia_size == i_size_read(inode))
630  			attr->ia_valid &= ~ATTR_SIZE;
631  	}
632  
633  	/* Optimization: if the end result is no change, don't RPC */
634  	if (((attr->ia_valid & NFS_VALID_ATTRS) & ~(ATTR_FILE|ATTR_OPEN)) == 0)
635  		return 0;
636  
637  	trace_nfs_setattr_enter(inode);
638  
639  	/* Write all dirty data */
640  	if (S_ISREG(inode->i_mode))
641  		nfs_sync_inode(inode);
642  
643  	fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
644  	if (fattr == NULL) {
645  		error = -ENOMEM;
646  		goto out;
647  	}
648  
649  	error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
650  	if (error == 0)
651  		error = nfs_refresh_inode(inode, fattr);
652  	nfs_free_fattr(fattr);
653  out:
654  	trace_nfs_setattr_exit(inode, error);
655  	return error;
656  }
657  EXPORT_SYMBOL_GPL(nfs_setattr);
658  
659  /**
660   * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
661   * @inode: inode of the file used
662   * @offset: file offset to start truncating
663   *
664   * This is a copy of the common vmtruncate, but with the locking
665   * corrected to take into account the fact that NFS requires
666   * inode->i_size to be updated under the inode->i_lock.
667   * Note: must be called with inode->i_lock held!
668   */
669  static int nfs_vmtruncate(struct inode * inode, loff_t offset)
670  {
671  	int err;
672  
673  	err = inode_newsize_ok(inode, offset);
674  	if (err)
675  		goto out;
676  
677  	trace_nfs_size_truncate(inode, offset);
678  	i_size_write(inode, offset);
679  	/* Optimisation */
680  	if (offset == 0)
681  		NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_DATA |
682  				NFS_INO_DATA_INVAL_DEFER);
683  	NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE;
684  
685  	spin_unlock(&inode->i_lock);
686  	truncate_pagecache(inode, offset);
687  	spin_lock(&inode->i_lock);
688  out:
689  	return err;
690  }
691  
692  /**
693   * nfs_setattr_update_inode - Update inode metadata after a setattr call.
694   * @inode: pointer to struct inode
695   * @attr: pointer to struct iattr
696   * @fattr: pointer to struct nfs_fattr
697   *
698   * Note: we do this in the *proc.c in order to ensure that
699   *       it works for things like exclusive creates too.
700   */
701  void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr,
702  		struct nfs_fattr *fattr)
703  {
704  	/* Barrier: bump the attribute generation count. */
705  	nfs_fattr_set_barrier(fattr);
706  
707  	spin_lock(&inode->i_lock);
708  	NFS_I(inode)->attr_gencount = fattr->gencount;
709  	if ((attr->ia_valid & ATTR_SIZE) != 0) {
710  		nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME |
711  						     NFS_INO_INVALID_BLOCKS);
712  		nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
713  		nfs_vmtruncate(inode, attr->ia_size);
714  	}
715  	if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
716  		NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_CTIME;
717  		if ((attr->ia_valid & ATTR_KILL_SUID) != 0 &&
718  		    inode->i_mode & S_ISUID)
719  			inode->i_mode &= ~S_ISUID;
720  		if ((attr->ia_valid & ATTR_KILL_SGID) != 0 &&
721  		    (inode->i_mode & (S_ISGID | S_IXGRP)) ==
722  		     (S_ISGID | S_IXGRP))
723  			inode->i_mode &= ~S_ISGID;
724  		if ((attr->ia_valid & ATTR_MODE) != 0) {
725  			int mode = attr->ia_mode & S_IALLUGO;
726  			mode |= inode->i_mode & ~S_IALLUGO;
727  			inode->i_mode = mode;
728  		}
729  		if ((attr->ia_valid & ATTR_UID) != 0)
730  			inode->i_uid = attr->ia_uid;
731  		if ((attr->ia_valid & ATTR_GID) != 0)
732  			inode->i_gid = attr->ia_gid;
733  		if (fattr->valid & NFS_ATTR_FATTR_CTIME)
734  			inode->i_ctime = fattr->ctime;
735  		else
736  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
737  					| NFS_INO_INVALID_CTIME);
738  		nfs_set_cache_invalid(inode, NFS_INO_INVALID_ACCESS
739  				| NFS_INO_INVALID_ACL);
740  	}
741  	if (attr->ia_valid & (ATTR_ATIME_SET|ATTR_ATIME)) {
742  		NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_ATIME
743  				| NFS_INO_INVALID_CTIME);
744  		if (fattr->valid & NFS_ATTR_FATTR_ATIME)
745  			inode->i_atime = fattr->atime;
746  		else if (attr->ia_valid & ATTR_ATIME_SET)
747  			inode->i_atime = attr->ia_atime;
748  		else
749  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
750  
751  		if (fattr->valid & NFS_ATTR_FATTR_CTIME)
752  			inode->i_ctime = fattr->ctime;
753  		else
754  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
755  					| NFS_INO_INVALID_CTIME);
756  	}
757  	if (attr->ia_valid & (ATTR_MTIME_SET|ATTR_MTIME)) {
758  		NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_MTIME
759  				| NFS_INO_INVALID_CTIME);
760  		if (fattr->valid & NFS_ATTR_FATTR_MTIME)
761  			inode->i_mtime = fattr->mtime;
762  		else if (attr->ia_valid & ATTR_MTIME_SET)
763  			inode->i_mtime = attr->ia_mtime;
764  		else
765  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
766  
767  		if (fattr->valid & NFS_ATTR_FATTR_CTIME)
768  			inode->i_ctime = fattr->ctime;
769  		else
770  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
771  					| NFS_INO_INVALID_CTIME);
772  	}
773  	if (fattr->valid)
774  		nfs_update_inode(inode, fattr);
775  	spin_unlock(&inode->i_lock);
776  }
777  EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);
778  
779  /*
780   * Don't request help from readdirplus if the file is being written to,
781   * or if attribute caching is turned off
782   */
783  static bool nfs_getattr_readdirplus_enable(const struct inode *inode)
784  {
785  	return nfs_server_capable(inode, NFS_CAP_READDIRPLUS) &&
786  	       !nfs_have_writebacks(inode) && NFS_MAXATTRTIMEO(inode) > 5 * HZ;
787  }
788  
789  static void nfs_readdirplus_parent_cache_miss(struct dentry *dentry)
790  {
791  	if (!IS_ROOT(dentry)) {
792  		struct dentry *parent = dget_parent(dentry);
793  		nfs_readdir_record_entry_cache_miss(d_inode(parent));
794  		dput(parent);
795  	}
796  }
797  
798  static void nfs_readdirplus_parent_cache_hit(struct dentry *dentry)
799  {
800  	if (!IS_ROOT(dentry)) {
801  		struct dentry *parent = dget_parent(dentry);
802  		nfs_readdir_record_entry_cache_hit(d_inode(parent));
803  		dput(parent);
804  	}
805  }
806  
807  static u32 nfs_get_valid_attrmask(struct inode *inode)
808  {
809  	unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
810  	u32 reply_mask = STATX_INO | STATX_TYPE;
811  
812  	if (!(cache_validity & NFS_INO_INVALID_ATIME))
813  		reply_mask |= STATX_ATIME;
814  	if (!(cache_validity & NFS_INO_INVALID_CTIME))
815  		reply_mask |= STATX_CTIME;
816  	if (!(cache_validity & NFS_INO_INVALID_MTIME))
817  		reply_mask |= STATX_MTIME;
818  	if (!(cache_validity & NFS_INO_INVALID_SIZE))
819  		reply_mask |= STATX_SIZE;
820  	if (!(cache_validity & NFS_INO_INVALID_NLINK))
821  		reply_mask |= STATX_NLINK;
822  	if (!(cache_validity & NFS_INO_INVALID_MODE))
823  		reply_mask |= STATX_MODE;
824  	if (!(cache_validity & NFS_INO_INVALID_OTHER))
825  		reply_mask |= STATX_UID | STATX_GID;
826  	if (!(cache_validity & NFS_INO_INVALID_BLOCKS))
827  		reply_mask |= STATX_BLOCKS;
828  	return reply_mask;
829  }
830  
831  int nfs_getattr(struct user_namespace *mnt_userns, const struct path *path,
832  		struct kstat *stat, u32 request_mask, unsigned int query_flags)
833  {
834  	struct inode *inode = d_inode(path->dentry);
835  	struct nfs_server *server = NFS_SERVER(inode);
836  	unsigned long cache_validity;
837  	int err = 0;
838  	bool force_sync = query_flags & AT_STATX_FORCE_SYNC;
839  	bool do_update = false;
840  	bool readdirplus_enabled = nfs_getattr_readdirplus_enable(inode);
841  
842  	trace_nfs_getattr_enter(inode);
843  
844  	request_mask &= STATX_TYPE | STATX_MODE | STATX_NLINK | STATX_UID |
845  			STATX_GID | STATX_ATIME | STATX_MTIME | STATX_CTIME |
846  			STATX_INO | STATX_SIZE | STATX_BLOCKS;
847  
848  	if ((query_flags & AT_STATX_DONT_SYNC) && !force_sync) {
849  		if (readdirplus_enabled)
850  			nfs_readdirplus_parent_cache_hit(path->dentry);
851  		goto out_no_revalidate;
852  	}
853  
854  	/* Flush out writes to the server in order to update c/mtime.  */
855  	if ((request_mask & (STATX_CTIME | STATX_MTIME)) &&
856  	    S_ISREG(inode->i_mode))
857  		filemap_write_and_wait(inode->i_mapping);
858  
859  	/*
860  	 * We may force a getattr if the user cares about atime.
861  	 *
862  	 * Note that we only have to check the vfsmount flags here:
863  	 *  - NFS always sets S_NOATIME by so checking it would give a
864  	 *    bogus result
865  	 *  - NFS never sets SB_NOATIME or SB_NODIRATIME so there is
866  	 *    no point in checking those.
867  	 */
868  	if ((path->mnt->mnt_flags & MNT_NOATIME) ||
869  	    ((path->mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
870  		request_mask &= ~STATX_ATIME;
871  
872  	/* Is the user requesting attributes that might need revalidation? */
873  	if (!(request_mask & (STATX_MODE|STATX_NLINK|STATX_ATIME|STATX_CTIME|
874  					STATX_MTIME|STATX_UID|STATX_GID|
875  					STATX_SIZE|STATX_BLOCKS)))
876  		goto out_no_revalidate;
877  
878  	/* Check whether the cached attributes are stale */
879  	do_update |= force_sync || nfs_attribute_cache_expired(inode);
880  	cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
881  	do_update |= cache_validity & NFS_INO_INVALID_CHANGE;
882  	if (request_mask & STATX_ATIME)
883  		do_update |= cache_validity & NFS_INO_INVALID_ATIME;
884  	if (request_mask & STATX_CTIME)
885  		do_update |= cache_validity & NFS_INO_INVALID_CTIME;
886  	if (request_mask & STATX_MTIME)
887  		do_update |= cache_validity & NFS_INO_INVALID_MTIME;
888  	if (request_mask & STATX_SIZE)
889  		do_update |= cache_validity & NFS_INO_INVALID_SIZE;
890  	if (request_mask & STATX_NLINK)
891  		do_update |= cache_validity & NFS_INO_INVALID_NLINK;
892  	if (request_mask & STATX_MODE)
893  		do_update |= cache_validity & NFS_INO_INVALID_MODE;
894  	if (request_mask & (STATX_UID | STATX_GID))
895  		do_update |= cache_validity & NFS_INO_INVALID_OTHER;
896  	if (request_mask & STATX_BLOCKS)
897  		do_update |= cache_validity & NFS_INO_INVALID_BLOCKS;
898  
899  	if (do_update) {
900  		if (readdirplus_enabled)
901  			nfs_readdirplus_parent_cache_miss(path->dentry);
902  		err = __nfs_revalidate_inode(server, inode);
903  		if (err)
904  			goto out;
905  	} else if (readdirplus_enabled)
906  		nfs_readdirplus_parent_cache_hit(path->dentry);
907  out_no_revalidate:
908  	/* Only return attributes that were revalidated. */
909  	stat->result_mask = nfs_get_valid_attrmask(inode) | request_mask;
910  
911  	generic_fillattr(&init_user_ns, inode, stat);
912  	stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
913  	if (S_ISDIR(inode->i_mode))
914  		stat->blksize = NFS_SERVER(inode)->dtsize;
915  out:
916  	trace_nfs_getattr_exit(inode, err);
917  	return err;
918  }
919  EXPORT_SYMBOL_GPL(nfs_getattr);
920  
921  static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
922  {
923  	refcount_set(&l_ctx->count, 1);
924  	l_ctx->lockowner = current->files;
925  	INIT_LIST_HEAD(&l_ctx->list);
926  	atomic_set(&l_ctx->io_count, 0);
927  }
928  
929  static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx)
930  {
931  	struct nfs_lock_context *pos;
932  
933  	list_for_each_entry_rcu(pos, &ctx->lock_context.list, list) {
934  		if (pos->lockowner != current->files)
935  			continue;
936  		if (refcount_inc_not_zero(&pos->count))
937  			return pos;
938  	}
939  	return NULL;
940  }
941  
942  struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
943  {
944  	struct nfs_lock_context *res, *new = NULL;
945  	struct inode *inode = d_inode(ctx->dentry);
946  
947  	rcu_read_lock();
948  	res = __nfs_find_lock_context(ctx);
949  	rcu_read_unlock();
950  	if (res == NULL) {
951  		new = kmalloc(sizeof(*new), GFP_KERNEL_ACCOUNT);
952  		if (new == NULL)
953  			return ERR_PTR(-ENOMEM);
954  		nfs_init_lock_context(new);
955  		spin_lock(&inode->i_lock);
956  		res = __nfs_find_lock_context(ctx);
957  		if (res == NULL) {
958  			new->open_context = get_nfs_open_context(ctx);
959  			if (new->open_context) {
960  				list_add_tail_rcu(&new->list,
961  						&ctx->lock_context.list);
962  				res = new;
963  				new = NULL;
964  			} else
965  				res = ERR_PTR(-EBADF);
966  		}
967  		spin_unlock(&inode->i_lock);
968  		kfree(new);
969  	}
970  	return res;
971  }
972  EXPORT_SYMBOL_GPL(nfs_get_lock_context);
973  
974  void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
975  {
976  	struct nfs_open_context *ctx = l_ctx->open_context;
977  	struct inode *inode = d_inode(ctx->dentry);
978  
979  	if (!refcount_dec_and_lock(&l_ctx->count, &inode->i_lock))
980  		return;
981  	list_del_rcu(&l_ctx->list);
982  	spin_unlock(&inode->i_lock);
983  	put_nfs_open_context(ctx);
984  	kfree_rcu(l_ctx, rcu_head);
985  }
986  EXPORT_SYMBOL_GPL(nfs_put_lock_context);
987  
988  /**
989   * nfs_close_context - Common close_context() routine NFSv2/v3
990   * @ctx: pointer to context
991   * @is_sync: is this a synchronous close
992   *
993   * Ensure that the attributes are up to date if we're mounted
994   * with close-to-open semantics and we have cached data that will
995   * need to be revalidated on open.
996   */
997  void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
998  {
999  	struct nfs_inode *nfsi;
1000  	struct inode *inode;
1001  
1002  	if (!(ctx->mode & FMODE_WRITE))
1003  		return;
1004  	if (!is_sync)
1005  		return;
1006  	inode = d_inode(ctx->dentry);
1007  	if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1008  		return;
1009  	nfsi = NFS_I(inode);
1010  	if (inode->i_mapping->nrpages == 0)
1011  		return;
1012  	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
1013  		return;
1014  	if (!list_empty(&nfsi->open_files))
1015  		return;
1016  	if (NFS_SERVER(inode)->flags & NFS_MOUNT_NOCTO)
1017  		return;
1018  	nfs_revalidate_inode(inode,
1019  			     NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE);
1020  }
1021  EXPORT_SYMBOL_GPL(nfs_close_context);
1022  
1023  struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry,
1024  						fmode_t f_mode,
1025  						struct file *filp)
1026  {
1027  	struct nfs_open_context *ctx;
1028  
1029  	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL_ACCOUNT);
1030  	if (!ctx)
1031  		return ERR_PTR(-ENOMEM);
1032  	nfs_sb_active(dentry->d_sb);
1033  	ctx->dentry = dget(dentry);
1034  	if (filp)
1035  		ctx->cred = get_cred(filp->f_cred);
1036  	else
1037  		ctx->cred = get_current_cred();
1038  	rcu_assign_pointer(ctx->ll_cred, NULL);
1039  	ctx->state = NULL;
1040  	ctx->mode = f_mode;
1041  	ctx->flags = 0;
1042  	ctx->error = 0;
1043  	ctx->flock_owner = (fl_owner_t)filp;
1044  	nfs_init_lock_context(&ctx->lock_context);
1045  	ctx->lock_context.open_context = ctx;
1046  	INIT_LIST_HEAD(&ctx->list);
1047  	ctx->mdsthreshold = NULL;
1048  	return ctx;
1049  }
1050  EXPORT_SYMBOL_GPL(alloc_nfs_open_context);
1051  
1052  struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
1053  {
1054  	if (ctx != NULL && refcount_inc_not_zero(&ctx->lock_context.count))
1055  		return ctx;
1056  	return NULL;
1057  }
1058  EXPORT_SYMBOL_GPL(get_nfs_open_context);
1059  
1060  static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
1061  {
1062  	struct inode *inode = d_inode(ctx->dentry);
1063  	struct super_block *sb = ctx->dentry->d_sb;
1064  
1065  	if (!refcount_dec_and_test(&ctx->lock_context.count))
1066  		return;
1067  	if (!list_empty(&ctx->list)) {
1068  		spin_lock(&inode->i_lock);
1069  		list_del_rcu(&ctx->list);
1070  		spin_unlock(&inode->i_lock);
1071  	}
1072  	if (inode != NULL)
1073  		NFS_PROTO(inode)->close_context(ctx, is_sync);
1074  	put_cred(ctx->cred);
1075  	dput(ctx->dentry);
1076  	nfs_sb_deactive(sb);
1077  	put_rpccred(rcu_dereference_protected(ctx->ll_cred, 1));
1078  	kfree(ctx->mdsthreshold);
1079  	kfree_rcu(ctx, rcu_head);
1080  }
1081  
1082  void put_nfs_open_context(struct nfs_open_context *ctx)
1083  {
1084  	__put_nfs_open_context(ctx, 0);
1085  }
1086  EXPORT_SYMBOL_GPL(put_nfs_open_context);
1087  
1088  static void put_nfs_open_context_sync(struct nfs_open_context *ctx)
1089  {
1090  	__put_nfs_open_context(ctx, 1);
1091  }
1092  
1093  /*
1094   * Ensure that mmap has a recent RPC credential for use when writing out
1095   * shared pages
1096   */
1097  void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
1098  {
1099  	struct inode *inode = d_inode(ctx->dentry);
1100  	struct nfs_inode *nfsi = NFS_I(inode);
1101  
1102  	spin_lock(&inode->i_lock);
1103  	if (list_empty(&nfsi->open_files) &&
1104  	    (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
1105  		nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA |
1106  						     NFS_INO_REVAL_FORCED);
1107  	list_add_tail_rcu(&ctx->list, &nfsi->open_files);
1108  	spin_unlock(&inode->i_lock);
1109  }
1110  EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context);
1111  
1112  void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
1113  {
1114  	filp->private_data = get_nfs_open_context(ctx);
1115  	set_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags);
1116  	if (list_empty(&ctx->list))
1117  		nfs_inode_attach_open_context(ctx);
1118  }
1119  EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
1120  
1121  /*
1122   * Given an inode, search for an open context with the desired characteristics
1123   */
1124  struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode)
1125  {
1126  	struct nfs_inode *nfsi = NFS_I(inode);
1127  	struct nfs_open_context *pos, *ctx = NULL;
1128  
1129  	rcu_read_lock();
1130  	list_for_each_entry_rcu(pos, &nfsi->open_files, list) {
1131  		if (cred != NULL && cred_fscmp(pos->cred, cred) != 0)
1132  			continue;
1133  		if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
1134  			continue;
1135  		if (!test_bit(NFS_CONTEXT_FILE_OPEN, &pos->flags))
1136  			continue;
1137  		ctx = get_nfs_open_context(pos);
1138  		if (ctx)
1139  			break;
1140  	}
1141  	rcu_read_unlock();
1142  	return ctx;
1143  }
1144  
1145  void nfs_file_clear_open_context(struct file *filp)
1146  {
1147  	struct nfs_open_context *ctx = nfs_file_open_context(filp);
1148  
1149  	if (ctx) {
1150  		struct inode *inode = d_inode(ctx->dentry);
1151  
1152  		clear_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags);
1153  		/*
1154  		 * We fatal error on write before. Try to writeback
1155  		 * every page again.
1156  		 */
1157  		if (ctx->error < 0)
1158  			invalidate_inode_pages2(inode->i_mapping);
1159  		filp->private_data = NULL;
1160  		put_nfs_open_context_sync(ctx);
1161  	}
1162  }
1163  
1164  /*
1165   * These allocate and release file read/write context information.
1166   */
1167  int nfs_open(struct inode *inode, struct file *filp)
1168  {
1169  	struct nfs_open_context *ctx;
1170  
1171  	ctx = alloc_nfs_open_context(file_dentry(filp),
1172  				     flags_to_mode(filp->f_flags), filp);
1173  	if (IS_ERR(ctx))
1174  		return PTR_ERR(ctx);
1175  	nfs_file_set_open_context(filp, ctx);
1176  	put_nfs_open_context(ctx);
1177  	nfs_fscache_open_file(inode, filp);
1178  	return 0;
1179  }
1180  
1181  /*
1182   * This function is called whenever some part of NFS notices that
1183   * the cached attributes have to be refreshed.
1184   */
1185  int
1186  __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1187  {
1188  	int		 status = -ESTALE;
1189  	struct nfs_fattr *fattr = NULL;
1190  	struct nfs_inode *nfsi = NFS_I(inode);
1191  
1192  	dfprintk(PAGECACHE, "NFS: revalidating (%s/%Lu)\n",
1193  		inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode));
1194  
1195  	trace_nfs_revalidate_inode_enter(inode);
1196  
1197  	if (is_bad_inode(inode))
1198  		goto out;
1199  	if (NFS_STALE(inode))
1200  		goto out;
1201  
1202  	/* pNFS: Attributes aren't updated until we layoutcommit */
1203  	if (S_ISREG(inode->i_mode)) {
1204  		status = pnfs_sync_inode(inode, false);
1205  		if (status)
1206  			goto out;
1207  	}
1208  
1209  	status = -ENOMEM;
1210  	fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
1211  	if (fattr == NULL)
1212  		goto out;
1213  
1214  	nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
1215  
1216  	status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, inode);
1217  	if (status != 0) {
1218  		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n",
1219  			 inode->i_sb->s_id,
1220  			 (unsigned long long)NFS_FILEID(inode), status);
1221  		switch (status) {
1222  		case -ETIMEDOUT:
1223  			/* A soft timeout occurred. Use cached information? */
1224  			if (server->flags & NFS_MOUNT_SOFTREVAL)
1225  				status = 0;
1226  			break;
1227  		case -ESTALE:
1228  			if (!S_ISDIR(inode->i_mode))
1229  				nfs_set_inode_stale(inode);
1230  			else
1231  				nfs_zap_caches(inode);
1232  		}
1233  		goto out;
1234  	}
1235  
1236  	status = nfs_refresh_inode(inode, fattr);
1237  	if (status) {
1238  		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n",
1239  			 inode->i_sb->s_id,
1240  			 (unsigned long long)NFS_FILEID(inode), status);
1241  		goto out;
1242  	}
1243  
1244  	if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
1245  		nfs_zap_acl_cache(inode);
1246  
1247  	nfs_setsecurity(inode, fattr);
1248  
1249  	dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n",
1250  		inode->i_sb->s_id,
1251  		(unsigned long long)NFS_FILEID(inode));
1252  
1253  out:
1254  	nfs_free_fattr(fattr);
1255  	trace_nfs_revalidate_inode_exit(inode, status);
1256  	return status;
1257  }
1258  
1259  int nfs_attribute_cache_expired(struct inode *inode)
1260  {
1261  	if (nfs_have_delegated_attributes(inode))
1262  		return 0;
1263  	return nfs_attribute_timeout(inode);
1264  }
1265  
1266  /**
1267   * nfs_revalidate_inode - Revalidate the inode attributes
1268   * @inode: pointer to inode struct
1269   * @flags: cache flags to check
1270   *
1271   * Updates inode attribute information by retrieving the data from the server.
1272   */
1273  int nfs_revalidate_inode(struct inode *inode, unsigned long flags)
1274  {
1275  	if (!nfs_check_cache_invalid(inode, flags))
1276  		return NFS_STALE(inode) ? -ESTALE : 0;
1277  	return __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1278  }
1279  EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
1280  
1281  static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
1282  {
1283  	int ret;
1284  
1285  	nfs_fscache_invalidate(inode, 0);
1286  	if (mapping->nrpages != 0) {
1287  		if (S_ISREG(inode->i_mode)) {
1288  			ret = nfs_sync_mapping(mapping);
1289  			if (ret < 0)
1290  				return ret;
1291  		}
1292  		ret = invalidate_inode_pages2(mapping);
1293  		if (ret < 0)
1294  			return ret;
1295  	}
1296  	nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
1297  
1298  	dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n",
1299  			inode->i_sb->s_id,
1300  			(unsigned long long)NFS_FILEID(inode));
1301  	return 0;
1302  }
1303  
1304  /**
1305   * nfs_clear_invalid_mapping - Conditionally clear a mapping
1306   * @mapping: pointer to mapping
1307   *
1308   * If the NFS_INO_INVALID_DATA inode flag is set, clear the mapping.
1309   */
1310  int nfs_clear_invalid_mapping(struct address_space *mapping)
1311  {
1312  	struct inode *inode = mapping->host;
1313  	struct nfs_inode *nfsi = NFS_I(inode);
1314  	unsigned long *bitlock = &nfsi->flags;
1315  	int ret = 0;
1316  
1317  	/*
1318  	 * We must clear NFS_INO_INVALID_DATA first to ensure that
1319  	 * invalidations that come in while we're shooting down the mappings
1320  	 * are respected. But, that leaves a race window where one revalidator
1321  	 * can clear the flag, and then another checks it before the mapping
1322  	 * gets invalidated. Fix that by serializing access to this part of
1323  	 * the function.
1324  	 *
1325  	 * At the same time, we need to allow other tasks to see whether we
1326  	 * might be in the middle of invalidating the pages, so we only set
1327  	 * the bit lock here if it looks like we're going to be doing that.
1328  	 */
1329  	for (;;) {
1330  		ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING,
1331  					 nfs_wait_bit_killable,
1332  					 TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
1333  		if (ret)
1334  			goto out;
1335  		spin_lock(&inode->i_lock);
1336  		if (test_bit(NFS_INO_INVALIDATING, bitlock)) {
1337  			spin_unlock(&inode->i_lock);
1338  			continue;
1339  		}
1340  		if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
1341  			break;
1342  		spin_unlock(&inode->i_lock);
1343  		goto out;
1344  	}
1345  
1346  	set_bit(NFS_INO_INVALIDATING, bitlock);
1347  	smp_wmb();
1348  	nfsi->cache_validity &=
1349  		~(NFS_INO_INVALID_DATA | NFS_INO_DATA_INVAL_DEFER);
1350  	spin_unlock(&inode->i_lock);
1351  	trace_nfs_invalidate_mapping_enter(inode);
1352  	ret = nfs_invalidate_mapping(inode, mapping);
1353  	trace_nfs_invalidate_mapping_exit(inode, ret);
1354  
1355  	clear_bit_unlock(NFS_INO_INVALIDATING, bitlock);
1356  	smp_mb__after_atomic();
1357  	wake_up_bit(bitlock, NFS_INO_INVALIDATING);
1358  out:
1359  	return ret;
1360  }
1361  
1362  bool nfs_mapping_need_revalidate_inode(struct inode *inode)
1363  {
1364  	return nfs_check_cache_invalid(inode, NFS_INO_INVALID_CHANGE) ||
1365  		NFS_STALE(inode);
1366  }
1367  
1368  int nfs_revalidate_mapping_rcu(struct inode *inode)
1369  {
1370  	struct nfs_inode *nfsi = NFS_I(inode);
1371  	unsigned long *bitlock = &nfsi->flags;
1372  	int ret = 0;
1373  
1374  	if (IS_SWAPFILE(inode))
1375  		goto out;
1376  	if (nfs_mapping_need_revalidate_inode(inode)) {
1377  		ret = -ECHILD;
1378  		goto out;
1379  	}
1380  	spin_lock(&inode->i_lock);
1381  	if (test_bit(NFS_INO_INVALIDATING, bitlock) ||
1382  	    (nfsi->cache_validity & NFS_INO_INVALID_DATA))
1383  		ret = -ECHILD;
1384  	spin_unlock(&inode->i_lock);
1385  out:
1386  	return ret;
1387  }
1388  
1389  /**
1390   * nfs_revalidate_mapping - Revalidate the pagecache
1391   * @inode: pointer to host inode
1392   * @mapping: pointer to mapping
1393   */
1394  int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
1395  {
1396  	/* swapfiles are not supposed to be shared. */
1397  	if (IS_SWAPFILE(inode))
1398  		return 0;
1399  
1400  	if (nfs_mapping_need_revalidate_inode(inode)) {
1401  		int ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1402  		if (ret < 0)
1403  			return ret;
1404  	}
1405  
1406  	return nfs_clear_invalid_mapping(mapping);
1407  }
1408  
1409  static bool nfs_file_has_writers(struct nfs_inode *nfsi)
1410  {
1411  	struct inode *inode = &nfsi->vfs_inode;
1412  
1413  	if (!S_ISREG(inode->i_mode))
1414  		return false;
1415  	if (list_empty(&nfsi->open_files))
1416  		return false;
1417  	return inode_is_open_for_write(inode);
1418  }
1419  
1420  static bool nfs_file_has_buffered_writers(struct nfs_inode *nfsi)
1421  {
1422  	return nfs_file_has_writers(nfsi) && nfs_file_io_is_buffered(nfsi);
1423  }
1424  
1425  static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1426  {
1427  	struct timespec64 ts;
1428  
1429  	if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
1430  			&& (fattr->valid & NFS_ATTR_FATTR_CHANGE)
1431  			&& inode_eq_iversion_raw(inode, fattr->pre_change_attr)) {
1432  		inode_set_iversion_raw(inode, fattr->change_attr);
1433  		if (S_ISDIR(inode->i_mode))
1434  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
1435  		else if (nfs_server_capable(inode, NFS_CAP_XATTR))
1436  			nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR);
1437  	}
1438  	/* If we have atomic WCC data, we may update some attributes */
1439  	ts = inode->i_ctime;
1440  	if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
1441  			&& (fattr->valid & NFS_ATTR_FATTR_CTIME)
1442  			&& timespec64_equal(&ts, &fattr->pre_ctime)) {
1443  		inode->i_ctime = fattr->ctime;
1444  	}
1445  
1446  	ts = inode->i_mtime;
1447  	if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
1448  			&& (fattr->valid & NFS_ATTR_FATTR_MTIME)
1449  			&& timespec64_equal(&ts, &fattr->pre_mtime)) {
1450  		inode->i_mtime = fattr->mtime;
1451  	}
1452  	if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
1453  			&& (fattr->valid & NFS_ATTR_FATTR_SIZE)
1454  			&& i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
1455  			&& !nfs_have_writebacks(inode)) {
1456  		trace_nfs_size_wcc(inode, fattr->size);
1457  		i_size_write(inode, nfs_size_to_loff_t(fattr->size));
1458  	}
1459  }
1460  
1461  /**
1462   * nfs_check_inode_attributes - verify consistency of the inode attribute cache
1463   * @inode: pointer to inode
1464   * @fattr: updated attributes
1465   *
1466   * Verifies the attribute cache. If we have just changed the attributes,
1467   * so that fattr carries weak cache consistency data, then it may
1468   * also update the ctime/mtime/change_attribute.
1469   */
1470  static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
1471  {
1472  	struct nfs_inode *nfsi = NFS_I(inode);
1473  	loff_t cur_size, new_isize;
1474  	unsigned long invalid = 0;
1475  	struct timespec64 ts;
1476  
1477  	if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1478  		return 0;
1479  
1480  	if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) {
1481  		/* Only a mounted-on-fileid? Just exit */
1482  		if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
1483  			return 0;
1484  	/* Has the inode gone and changed behind our back? */
1485  	} else if (nfsi->fileid != fattr->fileid) {
1486  		/* Is this perhaps the mounted-on fileid? */
1487  		if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) &&
1488  		    nfsi->fileid == fattr->mounted_on_fileid)
1489  			return 0;
1490  		return -ESTALE;
1491  	}
1492  	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode))
1493  		return -ESTALE;
1494  
1495  
1496  	if (!nfs_file_has_buffered_writers(nfsi)) {
1497  		/* Verify a few of the more important attributes */
1498  		if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && !inode_eq_iversion_raw(inode, fattr->change_attr))
1499  			invalid |= NFS_INO_INVALID_CHANGE;
1500  
1501  		ts = inode->i_mtime;
1502  		if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec64_equal(&ts, &fattr->mtime))
1503  			invalid |= NFS_INO_INVALID_MTIME;
1504  
1505  		ts = inode->i_ctime;
1506  		if ((fattr->valid & NFS_ATTR_FATTR_CTIME) && !timespec64_equal(&ts, &fattr->ctime))
1507  			invalid |= NFS_INO_INVALID_CTIME;
1508  
1509  		if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1510  			cur_size = i_size_read(inode);
1511  			new_isize = nfs_size_to_loff_t(fattr->size);
1512  			if (cur_size != new_isize)
1513  				invalid |= NFS_INO_INVALID_SIZE;
1514  		}
1515  	}
1516  
1517  	/* Have any file permissions changed? */
1518  	if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
1519  		invalid |= NFS_INO_INVALID_MODE;
1520  	if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))
1521  		invalid |= NFS_INO_INVALID_OTHER;
1522  	if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))
1523  		invalid |= NFS_INO_INVALID_OTHER;
1524  
1525  	/* Has the link count changed? */
1526  	if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
1527  		invalid |= NFS_INO_INVALID_NLINK;
1528  
1529  	ts = inode->i_atime;
1530  	if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec64_equal(&ts, &fattr->atime))
1531  		invalid |= NFS_INO_INVALID_ATIME;
1532  
1533  	if (invalid != 0)
1534  		nfs_set_cache_invalid(inode, invalid);
1535  
1536  	nfsi->read_cache_jiffies = fattr->time_start;
1537  	return 0;
1538  }
1539  
1540  static atomic_long_t nfs_attr_generation_counter;
1541  
1542  static unsigned long nfs_read_attr_generation_counter(void)
1543  {
1544  	return atomic_long_read(&nfs_attr_generation_counter);
1545  }
1546  
1547  unsigned long nfs_inc_attr_generation_counter(void)
1548  {
1549  	return atomic_long_inc_return(&nfs_attr_generation_counter);
1550  }
1551  EXPORT_SYMBOL_GPL(nfs_inc_attr_generation_counter);
1552  
1553  void nfs_fattr_init(struct nfs_fattr *fattr)
1554  {
1555  	fattr->valid = 0;
1556  	fattr->time_start = jiffies;
1557  	fattr->gencount = nfs_inc_attr_generation_counter();
1558  	fattr->owner_name = NULL;
1559  	fattr->group_name = NULL;
1560  }
1561  EXPORT_SYMBOL_GPL(nfs_fattr_init);
1562  
1563  /**
1564   * nfs_fattr_set_barrier
1565   * @fattr: attributes
1566   *
1567   * Used to set a barrier after an attribute was updated. This
1568   * barrier ensures that older attributes from RPC calls that may
1569   * have raced with our update cannot clobber these new values.
1570   * Note that you are still responsible for ensuring that other
1571   * operations which change the attribute on the server do not
1572   * collide.
1573   */
1574  void nfs_fattr_set_barrier(struct nfs_fattr *fattr)
1575  {
1576  	fattr->gencount = nfs_inc_attr_generation_counter();
1577  }
1578  
1579  struct nfs_fattr *nfs_alloc_fattr(void)
1580  {
1581  	struct nfs_fattr *fattr;
1582  
1583  	fattr = kmalloc(sizeof(*fattr), GFP_KERNEL);
1584  	if (fattr != NULL) {
1585  		nfs_fattr_init(fattr);
1586  		fattr->label = NULL;
1587  	}
1588  	return fattr;
1589  }
1590  EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
1591  
1592  struct nfs_fattr *nfs_alloc_fattr_with_label(struct nfs_server *server)
1593  {
1594  	struct nfs_fattr *fattr = nfs_alloc_fattr();
1595  
1596  	if (!fattr)
1597  		return NULL;
1598  
1599  	fattr->label = nfs4_label_alloc(server, GFP_KERNEL);
1600  	if (IS_ERR(fattr->label)) {
1601  		kfree(fattr);
1602  		return NULL;
1603  	}
1604  
1605  	return fattr;
1606  }
1607  EXPORT_SYMBOL_GPL(nfs_alloc_fattr_with_label);
1608  
1609  struct nfs_fh *nfs_alloc_fhandle(void)
1610  {
1611  	struct nfs_fh *fh;
1612  
1613  	fh = kmalloc(sizeof(struct nfs_fh), GFP_KERNEL);
1614  	if (fh != NULL)
1615  		fh->size = 0;
1616  	return fh;
1617  }
1618  EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
1619  
1620  #ifdef NFS_DEBUG
1621  /*
1622   * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle
1623   *                             in the same way that wireshark does
1624   *
1625   * @fh: file handle
1626   *
1627   * For debugging only.
1628   */
1629  u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
1630  {
1631  	/* wireshark uses 32-bit AUTODIN crc and does a bitwise
1632  	 * not on the result */
1633  	return nfs_fhandle_hash(fh);
1634  }
1635  EXPORT_SYMBOL_GPL(_nfs_display_fhandle_hash);
1636  
1637  /*
1638   * _nfs_display_fhandle - display an NFS file handle on the console
1639   *
1640   * @fh: file handle to display
1641   * @caption: display caption
1642   *
1643   * For debugging only.
1644   */
1645  void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
1646  {
1647  	unsigned short i;
1648  
1649  	if (fh == NULL || fh->size == 0) {
1650  		printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
1651  		return;
1652  	}
1653  
1654  	printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
1655  	       caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
1656  	for (i = 0; i < fh->size; i += 16) {
1657  		__be32 *pos = (__be32 *)&fh->data[i];
1658  
1659  		switch ((fh->size - i - 1) >> 2) {
1660  		case 0:
1661  			printk(KERN_DEFAULT " %08x\n",
1662  				be32_to_cpup(pos));
1663  			break;
1664  		case 1:
1665  			printk(KERN_DEFAULT " %08x %08x\n",
1666  				be32_to_cpup(pos), be32_to_cpup(pos + 1));
1667  			break;
1668  		case 2:
1669  			printk(KERN_DEFAULT " %08x %08x %08x\n",
1670  				be32_to_cpup(pos), be32_to_cpup(pos + 1),
1671  				be32_to_cpup(pos + 2));
1672  			break;
1673  		default:
1674  			printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
1675  				be32_to_cpup(pos), be32_to_cpup(pos + 1),
1676  				be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
1677  		}
1678  	}
1679  }
1680  EXPORT_SYMBOL_GPL(_nfs_display_fhandle);
1681  #endif
1682  
1683  /**
1684   * nfs_inode_attrs_cmp_generic - compare attributes
1685   * @fattr: attributes
1686   * @inode: pointer to inode
1687   *
1688   * Attempt to divine whether or not an RPC call reply carrying stale
1689   * attributes got scheduled after another call carrying updated ones.
1690   * Note also the check for wraparound of 'attr_gencount'
1691   *
1692   * The function returns '1' if it thinks the attributes in @fattr are
1693   * more recent than the ones cached in @inode. Otherwise it returns
1694   * the value '0'.
1695   */
1696  static int nfs_inode_attrs_cmp_generic(const struct nfs_fattr *fattr,
1697  				       const struct inode *inode)
1698  {
1699  	unsigned long attr_gencount = NFS_I(inode)->attr_gencount;
1700  
1701  	return (long)(fattr->gencount - attr_gencount) > 0 ||
1702  	       (long)(attr_gencount - nfs_read_attr_generation_counter()) > 0;
1703  }
1704  
1705  /**
1706   * nfs_inode_attrs_cmp_monotonic - compare attributes
1707   * @fattr: attributes
1708   * @inode: pointer to inode
1709   *
1710   * Attempt to divine whether or not an RPC call reply carrying stale
1711   * attributes got scheduled after another call carrying updated ones.
1712   *
1713   * We assume that the server observes monotonic semantics for
1714   * the change attribute, so a larger value means that the attributes in
1715   * @fattr are more recent, in which case the function returns the
1716   * value '1'.
1717   * A return value of '0' indicates no measurable change
1718   * A return value of '-1' means that the attributes in @inode are
1719   * more recent.
1720   */
1721  static int nfs_inode_attrs_cmp_monotonic(const struct nfs_fattr *fattr,
1722  					 const struct inode *inode)
1723  {
1724  	s64 diff = fattr->change_attr - inode_peek_iversion_raw(inode);
1725  	if (diff > 0)
1726  		return 1;
1727  	return diff == 0 ? 0 : -1;
1728  }
1729  
1730  /**
1731   * nfs_inode_attrs_cmp_strict_monotonic - compare attributes
1732   * @fattr: attributes
1733   * @inode: pointer to inode
1734   *
1735   * Attempt to divine whether or not an RPC call reply carrying stale
1736   * attributes got scheduled after another call carrying updated ones.
1737   *
1738   * We assume that the server observes strictly monotonic semantics for
1739   * the change attribute, so a larger value means that the attributes in
1740   * @fattr are more recent, in which case the function returns the
1741   * value '1'.
1742   * A return value of '-1' means that the attributes in @inode are
1743   * more recent or unchanged.
1744   */
1745  static int nfs_inode_attrs_cmp_strict_monotonic(const struct nfs_fattr *fattr,
1746  						const struct inode *inode)
1747  {
1748  	return  nfs_inode_attrs_cmp_monotonic(fattr, inode) > 0 ? 1 : -1;
1749  }
1750  
1751  /**
1752   * nfs_inode_attrs_cmp - compare attributes
1753   * @fattr: attributes
1754   * @inode: pointer to inode
1755   *
1756   * This function returns '1' if it thinks the attributes in @fattr are
1757   * more recent than the ones cached in @inode. It returns '-1' if
1758   * the attributes in @inode are more recent than the ones in @fattr,
1759   * and it returns 0 if not sure.
1760   */
1761  static int nfs_inode_attrs_cmp(const struct nfs_fattr *fattr,
1762  			       const struct inode *inode)
1763  {
1764  	if (nfs_inode_attrs_cmp_generic(fattr, inode) > 0)
1765  		return 1;
1766  	switch (NFS_SERVER(inode)->change_attr_type) {
1767  	case NFS4_CHANGE_TYPE_IS_UNDEFINED:
1768  		break;
1769  	case NFS4_CHANGE_TYPE_IS_TIME_METADATA:
1770  		if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE))
1771  			break;
1772  		return nfs_inode_attrs_cmp_monotonic(fattr, inode);
1773  	default:
1774  		if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE))
1775  			break;
1776  		return nfs_inode_attrs_cmp_strict_monotonic(fattr, inode);
1777  	}
1778  	return 0;
1779  }
1780  
1781  /**
1782   * nfs_inode_finish_partial_attr_update - complete a previous inode update
1783   * @fattr: attributes
1784   * @inode: pointer to inode
1785   *
1786   * Returns '1' if the last attribute update left the inode cached
1787   * attributes in a partially unrevalidated state, and @fattr
1788   * matches the change attribute of that partial update.
1789   * Otherwise returns '0'.
1790   */
1791  static int nfs_inode_finish_partial_attr_update(const struct nfs_fattr *fattr,
1792  						const struct inode *inode)
1793  {
1794  	const unsigned long check_valid =
1795  		NFS_INO_INVALID_ATIME | NFS_INO_INVALID_CTIME |
1796  		NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE |
1797  		NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_OTHER |
1798  		NFS_INO_INVALID_NLINK;
1799  	unsigned long cache_validity = NFS_I(inode)->cache_validity;
1800  	enum nfs4_change_attr_type ctype = NFS_SERVER(inode)->change_attr_type;
1801  
1802  	if (ctype != NFS4_CHANGE_TYPE_IS_UNDEFINED &&
1803  	    !(cache_validity & NFS_INO_INVALID_CHANGE) &&
1804  	    (cache_validity & check_valid) != 0 &&
1805  	    (fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1806  	    nfs_inode_attrs_cmp_monotonic(fattr, inode) == 0)
1807  		return 1;
1808  	return 0;
1809  }
1810  
1811  static int nfs_refresh_inode_locked(struct inode *inode,
1812  				    struct nfs_fattr *fattr)
1813  {
1814  	int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
1815  	int ret = 0;
1816  
1817  	trace_nfs_refresh_inode_enter(inode);
1818  
1819  	if (attr_cmp > 0 || nfs_inode_finish_partial_attr_update(fattr, inode))
1820  		ret = nfs_update_inode(inode, fattr);
1821  	else if (attr_cmp == 0)
1822  		ret = nfs_check_inode_attributes(inode, fattr);
1823  
1824  	trace_nfs_refresh_inode_exit(inode, ret);
1825  	return ret;
1826  }
1827  
1828  /**
1829   * nfs_refresh_inode - try to update the inode attribute cache
1830   * @inode: pointer to inode
1831   * @fattr: updated attributes
1832   *
1833   * Check that an RPC call that returned attributes has not overlapped with
1834   * other recent updates of the inode metadata, then decide whether it is
1835   * safe to do a full update of the inode attributes, or whether just to
1836   * call nfs_check_inode_attributes.
1837   */
1838  int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1839  {
1840  	int status;
1841  
1842  	if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1843  		return 0;
1844  	spin_lock(&inode->i_lock);
1845  	status = nfs_refresh_inode_locked(inode, fattr);
1846  	spin_unlock(&inode->i_lock);
1847  
1848  	return status;
1849  }
1850  EXPORT_SYMBOL_GPL(nfs_refresh_inode);
1851  
1852  static int nfs_post_op_update_inode_locked(struct inode *inode,
1853  		struct nfs_fattr *fattr, unsigned int invalid)
1854  {
1855  	if (S_ISDIR(inode->i_mode))
1856  		invalid |= NFS_INO_INVALID_DATA;
1857  	nfs_set_cache_invalid(inode, invalid);
1858  	if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1859  		return 0;
1860  	return nfs_refresh_inode_locked(inode, fattr);
1861  }
1862  
1863  /**
1864   * nfs_post_op_update_inode - try to update the inode attribute cache
1865   * @inode: pointer to inode
1866   * @fattr: updated attributes
1867   *
1868   * After an operation that has changed the inode metadata, mark the
1869   * attribute cache as being invalid, then try to update it.
1870   *
1871   * NB: if the server didn't return any post op attributes, this
1872   * function will force the retrieval of attributes before the next
1873   * NFS request.  Thus it should be used only for operations that
1874   * are expected to change one or more attributes, to avoid
1875   * unnecessary NFS requests and trips through nfs_update_inode().
1876   */
1877  int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1878  {
1879  	int status;
1880  
1881  	spin_lock(&inode->i_lock);
1882  	nfs_fattr_set_barrier(fattr);
1883  	status = nfs_post_op_update_inode_locked(inode, fattr,
1884  			NFS_INO_INVALID_CHANGE
1885  			| NFS_INO_INVALID_CTIME
1886  			| NFS_INO_REVAL_FORCED);
1887  	spin_unlock(&inode->i_lock);
1888  
1889  	return status;
1890  }
1891  EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
1892  
1893  /**
1894   * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache
1895   * @inode: pointer to inode
1896   * @fattr: updated attributes
1897   *
1898   * After an operation that has changed the inode metadata, mark the
1899   * attribute cache as being invalid, then try to update it. Fake up
1900   * weak cache consistency data, if none exist.
1901   *
1902   * This function is mainly designed to be used by the ->write_done() functions.
1903   */
1904  int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr)
1905  {
1906  	int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
1907  	int status;
1908  
1909  	/* Don't do a WCC update if these attributes are already stale */
1910  	if (attr_cmp < 0)
1911  		return 0;
1912  	if ((fattr->valid & NFS_ATTR_FATTR) == 0 || !attr_cmp) {
1913  		fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
1914  				| NFS_ATTR_FATTR_PRESIZE
1915  				| NFS_ATTR_FATTR_PREMTIME
1916  				| NFS_ATTR_FATTR_PRECTIME);
1917  		goto out_noforce;
1918  	}
1919  	if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1920  			(fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
1921  		fattr->pre_change_attr = inode_peek_iversion_raw(inode);
1922  		fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
1923  	}
1924  	if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
1925  			(fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
1926  		fattr->pre_ctime = inode->i_ctime;
1927  		fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
1928  	}
1929  	if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
1930  			(fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
1931  		fattr->pre_mtime = inode->i_mtime;
1932  		fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
1933  	}
1934  	if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
1935  			(fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
1936  		fattr->pre_size = i_size_read(inode);
1937  		fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
1938  	}
1939  out_noforce:
1940  	status = nfs_post_op_update_inode_locked(inode, fattr,
1941  			NFS_INO_INVALID_CHANGE
1942  			| NFS_INO_INVALID_CTIME
1943  			| NFS_INO_INVALID_MTIME
1944  			| NFS_INO_INVALID_BLOCKS);
1945  	return status;
1946  }
1947  
1948  /**
1949   * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
1950   * @inode: pointer to inode
1951   * @fattr: updated attributes
1952   *
1953   * After an operation that has changed the inode metadata, mark the
1954   * attribute cache as being invalid, then try to update it. Fake up
1955   * weak cache consistency data, if none exist.
1956   *
1957   * This function is mainly designed to be used by the ->write_done() functions.
1958   */
1959  int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
1960  {
1961  	int status;
1962  
1963  	spin_lock(&inode->i_lock);
1964  	nfs_fattr_set_barrier(fattr);
1965  	status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
1966  	spin_unlock(&inode->i_lock);
1967  	return status;
1968  }
1969  EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
1970  
1971  
1972  /*
1973   * Many nfs protocol calls return the new file attributes after
1974   * an operation.  Here we update the inode to reflect the state
1975   * of the server's inode.
1976   *
1977   * This is a bit tricky because we have to make sure all dirty pages
1978   * have been sent off to the server before calling invalidate_inode_pages.
1979   * To make sure no other process adds more write requests while we try
1980   * our best to flush them, we make them sleep during the attribute refresh.
1981   *
1982   * A very similar scenario holds for the dir cache.
1983   */
1984  static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1985  {
1986  	struct nfs_server *server = NFS_SERVER(inode);
1987  	struct nfs_inode *nfsi = NFS_I(inode);
1988  	loff_t cur_isize, new_isize;
1989  	u64 fattr_supported = server->fattr_valid;
1990  	unsigned long invalid = 0;
1991  	unsigned long now = jiffies;
1992  	unsigned long save_cache_validity;
1993  	bool have_writers = nfs_file_has_buffered_writers(nfsi);
1994  	bool cache_revalidated = true;
1995  	bool attr_changed = false;
1996  	bool have_delegation;
1997  
1998  	dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%x)\n",
1999  			__func__, inode->i_sb->s_id, inode->i_ino,
2000  			nfs_display_fhandle_hash(NFS_FH(inode)),
2001  			atomic_read(&inode->i_count), fattr->valid);
2002  
2003  	if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) {
2004  		/* Only a mounted-on-fileid? Just exit */
2005  		if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
2006  			return 0;
2007  	/* Has the inode gone and changed behind our back? */
2008  	} else if (nfsi->fileid != fattr->fileid) {
2009  		/* Is this perhaps the mounted-on fileid? */
2010  		if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) &&
2011  		    nfsi->fileid == fattr->mounted_on_fileid)
2012  			return 0;
2013  		printk(KERN_ERR "NFS: server %s error: fileid changed\n"
2014  			"fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
2015  			NFS_SERVER(inode)->nfs_client->cl_hostname,
2016  			inode->i_sb->s_id, (long long)nfsi->fileid,
2017  			(long long)fattr->fileid);
2018  		goto out_err;
2019  	}
2020  
2021  	/*
2022  	 * Make sure the inode's type hasn't changed.
2023  	 */
2024  	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) {
2025  		/*
2026  		* Big trouble! The inode has become a different object.
2027  		*/
2028  		printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
2029  				__func__, inode->i_ino, inode->i_mode, fattr->mode);
2030  		goto out_err;
2031  	}
2032  
2033  	/* Update the fsid? */
2034  	if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
2035  			!nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
2036  			!IS_AUTOMOUNT(inode))
2037  		server->fsid = fattr->fsid;
2038  
2039  	/* Save the delegation state before clearing cache_validity */
2040  	have_delegation = nfs_have_delegated_attributes(inode);
2041  
2042  	/*
2043  	 * Update the read time so we don't revalidate too often.
2044  	 */
2045  	nfsi->read_cache_jiffies = fattr->time_start;
2046  
2047  	save_cache_validity = nfsi->cache_validity;
2048  	nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
2049  			| NFS_INO_INVALID_ATIME
2050  			| NFS_INO_REVAL_FORCED
2051  			| NFS_INO_INVALID_BLOCKS);
2052  
2053  	/* Do atomic weak cache consistency updates */
2054  	nfs_wcc_update_inode(inode, fattr);
2055  
2056  	if (pnfs_layoutcommit_outstanding(inode)) {
2057  		nfsi->cache_validity |=
2058  			save_cache_validity &
2059  			(NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME |
2060  			 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE |
2061  			 NFS_INO_INVALID_BLOCKS);
2062  		cache_revalidated = false;
2063  	}
2064  
2065  	/* More cache consistency checks */
2066  	if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
2067  		if (!inode_eq_iversion_raw(inode, fattr->change_attr)) {
2068  			/* Could it be a race with writeback? */
2069  			if (!(have_writers || have_delegation)) {
2070  				invalid |= NFS_INO_INVALID_DATA
2071  					| NFS_INO_INVALID_ACCESS
2072  					| NFS_INO_INVALID_ACL
2073  					| NFS_INO_INVALID_XATTR;
2074  				/* Force revalidate of all attributes */
2075  				save_cache_validity |= NFS_INO_INVALID_CTIME
2076  					| NFS_INO_INVALID_MTIME
2077  					| NFS_INO_INVALID_SIZE
2078  					| NFS_INO_INVALID_BLOCKS
2079  					| NFS_INO_INVALID_NLINK
2080  					| NFS_INO_INVALID_MODE
2081  					| NFS_INO_INVALID_OTHER;
2082  				if (S_ISDIR(inode->i_mode))
2083  					nfs_force_lookup_revalidate(inode);
2084  				attr_changed = true;
2085  				dprintk("NFS: change_attr change on server for file %s/%ld\n",
2086  						inode->i_sb->s_id,
2087  						inode->i_ino);
2088  			} else if (!have_delegation)
2089  				nfsi->cache_validity |= NFS_INO_DATA_INVAL_DEFER;
2090  			inode_set_iversion_raw(inode, fattr->change_attr);
2091  		}
2092  	} else {
2093  		nfsi->cache_validity |=
2094  			save_cache_validity & NFS_INO_INVALID_CHANGE;
2095  		if (!have_delegation ||
2096  		    (nfsi->cache_validity & NFS_INO_INVALID_CHANGE) != 0)
2097  			cache_revalidated = false;
2098  	}
2099  
2100  	if (fattr->valid & NFS_ATTR_FATTR_MTIME)
2101  		inode->i_mtime = fattr->mtime;
2102  	else if (fattr_supported & NFS_ATTR_FATTR_MTIME)
2103  		nfsi->cache_validity |=
2104  			save_cache_validity & NFS_INO_INVALID_MTIME;
2105  
2106  	if (fattr->valid & NFS_ATTR_FATTR_CTIME)
2107  		inode->i_ctime = fattr->ctime;
2108  	else if (fattr_supported & NFS_ATTR_FATTR_CTIME)
2109  		nfsi->cache_validity |=
2110  			save_cache_validity & NFS_INO_INVALID_CTIME;
2111  
2112  	/* Check if our cached file size is stale */
2113  	if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
2114  		new_isize = nfs_size_to_loff_t(fattr->size);
2115  		cur_isize = i_size_read(inode);
2116  		if (new_isize != cur_isize && !have_delegation) {
2117  			/* Do we perhaps have any outstanding writes, or has
2118  			 * the file grown beyond our last write? */
2119  			if (!nfs_have_writebacks(inode) || new_isize > cur_isize) {
2120  				trace_nfs_size_update(inode, new_isize);
2121  				i_size_write(inode, new_isize);
2122  				if (!have_writers)
2123  					invalid |= NFS_INO_INVALID_DATA;
2124  			}
2125  		}
2126  		if (new_isize == 0 &&
2127  		    !(fattr->valid & (NFS_ATTR_FATTR_SPACE_USED |
2128  				      NFS_ATTR_FATTR_BLOCKS_USED))) {
2129  			fattr->du.nfs3.used = 0;
2130  			fattr->valid |= NFS_ATTR_FATTR_SPACE_USED;
2131  		}
2132  	} else
2133  		nfsi->cache_validity |=
2134  			save_cache_validity & NFS_INO_INVALID_SIZE;
2135  
2136  	if (fattr->valid & NFS_ATTR_FATTR_ATIME)
2137  		inode->i_atime = fattr->atime;
2138  	else if (fattr_supported & NFS_ATTR_FATTR_ATIME)
2139  		nfsi->cache_validity |=
2140  			save_cache_validity & NFS_INO_INVALID_ATIME;
2141  
2142  	if (fattr->valid & NFS_ATTR_FATTR_MODE) {
2143  		if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
2144  			umode_t newmode = inode->i_mode & S_IFMT;
2145  			newmode |= fattr->mode & S_IALLUGO;
2146  			inode->i_mode = newmode;
2147  			invalid |= NFS_INO_INVALID_ACCESS
2148  				| NFS_INO_INVALID_ACL;
2149  		}
2150  	} else if (fattr_supported & NFS_ATTR_FATTR_MODE)
2151  		nfsi->cache_validity |=
2152  			save_cache_validity & NFS_INO_INVALID_MODE;
2153  
2154  	if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
2155  		if (!uid_eq(inode->i_uid, fattr->uid)) {
2156  			invalid |= NFS_INO_INVALID_ACCESS
2157  				| NFS_INO_INVALID_ACL;
2158  			inode->i_uid = fattr->uid;
2159  		}
2160  	} else if (fattr_supported & NFS_ATTR_FATTR_OWNER)
2161  		nfsi->cache_validity |=
2162  			save_cache_validity & NFS_INO_INVALID_OTHER;
2163  
2164  	if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
2165  		if (!gid_eq(inode->i_gid, fattr->gid)) {
2166  			invalid |= NFS_INO_INVALID_ACCESS
2167  				| NFS_INO_INVALID_ACL;
2168  			inode->i_gid = fattr->gid;
2169  		}
2170  	} else if (fattr_supported & NFS_ATTR_FATTR_GROUP)
2171  		nfsi->cache_validity |=
2172  			save_cache_validity & NFS_INO_INVALID_OTHER;
2173  
2174  	if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
2175  		if (inode->i_nlink != fattr->nlink)
2176  			set_nlink(inode, fattr->nlink);
2177  	} else if (fattr_supported & NFS_ATTR_FATTR_NLINK)
2178  		nfsi->cache_validity |=
2179  			save_cache_validity & NFS_INO_INVALID_NLINK;
2180  
2181  	if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
2182  		/*
2183  		 * report the blocks in 512byte units
2184  		 */
2185  		inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
2186  	} else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED)
2187  		nfsi->cache_validity |=
2188  			save_cache_validity & NFS_INO_INVALID_BLOCKS;
2189  
2190  	if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
2191  		inode->i_blocks = fattr->du.nfs2.blocks;
2192  	else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED)
2193  		nfsi->cache_validity |=
2194  			save_cache_validity & NFS_INO_INVALID_BLOCKS;
2195  
2196  	/* Update attrtimeo value if we're out of the unstable period */
2197  	if (attr_changed) {
2198  		nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
2199  		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
2200  		nfsi->attrtimeo_timestamp = now;
2201  		/* Set barrier to be more recent than all outstanding updates */
2202  		nfsi->attr_gencount = nfs_inc_attr_generation_counter();
2203  	} else {
2204  		if (cache_revalidated) {
2205  			if (!time_in_range_open(now, nfsi->attrtimeo_timestamp,
2206  				nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
2207  				nfsi->attrtimeo <<= 1;
2208  				if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode))
2209  					nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
2210  			}
2211  			nfsi->attrtimeo_timestamp = now;
2212  		}
2213  		/* Set the barrier to be more recent than this fattr */
2214  		if ((long)(fattr->gencount - nfsi->attr_gencount) > 0)
2215  			nfsi->attr_gencount = fattr->gencount;
2216  	}
2217  
2218  	/* Don't invalidate the data if we were to blame */
2219  	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
2220  				|| S_ISLNK(inode->i_mode)))
2221  		invalid &= ~NFS_INO_INVALID_DATA;
2222  	nfs_set_cache_invalid(inode, invalid);
2223  
2224  	return 0;
2225   out_err:
2226  	/*
2227  	 * No need to worry about unhashing the dentry, as the
2228  	 * lookup validation will know that the inode is bad.
2229  	 * (But we fall through to invalidate the caches.)
2230  	 */
2231  	nfs_set_inode_stale_locked(inode);
2232  	return -ESTALE;
2233  }
2234  
2235  struct inode *nfs_alloc_inode(struct super_block *sb)
2236  {
2237  	struct nfs_inode *nfsi;
2238  	nfsi = alloc_inode_sb(sb, nfs_inode_cachep, GFP_KERNEL);
2239  	if (!nfsi)
2240  		return NULL;
2241  	nfsi->flags = 0UL;
2242  	nfsi->cache_validity = 0UL;
2243  #if IS_ENABLED(CONFIG_NFS_V4)
2244  	nfsi->nfs4_acl = NULL;
2245  #endif /* CONFIG_NFS_V4 */
2246  #ifdef CONFIG_NFS_V4_2
2247  	nfsi->xattr_cache = NULL;
2248  #endif
2249  	return &nfsi->vfs_inode;
2250  }
2251  EXPORT_SYMBOL_GPL(nfs_alloc_inode);
2252  
2253  void nfs_free_inode(struct inode *inode)
2254  {
2255  	kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
2256  }
2257  EXPORT_SYMBOL_GPL(nfs_free_inode);
2258  
2259  static inline void nfs4_init_once(struct nfs_inode *nfsi)
2260  {
2261  #if IS_ENABLED(CONFIG_NFS_V4)
2262  	INIT_LIST_HEAD(&nfsi->open_states);
2263  	nfsi->delegation = NULL;
2264  	init_rwsem(&nfsi->rwsem);
2265  	nfsi->layout = NULL;
2266  #endif
2267  }
2268  
2269  static void init_once(void *foo)
2270  {
2271  	struct nfs_inode *nfsi = foo;
2272  
2273  	inode_init_once(&nfsi->vfs_inode);
2274  	INIT_LIST_HEAD(&nfsi->open_files);
2275  	INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
2276  	INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
2277  	nfs4_init_once(nfsi);
2278  }
2279  
2280  static int __init nfs_init_inodecache(void)
2281  {
2282  	nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
2283  					     sizeof(struct nfs_inode),
2284  					     0, (SLAB_RECLAIM_ACCOUNT|
2285  						SLAB_MEM_SPREAD|SLAB_ACCOUNT),
2286  					     init_once);
2287  	if (nfs_inode_cachep == NULL)
2288  		return -ENOMEM;
2289  
2290  	return 0;
2291  }
2292  
2293  static void nfs_destroy_inodecache(void)
2294  {
2295  	/*
2296  	 * Make sure all delayed rcu free inodes are flushed before we
2297  	 * destroy cache.
2298  	 */
2299  	rcu_barrier();
2300  	kmem_cache_destroy(nfs_inode_cachep);
2301  }
2302  
2303  struct workqueue_struct *nfsiod_workqueue;
2304  EXPORT_SYMBOL_GPL(nfsiod_workqueue);
2305  
2306  /*
2307   * start up the nfsiod workqueue
2308   */
2309  static int nfsiod_start(void)
2310  {
2311  	struct workqueue_struct *wq;
2312  	dprintk("RPC:       creating workqueue nfsiod\n");
2313  	wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM | WQ_UNBOUND, 0);
2314  	if (wq == NULL)
2315  		return -ENOMEM;
2316  	nfsiod_workqueue = wq;
2317  	return 0;
2318  }
2319  
2320  /*
2321   * Destroy the nfsiod workqueue
2322   */
2323  static void nfsiod_stop(void)
2324  {
2325  	struct workqueue_struct *wq;
2326  
2327  	wq = nfsiod_workqueue;
2328  	if (wq == NULL)
2329  		return;
2330  	nfsiod_workqueue = NULL;
2331  	destroy_workqueue(wq);
2332  }
2333  
2334  unsigned int nfs_net_id;
2335  EXPORT_SYMBOL_GPL(nfs_net_id);
2336  
2337  static int nfs_net_init(struct net *net)
2338  {
2339  	nfs_clients_init(net);
2340  	return nfs_fs_proc_net_init(net);
2341  }
2342  
2343  static void nfs_net_exit(struct net *net)
2344  {
2345  	nfs_fs_proc_net_exit(net);
2346  	nfs_clients_exit(net);
2347  }
2348  
2349  static struct pernet_operations nfs_net_ops = {
2350  	.init = nfs_net_init,
2351  	.exit = nfs_net_exit,
2352  	.id   = &nfs_net_id,
2353  	.size = sizeof(struct nfs_net),
2354  };
2355  
2356  /*
2357   * Initialize NFS
2358   */
2359  static int __init init_nfs_fs(void)
2360  {
2361  	int err;
2362  
2363  	err = nfs_sysfs_init();
2364  	if (err < 0)
2365  		goto out10;
2366  
2367  	err = register_pernet_subsys(&nfs_net_ops);
2368  	if (err < 0)
2369  		goto out9;
2370  
2371  	err = nfsiod_start();
2372  	if (err)
2373  		goto out7;
2374  
2375  	err = nfs_fs_proc_init();
2376  	if (err)
2377  		goto out6;
2378  
2379  	err = nfs_init_nfspagecache();
2380  	if (err)
2381  		goto out5;
2382  
2383  	err = nfs_init_inodecache();
2384  	if (err)
2385  		goto out4;
2386  
2387  	err = nfs_init_readpagecache();
2388  	if (err)
2389  		goto out3;
2390  
2391  	err = nfs_init_writepagecache();
2392  	if (err)
2393  		goto out2;
2394  
2395  	err = nfs_init_directcache();
2396  	if (err)
2397  		goto out1;
2398  
2399  	rpc_proc_register(&init_net, &nfs_rpcstat);
2400  
2401  	err = register_nfs_fs();
2402  	if (err)
2403  		goto out0;
2404  
2405  	return 0;
2406  out0:
2407  	rpc_proc_unregister(&init_net, "nfs");
2408  	nfs_destroy_directcache();
2409  out1:
2410  	nfs_destroy_writepagecache();
2411  out2:
2412  	nfs_destroy_readpagecache();
2413  out3:
2414  	nfs_destroy_inodecache();
2415  out4:
2416  	nfs_destroy_nfspagecache();
2417  out5:
2418  	nfs_fs_proc_exit();
2419  out6:
2420  	nfsiod_stop();
2421  out7:
2422  	unregister_pernet_subsys(&nfs_net_ops);
2423  out9:
2424  	nfs_sysfs_exit();
2425  out10:
2426  	return err;
2427  }
2428  
2429  static void __exit exit_nfs_fs(void)
2430  {
2431  	nfs_destroy_directcache();
2432  	nfs_destroy_writepagecache();
2433  	nfs_destroy_readpagecache();
2434  	nfs_destroy_inodecache();
2435  	nfs_destroy_nfspagecache();
2436  	unregister_pernet_subsys(&nfs_net_ops);
2437  	rpc_proc_unregister(&init_net, "nfs");
2438  	unregister_nfs_fs();
2439  	nfs_fs_proc_exit();
2440  	nfsiod_stop();
2441  	nfs_sysfs_exit();
2442  }
2443  
2444  /* Not quite true; I just maintain it */
2445  MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
2446  MODULE_LICENSE("GPL");
2447  module_param(enable_ino64, bool, 0644);
2448  
2449  module_init(init_nfs_fs)
2450  module_exit(exit_nfs_fs)
2451