ext4: convert to ctime accessor functions

In later patches, we're going to change how the inode's ctime field is
used. Switch to using accessor functions instead of raw accesses of
inode->i_ctime.

Signed-off-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Jan Kara <jack@suse.cz>
Message-Id: <20230705190309.579783-40-jlayton@kernel.org>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/ext4/acl.c b/fs/ext4/acl.c
index 27fcbddfb14841180ed727a84f6482f5194c7cf2..3bffe862f9549919a4ac38fe301becd3ac846775 100644 (file)
--- a/fs/ext4/acl.c
+++ b/fs/ext4/acl.c
@@ -259,7 +259,7 @@ retry:
        error = __ext4_set_acl(handle, inode, type, acl, 0 /* xattr_flags */);
        if (!error && update_mode) {
                inode->i_mode = mode;
-               inode->i_ctime = current_time(inode);
+               inode_set_ctime_current(inode);
                error = ext4_mark_inode_dirty(handle, inode);
        }
 out_stop:

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 0a2d55faa095ef262c1bd5462b756663aa289706..1e2259d9967d22c4fd6e2365b265ac0541edd628 100644 (file)
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -868,64 +868,70 @@ struct ext4_inode {
  * affected filesystem before 2242.
  */
 
-static inline __le32 ext4_encode_extra_time(struct timespec64 *time)
+static inline __le32 ext4_encode_extra_time(struct timespec64 ts)
 {
-       u32 extra =((time->tv_sec - (s32)time->tv_sec) >> 32) & EXT4_EPOCH_MASK;
-       return cpu_to_le32(extra | (time->tv_nsec << EXT4_EPOCH_BITS));
+       u32 extra = ((ts.tv_sec - (s32)ts.tv_sec) >> 32) & EXT4_EPOCH_MASK;
+       return cpu_to_le32(extra | (ts.tv_nsec << EXT4_EPOCH_BITS));
 }
 
-static inline void ext4_decode_extra_time(struct timespec64 *time,
-                                         __le32 extra)
+static inline struct timespec64 ext4_decode_extra_time(__le32 base,
+                                                      __le32 extra)
 {
+       struct timespec64 ts = { .tv_sec = (signed)le32_to_cpu(base) };
+
        if (unlikely(extra & cpu_to_le32(EXT4_EPOCH_MASK)))
-               time->tv_sec += (u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK) << 32;
-       time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
+               ts.tv_sec += (u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK) << 32;
+       ts.tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
+       return ts;
 }
 
-#define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode)                          \
+#define EXT4_INODE_SET_XTIME_VAL(xtime, inode, raw_inode, ts)                  \
 do {                                                                           \
-       if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     {\
-               (raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);        \
-               (raw_inode)->xtime ## _extra =                                  \
-                               ext4_encode_extra_time(&(inode)->xtime);        \
-               }                                                               \
-       else    \
-               (raw_inode)->xtime = cpu_to_le32(clamp_t(int32_t, (inode)->xtime.tv_sec, S32_MIN, S32_MAX));    \
+       if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra)) {    \
+               (raw_inode)->xtime = cpu_to_le32((ts).tv_sec);                  \
+               (raw_inode)->xtime ## _extra = ext4_encode_extra_time(ts);      \
+       } else                                                                  \
+               (raw_inode)->xtime = cpu_to_le32(clamp_t(int32_t, (ts).tv_sec, S32_MIN, S32_MAX));      \
 } while (0)
 
-#define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode)                               \
-do {                                                                          \
-       if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                      \
-               (raw_inode)->xtime = cpu_to_le32((einode)->xtime.tv_sec);      \
-       if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra))            \
-               (raw_inode)->xtime ## _extra =                                 \
-                               ext4_encode_extra_time(&(einode)->xtime);      \
-} while (0)
+#define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode)                          \
+       EXT4_INODE_SET_XTIME_VAL(xtime, inode, raw_inode, (inode)->xtime)
+
+#define EXT4_INODE_SET_CTIME(inode, raw_inode)                                 \
+       EXT4_INODE_SET_XTIME_VAL(i_ctime, inode, raw_inode, inode_get_ctime(inode))
+
+#define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode)                                \
+       if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                       \
+               EXT4_INODE_SET_XTIME_VAL(xtime, &((einode)->vfs_inode),         \
+                                        raw_inode, (einode)->xtime)
+
+#define EXT4_INODE_GET_XTIME_VAL(xtime, inode, raw_inode)                      \
+       (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra) ?        \
+               ext4_decode_extra_time((raw_inode)->xtime,                              \
+                                      (raw_inode)->xtime ## _extra) :          \
+               (struct timespec64) {                                           \
+                       .tv_sec = (signed)le32_to_cpu((raw_inode)->xtime)       \
+               })
 
 #define EXT4_INODE_GET_XTIME(xtime, inode, raw_inode)                          \
 do {                                                                           \
-       (inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);        \
-       if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra)) {    \
-               ext4_decode_extra_time(&(inode)->xtime,                         \
-                                      raw_inode->xtime ## _extra);             \
-               }                                                               \
-       else                                                                    \
-               (inode)->xtime.tv_nsec = 0;                                     \
+       (inode)->xtime = EXT4_INODE_GET_XTIME_VAL(xtime, inode, raw_inode);     \
 } while (0)
 
