xfs: Split default quota limits by quota type (be607946) · Commits · 戴 / test

fs/xfs/xfs_dquot.c

+14 −12

Original line number	Original line	Diff line number	Diff line
	@@ -92,26 +92,28 @@ xfs_qm_adjust_dqlimits(
	{		{
	struct xfs_quotainfo *q = mp->m_quotainfo;		struct xfs_quotainfo *q = mp->m_quotainfo;
	struct xfs_disk_dquot *d = &dq->q_core;		struct xfs_disk_dquot *d = &dq->q_core;
			struct xfs_def_quota *defq;
	int prealloc = 0;		int prealloc = 0;

	ASSERT(d->d_id);		ASSERT(d->d_id);
			defq = xfs_get_defquota(dq, q);

	if (q->qi_bsoftlimit && !d->d_blk_softlimit) {		if (defq->bsoftlimit && !d->d_blk_softlimit) {
	d->d_blk_softlimit = cpu_to_be64(q->qi_bsoftlimit);		d->d_blk_softlimit = cpu_to_be64(defq->bsoftlimit);
	prealloc = 1;		prealloc = 1;
	}		}
	if (q->qi_bhardlimit && !d->d_blk_hardlimit) {		if (defq->bhardlimit && !d->d_blk_hardlimit) {
	d->d_blk_hardlimit = cpu_to_be64(q->qi_bhardlimit);		d->d_blk_hardlimit = cpu_to_be64(defq->bhardlimit);
	prealloc = 1;		prealloc = 1;
	}		}
	if (q->qi_isoftlimit && !d->d_ino_softlimit)		if (defq->isoftlimit && !d->d_ino_softlimit)
	d->d_ino_softlimit = cpu_to_be64(q->qi_isoftlimit);		d->d_ino_softlimit = cpu_to_be64(defq->isoftlimit);
	if (q->qi_ihardlimit && !d->d_ino_hardlimit)		if (defq->ihardlimit && !d->d_ino_hardlimit)
	d->d_ino_hardlimit = cpu_to_be64(q->qi_ihardlimit);		d->d_ino_hardlimit = cpu_to_be64(defq->ihardlimit);
	if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit)		if (defq->rtbsoftlimit && !d->d_rtb_softlimit)
	d->d_rtb_softlimit = cpu_to_be64(q->qi_rtbsoftlimit);		d->d_rtb_softlimit = cpu_to_be64(defq->rtbsoftlimit);
	if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit)		if (defq->rtbhardlimit && !d->d_rtb_hardlimit)
	d->d_rtb_hardlimit = cpu_to_be64(q->qi_rtbhardlimit);		d->d_rtb_hardlimit = cpu_to_be64(defq->rtbhardlimit);

	if (prealloc)		if (prealloc)
	xfs_dquot_set_prealloc_limits(dq);		xfs_dquot_set_prealloc_limits(dq);

fs/xfs/xfs_qm.c

+43 −12

Original line number	Original line	Diff line number	Diff line
	@@ -560,6 +560,37 @@ xfs_qm_shrink_count(
	return list_lru_shrink_count(&qi->qi_lru, sc);		return list_lru_shrink_count(&qi->qi_lru, sc);
	}		}

			STATIC void
			xfs_qm_set_defquota(
			xfs_mount_t *mp,
			uint type,
			xfs_quotainfo_t *qinf)
			{
			xfs_dquot_t *dqp;
			struct xfs_def_quota *defq;
			int error;

			error = xfs_qm_dqread(mp, 0, type, XFS_QMOPT_DOWARN, &dqp);

			if (!error) {
			xfs_disk_dquot_t *ddqp = &dqp->q_core;

			defq = xfs_get_defquota(dqp, qinf);

			/*
			* Timers and warnings have been already set, let's just set the
			* default limits for this quota type
			*/
			defq->bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
			defq->bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
			defq->ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
			defq->isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
			defq->rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
			defq->rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
			xfs_qm_dqdestroy(dqp);
			}
			}

	/*		/*
	* This initializes all the quota information that's kept in the		* This initializes all the quota information that's kept in the
	* mount structure		* mount structure
	@@ -606,19 +637,19 @@ xfs_qm_init_quotainfo(
	* We try to get the limits from the superuser's limits fields.		* We try to get the limits from the superuser's limits fields.
	* This is quite hacky, but it is standard quota practice.		* This is quite hacky, but it is standard quota practice.
	*		*
	* We look at the USR dquot with id == 0 first, but if user quotas
	* are not enabled we goto the GRP dquot with id == 0.
	* We don't really care to keep separate default limits for user
	* and group quotas, at least not at this point.
	*
	* Since we may not have done a quotacheck by this point, just read		* Since we may not have done a quotacheck by this point, just read
	* the dquot without attaching it to any hashtables or lists.		* 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.
	*/		*/
	error = xfs_qm_dqread(mp, 0,		error = xfs_qm_dqread(mp, 0,
	XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :		XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
	(XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :		(XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
	XFS_DQ_PROJ),		XFS_DQ_PROJ),
	XFS_QMOPT_DOWARN, &dqp);		XFS_QMOPT_DOWARN, &dqp);

	if (!error) {		if (!error) {
	xfs_disk_dquot_t *ddqp = &dqp->q_core;		xfs_disk_dquot_t *ddqp = &dqp->q_core;

	@@ -639,13 +670,6 @@ xfs_qm_init_quotainfo(
	be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;		be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
	qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?		qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
	be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;		be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
	qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
	qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
	qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
	qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
	qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
	qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);

	xfs_qm_dqdestroy(dqp);		xfs_qm_dqdestroy(dqp);
	} else {		} else {
	qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;		qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
	@@ -656,6 +680,13 @@ xfs_qm_init_quotainfo(
	qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;		qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
	}		}

			if (XFS_IS_UQUOTA_RUNNING(mp))
			xfs_qm_set_defquota(mp, XFS_DQ_USER, qinf);
			if (XFS_IS_GQUOTA_RUNNING(mp))
			xfs_qm_set_defquota(mp, XFS_DQ_GROUP, qinf);
			if (XFS_IS_PQUOTA_RUNNING(mp))
			xfs_qm_set_defquota(mp, XFS_DQ_PROJ, qinf);

	qinf->qi_shrinker.count_objects = xfs_qm_shrink_count;		qinf->qi_shrinker.count_objects = xfs_qm_shrink_count;
	qinf->qi_shrinker.scan_objects = xfs_qm_shrink_scan;		qinf->qi_shrinker.scan_objects = xfs_qm_shrink_scan;
	qinf->qi_shrinker.seeks = DEFAULT_SEEKS;		qinf->qi_shrinker.seeks = DEFAULT_SEEKS;

fs/xfs/xfs_qm.h

+28 −6

Original line number	Original line	Diff line number	Diff line
	@@ -53,6 +53,15 @@ extern struct kmem_zone *xfs_qm_dqtrxzone;
	*/		*/
	#define XFS_DQUOT_CLUSTER_SIZE_FSB (xfs_filblks_t)1		#define XFS_DQUOT_CLUSTER_SIZE_FSB (xfs_filblks_t)1

			struct 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 */
			};

	/*		/*
	* Various quota information for individual filesystems.		* Various quota information for individual filesystems.
	* The mount structure keeps a pointer to this.		* The mount structure keeps a pointer to this.
	@@ -76,12 +85,9 @@ typedef struct xfs_quotainfo {
	struct mutex qi_quotaofflock;/* to serialize quotaoff */		struct mutex qi_quotaofflock;/* to serialize quotaoff */
	xfs_filblks_t qi_dqchunklen; /* # BBs in a chunk of dqs */		xfs_filblks_t qi_dqchunklen; /* # BBs in a chunk of dqs */
	uint qi_dqperchunk; /* # ondisk dqs in above chunk */		uint qi_dqperchunk; /* # ondisk dqs in above chunk */
	xfs_qcnt_t qi_bhardlimit; /* default data blk hard limit */		struct xfs_def_quota qi_usr_default;
	xfs_qcnt_t qi_bsoftlimit; /* default data blk soft limit */		struct xfs_def_quota qi_grp_default;
	xfs_qcnt_t qi_ihardlimit; /* default inode count hard limit */		struct xfs_def_quota qi_prj_default;
	xfs_qcnt_t qi_isoftlimit; /* default inode count soft limit */
	xfs_qcnt_t qi_rtbhardlimit;/* default realtime blk hard limit */
	xfs_qcnt_t qi_rtbsoftlimit;/* default realtime blk soft limit */
	struct shrinker qi_shrinker;		struct shrinker qi_shrinker;
	} xfs_quotainfo_t;		} xfs_quotainfo_t;

	@@ -171,4 +177,20 @@ extern int xfs_qm_scall_setqlim(struct xfs_mount *, xfs_dqid_t, uint,
	extern int xfs_qm_scall_quotaon(struct xfs_mount *, uint);		extern int xfs_qm_scall_quotaon(struct xfs_mount *, uint);
	extern int xfs_qm_scall_quotaoff(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)
			{
			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;
			}
			return defq;
			}

	#endif /* __XFS_QM_H__ */		#endif /* __XFS_QM_H__ */

