Lines Matching defs:inode
3 * linux/fs/nfs/inode.c
7 * nfs inode and superblock handling functions
62 /* Default is to see 64-bit inode numbers */
65 static int nfs_update_inode(struct inode *, struct nfs_fattr *);
85 * nfs_compat_user_ino64 - returns the user-visible inode number
88 * This function returns a 32-bit inode number if the boot parameter
107 int nfs_drop_inode(struct inode *inode)
109 return NFS_STALE(inode) || generic_drop_inode(inode);
113 void nfs_clear_inode(struct inode *inode)
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);
126 void nfs_evict_inode(struct inode *inode)
128 truncate_inode_pages_final(&inode->i_data);
129 clear_inode(inode);
130 nfs_clear_inode(inode);
133 int nfs_sync_inode(struct inode *inode)
135 inode_dio_wait(inode);
136 return nfs_wb_all(inode);
155 static int nfs_attribute_timeout(struct inode *inode)
157 struct nfs_inode *nfsi = NFS_I(inode);
162 static bool nfs_check_cache_flags_invalid(struct inode *inode,
165 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
170 bool nfs_check_cache_invalid(struct inode *inode, unsigned long flags)
172 if (nfs_check_cache_flags_invalid(inode, flags))
174 return nfs_attribute_cache_expired(inode);
190 void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
192 struct nfs_inode *nfsi = NFS_I(inode);
194 if (nfs_have_delegated_attributes(inode)) {
205 nfs_fscache_invalidate(inode, 0);
209 if (inode->i_mapping->nrpages == 0)
215 if (inode->i_mapping->nrpages == 0 ||
219 trace_nfs_set_cache_invalid(inode, 0);
226 static void nfs_zap_caches_locked(struct inode *inode)
228 struct nfs_inode *nfsi = NFS_I(inode);
229 int mode = inode->i_mode;
231 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
233 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
237 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR |
243 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR |
250 void nfs_zap_caches(struct inode *inode)
252 spin_lock(&inode->i_lock);
253 nfs_zap_caches_locked(inode);
254 spin_unlock(&inode->i_lock);
257 void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
260 spin_lock(&inode->i_lock);
261 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
262 spin_unlock(&inode->i_lock);
266 void nfs_zap_acl_cache(struct inode *inode)
268 void (*clear_acl_cache)(struct inode *);
270 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
272 clear_acl_cache(inode);
273 spin_lock(&inode->i_lock);
274 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
275 spin_unlock(&inode->i_lock);
279 void nfs_invalidate_atime(struct inode *inode)
281 if (nfs_have_delegated_atime(inode))
283 spin_lock(&inode->i_lock);
284 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
285 spin_unlock(&inode->i_lock);
290 * Invalidate, but do not unhash, the inode.
291 * NB: must be called with inode->i_lock held!
293 static void nfs_set_inode_stale_locked(struct inode *inode)
295 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
296 nfs_zap_caches_locked(inode);
297 trace_nfs_set_inode_stale(inode);
300 void nfs_set_inode_stale(struct inode *inode)
302 spin_lock(&inode->i_lock);
303 nfs_set_inode_stale_locked(inode);
304 spin_unlock(&inode->i_lock);
313 * In NFSv3 we can have 64bit inode numbers. In order to support
319 nfs_find_actor(struct inode *inode, void *opaque)
325 if (NFS_FILEID(inode) != fattr->fileid)
327 if (inode_wrong_type(inode, fattr->mode))
329 if (nfs_compare_fh(NFS_FH(inode), fh))
331 if (is_bad_inode(inode) || NFS_STALE(inode))
337 nfs_init_locked(struct inode *inode, void *opaque)
342 set_nfs_fileid(inode, fattr->fileid);
343 inode->i_mode = fattr->mode;
344 nfs_copy_fh(NFS_FH(inode), desc->fh);
349 static void nfs_clear_label_invalid(struct inode *inode)
351 spin_lock(&inode->i_lock);
352 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_LABEL;
353 spin_unlock(&inode->i_lock);
356 void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr)
363 if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) && inode->i_security) {
364 error = security_inode_notifysecctx(inode, fattr->label->label,
372 nfs_clear_label_invalid(inode);
398 void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr)
404 /* Search for inode identified by fh, fileid and i_mode in inode cache. */
405 struct inode *
412 struct inode *inode;
420 inode = ilookup5(sb, hash, nfs_find_actor, &desc);
422 dprintk("%s: returning %p\n", __func__, inode);
423 return inode;
445 * instead of inode number.
447 struct inode *
454 struct inode *inode = ERR_PTR(-ENOENT);
469 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
470 if (inode == NULL) {
471 inode = ERR_PTR(-ENOMEM);
475 if (inode->i_state & I_NEW) {
476 struct nfs_inode *nfsi = NFS_I(inode);
481 inode->i_ino = hash;
484 inode->i_flags |= S_NOATIME|S_NOCMTIME;
485 inode->i_mode = fattr->mode;
489 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MODE);
493 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
494 if (S_ISREG(inode->i_mode)) {
495 inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
496 inode->i_data.a_ops = &nfs_file_aops;
498 mapping_set_large_folios(inode->i_mapping);
499 } else if (S_ISDIR(inode->i_mode)) {
500 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
501 inode->i_fop = &nfs_dir_operations;
502 inode->i_data.a_ops = &nfs_dir_aops;
508 inode->i_op = &nfs_referral_inode_operations;
510 inode->i_op = &nfs_mountpoint_inode_operations;
511 inode->i_fop = NULL;
512 inode->i_flags |= S_AUTOMOUNT;
514 } else if (S_ISLNK(inode->i_mode)) {
515 inode->i_op = &nfs_symlink_inode_operations;
516 inode_nohighmem(inode);
518 init_special_inode(inode, inode->i_mode, fattr->rdev);
520 inode_set_atime(inode, 0, 0);
521 inode_set_mtime(inode, 0, 0);
522 inode_set_ctime(inode, 0, 0);
523 inode_set_iversion_raw(inode, 0);
524 inode->i_size = 0;
525 clear_nlink(inode);
526 inode->i_uid = make_kuid(&init_user_ns, -2);
527 inode->i_gid = make_kgid(&init_user_ns, -2);
528 inode->i_blocks = 0;
535 inode_set_atime_to_ts(inode, fattr->atime);
537 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
539 inode_set_mtime_to_ts(inode, fattr->mtime);
541 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
543 inode_set_ctime_to_ts(inode, fattr->ctime);
545 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CTIME);
547 inode_set_iversion_raw(inode, fattr->change_attr);
549 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE);
551 inode->i_size = nfs_size_to_loff_t(fattr->size);
553 nfs_set_cache_invalid(inode, NFS_INO_INVALID_SIZE);
555 set_nlink(inode, fattr->nlink);
557 nfs_set_cache_invalid(inode, NFS_INO_INVALID_NLINK);
559 inode->i_uid = fattr->uid;
561 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
563 inode->i_gid = fattr->gid;
565 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
567 inode->i_blocks = fattr->du.nfs2.blocks;
570 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
575 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
578 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
580 nfs_setsecurity(inode, fattr);
582 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
586 nfs_fscache_init_inode(inode);
588 unlock_new_inode(inode);
590 int err = nfs_refresh_inode(inode, fattr);
592 iput(inode);
593 inode = ERR_PTR(err);
598 inode->i_sb->s_id,
599 (unsigned long long)NFS_FILEID(inode),
601 atomic_read(&inode->i_count));
604 return inode;
607 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
613 nfs_fattr_fixup_delegated(struct inode *inode, struct nfs_fattr *fattr)
615 unsigned long cache_validity = NFS_I(inode)->cache_validity;
617 if (nfs_have_delegated_mtime(inode)) {
628 } else if (nfs_have_delegated_atime(inode)) {
634 static void nfs_update_timestamps(struct inode *inode, unsigned int ia_valid)
647 inode_update_timestamps(inode, time_flags);
648 NFS_I(inode)->cache_validity &= ~cache_flags;
651 void nfs_update_delegated_atime(struct inode *inode)
653 spin_lock(&inode->i_lock);
654 if (nfs_have_delegated_atime(inode))
655 nfs_update_timestamps(inode, ATTR_ATIME);
656 spin_unlock(&inode->i_lock);
659 void nfs_update_delegated_mtime_locked(struct inode *inode)
661 if (nfs_have_delegated_mtime(inode))
662 nfs_update_timestamps(inode, ATTR_MTIME);
665 void nfs_update_delegated_mtime(struct inode *inode)
667 spin_lock(&inode->i_lock);
668 nfs_update_delegated_mtime_locked(inode);
669 spin_unlock(&inode->i_lock);
679 struct inode *inode = d_inode(dentry);
683 nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
690 BUG_ON(!S_ISREG(inode->i_mode));
692 error = inode_newsize_ok(inode, attr->ia_size);
696 if (attr->ia_size == i_size_read(inode))
700 if (nfs_have_delegated_mtime(inode) && attr->ia_valid & ATTR_MTIME) {
701 spin_lock(&inode->i_lock);
702 nfs_update_timestamps(inode, attr->ia_valid);
703 spin_unlock(&inode->i_lock);
705 } else if (nfs_have_delegated_atime(inode) &&
708 nfs_update_delegated_atime(inode);
716 trace_nfs_setattr_enter(inode);
719 if (S_ISREG(inode->i_mode))
720 nfs_sync_inode(inode);
722 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
728 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
730 error = nfs_refresh_inode(inode, fattr);
733 trace_nfs_setattr_exit(inode, error);
740 * @inode: inode of the file used
745 * inode->i_size to be updated under the inode->i_lock.
746 * Note: must be called with inode->i_lock held!
748 static int nfs_vmtruncate(struct inode * inode, loff_t offset)
752 err = inode_newsize_ok(inode, offset);
756 trace_nfs_size_truncate(inode, offset);
757 i_size_write(inode, offset);
760 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_DATA;
761 nfs_ooo_clear(NFS_I(inode));
763 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE;
765 spin_unlock(&inode->i_lock);
766 truncate_pagecache(inode, offset);
767 nfs_update_delegated_mtime_locked(inode);
768 spin_lock(&inode->i_lock);
774 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
775 * @inode: pointer to struct inode
782 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr,
788 spin_lock(&inode->i_lock);
789 NFS_I(inode)->attr_gencount = fattr->gencount;
791 if (!nfs_have_delegated_mtime(inode))
792 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
793 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
794 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
795 nfs_vmtruncate(inode, attr->ia_size);
798 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_CTIME;
800 inode->i_mode & S_ISUID)
801 inode->i_mode &= ~S_ISUID;
802 if (setattr_should_drop_sgid(&nop_mnt_idmap, inode))
803 inode->i_mode &= ~S_ISGID;
806 mode |= inode->i_mode & ~S_IALLUGO;
807 inode->i_mode = mode;
810 inode->i_uid = attr->ia_uid;
812 inode->i_gid = attr->ia_gid;
814 inode_set_ctime_to_ts(inode, fattr->ctime);
816 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
818 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ACCESS
822 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_ATIME
825 inode_set_atime_to_ts(inode, fattr->atime);
827 inode_set_atime_to_ts(inode, attr->ia_atime);
829 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
832 inode_set_ctime_to_ts(inode, fattr->ctime);
834 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
838 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_MTIME
841 inode_set_mtime_to_ts(inode, fattr->mtime);
843 inode_set_mtime_to_ts(inode, attr->ia_mtime);
845 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
848 inode_set_ctime_to_ts(inode, fattr->ctime);
850 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
854 nfs_update_inode(inode, fattr);
855 spin_unlock(&inode->i_lock);
863 static bool nfs_getattr_readdirplus_enable(const struct inode *inode)
865 return nfs_server_capable(inode, NFS_CAP_READDIRPLUS) &&
866 !nfs_have_writebacks(inode) && NFS_MAXATTRTIMEO(inode) > 5 * HZ;
887 static u32 nfs_get_valid_attrmask(struct inode *inode)
889 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
916 struct inode *inode = d_inode(path->dentry);
917 struct nfs_server *server = NFS_SERVER(inode);
922 bool readdirplus_enabled = nfs_getattr_readdirplus_enable(inode);
924 trace_nfs_getattr_enter(inode);
939 S_ISREG(inode->i_mode)) {
940 if (nfs_have_delegated_mtime(inode))
941 filemap_fdatawrite(inode->i_mapping);
943 filemap_write_and_wait(inode->i_mapping);
956 ((path->mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
967 do_update |= force_sync || nfs_attribute_cache_expired(inode);
968 cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
990 err = __nfs_revalidate_inode(server, inode);
997 stat->result_mask = nfs_get_valid_attrmask(inode) | request_mask;
999 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
1000 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
1001 stat->change_cookie = inode_peek_iversion_raw(inode);
1005 if (S_ISDIR(inode->i_mode))
1006 stat->blksize = NFS_SERVER(inode)->dtsize;
1008 trace_nfs_getattr_exit(inode, err);
1037 struct inode *inode = d_inode(ctx->dentry);
1047 spin_lock(&inode->i_lock);
1059 spin_unlock(&inode->i_lock);
1069 struct inode *inode = d_inode(ctx->dentry);
1071 if (!refcount_dec_and_lock(&l_ctx->count, &inode->i_lock))
1074 spin_unlock(&inode->i_lock);
1092 struct inode *inode;
1098 inode = d_inode(ctx->dentry);
1099 if (nfs_have_read_or_write_delegation(inode))
1101 nfsi = NFS_I(inode);
1102 if (inode->i_mapping->nrpages == 0)
1108 if (NFS_SERVER(inode)->flags & NFS_MOUNT_NOCTO)
1110 nfs_revalidate_inode(inode,
1156 struct inode *inode = d_inode(ctx->dentry);
1162 spin_lock(&inode->i_lock);
1164 spin_unlock(&inode->i_lock);
1166 if (inode != NULL)
1167 NFS_PROTO(inode)->close_context(ctx, is_sync);
1194 struct inode *inode = d_inode(ctx->dentry);
1195 struct nfs_inode *nfsi = NFS_I(inode);
1197 spin_lock(&inode->i_lock);
1200 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA |
1203 spin_unlock(&inode->i_lock);
1217 * Given an inode, search for an open context with the desired characteristics
1219 struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode)
1221 struct nfs_inode *nfsi = NFS_I(inode);
1245 struct inode *inode = d_inode(ctx->dentry);
1253 invalidate_inode_pages2(inode->i_mapping);
1262 int nfs_open(struct inode *inode, struct file *filp)
1272 nfs_fscache_open_file(inode, filp);
1281 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1285 struct nfs_inode *nfsi = NFS_I(inode);
1288 inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode));
1290 trace_nfs_revalidate_inode_enter(inode);
1292 if (is_bad_inode(inode))
1294 if (NFS_STALE(inode))
1298 if (S_ISREG(inode->i_mode)) {
1299 status = pnfs_sync_inode(inode, false);
1305 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
1309 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
1311 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, inode);
1314 inode->i_sb->s_id,
1315 (unsigned long long)NFS_FILEID(inode), status);
1323 if (!S_ISDIR(inode->i_mode))
1324 nfs_set_inode_stale(inode);
1326 nfs_zap_caches(inode);
1331 status = nfs_refresh_inode(inode, fattr);
1334 inode->i_sb->s_id,
1335 (unsigned long long)NFS_FILEID(inode), status);
1340 nfs_zap_acl_cache(inode);
1342 nfs_setsecurity(inode, fattr);
1345 inode->i_sb->s_id,
1346 (unsigned long long)NFS_FILEID(inode));
1350 trace_nfs_revalidate_inode_exit(inode, status);
1354 int nfs_attribute_cache_expired(struct inode *inode)
1356 if (nfs_have_delegated_attributes(inode))
1358 return nfs_attribute_timeout(inode);
1362 * nfs_revalidate_inode - Revalidate the inode attributes
1363 * @inode: pointer to inode struct
1366 * Updates inode attribute information by retrieving the data from the server.
1368 int nfs_revalidate_inode(struct inode *inode, unsigned long flags)
1370 if (!nfs_check_cache_invalid(inode, flags))
1371 return NFS_STALE(inode) ? -ESTALE : 0;
1372 return __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1376 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
1380 nfs_fscache_invalidate(inode, 0);
1382 if (S_ISREG(inode->i_mode)) {
1391 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
1394 inode->i_sb->s_id,
1395 (unsigned long long)NFS_FILEID(inode));
1403 * If the NFS_INO_INVALID_DATA inode flag is set, clear the mapping.
1407 struct inode *inode = mapping->host;
1408 struct nfs_inode *nfsi = NFS_I(inode);
1437 spin_lock(&inode->i_lock);
1439 spin_unlock(&inode->i_lock);
1444 spin_unlock(&inode->i_lock);
1452 spin_unlock(&inode->i_lock);
1453 trace_nfs_invalidate_mapping_enter(inode);
1454 ret = nfs_invalidate_mapping(inode, mapping);
1455 trace_nfs_invalidate_mapping_exit(inode, ret);
1464 bool nfs_mapping_need_revalidate_inode(struct inode *inode)
1466 return nfs_check_cache_invalid(inode, NFS_INO_INVALID_CHANGE) ||
1467 NFS_STALE(inode);
1470 int nfs_revalidate_mapping_rcu(struct inode *inode)
1472 struct nfs_inode *nfsi = NFS_I(inode);
1476 if (IS_SWAPFILE(inode))
1478 if (nfs_mapping_need_revalidate_inode(inode)) {
1482 spin_lock(&inode->i_lock);
1486 spin_unlock(&inode->i_lock);
1493 * @inode: pointer to host inode
1496 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
1499 if (IS_SWAPFILE(inode))
1502 if (nfs_mapping_need_revalidate_inode(inode)) {
1503 int ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1513 struct inode *inode = &nfsi->vfs_inode;
1515 if (!S_ISREG(inode->i_mode))
1519 return inode_is_open_for_write(inode);
1527 static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1533 && inode_eq_iversion_raw(inode, fattr->pre_change_attr)) {
1534 inode_set_iversion_raw(inode, fattr->change_attr);
1535 if (S_ISDIR(inode->i_mode))
1536 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
1537 else if (nfs_server_capable(inode, NFS_CAP_XATTR))
1538 nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR);
1541 ts = inode_get_ctime(inode);
1545 inode_set_ctime_to_ts(inode, fattr->ctime);
1548 ts = inode_get_mtime(inode);
1552 inode_set_mtime_to_ts(inode, fattr->mtime);
1556 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
1557 && !nfs_have_writebacks(inode)) {
1558 trace_nfs_size_wcc(inode, fattr->size);
1559 i_size_write(inode, nfs_size_to_loff_t(fattr->size));
1564 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
1565 * @inode: pointer to inode
1572 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
1574 struct nfs_inode *nfsi = NFS_I(inode);
1579 if (nfs_have_delegated_attributes(inode))
1586 /* Has the inode gone and changed behind our back? */
1594 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode))
1600 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && !inode_eq_iversion_raw(inode, fattr->change_attr))
1603 ts = inode_get_mtime(inode);
1607 ts = inode_get_ctime(inode);
1612 cur_size = i_size_read(inode);
1620 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
1622 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))
1624 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))
1628 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
1631 ts = inode_get_atime(inode);
1636 nfs_set_cache_invalid(inode, invalid);
1789 * @inode: pointer to inode
1796 * more recent than the ones cached in @inode. Otherwise it returns
1800 const struct inode *inode)
1802 unsigned long attr_gencount = NFS_I(inode)->attr_gencount;
1811 * @inode: pointer to inode
1821 * A return value of '-1' means that the attributes in @inode are
1825 const struct inode *inode)
1827 s64 diff = fattr->change_attr - inode_peek_iversion_raw(inode);
1836 * @inode: pointer to inode
1845 * A return value of '-1' means that the attributes in @inode are
1849 const struct inode *inode)
1851 return nfs_inode_attrs_cmp_monotonic(fattr, inode) > 0 ? 1 : -1;
1857 * @inode: pointer to inode
1860 * more recent than the ones cached in @inode. It returns '-1' if
1861 * the attributes in @inode are more recent than the ones in @fattr,
1865 const struct inode *inode)
1867 if (nfs_inode_attrs_cmp_generic(fattr, inode) > 0)
1869 switch (NFS_SERVER(inode)->change_attr_type) {
1875 return nfs_inode_attrs_cmp_monotonic(fattr, inode);
1879 return nfs_inode_attrs_cmp_strict_monotonic(fattr, inode);
1885 * nfs_inode_finish_partial_attr_update - complete a previous inode update
1887 * @inode: pointer to inode
1889 * Returns '1' if the last attribute update left the inode cached
1895 const struct inode *inode)
1902 unsigned long cache_validity = NFS_I(inode)->cache_validity;
1903 enum nfs4_change_attr_type ctype = NFS_SERVER(inode)->change_attr_type;
1909 nfs_inode_attrs_cmp_monotonic(fattr, inode) == 0)
1974 static int nfs_refresh_inode_locked(struct inode *inode,
1977 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
1980 trace_nfs_refresh_inode_enter(inode);
1982 if (attr_cmp > 0 || nfs_inode_finish_partial_attr_update(fattr, inode))
1983 ret = nfs_update_inode(inode, fattr);
1985 nfs_ooo_record(NFS_I(inode), fattr);
1988 ret = nfs_check_inode_attributes(inode, fattr);
1991 trace_nfs_refresh_inode_exit(inode, ret);
1996 * nfs_refresh_inode - try to update the inode attribute cache
1997 * @inode: pointer to inode
2001 * other recent updates of the inode metadata, then decide whether it is
2002 * safe to do a full update of the inode attributes, or whether just to
2005 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
2011 spin_lock(&inode->i_lock);
2012 status = nfs_refresh_inode_locked(inode, fattr);
2013 spin_unlock(&inode->i_lock);
2019 static int nfs_post_op_update_inode_locked(struct inode *inode,
2022 if (S_ISDIR(inode->i_mode))
2024 nfs_set_cache_invalid(inode, invalid);
2027 return nfs_refresh_inode_locked(inode, fattr);
2031 * nfs_post_op_update_inode - try to update the inode attribute cache
2032 * @inode: pointer to inode
2035 * After an operation that has changed the inode metadata, mark the
2044 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
2048 spin_lock(&inode->i_lock);
2050 status = nfs_post_op_update_inode_locked(inode, fattr,
2054 spin_unlock(&inode->i_lock);
2061 * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache
2062 * @inode: pointer to inode
2065 * After an operation that has changed the inode metadata, mark the
2071 int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr)
2073 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
2081 nfs_ooo_record(NFS_I(inode), fattr);
2090 fattr->pre_change_attr = inode_peek_iversion_raw(inode);
2095 fattr->pre_ctime = inode_get_ctime(inode);
2100 fattr->pre_mtime = inode_get_mtime(inode);
2105 fattr->pre_size = i_size_read(inode);
2109 status = nfs_post_op_update_inode_locked(inode, fattr,
2118 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
2119 * @inode: pointer to inode
2122 * After an operation that has changed the inode metadata, mark the
2128 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
2132 spin_lock(&inode->i_lock);
2134 status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
2135 spin_unlock(&inode->i_lock);
2143 * an operation. Here we update the inode to reflect the state
2144 * of the server's inode.
2153 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
2155 struct nfs_server *server = NFS_SERVER(inode);
2156 struct nfs_inode *nfsi = NFS_I(inode);
2168 __func__, inode->i_sb->s_id, inode->i_ino,
2169 nfs_display_fhandle_hash(NFS_FH(inode)),
2170 atomic_read(&inode->i_count), fattr->valid);
2176 /* Has the inode gone and changed behind our back? */
2184 NFS_SERVER(inode)->nfs_client->cl_hostname,
2185 inode->i_sb->s_id, (long long)nfsi->fileid,
2191 * Make sure the inode's type hasn't changed.
2193 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) {
2195 * Big trouble! The inode has become a different object.
2197 printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
2198 __func__, inode->i_ino, inode->i_mode, fattr->mode);
2203 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
2205 !IS_AUTOMOUNT(inode))
2209 have_delegation = nfs_have_delegated_attributes(inode);
2217 nfs_fattr_fixup_delegated(inode, fattr);
2226 nfs_wcc_update_inode(inode, fattr);
2228 if (pnfs_layoutcommit_outstanding(inode)) {
2240 nfsi->ooo->gap[0].end == inode_peek_iversion_raw(inode)) {
2244 inode_set_iversion_raw(inode, nfsi->ooo->gap[0].start);
2248 if (!inode_eq_iversion_raw(inode, fattr->change_attr)) {
2263 if (S_ISDIR(inode->i_mode))
2264 nfs_force_lookup_revalidate(inode);
2267 inode->i_sb->s_id,
2268 inode->i_ino);
2271 nfs_ooo_merge(nfsi, inode_peek_iversion_raw(inode),
2274 inode_set_iversion_raw(inode, fattr->change_attr);
2285 inode_set_mtime_to_ts(inode, fattr->mtime);
2291 inode_set_ctime_to_ts(inode, fattr->ctime);
2299 cur_isize = i_size_read(inode);
2303 if (!nfs_have_writebacks(inode) || new_isize > cur_isize) {
2304 trace_nfs_size_update(inode, new_isize);
2305 i_size_write(inode, new_isize);
2321 inode_set_atime_to_ts(inode, fattr->atime);
2327 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
2328 umode_t newmode = inode->i_mode & S_IFMT;
2330 inode->i_mode = newmode;
2339 if (!uid_eq(inode->i_uid, fattr->uid)) {
2342 inode->i_uid = fattr->uid;
2349 if (!gid_eq(inode->i_gid, fattr->gid)) {
2352 inode->i_gid = fattr->gid;
2359 if (inode->i_nlink != fattr->nlink)
2360 set_nlink(inode, fattr->nlink);
2369 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
2375 inode->i_blocks = fattr->du.nfs2.blocks;
2382 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
2383 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
2392 if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode))
2393 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
2403 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
2404 || S_ISLNK(inode->i_mode)))
2406 nfs_set_cache_invalid(inode, invalid);
2412 * lookup validation will know that the inode is bad.
2415 nfs_set_inode_stale_locked(inode);
2419 struct inode *nfs_alloc_inode(struct super_block *sb)
2440 void nfs_free_inode(struct inode *inode)
2442 kfree(NFS_I(inode)->ooo);
2443 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));