client: convert to new timestamp accessors

[ Upstream commit 8f22ce7088835444418f0775efb455d10b825596 ]

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-66-jlayton@kernel.org
Signed-off-by: Christian Brauner <brauner@kernel.org>
Stable-dep-of: 01fe654f78fd ("fs: cifs: Fix atime update check")
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/fs/smb/client/file.c b/fs/smb/client/file.c
index 2108b3b..cf17e3d 100644 (file)
--- a/fs/smb/client/file.c
+++ b/fs/smb/client/file.c
@@ -1085,7 +1085,8 @@ int cifs_close(struct inode *inode, struct file *file)
                    !test_bit(CIFS_INO_CLOSE_ON_LOCK, &cinode->flags) &&
                    dclose) {
                        if (test_and_clear_bit(CIFS_INO_MODIFIED_ATTR, &cinode->flags)) {
-                               inode->i_mtime = inode_set_ctime_current(inode);
+                               inode_set_mtime_to_ts(inode,
+                                                     inode_set_ctime_current(inode));
                        }
                        spin_lock(&cinode->deferred_lock);
                        cifs_add_deferred_close(cfile, dclose);
@@ -2596,7 +2597,7 @@ static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
                                           write_data, to - from, &offset);
                cifsFileInfo_put(open_file);
                /* Does mm or vfs already set times? */
-               inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode);
+               simple_inode_init_ts(inode);
                if ((bytes_written > 0) && (offset))
                        rc = 0;
                else if (bytes_written < 0)