fs/xfs/xfs_qm_syscalls.c

+9 −6

Original line number	Original line	Diff line number	Diff line
	@@ -404,6 +404,7 @@ xfs_qm_scall_setqlim(
	struct xfs_disk_dquot *ddq;		struct xfs_disk_dquot *ddq;
	struct xfs_dquot *dqp;		struct xfs_dquot *dqp;
	struct xfs_trans *tp;		struct xfs_trans *tp;
			struct xfs_def_quota *defq;
	int error;		int error;
	xfs_qcnt_t hard, soft;		xfs_qcnt_t hard, soft;

	@@ -431,6 +432,8 @@ xfs_qm_scall_setqlim(
	ASSERT(error != -ENOENT);		ASSERT(error != -ENOENT);
	goto out_unlock;		goto out_unlock;
	}		}

			defq = xfs_get_defquota(dqp, q);
	xfs_dqunlock(dqp);		xfs_dqunlock(dqp);

	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SETQLIM);		tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SETQLIM);
	@@ -458,8 +461,8 @@ xfs_qm_scall_setqlim(
	ddq->d_blk_softlimit = cpu_to_be64(soft);		ddq->d_blk_softlimit = cpu_to_be64(soft);
	xfs_dquot_set_prealloc_limits(dqp);		xfs_dquot_set_prealloc_limits(dqp);
	if (id == 0) {		if (id == 0) {
	q->qi_bhardlimit = hard;		defq->bhardlimit = hard;
	q->qi_bsoftlimit = soft;		defq->bsoftlimit = soft;
	}		}
	} else {		} else {
	xfs_debug(mp, "blkhard %Ld < blksoft %Ld", hard, soft);		xfs_debug(mp, "blkhard %Ld < blksoft %Ld", hard, soft);
	@@ -474,8 +477,8 @@ xfs_qm_scall_setqlim(
	ddq->d_rtb_hardlimit = cpu_to_be64(hard);		ddq->d_rtb_hardlimit = cpu_to_be64(hard);
	ddq->d_rtb_softlimit = cpu_to_be64(soft);		ddq->d_rtb_softlimit = cpu_to_be64(soft);
	if (id == 0) {		if (id == 0) {
	q->qi_rtbhardlimit = hard;		defq->rtbhardlimit = hard;
	q->qi_rtbsoftlimit = soft;		defq->rtbsoftlimit = soft;
	}		}
	} else {		} else {
	xfs_debug(mp, "rtbhard %Ld < rtbsoft %Ld", hard, soft);		xfs_debug(mp, "rtbhard %Ld < rtbsoft %Ld", hard, soft);
	@@ -491,8 +494,8 @@ xfs_qm_scall_setqlim(
	ddq->d_ino_hardlimit = cpu_to_be64(hard);		ddq->d_ino_hardlimit = cpu_to_be64(hard);
	ddq->d_ino_softlimit = cpu_to_be64(soft);		ddq->d_ino_softlimit = cpu_to_be64(soft);
	if (id == 0) {		if (id == 0) {
	q->qi_ihardlimit = hard;		defq->ihardlimit = hard;
	q->qi_isoftlimit = soft;		defq->isoftlimit = soft;
	}		}
	} else {		} else {
	xfs_debug(mp, "ihard %Ld < isoft %Ld", hard, soft);		xfs_debug(mp, "ihard %Ld < isoft %Ld", hard, soft);

fs/xfs/xfs_trans_dquot.c

+9 −6

Original line number	Original line	Diff line number	Diff line
	@@ -609,17 +609,20 @@ xfs_trans_dqresv(
	xfs_qcnt_t total_count;		xfs_qcnt_t total_count;
	xfs_qcnt_t *resbcountp;		xfs_qcnt_t *resbcountp;
	xfs_quotainfo_t *q = mp->m_quotainfo;		xfs_quotainfo_t *q = mp->m_quotainfo;
			struct xfs_def_quota *defq;


	xfs_dqlock(dqp);		xfs_dqlock(dqp);

			defq = xfs_get_defquota(dqp, q);

	if (flags & XFS_TRANS_DQ_RES_BLKS) {		if (flags & XFS_TRANS_DQ_RES_BLKS) {
	hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit);		hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
	if (!hardlimit)		if (!hardlimit)
	hardlimit = q->qi_bhardlimit;		hardlimit = defq->bhardlimit;
	softlimit = be64_to_cpu(dqp->q_core.d_blk_softlimit);		softlimit = be64_to_cpu(dqp->q_core.d_blk_softlimit);
	if (!softlimit)		if (!softlimit)
	softlimit = q->qi_bsoftlimit;		softlimit = defq->bsoftlimit;
	timer = be32_to_cpu(dqp->q_core.d_btimer);		timer = be32_to_cpu(dqp->q_core.d_btimer);
	warns = be16_to_cpu(dqp->q_core.d_bwarns);		warns = be16_to_cpu(dqp->q_core.d_bwarns);
	warnlimit = dqp->q_mount->m_quotainfo->qi_bwarnlimit;		warnlimit = dqp->q_mount->m_quotainfo->qi_bwarnlimit;
	@@ -628,10 +631,10 @@ xfs_trans_dqresv(
	ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);		ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);
	hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit);		hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit);
	if (!hardlimit)		if (!hardlimit)
	hardlimit = q->qi_rtbhardlimit;		hardlimit = defq->rtbhardlimit;
	softlimit = be64_to_cpu(dqp->q_core.d_rtb_softlimit);		softlimit = be64_to_cpu(dqp->q_core.d_rtb_softlimit);
	if (!softlimit)		if (!softlimit)
	softlimit = q->qi_rtbsoftlimit;		softlimit = defq->rtbsoftlimit;
	timer = be32_to_cpu(dqp->q_core.d_rtbtimer);		timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
	warns = be16_to_cpu(dqp->q_core.d_rtbwarns);		warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
	warnlimit = dqp->q_mount->m_quotainfo->qi_rtbwarnlimit;		warnlimit = dqp->q_mount->m_quotainfo->qi_rtbwarnlimit;
	@@ -672,10 +675,10 @@ xfs_trans_dqresv(
	warnlimit = dqp->q_mount->m_quotainfo->qi_iwarnlimit;		warnlimit = dqp->q_mount->m_quotainfo->qi_iwarnlimit;
	hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);		hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);
	if (!hardlimit)		if (!hardlimit)
	hardlimit = q->qi_ihardlimit;		hardlimit = defq->ihardlimit;
	softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);		softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);
	if (!softlimit)		if (!softlimit)
	softlimit = q->qi_isoftlimit;		softlimit = defq->isoftlimit;

	if (hardlimit && total_count > hardlimit) {		if (hardlimit && total_count > hardlimit) {
	xfs_quota_warn(mp, dqp, QUOTA_NL_IHARDWARN);		xfs_quota_warn(mp, dqp, QUOTA_NL_IHARDWARN);

Admin message