7 files changed, 68 insertions, 59 deletions

diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index afcc59ed7090..292b3d72d725 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -574,6 +574,7 @@ static u64 get_writepages_data_length(struct inode *inode,
  */
 static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
 {
+        struct timespec ts;
         struct inode *inode;
         struct ceph_inode_info *ci;
         struct ceph_fs_client *fsc;
@@ -624,11 +625,12 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
                 set_bdi_congested(inode_to_bdi(inode), BLK_RW_ASYNC);
 
         set_page_writeback(page);
+        ts = timespec64_to_timespec(inode->i_mtime);
         err = ceph_osdc_writepages(&fsc->client->osdc, ceph_vino(inode),
                                    &ci->i_layout, snapc, page_off, len,
                                    ceph_wbc.truncate_seq,
                                    ceph_wbc.truncate_size,
-                                   &inode->i_mtime, &page, 1);
+                                   &ts, &page, 1);
         if (err < 0) {
                 struct writeback_control tmp_wbc;
                 if (!wbc)
@@ -1132,7 +1134,7 @@ new_request:
                         pages = NULL;
                 }
 
-                req->r_mtime = inode->i_mtime;
+                req->r_mtime = timespec64_to_timespec(inode->i_mtime);
                 rc = ceph_osdc_start_request(&fsc->client->osdc, req, true);
                 BUG_ON(rc);
                 req = NULL;
@@ -1732,7 +1734,7 @@ int ceph_uninline_data(struct file *filp, struct page *locked_page)
                 goto out;
         }
 
-        req->r_mtime = inode->i_mtime;
+        req->r_mtime = timespec64_to_timespec(inode->i_mtime);
         err = ceph_osdc_start_request(&fsc->client->osdc, req, false);
         if (!err)
                 err = ceph_osdc_wait_request(&fsc->client->osdc, req);
@@ -1774,7 +1776,7 @@ int ceph_uninline_data(struct file *filp, struct page *locked_page)
                         goto out_put;
         }
 
-        req->r_mtime = inode->i_mtime;
+        req->r_mtime = timespec64_to_timespec(inode->i_mtime);
         err = ceph_osdc_start_request(&fsc->client->osdc, req, false);
         if (!err)
                 err = ceph_osdc_wait_request(&fsc->client->osdc, req);
@@ -1935,7 +1937,7 @@ static int __ceph_pool_perm_get(struct ceph_inode_info *ci,
                                      0, false, true);
         err = ceph_osdc_start_request(&fsc->client->osdc, rd_req, false);
 
-        wr_req->r_mtime = ci->vfs_inode.i_mtime;
+        wr_req->r_mtime = timespec64_to_timespec(ci->vfs_inode.i_mtime);
         err2 = ceph_osdc_start_request(&fsc->client->osdc, wr_req, false);
 
         if (!err)
