Commit 83e782e1 authored by Chandra Seetharaman's avatar Chandra Seetharaman Committed by Ben Myers
Browse files

xfs: Remove incore use of XFS_OQUOTA_ENFD and XFS_OQUOTA_CHKD 



Remove all incore use of XFS_OQUOTA_ENFD and XFS_OQUOTA_CHKD. Instead,
start using XFS_GQUOTA_.* XFS_PQUOTA_.* counterparts for GQUOTA and
PQUOTA respectively.

On-disk copy still uses XFS_OQUOTA_ENFD and XFS_OQUOTA_CHKD.

Read and write of the superblock does the conversion from *OQUOTA*
to *[PG]QUOTA*.

Signed-off-by: default avatarChandra Seetharaman <sekharan@us.ibm.com>
Reviewed-by: default avatarBen Myers <bpm@sgi.com>
Signed-off-by: default avatarBen Myers <bpm@sgi.com>
parent 0e6436d9

fs/xfs/xfs_mount.c

+51 −0
Original line number Diff line number Diff line
@@ -336,6 +336,14 @@ xfs_mount_validate_sb( 
		return XFS_ERROR(EWRONGFS);

	}



	if ((sbp->sb_qflags & (XFS_OQUOTA_ENFD | XFS_OQUOTA_CHKD)) &&

			(sbp->sb_qflags & (XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD |

				XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD))) {

		xfs_notice(mp,

"Super block has XFS_OQUOTA bits along with XFS_PQUOTA and/or XFS_GQUOTA bits.\n");

		return XFS_ERROR(EFSCORRUPTED);

	}



	/*

	 * Version 5 superblock feature mask validation. Reject combinations the

	 * kernel cannot support up front before checking anything else. For
@@ -561,6 +569,18 @@ out_unwind: 
	return error;

}



static void

xfs_sb_quota_from_disk(struct xfs_sb *sbp)

{

	if (sbp->sb_qflags & XFS_OQUOTA_ENFD)

		sbp->sb_qflags |= (sbp->sb_qflags & XFS_PQUOTA_ACCT) ?

					XFS_PQUOTA_ENFD : XFS_GQUOTA_ENFD;

	if (sbp->sb_qflags & XFS_OQUOTA_CHKD)

		sbp->sb_qflags |= (sbp->sb_qflags & XFS_PQUOTA_ACCT) ?

					XFS_PQUOTA_CHKD : XFS_GQUOTA_CHKD;

	sbp->sb_qflags &= ~(XFS_OQUOTA_ENFD | XFS_OQUOTA_CHKD);

}



void

xfs_sb_from_disk(

	struct xfs_sb	*to,
@@ -622,6 +642,35 @@ xfs_sb_from_disk( 
	to->sb_lsn = be64_to_cpu(from->sb_lsn);

}



static inline void

xfs_sb_quota_to_disk(

	xfs_dsb_t	*to,

	xfs_sb_t	*from,

	__int64_t	*fields)

{

	__uint16_t	qflags = from->sb_qflags;



	if (*fields & XFS_SB_QFLAGS) {

		/*

		 * The in-core version of sb_qflags do not have

		 * XFS_OQUOTA_* flags, whereas the on-disk version

		 * does.  So, convert incore XFS_{PG}QUOTA_* flags

		 * to on-disk XFS_OQUOTA_* flags.

		 */

		qflags &= ~(XFS_PQUOTA_ENFD | XFS_PQUOTA_CHKD |

				XFS_GQUOTA_ENFD | XFS_GQUOTA_CHKD);



		if (from->sb_qflags &

				(XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD))

			qflags |= XFS_OQUOTA_ENFD;

		if (from->sb_qflags &

				(XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD))

			qflags |= XFS_OQUOTA_CHKD;

		to->sb_qflags = cpu_to_be16(qflags);

		*fields &= ~XFS_SB_QFLAGS;

	}

}



/*

 * Copy in core superblock to ondisk one.

 *
@@ -643,6 +692,7 @@ xfs_sb_to_disk( 
	if (!fields)

		return;



	xfs_sb_quota_to_disk(to, from, &fields);

	while (fields) {

		f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields);

		first = xfs_sb_info[f].offset;
@@ -835,6 +885,7 @@ reread: 
	 */

	xfs_sb_from_disk(&mp->m_sb, XFS_BUF_TO_SBP(bp));



	xfs_sb_quota_from_disk(&mp->m_sb);

	/*

	 * We must be able to do sector-sized and sector-aligned IO.

	 */

