47 files changed, 294 insertions, 72 deletions
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index 08112fbcaece..ca243e658d71 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -69,8 +69,12 @@ v9fs_fill_super(struct super_block *sb, struct v9fs_session_info *v9ses,
        if (v9fs_proto_dotl(v9ses)) {
                sb->s_op = &v9fs_super_ops_dotl;
                sb->s_xattr = v9fs_xattr_handlers;
-        } else
+        } else {
                sb->s_op = &v9fs_super_ops;
+                sb->s_time_max = U32_MAX;
+        }
+        sb->s_time_min = 0;
        ret = super_setup_bdi(sb);
        if (ret)
diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index 14a6c1b90c9f..f708c45d5f66 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -375,7 +375,7 @@ affs_secs_to_datestamp(time64_t secs, struct affs_date *ds)
        u32      minute;
        s32      rem;
-        secs -= sys_tz.tz_minuteswest * 60 + ((8 * 365 + 2) * 24 * 60 * 60);
+        secs -= sys_tz.tz_minuteswest * 60 + AFFS_EPOCH_DELTA;
        if (secs < 0)
                secs = 0;
        days    = div_s64_rem(secs, 86400, &rem);
diff --git a/fs/affs/amigaffs.h b/fs/affs/amigaffs.h
index f9bef9056659..81fb396d4dfa 100644
--- a/fs/affs/amigaffs.h
+++ b/fs/affs/amigaffs.h
@@ -32,6 +32,9 @@
 #define AFFS_ROOT_BMAPS         25
+/* Seconds since Amiga epoch of 1978/01/01 to UNIX */
+#define AFFS_EPOCH_DELTA ((8 * 365 + 2) * 86400LL)
 struct affs_date {
        __be32 days;
        __be32 mins;
diff --git a/fs/affs/inode.c b/fs/affs/inode.c
index 73598bff8506..a346cf7659f1 100644
--- a/fs/affs/inode.c
+++ b/fs/affs/inode.c
@@ -150,10 +150,10 @@ struct inode *affs_iget(struct super_block *sb, unsigned long ino)
        }
        inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec
-                       = (be32_to_cpu(tail->change.days) * (24 * 60 * 60) +
+                       = (be32_to_cpu(tail->change.days) * 86400LL +
                         be32_to_cpu(tail->change.mins) * 60 +
                         be32_to_cpu(tail->change.ticks) / 50 +
-                         ((8 * 365 + 2) * 24 * 60 * 60)) +
+                         AFFS_EPOCH_DELTA) +
                         sys_tz.tz_minuteswest * 60;
        inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_atime.tv_nsec = 0;
        affs_brelse(bh);
diff --git a/fs/affs/super.c b/fs/affs/super.c
index e7d036efbaa1..cc463ae47c12 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -355,6 +355,10 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_op                = &affs_sops;
        sb->s_flags |= SB_NODIRATIME;
+        sb->s_time_gran = NSEC_PER_SEC;
+        sb->s_time_min = sys_tz.tz_minuteswest * 60 + AFFS_EPOCH_DELTA;
+        sb->s_time_max = 86400LL * U32_MAX + 86400 + sb->s_time_min;
        sbi = kzalloc(sizeof(struct affs_sb_info), GFP_KERNEL);
        if (!sbi)
                return -ENOMEM;
diff --git a/fs/attr.c b/fs/attr.c
index d22e8187477f..df28035aa23e 100644
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -183,15 +183,18 @@ void setattr_copy(struct inode *inode, const struct iattr *attr)
                inode->i_uid = attr->ia_uid;
        if (ia_valid & ATTR_GID)
                inode->i_gid = attr->ia_gid;
