quota: widen timestamps for the fs_disk_quota structure

Soon, XFS will support quota grace period expiration timestamps beyond
the year 2038, widen the timestamp fields to handle the extra time bits.
Internally, XFS now stores unsigned 34-bit quantities, so the extra 8
bits here should work fine.  (Note that XFS is the only user of this
structure.)

Link: https://lore.kernel.org/r/20200909163413.GJ7955@magnolia
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jan Kara <jack@suse.cz>

diff --git a/fs/quota/quota.c b/fs/quota/quota.c
index 47f9e151988b3eda074b4e2eef05273392091a38..52362eeaea94cac38877fda61f57f4c6f2dafdb4 100644 (file)
--- a/fs/quota/quota.c
+++ b/fs/quota/quota.c
@@ -481,6 +481,14 @@ static inline u64 quota_btobb(u64 bytes)
        return (bytes + (1 << XFS_BB_SHIFT) - 1) >> XFS_BB_SHIFT;
 }
 
+static inline s64 copy_from_xfs_dqblk_ts(const struct fs_disk_quota *d,
+               __s32 timer, __s8 timer_hi)
+{
+       if (d->d_fieldmask & FS_DQ_BIGTIME)
+               return (u32)timer | (s64)timer_hi << 32;
+       return timer;
+}
+
 static void copy_from_xfs_dqblk(struct qc_dqblk *dst, struct fs_disk_quota *src)
 {
        dst->d_spc_hardlimit = quota_bbtob(src->d_blk_hardlimit);
@@ -489,14 +497,17 @@ static void copy_from_xfs_dqblk(struct qc_dqblk *dst, struct fs_disk_quota *src)
        dst->d_ino_softlimit = src->d_ino_softlimit;
        dst->d_space = quota_bbtob(src->d_bcount);
        dst->d_ino_count = src->d_icount;
-       dst->d_ino_timer = src->d_itimer;
-       dst->d_spc_timer = src->d_btimer;
+       dst->d_ino_timer = copy_from_xfs_dqblk_ts(src, src->d_itimer,
+                                                 src->d_itimer_hi);
+       dst->d_spc_timer = copy_from_xfs_dqblk_ts(src, src->d_btimer,
+                                                 src->d_btimer_hi);
        dst->d_ino_warns = src->d_iwarns;
        dst->d_spc_warns = src->d_bwarns;
        dst->d_rt_spc_hardlimit = quota_bbtob(src->d_rtb_hardlimit);
        dst->d_rt_spc_softlimit = quota_bbtob(src->d_rtb_softlimit);
        dst->d_rt_space = quota_bbtob(src->d_rtbcount);
-       dst->d_rt_spc_timer = src->d_rtbtimer;
+       dst->d_rt_spc_timer = copy_from_xfs_dqblk_ts(src, src->d_rtbtimer,
+                                                    src->d_rtbtimer_hi);
        dst->d_rt_spc_warns = src->d_rtbwarns;
        dst->d_fieldmask = 0;
        if (src->d_fieldmask & FS_DQ_ISOFT)
@@ -588,10 +599,26 @@ static int quota_setxquota(struct super_block *sb, int type, qid_t id,
        return sb->s_qcop->set_dqblk(sb, qid, &qdq);
 }
 
+static inline void copy_to_xfs_dqblk_ts(const struct fs_disk_quota *d,
+               __s32 *timer_lo, __s8 *timer_hi, s64 timer)
+{
+       *timer_lo = timer;
+       if (d->d_fieldmask & FS_DQ_BIGTIME)
+               *timer_hi = timer >> 32;
+}
+
+static inline bool want_bigtime(s64 timer)
+{
+       return timer > S32_MAX || timer < S32_MIN;
+}
+
 static void copy_to_xfs_dqblk(struct fs_disk_quota *dst, struct qc_dqblk *src,
                              int type, qid_t id)
 {
        memset(dst, 0, sizeof(*dst));
+       if (want_bigtime(src->d_ino_timer) || want_bigtime(src->d_spc_timer) ||
+           want_bigtime(src->d_rt_spc_timer))
+               dst->d_fieldmask |= FS_DQ_BIGTIME;
        dst->d_version = FS_DQUOT_VERSION;
        dst->d_id = id;
        if (type == USRQUOTA)
@@ -606,14 +633,17 @@ static void copy_to_xfs_dqblk(struct fs_disk_quota *dst, struct qc_dqblk *src,
        dst->d_ino_softlimit = src->d_ino_softlimit;
        dst->d_bcount = quota_btobb(src->d_space);
        dst->d_icount = src->d_ino_count;
-       dst->d_itimer = src->d_ino_timer;
-       dst->d_btimer = src->d_spc_timer;
+       copy_to_xfs_dqblk_ts(dst, &dst->d_itimer, &dst->d_itimer_hi,
+                            src->d_ino_timer);
+       copy_to_xfs_dqblk_ts(dst, &dst->d_btimer, &dst->d_btimer_hi,
+                            src->d_spc_timer);
        dst->d_iwarns = src->d_ino_warns;
        dst->d_bwarns = src->d_spc_warns;
        dst->d_rtb_hardlimit = quota_btobb(src->d_rt_spc_hardlimit);
        dst->d_rtb_softlimit = quota_btobb(src->d_rt_spc_softlimit);
        dst->d_rtbcount = quota_btobb(src->d_rt_space);
-       dst->d_rtbtimer = src->d_rt_spc_timer;
+       copy_to_xfs_dqblk_ts(dst, &dst->d_rtbtimer, &dst->d_rtbtimer_hi,
+                            src->d_rt_spc_timer);
        dst->d_rtbwarns = src->d_rt_spc_warns;
 }
 

diff --git a/include/uapi/linux/dqblk_xfs.h b/include/uapi/linux/dqblk_xfs.h
index 03d890b80ebc86f42917289f1822f3b14dc4768e..16d73f54376d6ba54c1d8edab803cdc1d50a1d9f 100644 (file)
--- a/include/uapi/linux/dqblk_xfs.h
+++ b/include/uapi/linux/dqblk_xfs.h
@@ -66,7 +66,10 @@ typedef struct fs_disk_quota {
        __s32           d_btimer;       /* similar to above; for disk blocks */
        __u16           d_iwarns;       /* # warnings issued wrt num inodes */
        __u16           d_bwarns;       /* # warnings issued wrt disk blocks */
-       __s32           d_padding2;     /* padding2 - for future use */
+       __s8            d_itimer_hi;    /* upper 8 bits of timer values */
+       __s8            d_btimer_hi;
+       __s8            d_rtbtimer_hi;
+       __s8            d_padding2;     /* padding2 - for future use */
        __u64           d_rtb_hardlimit;/* absolute limit on realtime blks */
        __u64           d_rtb_softlimit;/* preferred limit on RT disk blks */
        __u64           d_rtbcount;     /* # realtime blocks owned */
@@ -121,6 +124,12 @@ typedef struct fs_disk_quota {
 #define FS_DQ_RTBCOUNT         (1<<14)
 #define FS_DQ_ACCT_MASK                (FS_DQ_BCOUNT | FS_DQ_ICOUNT | FS_DQ_RTBCOUNT)
 
+/*
+ * Quota expiration timestamps are 40-bit signed integers, with the upper 8
+ * bits encoded in the _hi fields.
+ */
+#define FS_DQ_BIGTIME          (1<<15)
+
 /*
  * Various flags related to quotactl(2).
  */