RETURN(rc);
}
-int ll_merge_lvb(const struct lu_env *env, struct inode *inode)
+int ll_merge_attr(const struct lu_env *env, struct inode *inode)
{
struct ll_inode_info *lli = ll_i2info(inode);
struct cl_object *obj = lli->lli_clob;
struct cl_attr *attr = ccc_env_thread_attr(env);
- struct ost_lvb lvb;
+ obd_time atime;
+ obd_time mtime;
+ obd_time ctime;
int rc = 0;
ENTRY;
ll_inode_size_lock(inode);
+
/* merge timestamps the most recently obtained from mds with
timestamps obtained from osts */
- LTIME_S(inode->i_atime) = lli->lli_lvb.lvb_atime;
- LTIME_S(inode->i_mtime) = lli->lli_lvb.lvb_mtime;
- LTIME_S(inode->i_ctime) = lli->lli_lvb.lvb_ctime;
+ LTIME_S(inode->i_atime) = lli->lli_atime;
+ LTIME_S(inode->i_mtime) = lli->lli_mtime;
+ LTIME_S(inode->i_ctime) = lli->lli_ctime;
- lvb.lvb_size = i_size_read(inode);
- lvb.lvb_blocks = inode->i_blocks;
- lvb.lvb_mtime = LTIME_S(inode->i_mtime);
- lvb.lvb_atime = LTIME_S(inode->i_atime);
- lvb.lvb_ctime = LTIME_S(inode->i_ctime);
+ atime = LTIME_S(inode->i_atime);
+ mtime = LTIME_S(inode->i_mtime);
+ ctime = LTIME_S(inode->i_ctime);
cl_object_attr_lock(obj);
rc = cl_object_attr_get(env, obj, attr);
cl_object_attr_unlock(obj);
- if (rc == 0) {
- if (lvb.lvb_atime < attr->cat_atime)
- lvb.lvb_atime = attr->cat_atime;
- if (lvb.lvb_ctime < attr->cat_ctime)
- lvb.lvb_ctime = attr->cat_ctime;
- if (lvb.lvb_mtime < attr->cat_mtime)
- lvb.lvb_mtime = attr->cat_mtime;
+ if (rc != 0)
+ GOTO(out_size_unlock, rc);
- CDEBUG(D_VFSTRACE, DFID" updating i_size "LPU64"\n",
- PFID(&lli->lli_fid), attr->cat_size);
- cl_isize_write_nolock(inode, attr->cat_size);
+ if (atime < attr->cat_atime)
+ atime = attr->cat_atime;
- inode->i_blocks = attr->cat_blocks;
+ if (ctime < attr->cat_ctime)
+ ctime = attr->cat_ctime;
- LTIME_S(inode->i_mtime) = lvb.lvb_mtime;
- LTIME_S(inode->i_atime) = lvb.lvb_atime;
- LTIME_S(inode->i_ctime) = lvb.lvb_ctime;
- }
+ if (mtime < attr->cat_mtime)
+ mtime = attr->cat_mtime;
+
+ CDEBUG(D_VFSTRACE, DFID" updating i_size "LPU64"\n",
+ PFID(&lli->lli_fid), attr->cat_size);
+
+ cl_isize_write_nolock(inode, attr->cat_size);
+ inode->i_blocks = attr->cat_blocks;
+
+ LTIME_S(inode->i_atime) = atime;
+ LTIME_S(inode->i_mtime) = mtime;
+ LTIME_S(inode->i_ctime) = ctime;
+
+out_size_unlock:
ll_inode_size_unlock(inode);
RETURN(rc);
if (IS_ERR(env))
GOTO(out, rc = PTR_ERR(env));
- ll_merge_lvb(env, inode);
+ ll_merge_attr(env, inode);
cl_env_nested_put(&nest, env);
/* Release the file.
ll_i2info(inode)->lli_stripe_dir_size = attr.cat_size;
ll_i2info(inode)->lli_stripe_dir_nlink = attr.cat_nlink;
- ll_i2info(inode)->lli_lvb.lvb_atime = attr.cat_atime;
- ll_i2info(inode)->lli_lvb.lvb_mtime = attr.cat_mtime;
- ll_i2info(inode)->lli_lvb.lvb_ctime = attr.cat_ctime;
+ ll_i2info(inode)->lli_atime = attr.cat_atime;
+ ll_i2info(inode)->lli_mtime = attr.cat_mtime;
+ ll_i2info(inode)->lli_ctime = attr.cat_ctime;
RETURN(0);
}
RETURN(rc);
}
- LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime;
- LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime;
- LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime;
+ LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_atime;
+ LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_mtime;
+ LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_ctime;
} else {
/* In case of restore, the MDT has the right size and has
* already send it back without granting the layout lock,
RETURN(result);
if (!agl) {
- cl_merge_lvb(env, inode);
+ ll_merge_attr(env, inode);
if (cl_isize_read(inode) > 0 &&
inode->i_blocks == 0) {
/*
cl_lock_release(env, lock);
} else {
CDEBUG(D_DLMTRACE, "No objects for inode\n");
- cl_merge_lvb(env, inode);
+ ll_merge_attr(env, inode);
}
}
lock->cll_descr.cld_obj = clob;
result = cl_lock_request(env, io, lock);
if (result == 0) {
- cl_merge_lvb(env, inode);
+ ll_merge_attr(env, inode);
cl_lock_release(env, lock);
}
}
struct inode lli_vfs_inode;
/* the most recent timestamps obtained from mds */
- struct ost_lvb lli_lvb;
+ obd_time lli_atime;
+ obd_time lli_mtime;
+ obd_time lli_ctime;
spinlock_t lli_agl_lock;
/* Try to make the d::member and f::member are aligned. Before using
#else
int ll_fsync(struct file *file, struct dentry *dentry, int data);
#endif
-int ll_merge_lvb(const struct lu_env *env, struct inode *inode);
+int ll_merge_attr(const struct lu_env *env, struct inode *inode);
int ll_fid2path(struct inode *inode, void __user *arg);
int ll_data_version(struct inode *inode, __u64 *data_version, int flags);
int ll_hsm_release(struct inode *inode);
#define cl_isize_read(inode) i_size_read(inode)
-static inline int cl_merge_lvb(const struct lu_env *env, struct inode *inode)
-{
- return ll_merge_lvb(env, inode);
-}
-
#define cl_inode_atime(inode) LTIME_S((inode)->i_atime)
#define cl_inode_ctime(inode) LTIME_S((inode)->i_ctime)
#define cl_inode_mtime(inode) LTIME_S((inode)->i_mtime)
if (body->mbo_valid & OBD_MD_FLATIME) {
if (body->mbo_atime > LTIME_S(inode->i_atime))
LTIME_S(inode->i_atime) = body->mbo_atime;
- lli->lli_lvb.lvb_atime = body->mbo_atime;
+ lli->lli_atime = body->mbo_atime;
}
if (body->mbo_valid & OBD_MD_FLMTIME) {
LTIME_S(inode->i_mtime), body->mbo_mtime);
LTIME_S(inode->i_mtime) = body->mbo_mtime;
}
- lli->lli_lvb.lvb_mtime = body->mbo_mtime;
+ lli->lli_mtime = body->mbo_mtime;
}
if (body->mbo_valid & OBD_MD_FLCTIME) {
if (body->mbo_ctime > LTIME_S(inode->i_ctime))
LTIME_S(inode->i_ctime) = body->mbo_ctime;
- lli->lli_lvb.lvb_ctime = body->mbo_ctime;
+ lli->lli_ctime = body->mbo_ctime;
}
if (body->mbo_valid & OBD_MD_FLMODE)