f2fs: convert to new timestamp accessors

Convert to using the new inode timestamp accessor functions.

Signed-off-by: Jeff Layton <jlayton@kernel.org>
Link: https://lore.kernel.org/r/20231004185347.80880-34-jlayton@kernel.org
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index 8aa29fe2e87b8a41e94e7b5991f8c4547a43a592..042593aed1ec0a79cdae8846d0e79c06674d97ca 100644 (file)
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -455,7 +455,7 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
        de->file_type = fs_umode_to_ftype(inode->i_mode);
        set_page_dirty(page);
 
-       dir->i_mtime = inode_set_ctime_current(dir);
+       inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
        f2fs_mark_inode_dirty_sync(dir, false);
        f2fs_put_page(page, 1);
 }
@@ -609,7 +609,7 @@ void f2fs_update_parent_metadata(struct inode *dir, struct inode *inode,
                        f2fs_i_links_write(dir, true);
                clear_inode_flag(inode, FI_NEW_INODE);
        }
-       dir->i_mtime = inode_set_ctime_current(dir);
+       inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
        f2fs_mark_inode_dirty_sync(dir, false);
 
        if (F2FS_I(dir)->i_current_depth != current_depth)
@@ -919,7 +919,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
        }
        f2fs_put_page(page, 1);
 
-       dir->i_mtime = inode_set_ctime_current(dir);
+       inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
        f2fs_mark_inode_dirty_sync(dir, false);
 
        if (inode)

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 6d688e42d89c59a84e4d17f681d304cb7c015431..cb9927a6d0c8070a4b0dcb2a1adc2b6e661f6df9 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -3317,13 +3317,15 @@ static inline void clear_file(struct inode *inode, int type)
 
 static inline bool f2fs_is_time_consistent(struct inode *inode)
 {
-       struct timespec64 ctime = inode_get_ctime(inode);
+       struct timespec64 ts = inode_get_atime(inode);
 
-       if (!timespec64_equal(F2FS_I(inode)->i_disk_time, &inode->i_atime))
+       if (!timespec64_equal(F2FS_I(inode)->i_disk_time, &ts))
                return false;
-       if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 1, &ctime))
+       ts = inode_get_ctime(inode);
+       if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 1, &ts))
                return false;
-       if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 2, &inode->i_mtime))
+       ts = inode_get_mtime(inode);
+       if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 2, &ts))
                return false;
        return true;
 }

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index ca5904129b1620690dc8cae13f365607b4ef0cf7..dd99abbb7186aa340ae1636f52b7416519a92514 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -798,7 +798,7 @@ int f2fs_truncate(struct inode *inode)
        if (err)
                return err;
 
-       inode->i_mtime = inode_set_ctime_current(inode);
+       inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
        f2fs_mark_inode_dirty_sync(inode, false);
        return 0;
 }
@@ -905,9 +905,9 @@ static void __setattr_copy(struct mnt_idmap *idmap,
        i_uid_update(idmap, attr, inode);
        i_gid_update(idmap, attr, inode);
        if (ia_valid & ATTR_ATIME)
-               inode->i_atime = attr->ia_atime;
+               inode_set_atime_to_ts(inode, attr->ia_atime);
        if (ia_valid & ATTR_MTIME)
-               inode->i_mtime = attr->ia_mtime;
+               inode_set_mtime_to_ts(inode, attr->ia_mtime);
        if (ia_valid & ATTR_CTIME)
                inode_set_ctime_to_ts(inode, attr->ia_ctime);
        if (ia_valid & ATTR_MODE) {
@@ -1012,7 +1012,7 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
                        return err;
 
                spin_lock(&F2FS_I(inode)->i_size_lock);
-               inode->i_mtime = inode_set_ctime_current(inode);
+               inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
                F2FS_I(inode)->last_disk_size = i_size_read(inode);
                spin_unlock(&F2FS_I(inode)->i_size_lock);
        }
@@ -1840,7 +1840,7 @@ static long f2fs_fallocate(struct file *file, int mode,
        }
 
        if (!ret) {
-               inode->i_mtime = inode_set_ctime_current(inode);
+               inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
                f2fs_mark_inode_dirty_sync(inode, false);
                f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
        }
@@ -2888,10 +2888,10 @@ out_src:
        if (ret)
                goto out_unlock;
 
-       src->i_mtime = inode_set_ctime_current(src);
+       inode_set_mtime_to_ts(src, inode_set_ctime_current(src));
        f2fs_mark_inode_dirty_sync(src, false);
        if (src != dst) {
-               dst->i_mtime = inode_set_ctime_current(dst);
+               inode_set_mtime_to_ts(dst, inode_set_ctime_current(dst));
                f2fs_mark_inode_dirty_sync(dst, false);
        }
        f2fs_update_time(sbi, REQ_TIME);

diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 2fe25619ccb5f55c7eba1e1a7e8ffd656785c93a..ac00423f117b5cb14af48a7cf579c2de76add278 100644 (file)
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -699,7 +699,7 @@ void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
        set_page_dirty(page);
        f2fs_put_page(page, 1);
 
-       dir->i_mtime = inode_set_ctime_current(dir);
+       inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
        f2fs_mark_inode_dirty_sync(dir, false);
 
        if (inode)

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index cde243840abd19b1efc576cfaa34911d2f60e328..5779c7edd49b753d3e032d50f00ed0f79ecfa65b 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -386,9 +386,9 @@ static void init_idisk_time(struct inode *inode)
 {
        struct f2fs_inode_info *fi = F2FS_I(inode);
 
-       fi->i_disk_time[0] = inode->i_atime;
+       fi->i_disk_time[0] = inode_get_atime(inode);
        fi->i_disk_time[1] = inode_get_ctime(inode);
-       fi->i_disk_time[2] = inode->i_mtime;
+       fi->i_disk_time[2] = inode_get_mtime(inode);
 }
 
 static int do_read_inode(struct inode *inode)
@@ -417,12 +417,12 @@ static int do_read_inode(struct inode *inode)
        inode->i_size = le64_to_cpu(ri->i_size);
        inode->i_blocks = SECTOR_FROM_BLOCK(le64_to_cpu(ri->i_blocks) - 1);
 
-       inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime);
+       inode_set_atime(inode, le64_to_cpu(ri->i_atime),
+                       le32_to_cpu(ri->i_atime_nsec));
        inode_set_ctime(inode, le64_to_cpu(ri->i_ctime),
                        le32_to_cpu(ri->i_ctime_nsec));
