quota: widen timestamps for the fs_disk_quota structure
authorDarrick J. Wong <darrick.wong@oracle.com>
Wed, 9 Sep 2020 16:34:13 +0000 (09:34 -0700)
committerJan Kara <jack@suse.cz>
Thu, 10 Sep 2020 07:09:51 +0000 (09:09 +0200)
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>
fs/quota/quota.c
include/uapi/linux/dqblk_xfs.h

index 47f9e15..52362ee 100644 (file)
@@ -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;
 }
 
index 03d890b..16d73f5 100644 (file)
@@ -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 */