-        if (ia_valid & ATTR_ATIME)
+        if (ia_valid & ATTR_ATIME) {
-                inode->i_atime = timespec64_trunc(attr->ia_atime,
+                inode->i_atime = timestamp_truncate(attr->ia_atime,
-                                                  inode->i_sb->s_time_gran);
+                                                  inode);
-        if (ia_valid & ATTR_MTIME)
+        }
-                inode->i_mtime = timespec64_trunc(attr->ia_mtime,
+        if (ia_valid & ATTR_MTIME) {
-                                                  inode->i_sb->s_time_gran);
+                inode->i_mtime = timestamp_truncate(attr->ia_mtime,
-        if (ia_valid & ATTR_CTIME)
+                                                  inode);
-                inode->i_ctime = timespec64_trunc(attr->ia_ctime,
+        }
-                                                  inode->i_sb->s_time_gran);
+        if (ia_valid & ATTR_CTIME) {
+                inode->i_ctime = timestamp_truncate(attr->ia_ctime,
+                                                  inode);
+        }
        if (ia_valid & ATTR_MODE) {
                umode_t mode = attr->ia_mode;
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 462d096ff3e9..64cdf4d8e424 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -893,6 +893,8 @@ befs_fill_super(struct super_block *sb, void *data, int silent)
        sb_set_blocksize(sb, (ulong) befs_sb->block_size);
        sb->s_op = &befs_sops;
        sb->s_export_op = &befs_export_operations;
+        sb->s_time_min = 0;
+        sb->s_time_max = 0xffffffffffffll;
        root = befs_iget(sb, iaddr2blockno(sb, &(befs_sb->root_dir)));
        if (IS_ERR(root)) {
                ret = PTR_ERR(root);
diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
index 5e97bed073d7..f8ce1368218b 100644
--- a/fs/bfs/inode.c
+++ b/fs/bfs/inode.c
@@ -324,6 +324,8 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent)
                return -ENOMEM;
        mutex_init(&info->bfs_lock);
        s->s_fs_info = info;
+        s->s_time_min = 0;
+        s->s_time_max = U32_MAX;
        sb_set_blocksize(s, BFS_BSIZE);
diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index ab4868c7308e..377fafc76f20 100644
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -979,6 +979,8 @@ static int ceph_set_super(struct super_block *s, void *data)
        s->s_export_op = &ceph_export_ops;
        s->s_time_gran = 1;
+        s->s_time_min = 0;
+        s->s_time_max = U32_MAX;
        ret = set_anon_super(s, NULL);  /* what is that second arg for? */
        if (ret != 0)
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 4e2f74894e9b..e8afff702bb8 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -56,6 +56,15 @@
 #include "dfs_cache.h"
 #endif
+/*
+ * DOS dates from 1980/1/1 through 2107/12/31
+ * Protocol specifications indicate the range should be to 119, which
+ * limits maximum year to 2099. But this range has not been checked.
+ */
+#define SMB_DATE_MAX (127<<9 | 12<<5 | 31)
+#define SMB_DATE_MIN (0<<9 | 1<<5 | 1)
+#define SMB_TIME_MAX (23<<11 | 59<<5 | 29)
 int cifsFYI = 0;
 bool traceSMB;
 bool enable_oplocks = true;
@@ -142,6 +151,7 @@ cifs_read_super(struct super_block *sb)
        struct inode *inode;
        struct cifs_sb_info *cifs_sb;
        struct cifs_tcon *tcon;
+        struct timespec64 ts;
        int rc = 0;
        cifs_sb = CIFS_SB(sb);
@@ -161,6 +171,18 @@ cifs_read_super(struct super_block *sb)
        /* BB FIXME fix time_gran to be larger for LANMAN sessions */
        sb->s_time_gran = 100;
+        if (tcon->unix_ext) {
+                ts = cifs_NTtimeToUnix(0);
+                sb->s_time_min = ts.tv_sec;
+                ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
+                sb->s_time_max = ts.tv_sec;
+        } else {
+                ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
+                sb->s_time_min = ts.tv_sec;
+                ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX), cpu_to_le16(SMB_TIME_MAX), 0);
+                sb->s_time_max = ts.tv_sec;
+        }
        sb->s_magic = CIFS_MAGIC_NUMBER;
        sb->s_op = &cifs_super_ops;
        sb->s_xattr = cifs_xattr_handlers;
diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
index ed92958e842d..49c17ee18254 100644
--- a/fs/cifs/netmisc.c
+++ b/fs/cifs/netmisc.c
@@ -949,8 +949,8 @@ static const int total_days_of_prev_months[] = {
 struct timespec64 cnvrtDosUnixTm(__le16 le_date, __le16 le_time, int offset)
 {
        struct timespec64 ts;
-        time64_t sec;
+        time64_t sec, days;
-        int min, days, month, year;
+        int min, day, month, year;
        u16 date = le16_to_cpu(le_date);
        u16 time = le16_to_cpu(le_time);
        SMB_TIME *st = (SMB_TIME *)&time;
@@ -966,15 +966,15 @@ struct timespec64 cnvrtDosUnixTm(__le16 le_date, __le16 le_time, int offset)
        sec += 60 * 60 * st->Hours;
        if (st->Hours > 24)
                cifs_dbg(VFS, "illegal hours %d\n", st->Hours);
-        days = sd->Day;
+        day = sd->Day;
        month = sd->Month;
-        if (days < 1 || days > 31 || month < 1 || month > 12) {
+        if (day < 1 || day > 31 || month < 1 || month > 12) {
-                cifs_dbg(VFS, "illegal date, month %d day: %d\n", month, days);
+                cifs_dbg(VFS, "illegal date, month %d day: %d\n", month, day);
-                days = clamp(days, 1, 31);
+                day = clamp(day, 1, 31);
                month = clamp(month, 1, 12);
        }
        month -= 1;
-        days += total_days_of_prev_months[month];
+        days = day + total_days_of_prev_months[month];
        days += 3652; /* account for difference in days between 1980 and 1970 */
        year = sd->Year;
        days += year * 365;
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 321f56e487cb..b1c70e2b9b1e 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -188,6 +188,9 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_magic = CODA_SUPER_MAGIC;
        sb->s_op = &coda_super_operations;
        sb->s_d_op = &coda_dentry_operations;
+        sb->s_time_gran = 1;
+        sb->s_time_min = S64_MIN;
+        sb->s_time_max = S64_MAX;
        error = super_setup_bdi(sb);
        if (error)
diff --git a/fs/configfs/inode.c b/fs/configfs/inode.c
index ab0284321912..884dcf06cfbe 100644
--- a/fs/configfs/inode.c
+++ b/fs/configfs/inode.c
@@ -76,14 +76,14 @@ int configfs_setattr(struct dentry * dentry, struct iattr * iattr)
        if (ia_valid & ATTR_GID)
                sd_iattr->ia_gid = iattr->ia_gid;
        if (ia_valid & ATTR_ATIME)
-                sd_iattr->ia_atime = timespec64_trunc(iattr->ia_atime,
+                sd_iattr->ia_atime = timestamp_truncate(iattr->ia_atime,
-                                                      inode->i_sb->s_time_gran);
+                                                      inode);
        if (ia_valid & ATTR_MTIME)
-                sd_iattr->ia_mtime = timespec64_trunc(iattr->ia_mtime,
+                sd_iattr->ia_mtime = timestamp_truncate(iattr->ia_mtime,
-                                                      inode->i_sb->s_time_gran);
+                                                      inode);
        if (ia_valid & ATTR_CTIME)
-                sd_iattr->ia_ctime = timespec64_trunc(iattr->ia_ctime,
+                sd_iattr->ia_ctime = timestamp_truncate(iattr->ia_ctime,
-                                                      inode->i_sb->s_time_gran);
+                                                      inode);
        if (ia_valid & ATTR_MODE) {
                umode_t mode = iattr->ia_mode;
diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index 9352487bd0fc..4d1d8b7761ed 100644
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -597,6 +597,8 @@ static int cramfs_finalize_super(struct super_block *sb,
        /* Set it all up.. */
        sb->s_flags |= SB_RDONLY;
+        sb->s_time_min = 0;
+        sb->s_time_max = 0;
        sb->s_op = &cramfs_ops;
        root = get_cramfs_inode(sb, cramfs_root, 0);
        if (IS_ERR(root))
diff --git a/fs/efs/super.c b/fs/efs/super.c
index 867fc24dee20..4a6ebff2af76 100644
--- a/fs/efs/super.c
+++ b/fs/efs/super.c
@@ -257,6 +257,8 @@ static int efs_fill_super(struct super_block *s, void *d, int silent)
        if (!sb)
                return -ENOMEM;
        s->s_fs_info = sb;
+        s->s_time_min = 0;
+        s->s_time_max = U32_MAX;
 
        s->s_magic              = EFS_SUPER_MAGIC;
        if (!sb_set_blocksize(s, EFS_BLOCKSIZE)) {
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 44eb6e7eb492..baa36c6fb71e 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1002,6 +1002,8 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_maxbytes = ext2_max_size(sb->s_blocksize_bits);
        sb->s_max_links = EXT2_LINK_MAX;
+        sb->s_time_min = S32_MIN;
+        sb->s_time_max = S32_MAX;
        if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV) {
                sbi->s_inode_size = EXT2_GOOD_OLD_INODE_SIZE;
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 9c7f4036021b..42c6e4a5e673 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -832,11 +832,13 @@ static inline void ext4_decode_extra_time(struct timespec64 *time,
 #define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode)                           \
 do {                                                                            \
-        (raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);                \
        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));    \
 } while (0)
 #define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode)                        \
@@ -1643,6 +1645,10 @@ static inline bool ext4_verity_in_progress(struct inode *inode)
 #define EXT4_GOOD_OLD_INODE_SIZE 128
+#define EXT4_EXTRA_TIMESTAMP_MAX        (((s64)1 << 34) - 1  + S32_MIN)
+#define EXT4_NON_EXTRA_TIMESTAMP_MAX    S32_MAX
+#define EXT4_TIMESTAMP_MIN              S32_MIN
 /*
 * Feature set definitions
 */
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 27cd622676e7..3db5f17228b7 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -4039,8 +4039,21 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                               sbi->s_inode_size);
                        goto failed_mount;
                }
-                if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE)
+                /*
-                        sb->s_time_gran = 1 << (EXT4_EPOCH_BITS - 2);
+                 * i_atime_extra is the last extra field available for [acm]times in
+                 * struct ext4_inode. Checking for that field should suffice to ensure
+                 * we have extra space for all three.
+                 */
+                if (sbi->s_inode_size >= offsetof(struct ext4_inode, i_atime_extra) +
+                        sizeof(((struct ext4_inode *)0)->i_atime_extra)) {
+                        sb->s_time_gran = 1;
+                        sb->s_time_max = EXT4_EXTRA_TIMESTAMP_MAX;
+                } else {
+                        sb->s_time_gran = NSEC_PER_SEC;
+                        sb->s_time_max = EXT4_NON_EXTRA_TIMESTAMP_MAX;
+                }
+                sb->s_time_min = EXT4_TIMESTAMP_MIN;
        }
        sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 39fffc19e00c..56efde9d3659 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -745,15 +745,18 @@ static void __setattr_copy(struct inode *inode, const struct iattr *attr)
                inode->i_uid = attr->ia_uid;
        if (ia_valid & ATTR_GID)
                inode->i_gid = attr->ia_gid;
-        if (ia_valid & ATTR_ATIME)
+        if (ia_valid & ATTR_ATIME) {
-                inode->i_atime = timespec64_trunc(attr->ia_atime,
+                inode->i_atime = timestamp_truncate(attr->ia_atime,
-                                                  inode->i_sb->s_time_gran);
+                                                  inode);
-        if (ia_valid & ATTR_MTIME)
+        }
-                inode->i_mtime = timespec64_trunc(attr->ia_mtime,
+        if (ia_valid & ATTR_MTIME) {
-                                                  inode->i_sb->s_time_gran);
+                inode->i_mtime = timestamp_truncate(attr->ia_mtime,
-        if (ia_valid & ATTR_CTIME)
+                                                  inode);
-                inode->i_ctime = timespec64_trunc(attr->ia_ctime,
+        }
-                                                  inode->i_sb->s_time_gran);
+        if (ia_valid & ATTR_CTIME) {
+                inode->i_ctime = timestamp_truncate(attr->ia_ctime,
+                                                  inode);
+        }
        if (ia_valid & ATTR_MODE) {
                umode_t mode = attr->ia_mode;
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 05689198f5af..5f04c5c810fb 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -31,6 +31,11 @@
 #define KB_IN_SECTORS 2
+/* DOS dates from 1980/1/1 through 2107/12/31 */
+#define FAT_DATE_MIN (0<<9 | 1<<5 | 1)
+#define FAT_DATE_MAX (127<<9 | 12<<5 | 31)
+#define FAT_TIME_MAX (23<<11 | 59<<5 | 29)
 /*
 * A deserialized copy of the on-disk structure laid out in struct
 * fat_boot_sector.
@@ -1605,6 +1610,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
        int debug;
        long error;
        char buf[50];
+        struct timespec64 ts;
        /*
         * GFP_KERNEL is ok here, because while we do hold the
@@ -1698,6 +1704,12 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
        sbi->free_clus_valid = 0;
        sbi->prev_free = FAT_START_ENT;
        sb->s_maxbytes = 0xffffffff;
+        fat_time_fat2unix(sbi, &ts, 0, cpu_to_le16(FAT_DATE_MIN), 0);
+        sb->s_time_min = ts.tv_sec;
+        fat_time_fat2unix(sbi, &ts, cpu_to_le16(FAT_TIME_MAX),
+                          cpu_to_le16(FAT_DATE_MAX), 0);
+        sb->s_time_max = ts.tv_sec;
        if (!sbi->fat_length && bpb.fat32_length) {
                struct fat_boot_fsinfo *fsinfo;
diff --git a/fs/freevxfs/vxfs_super.c b/fs/freevxfs/vxfs_super.c
index a89f68c3cbed..578a5062706e 100644
--- a/fs/freevxfs/vxfs_super.c
+++ b/fs/freevxfs/vxfs_super.c
@@ -229,6 +229,8 @@ static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent)
        sbp->s_op = &vxfs_super_ops;
        sbp->s_fs_info = infp;
+        sbp->s_time_min = 0;
+        sbp->s_time_max = U32_MAX;
        if (!vxfs_try_sb_magic(sbp, silent, 1,
                        (__force __fs32)cpu_to_le32(VXFS_SUPER_MAGIC))) {
diff --git a/fs/hpfs/hpfs_fn.h b/fs/hpfs/hpfs_fn.h
index ab2e7cc2ff33..1cca83218fb5 100644
--- a/fs/hpfs/hpfs_fn.h
+++ b/fs/hpfs/hpfs_fn.h
@@ -334,7 +334,7 @@ long hpfs_ioctl(struct file *file, unsigned cmd, unsigned long arg);
 * local time (HPFS) to GMT (Unix)
 */
-static inline time64_t local_to_gmt(struct super_block *s, time32_t t)
+static inline time64_t local_to_gmt(struct super_block *s, time64_t t)
 {
        extern struct timezone sys_tz;
        return t + sys_tz.tz_minuteswest * 60 + hpfs_sb(s)->sb_timeshift;
@@ -343,9 +343,7 @@ static inline time64_t local_to_gmt(struct super_block *s, time32_t t)
 static inline time32_t gmt_to_local(struct super_block *s, time64_t t)
 {
        extern struct timezone sys_tz;
-        t = t - sys_tz.tz_minuteswest * 60 - hpfs_sb(s)->sb_timeshift;
+        return t - sys_tz.tz_minuteswest * 60 - hpfs_sb(s)->sb_timeshift;
-        return clamp_t(time64_t, t, 0, U32_MAX);
 }
 static inline time32_t local_get_seconds(struct super_block *s)
diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index 9db6d84f0d62..0a677a9aaf34 100644
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -614,6 +614,8 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
        s->s_magic = HPFS_SUPER_MAGIC;
        s->s_op = &hpfs_sops;
        s->s_d_op = &hpfs_dentry_operations;
+        s->s_time_min =  local_to_gmt(s, 0);
+        s->s_time_max =  local_to_gmt(s, U32_MAX);
        sbi->sb_root = le32_to_cpu(superblock->root);
        sbi->sb_fs_size = le32_to_cpu(superblock->n_sectors);
diff --git a/fs/inode.c b/fs/inode.c
index 0f1e3b563c47..64bf28cf05cd 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -2167,6 +2167,37 @@ struct timespec64 timespec64_trunc(struct timespec64 t, unsigned gran)
 EXPORT_SYMBOL(timespec64_trunc);
 /**
+ * timestamp_truncate - Truncate timespec to a granularity
+ * @t: Timespec
+ * @inode: inode being updated
+ *
+ * Truncate a timespec to the granularity supported by the fs
+ * containing the inode. Always rounds down. gran must
+ * not be 0 nor greater than a second (NSEC_PER_SEC, or 10^9 ns).
+ */
+struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode)
+{
+        struct super_block *sb = inode->i_sb;
+        unsigned int gran = sb->s_time_gran;
+        t.tv_sec = clamp(t.tv_sec, sb->s_time_min, sb->s_time_max);
+        if (unlikely(t.tv_sec == sb->s_time_max || t.tv_sec == sb->s_time_min))
+                t.tv_nsec = 0;
+        /* Avoid division in the common cases 1 ns and 1 s. */
+        if (gran == 1)
+                ; /* nothing */
+        else if (gran == NSEC_PER_SEC)
+                t.tv_nsec = 0;
+        else if (gran > 1 && gran < NSEC_PER_SEC)
+                t.tv_nsec -= t.tv_nsec % gran;
+        else
+                WARN(1, "invalid file time granularity: %u", gran);
+        return t;
+}
+EXPORT_SYMBOL(timestamp_truncate);
+/**
 * current_time - Return FS time
 * @inode: inode.
 *
@@ -2187,7 +2218,7 @@ struct timespec64 current_time(struct inode *inode)
                return now;
        }
-        return timespec64_trunc(now, inode->i_sb->s_time_gran);
+        return timestamp_truncate(now, inode);
 }
 EXPORT_SYMBOL(current_time);
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 9e30d8703735..62c0462dc89f 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -30,6 +30,9 @@
 #include "isofs.h"
 #include "zisofs.h"
+/* max tz offset is 13 hours */
+#define MAX_TZ_OFFSET (52*15*60)
 #define BEQUIET
 static int isofs_hashi(const struct dentry *parent, struct qstr *qstr);
@@ -801,6 +804,10 @@ root_found:
         */
        s->s_maxbytes = 0x80000000000LL;
+        /* ECMA-119 timestamp from 1900/1/1 with tz offset */
+        s->s_time_min = mktime64(1900, 1, 1, 0, 0, 0) - MAX_TZ_OFFSET;
+        s->s_time_max = mktime64(U8_MAX+1900, 12, 31, 23, 59, 59) + MAX_TZ_OFFSET;
        /* Set this for reference. Its not currently used except on write
           which we don't have .. */
diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index 8a20ddd25f2d..d0b59d03a7a9 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -590,6 +590,9 @@ int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_blocksize = PAGE_SIZE;
        sb->s_blocksize_bits = PAGE_SHIFT;
        sb->s_magic = JFFS2_SUPER_MAGIC;
+        sb->s_time_min = 0;
+        sb->s_time_max = U32_MAX;
        if (!sb_rdonly(sb))
                jffs2_start_garbage_collect_thread(c);
        return 0;
diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index f4e10cb9f734..b2dc4d1f9dcc 100644
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -503,6 +503,8 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_fs_info = sbi;
        sb->s_max_links = JFS_LINK_MAX;
+        sb->s_time_min = 0;
+        sb->s_time_max = U32_MAX;
        sbi->sb = sb;
        sbi->uid = INVALID_UID;
        sbi->gid = INVALID_GID;
diff --git a/fs/kernfs/inode.c b/fs/kernfs/inode.c
index f3f3984cce80..f3eaa8869f42 100644
--- a/fs/kernfs/inode.c
+++ b/fs/kernfs/inode.c
@@ -158,12 +158,11 @@ static inline void set_default_inode_attr(struct inode *inode, umode_t mode)
 static inline void set_inode_attr(struct inode *inode,
                                  struct kernfs_iattrs *attrs)
 {
-        struct super_block *sb = inode->i_sb;
        inode->i_uid = attrs->ia_uid;
        inode->i_gid = attrs->ia_gid;
-        inode->i_atime = timespec64_trunc(attrs->ia_atime, sb->s_time_gran);
+        inode->i_atime = timestamp_truncate(attrs->ia_atime, inode);
-        inode->i_mtime = timespec64_trunc(attrs->ia_mtime, sb->s_time_gran);
+        inode->i_mtime = timestamp_truncate(attrs->ia_mtime, inode);
-        inode->i_ctime = timespec64_trunc(attrs->ia_ctime, sb->s_time_gran);
+        inode->i_ctime = timestamp_truncate(attrs->ia_ctime, inode);
 }
 static void kernfs_refresh_inode(struct kernfs_node *kn, struct inode *inode)
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index f96073f25432..7cb5fd38eb14 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -277,6 +277,8 @@ static int minix_fill_super(struct super_block *s, void *data, int silent)
        /* set up enough so that it can read an inode */
        s->s_op = &minix_sops;
+        s->s_time_min = 0;
+        s->s_time_max = U32_MAX;
        root_inode = minix_iget(s, MINIX_ROOT_INO);
        if (IS_ERR(root_inode)) {
                ret = PTR_ERR(root_inode);
diff --git a/fs/namespace.c b/fs/namespace.c
index 227f7b343034..93c043245c46 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -2466,6 +2466,26 @@ static void set_mount_attributes(struct mount *mnt, unsigned int mnt_flags)
        unlock_mount_hash();
 }
+static void mnt_warn_timestamp_expiry(struct path *mountpoint, struct vfsmount *mnt)
+{
+        struct super_block *sb = mnt->mnt_sb;
+        if (!__mnt_is_readonly(mnt) &&
+           (ktime_get_real_seconds() + TIME_UPTIME_SEC_MAX > sb->s_time_max)) {
+                char *buf = (char *)__get_free_page(GFP_KERNEL);
+                char *mntpath = buf ? d_path(mountpoint, buf, PAGE_SIZE) : ERR_PTR(-ENOMEM);
+                struct tm tm;
+                time64_to_tm(sb->s_time_max, 0, &tm);
+                pr_warn("Mounted %s file system at %s supports timestamps until %04ld (0x%llx)\n",
+                        sb->s_type->name, mntpath,
+                        tm.tm_year+1900, (unsigned long long)sb->s_time_max);
+                free_page((unsigned long)buf);
+        }
+}
 /*
 * Handle reconfiguration of the mountpoint only without alteration of the
 * superblock it refers to.  This is triggered by specifying MS_REMOUNT|MS_BIND
@@ -2491,6 +2511,9 @@ static int do_reconfigure_mnt(struct path *path, unsigned int mnt_flags)
        if (ret == 0)
                set_mount_attributes(mnt, mnt_flags);
        up_write(&sb->s_umount);
+        mnt_warn_timestamp_expiry(path, &mnt->mnt);
        return ret;
 }
@@ -2531,6 +2554,9 @@ static int do_remount(struct path *path, int ms_flags, int sb_flags,
                }
                up_write(&sb->s_umount);
        }
+        mnt_warn_timestamp_expiry(path, &mnt->mnt);
        put_fs_context(fc);
        return err;
 }
@@ -2739,8 +2765,13 @@ static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint,
                return PTR_ERR(mnt);
        error = do_add_mount(real_mount(mnt), mountpoint, mnt_flags);
-        if (error < 0)
+        if (error < 0) {
                mntput(mnt);
+                return error;
+        }
+        mnt_warn_timestamp_expiry(mountpoint, mnt);
        return error;
 }
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 703f595dce90..19a76cfa8b1f 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -2382,6 +2382,15 @@ void nfs_fill_super(struct super_block *sb, struct nfs_mount_info *mount_info)
                sb->s_flags |= SB_POSIXACL;
                sb->s_time_gran = 1;
                sb->s_export_op = &nfs_export_ops;
+        } else
+                sb->s_time_gran = 1000;
+        if (server->nfs_client->rpc_ops->version != 4) {
+                sb->s_time_min = 0;
+                sb->s_time_max = U32_MAX;
+        } else {
+                sb->s_time_min = S64_MIN;
+                sb->s_time_max = S64_MAX;
        }
        nfs_initialise_sb(sb);
@@ -2402,7 +2411,6 @@ static void nfs_clone_super(struct super_block *sb,
        sb->s_maxbytes = old_sb->s_maxbytes;
        sb->s_xattr = old_sb->s_xattr;
        sb->s_op = old_sb->s_op;
-        sb->s_time_gran = 1;
        sb->s_export_op = old_sb->s_export_op;
        if (server->nfs_client->rpc_ops->version != 2) {
@@ -2410,6 +2418,16 @@ static void nfs_clone_super(struct super_block *sb,
                 * so ourselves when necessary.
                 */
                sb->s_flags |= SB_POSIXACL;
+                sb->s_time_gran = 1;
+        } else
+                sb->s_time_gran = 1000;
+        if (server->nfs_client->rpc_ops->version != 4) {
+                sb->s_time_min = 0;
+                sb->s_time_max = U32_MAX;
+        } else {
+                sb->s_time_min = S64_MIN;
+                sb->s_time_max = S64_MAX;
        }
        nfs_initialise_sb(sb);
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index 8baa34baf548..6c7388430ad3 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -2899,15 +2899,18 @@ int ntfs_setattr(struct dentry *dentry, struct iattr *attr)
                        ia_valid |= ATTR_MTIME | ATTR_CTIME;
                }
        }