-       inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime);
-       inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
-       inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
+       inode_set_mtime(inode, le64_to_cpu(ri->i_mtime),
+                       le32_to_cpu(ri->i_mtime_nsec));
        inode->i_generation = le32_to_cpu(ri->i_generation);
        if (S_ISDIR(inode->i_mode))
                fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
@@ -698,12 +698,12 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page)
        }
        set_raw_inline(inode, ri);
 
-       ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
-       ri->i_ctime = cpu_to_le64(inode_get_ctime(inode).tv_sec);
-       ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
-       ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
-       ri->i_ctime_nsec = cpu_to_le32(inode_get_ctime(inode).tv_nsec);
-       ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
+       ri->i_atime = cpu_to_le64(inode_get_atime_sec(inode));
+       ri->i_ctime = cpu_to_le64(inode_get_ctime_sec(inode));
+       ri->i_mtime = cpu_to_le64(inode_get_mtime_sec(inode));
+       ri->i_atime_nsec = cpu_to_le32(inode_get_atime_nsec(inode));
+       ri->i_ctime_nsec = cpu_to_le32(inode_get_ctime_nsec(inode));
+       ri->i_mtime_nsec = cpu_to_le32(inode_get_mtime_nsec(inode));
        if (S_ISDIR(inode->i_mode))
                ri->i_current_depth =
                        cpu_to_le32(F2FS_I(inode)->i_current_depth);

diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 193b22a2d6bfb2a5c90be3271f423bd4ea11adb6..d0053b0284d8e53386ace76c6c957dca10e11f8c 100644 (file)
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -243,8 +243,8 @@ static struct inode *f2fs_new_inode(struct mnt_idmap *idmap,
 
        inode->i_ino = ino;
        inode->i_blocks = 0;
-       inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode);
-       F2FS_I(inode)->i_crtime = inode->i_mtime;
+       simple_inode_init_ts(inode);
+       F2FS_I(inode)->i_crtime = inode_get_mtime(inode);
        inode->i_generation = get_random_u32();
 
        if (S_ISDIR(inode->i_mode))

diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 7be60df277a5293f1bcb58aabc06d96b1c703666..b56d0f1078a76c463691420305f1a1127a913889 100644 (file)
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -320,12 +320,12 @@ static int recover_inode(struct inode *inode, struct page *page)
        }
 
        f2fs_i_size_write(inode, le64_to_cpu(raw->i_size));
-       inode->i_atime.tv_sec = le64_to_cpu(raw->i_atime);
+       inode_set_atime(inode, le64_to_cpu(raw->i_atime),
+                       le32_to_cpu(raw->i_atime_nsec));
        inode_set_ctime(inode, le64_to_cpu(raw->i_ctime),
                        le32_to_cpu(raw->i_ctime_nsec));
-       inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);
-       inode->i_atime.tv_nsec = le32_to_cpu(raw->i_atime_nsec);
-       inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
+       inode_set_mtime(inode, le64_to_cpu(raw->i_mtime),
+                       le32_to_cpu(raw->i_mtime_nsec));
 
        F2FS_I(inode)->i_advise = raw->i_advise;
        F2FS_I(inode)->i_flags = le32_to_cpu(raw->i_flags);

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index a8c8232852bb18749f8a60238c15dfab7f55e0e7..ca965136c09fa4615a67763285846349d7830ead 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -2710,7 +2710,7 @@ retry:
 
        if (len == towrite)
                return err;
-       inode->i_mtime = inode_set_ctime_current(inode);
+       inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
        f2fs_mark_inode_dirty_sync(inode, false);
        return len - towrite;
 }