Lines Matching refs: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);
193 bool have_delegation = NFS_PROTO(inode)->have_delegation(inode, FMODE_READ);
206 nfs_fscache_invalidate(inode, 0);
211 if (inode->i_mapping->nrpages == 0) {
217 trace_nfs_set_cache_invalid(inode, 0);
224 static void nfs_zap_caches_locked(struct inode *inode)
226 struct nfs_inode *nfsi = NFS_I(inode);
227 int mode = inode->i_mode;
229 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
231 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
235 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR |
241 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR |
248 void nfs_zap_caches(struct inode *inode)
250 spin_lock(&inode->i_lock);
251 nfs_zap_caches_locked(inode);
252 spin_unlock(&inode->i_lock);
255 void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
258 spin_lock(&inode->i_lock);
259 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
260 spin_unlock(&inode->i_lock);
264 void nfs_zap_acl_cache(struct inode *inode)
266 void (*clear_acl_cache)(struct inode *);
268 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
270 clear_acl_cache(inode);
271 spin_lock(&inode->i_lock);
272 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
273 spin_unlock(&inode->i_lock);
277 void nfs_invalidate_atime(struct inode *inode)
279 spin_lock(&inode->i_lock);
280 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
281 spin_unlock(&inode->i_lock);
286 * Invalidate, but do not unhash, the inode.
287 * NB: must be called with inode->i_lock held!
289 static void nfs_set_inode_stale_locked(struct inode *inode)
291 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
292 nfs_zap_caches_locked(inode);
293 trace_nfs_set_inode_stale(inode);
296 void nfs_set_inode_stale(struct inode *inode)
298 spin_lock(&inode->i_lock);
299 nfs_set_inode_stale_locked(inode);
300 spin_unlock(&inode->i_lock);
309 * In NFSv3 we can have 64bit inode numbers. In order to support
315 nfs_find_actor(struct inode *inode, void *opaque)
321 if (NFS_FILEID(inode) != fattr->fileid)
323 if (inode_wrong_type(inode, fattr->mode))
325 if (nfs_compare_fh(NFS_FH(inode), fh))
327 if (is_bad_inode(inode) || NFS_STALE(inode))
333 nfs_init_locked(struct inode *inode, void *opaque)
338 set_nfs_fileid(inode, fattr->fileid);
339 inode->i_mode = fattr->mode;
340 nfs_copy_fh(NFS_FH(inode), desc->fh);
345 static void nfs_clear_label_invalid(struct inode *inode)
347 spin_lock(&inode->i_lock);
348 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_LABEL;
349 spin_unlock(&inode->i_lock);
352 void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr)
359 if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) && inode->i_security) {
360 error = security_inode_notifysecctx(inode, fattr->label->label,
368 nfs_clear_label_invalid(inode);
394 void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr)
400 /* Search for inode identified by fh, fileid and i_mode in inode cache. */
401 struct inode *
408 struct inode *inode;
416 inode = ilookup5(sb, hash, nfs_find_actor, &desc);
418 dprintk("%s: returning %p\n", __func__, inode);
419 return inode;
441 * instead of inode number.
443 struct inode *
450 struct inode *inode = ERR_PTR(-ENOENT);
465 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
466 if (inode == NULL) {
467 inode = ERR_PTR(-ENOMEM);
471 if (inode->i_state & I_NEW) {
472 struct nfs_inode *nfsi = NFS_I(inode);
477 inode->i_ino = hash;
480 inode->i_flags |= S_NOATIME|S_NOCMTIME;
481 inode->i_mode = fattr->mode;
485 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MODE);
489 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
490 if (S_ISREG(inode->i_mode)) {
491 inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
492 inode->i_data.a_ops = &nfs_file_aops;
494 } else if (S_ISDIR(inode->i_mode)) {
495 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
496 inode->i_fop = &nfs_dir_operations;
497 inode->i_data.a_ops = &nfs_dir_aops;
503 inode->i_op = &nfs_referral_inode_operations;
505 inode->i_op = &nfs_mountpoint_inode_operations;
506 inode->i_fop = NULL;
507 inode->i_flags |= S_AUTOMOUNT;
509 } else if (S_ISLNK(inode->i_mode)) {
510 inode->i_op = &nfs_symlink_inode_operations;
511 inode_nohighmem(inode);
513 init_special_inode(inode, inode->i_mode, fattr->rdev);
515 memset(&inode->i_atime, 0, sizeof(inode->i_atime));
516 memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
517 inode_set_ctime(inode, 0, 0);
518 inode_set_iversion_raw(inode, 0);
519 inode->i_size = 0;
520 clear_nlink(inode);
521 inode->i_uid = make_kuid(&init_user_ns, -2);
522 inode->i_gid = make_kgid(&init_user_ns, -2);
523 inode->i_blocks = 0;
530 inode->i_atime = fattr->atime;
532 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
534 inode->i_mtime = fattr->mtime;
536 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
538 inode_set_ctime_to_ts(inode, fattr->ctime);
540 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CTIME);
542 inode_set_iversion_raw(inode, fattr->change_attr);
544 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE);
546 inode->i_size = nfs_size_to_loff_t(fattr->size);
548 nfs_set_cache_invalid(inode, NFS_INO_INVALID_SIZE);
550 set_nlink(inode, fattr->nlink);
552 nfs_set_cache_invalid(inode, NFS_INO_INVALID_NLINK);
554 inode->i_uid = fattr->uid;
556 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
558 inode->i_gid = fattr->gid;
560 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
562 inode->i_blocks = fattr->du.nfs2.blocks;
565 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
570 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
573 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
575 nfs_setsecurity(inode, fattr);
577 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
581 nfs_fscache_init_inode(inode);
583 unlock_new_inode(inode);
585 int err = nfs_refresh_inode(inode, fattr);
587 iput(inode);
588 inode = ERR_PTR(err);
593 inode->i_sb->s_id,
594 (unsigned long long)NFS_FILEID(inode),
596 atomic_read(&inode->i_count));
599 return inode;
602 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
613 struct inode *inode = d_inode(dentry);
617 nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
624 BUG_ON(!S_ISREG(inode->i_mode));
626 error = inode_newsize_ok(inode, attr->ia_size);
630 if (attr->ia_size == i_size_read(inode))
638 trace_nfs_setattr_enter(inode);
641 if (S_ISREG(inode->i_mode))
642 nfs_sync_inode(inode);
644 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
650 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
652 error = nfs_refresh_inode(inode, fattr);
655 trace_nfs_setattr_exit(inode, error);
662 * @inode: inode of the file used
667 * inode->i_size to be updated under the inode->i_lock.
668 * Note: must be called with inode->i_lock held!
670 static int nfs_vmtruncate(struct inode * inode, loff_t offset)
674 err = inode_newsize_ok(inode, offset);
678 trace_nfs_size_truncate(inode, offset);
679 i_size_write(inode, offset);
682 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_DATA;
683 nfs_ooo_clear(NFS_I(inode));
685 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE;
687 spin_unlock(&inode->i_lock);
688 truncate_pagecache(inode, offset);
689 spin_lock(&inode->i_lock);
695 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
696 * @inode: pointer to struct inode
703 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr,
709 spin_lock(&inode->i_lock);
710 NFS_I(inode)->attr_gencount = fattr->gencount;
712 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME |
714 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
715 nfs_vmtruncate(inode, attr->ia_size);
718 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_CTIME;
720 inode->i_mode & S_ISUID)
721 inode->i_mode &= ~S_ISUID;
722 if (setattr_should_drop_sgid(&nop_mnt_idmap, inode))
723 inode->i_mode &= ~S_ISGID;
726 mode |= inode->i_mode & ~S_IALLUGO;
727 inode->i_mode = mode;
730 inode->i_uid = attr->ia_uid;
732 inode->i_gid = attr->ia_gid;
734 inode_set_ctime_to_ts(inode, fattr->ctime);
736 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
738 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ACCESS
742 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_ATIME
745 inode->i_atime = fattr->atime;
747 inode->i_atime = attr->ia_atime;
749 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
752 inode_set_ctime_to_ts(inode, fattr->ctime);
754 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
758 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_MTIME
761 inode->i_mtime = fattr->mtime;
763 inode->i_mtime = attr->ia_mtime;
765 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
768 inode_set_ctime_to_ts(inode, fattr->ctime);
770 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
774 nfs_update_inode(inode, fattr);
775 spin_unlock(&inode->i_lock);
783 static bool nfs_getattr_readdirplus_enable(const struct inode *inode)
785 return nfs_server_capable(inode, NFS_CAP_READDIRPLUS) &&
786 !nfs_have_writebacks(inode) && NFS_MAXATTRTIMEO(inode) > 5 * HZ;
807 static u32 nfs_get_valid_attrmask(struct inode *inode)
809 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
836 struct inode *inode = d_inode(path->dentry);
837 struct nfs_server *server = NFS_SERVER(inode);
842 bool readdirplus_enabled = nfs_getattr_readdirplus_enable(inode);
844 trace_nfs_getattr_enter(inode);
859 S_ISREG(inode->i_mode))
860 filemap_write_and_wait(inode->i_mapping);
872 ((path->mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
883 do_update |= force_sync || nfs_attribute_cache_expired(inode);
884 cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
906 err = __nfs_revalidate_inode(server, inode);
913 stat->result_mask = nfs_get_valid_attrmask(inode) | request_mask;
915 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
916 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
917 stat->change_cookie = inode_peek_iversion_raw(inode);
921 if (S_ISDIR(inode->i_mode))
922 stat->blksize = NFS_SERVER(inode)->dtsize;
924 trace_nfs_getattr_exit(inode, err);
953 struct inode *inode = d_inode(ctx->dentry);
963 spin_lock(&inode->i_lock);
975 spin_unlock(&inode->i_lock);
985 struct inode *inode = d_inode(ctx->dentry);
987 if (!refcount_dec_and_lock(&l_ctx->count, &inode->i_lock))
990 spin_unlock(&inode->i_lock);
1008 struct inode *inode;
1014 inode = d_inode(ctx->dentry);
1015 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1017 nfsi = NFS_I(inode);
1018 if (inode->i_mapping->nrpages == 0)
1024 if (NFS_SERVER(inode)->flags & NFS_MOUNT_NOCTO)
1026 nfs_revalidate_inode(inode,
1070 struct inode *inode = d_inode(ctx->dentry);
1076 spin_lock(&inode->i_lock);
1078 spin_unlock(&inode->i_lock);
1080 if (inode != NULL)
1081 NFS_PROTO(inode)->close_context(ctx, is_sync);
1107 struct inode *inode = d_inode(ctx->dentry);
1108 struct nfs_inode *nfsi = NFS_I(inode);
1110 spin_lock(&inode->i_lock);
1113 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA |
1116 spin_unlock(&inode->i_lock);
1130 * Given an inode, search for an open context with the desired characteristics
1132 struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode)
1134 struct nfs_inode *nfsi = NFS_I(inode);
1158 struct inode *inode = d_inode(ctx->dentry);
1166 invalidate_inode_pages2(inode->i_mapping);
1175 int nfs_open(struct inode *inode, struct file *filp)
1185 nfs_fscache_open_file(inode, filp);
1194 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1198 struct nfs_inode *nfsi = NFS_I(inode);
1201 inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode));
1203 trace_nfs_revalidate_inode_enter(inode);
1205 if (is_bad_inode(inode))
1207 if (NFS_STALE(inode))
1211 if (S_ISREG(inode->i_mode)) {
1212 status = pnfs_sync_inode(inode, false);
1218 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
1222 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
1224 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, inode);
1227 inode->i_sb->s_id,
1228 (unsigned long long)NFS_FILEID(inode), status);
1236 if (!S_ISDIR(inode->i_mode))
1237 nfs_set_inode_stale(inode);
1239 nfs_zap_caches(inode);
1244 status = nfs_refresh_inode(inode, fattr);
1247 inode->i_sb->s_id,
1248 (unsigned long long)NFS_FILEID(inode), status);
1253 nfs_zap_acl_cache(inode);
1255 nfs_setsecurity(inode, fattr);
1258 inode->i_sb->s_id,
1259 (unsigned long long)NFS_FILEID(inode));
1263 trace_nfs_revalidate_inode_exit(inode, status);
1267 int nfs_attribute_cache_expired(struct inode *inode)
1269 if (nfs_have_delegated_attributes(inode))
1271 return nfs_attribute_timeout(inode);
1275 * nfs_revalidate_inode - Revalidate the inode attributes
1276 * @inode: pointer to inode struct
1279 * Updates inode attribute information by retrieving the data from the server.
1281 int nfs_revalidate_inode(struct inode *inode, unsigned long flags)
1283 if (!nfs_check_cache_invalid(inode, flags))
1284 return NFS_STALE(inode) ? -ESTALE : 0;
1285 return __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1289 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
1293 nfs_fscache_invalidate(inode, 0);
1295 if (S_ISREG(inode->i_mode)) {
1304 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
1307 inode->i_sb->s_id,
1308 (unsigned long long)NFS_FILEID(inode));
1316 * If the NFS_INO_INVALID_DATA inode flag is set, clear the mapping.
1320 struct inode *inode = mapping->host;
1321 struct nfs_inode *nfsi = NFS_I(inode);
1343 spin_lock(&inode->i_lock);
1345 spin_unlock(&inode->i_lock);
1350 spin_unlock(&inode->i_lock);
1358 spin_unlock(&inode->i_lock);
1359 trace_nfs_invalidate_mapping_enter(inode);
1360 ret = nfs_invalidate_mapping(inode, mapping);
1361 trace_nfs_invalidate_mapping_exit(inode, ret);
1370 bool nfs_mapping_need_revalidate_inode(struct inode *inode)
1372 return nfs_check_cache_invalid(inode, NFS_INO_INVALID_CHANGE) ||
1373 NFS_STALE(inode);
1376 int nfs_revalidate_mapping_rcu(struct inode *inode)
1378 struct nfs_inode *nfsi = NFS_I(inode);
1382 if (IS_SWAPFILE(inode))
1384 if (nfs_mapping_need_revalidate_inode(inode)) {
1388 spin_lock(&inode->i_lock);
1392 spin_unlock(&inode->i_lock);
1399 * @inode: pointer to host inode
1402 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
1405 if (IS_SWAPFILE(inode))
1408 if (nfs_mapping_need_revalidate_inode(inode)) {
1409 int ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1419 struct inode *inode = &nfsi->vfs_inode;
1421 if (!S_ISREG(inode->i_mode))
1425 return inode_is_open_for_write(inode);
1433 static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1439 && inode_eq_iversion_raw(inode, fattr->pre_change_attr)) {
1440 inode_set_iversion_raw(inode, fattr->change_attr);
1441 if (S_ISDIR(inode->i_mode))
1442 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
1443 else if (nfs_server_capable(inode, NFS_CAP_XATTR))
1444 nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR);
1447 ts = inode_get_ctime(inode);
1451 inode_set_ctime_to_ts(inode, fattr->ctime);
1454 ts = inode->i_mtime;
1458 inode->i_mtime = fattr->mtime;
1462 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
1463 && !nfs_have_writebacks(inode)) {
1464 trace_nfs_size_wcc(inode, fattr->size);
1465 i_size_write(inode, nfs_size_to_loff_t(fattr->size));
1470 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
1471 * @inode: pointer to inode
1478 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
1480 struct nfs_inode *nfsi = NFS_I(inode);
1485 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1492 /* Has the inode gone and changed behind our back? */
1500 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode))
1506 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && !inode_eq_iversion_raw(inode, fattr->change_attr))
1509 ts = inode->i_mtime;
1513 ts = inode_get_ctime(inode);
1518 cur_size = i_size_read(inode);
1526 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
1528 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))
1530 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))
1534 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
1537 ts = inode->i_atime;
1542 nfs_set_cache_invalid(inode, invalid);
1694 * @inode: pointer to inode
1701 * more recent than the ones cached in @inode. Otherwise it returns
1705 const struct inode *inode)
1707 unsigned long attr_gencount = NFS_I(inode)->attr_gencount;
1716 * @inode: pointer to inode
1726 * A return value of '-1' means that the attributes in @inode are
1730 const struct inode *inode)
1732 s64 diff = fattr->change_attr - inode_peek_iversion_raw(inode);
1741 * @inode: pointer to inode
1750 * A return value of '-1' means that the attributes in @inode are
1754 const struct inode *inode)
1756 return nfs_inode_attrs_cmp_monotonic(fattr, inode) > 0 ? 1 : -1;
1762 * @inode: pointer to inode
1765 * more recent than the ones cached in @inode. It returns '-1' if
1766 * the attributes in @inode are more recent than the ones in @fattr,
1770 const struct inode *inode)
1772 if (nfs_inode_attrs_cmp_generic(fattr, inode) > 0)
1774 switch (NFS_SERVER(inode)->change_attr_type) {
1780 return nfs_inode_attrs_cmp_monotonic(fattr, inode);
1784 return nfs_inode_attrs_cmp_strict_monotonic(fattr, inode);
1790 * nfs_inode_finish_partial_attr_update - complete a previous inode update
1792 * @inode: pointer to inode
1794 * Returns '1' if the last attribute update left the inode cached
1800 const struct inode *inode)
1807 unsigned long cache_validity = NFS_I(inode)->cache_validity;
1808 enum nfs4_change_attr_type ctype = NFS_SERVER(inode)->change_attr_type;
1814 nfs_inode_attrs_cmp_monotonic(fattr, inode) == 0)
1879 static int nfs_refresh_inode_locked(struct inode *inode,
1882 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
1885 trace_nfs_refresh_inode_enter(inode);
1887 if (attr_cmp > 0 || nfs_inode_finish_partial_attr_update(fattr, inode))
1888 ret = nfs_update_inode(inode, fattr);
1890 nfs_ooo_record(NFS_I(inode), fattr);
1893 ret = nfs_check_inode_attributes(inode, fattr);
1896 trace_nfs_refresh_inode_exit(inode, ret);
1901 * nfs_refresh_inode - try to update the inode attribute cache
1902 * @inode: pointer to inode
1906 * other recent updates of the inode metadata, then decide whether it is
1907 * safe to do a full update of the inode attributes, or whether just to
1910 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1916 spin_lock(&inode->i_lock);
1917 status = nfs_refresh_inode_locked(inode, fattr);
1918 spin_unlock(&inode->i_lock);
1924 static int nfs_post_op_update_inode_locked(struct inode *inode,
1927 if (S_ISDIR(inode->i_mode))
1929 nfs_set_cache_invalid(inode, invalid);
1932 return nfs_refresh_inode_locked(inode, fattr);
1936 * nfs_post_op_update_inode - try to update the inode attribute cache
1937 * @inode: pointer to inode
1940 * After an operation that has changed the inode metadata, mark the
1949 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1953 spin_lock(&inode->i_lock);
1955 status = nfs_post_op_update_inode_locked(inode, fattr,
1959 spin_unlock(&inode->i_lock);
1966 * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache
1967 * @inode: pointer to inode
1970 * After an operation that has changed the inode metadata, mark the
1976 int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr)
1978 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
1986 nfs_ooo_record(NFS_I(inode), fattr);
1995 fattr->pre_change_attr = inode_peek_iversion_raw(inode);
2000 fattr->pre_ctime = inode_get_ctime(inode);
2005 fattr->pre_mtime = inode->i_mtime;
2010 fattr->pre_size = i_size_read(inode);
2014 status = nfs_post_op_update_inode_locked(inode, fattr,
2023 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
2024 * @inode: pointer to inode
2027 * After an operation that has changed the inode metadata, mark the
2033 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
2037 spin_lock(&inode->i_lock);
2039 status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
2040 spin_unlock(&inode->i_lock);
2048 * an operation. Here we update the inode to reflect the state
2049 * of the server's inode.
2058 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
2060 struct nfs_server *server = NFS_SERVER(inode);
2061 struct nfs_inode *nfsi = NFS_I(inode);
2073 __func__, inode->i_sb->s_id, inode->i_ino,
2074 nfs_display_fhandle_hash(NFS_FH(inode)),
2075 atomic_read(&inode->i_count), fattr->valid);
2081 /* Has the inode gone and changed behind our back? */
2089 NFS_SERVER(inode)->nfs_client->cl_hostname,
2090 inode->i_sb->s_id, (long long)nfsi->fileid,
2096 * Make sure the inode's type hasn't changed.
2098 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) {
2100 * Big trouble! The inode has become a different object.
2102 printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
2103 __func__, inode->i_ino, inode->i_mode, fattr->mode);
2108 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
2110 !IS_AUTOMOUNT(inode))
2114 have_delegation = nfs_have_delegated_attributes(inode);
2128 nfs_wcc_update_inode(inode, fattr);
2130 if (pnfs_layoutcommit_outstanding(inode)) {
2142 nfsi->ooo->gap[0].end == inode_peek_iversion_raw(inode)) {
2146 inode_set_iversion_raw(inode, nfsi->ooo->gap[0].start);
2150 if (!inode_eq_iversion_raw(inode, fattr->change_attr)) {
2165 if (S_ISDIR(inode->i_mode))
2166 nfs_force_lookup_revalidate(inode);
2169 inode->i_sb->s_id,
2170 inode->i_ino);
2173 nfs_ooo_merge(nfsi, inode_peek_iversion_raw(inode),
2176 inode_set_iversion_raw(inode, fattr->change_attr);
2187 inode->i_mtime = fattr->mtime;
2193 inode_set_ctime_to_ts(inode, fattr->ctime);
2201 cur_isize = i_size_read(inode);
2205 if (!nfs_have_writebacks(inode) || new_isize > cur_isize) {
2206 trace_nfs_size_update(inode, new_isize);
2207 i_size_write(inode, new_isize);
2223 inode->i_atime = fattr->atime;
2229 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
2230 umode_t newmode = inode->i_mode & S_IFMT;
2232 inode->i_mode = newmode;
2241 if (!uid_eq(inode->i_uid, fattr->uid)) {
2244 inode->i_uid = fattr->uid;
2251 if (!gid_eq(inode->i_gid, fattr->gid)) {
2254 inode->i_gid = fattr->gid;
2261 if (inode->i_nlink != fattr->nlink)
2262 set_nlink(inode, fattr->nlink);
2271 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
2277 inode->i_blocks = fattr->du.nfs2.blocks;
2284 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
2285 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
2294 if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode))
2295 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
2305 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
2306 || S_ISLNK(inode->i_mode)))
2308 nfs_set_cache_invalid(inode, invalid);
2314 * lookup validation will know that the inode is bad.
2317 nfs_set_inode_stale_locked(inode);
2321 struct inode *nfs_alloc_inode(struct super_block *sb)
2342 void nfs_free_inode(struct inode *inode)
2344 kfree(NFS_I(inode)->ooo);
2345 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));