@@ -4647,11 +4648,13 @@ static void cifs_readahead(struct readahead_control *ractl)
 static int cifs_readpage_worker(struct file *file, struct page *page,
        loff_t *poffset)
 {
+       struct inode *inode = file_inode(file);
+       struct timespec64 atime, mtime;
        char *read_data;
        int rc;
 
        /* Is the page cached? */
-       rc = cifs_readpage_from_fscache(file_inode(file), page);
+       rc = cifs_readpage_from_fscache(inode, page);
        if (rc == 0)
                goto read_complete;
 
@@ -4666,11 +4669,10 @@ static int cifs_readpage_worker(struct file *file, struct page *page,
                cifs_dbg(FYI, "Bytes read %d\n", rc);
 
        /* we do not want atime to be less than mtime, it broke some apps */
-       file_inode(file)->i_atime = current_time(file_inode(file));
-       if (timespec64_compare(&(file_inode(file)->i_atime), &(file_inode(file)->i_mtime)))
-               file_inode(file)->i_atime = file_inode(file)->i_mtime;
-       else
-               file_inode(file)->i_atime = current_time(file_inode(file));
+       atime = inode_set_atime_to_ts(inode, current_time(inode));
+       mtime = inode_get_mtime(inode);
+       if (timespec64_compare(&atime, &mtime))
+               inode_set_atime_to_ts(inode, inode_get_mtime(inode));
 
        if (PAGE_SIZE > rc)
                memset(read_data + rc, 0, PAGE_SIZE - rc);

diff --git a/fs/smb/client/fscache.h b/fs/smb/client/fscache.h
index 84f3b09..a3d7372 100644 (file)
--- a/fs/smb/client/fscache.h
+++ b/fs/smb/client/fscache.h
@@ -49,12 +49,12 @@ static inline
 void cifs_fscache_fill_coherency(struct inode *inode,
                                 struct cifs_fscache_inode_coherency_data *cd)
 {
-       struct cifsInodeInfo *cifsi = CIFS_I(inode);
        struct timespec64 ctime = inode_get_ctime(inode);
+       struct timespec64 mtime = inode_get_mtime(inode);
 
        memset(cd, 0, sizeof(*cd));
-       cd->last_write_time_sec   = cpu_to_le64(cifsi->netfs.inode.i_mtime.tv_sec);
-       cd->last_write_time_nsec  = cpu_to_le32(cifsi->netfs.inode.i_mtime.tv_nsec);
+       cd->last_write_time_sec   = cpu_to_le64(mtime.tv_sec);
+       cd->last_write_time_nsec  = cpu_to_le32(mtime.tv_nsec);
        cd->last_change_time_sec  = cpu_to_le64(ctime.tv_sec);
        cd->last_change_time_nsec = cpu_to_le32(ctime.tv_nsec);
 }

diff --git a/fs/smb/client/inode.c b/fs/smb/client/inode.c
index 6a85694..09c5c0f 100644 (file)
--- a/fs/smb/client/inode.c
+++ b/fs/smb/client/inode.c
@@ -82,6 +82,7 @@ cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
 {
        struct cifs_fscache_inode_coherency_data cd;
        struct cifsInodeInfo *cifs_i = CIFS_I(inode);
+       struct timespec64 mtime;
 
        cifs_dbg(FYI, "%s: revalidating inode %llu\n",
                 __func__, cifs_i->uniqueid);
@@ -101,7 +102,8 @@ cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
 
         /* revalidate if mtime or size have changed */
        fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
-       if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
+       mtime = inode_get_mtime(inode);
+       if (timespec64_equal(&mtime, &fattr->cf_mtime) &&
            cifs_i->server_eof == fattr->cf_eof) {
                cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
                         __func__, cifs_i->uniqueid);
@@ -164,10 +166,10 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
        fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
        /* we do not want atime to be less than mtime, it broke some apps */
        if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
-               inode->i_atime = fattr->cf_mtime;
+               inode_set_atime_to_ts(inode, fattr->cf_mtime);
        else
-               inode->i_atime = fattr->cf_atime;
-       inode->i_mtime = fattr->cf_mtime;
+               inode_set_atime_to_ts(inode, fattr->cf_atime);
+       inode_set_mtime_to_ts(inode, fattr->cf_mtime);
        inode_set_ctime_to_ts(inode, fattr->cf_ctime);
        inode->i_rdev = fattr->cf_rdev;
        cifs_nlink_fattr_to_inode(inode, fattr);
@@ -1868,7 +1870,7 @@ out_reval:
                                           when needed */
                inode_set_ctime_current(inode);
        }
-       dir->i_mtime = inode_set_ctime_current(dir);
+       inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
        cifs_inode = CIFS_I(dir);
        CIFS_I(dir)->time = 0;  /* force revalidate of dir as well */
 unlink_out:
@@ -2183,7 +2185,7 @@ int cifs_rmdir(struct inode *inode, struct dentry *direntry)
        cifsInode->time = 0;
 
        inode_set_ctime_current(d_inode(direntry));
-       inode->i_mtime = inode_set_ctime_current(inode);
+       inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
 
 rmdir_exit:
        free_dentry_path(page);
@@ -2389,9 +2391,6 @@ unlink_target:
        /* force revalidate to go get info when needed */
        CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
 
-       source_dir->i_mtime = target_dir->i_mtime = inode_set_ctime_to_ts(source_dir,
-                                                                         inode_set_ctime_current(target_dir));
-
 cifs_rename_exit:
        kfree(info_buf_source);
        free_dentry_path(page2);

diff --git a/fs/smb/client/smb2ops.c b/fs/smb/client/smb2ops.c
index 2187921..e917eeb 100644 (file)
--- a/fs/smb/client/smb2ops.c
+++ b/fs/smb/client/smb2ops.c
@@ -1409,12 +1409,14 @@ smb2_close_getattr(const unsigned int xid, struct cifs_tcon *tcon,
 
        /* Creation time should not need to be updated on close */
        if (file_inf.LastWriteTime)
-               inode->i_mtime = cifs_NTtimeToUnix(file_inf.LastWriteTime);
+               inode_set_mtime_to_ts(inode,
+                                     cifs_NTtimeToUnix(file_inf.LastWriteTime));
        if (file_inf.ChangeTime)
                inode_set_ctime_to_ts(inode,
                                      cifs_NTtimeToUnix(file_inf.ChangeTime));
        if (file_inf.LastAccessTime)
-               inode->i_atime = cifs_NTtimeToUnix(file_inf.LastAccessTime);
+               inode_set_atime_to_ts(inode,
+                                     cifs_NTtimeToUnix(file_inf.LastAccessTime));
 
        /*
         * i_blocks is not related to (i_size / i_blksize),