LU-11838 lustre: discard LTIME_S macro

Rather than using a macro, just access the required
field directly.

Linux-commit: 5b7cc4e4ce3cc15f67462ae75c55eecc7edc3a40

Change-Id: I325cac7458265d1cf6ad9f195a513f2612865906
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-on: https://review.whamcloud.com/33984
Tested-by: Jenkins
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Bobi Jam <bobijam@hotmail.com>
Reviewed-by: Ben Evans <bevans@cray.com>

diff --git a/lustre/include/lustre_compat.h b/lustre/include/lustre_compat.h
index f55f6e5..df20146 100644 (file)
--- a/lustre/include/lustre_compat.h
+++ b/lustre/include/lustre_compat.h
@@ -99,8 +99,6 @@ static inline void ll_set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt,
 #define MODULE_ALIAS_FS(name)
 #endif
 
 #define MODULE_ALIAS_FS(name)
 #endif
 

-#define LTIME_S(time)                   (time.tv_sec)
-

 #ifdef HAVE_GENERIC_PERMISSION_2ARGS
 # define ll_generic_permission(inode, mask, flags, check_acl) \
         generic_permission(inode, mask)
 #ifdef HAVE_GENERIC_PERMISSION_2ARGS
 # define ll_generic_permission(inode, mask, flags, check_acl) \
         generic_permission(inode, mask)

diff --git a/lustre/llite/file.c b/lustre/llite/file.c
index 9332f1e..6af68fa 100644 (file)
--- a/lustre/llite/file.c
+++ b/lustre/llite/file.c
@@ -1216,17 +1216,19 @@ int ll_merge_attr(const struct lu_env *env, struct inode *inode)
         * if it's at least 'mdd.*.atime_diff' older.
         * All in all, the atime in Lustre does not strictly comply with
         * POSIX. Solving this problem needs to send an RPC to MDT for each
         * if it's at least 'mdd.*.atime_diff' older.
         * All in all, the atime in Lustre does not strictly comply with
         * POSIX. Solving this problem needs to send an RPC to MDT for each

-        * read, this will hurt performance. */
-       if (LTIME_S(inode->i_atime) < lli->lli_atime || lli->lli_update_atime) {
-               LTIME_S(inode->i_atime) = lli->lli_atime;
+        * read, this will hurt performance.
+        */
+       if (inode->i_atime.tv_sec < lli->lli_atime ||
+           lli->lli_update_atime) {
+               inode->i_atime.tv_sec = lli->lli_atime;

                lli->lli_update_atime = 0;
        }
                lli->lli_update_atime = 0;
        }

-       LTIME_S(inode->i_mtime) = lli->lli_mtime;
-       LTIME_S(inode->i_ctime) = lli->lli_ctime;
+       inode->i_mtime.tv_sec = lli->lli_mtime;
+       inode->i_ctime.tv_sec = lli->lli_ctime;

 
 

-       atime = LTIME_S(inode->i_atime);
-       mtime = LTIME_S(inode->i_mtime);
-       ctime = LTIME_S(inode->i_ctime);
+       mtime = inode->i_mtime.tv_sec;
+       atime = inode->i_atime.tv_sec;
+       ctime = inode->i_ctime.tv_sec;

 
        cl_object_attr_lock(obj);
        if (OBD_FAIL_CHECK(OBD_FAIL_MDC_MERGE))
 
        cl_object_attr_lock(obj);
        if (OBD_FAIL_CHECK(OBD_FAIL_MDC_MERGE))


@@ -1253,9 +1255,9 @@ int ll_merge_attr(const struct lu_env *env, struct inode *inode)
        i_size_write(inode, attr->cat_size);
        inode->i_blocks = attr->cat_blocks;
 
        i_size_write(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;
+       inode->i_mtime.tv_sec = mtime;
+       inode->i_atime.tv_sec = atime;
+       inode->i_ctime.tv_sec = ctime;

 
 out_size_unlock:
        ll_inode_size_unlock(inode);
 
 out_size_unlock:
        ll_inode_size_unlock(inode);


@@ -4404,9 +4406,9 @@ int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
                                RETURN(rc);
                }
 
                                RETURN(rc);
                }
 

-               LTIME_S(inode->i_atime) = lli->lli_atime;
-               LTIME_S(inode->i_mtime) = lli->lli_mtime;
-               LTIME_S(inode->i_ctime) = lli->lli_ctime;
+               inode->i_atime.tv_sec = lli->lli_atime;
+               inode->i_mtime.tv_sec = lli->lli_mtime;
+               inode->i_ctime.tv_sec = lli->lli_ctime;

        }
 
        OBD_FAIL_TIMEOUT(OBD_FAIL_GETATTR_DELAY, 30);
        }
 
        OBD_FAIL_TIMEOUT(OBD_FAIL_GETATTR_DELAY, 30);