-        if (ia_valid & ATTR_ATIME)
+        if (ia_valid & ATTR_ATIME) {
-                vi->i_atime = timespec64_trunc(attr->ia_atime,
+                vi->i_atime = timestamp_truncate(attr->ia_atime,
-                                               vi->i_sb->s_time_gran);
+                                               vi);
-        if (ia_valid & ATTR_MTIME)
+        }
-                vi->i_mtime = timespec64_trunc(attr->ia_mtime,
+        if (ia_valid & ATTR_MTIME) {
-                                               vi->i_sb->s_time_gran);
+                vi->i_mtime = timestamp_truncate(attr->ia_mtime,
-        if (ia_valid & ATTR_CTIME)
+                                               vi);
-                vi->i_ctime = timespec64_trunc(attr->ia_ctime,
+        }
-                                               vi->i_sb->s_time_gran);
+        if (ia_valid & ATTR_CTIME) {
+                vi->i_ctime = timestamp_truncate(attr->ia_ctime,
+                                               vi);
+        }
        mark_inode_dirty(vi);
 out:
        return err;
diff --git a/fs/omfs/inode.c b/fs/omfs/inode.c
index 08226a835ec3..b76ec6b88ded 100644
--- a/fs/omfs/inode.c
+++ b/fs/omfs/inode.c
@@ -478,6 +478,10 @@ static int omfs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_maxbytes = 0xffffffff;
+        sb->s_time_gran = NSEC_PER_MSEC;
+        sb->s_time_min = 0;
+        sb->s_time_max = U64_MAX / MSEC_PER_SEC;
        sb_set_blocksize(sb, 0x200);
        bh = sb_bread(sb, 0);
