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 47f9e15..52362ee 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 03d890b..16d73f5 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 */
@@ -122,6 +125,12 @@ typedef struct fs_disk_quota {
 #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).
  */
 #define FS_QUOTA_UDQ_ACCT      (1<<0)  /* user quota accounting */