+#define EXT4_INODE_GET_CTIME(inode, raw_inode)                                 \
+do {                                                                           \
+       inode_set_ctime_to_ts(inode,                                            \
+               EXT4_INODE_GET_XTIME_VAL(i_ctime, inode, raw_inode));           \
+} while (0)
 
-#define EXT4_EINODE_GET_XTIME(xtime, einode, raw_inode)                               \
-do {                                                                          \
-       if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                      \
-               (einode)->xtime.tv_sec =                                       \
-                       (signed)le32_to_cpu((raw_inode)->xtime);               \
-       else                                                                   \
-               (einode)->xtime.tv_sec = 0;                                    \
-       if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra))            \
-               ext4_decode_extra_time(&(einode)->xtime,                       \
-                                      raw_inode->xtime ## _extra);            \
-       else                                                                   \
-               (einode)->xtime.tv_nsec = 0;                                   \
+#define EXT4_EINODE_GET_XTIME(xtime, einode, raw_inode)                                \
+do {                                                                           \
+       if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                       \
+               (einode)->xtime =                                               \
+                       EXT4_INODE_GET_XTIME_VAL(xtime, &(einode->vfs_inode),   \
+                                                raw_inode);                    \
+       else                                                                    \
+               (einode)->xtime = (struct timespec64){0, 0};                    \
 } while (0)
 
 #define i_disk_version osd1.linux1.l_i_version

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index e4115d338f1012e5d81ff59df9034384ab5476e9..202c76996b621321c2e00c90e932fed5f48dd9d2 100644 (file)
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -4476,12 +4476,12 @@ retry:
                map.m_lblk += ret;
                map.m_len = len = len - ret;
                epos = (loff_t)map.m_lblk << inode->i_blkbits;
-               inode->i_ctime = current_time(inode);
+               inode_set_ctime_current(inode);
                if (new_size) {
                        if (epos > new_size)
                                epos = new_size;
                        if (ext4_update_inode_size(inode, epos) & 0x1)
-                               inode->i_mtime = inode->i_ctime;
+                               inode->i_mtime = inode_get_ctime(inode);
                }
                ret2 = ext4_mark_inode_dirty(handle, inode);
                ext4_update_inode_fsync_trans(handle, inode, 1);
@@ -4617,7 +4617,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,
 
                /* Now release the pages and zero block aligned part of pages */
                truncate_pagecache_range(inode, start, end - 1);
-               inode->i_mtime = inode->i_ctime = current_time(inode);
+               inode->i_mtime = inode_set_ctime_current(inode);
 
                ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size,
                                             flags);
@@ -4642,7 +4642,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,
                goto out_mutex;
        }
 
-       inode->i_mtime = inode->i_ctime = current_time(inode);
+       inode->i_mtime = inode_set_ctime_current(inode);
        if (new_size)
                ext4_update_inode_size(inode, new_size);
        ret = ext4_mark_inode_dirty(handle, inode);
@@ -5378,7 +5378,7 @@ static int ext4_collapse_range(struct file *file, loff_t offset, loff_t len)
        up_write(&EXT4_I(inode)->i_data_sem);
        if (IS_SYNC(inode))
                ext4_handle_sync(handle);
-       inode->i_mtime = inode->i_ctime = current_time(inode);
+       inode->i_mtime = inode_set_ctime_current(inode);
        ret = ext4_mark_inode_dirty(handle, inode);
        ext4_update_inode_fsync_trans(handle, inode, 1);
 
@@ -5488,7 +5488,7 @@ static int ext4_insert_range(struct file *file, loff_t offset, loff_t len)
        /* Expand file to avoid data loss if there is error while shifting */
        inode->i_size += len;
        EXT4_I(inode)->i_disksize += len;