diff --git a/fs/pstore/ram.c b/fs/pstore/ram.c
index 2bb3468fc93a..8caff834f002 100644
--- a/fs/pstore/ram.c
+++ b/fs/pstore/ram.c
@@ -144,6 +144,7 @@ static int ramoops_read_kmsg_hdr(char *buffer, struct timespec64 *time,
        if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lld.%lu-%c\n%n",
                   (time64_t *)&time->tv_sec, &time->tv_nsec, &data_type,
                   &header_length) == 3) {
+                time->tv_nsec *= 1000;
                if (data_type == 'C')
                        *compressed = true;
                else
@@ -151,6 +152,7 @@ static int ramoops_read_kmsg_hdr(char *buffer, struct timespec64 *time,
        } else if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lld.%lu\n%n",
                          (time64_t *)&time->tv_sec, &time->tv_nsec,
                          &header_length) == 2) {
+                time->tv_nsec *= 1000;
                *compressed = false;
        } else {
                time->tv_sec = 0;
diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index 922d083bbc7c..e8da1cde87b9 100644
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -201,6 +201,8 @@ static int qnx4_fill_super(struct super_block *s, void *data, int silent)
        s->s_op = &qnx4_sops;
        s->s_magic = QNX4_SUPER_MAGIC;
        s->s_flags |= SB_RDONLY;        /* Yup, read-only yet */
+        s->s_time_min = 0;
+        s->s_time_max = U32_MAX;
        /* Check the superblock signature. Since the qnx4 code is
           dangerous, we should leave as quickly as possible
diff --git a/fs/qnx6/inode.c b/fs/qnx6/inode.c
index 0f8b0ff1ba43..345db56c98fd 100644
--- a/fs/qnx6/inode.c
+++ b/fs/qnx6/inode.c
@@ -429,6 +429,8 @@ mmi_success:
        s->s_op = &qnx6_sops;
        s->s_magic = QNX6_SUPER_MAGIC;
        s->s_flags |= SB_RDONLY;        /* Yup, read-only yet */
+        s->s_time_min = 0;
+        s->s_time_max = U32_MAX;
        /* ease the later tree level calculations */
        sbi = QNX6_SB(s);
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index ab028ea0e561..d69b4ac0ae2f 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -1976,6 +1976,9 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
                goto error_unlocked;
        }