fs/xfs/xfs_qm.c

+6 −3
Original line number Diff line number Diff line
@@ -299,8 +299,10 @@ xfs_qm_mount_quotas( 
	 */

	if (!XFS_IS_UQUOTA_ON(mp))

		mp->m_qflags &= ~XFS_UQUOTA_CHKD;

	if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))

		mp->m_qflags &= ~XFS_OQUOTA_CHKD;

	if (!XFS_IS_GQUOTA_ON(mp))

		mp->m_qflags &= ~XFS_GQUOTA_CHKD;

	if (!XFS_IS_PQUOTA_ON(mp))

		mp->m_qflags &= ~XFS_PQUOTA_CHKD;



 write_changes:

	/*
@@ -1297,7 +1299,8 @@ xfs_qm_quotacheck( 
					 &buffer_list);

		if (error)

			goto error_return;

		flags |= XFS_OQUOTA_CHKD;

		flags |= XFS_IS_GQUOTA_ON(mp) ?

					XFS_GQUOTA_CHKD : XFS_PQUOTA_CHKD;

	}



	do {

fs/xfs/xfs_qm_syscalls.c

+23 −20
Original line number Diff line number Diff line
@@ -117,11 +117,11 @@ xfs_qm_scall_quotaoff( 
	}

	if (flags & XFS_GQUOTA_ACCT) {

		dqtype |= XFS_QMOPT_GQUOTA;

		flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);

		flags |= (XFS_GQUOTA_CHKD | XFS_GQUOTA_ENFD);

		inactivate_flags |= XFS_GQUOTA_ACTIVE;

	} else if (flags & XFS_PQUOTA_ACCT) {

		dqtype |= XFS_QMOPT_PQUOTA;

		flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);

		flags |= (XFS_PQUOTA_CHKD | XFS_PQUOTA_ENFD);

		inactivate_flags |= XFS_PQUOTA_ACTIVE;

	}
@@ -336,13 +336,13 @@ xfs_qm_scall_quotaon( 
	 */

	if (((flags & XFS_UQUOTA_ACCT) == 0 &&

	     (mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 &&

	    (flags & XFS_UQUOTA_ENFD))

	    ||

	     (flags & XFS_UQUOTA_ENFD)) ||

	    ((flags & XFS_GQUOTA_ACCT) == 0 &&

	     (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&

	     (flags & XFS_GQUOTA_ENFD)) ||

	    ((flags & XFS_PQUOTA_ACCT) == 0 &&

	     (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&

	    (flags & XFS_GQUOTA_ACCT) == 0 &&

	    (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&

	    (flags & XFS_OQUOTA_ENFD))) {

	     (flags & XFS_PQUOTA_ENFD))) {

		xfs_debug(mp,

			"%s: Can't enforce without acct, flags=%x sbflags=%x\n",

			__func__, flags, mp->m_sb.sb_qflags);
@@ -776,9 +776,12 @@ xfs_qm_scall_getquota( 
	 * gets turned off. No need to confuse the user level code,

	 * so return zeroes in that case.

	 */

	if ((!XFS_IS_UQUOTA_ENFORCED(mp) && dqp->q_core.d_flags == XFS_DQ_USER) ||

	    (!XFS_IS_OQUOTA_ENFORCED(mp) &&

			(dqp->q_core.d_flags & (XFS_DQ_PROJ | XFS_DQ_GROUP)))) {

	if ((!XFS_IS_UQUOTA_ENFORCED(mp) &&

	     dqp->q_core.d_flags == XFS_DQ_USER) ||

	    (!XFS_IS_GQUOTA_ENFORCED(mp) &&

	     dqp->q_core.d_flags == XFS_DQ_GROUP) ||

	    (!XFS_IS_PQUOTA_ENFORCED(mp) &&

	     dqp->q_core.d_flags == XFS_DQ_PROJ)) {

		dst->d_btimer = 0;

		dst->d_itimer = 0;

		dst->d_rtbtimer = 0;
@@ -786,8 +789,8 @@ xfs_qm_scall_getquota( 


#ifdef DEBUG

	if (((XFS_IS_UQUOTA_ENFORCED(mp) && dst->d_flags == FS_USER_QUOTA) ||

	     (XFS_IS_OQUOTA_ENFORCED(mp) &&

			(dst->d_flags & (FS_PROJ_QUOTA | FS_GROUP_QUOTA)))) &&

	     (XFS_IS_GQUOTA_ENFORCED(mp) && dst->d_flags == FS_GROUP_QUOTA) ||

	     (XFS_IS_PQUOTA_ENFORCED(mp) && dst->d_flags == FS_PROJ_QUOTA)) &&

	    dst->d_id != 0) {

		if ((dst->d_bcount > dst->d_blk_softlimit) &&

		    (dst->d_blk_softlimit > 0)) {
@@ -833,16 +836,16 @@ xfs_qm_export_flags( 
	uflags = 0;

	if (flags & XFS_UQUOTA_ACCT)

		uflags |= FS_QUOTA_UDQ_ACCT;

	if (flags & XFS_PQUOTA_ACCT)

		uflags |= FS_QUOTA_PDQ_ACCT;

	if (flags & XFS_GQUOTA_ACCT)

		uflags |= FS_QUOTA_GDQ_ACCT;

	if (flags & XFS_PQUOTA_ACCT)

		uflags |= FS_QUOTA_PDQ_ACCT;

	if (flags & XFS_UQUOTA_ENFD)

		uflags |= FS_QUOTA_UDQ_ENFD;

	if (flags & (XFS_OQUOTA_ENFD)) {

		uflags |= (flags & XFS_GQUOTA_ACCT) ?

			FS_QUOTA_GDQ_ENFD : FS_QUOTA_PDQ_ENFD;

	}

	if (flags & XFS_GQUOTA_ENFD)

		uflags |= FS_QUOTA_GDQ_ENFD;

	if (flags & XFS_PQUOTA_ENFD)

		uflags |= FS_QUOTA_PDQ_ENFD;

	return (uflags);

}

fs/xfs/xfs_quota.h

+29 −18
Original line number Diff line number Diff line
@@ -160,31 +160,43 @@ typedef struct xfs_qoff_logformat { 
#define XFS_OQUOTA_CHKD	0x0020  /* quotacheck run on other (grp/prj) quotas */

#define XFS_GQUOTA_ACCT	0x0040  /* group quota accounting ON */



/*

 * Conversion to and from the combined OQUOTA flag (if necessary)

 * is done only in xfs_sb_qflags_to_disk() and xfs_sb_qflags_from_disk()

 */

#define XFS_GQUOTA_ENFD	0x0080  /* group quota limits enforced */

#define XFS_GQUOTA_CHKD	0x0100  /* quotacheck run on group quotas */

#define XFS_PQUOTA_ENFD	0x0200  /* project quota limits enforced */

#define XFS_PQUOTA_CHKD	0x0400  /* quotacheck run on project quotas */



/*

 * Quota Accounting/Enforcement flags

 */

#define XFS_ALL_QUOTA_ACCT	\

		(XFS_UQUOTA_ACCT | XFS_GQUOTA_ACCT | XFS_PQUOTA_ACCT)

#define XFS_ALL_QUOTA_ENFD	(XFS_UQUOTA_ENFD | XFS_OQUOTA_ENFD)

#define XFS_ALL_QUOTA_CHKD	(XFS_UQUOTA_CHKD | XFS_OQUOTA_CHKD)

#define XFS_ALL_QUOTA_ENFD	\

		(XFS_UQUOTA_ENFD | XFS_GQUOTA_ENFD | XFS_PQUOTA_ENFD)

#define XFS_ALL_QUOTA_CHKD	\

		(XFS_UQUOTA_CHKD | XFS_GQUOTA_CHKD | XFS_PQUOTA_CHKD)



#define XFS_IS_QUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_ALL_QUOTA_ACCT)

#define XFS_IS_UQUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_UQUOTA_ACCT)

#define XFS_IS_PQUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_PQUOTA_ACCT)

#define XFS_IS_GQUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_GQUOTA_ACCT)

#define XFS_IS_UQUOTA_ENFORCED(mp)	((mp)->m_qflags & XFS_UQUOTA_ENFD)

#define XFS_IS_OQUOTA_ENFORCED(mp)	((mp)->m_qflags & XFS_OQUOTA_ENFD)

#define XFS_IS_GQUOTA_ENFORCED(mp)	((mp)->m_qflags & XFS_GQUOTA_ENFD)

#define XFS_IS_PQUOTA_ENFORCED(mp)	((mp)->m_qflags & XFS_PQUOTA_ENFD)



/*

 * Incore only flags for quotaoff - these bits get cleared when quota(s)

 * are in the process of getting turned off. These flags are in m_qflags but

 * never in sb_qflags.

 */

#define XFS_UQUOTA_ACTIVE	0x0100  /* uquotas are being turned off */

#define XFS_PQUOTA_ACTIVE	0x0200  /* pquotas are being turned off */

#define XFS_GQUOTA_ACTIVE	0x0400  /* gquotas are being turned off */

#define XFS_UQUOTA_ACTIVE	0x1000  /* uquotas are being turned off */

#define XFS_GQUOTA_ACTIVE	0x2000  /* gquotas are being turned off */

#define XFS_PQUOTA_ACTIVE	0x4000  /* pquotas are being turned off */

#define XFS_ALL_QUOTA_ACTIVE	\

	(XFS_UQUOTA_ACTIVE | XFS_PQUOTA_ACTIVE | XFS_GQUOTA_ACTIVE)

	(XFS_UQUOTA_ACTIVE | XFS_GQUOTA_ACTIVE | XFS_PQUOTA_ACTIVE)



/*

 * Checking XFS_IS_*QUOTA_ON() while holding any inode lock guarantees
@@ -268,24 +280,23 @@ typedef struct xfs_qoff_logformat { 
	((XFS_IS_UQUOTA_ON(mp) && \

		(mp->m_sb.sb_qflags & XFS_UQUOTA_CHKD) == 0) || \

	 (XFS_IS_GQUOTA_ON(mp) && \

		((mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD) == 0 || \

		 (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT))) || \

		(mp->m_sb.sb_qflags & XFS_GQUOTA_CHKD) == 0) || \

	 (XFS_IS_PQUOTA_ON(mp) && \

		((mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD) == 0 || \

		 (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT))))

		(mp->m_sb.sb_qflags & XFS_PQUOTA_CHKD) == 0))



#define XFS_MOUNT_QUOTA_SET1	(XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\

				 XFS_UQUOTA_CHKD|XFS_PQUOTA_ACCT|\

				 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD)

				 XFS_UQUOTA_CHKD|XFS_GQUOTA_ACCT|\

				 XFS_GQUOTA_ENFD|XFS_GQUOTA_CHKD)



#define XFS_MOUNT_QUOTA_SET2	(XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\

				 XFS_UQUOTA_CHKD|XFS_GQUOTA_ACCT|\

				 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD)

				 XFS_UQUOTA_CHKD|XFS_PQUOTA_ACCT|\

				 XFS_PQUOTA_ENFD|XFS_PQUOTA_CHKD)



#define XFS_MOUNT_QUOTA_ALL	(XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\

				 XFS_UQUOTA_CHKD|XFS_PQUOTA_ACCT|\

				 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD|\

				 XFS_GQUOTA_ACCT)

				 XFS_UQUOTA_CHKD|XFS_GQUOTA_ACCT|\

				 XFS_GQUOTA_ENFD|XFS_GQUOTA_CHKD|\

				 XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD|\

				 XFS_PQUOTA_CHKD)





/*

fs/xfs/xfs_quotaops.c

+4 −2
Original line number Diff line number Diff line
@@ -75,8 +75,10 @@ xfs_fs_set_xstate( 
		flags |= XFS_GQUOTA_ACCT;

	if (uflags & FS_QUOTA_UDQ_ENFD)

		flags |= XFS_UQUOTA_ENFD;

	if (uflags & (FS_QUOTA_PDQ_ENFD|FS_QUOTA_GDQ_ENFD))

		flags |= XFS_OQUOTA_ENFD;

	if (uflags & FS_QUOTA_GDQ_ENFD)

		flags |= XFS_GQUOTA_ENFD;

	if (uflags & FS_QUOTA_PDQ_ENFD)

		flags |= XFS_PQUOTA_ENFD;



	switch (op) {

	case Q_XQUOTAON:

CRA Git | Maintained and supported by SUSTech CRA and CCSE