diff --git a/fs/ceph/cache.c b/fs/ceph/cache.c
index bb524c880b1e..362900e42424 100644
--- a/fs/ceph/cache.c
+++ b/fs/ceph/cache.c
@@ -130,7 +130,7 @@ static enum fscache_checkaux ceph_fscache_inode_check_aux(
 
         memset(&aux, 0, sizeof(aux));
         aux.version = ci->i_version;
-        aux.mtime = inode->i_mtime;
+        aux.mtime = timespec64_to_timespec(inode->i_mtime);
 
         if (memcmp(data, &aux, sizeof(aux)) != 0)
                 return FSCACHE_CHECKAUX_OBSOLETE;
@@ -163,7 +163,7 @@ void ceph_fscache_register_inode_cookie(struct inode *inode)
         if (!ci->fscache) {
                 memset(&aux, 0, sizeof(aux));
                 aux.version = ci->i_version;
-                aux.mtime = inode->i_mtime;
+                aux.mtime = timespec64_to_timespec(inode->i_mtime);
                 ci->fscache = fscache_acquire_cookie(fsc->fscache,
                                                      &ceph_fscache_inode_object_def,
                                                      &ci->i_vino, sizeof(ci->i_vino),
diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index 0ae41854d676..990258cbd836 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -1360,9 +1360,9 @@ static int __send_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap,
                 arg.xattr_buf = NULL;
         }
 
-        arg.mtime = inode->i_mtime;
-        arg.atime = inode->i_atime;
-        arg.ctime = inode->i_ctime;
+        arg.mtime = timespec64_to_timespec(inode->i_mtime);
+        arg.atime = timespec64_to_timespec(inode->i_atime);
+        arg.ctime = timespec64_to_timespec(inode->i_ctime);
 
         arg.op = op;
         arg.caps = cap->implemented;
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 6b9f7f3cd237..ad0bed99b1d5 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -923,7 +923,7 @@ ceph_direct_read_write(struct kiocb *iocb, struct iov_iter *iter,
         int num_pages = 0;
         int flags;
         int ret;
-        struct timespec mtime = current_time(inode);
+        struct timespec mtime = timespec64_to_timespec(current_time(inode));
         size_t count = iov_iter_count(iter);
         loff_t pos = iocb->ki_pos;
         bool write = iov_iter_rw(iter) == WRITE;
@@ -1131,7 +1131,7 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
         int flags;
         int ret;
         bool check_caps = false;
-        struct timespec mtime = current_time(inode);
+        struct timespec mtime = timespec64_to_timespec(current_time(inode));
         size_t count = iov_iter_count(from);
 
         if (ceph_snap(file_inode(file)) != CEPH_NOSNAP)
@@ -1663,7 +1663,7 @@ static int ceph_zero_partial_object(struct inode *inode,
                 goto out;
         }
 
-        req->r_mtime = inode->i_mtime;
+        req->r_mtime = timespec64_to_timespec(inode->i_mtime);
         ret = ceph_osdc_start_request(&fsc->client->osdc, req, false);
         if (!ret) {
                 ret = ceph_osdc_wait_request(&fsc->client->osdc, req);
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index 4fda7a9d4c9d..ee764ac352ab 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -662,6 +662,9 @@ void ceph_fill_file_time(struct inode *inode, int issued,
                          struct timespec *mtime, struct timespec *atime)
 {
         struct ceph_inode_info *ci = ceph_inode(inode);
+        struct timespec64 ctime64 = timespec_to_timespec64(*ctime);
+        struct timespec64 mtime64 = timespec_to_timespec64(*mtime);
+        struct timespec64 atime64 = timespec_to_timespec64(*atime);
         int warn = 0;
 
         if (issued & (CEPH_CAP_FILE_EXCL|
@@ -670,39 +673,39 @@ void ceph_fill_file_time(struct inode *inode, int issued,
                       CEPH_CAP_AUTH_EXCL|
                       CEPH_CAP_XATTR_EXCL)) {
                 if (ci->i_version == 0 ||
-                    timespec_compare(ctime, &inode->i_ctime) > 0) {
-                        dout("ctime %ld.%09ld -> %ld.%09ld inc w/ cap\n",
-                             inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
-                             ctime->tv_sec, ctime->tv_nsec);
-                        inode->i_ctime = *ctime;
+                    timespec64_compare(&ctime64, &inode->i_ctime) > 0) {
+                        dout("ctime %lld.%09ld -> %lld.%09ld inc w/ cap\n",
+                             (long long)inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
+                             (long long)ctime->tv_sec, ctime->tv_nsec);
+                        inode->i_ctime = ctime64;
                 }
                 if (ci->i_version == 0 ||
                     ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) > 0) {
                         /* the MDS did a utimes() */
-                        dout("mtime %ld.%09ld -> %ld.%09ld "
+                        dout("mtime %lld.%09ld -> %lld.%09ld "
                              "tw %d -> %d\n",
-                             inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
-                             mtime->tv_sec, mtime->tv_nsec,
+                             (long long)inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
+                             (long long)mtime->tv_sec, mtime->tv_nsec,
                              ci->i_time_warp_seq, (int)time_warp_seq);
 
-                        inode->i_mtime = *mtime;
-                        inode->i_atime = *atime;
+                        inode->i_mtime = mtime64;
+                        inode->i_atime = atime64;
                         ci->i_time_warp_seq = time_warp_seq;
                 } else if (time_warp_seq == ci->i_time_warp_seq) {
                         /* nobody did utimes(); take the max */
-                        if (timespec_compare(mtime, &inode->i_mtime) > 0) {
-                                dout("mtime %ld.%09ld -> %ld.%09ld inc\n",
-                                     inode->i_mtime.tv_sec,
+                        if (timespec64_compare(&mtime64, &inode->i_mtime) > 0) {
+                                dout("mtime %lld.%09ld -> %lld.%09ld inc\n",
+                                     (long long)inode->i_mtime.tv_sec,
                                      inode->i_mtime.tv_nsec,
-                                     mtime->tv_sec, mtime->tv_nsec);
-                                inode->i_mtime = *mtime;
+                                     (long long)mtime->tv_sec, mtime->tv_nsec);
+                                inode->i_mtime = mtime64;
                         }
-                        if (timespec_compare(atime, &inode->i_atime) > 0) {
-                                dout("atime %ld.%09ld -> %ld.%09ld inc\n",
-                                     inode->i_atime.tv_sec,
+                        if (timespec64_compare(&atime64, &inode->i_atime) > 0) {
+                                dout("atime %lld.%09ld -> %lld.%09ld inc\n",
+                                     (long long)inode->i_atime.tv_sec,
                                      inode->i_atime.tv_nsec,
-                                     atime->tv_sec, atime->tv_nsec);
-                                inode->i_atime = *atime;
+                                     (long long)atime->tv_sec, atime->tv_nsec);
+                                inode->i_atime = atime64;
                         }
                 } else if (issued & CEPH_CAP_FILE_EXCL) {
                         /* we did a utimes(); ignore mds values */
@@ -712,9 +715,9 @@ void ceph_fill_file_time(struct inode *inode, int issued,
         } else {
                 /* we have no write|excl caps; whatever the MDS says is true */
                 if (ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) >= 0) {
-                        inode->i_ctime = *ctime;
-                        inode->i_mtime = *mtime;
-                        inode->i_atime = *atime;
+                        inode->i_ctime = ctime64;
+                        inode->i_mtime = mtime64;
+                        inode->i_atime = atime64;
                         ci->i_time_warp_seq = time_warp_seq;
                 } else {
                         warn = 1;
@@ -1950,6 +1953,7 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr)
         int err = 0;
         int inode_dirty_flags = 0;
         bool lock_snap_rwsem = false;
+        struct timespec ts;
 
         prealloc_cf = ceph_alloc_cap_flush();
         if (!prealloc_cf)
@@ -2024,44 +2028,44 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr)
         }
 
         if (ia_valid & ATTR_ATIME) {
-                dout("setattr %p atime %ld.%ld -> %ld.%ld\n", inode,
-                     inode->i_atime.tv_sec, inode->i_atime.tv_nsec,
-                     attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec);
+                dout("setattr %p atime %lld.%ld -> %lld.%ld\n", inode,
+                     (long long)inode->i_atime.tv_sec, inode->i_atime.tv_nsec,
+                     (long long)attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec);
                 if (issued & CEPH_CAP_FILE_EXCL) {
                         ci->i_time_warp_seq++;
                         inode->i_atime = attr->ia_atime;
                         dirtied |= CEPH_CAP_FILE_EXCL;
                 } else if ((issued & CEPH_CAP_FILE_WR) &&
-                           timespec_compare(&inode->i_atime,
+                           timespec64_compare(&inode->i_atime,
                                             &attr->ia_atime) < 0) {
                         inode->i_atime = attr->ia_atime;
                         dirtied |= CEPH_CAP_FILE_WR;
                 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
-                           !timespec_equal(&inode->i_atime, &attr->ia_atime)) {
-                        ceph_encode_timespec(&req->r_args.setattr.atime,
-                                             &attr->ia_atime);
+                           !timespec64_equal(&inode->i_atime, &attr->ia_atime)) {
+                        ts = timespec64_to_timespec(attr->ia_atime);
+                        ceph_encode_timespec(&req->r_args.setattr.atime, &ts);
                         mask |= CEPH_SETATTR_ATIME;
                         release |= CEPH_CAP_FILE_SHARED |
                                    CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
                 }
         }
         if (ia_valid & ATTR_MTIME) {
-                dout("setattr %p mtime %ld.%ld -> %ld.%ld\n", inode,
-                     inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
-                     attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec);
+                dout("setattr %p mtime %lld.%ld -> %lld.%ld\n", inode,
+                     (long long)inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
+                     (long long)attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec);
                 if (issued & CEPH_CAP_FILE_EXCL) {
                         ci->i_time_warp_seq++;
                         inode->i_mtime = attr->ia_mtime;
                         dirtied |= CEPH_CAP_FILE_EXCL;
                 } else if ((issued & CEPH_CAP_FILE_WR) &&
-                           timespec_compare(&inode->i_mtime,
+                           timespec64_compare(&inode->i_mtime,
                                             &attr->ia_mtime) < 0) {
                         inode->i_mtime = attr->ia_mtime;
                         dirtied |= CEPH_CAP_FILE_WR;
                 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
-                           !timespec_equal(&inode->i_mtime, &attr->ia_mtime)) {
-                        ceph_encode_timespec(&req->r_args.setattr.mtime,
-                                             &attr->ia_mtime);
+                           !timespec64_equal(&inode->i_mtime, &attr->ia_mtime)) {
+                        ts = timespec64_to_timespec(attr->ia_mtime);
+                        ceph_encode_timespec(&req->r_args.setattr.mtime, &ts);
                         mask |= CEPH_SETATTR_MTIME;
                         release |= CEPH_CAP_FILE_SHARED |
                                    CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
@@ -2091,9 +2095,9 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr)
         if (ia_valid & ATTR_CTIME) {
                 bool only = (ia_valid & (ATTR_SIZE|ATTR_MTIME|ATTR_ATIME|
                                          ATTR_MODE|ATTR_UID|ATTR_GID)) == 0;
-                dout("setattr %p ctime %ld.%ld -> %ld.%ld (%s)\n", inode,
-                     inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
-                     attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec,
+                dout("setattr %p ctime %lld.%ld -> %lld.%ld (%s)\n", inode,
+                     (long long)inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
+                     (long long)attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec,
                      only ? "ctime only" : "ignored");
                 if (only) {
                         /*
@@ -2135,7 +2139,7 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr)
                 req->r_inode_drop = release;
                 req->r_args.setattr.mask = cpu_to_le32(mask);
                 req->r_num_caps = 1;
-                req->r_stamp = attr->ia_ctime;
+                req->r_stamp = timespec64_to_timespec(attr->ia_ctime);
                 err = ceph_mdsc_do_request(mdsc, NULL, req);
         }
         dout("setattr %p result=%d (%s locally, %d remote)\n", inode, err,
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index cf8d24812cc0..dc8bc664a871 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -2958,12 +2958,15 @@ static int encode_caps_cb(struct inode *inode, struct ceph_cap *cap,
                 rec.v2.flock_len = (__force __le32)
                         ((ci->i_ceph_flags & CEPH_I_ERROR_FILELOCK) ? 0 : 1);
         } else {
+                struct timespec ts;
                 rec.v1.cap_id = cpu_to_le64(cap->cap_id);
                 rec.v1.wanted = cpu_to_le32(__ceph_caps_wanted(ci));
                 rec.v1.issued = cpu_to_le32(cap->issued);
                 rec.v1.size = cpu_to_le64(inode->i_size);
-                ceph_encode_timespec(&rec.v1.mtime, &inode->i_mtime);
-                ceph_encode_timespec(&rec.v1.atime, &inode->i_atime);
+                ts = timespec64_to_timespec(inode->i_mtime);
+                ceph_encode_timespec(&rec.v1.mtime, &ts);
+                ts = timespec64_to_timespec(inode->i_atime);
+                ceph_encode_timespec(&rec.v1.atime, &ts);
                 rec.v1.snaprealm = cpu_to_le64(ci->i_snap_realm->ino);
                 rec.v1.pathbase = cpu_to_le64(pathbase);
         }
diff --git a/fs/ceph/snap.c b/fs/ceph/snap.c
index 041c27ea8de1..af81555c14fd 100644
--- a/fs/ceph/snap.c
+++ b/fs/ceph/snap.c
@@ -594,9 +594,9 @@ int __ceph_finish_cap_snap(struct ceph_inode_info *ci,
 
         BUG_ON(capsnap->writing);
         capsnap->size = inode->i_size;
-        capsnap->mtime = inode->i_mtime;
-        capsnap->atime = inode->i_atime;
-        capsnap->ctime = inode->i_ctime;
+        capsnap->mtime = timespec64_to_timespec(inode->i_mtime);
+        capsnap->atime = timespec64_to_timespec(inode->i_atime);
+        capsnap->ctime = timespec64_to_timespec(inode->i_ctime);
         capsnap->time_warp_seq = ci->i_time_warp_seq;
         capsnap->truncate_size = ci->i_truncate_size;
         capsnap->truncate_seq = ci->i_truncate_seq;