1 // SPDX-License-Identifier: GPL-2.0-only
5 * Copyright (C) 1992 Rick Sladkey
7 * nfs inode and superblock handling functions
9 * Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
10 * experimental NFS changes. Modularisation taken straight from SYS5 fs.
12 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
13 * J.S.Peatfield@damtp.cam.ac.uk
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>
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>
47 #include "delegation.h"
58 #define NFSDBG_FACILITY NFSDBG_VFS
60 #define NFS_64_BIT_INODE_NUMBERS_ENABLED 1
62 /* Default is to see 64-bit inode numbers */
63 static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
65 static int nfs_update_inode(struct inode *, struct nfs_fattr *);
67 static struct kmem_cache * nfs_inode_cachep;
69 static inline unsigned long
70 nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
72 return nfs_fileid_to_ino_t(fattr->fileid);
75 static int nfs_wait_killable(int mode)
77 freezable_schedule_unsafe();
78 if (signal_pending_state(mode, current))
83 int nfs_wait_bit_killable(struct wait_bit_key *key, int mode)
85 return nfs_wait_killable(mode);
87 EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
90 * nfs_compat_user_ino64 - returns the user-visible inode number
91 * @fileid: 64-bit fileid
93 * This function returns a 32-bit inode number if the boot parameter
94 * nfs.enable_ino64 is zero.
96 u64 nfs_compat_user_ino64(u64 fileid)
107 if (sizeof(ino) < sizeof(fileid))
108 ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
112 int nfs_drop_inode(struct inode *inode)
114 return NFS_STALE(inode) || generic_drop_inode(inode);
116 EXPORT_SYMBOL_GPL(nfs_drop_inode);
118 void nfs_clear_inode(struct inode *inode)
121 * The following should never happen...
123 WARN_ON_ONCE(nfs_have_writebacks(inode));
124 WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files));
125 nfs_zap_acl_cache(inode);
126 nfs_access_zap_cache(inode);
127 nfs_fscache_clear_inode(inode);
129 EXPORT_SYMBOL_GPL(nfs_clear_inode);
131 void nfs_evict_inode(struct inode *inode)
133 truncate_inode_pages_final(&inode->i_data);
135 nfs_clear_inode(inode);
138 int nfs_sync_inode(struct inode *inode)
140 inode_dio_wait(inode);
141 return nfs_wb_all(inode);
143 EXPORT_SYMBOL_GPL(nfs_sync_inode);
146 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
147 * @mapping: pointer to struct address_space
149 int nfs_sync_mapping(struct address_space *mapping)
153 if (mapping->nrpages != 0) {
154 unmap_mapping_range(mapping, 0, 0, 0);
155 ret = nfs_wb_all(mapping->host);
160 static int nfs_attribute_timeout(struct inode *inode)
162 struct nfs_inode *nfsi = NFS_I(inode);
164 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
167 static bool nfs_check_cache_flags_invalid(struct inode *inode,
170 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
172 return (cache_validity & flags) != 0;
175 bool nfs_check_cache_invalid(struct inode *inode, unsigned long flags)
177 if (nfs_check_cache_flags_invalid(inode, flags))
179 return nfs_attribute_cache_expired(inode);
181 EXPORT_SYMBOL_GPL(nfs_check_cache_invalid);
183 #ifdef CONFIG_NFS_V4_2
184 static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi)
186 return nfsi->xattr_cache != NULL;
189 static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi)
195 void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
197 struct nfs_inode *nfsi = NFS_I(inode);
198 bool have_delegation = NFS_PROTO(inode)->have_delegation(inode, FMODE_READ);
200 if (have_delegation) {
201 if (!(flags & NFS_INO_REVAL_FORCED))
202 flags &= ~(NFS_INO_INVALID_MODE |
203 NFS_INO_INVALID_OTHER |
204 NFS_INO_INVALID_XATTR);
205 flags &= ~(NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE);
206 } else if (flags & NFS_INO_REVAL_PAGECACHE)
207 flags |= NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE;
209 if (!nfs_has_xattr_cache(nfsi))
210 flags &= ~NFS_INO_INVALID_XATTR;
211 if (flags & NFS_INO_INVALID_DATA)
212 nfs_fscache_invalidate(inode, 0);
213 flags &= ~(NFS_INO_REVAL_PAGECACHE | NFS_INO_REVAL_FORCED);
215 nfsi->cache_validity |= flags;
217 if (inode->i_mapping->nrpages == 0)
218 nfsi->cache_validity &= ~(NFS_INO_INVALID_DATA |
219 NFS_INO_DATA_INVAL_DEFER);
220 else if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
221 nfsi->cache_validity &= ~NFS_INO_DATA_INVAL_DEFER;
222 trace_nfs_set_cache_invalid(inode, 0);
224 EXPORT_SYMBOL_GPL(nfs_set_cache_invalid);
227 * Invalidate the local caches
229 static void nfs_zap_caches_locked(struct inode *inode)
231 struct nfs_inode *nfsi = NFS_I(inode);
232 int mode = inode->i_mode;
234 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
236 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
237 nfsi->attrtimeo_timestamp = jiffies;
239 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
240 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
241 | NFS_INO_INVALID_DATA
242 | NFS_INO_INVALID_ACCESS
243 | NFS_INO_INVALID_ACL
244 | NFS_INO_INVALID_XATTR
245 | NFS_INO_REVAL_PAGECACHE);
247 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
248 | NFS_INO_INVALID_ACCESS
249 | NFS_INO_INVALID_ACL
250 | NFS_INO_INVALID_XATTR
251 | NFS_INO_REVAL_PAGECACHE);
252 nfs_zap_label_cache_locked(nfsi);
255 void nfs_zap_caches(struct inode *inode)
257 spin_lock(&inode->i_lock);
258 nfs_zap_caches_locked(inode);
259 spin_unlock(&inode->i_lock);
262 void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
264 if (mapping->nrpages != 0) {
265 spin_lock(&inode->i_lock);
266 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
267 spin_unlock(&inode->i_lock);
271 void nfs_zap_acl_cache(struct inode *inode)
273 void (*clear_acl_cache)(struct inode *);
275 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
276 if (clear_acl_cache != NULL)
277 clear_acl_cache(inode);
278 spin_lock(&inode->i_lock);
279 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
280 spin_unlock(&inode->i_lock);
282 EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
284 void nfs_invalidate_atime(struct inode *inode)
286 spin_lock(&inode->i_lock);
287 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
288 spin_unlock(&inode->i_lock);
290 EXPORT_SYMBOL_GPL(nfs_invalidate_atime);
293 * Invalidate, but do not unhash, the inode.
294 * NB: must be called with inode->i_lock held!
296 static void nfs_set_inode_stale_locked(struct inode *inode)
298 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
299 nfs_zap_caches_locked(inode);
300 trace_nfs_set_inode_stale(inode);
303 void nfs_set_inode_stale(struct inode *inode)
305 spin_lock(&inode->i_lock);
306 nfs_set_inode_stale_locked(inode);
307 spin_unlock(&inode->i_lock);
310 struct nfs_find_desc {
312 struct nfs_fattr *fattr;
316 * In NFSv3 we can have 64bit inode numbers. In order to support
317 * this, and re-exported directories (also seen in NFSv2)
318 * we are forced to allow 2 different inodes to have the same
322 nfs_find_actor(struct inode *inode, void *opaque)
324 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
325 struct nfs_fh *fh = desc->fh;
326 struct nfs_fattr *fattr = desc->fattr;
328 if (NFS_FILEID(inode) != fattr->fileid)
330 if (inode_wrong_type(inode, fattr->mode))
332 if (nfs_compare_fh(NFS_FH(inode), fh))
334 if (is_bad_inode(inode) || NFS_STALE(inode))
340 nfs_init_locked(struct inode *inode, void *opaque)
342 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
343 struct nfs_fattr *fattr = desc->fattr;
345 set_nfs_fileid(inode, fattr->fileid);
346 inode->i_mode = fattr->mode;
347 nfs_copy_fh(NFS_FH(inode), desc->fh);
351 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
352 static void nfs_clear_label_invalid(struct inode *inode)
354 spin_lock(&inode->i_lock);
355 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_LABEL;
356 spin_unlock(&inode->i_lock);
359 void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr)
363 if (fattr->label == NULL)
366 if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) && inode->i_security) {
367 error = security_inode_notifysecctx(inode, fattr->label->label,
370 printk(KERN_ERR "%s() %s %d "
371 "security_inode_notifysecctx() %d\n",
373 (char *)fattr->label->label,
374 fattr->label->len, error);
375 nfs_clear_label_invalid(inode);
379 struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
381 struct nfs4_label *label;
383 if (!(server->caps & NFS_CAP_SECURITY_LABEL))
386 label = kzalloc(sizeof(struct nfs4_label), flags);
388 return ERR_PTR(-ENOMEM);
390 label->label = kzalloc(NFS4_MAXLABELLEN, flags);
391 if (label->label == NULL) {
393 return ERR_PTR(-ENOMEM);
395 label->len = NFS4_MAXLABELLEN;
399 EXPORT_SYMBOL_GPL(nfs4_label_alloc);
401 void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr)
405 EXPORT_SYMBOL_GPL(nfs_setsecurity);
407 /* Search for inode identified by fh, fileid and i_mode in inode cache. */
409 nfs_ilookup(struct super_block *sb, struct nfs_fattr *fattr, struct nfs_fh *fh)
411 struct nfs_find_desc desc = {
418 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID) ||
419 !(fattr->valid & NFS_ATTR_FATTR_TYPE))
422 hash = nfs_fattr_to_ino_t(fattr);
423 inode = ilookup5(sb, hash, nfs_find_actor, &desc);
425 dprintk("%s: returning %p\n", __func__, inode);
429 static void nfs_inode_init_regular(struct nfs_inode *nfsi)
431 atomic_long_set(&nfsi->nrequests, 0);
432 INIT_LIST_HEAD(&nfsi->commit_info.list);
433 atomic_long_set(&nfsi->commit_info.ncommit, 0);
434 atomic_set(&nfsi->commit_info.rpcs_out, 0);
435 mutex_init(&nfsi->commit_mutex);
438 static void nfs_inode_init_dir(struct nfs_inode *nfsi)
440 nfsi->cache_change_attribute = 0;
441 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
442 init_rwsem(&nfsi->rmdir_sem);
446 * This is our front-end to iget that looks up inodes by file handle
447 * instead of inode number.
450 nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
452 struct nfs_find_desc desc = {
456 struct inode *inode = ERR_PTR(-ENOENT);
457 u64 fattr_supported = NFS_SB(sb)->fattr_valid;
460 nfs_attr_check_mountpoint(sb, fattr);
462 if (nfs_attr_use_mounted_on_fileid(fattr))
463 fattr->fileid = fattr->mounted_on_fileid;
464 else if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0)
466 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
469 hash = nfs_fattr_to_ino_t(fattr);
471 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
473 inode = ERR_PTR(-ENOMEM);
477 if (inode->i_state & I_NEW) {
478 struct nfs_inode *nfsi = NFS_I(inode);
479 unsigned long now = jiffies;
481 /* We set i_ino for the few things that still rely on it,
485 /* We can't support update_atime(), since the server will reset it */
486 inode->i_flags |= S_NOATIME|S_NOCMTIME;
487 inode->i_mode = fattr->mode;
488 nfsi->cache_validity = 0;
489 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
490 && (fattr_supported & NFS_ATTR_FATTR_MODE))
491 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MODE);
492 /* Why so? Because we want revalidate for devices/FIFOs, and
493 * that's precisely what we have in nfs_file_inode_operations.
495 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
496 if (S_ISREG(inode->i_mode)) {
497 inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
498 inode->i_data.a_ops = &nfs_file_aops;
499 nfs_inode_init_regular(nfsi);
500 } else if (S_ISDIR(inode->i_mode)) {
501 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
502 inode->i_fop = &nfs_dir_operations;
503 inode->i_data.a_ops = &nfs_dir_aops;
504 nfs_inode_init_dir(nfsi);
505 /* Deal with crossing mountpoints */
506 if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
507 fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
508 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
509 inode->i_op = &nfs_referral_inode_operations;
511 inode->i_op = &nfs_mountpoint_inode_operations;
513 inode->i_flags |= S_AUTOMOUNT;
515 } else if (S_ISLNK(inode->i_mode)) {
516 inode->i_op = &nfs_symlink_inode_operations;
517 inode_nohighmem(inode);
519 init_special_inode(inode, inode->i_mode, fattr->rdev);
521 memset(&inode->i_atime, 0, sizeof(inode->i_atime));
522 memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
523 memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
524 inode_set_iversion_raw(inode, 0);
527 inode->i_uid = make_kuid(&init_user_ns, -2);
528 inode->i_gid = make_kgid(&init_user_ns, -2);
533 nfsi->read_cache_jiffies = fattr->time_start;
534 nfsi->attr_gencount = fattr->gencount;
535 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
536 inode->i_atime = fattr->atime;
537 else if (fattr_supported & NFS_ATTR_FATTR_ATIME)
538 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
539 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
540 inode->i_mtime = fattr->mtime;
541 else if (fattr_supported & NFS_ATTR_FATTR_MTIME)
542 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
543 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
544 inode->i_ctime = fattr->ctime;
545 else if (fattr_supported & NFS_ATTR_FATTR_CTIME)
546 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CTIME);
547 if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
548 inode_set_iversion_raw(inode, fattr->change_attr);
550 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE);
551 if (fattr->valid & NFS_ATTR_FATTR_SIZE)
552 inode->i_size = nfs_size_to_loff_t(fattr->size);
554 nfs_set_cache_invalid(inode, NFS_INO_INVALID_SIZE);
555 if (fattr->valid & NFS_ATTR_FATTR_NLINK)
556 set_nlink(inode, fattr->nlink);
557 else if (fattr_supported & NFS_ATTR_FATTR_NLINK)
558 nfs_set_cache_invalid(inode, NFS_INO_INVALID_NLINK);
559 if (fattr->valid & NFS_ATTR_FATTR_OWNER)
560 inode->i_uid = fattr->uid;
561 else if (fattr_supported & NFS_ATTR_FATTR_OWNER)
562 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
563 if (fattr->valid & NFS_ATTR_FATTR_GROUP)
564 inode->i_gid = fattr->gid;
565 else if (fattr_supported & NFS_ATTR_FATTR_GROUP)
566 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
567 if (nfs_server_capable(inode, NFS_CAP_XATTR))
568 nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR);
569 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
570 inode->i_blocks = fattr->du.nfs2.blocks;
571 else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED &&
573 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
574 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
576 * report the blocks in 512byte units
578 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
579 } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED &&
581 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
583 nfs_setsecurity(inode, fattr);
585 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
586 nfsi->attrtimeo_timestamp = now;
587 nfsi->access_cache = RB_ROOT;
589 nfs_fscache_init_inode(inode);
591 unlock_new_inode(inode);
593 int err = nfs_refresh_inode(inode, fattr);
596 inode = ERR_PTR(err);
600 dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n",
602 (unsigned long long)NFS_FILEID(inode),
603 nfs_display_fhandle_hash(fh),
604 atomic_read(&inode->i_count));
610 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
613 EXPORT_SYMBOL_GPL(nfs_fhget);
615 #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)
618 nfs_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
621 struct inode *inode = d_inode(dentry);
622 struct nfs_fattr *fattr;
625 nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
627 /* skip mode change if it's just for clearing setuid/setgid */
628 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
629 attr->ia_valid &= ~ATTR_MODE;
631 if (attr->ia_valid & ATTR_SIZE) {
632 BUG_ON(!S_ISREG(inode->i_mode));
634 error = inode_newsize_ok(inode, attr->ia_size);
638 if (attr->ia_size == i_size_read(inode))
639 attr->ia_valid &= ~ATTR_SIZE;
642 /* Optimization: if the end result is no change, don't RPC */
643 if (((attr->ia_valid & NFS_VALID_ATTRS) & ~(ATTR_FILE|ATTR_OPEN)) == 0)
646 trace_nfs_setattr_enter(inode);
648 /* Write all dirty data */
649 if (S_ISREG(inode->i_mode))
650 nfs_sync_inode(inode);
652 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
658 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
660 error = nfs_refresh_inode(inode, fattr);
661 nfs_free_fattr(fattr);
663 trace_nfs_setattr_exit(inode, error);
666 EXPORT_SYMBOL_GPL(nfs_setattr);
669 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
670 * @inode: inode of the file used
671 * @offset: file offset to start truncating
673 * This is a copy of the common vmtruncate, but with the locking
674 * corrected to take into account the fact that NFS requires
675 * inode->i_size to be updated under the inode->i_lock.
676 * Note: must be called with inode->i_lock held!
678 static int nfs_vmtruncate(struct inode * inode, loff_t offset)
682 err = inode_newsize_ok(inode, offset);
686 trace_nfs_size_truncate(inode, offset);
687 i_size_write(inode, offset);
690 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_DATA |
691 NFS_INO_DATA_INVAL_DEFER);
692 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE;
694 spin_unlock(&inode->i_lock);
695 truncate_pagecache(inode, offset);
696 spin_lock(&inode->i_lock);
702 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
703 * @inode: pointer to struct inode
704 * @attr: pointer to struct iattr
705 * @fattr: pointer to struct nfs_fattr
707 * Note: we do this in the *proc.c in order to ensure that
708 * it works for things like exclusive creates too.
710 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr,
711 struct nfs_fattr *fattr)
713 /* Barrier: bump the attribute generation count. */
714 nfs_fattr_set_barrier(fattr);
716 spin_lock(&inode->i_lock);
717 NFS_I(inode)->attr_gencount = fattr->gencount;
718 if ((attr->ia_valid & ATTR_SIZE) != 0) {
719 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME |
720 NFS_INO_INVALID_BLOCKS);
721 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
722 nfs_vmtruncate(inode, attr->ia_size);
724 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
725 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_CTIME;
726 if ((attr->ia_valid & ATTR_KILL_SUID) != 0 &&
727 inode->i_mode & S_ISUID)
728 inode->i_mode &= ~S_ISUID;
729 if ((attr->ia_valid & ATTR_KILL_SGID) != 0 &&
730 (inode->i_mode & (S_ISGID | S_IXGRP)) ==
732 inode->i_mode &= ~S_ISGID;
733 if ((attr->ia_valid & ATTR_MODE) != 0) {
734 int mode = attr->ia_mode & S_IALLUGO;
735 mode |= inode->i_mode & ~S_IALLUGO;
736 inode->i_mode = mode;
738 if ((attr->ia_valid & ATTR_UID) != 0)
739 inode->i_uid = attr->ia_uid;
740 if ((attr->ia_valid & ATTR_GID) != 0)
741 inode->i_gid = attr->ia_gid;
742 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
743 inode->i_ctime = fattr->ctime;
745 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
746 | NFS_INO_INVALID_CTIME);
747 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ACCESS
748 | NFS_INO_INVALID_ACL);
750 if (attr->ia_valid & (ATTR_ATIME_SET|ATTR_ATIME)) {
751 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_ATIME
752 | NFS_INO_INVALID_CTIME);
753 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
754 inode->i_atime = fattr->atime;
755 else if (attr->ia_valid & ATTR_ATIME_SET)
756 inode->i_atime = attr->ia_atime;
758 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
760 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
761 inode->i_ctime = fattr->ctime;
763 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
764 | NFS_INO_INVALID_CTIME);
766 if (attr->ia_valid & (ATTR_MTIME_SET|ATTR_MTIME)) {
767 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_MTIME
768 | NFS_INO_INVALID_CTIME);
769 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
770 inode->i_mtime = fattr->mtime;
771 else if (attr->ia_valid & ATTR_MTIME_SET)
772 inode->i_mtime = attr->ia_mtime;
774 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
776 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
777 inode->i_ctime = fattr->ctime;
779 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
780 | NFS_INO_INVALID_CTIME);
783 nfs_update_inode(inode, fattr);
784 spin_unlock(&inode->i_lock);
786 EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);
788 static void nfs_readdirplus_parent_cache_miss(struct dentry *dentry)
790 struct dentry *parent;
792 if (!nfs_server_capable(d_inode(dentry), NFS_CAP_READDIRPLUS))
794 parent = dget_parent(dentry);
795 nfs_force_use_readdirplus(d_inode(parent));
799 static void nfs_readdirplus_parent_cache_hit(struct dentry *dentry)
801 struct dentry *parent;
803 if (!nfs_server_capable(d_inode(dentry), NFS_CAP_READDIRPLUS))
805 parent = dget_parent(dentry);
806 nfs_advise_use_readdirplus(d_inode(parent));
810 static u32 nfs_get_valid_attrmask(struct inode *inode)
812 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
813 u32 reply_mask = STATX_INO | STATX_TYPE;
815 if (!(cache_validity & NFS_INO_INVALID_ATIME))
816 reply_mask |= STATX_ATIME;
817 if (!(cache_validity & NFS_INO_INVALID_CTIME))
818 reply_mask |= STATX_CTIME;
819 if (!(cache_validity & NFS_INO_INVALID_MTIME))
820 reply_mask |= STATX_MTIME;
821 if (!(cache_validity & NFS_INO_INVALID_SIZE))
822 reply_mask |= STATX_SIZE;
823 if (!(cache_validity & NFS_INO_INVALID_NLINK))
824 reply_mask |= STATX_NLINK;
825 if (!(cache_validity & NFS_INO_INVALID_MODE))
826 reply_mask |= STATX_MODE;
827 if (!(cache_validity & NFS_INO_INVALID_OTHER))
828 reply_mask |= STATX_UID | STATX_GID;
829 if (!(cache_validity & NFS_INO_INVALID_BLOCKS))
830 reply_mask |= STATX_BLOCKS;
834 int nfs_getattr(struct user_namespace *mnt_userns, const struct path *path,
835 struct kstat *stat, u32 request_mask, unsigned int query_flags)
837 struct inode *inode = d_inode(path->dentry);
838 struct nfs_server *server = NFS_SERVER(inode);
839 unsigned long cache_validity;
841 bool force_sync = query_flags & AT_STATX_FORCE_SYNC;
842 bool do_update = false;
844 trace_nfs_getattr_enter(inode);
846 request_mask &= STATX_TYPE | STATX_MODE | STATX_NLINK | STATX_UID |
847 STATX_GID | STATX_ATIME | STATX_MTIME | STATX_CTIME |
848 STATX_INO | STATX_SIZE | STATX_BLOCKS;
850 if ((query_flags & AT_STATX_DONT_SYNC) && !force_sync) {
851 nfs_readdirplus_parent_cache_hit(path->dentry);
852 goto out_no_revalidate;
855 /* Flush out writes to the server in order to update c/mtime. */
856 if ((request_mask & (STATX_CTIME | STATX_MTIME)) &&
857 S_ISREG(inode->i_mode))
858 filemap_write_and_wait(inode->i_mapping);
861 * We may force a getattr if the user cares about atime.
863 * Note that we only have to check the vfsmount flags here:
864 * - NFS always sets S_NOATIME by so checking it would give a
866 * - NFS never sets SB_NOATIME or SB_NODIRATIME so there is
867 * no point in checking those.
869 if ((path->mnt->mnt_flags & MNT_NOATIME) ||
870 ((path->mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
871 request_mask &= ~STATX_ATIME;
873 /* Is the user requesting attributes that might need revalidation? */
874 if (!(request_mask & (STATX_MODE|STATX_NLINK|STATX_ATIME|STATX_CTIME|
875 STATX_MTIME|STATX_UID|STATX_GID|
876 STATX_SIZE|STATX_BLOCKS)))
877 goto out_no_revalidate;
879 /* Check whether the cached attributes are stale */
880 do_update |= force_sync || nfs_attribute_cache_expired(inode);
881 cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
882 do_update |= cache_validity & NFS_INO_INVALID_CHANGE;
883 if (request_mask & STATX_ATIME)
884 do_update |= cache_validity & NFS_INO_INVALID_ATIME;
885 if (request_mask & STATX_CTIME)
886 do_update |= cache_validity & NFS_INO_INVALID_CTIME;
887 if (request_mask & STATX_MTIME)
888 do_update |= cache_validity & NFS_INO_INVALID_MTIME;
889 if (request_mask & STATX_SIZE)
890 do_update |= cache_validity & NFS_INO_INVALID_SIZE;
891 if (request_mask & STATX_NLINK)
892 do_update |= cache_validity & NFS_INO_INVALID_NLINK;
893 if (request_mask & STATX_MODE)
894 do_update |= cache_validity & NFS_INO_INVALID_MODE;
895 if (request_mask & (STATX_UID | STATX_GID))
896 do_update |= cache_validity & NFS_INO_INVALID_OTHER;
897 if (request_mask & STATX_BLOCKS)
898 do_update |= cache_validity & NFS_INO_INVALID_BLOCKS;
901 /* Update the attribute cache */
902 if (!(server->flags & NFS_MOUNT_NOAC))
903 nfs_readdirplus_parent_cache_miss(path->dentry);
905 nfs_readdirplus_parent_cache_hit(path->dentry);
906 err = __nfs_revalidate_inode(server, inode);
910 nfs_readdirplus_parent_cache_hit(path->dentry);
912 /* Only return attributes that were revalidated. */
913 stat->result_mask = nfs_get_valid_attrmask(inode) | request_mask;
915 generic_fillattr(&init_user_ns, inode, stat);
916 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
917 if (S_ISDIR(inode->i_mode))
918 stat->blksize = NFS_SERVER(inode)->dtsize;
920 trace_nfs_getattr_exit(inode, err);
923 EXPORT_SYMBOL_GPL(nfs_getattr);
925 static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
927 refcount_set(&l_ctx->count, 1);
928 l_ctx->lockowner = current->files;
929 INIT_LIST_HEAD(&l_ctx->list);
930 atomic_set(&l_ctx->io_count, 0);
933 static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx)
935 struct nfs_lock_context *pos;
937 list_for_each_entry_rcu(pos, &ctx->lock_context.list, list) {
938 if (pos->lockowner != current->files)
940 if (refcount_inc_not_zero(&pos->count))
946 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
948 struct nfs_lock_context *res, *new = NULL;
949 struct inode *inode = d_inode(ctx->dentry);
952 res = __nfs_find_lock_context(ctx);
955 new = kmalloc(sizeof(*new), GFP_KERNEL);
957 return ERR_PTR(-ENOMEM);
958 nfs_init_lock_context(new);
959 spin_lock(&inode->i_lock);
960 res = __nfs_find_lock_context(ctx);
962 new->open_context = get_nfs_open_context(ctx);
963 if (new->open_context) {
964 list_add_tail_rcu(&new->list,
965 &ctx->lock_context.list);
969 res = ERR_PTR(-EBADF);
971 spin_unlock(&inode->i_lock);
976 EXPORT_SYMBOL_GPL(nfs_get_lock_context);
978 void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
980 struct nfs_open_context *ctx = l_ctx->open_context;
981 struct inode *inode = d_inode(ctx->dentry);
983 if (!refcount_dec_and_lock(&l_ctx->count, &inode->i_lock))
985 list_del_rcu(&l_ctx->list);
986 spin_unlock(&inode->i_lock);
987 put_nfs_open_context(ctx);
988 kfree_rcu(l_ctx, rcu_head);
990 EXPORT_SYMBOL_GPL(nfs_put_lock_context);
993 * nfs_close_context - Common close_context() routine NFSv2/v3
994 * @ctx: pointer to context
995 * @is_sync: is this a synchronous close
997 * Ensure that the attributes are up to date if we're mounted
998 * with close-to-open semantics and we have cached data that will
999 * need to be revalidated on open.
1001 void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
1003 struct nfs_inode *nfsi;
1004 struct inode *inode;
1006 if (!(ctx->mode & FMODE_WRITE))
1010 inode = d_inode(ctx->dentry);
1011 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1013 nfsi = NFS_I(inode);
1014 if (inode->i_mapping->nrpages == 0)
1016 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
1018 if (!list_empty(&nfsi->open_files))
1020 if (NFS_SERVER(inode)->flags & NFS_MOUNT_NOCTO)
1022 nfs_revalidate_inode(inode,
1023 NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE);
1025 EXPORT_SYMBOL_GPL(nfs_close_context);
1027 struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry,
1031 struct nfs_open_context *ctx;
1033 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
1035 return ERR_PTR(-ENOMEM);
1036 nfs_sb_active(dentry->d_sb);
1037 ctx->dentry = dget(dentry);
1039 ctx->cred = get_cred(filp->f_cred);
1041 ctx->cred = get_current_cred();
1042 rcu_assign_pointer(ctx->ll_cred, NULL);
1047 ctx->flock_owner = (fl_owner_t)filp;
1048 nfs_init_lock_context(&ctx->lock_context);
1049 ctx->lock_context.open_context = ctx;
1050 INIT_LIST_HEAD(&ctx->list);
1051 ctx->mdsthreshold = NULL;
1054 EXPORT_SYMBOL_GPL(alloc_nfs_open_context);
1056 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
1058 if (ctx != NULL && refcount_inc_not_zero(&ctx->lock_context.count))
1062 EXPORT_SYMBOL_GPL(get_nfs_open_context);
1064 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
1066 struct inode *inode = d_inode(ctx->dentry);
1067 struct super_block *sb = ctx->dentry->d_sb;
1069 if (!refcount_dec_and_test(&ctx->lock_context.count))
1071 if (!list_empty(&ctx->list)) {
1072 spin_lock(&inode->i_lock);
1073 list_del_rcu(&ctx->list);
1074 spin_unlock(&inode->i_lock);
1077 NFS_PROTO(inode)->close_context(ctx, is_sync);
1078 put_cred(ctx->cred);
1080 nfs_sb_deactive(sb);
1081 put_rpccred(rcu_dereference_protected(ctx->ll_cred, 1));
1082 kfree(ctx->mdsthreshold);
1083 kfree_rcu(ctx, rcu_head);
1086 void put_nfs_open_context(struct nfs_open_context *ctx)
1088 __put_nfs_open_context(ctx, 0);
1090 EXPORT_SYMBOL_GPL(put_nfs_open_context);
1092 static void put_nfs_open_context_sync(struct nfs_open_context *ctx)
1094 __put_nfs_open_context(ctx, 1);
1098 * Ensure that mmap has a recent RPC credential for use when writing out
1101 void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
1103 struct inode *inode = d_inode(ctx->dentry);
1104 struct nfs_inode *nfsi = NFS_I(inode);
1106 spin_lock(&inode->i_lock);
1107 if (list_empty(&nfsi->open_files) &&
1108 (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
1109 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA |
1110 NFS_INO_REVAL_FORCED);
1111 list_add_tail_rcu(&ctx->list, &nfsi->open_files);
1112 spin_unlock(&inode->i_lock);
1114 EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context);
1116 void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
1118 filp->private_data = get_nfs_open_context(ctx);
1119 set_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags);
1120 if (list_empty(&ctx->list))
1121 nfs_inode_attach_open_context(ctx);
1123 EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
1126 * Given an inode, search for an open context with the desired characteristics
1128 struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode)
1130 struct nfs_inode *nfsi = NFS_I(inode);
1131 struct nfs_open_context *pos, *ctx = NULL;
1134 list_for_each_entry_rcu(pos, &nfsi->open_files, list) {
1135 if (cred != NULL && cred_fscmp(pos->cred, cred) != 0)
1137 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
1139 if (!test_bit(NFS_CONTEXT_FILE_OPEN, &pos->flags))
1141 ctx = get_nfs_open_context(pos);
1149 void nfs_file_clear_open_context(struct file *filp)
1151 struct nfs_open_context *ctx = nfs_file_open_context(filp);
1154 struct inode *inode = d_inode(ctx->dentry);
1156 clear_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags);
1158 * We fatal error on write before. Try to writeback
1162 invalidate_inode_pages2(inode->i_mapping);
1163 filp->private_data = NULL;
1164 put_nfs_open_context_sync(ctx);
1169 * These allocate and release file read/write context information.
1171 int nfs_open(struct inode *inode, struct file *filp)
1173 struct nfs_open_context *ctx;
1175 ctx = alloc_nfs_open_context(file_dentry(filp), filp->f_mode, filp);
1177 return PTR_ERR(ctx);
1178 nfs_file_set_open_context(filp, ctx);
1179 put_nfs_open_context(ctx);
1180 nfs_fscache_open_file(inode, filp);
1183 EXPORT_SYMBOL_GPL(nfs_open);
1186 * This function is called whenever some part of NFS notices that
1187 * the cached attributes have to be refreshed.
1190 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1192 int status = -ESTALE;
1193 struct nfs_fattr *fattr = NULL;
1194 struct nfs_inode *nfsi = NFS_I(inode);
1196 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Lu)\n",
1197 inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode));
1199 trace_nfs_revalidate_inode_enter(inode);
1201 if (is_bad_inode(inode))
1203 if (NFS_STALE(inode))
1206 /* pNFS: Attributes aren't updated until we layoutcommit */
1207 if (S_ISREG(inode->i_mode)) {
1208 status = pnfs_sync_inode(inode, false);
1214 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
1218 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
1220 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, inode);
1222 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n",
1224 (unsigned long long)NFS_FILEID(inode), status);
1227 /* A soft timeout occurred. Use cached information? */
1228 if (server->flags & NFS_MOUNT_SOFTREVAL)
1232 if (!S_ISDIR(inode->i_mode))
1233 nfs_set_inode_stale(inode);
1235 nfs_zap_caches(inode);
1240 status = nfs_refresh_inode(inode, fattr);
1242 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n",
1244 (unsigned long long)NFS_FILEID(inode), status);
1248 if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
1249 nfs_zap_acl_cache(inode);
1251 nfs_setsecurity(inode, fattr);
1253 dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n",
1255 (unsigned long long)NFS_FILEID(inode));
1258 nfs_free_fattr(fattr);
1259 trace_nfs_revalidate_inode_exit(inode, status);
1263 int nfs_attribute_cache_expired(struct inode *inode)
1265 if (nfs_have_delegated_attributes(inode))
1267 return nfs_attribute_timeout(inode);
1271 * nfs_revalidate_inode - Revalidate the inode attributes
1272 * @inode: pointer to inode struct
1273 * @flags: cache flags to check
1275 * Updates inode attribute information by retrieving the data from the server.
1277 int nfs_revalidate_inode(struct inode *inode, unsigned long flags)
1279 if (!nfs_check_cache_invalid(inode, flags))
1280 return NFS_STALE(inode) ? -ESTALE : 0;
1281 return __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1283 EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
1285 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
1289 nfs_fscache_invalidate(inode, 0);
1290 if (mapping->nrpages != 0) {
1291 if (S_ISREG(inode->i_mode)) {
1292 ret = nfs_sync_mapping(mapping);
1296 ret = invalidate_inode_pages2(mapping);
1300 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
1302 dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n",
1304 (unsigned long long)NFS_FILEID(inode));
1309 * nfs_clear_invalid_mapping - Conditionally clear a mapping
1310 * @mapping: pointer to mapping
1312 * If the NFS_INO_INVALID_DATA inode flag is set, clear the mapping.
1314 int nfs_clear_invalid_mapping(struct address_space *mapping)
1316 struct inode *inode = mapping->host;
1317 struct nfs_inode *nfsi = NFS_I(inode);
1318 unsigned long *bitlock = &nfsi->flags;
1322 * We must clear NFS_INO_INVALID_DATA first to ensure that
1323 * invalidations that come in while we're shooting down the mappings
1324 * are respected. But, that leaves a race window where one revalidator
1325 * can clear the flag, and then another checks it before the mapping
1326 * gets invalidated. Fix that by serializing access to this part of
1329 * At the same time, we need to allow other tasks to see whether we
1330 * might be in the middle of invalidating the pages, so we only set
1331 * the bit lock here if it looks like we're going to be doing that.
1334 ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING,
1335 nfs_wait_bit_killable, TASK_KILLABLE);
1338 spin_lock(&inode->i_lock);
1339 if (test_bit(NFS_INO_INVALIDATING, bitlock)) {
1340 spin_unlock(&inode->i_lock);
1343 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
1345 spin_unlock(&inode->i_lock);
1349 set_bit(NFS_INO_INVALIDATING, bitlock);
1351 nfsi->cache_validity &=
1352 ~(NFS_INO_INVALID_DATA | NFS_INO_DATA_INVAL_DEFER);
1353 spin_unlock(&inode->i_lock);
1354 trace_nfs_invalidate_mapping_enter(inode);
1355 ret = nfs_invalidate_mapping(inode, mapping);
1356 trace_nfs_invalidate_mapping_exit(inode, ret);
1358 clear_bit_unlock(NFS_INO_INVALIDATING, bitlock);
1359 smp_mb__after_atomic();
1360 wake_up_bit(bitlock, NFS_INO_INVALIDATING);
1365 bool nfs_mapping_need_revalidate_inode(struct inode *inode)
1367 return nfs_check_cache_invalid(inode, NFS_INO_INVALID_CHANGE) ||
1371 int nfs_revalidate_mapping_rcu(struct inode *inode)
1373 struct nfs_inode *nfsi = NFS_I(inode);
1374 unsigned long *bitlock = &nfsi->flags;
1377 if (IS_SWAPFILE(inode))
1379 if (nfs_mapping_need_revalidate_inode(inode)) {
1383 spin_lock(&inode->i_lock);
1384 if (test_bit(NFS_INO_INVALIDATING, bitlock) ||
1385 (nfsi->cache_validity & NFS_INO_INVALID_DATA))
1387 spin_unlock(&inode->i_lock);
1393 * nfs_revalidate_mapping - Revalidate the pagecache
1394 * @inode: pointer to host inode
1395 * @mapping: pointer to mapping
1397 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
1399 /* swapfiles are not supposed to be shared. */
1400 if (IS_SWAPFILE(inode))
1403 if (nfs_mapping_need_revalidate_inode(inode)) {
1404 int ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1409 return nfs_clear_invalid_mapping(mapping);
1412 static bool nfs_file_has_writers(struct nfs_inode *nfsi)
1414 struct inode *inode = &nfsi->vfs_inode;
1416 if (!S_ISREG(inode->i_mode))
1418 if (list_empty(&nfsi->open_files))
1420 return inode_is_open_for_write(inode);
1423 static bool nfs_file_has_buffered_writers(struct nfs_inode *nfsi)
1425 return nfs_file_has_writers(nfsi) && nfs_file_io_is_buffered(nfsi);
1428 static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1430 struct timespec64 ts;
1432 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
1433 && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
1434 && inode_eq_iversion_raw(inode, fattr->pre_change_attr)) {
1435 inode_set_iversion_raw(inode, fattr->change_attr);
1436 if (S_ISDIR(inode->i_mode))
1437 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
1438 else if (nfs_server_capable(inode, NFS_CAP_XATTR))
1439 nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR);
1441 /* If we have atomic WCC data, we may update some attributes */
1442 ts = inode->i_ctime;
1443 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
1444 && (fattr->valid & NFS_ATTR_FATTR_CTIME)
1445 && timespec64_equal(&ts, &fattr->pre_ctime)) {
1446 inode->i_ctime = fattr->ctime;
1449 ts = inode->i_mtime;
1450 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
1451 && (fattr->valid & NFS_ATTR_FATTR_MTIME)
1452 && timespec64_equal(&ts, &fattr->pre_mtime)) {
1453 inode->i_mtime = fattr->mtime;
1455 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
1456 && (fattr->valid & NFS_ATTR_FATTR_SIZE)
1457 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
1458 && !nfs_have_writebacks(inode)) {
1459 trace_nfs_size_wcc(inode, fattr->size);
1460 i_size_write(inode, nfs_size_to_loff_t(fattr->size));
1465 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
1466 * @inode: pointer to inode
1467 * @fattr: updated attributes
1469 * Verifies the attribute cache. If we have just changed the attributes,
1470 * so that fattr carries weak cache consistency data, then it may
1471 * also update the ctime/mtime/change_attribute.
1473 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
1475 struct nfs_inode *nfsi = NFS_I(inode);
1476 loff_t cur_size, new_isize;
1477 unsigned long invalid = 0;
1478 struct timespec64 ts;
1480 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1483 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) {
1484 /* Only a mounted-on-fileid? Just exit */
1485 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
1487 /* Has the inode gone and changed behind our back? */
1488 } else if (nfsi->fileid != fattr->fileid) {
1489 /* Is this perhaps the mounted-on fileid? */
1490 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) &&
1491 nfsi->fileid == fattr->mounted_on_fileid)
1495 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode))
1499 if (!nfs_file_has_buffered_writers(nfsi)) {
1500 /* Verify a few of the more important attributes */
1501 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && !inode_eq_iversion_raw(inode, fattr->change_attr))
1502 invalid |= NFS_INO_INVALID_CHANGE;
1504 ts = inode->i_mtime;
1505 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec64_equal(&ts, &fattr->mtime))
1506 invalid |= NFS_INO_INVALID_MTIME;
1508 ts = inode->i_ctime;
1509 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) && !timespec64_equal(&ts, &fattr->ctime))
1510 invalid |= NFS_INO_INVALID_CTIME;
1512 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1513 cur_size = i_size_read(inode);
1514 new_isize = nfs_size_to_loff_t(fattr->size);
1515 if (cur_size != new_isize)
1516 invalid |= NFS_INO_INVALID_SIZE;
1520 /* Have any file permissions changed? */
1521 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
1522 invalid |= NFS_INO_INVALID_MODE;
1523 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))
1524 invalid |= NFS_INO_INVALID_OTHER;
1525 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))
1526 invalid |= NFS_INO_INVALID_OTHER;
1528 /* Has the link count changed? */
1529 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
1530 invalid |= NFS_INO_INVALID_NLINK;
1532 ts = inode->i_atime;
1533 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec64_equal(&ts, &fattr->atime))
1534 invalid |= NFS_INO_INVALID_ATIME;
1537 nfs_set_cache_invalid(inode, invalid);
1539 nfsi->read_cache_jiffies = fattr->time_start;
1543 static atomic_long_t nfs_attr_generation_counter;
1545 static unsigned long nfs_read_attr_generation_counter(void)
1547 return atomic_long_read(&nfs_attr_generation_counter);
1550 unsigned long nfs_inc_attr_generation_counter(void)
1552 return atomic_long_inc_return(&nfs_attr_generation_counter);
1554 EXPORT_SYMBOL_GPL(nfs_inc_attr_generation_counter);
1556 void nfs_fattr_init(struct nfs_fattr *fattr)
1559 fattr->time_start = jiffies;
1560 fattr->gencount = nfs_inc_attr_generation_counter();
1561 fattr->owner_name = NULL;
1562 fattr->group_name = NULL;
1564 EXPORT_SYMBOL_GPL(nfs_fattr_init);
1567 * nfs_fattr_set_barrier
1568 * @fattr: attributes
1570 * Used to set a barrier after an attribute was updated. This
1571 * barrier ensures that older attributes from RPC calls that may
1572 * have raced with our update cannot clobber these new values.
1573 * Note that you are still responsible for ensuring that other
1574 * operations which change the attribute on the server do not
1577 void nfs_fattr_set_barrier(struct nfs_fattr *fattr)
1579 fattr->gencount = nfs_inc_attr_generation_counter();
1582 struct nfs_fattr *nfs_alloc_fattr(void)
1584 struct nfs_fattr *fattr;
1586 fattr = kmalloc(sizeof(*fattr), GFP_NOFS);
1587 if (fattr != NULL) {
1588 nfs_fattr_init(fattr);
1589 fattr->label = NULL;
1593 EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
1595 struct nfs_fattr *nfs_alloc_fattr_with_label(struct nfs_server *server)
1597 struct nfs_fattr *fattr = nfs_alloc_fattr();
1602 fattr->label = nfs4_label_alloc(server, GFP_NOFS);
1603 if (IS_ERR(fattr->label)) {
1610 EXPORT_SYMBOL_GPL(nfs_alloc_fattr_with_label);
1612 struct nfs_fh *nfs_alloc_fhandle(void)
1616 fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS);
1621 EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
1625 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle
1626 * in the same way that wireshark does
1630 * For debugging only.
1632 u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
1634 /* wireshark uses 32-bit AUTODIN crc and does a bitwise
1635 * not on the result */
1636 return nfs_fhandle_hash(fh);
1638 EXPORT_SYMBOL_GPL(_nfs_display_fhandle_hash);
1641 * _nfs_display_fhandle - display an NFS file handle on the console
1643 * @fh: file handle to display
1644 * @caption: display caption
1646 * For debugging only.
1648 void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
1652 if (fh == NULL || fh->size == 0) {
1653 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
1657 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
1658 caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
1659 for (i = 0; i < fh->size; i += 16) {
1660 __be32 *pos = (__be32 *)&fh->data[i];
1662 switch ((fh->size - i - 1) >> 2) {
1664 printk(KERN_DEFAULT " %08x\n",
1668 printk(KERN_DEFAULT " %08x %08x\n",
1669 be32_to_cpup(pos), be32_to_cpup(pos + 1));
1672 printk(KERN_DEFAULT " %08x %08x %08x\n",
1673 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1674 be32_to_cpup(pos + 2));
1677 printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
1678 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1679 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
1683 EXPORT_SYMBOL_GPL(_nfs_display_fhandle);
1687 * nfs_inode_attrs_cmp_generic - compare attributes
1688 * @fattr: attributes
1689 * @inode: pointer to inode
1691 * Attempt to divine whether or not an RPC call reply carrying stale
1692 * attributes got scheduled after another call carrying updated ones.
1693 * Note also the check for wraparound of 'attr_gencount'
1695 * The function returns '1' if it thinks the attributes in @fattr are
1696 * more recent than the ones cached in @inode. Otherwise it returns
1699 static int nfs_inode_attrs_cmp_generic(const struct nfs_fattr *fattr,
1700 const struct inode *inode)
1702 unsigned long attr_gencount = NFS_I(inode)->attr_gencount;
1704 return (long)(fattr->gencount - attr_gencount) > 0 ||
1705 (long)(attr_gencount - nfs_read_attr_generation_counter()) > 0;
1709 * nfs_inode_attrs_cmp_monotonic - compare attributes
1710 * @fattr: attributes
1711 * @inode: pointer to inode
1713 * Attempt to divine whether or not an RPC call reply carrying stale
1714 * attributes got scheduled after another call carrying updated ones.
1716 * We assume that the server observes monotonic semantics for
1717 * the change attribute, so a larger value means that the attributes in
1718 * @fattr are more recent, in which case the function returns the
1720 * A return value of '0' indicates no measurable change
1721 * A return value of '-1' means that the attributes in @inode are
1724 static int nfs_inode_attrs_cmp_monotonic(const struct nfs_fattr *fattr,
1725 const struct inode *inode)
1727 s64 diff = fattr->change_attr - inode_peek_iversion_raw(inode);
1730 return diff == 0 ? 0 : -1;
1734 * nfs_inode_attrs_cmp_strict_monotonic - compare attributes
1735 * @fattr: attributes
1736 * @inode: pointer to inode
1738 * Attempt to divine whether or not an RPC call reply carrying stale
1739 * attributes got scheduled after another call carrying updated ones.
1741 * We assume that the server observes strictly monotonic semantics for
1742 * the change attribute, so a larger value means that the attributes in
1743 * @fattr are more recent, in which case the function returns the
1745 * A return value of '-1' means that the attributes in @inode are
1746 * more recent or unchanged.
1748 static int nfs_inode_attrs_cmp_strict_monotonic(const struct nfs_fattr *fattr,
1749 const struct inode *inode)
1751 return nfs_inode_attrs_cmp_monotonic(fattr, inode) > 0 ? 1 : -1;
1755 * nfs_inode_attrs_cmp - compare attributes
1756 * @fattr: attributes
1757 * @inode: pointer to inode
1759 * This function returns '1' if it thinks the attributes in @fattr are
1760 * more recent than the ones cached in @inode. It returns '-1' if
1761 * the attributes in @inode are more recent than the ones in @fattr,
1762 * and it returns 0 if not sure.
1764 static int nfs_inode_attrs_cmp(const struct nfs_fattr *fattr,
1765 const struct inode *inode)
1767 if (nfs_inode_attrs_cmp_generic(fattr, inode) > 0)
1769 switch (NFS_SERVER(inode)->change_attr_type) {
1770 case NFS4_CHANGE_TYPE_IS_UNDEFINED:
1772 case NFS4_CHANGE_TYPE_IS_TIME_METADATA:
1773 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE))
1775 return nfs_inode_attrs_cmp_monotonic(fattr, inode);
1777 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE))
1779 return nfs_inode_attrs_cmp_strict_monotonic(fattr, inode);
1785 * nfs_inode_finish_partial_attr_update - complete a previous inode update
1786 * @fattr: attributes
1787 * @inode: pointer to inode
1789 * Returns '1' if the last attribute update left the inode cached
1790 * attributes in a partially unrevalidated state, and @fattr
1791 * matches the change attribute of that partial update.
1792 * Otherwise returns '0'.
1794 static int nfs_inode_finish_partial_attr_update(const struct nfs_fattr *fattr,
1795 const struct inode *inode)
1797 const unsigned long check_valid =
1798 NFS_INO_INVALID_ATIME | NFS_INO_INVALID_CTIME |
1799 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE |
1800 NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_OTHER |
1801 NFS_INO_INVALID_NLINK;
1802 unsigned long cache_validity = NFS_I(inode)->cache_validity;
1803 enum nfs4_change_attr_type ctype = NFS_SERVER(inode)->change_attr_type;
1805 if (ctype != NFS4_CHANGE_TYPE_IS_UNDEFINED &&
1806 !(cache_validity & NFS_INO_INVALID_CHANGE) &&
1807 (cache_validity & check_valid) != 0 &&
1808 (fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1809 nfs_inode_attrs_cmp_monotonic(fattr, inode) == 0)
1814 static int nfs_refresh_inode_locked(struct inode *inode,
1815 struct nfs_fattr *fattr)
1817 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
1820 trace_nfs_refresh_inode_enter(inode);
1822 if (attr_cmp > 0 || nfs_inode_finish_partial_attr_update(fattr, inode))
1823 ret = nfs_update_inode(inode, fattr);
1824 else if (attr_cmp == 0)
1825 ret = nfs_check_inode_attributes(inode, fattr);
1827 trace_nfs_refresh_inode_exit(inode, ret);
1832 * nfs_refresh_inode - try to update the inode attribute cache
1833 * @inode: pointer to inode
1834 * @fattr: updated attributes
1836 * Check that an RPC call that returned attributes has not overlapped with
1837 * other recent updates of the inode metadata, then decide whether it is
1838 * safe to do a full update of the inode attributes, or whether just to
1839 * call nfs_check_inode_attributes.
1841 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1845 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1847 spin_lock(&inode->i_lock);
1848 status = nfs_refresh_inode_locked(inode, fattr);
1849 spin_unlock(&inode->i_lock);
1853 EXPORT_SYMBOL_GPL(nfs_refresh_inode);
1855 static int nfs_post_op_update_inode_locked(struct inode *inode,
1856 struct nfs_fattr *fattr, unsigned int invalid)
1858 if (S_ISDIR(inode->i_mode))
1859 invalid |= NFS_INO_INVALID_DATA;
1860 nfs_set_cache_invalid(inode, invalid);
1861 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1863 return nfs_refresh_inode_locked(inode, fattr);
1867 * nfs_post_op_update_inode - try to update the inode attribute cache
1868 * @inode: pointer to inode
1869 * @fattr: updated attributes
1871 * After an operation that has changed the inode metadata, mark the
1872 * attribute cache as being invalid, then try to update it.
1874 * NB: if the server didn't return any post op attributes, this
1875 * function will force the retrieval of attributes before the next
1876 * NFS request. Thus it should be used only for operations that
1877 * are expected to change one or more attributes, to avoid
1878 * unnecessary NFS requests and trips through nfs_update_inode().
1880 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1884 spin_lock(&inode->i_lock);
1885 nfs_fattr_set_barrier(fattr);
1886 status = nfs_post_op_update_inode_locked(inode, fattr,
1887 NFS_INO_INVALID_CHANGE
1888 | NFS_INO_INVALID_CTIME
1889 | NFS_INO_REVAL_FORCED);
1890 spin_unlock(&inode->i_lock);
1894 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
1897 * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache
1898 * @inode: pointer to inode
1899 * @fattr: updated attributes
1901 * After an operation that has changed the inode metadata, mark the
1902 * attribute cache as being invalid, then try to update it. Fake up
1903 * weak cache consistency data, if none exist.
1905 * This function is mainly designed to be used by the ->write_done() functions.
1907 int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr)
1909 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
1912 /* Don't do a WCC update if these attributes are already stale */
1915 if ((fattr->valid & NFS_ATTR_FATTR) == 0 || !attr_cmp) {
1916 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
1917 | NFS_ATTR_FATTR_PRESIZE
1918 | NFS_ATTR_FATTR_PREMTIME
1919 | NFS_ATTR_FATTR_PRECTIME);
1922 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1923 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
1924 fattr->pre_change_attr = inode_peek_iversion_raw(inode);
1925 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
1927 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
1928 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
1929 fattr->pre_ctime = inode->i_ctime;
1930 fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
1932 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
1933 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
1934 fattr->pre_mtime = inode->i_mtime;
1935 fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
1937 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
1938 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
1939 fattr->pre_size = i_size_read(inode);
1940 fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
1943 status = nfs_post_op_update_inode_locked(inode, fattr,
1944 NFS_INO_INVALID_CHANGE
1945 | NFS_INO_INVALID_CTIME
1946 | NFS_INO_INVALID_MTIME
1947 | NFS_INO_INVALID_BLOCKS);
1952 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
1953 * @inode: pointer to inode
1954 * @fattr: updated attributes
1956 * After an operation that has changed the inode metadata, mark the
1957 * attribute cache as being invalid, then try to update it. Fake up
1958 * weak cache consistency data, if none exist.
1960 * This function is mainly designed to be used by the ->write_done() functions.
1962 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
1966 spin_lock(&inode->i_lock);
1967 nfs_fattr_set_barrier(fattr);
1968 status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
1969 spin_unlock(&inode->i_lock);
1972 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
1976 * Many nfs protocol calls return the new file attributes after
1977 * an operation. Here we update the inode to reflect the state
1978 * of the server's inode.
1980 * This is a bit tricky because we have to make sure all dirty pages
1981 * have been sent off to the server before calling invalidate_inode_pages.
1982 * To make sure no other process adds more write requests while we try
1983 * our best to flush them, we make them sleep during the attribute refresh.
1985 * A very similar scenario holds for the dir cache.
1987 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1989 struct nfs_server *server = NFS_SERVER(inode);
1990 struct nfs_inode *nfsi = NFS_I(inode);
1991 loff_t cur_isize, new_isize;
1992 u64 fattr_supported = server->fattr_valid;
1993 unsigned long invalid = 0;
1994 unsigned long now = jiffies;
1995 unsigned long save_cache_validity;
1996 bool have_writers = nfs_file_has_buffered_writers(nfsi);
1997 bool cache_revalidated = true;
1998 bool attr_changed = false;
1999 bool have_delegation;
2001 dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%x)\n",
2002 __func__, inode->i_sb->s_id, inode->i_ino,
2003 nfs_display_fhandle_hash(NFS_FH(inode)),
2004 atomic_read(&inode->i_count), fattr->valid);
2006 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) {
2007 /* Only a mounted-on-fileid? Just exit */
2008 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
2010 /* Has the inode gone and changed behind our back? */
2011 } else if (nfsi->fileid != fattr->fileid) {
2012 /* Is this perhaps the mounted-on fileid? */
2013 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) &&
2014 nfsi->fileid == fattr->mounted_on_fileid)
2016 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
2017 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
2018 NFS_SERVER(inode)->nfs_client->cl_hostname,
2019 inode->i_sb->s_id, (long long)nfsi->fileid,
2020 (long long)fattr->fileid);
2025 * Make sure the inode's type hasn't changed.
2027 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) {
2029 * Big trouble! The inode has become a different object.
2031 printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
2032 __func__, inode->i_ino, inode->i_mode, fattr->mode);
2036 /* Update the fsid? */
2037 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
2038 !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
2039 !IS_AUTOMOUNT(inode))
2040 server->fsid = fattr->fsid;
2042 /* Save the delegation state before clearing cache_validity */
2043 have_delegation = nfs_have_delegated_attributes(inode);
2046 * Update the read time so we don't revalidate too often.
2048 nfsi->read_cache_jiffies = fattr->time_start;
2050 save_cache_validity = nfsi->cache_validity;
2051 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
2052 | NFS_INO_INVALID_ATIME
2053 | NFS_INO_REVAL_FORCED
2054 | NFS_INO_INVALID_BLOCKS);
2056 /* Do atomic weak cache consistency updates */
2057 nfs_wcc_update_inode(inode, fattr);
2059 if (pnfs_layoutcommit_outstanding(inode)) {
2060 nfsi->cache_validity |=
2061 save_cache_validity &
2062 (NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME |
2063 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE |
2064 NFS_INO_INVALID_BLOCKS);
2065 cache_revalidated = false;
2068 /* More cache consistency checks */
2069 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
2070 if (!inode_eq_iversion_raw(inode, fattr->change_attr)) {
2071 /* Could it be a race with writeback? */
2072 if (!(have_writers || have_delegation)) {
2073 invalid |= NFS_INO_INVALID_DATA
2074 | NFS_INO_INVALID_ACCESS
2075 | NFS_INO_INVALID_ACL
2076 | NFS_INO_INVALID_XATTR;
2077 /* Force revalidate of all attributes */
2078 save_cache_validity |= NFS_INO_INVALID_CTIME
2079 | NFS_INO_INVALID_MTIME
2080 | NFS_INO_INVALID_SIZE
2081 | NFS_INO_INVALID_BLOCKS
2082 | NFS_INO_INVALID_NLINK
2083 | NFS_INO_INVALID_MODE
2084 | NFS_INO_INVALID_OTHER;
2085 if (S_ISDIR(inode->i_mode))
2086 nfs_force_lookup_revalidate(inode);
2087 attr_changed = true;
2088 dprintk("NFS: change_attr change on server for file %s/%ld\n",
2091 } else if (!have_delegation)
2092 nfsi->cache_validity |= NFS_INO_DATA_INVAL_DEFER;
2093 inode_set_iversion_raw(inode, fattr->change_attr);
2096 nfsi->cache_validity |=
2097 save_cache_validity & NFS_INO_INVALID_CHANGE;
2098 if (!have_delegation ||
2099 (nfsi->cache_validity & NFS_INO_INVALID_CHANGE) != 0)
2100 cache_revalidated = false;
2103 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
2104 inode->i_mtime = fattr->mtime;
2105 else if (fattr_supported & NFS_ATTR_FATTR_MTIME)
2106 nfsi->cache_validity |=
2107 save_cache_validity & NFS_INO_INVALID_MTIME;
2109 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
2110 inode->i_ctime = fattr->ctime;
2111 else if (fattr_supported & NFS_ATTR_FATTR_CTIME)
2112 nfsi->cache_validity |=
2113 save_cache_validity & NFS_INO_INVALID_CTIME;
2115 /* Check if our cached file size is stale */
2116 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
2117 new_isize = nfs_size_to_loff_t(fattr->size);
2118 cur_isize = i_size_read(inode);
2119 if (new_isize != cur_isize && !have_delegation) {
2120 /* Do we perhaps have any outstanding writes, or has
2121 * the file grown beyond our last write? */
2122 if (!nfs_have_writebacks(inode) || new_isize > cur_isize) {
2123 trace_nfs_size_update(inode, new_isize);
2124 i_size_write(inode, new_isize);
2126 invalid |= NFS_INO_INVALID_DATA;
2129 if (new_isize == 0 &&
2130 !(fattr->valid & (NFS_ATTR_FATTR_SPACE_USED |
2131 NFS_ATTR_FATTR_BLOCKS_USED))) {
2132 fattr->du.nfs3.used = 0;
2133 fattr->valid |= NFS_ATTR_FATTR_SPACE_USED;
2136 nfsi->cache_validity |=
2137 save_cache_validity & NFS_INO_INVALID_SIZE;
2139 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
2140 inode->i_atime = fattr->atime;
2141 else if (fattr_supported & NFS_ATTR_FATTR_ATIME)
2142 nfsi->cache_validity |=
2143 save_cache_validity & NFS_INO_INVALID_ATIME;
2145 if (fattr->valid & NFS_ATTR_FATTR_MODE) {
2146 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
2147 umode_t newmode = inode->i_mode & S_IFMT;
2148 newmode |= fattr->mode & S_IALLUGO;
2149 inode->i_mode = newmode;
2150 invalid |= NFS_INO_INVALID_ACCESS
2151 | NFS_INO_INVALID_ACL;
2153 } else if (fattr_supported & NFS_ATTR_FATTR_MODE)
2154 nfsi->cache_validity |=
2155 save_cache_validity & NFS_INO_INVALID_MODE;
2157 if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
2158 if (!uid_eq(inode->i_uid, fattr->uid)) {
2159 invalid |= NFS_INO_INVALID_ACCESS
2160 | NFS_INO_INVALID_ACL;
2161 inode->i_uid = fattr->uid;
2163 } else if (fattr_supported & NFS_ATTR_FATTR_OWNER)
2164 nfsi->cache_validity |=
2165 save_cache_validity & NFS_INO_INVALID_OTHER;
2167 if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
2168 if (!gid_eq(inode->i_gid, fattr->gid)) {
2169 invalid |= NFS_INO_INVALID_ACCESS
2170 | NFS_INO_INVALID_ACL;
2171 inode->i_gid = fattr->gid;
2173 } else if (fattr_supported & NFS_ATTR_FATTR_GROUP)
2174 nfsi->cache_validity |=
2175 save_cache_validity & NFS_INO_INVALID_OTHER;
2177 if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
2178 if (inode->i_nlink != fattr->nlink)
2179 set_nlink(inode, fattr->nlink);
2180 } else if (fattr_supported & NFS_ATTR_FATTR_NLINK)
2181 nfsi->cache_validity |=
2182 save_cache_validity & NFS_INO_INVALID_NLINK;
2184 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
2186 * report the blocks in 512byte units
2188 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
2189 } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED)
2190 nfsi->cache_validity |=
2191 save_cache_validity & NFS_INO_INVALID_BLOCKS;
2193 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
2194 inode->i_blocks = fattr->du.nfs2.blocks;
2195 else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED)
2196 nfsi->cache_validity |=
2197 save_cache_validity & NFS_INO_INVALID_BLOCKS;
2199 /* Update attrtimeo value if we're out of the unstable period */
2201 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
2202 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
2203 nfsi->attrtimeo_timestamp = now;
2204 /* Set barrier to be more recent than all outstanding updates */
2205 nfsi->attr_gencount = nfs_inc_attr_generation_counter();
2207 if (cache_revalidated) {
2208 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp,
2209 nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
2210 nfsi->attrtimeo <<= 1;
2211 if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode))
2212 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
2214 nfsi->attrtimeo_timestamp = now;
2216 /* Set the barrier to be more recent than this fattr */
2217 if ((long)(fattr->gencount - nfsi->attr_gencount) > 0)
2218 nfsi->attr_gencount = fattr->gencount;
2221 /* Don't invalidate the data if we were to blame */
2222 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
2223 || S_ISLNK(inode->i_mode)))
2224 invalid &= ~NFS_INO_INVALID_DATA;
2225 nfs_set_cache_invalid(inode, invalid);
2230 * No need to worry about unhashing the dentry, as the
2231 * lookup validation will know that the inode is bad.
2232 * (But we fall through to invalidate the caches.)
2234 nfs_set_inode_stale_locked(inode);
2238 struct inode *nfs_alloc_inode(struct super_block *sb)
2240 struct nfs_inode *nfsi;
2241 nfsi = alloc_inode_sb(sb, nfs_inode_cachep, GFP_KERNEL);
2245 nfsi->cache_validity = 0UL;
2246 #if IS_ENABLED(CONFIG_NFS_V4)
2247 nfsi->nfs4_acl = NULL;
2248 #endif /* CONFIG_NFS_V4 */
2249 #ifdef CONFIG_NFS_V4_2
2250 nfsi->xattr_cache = NULL;
2252 return &nfsi->vfs_inode;
2254 EXPORT_SYMBOL_GPL(nfs_alloc_inode);
2256 void nfs_free_inode(struct inode *inode)
2258 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
2260 EXPORT_SYMBOL_GPL(nfs_free_inode);
2262 static inline void nfs4_init_once(struct nfs_inode *nfsi)
2264 #if IS_ENABLED(CONFIG_NFS_V4)
2265 INIT_LIST_HEAD(&nfsi->open_states);
2266 nfsi->delegation = NULL;
2267 init_rwsem(&nfsi->rwsem);
2268 nfsi->layout = NULL;
2272 static void init_once(void *foo)
2274 struct nfs_inode *nfsi = (struct nfs_inode *) foo;
2276 inode_init_once(&nfsi->vfs_inode);
2277 INIT_LIST_HEAD(&nfsi->open_files);
2278 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
2279 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
2280 nfs4_init_once(nfsi);
2283 static int __init nfs_init_inodecache(void)
2285 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
2286 sizeof(struct nfs_inode),
2287 0, (SLAB_RECLAIM_ACCOUNT|
2288 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
2290 if (nfs_inode_cachep == NULL)
2296 static void nfs_destroy_inodecache(void)
2299 * Make sure all delayed rcu free inodes are flushed before we
2303 kmem_cache_destroy(nfs_inode_cachep);
2306 struct workqueue_struct *nfsiod_workqueue;
2307 EXPORT_SYMBOL_GPL(nfsiod_workqueue);
2310 * start up the nfsiod workqueue
2312 static int nfsiod_start(void)
2314 struct workqueue_struct *wq;
2315 dprintk("RPC: creating workqueue nfsiod\n");
2316 wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM | WQ_UNBOUND, 0);
2319 nfsiod_workqueue = wq;
2324 * Destroy the nfsiod workqueue
2326 static void nfsiod_stop(void)
2328 struct workqueue_struct *wq;
2330 wq = nfsiod_workqueue;
2333 nfsiod_workqueue = NULL;
2334 destroy_workqueue(wq);
2337 unsigned int nfs_net_id;
2338 EXPORT_SYMBOL_GPL(nfs_net_id);
2340 static int nfs_net_init(struct net *net)
2342 nfs_clients_init(net);
2343 return nfs_fs_proc_net_init(net);
2346 static void nfs_net_exit(struct net *net)
2348 nfs_fs_proc_net_exit(net);
2349 nfs_clients_exit(net);
2352 static struct pernet_operations nfs_net_ops = {
2353 .init = nfs_net_init,
2354 .exit = nfs_net_exit,
2356 .size = sizeof(struct nfs_net),
2362 static int __init init_nfs_fs(void)
2366 err = nfs_sysfs_init();
2370 err = register_pernet_subsys(&nfs_net_ops);
2374 err = nfsiod_start();
2378 err = nfs_fs_proc_init();
2382 err = nfs_init_nfspagecache();
2386 err = nfs_init_inodecache();
2390 err = nfs_init_readpagecache();
2394 err = nfs_init_writepagecache();
2398 err = nfs_init_directcache();
2402 rpc_proc_register(&init_net, &nfs_rpcstat);
2404 err = register_nfs_fs();
2410 rpc_proc_unregister(&init_net, "nfs");
2411 nfs_destroy_directcache();
2413 nfs_destroy_writepagecache();
2415 nfs_destroy_readpagecache();
2417 nfs_destroy_inodecache();
2419 nfs_destroy_nfspagecache();
2425 unregister_pernet_subsys(&nfs_net_ops);
2432 static void __exit exit_nfs_fs(void)
2434 nfs_destroy_directcache();
2435 nfs_destroy_writepagecache();
2436 nfs_destroy_readpagecache();
2437 nfs_destroy_inodecache();
2438 nfs_destroy_nfspagecache();
2439 unregister_pernet_subsys(&nfs_net_ops);
2440 rpc_proc_unregister(&init_net, "nfs");
2441 unregister_nfs_fs();
2447 /* Not quite true; I just maintain it */
2448 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
2449 MODULE_LICENSE("GPL");
2450 module_param(enable_ino64, bool, 0644);
2452 module_init(init_nfs_fs)
2453 module_exit(exit_nfs_fs)