-       inode->i_mtime = inode->i_ctime = current_time(inode);
+       inode->i_mtime = inode_set_ctime_current(inode);
        ret = ext4_mark_inode_dirty(handle, inode);
        if (ret)
                goto out_stop;

diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 754f961cd9fdfbccb3b1280b40a56bcb3b066454..48abef5f23e7fcffc3ad8011dd826f2ef372d6a6 100644 (file)
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -1250,7 +1250,7 @@ got:
        inode->i_ino = ino + group * EXT4_INODES_PER_GROUP(sb);
        /* This is the optimal IO size (for stat), not the fs block size */
        inode->i_blocks = 0;
-       inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
+       inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode);
        ei->i_crtime = inode->i_mtime;
 
        memset(ei->i_data, 0, sizeof(ei->i_data));

diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c
index a4b7e4bc32d409f23448c9a55fbf48c44bc9617d..0038610373745f7853c53421c8cdccb08ff092b1 100644 (file)
--- a/fs/ext4/inline.c
+++ b/fs/ext4/inline.c
@@ -1037,7 +1037,7 @@ static int ext4_add_dirent_to_inline(handle_t *handle,
         * happen is that the times are slightly out of date
         * and/or different from the directory change time.
         */
-       dir->i_mtime = dir->i_ctime = current_time(dir);
+       dir->i_mtime = inode_set_ctime_current(dir);
        ext4_update_dx_flag(dir);
        inode_inc_iversion(dir);
        return 1;
@@ -1991,7 +1991,7 @@ out:
                ext4_orphan_del(handle, inode);
 
        if (err == 0) {
-               inode->i_mtime = inode->i_ctime = current_time(inode);
+               inode->i_mtime = inode_set_ctime_current(inode);
                err = ext4_mark_inode_dirty(handle, inode);
                if (IS_SYNC(inode))
                        ext4_handle_sync(handle);

diff --git a/fs/ext4/inode-test.c b/fs/ext4/inode-test.c
index 7935ea6cf92ce33a33412f3f3c006a36515ce6e0..f0c0fd507fbc9aa772e4397dc9d6396db04abc5e 100644 (file)
--- a/fs/ext4/inode-test.c
+++ b/fs/ext4/inode-test.c
@@ -245,9 +245,9 @@ static void inode_test_xtimestamp_decoding(struct kunit *test)
        struct timestamp_expectation *test_param =
                        (struct timestamp_expectation *)(test->param_value);
 
-       timestamp.tv_sec = get_32bit_time(test_param);
-       ext4_decode_extra_time(&timestamp,
-                              cpu_to_le32(test_param->extra_bits));
+       timestamp = ext4_decode_extra_time(
+                               cpu_to_le32(get_32bit_time(test_param)),
+                               cpu_to_le32(test_param->extra_bits));
 
        KUNIT_EXPECT_EQ_MSG(test,
                            test_param->expected.tv_sec,

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 43775a6ca5054a485c33932a801928b55240a3c0..86696b40c58f8d841e89839f7ea24597179cdd60 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -3986,7 +3986,7 @@ int ext4_punch_hole(struct file *file, loff_t offset, loff_t length)
        if (IS_SYNC(inode))
                ext4_handle_sync(handle);
 
-       inode->i_mtime = inode->i_ctime = current_time(inode);
+       inode->i_mtime = inode_set_ctime_current(inode);
        ret2 = ext4_mark_inode_dirty(handle, inode);
        if (unlikely(ret2))
                ret = ret2;
@@ -4146,7 +4146,7 @@ out_stop:
        if (inode->i_nlink)
                ext4_orphan_del(handle, inode);
 
-       inode->i_mtime = inode->i_ctime = current_time(inode);
+       inode->i_mtime = inode_set_ctime_current(inode);
        err2 = ext4_mark_inode_dirty(handle, inode);
        if (unlikely(err2 && !err))
                err = err2;
@@ -4249,7 +4249,7 @@ static int ext4_fill_raw_inode(struct inode *inode, struct ext4_inode *raw_inode
        }
        raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
 
-       EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode);
+       EXT4_INODE_SET_CTIME(inode, raw_inode);
        EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode);
        EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
        EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);
@@ -4858,7 +4858,7 @@ struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
                }
        }
 
-       EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode);
+       EXT4_INODE_GET_CTIME(inode, raw_inode);
        EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode);
        EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode);
        EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