+        s->s_time_min = 0;
+        s->s_time_max = U32_MAX;
        rs = SB_DISK_SUPER_BLOCK(s);
        /*
         * Let's do basic sanity check to verify that underlying device is not
diff --git a/fs/romfs/super.c b/fs/romfs/super.c
index 7d580f7c3f1d..a42c0e3079dc 100644
--- a/fs/romfs/super.c
+++ b/fs/romfs/super.c
@@ -478,6 +478,8 @@ static int romfs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_maxbytes = 0xFFFFFFFF;
        sb->s_magic = ROMFS_MAGIC;
        sb->s_flags |= SB_RDONLY | SB_NOATIME;
+        sb->s_time_min = 0;
+        sb->s_time_max = 0;
        sb->s_op = &romfs_super_ops;
 #ifdef CONFIG_ROMFS_ON_MTD
diff --git a/fs/squashfs/super.c b/fs/squashfs/super.c
index effa638d6d85..a9e9837617a9 100644
--- a/fs/squashfs/super.c
+++ b/fs/squashfs/super.c
@@ -183,6 +183,8 @@ static int squashfs_fill_super(struct super_block *sb, void *data, int silent)
                (u64) le64_to_cpu(sblk->id_table_start));
        sb->s_maxbytes = MAX_LFS_FILESIZE;
+        sb->s_time_min = 0;
+        sb->s_time_max = U32_MAX;
        sb->s_flags |= SB_RDONLY;
        sb->s_op = &squashfs_super_ops;
diff --git a/fs/super.c b/fs/super.c
index 9459ba75a32e..2d679db9e8c7 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -258,6 +258,8 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags,
        s->s_maxbytes = MAX_NON_LFS;
        s->s_op = &default_op;
        s->s_time_gran = 1000000000;
+        s->s_time_min = TIME64_MIN;
+        s->s_time_max = TIME64_MAX;
        s->cleancache_poolid = CLEANCACHE_NO_POOL;
        s->s_shrink.seeks = DEFAULT_SEEKS;
diff --git a/fs/sysv/super.c b/fs/sysv/super.c
index d788b1daa7eb..cc8e2ed155c8 100644
--- a/fs/sysv/super.c
+++ b/fs/sysv/super.c
@@ -368,7 +368,8 @@ static int sysv_fill_super(struct super_block *sb, void *data, int silent)
        sbi->s_block_base = 0;
        mutex_init(&sbi->s_lock);
        sb->s_fs_info = sbi;
+        sb->s_time_min = 0;
+        sb->s_time_max = U32_MAX;
        sb_set_blocksize(sb, BLOCK_SIZE);
        for (i = 0; i < ARRAY_SIZE(flavours) && !size; i++) {
@@ -487,6 +488,8 @@ static int v7_fill_super(struct super_block *sb, void *data, int silent)
        sbi->s_type = FSTYPE_V7;
        mutex_init(&sbi->s_lock);
        sb->s_fs_info = sbi;
+        sb->s_time_min = 0;
+        sb->s_time_max = U32_MAX;
        
        sb_set_blocksize(sb, 512);
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index 400970d740bb..cd52585c8f4f 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -1078,15 +1078,18 @@ static void do_attr_changes(struct inode *inode, const struct iattr *attr)
                inode->i_uid = attr->ia_uid;
        if (attr->ia_valid & ATTR_GID)
                inode->i_gid = attr->ia_gid;
-        if (attr->ia_valid & ATTR_ATIME)
+        if (attr->ia_valid & ATTR_ATIME) {
-                inode->i_atime = timespec64_trunc(attr->ia_atime,
+                inode->i_atime = timestamp_truncate(attr->ia_atime,
-                                                  inode->i_sb->s_time_gran);
+                                                  inode);
-        if (attr->ia_valid & ATTR_MTIME)
+        }
-                inode->i_mtime = timespec64_trunc(attr->ia_mtime,
+        if (attr->ia_valid & ATTR_MTIME) {
-                                                  inode->i_sb->s_time_gran);
+                inode->i_mtime = timestamp_truncate(attr->ia_mtime,
-        if (attr->ia_valid & ATTR_CTIME)
+                                                  inode);
-                inode->i_ctime = timespec64_trunc(attr->ia_ctime,
+        }
-                                                  inode->i_sb->s_time_gran);
+        if (attr->ia_valid & ATTR_CTIME) {
+                inode->i_ctime = timestamp_truncate(attr->ia_ctime,
+                                                  inode);
+        }
        if (attr->ia_valid & ATTR_MODE) {
                umode_t mode = attr->ia_mode;
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index 4ed0dca52ec8..1da0be667409 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -843,6 +843,10 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_maxbytes = MAX_LFS_FILESIZE;
+        sb->s_time_gran = NSEC_PER_SEC;
+        sb->s_time_min = S32_MIN;
+        sb->s_time_max = S32_MAX;
        switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) {
        case UFS_MOUNT_UFSTYPE_44BSD:
                UFSD("ufstype=44bsd\n");
@@ -861,6 +865,9 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                uspi->s_fshift = 9;
                uspi->s_sbsize = super_block_size = 1536;
                uspi->s_sbbase =  0;
+                sb->s_time_gran = 1;
+                sb->s_time_min = S64_MIN;
+                sb->s_time_max = S64_MAX;
                flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
                break;
                
diff --git a/fs/utimes.c b/fs/utimes.c
index 350c9c16ace1..1ba3f7883870 100644
--- a/fs/utimes.c
+++ b/fs/utimes.c
@@ -36,16 +36,14 @@ static int utimes_common(const struct path *path, struct timespec64 *times)
                if (times[0].tv_nsec == UTIME_OMIT)
                        newattrs.ia_valid &= ~ATTR_ATIME;
                else if (times[0].tv_nsec != UTIME_NOW) {
-                        newattrs.ia_atime.tv_sec = times[0].tv_sec;
+                        newattrs.ia_atime = timestamp_truncate(times[0], inode);
-                        newattrs.ia_atime.tv_nsec = times[0].tv_nsec;
                        newattrs.ia_valid |= ATTR_ATIME_SET;
                }
                if (times[1].tv_nsec == UTIME_OMIT)
                        newattrs.ia_valid &= ~ATTR_MTIME;
                else if (times[1].tv_nsec != UTIME_NOW) {
-                        newattrs.ia_mtime.tv_sec = times[1].tv_sec;
+                        newattrs.ia_mtime = timestamp_truncate(times[1], inode);
-                        newattrs.ia_mtime.tv_nsec = times[1].tv_nsec;
                        newattrs.ia_valid |= ATTR_MTIME_SET;
                }
                /*
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 391b4748cae3..8d1df9f8be07 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1664,6 +1664,8 @@ xfs_fs_fill_super(
        sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
        sb->s_max_links = XFS_MAXLINK;
        sb->s_time_gran = 1;
+        sb->s_time_min = S32_MIN;
+        sb->s_time_max = S32_MAX;
        sb->s_iflags |= SB_I_CGROUPWB;
        set_posix_acl_flag(sb);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index ffe35d97afcb..866268c2c6e3 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -732,6 +732,8 @@ struct inode {
        void                    *i_private; /* fs or device private pointer */
 } __randomize_layout;
+struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode);
 static inline unsigned int i_blocksize(const struct inode *node)
 {
        return (1 << node->i_blkbits);
@@ -1458,6 +1460,9 @@ struct super_block {
        /* Granularity of c/m/atime in ns (cannot be worse than a second) */
        u32                     s_time_gran;
+        /* Time limits for c/m/atime in seconds */
+        time64_t                   s_time_min;
+        time64_t                   s_time_max;
 #ifdef CONFIG_FSNOTIFY
        __u32                   s_fsnotify_mask;
        struct fsnotify_mark_connector __rcu    *s_fsnotify_marks;
diff --git a/include/linux/time64.h b/include/linux/time64.h
index a620ee610b9f..19125489ae94 100644
--- a/include/linux/time64.h
+++ b/include/linux/time64.h
@@ -30,6 +30,8 @@ struct itimerspec64 {
 /* Located here for timespec[64]_valid_strict */
 #define TIME64_MAX                      ((s64)~((u64)1 << 63))
+#define TIME64_MIN                      (-TIME64_MAX - 1)
 #define KTIME_MAX                       ((s64)~((u64)1 << 63))
 #define KTIME_SEC_MAX                   (KTIME_MAX / NSEC_PER_SEC)