diff --git a/lustre/llite/lcommon_cl.c b/lustre/llite/lcommon_cl.c
index c4b6cc9..21a10ec 100644 (file)
--- a/lustre/llite/lcommon_cl.c
+++ b/lustre/llite/lcommon_cl.c
@@ -85,9 +85,9 @@ int cl_setattr_ost(struct cl_object *obj, const struct iattr *attr,
        io->ci_obj = obj;
        io->ci_verify_layout = 1;
 
        io->ci_obj = obj;
        io->ci_verify_layout = 1;
 

-       io->u.ci_setattr.sa_attr.lvb_atime = LTIME_S(attr->ia_atime);
-       io->u.ci_setattr.sa_attr.lvb_mtime = LTIME_S(attr->ia_mtime);
-       io->u.ci_setattr.sa_attr.lvb_ctime = LTIME_S(attr->ia_ctime);
+       io->u.ci_setattr.sa_attr.lvb_atime = attr->ia_atime.tv_sec;
+       io->u.ci_setattr.sa_attr.lvb_mtime = attr->ia_mtime.tv_sec;
+       io->u.ci_setattr.sa_attr.lvb_ctime = attr->ia_ctime.tv_sec;

        io->u.ci_setattr.sa_attr.lvb_size = attr->ia_size;
        io->u.ci_setattr.sa_attr_flags = attr_flags;
        io->u.ci_setattr.sa_avalid = attr->ia_valid;
        io->u.ci_setattr.sa_attr.lvb_size = attr->ia_size;
        io->u.ci_setattr.sa_attr_flags = attr_flags;
        io->u.ci_setattr.sa_avalid = attr->ia_valid;

diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c
index 34f1627..b4cbe57 100644 (file)
--- a/lustre/llite/llite_lib.c
+++ b/lustre/llite/llite_lib.c
@@ -1290,9 +1290,9 @@ static struct inode *ll_iget_anon_dir(struct super_block *sb,
                LASSERTF(S_ISDIR(inode->i_mode), "Not slave inode "DFID"\n",
                         PFID(fid));
 
                LASSERTF(S_ISDIR(inode->i_mode), "Not slave inode "DFID"\n",
                         PFID(fid));
 

-               LTIME_S(inode->i_mtime) = 0;
-               LTIME_S(inode->i_atime) = 0;
-               LTIME_S(inode->i_ctime) = 0;
+               inode->i_mtime.tv_sec = 0;
+               inode->i_atime.tv_sec = 0;
+               inode->i_ctime.tv_sec = 0;

                inode->i_rdev = 0;
 
 #ifdef HAVE_BACKING_DEV_INFO
                inode->i_rdev = 0;
 
 #ifdef HAVE_BACKING_DEV_INFO


@@ -1651,9 +1651,9 @@ int ll_setattr_raw(struct dentry *dentry, struct iattr *attr,
         }
 
         if (attr->ia_valid & (ATTR_MTIME | ATTR_CTIME))
         }
 
         if (attr->ia_valid & (ATTR_MTIME | ATTR_CTIME))

-               CDEBUG(D_INODE, "setting mtime %lu, ctime %lu, now = %llu\n",
-                       LTIME_S(attr->ia_mtime), LTIME_S(attr->ia_ctime),
-                      (s64)ktime_get_real_seconds());
+               CDEBUG(D_INODE, "setting mtime %lld, ctime %lld, now = %lld\n",
+                      (s64)attr->ia_mtime.tv_sec, (s64)attr->ia_ctime.tv_sec,
+                      ktime_get_real_seconds());

 
        if (S_ISREG(inode->i_mode)) {
                if (attr->ia_valid & ATTR_SIZE)
 
        if (S_ISREG(inode->i_mode)) {
                if (attr->ia_valid & ATTR_SIZE)


@@ -1946,24 +1946,25 @@ int ll_update_inode(struct inode *inode, struct lustre_md *md)
        inode->i_generation = cl_fid_build_gen(&body->mbo_fid1);
 
        if (body->mbo_valid & OBD_MD_FLATIME) {
        inode->i_generation = cl_fid_build_gen(&body->mbo_fid1);
 
        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_atime > inode->i_atime.tv_sec)
+                       inode->i_atime.tv_sec = body->mbo_atime;

                lli->lli_atime = body->mbo_atime;
        }
 
        if (body->mbo_valid & OBD_MD_FLMTIME) {
                lli->lli_atime = body->mbo_atime;
        }
 
        if (body->mbo_valid & OBD_MD_FLMTIME) {

-               if (body->mbo_mtime > LTIME_S(inode->i_mtime)) {
-                       CDEBUG(D_INODE, "setting ino %lu mtime from %lu "
-                              "to %llu\n", inode->i_ino,
-                              LTIME_S(inode->i_mtime), body->mbo_mtime);
-                       LTIME_S(inode->i_mtime) = body->mbo_mtime;
+               if (body->mbo_mtime > inode->i_mtime.tv_sec) {
+                       CDEBUG(D_INODE,
+                              "setting ino %lu mtime from %lld to %llu\n",
+                              inode->i_ino, (s64)inode->i_mtime.tv_sec,
+                              body->mbo_mtime);
+                       inode->i_mtime.tv_sec = body->mbo_mtime;

                }
                lli->lli_mtime = body->mbo_mtime;
        }
 
        if (body->mbo_valid & OBD_MD_FLCTIME) {
                }
                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_ctime > inode->i_ctime.tv_sec)
+                       inode->i_ctime.tv_sec = body->mbo_ctime;

                lli->lli_ctime = body->mbo_ctime;
        }
 
                lli->lli_ctime = body->mbo_ctime;
        }
 