@@ -4981,7 +4981,7 @@ static void __ext4_update_other_inode_time(struct super_block *sb,
                spin_unlock(&inode->i_lock);
 
                spin_lock(&ei->i_raw_lock);
-               EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode);
+               EXT4_INODE_SET_CTIME(inode, raw_inode);
                EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode);
                EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
                ext4_inode_csum_set(inode, raw_inode, ei);
@@ -5376,10 +5376,8 @@ int ext4_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
                         * Update c/mtime on truncate up, ext4_truncate() will
                         * update c/mtime in shrink case below
                         */
-                       if (!shrink) {
-                               inode->i_mtime = current_time(inode);
-                               inode->i_ctime = inode->i_mtime;
-                       }
+                       if (!shrink)
+                               inode->i_mtime = inode_set_ctime_current(inode);
 
                        if (shrink)
                                ext4_fc_track_range(handle, inode,

diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 331859511f80fa9f47e3c196c08406bb347e055e..b0349f45186370192fb98e7bf2e67abdcc475f31 100644 (file)
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -449,7 +449,8 @@ static long swap_inode_boot_loader(struct super_block *sb,
        diff = size - size_bl;
        swap_inode_data(inode, inode_bl);
 
-       inode->i_ctime = inode_bl->i_ctime = current_time(inode);
+       inode_set_ctime_current(inode);
+       inode_set_ctime_current(inode_bl);
        inode_inc_iversion(inode);
 
        inode->i_generation = get_random_u32();
@@ -663,7 +664,7 @@ static int ext4_ioctl_setflags(struct inode *inode,
 
        ext4_set_inode_flags(inode, false);
 
-       inode->i_ctime = current_time(inode);
+       inode_set_ctime_current(inode);
        inode_inc_iversion(inode);
 
        err = ext4_mark_iloc_dirty(handle, inode, &iloc);
@@ -774,7 +775,7 @@ static int ext4_ioctl_setproject(struct inode *inode, __u32 projid)
        }
 
        EXT4_I(inode)->i_projid = kprojid;
-       inode->i_ctime = current_time(inode);
+       inode_set_ctime_current(inode);
        inode_inc_iversion(inode);
 out_dirty:
        rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
@@ -1266,7 +1267,7 @@ static long __ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                }
                err = ext4_reserve_inode_write(handle, inode, &iloc);
                if (err == 0) {
-                       inode->i_ctime = current_time(inode);
+                       inode_set_ctime_current(inode);
                        inode_inc_iversion(inode);
                        inode->i_generation = generation;
                        err = ext4_mark_iloc_dirty(handle, inode, &iloc);

diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 0caf6c730ce34b38a6d4eb7a0a176d4ce93bd2ca..933ad03f4f5853542d44f59ea27e2aad15d3d879 100644 (file)
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -2203,7 +2203,7 @@ static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname,
         * happen is that the times are slightly out of date
         * and/or different from the directory change time.
         */
-       dir->i_mtime = dir->i_ctime = current_time(dir);
+       dir->i_mtime = inode_set_ctime_current(dir);
        ext4_update_dx_flag(dir);
        inode_inc_iversion(dir);
        err2 = ext4_mark_inode_dirty(handle, dir);
@@ -3197,7 +3197,8 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
         * recovery. */
        inode->i_size = 0;
        ext4_orphan_add(handle, inode);
-       inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
+       dir->i_mtime = inode_set_ctime_current(dir);
+       inode_set_ctime_current(inode);
        retval = ext4_mark_inode_dirty(handle, inode);
        if (retval)
                goto end_rmdir;
@@ -3271,7 +3272,7 @@ int __ext4_unlink(struct inode *dir, const struct qstr *d_name,
                retval = ext4_delete_entry(handle, dir, de, bh);
                if (retval)
                        goto out_handle;
-               dir->i_ctime = dir->i_mtime = current_time(dir);
+               dir->i_mtime = inode_set_ctime_current(dir);
                ext4_update_dx_flag(dir);
                retval = ext4_mark_inode_dirty(handle, dir);
                if (retval)
@@ -3286,7 +3287,7 @@ int __ext4_unlink(struct inode *dir, const struct qstr *d_name,
                drop_nlink(inode);
        if (!inode->i_nlink)
                ext4_orphan_add(handle, inode);
-       inode->i_ctime = current_time(inode);
+       inode_set_ctime_current(inode);
        retval = ext4_mark_inode_dirty(handle, inode);
        if (dentry && !retval)
                ext4_fc_track_unlink(handle, dentry);
@@ -3463,7 +3464,7 @@ retry:
        if (IS_DIRSYNC(dir))
                ext4_handle_sync(handle);
 
-       inode->i_ctime = current_time(inode);
+       inode_set_ctime_current(inode);
        ext4_inc_count(inode);
        ihold(inode);
 
@@ -3641,8 +3642,7 @@ static int ext4_setent(handle_t *handle, struct ext4_renament *ent,
        if (ext4_has_feature_filetype(ent->dir->i_sb))
                ent->de->file_type = file_type;
        inode_inc_iversion(ent->dir);
-       ent->dir->i_ctime = ent->dir->i_mtime =
-               current_time(ent->dir);
+       ent->dir->i_mtime = inode_set_ctime_current(ent->dir);
        retval = ext4_mark_inode_dirty(handle, ent->dir);
        BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata");
        if (!ent->inlined) {
@@ -3941,7 +3941,7 @@ static int ext4_rename(struct mnt_idmap *idmap, struct inode *old_dir,
         * Like most other Unix systems, set the ctime for inodes on a
         * rename.
         */
-       old.inode->i_ctime = current_time(old.inode);
+       inode_set_ctime_current(old.inode);
        retval = ext4_mark_inode_dirty(handle, old.inode);
        if (unlikely(retval))
                goto end_rename;
@@ -3955,9 +3955,9 @@ static int ext4_rename(struct mnt_idmap *idmap, struct inode *old_dir,
 
        if (new.inode) {
                ext4_dec_count(new.inode);
-               new.inode->i_ctime = current_time(new.inode);
+               inode_set_ctime_current(new.inode);
        }
-       old.dir->i_ctime = old.dir->i_mtime = current_time(old.dir);
+       old.dir->i_mtime = inode_set_ctime_current(old.dir);
        ext4_update_dx_flag(old.dir);
        if (old.dir_bh) {
                retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
@@ -4053,7 +4053,6 @@ static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
        };
        u8 new_file_type;
        int retval;
-       struct timespec64 ctime;
 
        if ((ext4_test_inode_flag(new_dir, EXT4_INODE_PROJINHERIT) &&
             !projid_eq(EXT4_I(new_dir)->i_projid,
@@ -4147,9 +4146,8 @@ static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
         * Like most other Unix systems, set the ctime for inodes on a
         * rename.
         */
-       ctime = current_time(old.inode);
-       old.inode->i_ctime = ctime;
-       new.inode->i_ctime = ctime;
+       inode_set_ctime_current(old.inode);
+       inode_set_ctime_current(new.inode);
        retval = ext4_mark_inode_dirty(handle, old.inode);
        if (unlikely(retval))
                goto end_rename;

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index c94ebf704616e5289b5a10eacddecf8f6c9862a7..b54c70e1a74e7beca4343a64a0b299c5f289c844 100644 (file)
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -7103,7 +7103,7 @@ static int ext4_quota_off(struct super_block *sb, int type)
        }
        EXT4_I(inode)->i_flags &= ~(EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL);
        inode_set_flags(inode, 0, S_NOATIME | S_IMMUTABLE);
-       inode->i_mtime = inode->i_ctime = current_time(inode);
+       inode->i_mtime = inode_set_ctime_current(inode);
        err = ext4_mark_inode_dirty(handle, inode);
        ext4_journal_stop(handle);
 out_unlock:

diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index 321e3a888c20bf26880debed2d8374cdb01c2a7d..dbe54cddda3d215abaea3b5840cb729d5046e6b4 100644 (file)
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -356,13 +356,13 @@ ext4_xattr_inode_hash(struct ext4_sb_info *sbi, const void *buffer, size_t size)
 
 static u64 ext4_xattr_inode_get_ref(struct inode *ea_inode)
 {
-       return ((u64)ea_inode->i_ctime.tv_sec << 32) |
+       return ((u64) inode_get_ctime(ea_inode).tv_sec << 32) |
                (u32) inode_peek_iversion_raw(ea_inode);
 }
 
 static void ext4_xattr_inode_set_ref(struct inode *ea_inode, u64 ref_count)
 {
-       ea_inode->i_ctime.tv_sec = (u32)(ref_count >> 32);
+       inode_set_ctime(ea_inode, (u32)(ref_count >> 32), 0);
        inode_set_iversion_raw(ea_inode, ref_count & 0xffffffff);
 }
 
@@ -2459,7 +2459,7 @@ retry_inode:
        }
        if (!error) {
                ext4_xattr_update_super_block(handle, inode->i_sb);
-               inode->i_ctime = current_time(inode);
+               inode_set_ctime_current(inode);
                inode_inc_iversion(inode);
                if (!value)
                        no_expand = 0;