LU-2675 llite: remove lli_lvb

In struct ll_inode_info remove the struct ost_lvb lli_lvb member and
replace it with obd_time lli_{a,m,c}time. Rename ll_merge_lvb() to
ll_merge_attr(). Remove cl_merge_lvb() and replace calls to it with
calls to ll_merge_attr().

Signed-off-by: John L. Hammond <john.hammond@intel.com>
Change-Id: Idaf8a89d2e4243e62a23cab949c3c129001bb9f3
Reviewed-on: http://review.whamcloud.com/12849
Tested-by: Jenkins
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Bobi Jam <bobijam@gmail.com>
Reviewed-by: Lai Siyao <lai.siyao@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>

diff --git a/lustre/llite/file.c b/lustre/llite/file.c
index 28cb292..57bee66 100644 (file)
--- a/lustre/llite/file.c
+++ b/lustre/llite/file.c
@@ -1009,51 +1009,57 @@ int ll_inode_getattr(struct inode *inode, struct obdo *obdo,
        RETURN(rc);
 }
 
        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 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);
        int rc = 0;
 
        ENTRY;
 
        ll_inode_size_lock(inode);

+

        /* merge timestamps the most recently obtained from mds with
           timestamps obtained from osts */
        /* 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);
 
 
        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);
        ll_inode_size_unlock(inode);
 
        RETURN(rc);


@@ -1982,7 +1988,7 @@ int ll_hsm_release(struct inode *inode)
        if (IS_ERR(env))
                GOTO(out, rc = PTR_ERR(env));
 
        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.
        cl_env_nested_put(&nest, env);
 
        /* Release the file.


@@ -3271,9 +3277,9 @@ static int ll_merge_md_attr(struct inode *inode)
        ll_i2info(inode)->lli_stripe_dir_size = attr.cat_size;
        ll_i2info(inode)->lli_stripe_dir_nlink = attr.cat_nlink;
 
        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(0);
 }


@@ -3298,9 +3304,9 @@ ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
                                RETURN(rc);
                }
 
                                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,
        } else {
                /* In case of restore, the MDT has the right size and has
                 * already send it back without granting the layout lock,

diff --git a/lustre/llite/glimpse.c b/lustre/llite/glimpse.c
index 38559b8..0ebf4cd 100644 (file)
--- a/lustre/llite/glimpse.c
+++ b/lustre/llite/glimpse.c
@@ -129,7 +129,7 @@ int cl_glimpse_lock(const struct lu_env *env, struct cl_io *io,
                                RETURN(result);
 
                        if (!agl) {
                                RETURN(result);
 
                        if (!agl) {

-                               cl_merge_lvb(env, inode);
+                               ll_merge_attr(env, inode);

                                if (cl_isize_read(inode) > 0 &&
                                    inode->i_blocks == 0) {
                                        /*
                                if (cl_isize_read(inode) > 0 &&
                                    inode->i_blocks == 0) {
                                        /*


@@ -144,7 +144,7 @@ int cl_glimpse_lock(const struct lu_env *env, struct cl_io *io,
                        cl_lock_release(env, lock);
                } else {
                        CDEBUG(D_DLMTRACE, "No objects for inode\n");
                        cl_lock_release(env, lock);
                } else {
                        CDEBUG(D_DLMTRACE, "No objects for inode\n");

-                       cl_merge_lvb(env, inode);
+                       ll_merge_attr(env, inode);

                }
        }
 
                }
        }
 


@@ -247,7 +247,7 @@ int cl_local_size(struct inode *inode)
                lock->cll_descr.cld_obj = clob;
                result = cl_lock_request(env, io, lock);
                if (result == 0) {
                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);
                }
        }
                        cl_lock_release(env, lock);
                }
        }

diff --git a/lustre/llite/llite_internal.h b/lustre/llite/llite_internal.h
index 25b92b8..2ce7639 100644 (file)
--- a/lustre/llite/llite_internal.h
+++ b/lustre/llite/llite_internal.h
@@ -173,7 +173,9 @@ struct ll_inode_info {
        struct inode                    lli_vfs_inode;
 
        /* the most recent timestamps obtained from mds */
        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
        spinlock_t                      lli_agl_lock;
 
        /* Try to make the d::member and f::member are aligned. Before using


@@ -882,7 +884,7 @@ int ll_fsync(struct file *file, int data);
 #else
 int ll_fsync(struct file *file, struct dentry *dentry, int data);
 #endif
 #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);
 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);


@@ -1471,11 +1473,6 @@ static inline void cl_isize_write(struct inode *inode, loff_t kms)
 
 #define cl_isize_read(inode)             i_size_read(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)
 #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)

diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c
index 91993d7..09aa53c 100644 (file)
--- a/lustre/llite/llite_lib.c
+++ b/lustre/llite/llite_lib.c
@@ -1958,7 +1958,7 @@ int ll_update_inode(struct inode *inode, struct lustre_md *md)
        if (body->mbo_valid & OBD_MD_FLATIME) {
                if (body->mbo_atime > LTIME_S(inode->i_atime))
                        LTIME_S(inode->i_atime) = body->mbo_atime;
        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) {
        }
 
        if (body->mbo_valid & OBD_MD_FLMTIME) {


@@ -1968,13 +1968,13 @@ int ll_update_inode(struct inode *inode, struct lustre_md *md)
                               LTIME_S(inode->i_mtime), body->mbo_mtime);
                        LTIME_S(inode->i_mtime) = body->mbo_mtime;
                }
                               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;
        }
 
        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)
        }
 
        if (body->mbo_valid & OBD_MD_FLMODE)

diff --git a/lustre/llite/vvp_io.c b/lustre/llite/vvp_io.c
index 31d775b..df9a83a 100644 (file)
--- a/lustre/llite/vvp_io.c
+++ b/lustre/llite/vvp_io.c
@@ -749,7 +749,7 @@ int vvp_io_write_commit(const struct lu_env *env, struct cl_io *io)
        }
 
        /* update inode size */
        }
 
        /* update inode size */

-       ll_merge_lvb(env, inode);
+       ll_merge_attr(env, inode);

 
        /* Now the pages in queue were failed to commit, discard them
         * unless they were dirtied before. */
 
        /* Now the pages in queue were failed to commit, discard them
         * unless they were dirtied before. */


@@ -792,7 +792,7 @@ static int vvp_io_write_start(const struct lu_env *env,
                  * PARALLEL IO This has to be changed for parallel IO doing
                  * out-of-order writes.
                  */
                  * PARALLEL IO This has to be changed for parallel IO doing
                  * out-of-order writes.
                  */

-               ll_merge_lvb(env, inode);
+               ll_merge_attr(env, inode);

                 pos = io->u.ci_wr.wr.crw_pos = i_size_read(inode);
                 cio->cui_iocb->ki_pos = pos;
         } else {
                 pos = io->u.ci_wr.wr.crw_pos = i_size_read(inode);
                 cio->cui_iocb->ki_pos = pos;
         } else {