@@ -2049,11 +2050,12 @@ int ll_read_inode2(struct inode *inode, void *opaque)
         /* Core attributes from the MDS first.  This is a new inode, and
          * the VFS doesn't zero times in the core inode so we have to do
          * it ourselves.  They will be overwritten by either MDS or OST
         /* Core attributes from the MDS first.  This is a new inode, and
          * the VFS doesn't zero times in the core inode so we have to do
          * it ourselves.  They will be overwritten by either MDS or OST

-         * attributes - we just need to make sure they aren't newer. */
-        LTIME_S(inode->i_mtime) = 0;
-        LTIME_S(inode->i_atime) = 0;
-        LTIME_S(inode->i_ctime) = 0;
-        inode->i_rdev = 0;
+        * attributes - we just need to make sure they aren't newer.
+        */
+       inode->i_mtime.tv_sec = 0;
+       inode->i_atime.tv_sec = 0;
+       inode->i_ctime.tv_sec = 0;
+       inode->i_rdev = 0;

        rc = ll_update_inode(inode, md);
        if (rc != 0)
                RETURN(rc);
        rc = ll_update_inode(inode, md);
        if (rc != 0)
                RETURN(rc);

diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c
index 3c63e23..53b8a74 100644 (file)
--- a/lustre/llite/namei.c
+++ b/lustre/llite/namei.c
@@ -1144,16 +1144,17 @@ void ll_update_times(struct ptlrpc_request *request, struct inode *inode)
 
        LASSERT(body);
        if (body->mbo_valid & OBD_MD_FLMTIME &&
 
        LASSERT(body);
        if (body->mbo_valid & OBD_MD_FLMTIME &&

-           body->mbo_mtime > LTIME_S(inode->i_mtime)) {
-               CDEBUG(D_INODE, "setting fid "DFID" mtime from %lu to %llu"
-                      "\n", PFID(ll_inode2fid(inode)),
-                      LTIME_S(inode->i_mtime), body->mbo_mtime);
-               LTIME_S(inode->i_mtime) = body->mbo_mtime;
+           body->mbo_mtime > inode->i_mtime.tv_sec) {
+               CDEBUG(D_INODE,
+                      "setting fid " DFID " mtime from %lld to %llu\n",
+                      PFID(ll_inode2fid(inode)),
+                      (s64)inode->i_mtime.tv_sec, body->mbo_mtime);
+               inode->i_mtime.tv_sec = body->mbo_mtime;

        }
 
        if (body->mbo_valid & OBD_MD_FLCTIME &&
        }
 
        if (body->mbo_valid & OBD_MD_FLCTIME &&

-           body->mbo_ctime > LTIME_S(inode->i_ctime))
-               LTIME_S(inode->i_ctime) = body->mbo_ctime;
+           body->mbo_ctime > inode->i_ctime.tv_sec)
+               inode->i_ctime.tv_sec = body->mbo_ctime;

 }
 
 static int ll_new_node(struct inode *dir, struct dentry *dchild,
 }
 
 static int ll_new_node(struct inode *dir, struct dentry *dchild,

diff --git a/lustre/llite/vvp_object.c b/lustre/llite/vvp_object.c
index 4038741..c3bf715 100644 (file)
--- a/lustre/llite/vvp_object.c
+++ b/lustre/llite/vvp_object.c
@@ -185,9 +185,9 @@ static int vvp_object_glimpse(const struct lu_env *env,
        struct inode *inode = vvp_object_inode(obj);
 
        ENTRY;
        struct inode *inode = vvp_object_inode(obj);
 
        ENTRY;

-       lvb->lvb_mtime = LTIME_S(inode->i_mtime);
-       lvb->lvb_atime = LTIME_S(inode->i_atime);
-       lvb->lvb_ctime = LTIME_S(inode->i_ctime);
+       lvb->lvb_mtime = inode->i_mtime.tv_sec;
+       lvb->lvb_atime = inode->i_atime.tv_sec;
+       lvb->lvb_ctime = inode->i_ctime.tv_sec;

 
        /*
         * LU-417: Add dirty pages block count lest i_blocks reports 0, some
 
        /*
         * LU-417: Add dirty pages block count lest i_blocks reports 0, some

diff --git a/lustre/lmv/lmv_intent.c b/lustre/lmv/lmv_intent.c
index cc902bd..86e666e 100644 (file)
--- a/lustre/lmv/lmv_intent.c
+++ b/lustre/lmv/lmv_intent.c
@@ -232,9 +232,9 @@ int lmv_revalidate_slaves(struct obd_export *exp,
                        i_size_write(inode, body->mbo_size);
                        inode->i_blocks = body->mbo_blocks;
                        set_nlink(inode, body->mbo_nlink);
                        i_size_write(inode, body->mbo_size);
                        inode->i_blocks = body->mbo_blocks;
                        set_nlink(inode, body->mbo_nlink);

-                       LTIME_S(inode->i_atime) = body->mbo_atime;
-                       LTIME_S(inode->i_ctime) = body->mbo_ctime;
-                       LTIME_S(inode->i_mtime) = body->mbo_mtime;
+                       inode->i_atime.tv_sec = body->mbo_atime;
+                       inode->i_ctime.tv_sec = body->mbo_ctime;
+                       inode->i_mtime.tv_sec = body->mbo_mtime;

                }
 
                md_set_lock_data(tgt->ltd_exp, lockh, inode, NULL);
                }
 
                md_set_lock_data(tgt->ltd_exp, lockh, inode, NULL);

diff --git a/lustre/lmv/lmv_obd.c b/lustre/lmv/lmv_obd.c
index e785fd9..5a7945b 100644 (file)
--- a/lustre/lmv/lmv_obd.c
+++ b/lustre/lmv/lmv_obd.c
@@ -3347,12 +3347,12 @@ static int lmv_merge_attr(struct obd_export *exp,
        for (i = 0; i < lsm->lsm_md_stripe_count; i++) {
                struct inode *inode = lsm->lsm_md_oinfo[i].lmo_root;
 
        for (i = 0; i < lsm->lsm_md_stripe_count; i++) {
                struct inode *inode = lsm->lsm_md_oinfo[i].lmo_root;
 

-               CDEBUG(D_INFO, ""DFID" size %llu, blocks %llu nlink %u,"
-                      " atime %lu ctime %lu, mtime %lu.\n",
+               CDEBUG(D_INFO,
+                      "" DFID " size %llu, blocks %llu nlink %u, atime %lld ctime %lld, mtime %lld.\n",

                       PFID(&lsm->lsm_md_oinfo[i].lmo_fid),
                       i_size_read(inode), (unsigned long long)inode->i_blocks,
                       PFID(&lsm->lsm_md_oinfo[i].lmo_fid),
                       i_size_read(inode), (unsigned long long)inode->i_blocks,

-                      inode->i_nlink, LTIME_S(inode->i_atime),
-                      LTIME_S(inode->i_ctime), LTIME_S(inode->i_mtime));
+                      inode->i_nlink, (s64)inode->i_atime.tv_sec,
+                      (s64)inode->i_ctime.tv_sec, (s64)inode->i_mtime.tv_sec);

 
                /* for slave stripe, it needs to subtract nlink for . and .. */
                if (i != 0)
 
                /* for slave stripe, it needs to subtract nlink for . and .. */
                if (i != 0)


@@ -3363,14 +3363,14 @@ static int lmv_merge_attr(struct obd_export *exp,
                attr->cat_size += i_size_read(inode);
                attr->cat_blocks += inode->i_blocks;
 
                attr->cat_size += i_size_read(inode);
                attr->cat_blocks += inode->i_blocks;
 

-               if (attr->cat_atime < LTIME_S(inode->i_atime))
-                       attr->cat_atime = LTIME_S(inode->i_atime);
+               if (attr->cat_atime < inode->i_atime.tv_sec)
+                       attr->cat_atime = inode->i_atime.tv_sec;

 
 

-               if (attr->cat_ctime < LTIME_S(inode->i_ctime))
-                       attr->cat_ctime = LTIME_S(inode->i_ctime);
+               if (attr->cat_ctime < inode->i_ctime.tv_sec)
+                       attr->cat_ctime = inode->i_ctime.tv_sec;

 
 

-               if (attr->cat_mtime < LTIME_S(inode->i_mtime))
-                       attr->cat_mtime = LTIME_S(inode->i_mtime);
+               if (attr->cat_mtime < inode->i_mtime.tv_sec)
+                       attr->cat_mtime = inode->i_mtime.tv_sec;

        }
        return 0;
 }
        }
        return 0;
 }

