Merge branch 'xfs-5.19-quota-warn-remove' into xfs-5.19-for-next

fs/xfs/libxfs/xfs_quota_defs.h

@@ -16,7 +16,6 @@
  * and quota-limits. This is a waste in the common case, but hey ...
  */
 typedef uint64_t xfs_qcnt_t;
-typedef uint16_t xfs_qwarncnt_t;
 
 typedef uint8_t xfs_dqtype_t;
 

fs/xfs/xfs_dquot.c

@@ -136,10 +136,7 @@ xfs_qm_adjust_res_timer(
  res->timer = xfs_dquot_set_timeout(mp,
  ktime_get_real_seconds() + qlim->time);
  } else {
- if (res->timer == 0)
- res->warnings = 0;
- else
- res->timer = 0;
+ res->timer = 0;
  }
 }
 
@@ -592,10 +589,6 @@ xfs_dquot_from_disk(
  dqp->q_ino.count = be64_to_cpu(ddqp->d_icount);
  dqp->q_rtb.count = be64_to_cpu(ddqp->d_rtbcount);
 
- dqp->q_blk.warnings = be16_to_cpu(ddqp->d_bwarns);
- dqp->q_ino.warnings = be16_to_cpu(ddqp->d_iwarns);
- dqp->q_rtb.warnings = be16_to_cpu(ddqp->d_rtbwarns);
-
  dqp->q_blk.timer = xfs_dquot_from_disk_ts(ddqp, ddqp->d_btimer);
  dqp->q_ino.timer = xfs_dquot_from_disk_ts(ddqp, ddqp->d_itimer);
  dqp->q_rtb.timer = xfs_dquot_from_disk_ts(ddqp, ddqp->d_rtbtimer);
@@ -637,9 +630,9 @@ xfs_dquot_to_disk(
  ddqp->d_icount = cpu_to_be64(dqp->q_ino.count);
  ddqp->d_rtbcount = cpu_to_be64(dqp->q_rtb.count);
 
- ddqp->d_bwarns = cpu_to_be16(dqp->q_blk.warnings);
- ddqp->d_iwarns = cpu_to_be16(dqp->q_ino.warnings);
- ddqp->d_rtbwarns = cpu_to_be16(dqp->q_rtb.warnings);
+ ddqp->d_bwarns = 0;
+ ddqp->d_iwarns = 0;
+ ddqp->d_rtbwarns = 0;
 
  ddqp->d_btimer = xfs_dquot_to_disk_ts(dqp, dqp->q_blk.timer);
  ddqp->d_itimer = xfs_dquot_to_disk_ts(dqp, dqp->q_ino.timer);

fs/xfs/xfs_dquot.h

@@ -44,14 +44,6 @@ struct xfs_dquot_res {
  * in seconds since the Unix epoch.
  */
  time64_t timer;
-
- /*
- * For root dquots, this is the maximum number of warnings that will
- * be issued for this quota type. Otherwise, this is the number of
- * warnings issued against this quota. Note that none of this is
- * implemented.
- */
- xfs_qwarncnt_t warnings;
 };
 
 static inline bool

fs/xfs/xfs_qm.c

@@ -582,9 +582,6 @@ xfs_qm_init_timelimits(
  defq->blk.time = XFS_QM_BTIMELIMIT;
  defq->ino.time = XFS_QM_ITIMELIMIT;
  defq->rtb.time = XFS_QM_RTBTIMELIMIT;
- defq->blk.warn = XFS_QM_BWARNLIMIT;
- defq->ino.warn = XFS_QM_IWARNLIMIT;
- defq->rtb.warn = XFS_QM_RTBWARNLIMIT;
 
  /*
  * We try to get the limits from the superuser's limits fields.
@@ -608,12 +605,6 @@ xfs_qm_init_timelimits(
  defq->ino.time = dqp->q_ino.timer;
  if (dqp->q_rtb.timer)
  defq->rtb.time = dqp->q_rtb.timer;
- if (dqp->q_blk.warnings)
- defq->blk.warn = dqp->q_blk.warnings;
- if (dqp->q_ino.warnings)
- defq->ino.warn = dqp->q_ino.warnings;
- if (dqp->q_rtb.warnings)
- defq->rtb.warn = dqp->q_rtb.warnings;
 
  xfs_qm_dqdestroy(dqp);
 }

fs/xfs/xfs_qm.h

@@ -34,7 +34,6 @@ struct xfs_quota_limits {
  xfs_qcnt_t hard; /* default hard limit */
  xfs_qcnt_t soft; /* default soft limit */
  time64_t time; /* limit for timers */
- xfs_qwarncnt_t warn; /* limit for warnings */
 };
 
 /* Defaults for each quota type: time limits, warn limits, usage limits */
@@ -134,10 +133,6 @@ struct xfs_dquot_acct {
 #define XFS_QM_RTBTIMELIMIT (7 * 24*60*60) /* 1 week */
 #define XFS_QM_ITIMELIMIT (7 * 24*60*60) /* 1 week */
 
-#define XFS_QM_BWARNLIMIT 5
-#define XFS_QM_IWARNLIMIT 5
-#define XFS_QM_RTBWARNLIMIT 5
-
 extern void xfs_qm_destroy_quotainfo(struct xfs_mount *);
 
 /* quota ops */

fs/xfs/xfs_qm_syscalls.c

@@ -217,8 +217,7 @@ xfs_qm_scall_quotaon(
  return 0;
 }
 
-#define XFS_QC_MASK \
- (QC_LIMIT_MASK | QC_TIMER_MASK | QC_WARNS_MASK)
+#define XFS_QC_MASK (QC_LIMIT_MASK | QC_TIMER_MASK)
 
 /*
  * Adjust limits of this quota, and the defaults if passed in. Returns true
@@ -250,17 +249,6 @@ xfs_setqlim_limits(
  return true;
 }
 
-static inline void
-xfs_setqlim_warns(
- struct xfs_dquot_res *res,
- struct xfs_quota_limits *qlim,
- int warns)
-{
- res->warnings = warns;
- if (qlim)
- qlim->warn = warns;
-}
-
 static inline void
 xfs_setqlim_timer(
  struct xfs_mount *mp,
@@ -354,8 +342,6 @@ xfs_qm_scall_setqlim(
 
  if (xfs_setqlim_limits(mp, res, qlim, hard, soft, "blk"))
  xfs_dquot_set_prealloc_limits(dqp);
- if (newlim->d_fieldmask & QC_SPC_WARNS)
- xfs_setqlim_warns(res, qlim, newlim->d_spc_warns);
  if (newlim->d_fieldmask & QC_SPC_TIMER)
  xfs_setqlim_timer(mp, res, qlim, newlim->d_spc_timer);
 
@@ -370,8 +356,6 @@ xfs_qm_scall_setqlim(
  qlim = id == 0 ? &defq->rtb : NULL;
 
  xfs_setqlim_limits(mp, res, qlim, hard, soft, "rtb");
- if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
- xfs_setqlim_warns(res, qlim, newlim->d_rt_spc_warns);
  if (newlim->d_fieldmask & QC_RT_SPC_TIMER)
  xfs_setqlim_timer(mp, res, qlim, newlim->d_rt_spc_timer);
 
@@ -386,8 +370,6 @@ xfs_qm_scall_setqlim(
  qlim = id == 0 ? &defq->ino : NULL;
 
  xfs_setqlim_limits(mp, res, qlim, hard, soft, "ino");
- if (newlim->d_fieldmask & QC_INO_WARNS)
- xfs_setqlim_warns(res, qlim, newlim->d_ino_warns);
  if (newlim->d_fieldmask & QC_INO_TIMER)
  xfs_setqlim_timer(mp, res, qlim, newlim->d_ino_timer);
 
@@ -428,13 +410,13 @@ xfs_qm_scall_getquota_fill_qc(
  dst->d_ino_count = dqp->q_ino.reserved;
  dst->d_spc_timer = dqp->q_blk.timer;
  dst->d_ino_timer = dqp->q_ino.timer;
- dst->d_ino_warns = dqp->q_ino.warnings;
- dst->d_spc_warns = dqp->q_blk.warnings;
+ dst->d_ino_warns = 0;
+ dst->d_spc_warns = 0;
  dst->d_rt_spc_hardlimit = XFS_FSB_TO_B(mp, dqp->q_rtb.hardlimit);
  dst->d_rt_spc_softlimit = XFS_FSB_TO_B(mp, dqp->q_rtb.softlimit);
  dst->d_rt_space = XFS_FSB_TO_B(mp, dqp->q_rtb.reserved);
  dst->d_rt_spc_timer = dqp->q_rtb.timer;
- dst->d_rt_spc_warns = dqp->q_rtb.warnings;
+ dst->d_rt_spc_warns = 0;
 
  /*
  * Internally, we don't reset all the timers when quota enforcement

fs/xfs/xfs_quotaops.c

@@ -40,9 +40,9 @@ xfs_qm_fill_state(
  tstate->spc_timelimit = (u32)defq->blk.time;
  tstate->ino_timelimit = (u32)defq->ino.time;
  tstate->rt_spc_timelimit = (u32)defq->rtb.time;
- tstate->spc_warnlimit = defq->blk.warn;
- tstate->ino_warnlimit = defq->ino.warn;
- tstate->rt_spc_warnlimit = defq->rtb.warn;
+ tstate->spc_warnlimit = 0;
+ tstate->ino_warnlimit = 0;
+ tstate->rt_spc_warnlimit = 0;
  if (tempqip)
  xfs_irele(ip);
 }
@@ -98,7 +98,7 @@ xfs_quota_type(int type)
  }
 }
 
-#define XFS_QC_SETINFO_MASK (QC_TIMER_MASK | QC_WARNS_MASK)
+#define XFS_QC_SETINFO_MASK (QC_TIMER_MASK)
 
 /*
  * Adjust quota timers & warnings

fs/xfs/xfs_trans_dquot.c

@@ -597,8 +597,7 @@ xfs_dqresv_check(
  if (softlimit && total_count > softlimit) {
  time64_t now = ktime_get_real_seconds();
 
- if ((res->timer != 0 && now > res->timer) ||
- (res->warnings != 0 && res->warnings >= qlim->warn)) {
+ if (res->timer != 0 && now > res->timer) {
  *fatal = true;
  return QUOTA_NL_ISOFTLONGWARN;
  }