Merge tag 'vfs-timespec64' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/playground

Pull inode timestamps conversion to timespec64 from Arnd Bergmann:
 "This is a late set of changes from Deepa Dinamani doing an automated
  treewide conversion of the inode and iattr structures from 'timespec'
  to 'timespec64', to push the conversion from the VFS layer into the
  individual file systems.

  As Deepa writes:

   'The series aims to switch vfs timestamps to use struct timespec64.
    Currently vfs uses struct timespec, which is not y2038 safe.

    The series involves the following:
    1. Add vfs helper functions for supporting struct timepec64
       timestamps.
    2. Cast prints of vfs timestamps to avoid warnings after the switch.
    3. Simplify code using vfs timestamps so that the actual replacement
       becomes easy.
    4. Convert vfs timestamps to use struct timespec64 using a script.
       This is a flag day patch.

    Next steps:
    1. Convert APIs that can handle timespec64, instead of converting
       timestamps at the boundaries.
    2. Update internal data structures to avoid timestamp conversions'

  Thomas Gleixner adds:

   'I think there is no point to drag that out for the next merge
    window. The whole thing needs to be done in one go for the core
    changes which means that you're going to play that catchup game
    forever. Let's get over with it towards the end of the merge window'"

* tag 'vfs-timespec64' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/playground:
  pstore: Remove bogus format string definition
  vfs: change inode times to use struct timespec64
  pstore: Convert internal records to timespec64
  udf: Simplify calls to udf_disk_stamp_to_time
  fs: nfs: get rid of memcpys for inode times
  ceph: make inode time prints to be long long
  lustre: Use long long type to print inode time
  fs: add timespec64_truncate()

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;