diff --git a/lustre/mdc/mdc_lib.c b/lustre/mdc/mdc_lib.c
index f6e0066..336761d 100644 (file)
--- a/lustre/mdc/mdc_lib.c
+++ b/lustre/mdc/mdc_lib.c
@@ -352,9 +352,9 @@ static void mdc_setattr_pack_rec(struct mdt_rec_setattr *rec,
        rec->sa_projid = op_data->op_projid;
        rec->sa_size   = op_data->op_attr.ia_size;
        rec->sa_blocks = op_data->op_attr_blocks;
        rec->sa_projid = op_data->op_projid;
        rec->sa_size   = op_data->op_attr.ia_size;
        rec->sa_blocks = op_data->op_attr_blocks;

-       rec->sa_atime  = LTIME_S(op_data->op_attr.ia_atime);
-       rec->sa_mtime  = LTIME_S(op_data->op_attr.ia_mtime);
-       rec->sa_ctime  = LTIME_S(op_data->op_attr.ia_ctime);
+       rec->sa_atime = op_data->op_attr.ia_atime.tv_sec;
+       rec->sa_mtime = op_data->op_attr.ia_mtime.tv_sec;
+       rec->sa_ctime = op_data->op_attr.ia_ctime.tv_sec;

        rec->sa_attr_flags = op_data->op_attr_flags;
        if ((op_data->op_attr.ia_valid & ATTR_GID) &&
             in_group_p(op_data->op_attr.ia_gid))
        rec->sa_attr_flags = op_data->op_attr_flags;
        if ((op_data->op_attr.ia_valid & ATTR_GID) &&
             in_group_p(op_data->op_attr.ia_gid))

diff --git a/lustre/mdc/mdc_reint.c b/lustre/mdc/mdc_reint.c
index 5868101..3a95276 100644 (file)
--- a/lustre/mdc/mdc_reint.c
+++ b/lustre/mdc/mdc_reint.c
@@ -131,9 +131,9 @@ int mdc_setattr(struct obd_export *exp, struct md_op_data *op_data,
        }
 
         if (op_data->op_attr.ia_valid & (ATTR_MTIME | ATTR_CTIME))
        }
 
         if (op_data->op_attr.ia_valid & (ATTR_MTIME | ATTR_CTIME))

