xfs: quota fixes and enhancements
v3 cover xfs: quota fixes and enhancements
Once more with feeling, this rolls up the kernel patches sent in the prior 0/SEVERAL series, with the fixes Darrick pointed out. sorry this has been such a mess.
PATCH v3 1/7 xfs: group quota should return EDQUOT when prj quota enabled
Long ago, group & project quota were mutually exclusive, and so when we turned on XFS_QMOPT_ENOSPC ("return ENOSPC if project quota is exceeded") when project quota was enabled, we only needed to disable it again for user quota.
When group & project quota got separated, this got missed, and as a result if project quota is enabled and group quota is exceeded, the error code returned is incorrectly returned as ENOSPC not EDQUOT.
Fix this by stripping XFS_QMOPT_ENOSPC out of flags for group quota when we try to reserve the space.
--- fs/xfs/xfs_trans_dquot.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/xfs/xfs_trans_dquot.c +2 -1
@@ -758,7 +758,8 @@ }if (gdqp) { - error =xfs_trans_dqresv (tp, mp, gdqp, nblks, ninos, flags); + error =xfs_trans_dqresv (tp, mp, gdqp, nblks, ninos, + (flags & ~XFS_QMOPT_ENOSPC ));if (error) goto unwind_usr; }
Signature · 1 line
1.8.3.1
PATCH v3 2/7 xfs: always return -ENOSPC on project quota reservation failure
In reply to Eric SandeenXFS project quota treats project hierarchies as "mini filesysems" and so rather than -EDQUOT, the intent is to return -ENOSPC when a quota reservation fails, but this behavior is not consistent.
The only place we make a decision between -EDQUOT and -ENOSPC returns based on quota type is in xfs_trans_dqresv().
This behavior is currently controlled by whether or not the XFS_QMOPT_ENOSPC flag gets passed into the quota reservation. However, its use is not consistent; paths such as xfs_create() and xfs_symlink() don't set the flag, so a reservation failure will return -EDQUOT for project quota reservation failures rather than -ENOSPC for these sorts of operations, even for project quota:
# mkdir mnt/project
# xfs_quota -x -c "project -s -p mnt/project 42" mnt
# xfs_quota -x -c 'limit -p isoft=2 ihard=3 42' mnt
# touch mnt/project/file{1,2,3}
touch: cannot touch ‘mnt/project/file3’: Disk quota exceededWe can make this consistent by not requiring the flag to be set at the top of the callchain; instead we can simply test whether we are reserving a project quota with XFS_QM_ISPDQ in xfs_trans_dqresv and if so, return -ENOSPC for that failure. This removes the need for the XFS_QMOPT_ENOSPC altogether and simplifies the code a fair bit.
--- fs/xfs/libxfs/xfs_quota_defs.h | 1 - fs/xfs/xfs_qm.c | 9 +++------ fs/xfs/xfs_trans_dquot.c | 16 +++++----------- 3 files changed, 8 insertions(+), 18 deletions(-)
fs/xfs/libxfs/xfs_quota_defs.h +0 -1
@@ -100,7 +100,6 @@#define XFS_QMOPT_FORCE_RES 0x0000010/* ignore quota limits */ #define XFS_QMOPT_SBVERSION 0x0000040/* change superblock version num */ #define XFS_QMOPT_GQUOTA 0x0002000/* group dquot requested */ -#define XFS_QMOPT_ENOSPC 0x0004000/* enospc instead of edquot (prj) */ /* * flags to xfs_trans_mod_dquot to indicate which field needs to be
fs/xfs/xfs_qm.c +3 -6
@@ -1808,7 +1808,7 @@ struct xfs_dquot * {struct xfs_mount *mp = ip->i_mount;uint64_t delblks; -unsigned int blkflags, prjflags =0 ; +unsigned int blkflags;struct xfs_dquot *udq_unres =NULL ;struct xfs_dquot *gdq_unres =NULL ;struct xfs_dquot *pdq_unres =NULL ;
@@ -1849,7 +1849,6 @@ struct xfs_dquot *if (XFS_IS_PQUOTA_ON (ip->i_mount) && pdqp && ip->i_d.di_projid !=be32_to_cpu (pdqp->q_core.d_id)) { - prjflags =XFS_QMOPT_ENOSPC ; pdq_delblks = pdqp;if (delblks) {ASSERT (ip->i_pdquot);
@@ -1859,8 +1858,7 @@ struct xfs_dquot * error =xfs_trans_reserve_quota_bydquots (tp, ip->i_mount, udq_delblks, gdq_delblks, pdq_delblks, - ip->i_d.di_nblocks,1 , - flags | blkflags | prjflags); + ip->i_d.di_nblocks,1 , flags | blkflags);if (error)return error;
@@ -1878,8 +1876,7 @@ struct xfs_dquot *ASSERT (udq_unres || gdq_unres || pdq_unres); error =xfs_trans_reserve_quota_bydquots (NULL , ip->i_mount, udq_delblks, gdq_delblks, pdq_delblks, - (xfs_qcnt_t )delblks,0 , - flags | blkflags | prjflags); + (xfs_qcnt_t )delblks,0 , flags | blkflags);if (error)return error; xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
fs/xfs/xfs_trans_dquot.c +5 -11
@@ -711,7 +711,7 @@ error_return:xfs_dqunlock (dqp); -if (flags &XFS_QMOPT_ENOSPC ) +if (XFS_QM_ISPDQ (dqp))return -ENOSPC ;return -EDQUOT ; }
@@ -751,15 +751,13 @@ASSERT (flags &XFS_QMOPT_RESBLK_MASK );if (udqp) { - error =xfs_trans_dqresv (tp, mp, udqp, nblks, ninos, - (flags & ~XFS_QMOPT_ENOSPC )); + error =xfs_trans_dqresv (tp, mp, udqp, nblks, ninos, flags);if (error)return error; }if (gdqp) { - error =xfs_trans_dqresv (tp, mp, gdqp, nblks, ninos, - (flags & ~XFS_QMOPT_ENOSPC )); + error =xfs_trans_dqresv (tp, mp, gdqp, nblks, ninos, flags);if (error) goto unwind_usr; }
@@ -804,16 +802,12 @@if (!XFS_IS_QUOTA_RUNNING (mp) || !XFS_IS_QUOTA_ON (mp))return 0 ; -if (XFS_IS_PQUOTA_ON (mp)) - flags |=XFS_QMOPT_ENOSPC ;ASSERT (!xfs_is_quota_inode (&mp->m_sb, ip->i_ino));ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL )); -ASSERT ((flags & ~(XFS_QMOPT_FORCE_RES |XFS_QMOPT_ENOSPC )) == -XFS_TRANS_DQ_RES_RTBLKS || - (flags & ~(XFS_QMOPT_FORCE_RES |XFS_QMOPT_ENOSPC )) == -XFS_TRANS_DQ_RES_BLKS ); +ASSERT ((flags & ~(XFS_QMOPT_FORCE_RES )) ==XFS_TRANS_DQ_RES_RTBLKS || + (flags & ~(XFS_QMOPT_FORCE_RES )) ==XFS_TRANS_DQ_RES_BLKS );/* * Reserve nblks against these dquots, with trans as the mediator.
Signature · 1 line
1.8.3.1
PATCH v3 3/7 xfs: fix up some whitespace in quota code
In reply to Eric SandeenThere is a fair bit of whitespace damage in the quota code, so fix up enough of it that subsequent patches are restricted to functional change to aid review.
--- fs/xfs/xfs_qm.h | 44 ++++++++++++++++++++++---------------------- fs/xfs/xfs_quotaops.c | 8 ++++---- 2 files changed, 26 insertions(+), 26 deletions(-)
fs/xfs/xfs_qm.h +22 -22
@@ -42,12 +42,12 @@#define XFS_DQUOT_CLUSTER_SIZE_FSB (xfs_filblks_t)1struct xfs_def_quota { -xfs_qcnt_t bhardlimit;/* default data blk hard limit */ -xfs_qcnt_t bsoftlimit;/* default data blk soft limit */ -xfs_qcnt_t ihardlimit;/* default inode count hard limit */ -xfs_qcnt_t isoftlimit;/* default inode count soft limit */ -xfs_qcnt_t rtbhardlimit;/* default realtime blk hard limit */ -xfs_qcnt_t rtbsoftlimit;/* default realtime blk soft limit */ +xfs_qcnt_t bhardlimit;/* default data blk hard limit */ +xfs_qcnt_t bsoftlimit;/* default data blk soft limit */ +xfs_qcnt_t ihardlimit;/* default inode count hard limit */ +xfs_qcnt_t isoftlimit;/* default inode count soft limit */ +xfs_qcnt_t rtbhardlimit;/* default realtime blk hard limit */ +xfs_qcnt_t rtbsoftlimit;/* default realtime blk soft limit */ };/*
@@ -55,28 +55,28 @@ struct xfs_def_quota {* The mount structure keeps a pointer to this. */ struct xfs_quotainfo { -struct radix_tree_root qi_uquota_tree; -struct radix_tree_root qi_gquota_tree; -struct radix_tree_root qi_pquota_tree; -struct mutex qi_tree_lock; +struct radix_tree_root qi_uquota_tree; +struct radix_tree_root qi_gquota_tree; +struct radix_tree_root qi_pquota_tree; +struct mutex qi_tree_lock;struct xfs_inode *qi_uquotaip;/* user quota inode */ struct xfs_inode *qi_gquotaip;/* group quota inode */ struct xfs_inode *qi_pquotaip;/* project quota inode */ -struct list_lru qi_lru; -int qi_dquots; -time64_t qi_btimelimit;/* limit for blks timer */ -time64_t qi_itimelimit;/* limit for inodes timer */ -time64_t qi_rtbtimelimit;/* limit for rt blks timer */ -xfs_qwarncnt_t qi_bwarnlimit;/* limit for blks warnings */ -xfs_qwarncnt_t qi_iwarnlimit;/* limit for inodes warnings */ -xfs_qwarncnt_t qi_rtbwarnlimit;/* limit for rt blks warnings */ -struct mutex qi_quotaofflock;/* to serialize quotaoff */ -xfs_filblks_t qi_dqchunklen;/* # BBs in a chunk of dqs */ -uint qi_dqperchunk;/* # ondisk dqs in above chunk */ +struct list_lru qi_lru; +int qi_dquots; +time64_t qi_btimelimit;/* limit for blks timer */ +time64_t qi_itimelimit;/* limit for inodes timer */ +time64_t qi_rtbtimelimit;/* limit for rt blks timer */ +xfs_qwarncnt_t qi_bwarnlimit;/* limit for blks warnings */ +xfs_qwarncnt_t qi_iwarnlimit;/* limit for inodes warnings */ +xfs_qwarncnt_t qi_rtbwarnlimit;/* limit for rt blks warnings */ +struct mutex qi_quotaofflock;/* to serialize quotaoff */ +xfs_filblks_t qi_dqchunklen;/* # BBs in a chunk of dqs */ +uint qi_dqperchunk;/* # ondisk dq in above chunk */ struct xfs_def_quota qi_usr_default;struct xfs_def_quota qi_grp_default;struct xfs_def_quota qi_prj_default; -struct shrinker qi_shrinker; +struct shrinker qi_shrinker; }; static inline struct radix_tree_root *
fs/xfs/xfs_quotaops.c +4 -4
@@ -23,8 +23,8 @@ struct xfs_inode *ip, xfs_ino_t ino) { -struct xfs_quotainfo *q = mp->m_quotainfo; -bool tempqip = false; +struct xfs_quotainfo *q = mp->m_quotainfo; +bool tempqip = false; tstate->ino = ino;if (!ip && ino ==NULLFSINO )
@@ -109,8 +109,8 @@int type, struct qc_info *info) { - struct xfs_mount *mp = XFS_M(sb); -struct qc_dqblk newlim; + struct xfs_mount *mp = XFS_M(sb); +struct qc_dqblk newlim;if (sb_rdonly (sb))return -EROFS ;
Signature · 1 line
1.8.3.1
PATCH v3 4/7 xfs: pass xfs_dquot to xfs_qm_adjust_dqtimers
In reply to Eric SandeenPass xfs_dquot rather than xfs_disk_dquot to xfs_qm_adjust_dqtimers; this makes it symmetric with xfs_qm_adjust_dqlimits and will help the next patch.
--- fs/xfs/xfs_dquot.c | 3 ++- fs/xfs/xfs_dquot.h | 2 +- fs/xfs/xfs_qm.c | 2 +- fs/xfs/xfs_qm_syscalls.c | 2 +- fs/xfs/xfs_trans_dquot.c | 2 +- 5 files changed, 6 insertions(+), 5 deletions(-)
fs/xfs/xfs_dquot.c +2 -1
@@ -114,8 +114,9 @@void xfs_qm_adjust_dqtimers (struct xfs_mount *mp, -struct xfs_disk_dquot *d) +struct xfs_dquot *dq) { +struct xfs_disk_dquot *d = &dq->q_core;ASSERT (d->d_id);#ifdef DEBUG
fs/xfs/xfs_dquot.h +1 -1
@@ -154,7 +154,7 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)int xfs_qm_dqflush (struct xfs_dquot *dqp,struct xfs_buf **bpp);void xfs_qm_dqunpin_wait (struct xfs_dquot *dqp);void xfs_qm_adjust_dqtimers (struct xfs_mount *mp, -struct xfs_disk_dquot *d); +struct xfs_dquot *d);void xfs_qm_adjust_dqlimits (struct xfs_mount *mp,struct xfs_dquot *d);xfs_dqid_t xfs_qm_id_for_quotatype (struct xfs_inode *ip,uint type);
fs/xfs/xfs_qm.c +1 -1
@@ -1117,7 +1117,7 @@ struct xfs_qm_isolate {*/ if (dqp->q_core.d_id) {xfs_qm_adjust_dqlimits (mp, dqp); -xfs_qm_adjust_dqtimers (mp, &dqp->q_core); +xfs_qm_adjust_dqtimers (mp, dqp); } dqp->dq_flags |=XFS_DQ_DIRTY ;
fs/xfs/xfs_qm_syscalls.c +1 -1
@@ -588,7 +588,7 @@* is on or off. We don't really want to bother with iterating * over all ondisk dquots and turning the timers on/off. */ -xfs_qm_adjust_dqtimers (mp, ddq); +xfs_qm_adjust_dqtimers (mp, dqp); } dqp->dq_flags |=XFS_DQ_DIRTY ;xfs_trans_log_dquot (tp, dqp);
fs/xfs/xfs_trans_dquot.c +1 -1
@@ -388,7 +388,7 @@*/ if (d->d_id) {xfs_qm_adjust_dqlimits (tp->t_mountp, dqp); -xfs_qm_adjust_dqtimers (tp->t_mountp, d); +xfs_qm_adjust_dqtimers (tp->t_mountp, dqp); } dqp->dq_flags |=XFS_DQ_DIRTY ;
Signature · 1 line
1.8.3.1
PATCH v3 5/7 xfs: switch xfs_get_defquota to take explicit type
In reply to Eric Sandeenxfs_get_defquota() currently takes an xfs_dquot, and from that obtains the type of default quota we should get (user/group/project).
But early in init, we don't have access to a fully set up quota, so that's not possible. The next patch needs go set up default quota timers early, so switch xfs_get_defquota to take an explicit type and add a helper function to obtain that type from an xfs_dquot for the existing callers.
--- fs/xfs/xfs_dquot.c | 2 +- fs/xfs/xfs_qm.c | 2 +- fs/xfs/xfs_qm.h | 28 +++++++++++++++++++++++----- fs/xfs/xfs_qm_syscalls.c | 2 +- fs/xfs/xfs_trans_dquot.c | 2 +- 5 files changed, 27 insertions(+), 9 deletions(-)
fs/xfs/xfs_dquot.c +1 -1
@@ -75,7 +75,7 @@int prealloc =0 ;ASSERT (d->d_id); - defq =xfs_get_defquota (dq, q); + defq =xfs_get_defquota (q,xfs_dquot_type (dq));if (defq->bsoftlimit && !d->d_blk_softlimit) { d->d_blk_softlimit =cpu_to_be64 (defq->bsoftlimit);
fs/xfs/xfs_qm.c +1 -1
@@ -558,7 +558,7 @@ struct xfs_qm_isolate {return ; ddqp = &dqp->q_core; - defq =xfs_get_defquota (dqp, qinf); + defq =xfs_get_defquota (qinf,xfs_dquot_type (dqp));/* * Timers and warnings have been already set, let's just set the
fs/xfs/xfs_qm.h +23 -5
@@ -113,6 +113,19 @@ struct xfs_quotainfo {return NULL ; } +static inline int +xfs_dquot_type (struct xfs_dquot *dqp) +{ +if (XFS_QM_ISUDQ (dqp)) +return XFS_DQ_USER ; +else if (XFS_QM_ISGDQ (dqp)) +return XFS_DQ_GROUP ; +else { +ASSERT (XFS_QM_ISPDQ (dqp)); +return XFS_DQ_PROJ ; + } +} +extern void xfs_trans_mod_dquot (struct xfs_trans *tp,struct xfs_dquot *dqp,uint field,int64_t delta);extern void xfs_trans_dqjoin (struct xfs_trans *,struct xfs_dquot *);
@@ -164,17 +177,22 @@ extern int xfs_qm_scall_setqlim(struct xfs_mount *, xfs_dqid_t, uint,extern int xfs_qm_scall_quotaoff (struct xfs_mount *,uint );static inline struct xfs_def_quota * -xfs_get_defquota (struct xfs_dquot *dqp,struct xfs_quotainfo *qi) +xfs_get_defquota (struct xfs_quotainfo *qi,int type) {struct xfs_def_quota *defq; -if (XFS_QM_ISUDQ (dqp)) +switch (type) { +case XFS_DQ_USER : defq = &qi->qi_usr_default; -else if (XFS_QM_ISGDQ (dqp)) +break ; +case XFS_DQ_GROUP : defq = &qi->qi_grp_default; -else { -ASSERT (XFS_QM_ISPDQ (dqp)); +break ; +case XFS_DQ_PROJ : defq = &qi->qi_prj_default; +break ; +default : +ASSERT (0 ); }return defq; }
fs/xfs/xfs_qm_syscalls.c +1 -1
@@ -479,7 +479,7 @@ goto out_unlock; } - defq =xfs_get_defquota (dqp, q); + defq =xfs_get_defquota (q,xfs_dquot_type (dqp));xfs_dqunlock (dqp); error =xfs_trans_alloc (mp, &M_RES (mp)->tr_qm_setqlim,0 ,0 ,0 , &tp);
fs/xfs/xfs_trans_dquot.c +1 -1
@@ -591,7 +591,7 @@xfs_dqlock (dqp); - defq =xfs_get_defquota (dqp, q); + defq =xfs_get_defquota (q,xfs_dquot_type (dqp));if (flags &XFS_TRANS_DQ_RES_BLKS ) { hardlimit =be64_to_cpu (dqp->q_core.d_blk_hardlimit);
Signature · 1 line
1.8.3.1
Re: [PATCH 5/7] xfs: switch xfs_get_defquota to take explicit type
Quoted 53 lines · Eric Sandeen
xfs_get_defquota()currently takes anxfs_dquot, and from that obtains the type of default quota we should get (user/group/project).But early in init, we don't have access to a fully set up quota, so that's not possible. The next patch needs go set up default quota timers early, so switch
xfs_get_defquotato take an explicit type and add a helper function to obtain that type from anxfs_dquotfor the existing callers.Signed-off-by Eric Sandeen <[email protected]>--- fs/xfs/xfs_dquot.c | 2 +- fs/xfs/xfs_qm.c | 2 +- fs/xfs/xfs_qm.h | 28 +++++++++++++++++++++++----- fs/xfs/xfs_qm_syscalls.c | 2 +- fs/xfs/xfs_trans_dquot.c | 2 +- 5 files changed, 27 insertions(+), 9 deletions(-)fs/xfs/xfs_dquot.c +1
-1@@ -75,7 +75,7 @@int prealloc =0 ;ASSERT (d->d_id); - defq =xfs_get_defquota (dq, q); + defq =xfs_get_defquota (q,xfs_dquot_type (dq));if (defq->bsoftlimit && !d->d_blk_softlimit) { d->d_blk_softlimit =cpu_to_be64 (defq->bsoftlimit);fs/xfs/xfs_qm.c +1
-1@@ -558,7 +558,7 @@ struct xfs_qm_isolate {return ; ddqp = &dqp->q_core; - defq =xfs_get_defquota (dqp, qinf); + defq =xfs_get_defquota (qinf,xfs_dquot_type (dqp));/* * Timers and warnings have been already set, let's just set the fs/xfs/xfs_qm.h +1
-0@@ -113,6 +113,19 @@ struct xfs_quotainfo {return NULL ; } +static inline int
fs/xfs/xfs_qm.h struct xfs_quotainfo { · line 126
Quoted 10 lines
fs/xfs/xfs_qm.h +10
-0+xfs_dquot_type(struct xfs_dquot *dqp) +{ +if (XFS_QM_ISUDQ (dqp)) +return XFS_DQ_USER ; +else if (XFS_QM_ISGDQ (dqp)) +return XFS_DQ_GROUP ; +else { +ASSERT (XFS_QM_ISPDQ (dqp)); +return XFS_DQ_PROJ ; + }
No real need for the elses here:
if (XFS_QM_ISUDQ(dqp)) return XFS_DQ_USER; if (XFS_QM_ISGDQ(dqp)) return XFS_DQ_GROUP; ASSERT(XFS_QM_ISPDQ(dqp)); return XFS_DQ_PROJ;
Quoted 8 lines
fs/xfs/xfs_qm.h +4
-0+xfs_get_defquota(struct xfs_quotainfo *qi, int type) {struct xfs_def_quota *defq; +switch (type) { +case XFS_DQ_USER : defq = &qi->qi_usr_default; +break ;
fs/xfs/xfs_qm.h extern int xfs_qm_scall_setqlim(struct xfs_mount *, xfs_dqid_t, uint, · line 197
Quoted 10 lines
fs/xfs/xfs_qm.h +6
-0+case XFS_DQ_GROUP : defq = &qi->qi_grp_default; +break ; +case XFS_DQ_PROJ : defq = &qi->qi_prj_default; +break ; +default : +ASSERT (0 ); }return defq;
Just kill the defq variable and return directly?
switch (type) {
case XFS_DQ_USER:
return &qi->qi_usr_default;
case XFS_DQ_GROUP:
return &qi->qi_grp_default;
case XFS_DQ_PROJ:
return &qi->qi_prj_default;
default:
ASSERT(0);
return NULL;
}PATCH v2 5/7 xfs: switch xfs_get_defquota to take explicit type
In reply to Eric Sandeenxfs_get_defquota() currently takes an xfs_dquot, and from that obtains the type of default quota we should get (user/group/project).
But early in init, we don't have access to a fully set up quota, so that's not possible. The next patch needs go set up default quota timers early, so switch xfs_get_defquota to take an explicit type and add a helper function to obtain that type from an xfs_dquot for the existing callers.
---
V2: Make hch's suggested tidiness changes.
Yes I did run this through the quota tests again, still pass. :)
fs/xfs/xfs_dquot.c +1 -1
@@ -75,7 +75,7 @@ xfs_qm_adjust_dqlimits(int prealloc =0 ;ASSERT (d->d_id); - defq =xfs_get_defquota (dq, q); + defq =xfs_get_defquota (q,xfs_dquot_type (dq));if (defq->bsoftlimit && !d->d_blk_softlimit) { d->d_blk_softlimit =cpu_to_be64 (defq->bsoftlimit);
fs/xfs/xfs_qm.c +1 -1
@@ -558,7 +558,7 @@ xfs_qm_set_defquota(return ; ddqp = &dqp->q_core; - defq =xfs_get_defquota (dqp, qinf); + defq =xfs_get_defquota (qinf,xfs_dquot_type (dqp));/* * Timers and warnings have been already set, let's just set the
fs/xfs/xfs_qm.h +22 -11
@@ -113,6 +113,17 @@ xfs_quota_inode(xfs_mount_t *mp, uint dq_flags)return NULL ; } +static inline int +xfs_dquot_type (struct xfs_dquot *dqp) +{ +if (XFS_QM_ISUDQ (dqp)) +return XFS_DQ_USER ; +if (XFS_QM_ISGDQ (dqp)) +return XFS_DQ_GROUP ; +ASSERT (XFS_QM_ISPDQ (dqp)); +return XFS_DQ_PROJ ; +} +extern void xfs_trans_mod_dquot (struct xfs_trans *tp,struct xfs_dquot *dqp,uint field,int64_t delta);extern void xfs_trans_dqjoin (struct xfs_trans *,struct xfs_dquot *);
@@ -164,19 +175,19 @@ extern int xfs_qm_scall_quotaon(struct xfs_mount *, uint);extern int xfs_qm_scall_quotaoff (struct xfs_mount *,uint );static inline struct xfs_def_quota * -xfs_get_defquota (struct xfs_dquot *dqp,struct xfs_quotainfo *qi) +xfs_get_defquota (struct xfs_quotainfo *qi,int type) { -struct xfs_def_quota *defq; - -if (XFS_QM_ISUDQ (dqp)) - defq = &qi->qi_usr_default; -else if (XFS_QM_ISGDQ (dqp)) - defq = &qi->qi_grp_default; -else { -ASSERT (XFS_QM_ISPDQ (dqp)); - defq = &qi->qi_prj_default; +switch (type) { +case XFS_DQ_USER : +return &qi->qi_usr_default; +case XFS_DQ_GROUP : +return &qi->qi_grp_default; +case XFS_DQ_PROJ : +return &qi->qi_prj_default; +default : +ASSERT (0 ); +return NULL ; } -return defq; }#endif /* __XFS_QM_H__ */
fs/xfs/xfs_qm_syscalls.c +1 -1
@@ -479,7 +479,7 @@ xfs_qm_scall_setqlim( goto out_unlock; } - defq =xfs_get_defquota (dqp, q); + defq =xfs_get_defquota (q,xfs_dquot_type (dqp));xfs_dqunlock (dqp); error =xfs_trans_alloc (mp, &M_RES (mp)->tr_qm_setqlim,0 ,0 ,0 , &tp);
fs/xfs/xfs_trans_dquot.c +1 -1
@@ -591,7 +591,7 @@ xfs_trans_dqresv(xfs_dqlock (dqp); - defq =xfs_get_defquota (dqp, q); + defq =xfs_get_defquota (q,xfs_dquot_type (dqp));if (flags &XFS_TRANS_DQ_RES_BLKS ) { hardlimit =be64_to_cpu (dqp->q_core.d_blk_hardlimit);
Re: [PATCH 5/7 V2] xfs: switch xfs_get_defquota to take explicit type
Quoted 10 lines · Eric Sandeen
xfs_get_defquota()currently takes anxfs_dquot, and from that obtains the type of default quota we should get (user/group/project).But early in init, we don't have access to a fully set up quota, so that's not possible. The next patch needs go set up default quota timers early, so switch
xfs_get_defquotato take an explicit type and add a helper function to obtain that type from anxfs_dquotfor the existing callers.Signed-off-by Eric Sandeen <[email protected]>
Looks good,
Re: [PATCH 5/7 V2] xfs: switch xfs_get_defquota to take explicit type
In reply to Eric SandeenQuoted 10 lines · Eric Sandeen
xfs_get_defquota()currently takes anxfs_dquot, and from that obtains the type of default quota we should get (user/group/project).But early in init, we don't have access to a fully set up quota, so that's not possible. The next patch needs go set up default quota timers early, so switch
xfs_get_defquotato take an explicit type and add a helper function to obtain that type from anxfs_dquotfor the existing callers.Signed-off-by Eric Sandeen <[email protected]>
Looks ok,
--D
Quoted 113 lines
---
V2: Make hch's suggested tidiness changes.
Yes I did run this through the quota tests again, still pass. :)
fs/xfs/xfs_dquot.c +1
-1@@ -75,7 +75,7 @@ xfs_qm_adjust_dqlimits(int prealloc =0 ;ASSERT (d->d_id); - defq =xfs_get_defquota (dq, q); + defq =xfs_get_defquota (q,xfs_dquot_type (dq));if (defq->bsoftlimit && !d->d_blk_softlimit) { d->d_blk_softlimit =cpu_to_be64 (defq->bsoftlimit);fs/xfs/xfs_qm.c +1
-1@@ -558,7 +558,7 @@ xfs_qm_set_defquota(return ; ddqp = &dqp->q_core; - defq =xfs_get_defquota (dqp, qinf); + defq =xfs_get_defquota (qinf,xfs_dquot_type (dqp));/* * Timers and warnings have been already set, let's just set the fs/xfs/xfs_qm.h +22
-11@@ -113,6 +113,17 @@ xfs_quota_inode(xfs_mount_t *mp, uint dq_flags)return NULL ; } +static inline int +xfs_dquot_type (struct xfs_dquot *dqp) +{ +if (XFS_QM_ISUDQ (dqp)) +return XFS_DQ_USER ; +if (XFS_QM_ISGDQ (dqp)) +return XFS_DQ_GROUP ; +ASSERT (XFS_QM_ISPDQ (dqp)); +return XFS_DQ_PROJ ; +} +extern void xfs_trans_mod_dquot (struct xfs_trans *tp,struct xfs_dquot *dqp,uint field,int64_t delta);extern void xfs_trans_dqjoin (struct xfs_trans *,struct xfs_dquot *);@@ -164,19 +175,19 @@ extern int xfs_qm_scall_quotaon(struct xfs_mount *, uint);extern int xfs_qm_scall_quotaoff (struct xfs_mount *,uint );static inline struct xfs_def_quota * -xfs_get_defquota (struct xfs_dquot *dqp,struct xfs_quotainfo *qi) +xfs_get_defquota (struct xfs_quotainfo *qi,int type) { -struct xfs_def_quota *defq; - -if (XFS_QM_ISUDQ (dqp)) - defq = &qi->qi_usr_default; -else if (XFS_QM_ISGDQ (dqp)) - defq = &qi->qi_grp_default; -else { -ASSERT (XFS_QM_ISPDQ (dqp)); - defq = &qi->qi_prj_default; +switch (type) { +case XFS_DQ_USER : +return &qi->qi_usr_default; +case XFS_DQ_GROUP : +return &qi->qi_grp_default; +case XFS_DQ_PROJ : +return &qi->qi_prj_default; +default : +ASSERT (0 ); +return NULL ; } -return defq; }#endif /* __XFS_QM_H__ */ fs/xfs/xfs_qm_syscalls.c +1
-1@@ -479,7 +479,7 @@ xfs_qm_scall_setqlim( goto out_unlock; } - defq =xfs_get_defquota (dqp, q); + defq =xfs_get_defquota (q,xfs_dquot_type (dqp));xfs_dqunlock (dqp); error =xfs_trans_alloc (mp, &M_RES (mp)->tr_qm_setqlim,0 ,0 ,0 , &tp);fs/xfs/xfs_trans_dquot.c +1
-1@@ -591,7 +591,7 @@ xfs_trans_dqresv(xfs_dqlock (dqp); - defq =xfs_get_defquota (dqp, q); + defq =xfs_get_defquota (q,xfs_dquot_type (dqp));if (flags &XFS_TRANS_DQ_RES_BLKS ) { hardlimit =be64_to_cpu (dqp->q_core.d_blk_hardlimit);
PATCH v3 6/7 xfs: per-type quota timers and warn limits
In reply to Eric SandeenMove timers and warnings out of xfs_quotainfo and into xfs_def_quota so that we can utilize them on a per-type basis, rather than enforcing them based on the values found in the first enabled quota type.
--- fs/xfs/xfs_dquot.c | 10 +++++++--- fs/xfs/xfs_qm.c | 46 +++++++++++++++++++++------------------------- fs/xfs/xfs_qm.h | 13 +++++++------ fs/xfs/xfs_qm_syscalls.c | 12 ++++++------ fs/xfs/xfs_quotaops.c | 22 +++++++++++----------- fs/xfs/xfs_trans_dquot.c | 6 +++--- 6 files changed, 55 insertions(+), 54 deletions(-)
fs/xfs/xfs_dquot.c +7 -3
@@ -116,8 +116,12 @@struct xfs_mount *mp, struct xfs_dquot *dq) { + struct xfs_quotainfo *qi = mp->m_quotainfo;struct xfs_disk_dquot *d = &dq->q_core; +struct xfs_def_quota *defq; +ASSERT (d->d_id); + defq =xfs_get_defquota (qi,xfs_dquot_type (dq));#ifdef DEBUG if (d->d_blk_hardlimit)
@@ -139,7 +143,7 @@ (be64_to_cpu(d->d_bcount) > be64_to_cpu(d->d_blk_hardlimit)))) { d->d_btimer = cpu_to_be32(ktime_get_real_seconds() + - mp->m_quotainfo->qi_btimelimit); + defq->btimelimit); } else { d->d_bwarns =0 ; }
@@ -162,7 +166,7 @@ (be64_to_cpu(d->d_icount) > be64_to_cpu(d->d_ino_hardlimit)))) { d->d_itimer = cpu_to_be32(ktime_get_real_seconds() + - mp->m_quotainfo->qi_itimelimit); + defq->itimelimit); } else { d->d_iwarns =0 ; }
@@ -185,7 +189,7 @@ (be64_to_cpu(d->d_rtbcount) > be64_to_cpu(d->d_rtb_hardlimit)))) { d->d_rtbtimer = cpu_to_be32(ktime_get_real_seconds() + - mp->m_quotainfo->qi_rtbtimelimit); + defq->rtbtimelimit); } else { d->d_rtbwarns =0 ; }
fs/xfs/xfs_qm.c +21 -25
86 lines not on this page · raw message
fs/xfs/xfs_qm.h +7 -6
@@ -41,7 +41,14 @@*/ #define XFS_DQUOT_CLUSTER_SIZE_FSB (xfs_filblks_t)1 +/* Defaults for each quota type: time limits, warn limits, usage limits */ struct xfs_def_quota { +time64_t btimelimit;/* limit for blks timer */ +time64_t itimelimit;/* limit for inodes timer */ +time64_t rtbtimelimit;/* limit for rt blks timer */ +xfs_qwarncnt_t bwarnlimit;/* limit for blks warnings */ +xfs_qwarncnt_t iwarnlimit;/* limit for inodes warnings */ +xfs_qwarncnt_t rtbwarnlimit;/* limit for rt blks warnings */ xfs_qcnt_t bhardlimit;/* default data blk hard limit */ xfs_qcnt_t bsoftlimit;/* default data blk soft limit */ xfs_qcnt_t ihardlimit;/* default inode count hard limit */
@@ -64,12 +71,6 @@ struct xfs_quotainfo {struct xfs_inode *qi_pquotaip;/* project quota inode */ struct list_lru qi_lru;int qi_dquots; -time64_t qi_btimelimit;/* limit for blks timer */ -time64_t qi_itimelimit;/* limit for inodes timer */ -time64_t qi_rtbtimelimit;/* limit for rt blks timer */ -xfs_qwarncnt_t qi_bwarnlimit;/* limit for blks warnings */ -xfs_qwarncnt_t qi_iwarnlimit;/* limit for inodes warnings */ -xfs_qwarncnt_t qi_rtbwarnlimit;/* limit for rt blks warnings */ struct mutex qi_quotaofflock;/* to serialize quotaoff */ xfs_filblks_t qi_dqchunklen;/* # BBs in a chunk of dqs */ uint qi_dqperchunk;/* # ondisk dq in above chunk */
fs/xfs/xfs_qm_syscalls.c +6 -6
@@ -563,23 +563,23 @@* for warnings. */ if (newlim->d_fieldmask &QC_SPC_TIMER ) { - q->qi_btimelimit = newlim->d_spc_timer; + defq->btimelimit = newlim->d_spc_timer; ddq->d_btimer =cpu_to_be32 (newlim->d_spc_timer); }if (newlim->d_fieldmask &QC_INO_TIMER ) { - q->qi_itimelimit = newlim->d_ino_timer; + defq->itimelimit = newlim->d_ino_timer; ddq->d_itimer =cpu_to_be32 (newlim->d_ino_timer); }if (newlim->d_fieldmask &QC_RT_SPC_TIMER ) { - q->qi_rtbtimelimit = newlim->d_rt_spc_timer; + defq->rtbtimelimit = newlim->d_rt_spc_timer; ddq->d_rtbtimer =cpu_to_be32 (newlim->d_rt_spc_timer); }if (newlim->d_fieldmask &QC_SPC_WARNS ) - q->qi_bwarnlimit = newlim->d_spc_warns; + defq->bwarnlimit = newlim->d_spc_warns;if (newlim->d_fieldmask &QC_INO_WARNS ) - q->qi_iwarnlimit = newlim->d_ino_warns; + defq->iwarnlimit = newlim->d_ino_warns;if (newlim->d_fieldmask &QC_RT_SPC_WARNS ) - q->qi_rtbwarnlimit = newlim->d_rt_spc_warns; + defq->rtbwarnlimit = newlim->d_rt_spc_warns; }else {/* * If the user is now over quota, start the timelimit.
fs/xfs/xfs_quotaops.c +11 -11
@@ -21,9 +21,9 @@struct qc_type_state *tstate, struct xfs_mount *mp, struct xfs_inode *ip, - xfs_ino_t ino) + xfs_ino_t ino, + struct xfs_def_quota *defq) { - struct xfs_quotainfo *q = mp->m_quotainfo; bool tempqip = false; tstate->ino = ino;
@@ -37,12 +37,12 @@ tstate->flags |=QCI_SYSFILE ; tstate->blocks = ip->i_d.di_nblocks; tstate->nextents = ip->i_df.if_nextents; - tstate->spc_timelimit = (u32 )q->qi_btimelimit; - tstate->ino_timelimit = (u32 )q->qi_itimelimit; - tstate->rt_spc_timelimit = (u32 )q->qi_rtbtimelimit; - tstate->spc_warnlimit = q->qi_bwarnlimit; - tstate->ino_warnlimit = q->qi_iwarnlimit; - tstate->rt_spc_warnlimit = q->qi_rtbwarnlimit; + tstate->spc_timelimit = (u32 )defq->btimelimit; + tstate->ino_timelimit = (u32 )defq->itimelimit; + tstate->rt_spc_timelimit = (u32 )defq->rtbtimelimit; + tstate->spc_warnlimit = defq->bwarnlimit; + tstate->ino_warnlimit = defq->iwarnlimit; + tstate->rt_spc_warnlimit = defq->rtbwarnlimit;if (tempqip)xfs_irele (ip); }
@@ -77,11 +77,11 @@ state->s_state[PRJQUOTA ].flags |=QCI_LIMITS_ENFORCED ;xfs_qm_fill_state (&state->s_state[USRQUOTA ], mp, q->qi_uquotaip, - mp->m_sb.sb_uquotino); + mp->m_sb.sb_uquotino, &q->qi_usr_default);xfs_qm_fill_state (&state->s_state[GRPQUOTA ], mp, q->qi_gquotaip, - mp->m_sb.sb_gquotino); + mp->m_sb.sb_gquotino, &q->qi_grp_default);xfs_qm_fill_state (&state->s_state[PRJQUOTA ], mp, q->qi_pquotaip, - mp->m_sb.sb_pquotino); + mp->m_sb.sb_pquotino, &q->qi_prj_default);return 0 ; }
fs/xfs/xfs_trans_dquot.c +3 -3
@@ -602,7 +602,7 @@ softlimit = defq->bsoftlimit; timer =be32_to_cpu (dqp->q_core.d_btimer); warns =be16_to_cpu (dqp->q_core.d_bwarns); - warnlimit = dqp->q_mount->m_quotainfo->qi_bwarnlimit; + warnlimit = defq->bwarnlimit; resbcountp = &dqp->q_res_bcount; }else {ASSERT (flags &XFS_TRANS_DQ_RES_RTBLKS );
@@ -614,7 +614,7 @@ softlimit = defq->rtbsoftlimit; timer =be32_to_cpu (dqp->q_core.d_rtbtimer); warns =be16_to_cpu (dqp->q_core.d_rtbwarns); - warnlimit = dqp->q_mount->m_quotainfo->qi_rtbwarnlimit; + warnlimit = defq->rtbwarnlimit; resbcountp = &dqp->q_res_rtbcount; }
@@ -650,7 +650,7 @@ total_count =be64_to_cpu (dqp->q_core.d_icount) + ninos; timer =be32_to_cpu (dqp->q_core.d_itimer); warns =be16_to_cpu (dqp->q_core.d_iwarns); - warnlimit = dqp->q_mount->m_quotainfo->qi_iwarnlimit; + warnlimit = defq->iwarnlimit; hardlimit =be64_to_cpu (dqp->q_core.d_ino_hardlimit);if (!hardlimit) hardlimit = defq->ihardlimit;
Signature · 1 line
1.8.3.1
Re: [PATCH 6/7] xfs: per-type quota timers and warn limits
Looks good,
Re: [PATCH 6/7] xfs: per-type quota timers and warn limits
In reply to Eric SandeenQuoted 10 lines · Eric Sandeen
Move timers and warnings out of
xfs_quotainfoand intoxfs_def_quotaso that we can utilize them on a per-type basis, rather than enforcing them based on the values found in the first enabled quota type.Signed-off-by Eric Sandeen <[email protected]>[zlang: new way to get defquota in xfs_qm_init_timelimits][zlang: remove redundant defq assign]Signed-off-by Zorro Lang <[email protected]>Signed-off-by Eric Sandeen <[email protected]>
Looks decent,
--D
Quoted 296 lines
--- fs/xfs/xfs_dquot.c | 10 +++++++--- fs/xfs/xfs_qm.c | 46 +++++++++++++++++++++------------------------- fs/xfs/xfs_qm.h | 13 +++++++------ fs/xfs/xfs_qm_syscalls.c | 12 ++++++------ fs/xfs/xfs_quotaops.c | 22 +++++++++++----------- fs/xfs/xfs_trans_dquot.c | 6 +++--- 6 files changed, 55 insertions(+), 54 deletions(-)fs/xfs/xfs_dquot.c +7
-3@@ -116,8 +116,12 @@struct xfs_mount *mp, struct xfs_dquot *dq) { + struct xfs_quotainfo *qi = mp->m_quotainfo;struct xfs_disk_dquot *d = &dq->q_core; +struct xfs_def_quota *defq; +ASSERT (d->d_id); + defq =xfs_get_defquota (qi,xfs_dquot_type (dq));#ifdef DEBUG if (d->d_blk_hardlimit)@@ -139,7 +143,7 @@ (be64_to_cpu(d->d_bcount) > be64_to_cpu(d->d_blk_hardlimit)))) { d->d_btimer = cpu_to_be32(ktime_get_real_seconds() + - mp->m_quotainfo->qi_btimelimit); + defq->btimelimit); } else { d->d_bwarns =0 ; }@@ -162,7 +166,7 @@ (be64_to_cpu(d->d_icount) > be64_to_cpu(d->d_ino_hardlimit)))) { d->d_itimer = cpu_to_be32(ktime_get_real_seconds() + - mp->m_quotainfo->qi_itimelimit); + defq->itimelimit); } else { d->d_iwarns =0 ; }@@ -185,7 +189,7 @@ (be64_to_cpu(d->d_rtbcount) > be64_to_cpu(d->d_rtb_hardlimit)))) { d->d_rtbtimer = cpu_to_be32(ktime_get_real_seconds() + - mp->m_quotainfo->qi_rtbtimelimit); + defq->rtbtimelimit); } else { d->d_rtbwarns =0 ; }fs/xfs/xfs_qm.c +21
-25@@ -577,19 +577,22 @@ struct xfs_qm_isolate {static void xfs_qm_init_timelimits (struct xfs_mount *mp, -struct xfs_quotainfo *qinf) +uint type) { +struct xfs_quotainfo *qinf = mp->m_quotainfo; +struct xfs_def_quota *defq;struct xfs_disk_dquot *ddqp;struct xfs_dquot *dqp; -uint type;int error; - qinf->qi_btimelimit =XFS_QM_BTIMELIMIT ; - qinf->qi_itimelimit =XFS_QM_ITIMELIMIT ; - qinf->qi_rtbtimelimit =XFS_QM_RTBTIMELIMIT ; - qinf->qi_bwarnlimit =XFS_QM_BWARNLIMIT ; - qinf->qi_iwarnlimit =XFS_QM_IWARNLIMIT ; - qinf->qi_rtbwarnlimit =XFS_QM_RTBWARNLIMIT ; + defq =xfs_get_defquota (qinf, type); + + defq->btimelimit =XFS_QM_BTIMELIMIT ; + defq->itimelimit =XFS_QM_ITIMELIMIT ; + defq->rtbtimelimit =XFS_QM_RTBTIMELIMIT ; + defq->bwarnlimit =XFS_QM_BWARNLIMIT ; + defq->iwarnlimit =XFS_QM_IWARNLIMIT ; + defq->rtbwarnlimit =XFS_QM_RTBWARNLIMIT ;/* * We try to get the limits from the superuser's limits fields. @@ -597,39 +600,30 @@ struct xfs_qm_isolate {* * Since we may not have done a quotacheck by this point, just read * the dquot without attaching it to any hashtables or lists. -* -* Timers and warnings are globally set by the first timer found in -* user/group/proj quota types, otherwise a default value is used. -* This should be split into different fields per quota type. */ -if (XFS_IS_UQUOTA_RUNNING (mp)) - type =XFS_DQ_USER ; -else if (XFS_IS_GQUOTA_RUNNING (mp)) - type =XFS_DQ_GROUP ; -else - type =XFS_DQ_PROJ ; error =xfs_qm_dqget_uncached (mp,0 , type, &dqp);if (error)return ; ddqp = &dqp->q_core; +/* * The warnings and timers set the grace period given to * a user or group before he or she can not perform any * more writing. If it is zero, a default is used. */ if (ddqp->d_btimer) - qinf->qi_btimelimit =be32_to_cpu (ddqp->d_btimer); + defq->btimelimit =be32_to_cpu (ddqp->d_btimer);if (ddqp->d_itimer) - qinf->qi_itimelimit =be32_to_cpu (ddqp->d_itimer); + defq->itimelimit =be32_to_cpu (ddqp->d_itimer);if (ddqp->d_rtbtimer) - qinf->qi_rtbtimelimit =be32_to_cpu (ddqp->d_rtbtimer); + defq->rtbtimelimit =be32_to_cpu (ddqp->d_rtbtimer);if (ddqp->d_bwarns) - qinf->qi_bwarnlimit =be16_to_cpu (ddqp->d_bwarns); + defq->bwarnlimit =be16_to_cpu (ddqp->d_bwarns);if (ddqp->d_iwarns) - qinf->qi_iwarnlimit =be16_to_cpu (ddqp->d_iwarns); + defq->iwarnlimit =be16_to_cpu (ddqp->d_iwarns);if (ddqp->d_rtbwarns) - qinf->qi_rtbwarnlimit =be16_to_cpu (ddqp->d_rtbwarns); + defq->rtbwarnlimit =be16_to_cpu (ddqp->d_rtbwarns);xfs_qm_dqdestroy (dqp); }@@ -675,7 +669,9 @@ struct xfs_qm_isolate { mp->m_qflags |= (mp->m_sb.sb_qflags &XFS_ALL_QUOTA_CHKD ); -xfs_qm_init_timelimits (mp, qinf); +xfs_qm_init_timelimits (mp,XFS_DQ_USER ); +xfs_qm_init_timelimits (mp,XFS_DQ_GROUP ); +xfs_qm_init_timelimits (mp,XFS_DQ_PROJ );if (XFS_IS_UQUOTA_RUNNING (mp))xfs_qm_set_defquota (mp,XFS_DQ_USER , qinf);fs/xfs/xfs_qm.h +7
-6@@ -41,7 +41,14 @@*/ #define XFS_DQUOT_CLUSTER_SIZE_FSB (xfs_filblks_t)1 +/* Defaults for each quota type: time limits, warn limits, usage limits */ struct xfs_def_quota { +time64_t btimelimit;/* limit for blks timer */ +time64_t itimelimit;/* limit for inodes timer */ +time64_t rtbtimelimit;/* limit for rt blks timer */ +xfs_qwarncnt_t bwarnlimit;/* limit for blks warnings */ +xfs_qwarncnt_t iwarnlimit;/* limit for inodes warnings */ +xfs_qwarncnt_t rtbwarnlimit;/* limit for rt blks warnings */ xfs_qcnt_t bhardlimit;/* default data blk hard limit */ xfs_qcnt_t bsoftlimit;/* default data blk soft limit */ xfs_qcnt_t ihardlimit;/* default inode count hard limit */ @@ -64,12 +71,6 @@ struct xfs_quotainfo {struct xfs_inode *qi_pquotaip;/* project quota inode */ struct list_lru qi_lru;int qi_dquots; -time64_t qi_btimelimit;/* limit for blks timer */ -time64_t qi_itimelimit;/* limit for inodes timer */ -time64_t qi_rtbtimelimit;/* limit for rt blks timer */ -xfs_qwarncnt_t qi_bwarnlimit;/* limit for blks warnings */ -xfs_qwarncnt_t qi_iwarnlimit;/* limit for inodes warnings */ -xfs_qwarncnt_t qi_rtbwarnlimit;/* limit for rt blks warnings */ struct mutex qi_quotaofflock;/* to serialize quotaoff */ xfs_filblks_t qi_dqchunklen;/* # BBs in a chunk of dqs */ uint qi_dqperchunk;/* # ondisk dq in above chunk */ fs/xfs/xfs_qm_syscalls.c +6
-6@@ -563,23 +563,23 @@* for warnings. */ if (newlim->d_fieldmask &QC_SPC_TIMER ) { - q->qi_btimelimit = newlim->d_spc_timer; + defq->btimelimit = newlim->d_spc_timer; ddq->d_btimer =cpu_to_be32 (newlim->d_spc_timer); }if (newlim->d_fieldmask &QC_INO_TIMER ) { - q->qi_itimelimit = newlim->d_ino_timer; + defq->itimelimit = newlim->d_ino_timer; ddq->d_itimer =cpu_to_be32 (newlim->d_ino_timer); }if (newlim->d_fieldmask &QC_RT_SPC_TIMER ) { - q->qi_rtbtimelimit = newlim->d_rt_spc_timer; + defq->rtbtimelimit = newlim->d_rt_spc_timer; ddq->d_rtbtimer =cpu_to_be32 (newlim->d_rt_spc_timer); }if (newlim->d_fieldmask &QC_SPC_WARNS ) - q->qi_bwarnlimit = newlim->d_spc_warns; + defq->bwarnlimit = newlim->d_spc_warns;if (newlim->d_fieldmask &QC_INO_WARNS ) - q->qi_iwarnlimit = newlim->d_ino_warns; + defq->iwarnlimit = newlim->d_ino_warns;if (newlim->d_fieldmask &QC_RT_SPC_WARNS ) - q->qi_rtbwarnlimit = newlim->d_rt_spc_warns; + defq->rtbwarnlimit = newlim->d_rt_spc_warns; }else {/* * If the user is now over quota, start the timelimit. fs/xfs/xfs_quotaops.c +11
-11@@ -21,9 +21,9 @@struct qc_type_state *tstate, struct xfs_mount *mp, struct xfs_inode *ip, - xfs_ino_t ino) + xfs_ino_t ino, + struct xfs_def_quota *defq) { - struct xfs_quotainfo *q = mp->m_quotainfo; bool tempqip = false; tstate->ino = ino;@@ -37,12 +37,12 @@ tstate->flags |=QCI_SYSFILE ; tstate->blocks = ip->i_d.di_nblocks; tstate->nextents = ip->i_df.if_nextents; - tstate->spc_timelimit = (u32 )q->qi_btimelimit; - tstate->ino_timelimit = (u32 )q->qi_itimelimit; - tstate->rt_spc_timelimit = (u32 )q->qi_rtbtimelimit; - tstate->spc_warnlimit = q->qi_bwarnlimit; - tstate->ino_warnlimit = q->qi_iwarnlimit; - tstate->rt_spc_warnlimit = q->qi_rtbwarnlimit; + tstate->spc_timelimit = (u32 )defq->btimelimit; + tstate->ino_timelimit = (u32 )defq->itimelimit; + tstate->rt_spc_timelimit = (u32 )defq->rtbtimelimit; + tstate->spc_warnlimit = defq->bwarnlimit; + tstate->ino_warnlimit = defq->iwarnlimit; + tstate->rt_spc_warnlimit = defq->rtbwarnlimit;if (tempqip)xfs_irele (ip); }@@ -77,11 +77,11 @@ state->s_state[PRJQUOTA ].flags |=QCI_LIMITS_ENFORCED ;xfs_qm_fill_state (&state->s_state[USRQUOTA ], mp, q->qi_uquotaip, - mp->m_sb.sb_uquotino); + mp->m_sb.sb_uquotino, &q->qi_usr_default);xfs_qm_fill_state (&state->s_state[GRPQUOTA ], mp, q->qi_gquotaip, - mp->m_sb.sb_gquotino); + mp->m_sb.sb_gquotino, &q->qi_grp_default);xfs_qm_fill_state (&state->s_state[PRJQUOTA ], mp, q->qi_pquotaip, - mp->m_sb.sb_pquotino); + mp->m_sb.sb_pquotino, &q->qi_prj_default);return 0 ; }fs/xfs/xfs_trans_dquot.c +3
-3@@ -602,7 +602,7 @@ softlimit = defq->bsoftlimit; timer =be32_to_cpu (dqp->q_core.d_btimer); warns =be16_to_cpu (dqp->q_core.d_bwarns); - warnlimit = dqp->q_mount->m_quotainfo->qi_bwarnlimit; + warnlimit = defq->bwarnlimit; resbcountp = &dqp->q_res_bcount; }else {ASSERT (flags &XFS_TRANS_DQ_RES_RTBLKS );@@ -614,7 +614,7 @@ softlimit = defq->rtbsoftlimit; timer =be32_to_cpu (dqp->q_core.d_rtbtimer); warns =be16_to_cpu (dqp->q_core.d_rtbwarns); - warnlimit = dqp->q_mount->m_quotainfo->qi_rtbwarnlimit; + warnlimit = defq->rtbwarnlimit; resbcountp = &dqp->q_res_rtbcount; }@@ -650,7 +650,7 @@ total_count =be64_to_cpu (dqp->q_core.d_icount) + ninos; timer =be32_to_cpu (dqp->q_core.d_itimer); warns =be16_to_cpu (dqp->q_core.d_iwarns); - warnlimit = dqp->q_mount->m_quotainfo->qi_iwarnlimit; + warnlimit = defq->iwarnlimit; hardlimit =be64_to_cpu (dqp->q_core.d_ino_hardlimit);if (!hardlimit) hardlimit = defq->ihardlimit;Signature · 1 line
1.8.3.1
PATCH v3 7/7 xfs: allow individual quota grace period extension
In reply to Eric SandeenThe only grace period which can be set in the kernel today is for id 0, i.e. the default grace period for all users. However, setting an individual grace period is useful; for example:
Alice has a soft quota of 100 inodes, and a hard quota of 200 inodes Alice uses 150 inodes, and enters a short grace period Alice really needs to use those 150 inodes past the grace period The administrator extends Alice's grace period until next Monday
vfs quota users such as ext4 can do this today, with setquota -T
To enable this for XFS, we simply move the timelimit assignment out from under the (id == 0) test. Default setting remains under (id == 0). Note that this now is consistent with how we set warnings.
(Userspace requires updates to enable this as well; xfs_quota needs to parse new options, and setquota needs to set appropriate field flags.)
--- fs/xfs/xfs_qm_syscalls.c | 48 ++++++++++++++++++++++++++++-------------------- 1 file changed, 28 insertions(+), 20 deletions(-)
fs/xfs/xfs_qm_syscalls.c +28 -20
@@ -555,32 +555,40 @@ ddq->d_rtbwarns =cpu_to_be16 (newlim->d_rt_spc_warns);if (id ==0 ) { -/* -* Timelimits for the super user set the relative time -* the other users can be over quota for this file system. -* If it is zero a default is used. Ditto for the default -* soft and hard limit values (already done, above), and -* for warnings. -*/ -if (newlim->d_fieldmask &QC_SPC_TIMER ) { - defq->btimelimit = newlim->d_spc_timer; - ddq->d_btimer =cpu_to_be32 (newlim->d_spc_timer); - } -if (newlim->d_fieldmask &QC_INO_TIMER ) { - defq->itimelimit = newlim->d_ino_timer; - ddq->d_itimer =cpu_to_be32 (newlim->d_ino_timer); - } -if (newlim->d_fieldmask &QC_RT_SPC_TIMER ) { - defq->rtbtimelimit = newlim->d_rt_spc_timer; - ddq->d_rtbtimer =cpu_to_be32 (newlim->d_rt_spc_timer); - }if (newlim->d_fieldmask &QC_SPC_WARNS ) defq->bwarnlimit = newlim->d_spc_warns;if (newlim->d_fieldmask &QC_INO_WARNS ) defq->iwarnlimit = newlim->d_ino_warns;if (newlim->d_fieldmask &QC_RT_SPC_WARNS ) defq->rtbwarnlimit = newlim->d_rt_spc_warns; - }else { + } + +/* +* Timelimits for the super user set the relative time the other users +* can be over quota for this file system. If it is zero a default is +* used. Ditto for the default soft and hard limit values (already +* done, above), and for warnings. +* +* For other IDs, userspace can bump out the grace period if over +* the soft limit. +*/ +if (newlim->d_fieldmask &QC_SPC_TIMER ) + ddq->d_btimer =cpu_to_be32 (newlim->d_spc_timer); +if (newlim->d_fieldmask &QC_INO_TIMER ) + ddq->d_itimer =cpu_to_be32 (newlim->d_ino_timer); +if (newlim->d_fieldmask &QC_RT_SPC_TIMER ) + ddq->d_rtbtimer =cpu_to_be32 (newlim->d_rt_spc_timer); + +if (id ==0 ) { +if (newlim->d_fieldmask &QC_SPC_TIMER ) + defq->btimelimit = newlim->d_spc_timer; +if (newlim->d_fieldmask &QC_INO_TIMER ) + defq->itimelimit = newlim->d_ino_timer; +if (newlim->d_fieldmask &QC_RT_SPC_TIMER ) + defq->rtbtimelimit = newlim->d_rt_spc_timer; + } + +if (id !=0 ) {/* * If the user is now over quota, start the timelimit. * The user will not be 'warned'.
Signature · 1 line
1.8.3.1
Re: [PATCH 7/7] xfs: allow individual quota grace period extension
Looks good,