-               CDEBUG(D_INODE, "setting mtime %ld, ctime %ld\n",
-                       LTIME_S(op_data->op_attr.ia_mtime),
-                       LTIME_S(op_data->op_attr.ia_ctime));
+               CDEBUG(D_INODE, "setting mtime %lld, ctime %lld\n",
+                      (s64)op_data->op_attr.ia_mtime.tv_sec,
+                      (s64)op_data->op_attr.ia_ctime.tv_sec);

        mdc_setattr_pack(req, op_data, ea, ealen);
 
        req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER,
        mdc_setattr_pack(req, op_data, ea, ealen);
 
        req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER,

diff --git a/lustre/obdclass/obdo.c b/lustre/obdclass/obdo.c
index 311b464..0367cfd 100644 (file)
--- a/lustre/obdclass/obdo.c
+++ b/lustre/obdclass/obdo.c
@@ -70,20 +70,20 @@ void obdo_from_inode(struct obdo *dst, struct inode *src, u64 valid)
        u64 newvalid = 0;
 
        if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
        u64 newvalid = 0;
 
        if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))

-               CDEBUG(D_INODE, "valid %#llx, new time %lu/%lu\n",
-                       valid, LTIME_S(src->i_mtime),
-                       LTIME_S(src->i_ctime));
+               CDEBUG(D_INODE, "valid %#llx, new time %lld/%lld\n",
+                      valid, (s64) src->i_mtime.tv_sec,
+                      (s64) src->i_ctime.tv_sec);

 
        if (valid & OBD_MD_FLATIME) {
 
        if (valid & OBD_MD_FLATIME) {

-               dst->o_atime = LTIME_S(src->i_atime);
+               dst->o_atime = src->i_atime.tv_sec;

                newvalid |= OBD_MD_FLATIME;
        }
        if (valid & OBD_MD_FLMTIME) {
                newvalid |= OBD_MD_FLATIME;
        }
        if (valid & OBD_MD_FLMTIME) {

-               dst->o_mtime = LTIME_S(src->i_mtime);
+               dst->o_mtime = src->i_mtime.tv_sec;

                newvalid |= OBD_MD_FLMTIME;
        }
        if (valid & OBD_MD_FLCTIME) {
                newvalid |= OBD_MD_FLMTIME;
        }
        if (valid & OBD_MD_FLCTIME) {

-               dst->o_ctime = LTIME_S(src->i_ctime);
+               dst->o_ctime = src->i_ctime.tv_sec;

                newvalid |= OBD_MD_FLCTIME;
        }
        if (valid & OBD_MD_FLSIZE) {
                newvalid |= OBD_MD_FLCTIME;
        }
        if (valid & OBD_MD_FLSIZE) {

diff --git a/lustre/osd-ldiskfs/osd_handler.c b/lustre/osd-ldiskfs/osd_handler.c
index f0cda5f..f46bf1a 100644 (file)
--- a/lustre/osd-ldiskfs/osd_handler.c
+++ b/lustre/osd-ldiskfs/osd_handler.c
@@ -2600,9 +2600,9 @@ static void osd_inode_getattr(const struct lu_env *env,
                           LA_PROJID | LA_FLAGS | LA_NLINK | LA_RDEV |
                           LA_BLKSIZE | LA_TYPE;
 
                           LA_PROJID | LA_FLAGS | LA_NLINK | LA_RDEV |
                           LA_BLKSIZE | LA_TYPE;
 

-       attr->la_atime   = LTIME_S(inode->i_atime);
-       attr->la_mtime   = LTIME_S(inode->i_mtime);
-       attr->la_ctime   = LTIME_S(inode->i_ctime);
+       attr->la_atime = inode->i_atime.tv_sec;
+       attr->la_mtime = inode->i_mtime.tv_sec;
+       attr->la_ctime = inode->i_ctime.tv_sec;

        attr->la_mode    = inode->i_mode;
        attr->la_size    = i_size_read(inode);
        attr->la_blocks  = inode->i_blocks;
        attr->la_mode    = inode->i_mode;
        attr->la_size    = i_size_read(inode);
        attr->la_blocks  = inode->i_blocks;


@@ -3280,11 +3280,11 @@ static void osd_attr_init(struct osd_thread_info *info, struct osd_object *obj,
 
        if (dof->dof_type != DFT_NODE)
                attr->la_valid &= ~LA_RDEV;
 
        if (dof->dof_type != DFT_NODE)
                attr->la_valid &= ~LA_RDEV;

-       if ((valid & LA_ATIME) && (attr->la_atime == LTIME_S(inode->i_atime)))
+       if ((valid & LA_ATIME) && (attr->la_atime == inode->i_atime.tv_sec))

                attr->la_valid &= ~LA_ATIME;
                attr->la_valid &= ~LA_ATIME;

-       if ((valid & LA_CTIME) && (attr->la_ctime == LTIME_S(inode->i_ctime)))
+       if ((valid & LA_CTIME) && (attr->la_ctime == inode->i_ctime.tv_sec))

                attr->la_valid &= ~LA_CTIME;
                attr->la_valid &= ~LA_CTIME;

-       if ((valid & LA_MTIME) && (attr->la_mtime == LTIME_S(inode->i_mtime)))
+       if ((valid & LA_MTIME) && (attr->la_mtime == inode->i_mtime.tv_sec))

                attr->la_valid &= ~LA_MTIME;
 
        result = osd_quota_transfer(inode, attr);
                attr->la_valid &= ~LA_MTIME;
 
        result = osd_quota_transfer(inode, attr);