Commit 2d53f66b authored by Darrick J. Wong's avatar Darrick J. Wong
Browse files

xfs: change the prefix of XFS_EOF_FLAGS_* to XFS_ICWALK_FLAG_ 



In preparation for renaming struct xfs_eofblocks to struct xfs_icwalk,
change the prefix of the existing XFS_EOF_FLAGS_* flags to
XFS_ICWALK_FLAG_ and convert all the existing users.  This adds a degree
of interface separation between the ioctl definitions and the incore
parameters.  Since FLAGS_UNION is only used in xfs_icache.c, move it
there as a private flag.

Signed-off-by: default avatarDarrick J. Wong <djwong@kernel.org>
Reviewed-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarCarlos Maiolino <cmaiolino@redhat.com>
parent 9492750a

fs/xfs/xfs_file.c

+2 −2
Original line number Diff line number Diff line
@@ -769,7 +769,7 @@ xfs_file_buffered_write( 
	 */

	if (ret == -EDQUOT && !cleared_space) {

		xfs_iunlock(ip, iolock);

		xfs_blockgc_free_quota(ip, XFS_EOF_FLAGS_SYNC);

		xfs_blockgc_free_quota(ip, XFS_ICWALK_FLAG_SYNC);

		cleared_space = true;

		goto write_retry;

	} else if (ret == -ENOSPC && !cleared_space) {
@@ -779,7 +779,7 @@ xfs_file_buffered_write( 
		xfs_flush_inodes(ip->i_mount);



		xfs_iunlock(ip, iolock);

		eofb.eof_flags = XFS_EOF_FLAGS_SYNC;

		eofb.eof_flags = XFS_ICWALK_FLAG_SYNC;

		xfs_blockgc_free_space(ip->i_mount, &eofb);

		goto write_retry;

	}

fs/xfs/xfs_icache.c

+23 −21
Original line number Diff line number Diff line
@@ -62,7 +62,7 @@ static int xfs_icwalk_ag(struct xfs_perag *pag, 


/*

 * Private inode cache walk flags for struct xfs_eofblocks.  Must not coincide

 * with XFS_EOF_FLAGS_*.

 * with XFS_ICWALK_FLAGS_VALID.

 */

#define XFS_ICWALK_FLAG_DROP_UDQUOT	(1U << 31)

#define XFS_ICWALK_FLAG_DROP_GDQUOT	(1U << 30)
@@ -72,12 +72,14 @@ static int xfs_icwalk_ag(struct xfs_perag *pag, 
#define XFS_ICWALK_FLAG_SCAN_LIMIT	(1U << 28)



#define XFS_ICWALK_FLAG_RECLAIM_SICK	(1U << 27)

#define XFS_ICWALK_FLAG_UNION		(1U << 26) /* union filter algorithm */



#define XFS_ICWALK_PRIVATE_FLAGS	(XFS_ICWALK_FLAG_DROP_UDQUOT | \

					 XFS_ICWALK_FLAG_DROP_GDQUOT | \

					 XFS_ICWALK_FLAG_DROP_PDQUOT | \

					 XFS_ICWALK_FLAG_SCAN_LIMIT | \

					 XFS_ICWALK_FLAG_RECLAIM_SICK)

					 XFS_ICWALK_FLAG_RECLAIM_SICK | \

					 XFS_ICWALK_FLAG_UNION)



/*

 * Allocate and initialise an xfs_inode.
@@ -1113,15 +1115,15 @@ xfs_inode_match_id( 
	struct xfs_inode	*ip,

	struct xfs_eofblocks	*eofb)

{

	if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&

	if ((eofb->eof_flags & XFS_ICWALK_FLAG_UID) &&

	    !uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))

		return false;



	if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&

	if ((eofb->eof_flags & XFS_ICWALK_FLAG_GID) &&

	    !gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))

		return false;



	if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&

	if ((eofb->eof_flags & XFS_ICWALK_FLAG_PRID) &&

	    ip->i_projid != eofb->eof_prid)

		return false;
@@ -1137,15 +1139,15 @@ xfs_inode_match_id_union( 
	struct xfs_inode	*ip,

	struct xfs_eofblocks	*eofb)

{

	if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&

	if ((eofb->eof_flags & XFS_ICWALK_FLAG_UID) &&

	    uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))

		return true;



	if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&

	if ((eofb->eof_flags & XFS_ICWALK_FLAG_GID) &&

	    gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))

		return true;



	if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&

	if ((eofb->eof_flags & XFS_ICWALK_FLAG_PRID) &&

	    ip->i_projid == eofb->eof_prid)

		return true;
@@ -1167,7 +1169,7 @@ xfs_inode_matches_eofb( 
	if (!eofb)

		return true;



	if (eofb->eof_flags & XFS_EOF_FLAGS_UNION)

	if (eofb->eof_flags & XFS_ICWALK_FLAG_UNION)

		match = xfs_inode_match_id_union(ip, eofb);

	else

		match = xfs_inode_match_id(ip, eofb);
@@ -1175,7 +1177,7 @@ xfs_inode_matches_eofb( 
		return false;



	/* skip the inode if the file size is too small */

	if ((eofb->eof_flags & XFS_EOF_FLAGS_MINFILESIZE) &&

	if ((eofb->eof_flags & XFS_ICWALK_FLAG_MINFILESIZE) &&

	    XFS_ISIZE(ip) < eofb->eof_min_file_size)

		return false;
@@ -1207,7 +1209,7 @@ xfs_inode_free_eofblocks( 
{

	bool			wait;



	wait = eofb && (eofb->eof_flags & XFS_EOF_FLAGS_SYNC);

	wait = eofb && (eofb->eof_flags & XFS_ICWALK_FLAG_SYNC);



	if (!xfs_iflags_test(ip, XFS_IEOFBLOCKS))

		return 0;
@@ -1370,7 +1372,7 @@ xfs_inode_free_cowblocks( 
	bool			wait;

	int			ret = 0;



	wait = eofb && (eofb->eof_flags & XFS_EOF_FLAGS_SYNC);

	wait = eofb && (eofb->eof_flags & XFS_ICWALK_FLAG_SYNC);



	if (!xfs_iflags_test(ip, XFS_ICOWBLOCKS))

		return 0;
@@ -1552,7 +1554,7 @@ xfs_blockgc_free_space( 
 * scan.

 *

 * Callers must not hold any inode's ILOCK.  If requesting a synchronous scan

 * (XFS_EOF_FLAGS_SYNC), the caller also must not hold any inode's IOLOCK or

 * (XFS_ICWALK_FLAG_SYNC), the caller also must not hold any inode's IOLOCK or

 * MMAPLOCK.

 */

int
@@ -1561,7 +1563,7 @@ xfs_blockgc_free_dquots( 
	struct xfs_dquot	*udqp,

	struct xfs_dquot	*gdqp,

	struct xfs_dquot	*pdqp,

	unsigned int		eof_flags)

	unsigned int		iwalk_flags)

{

	struct xfs_eofblocks	eofb = {0};

	bool			do_work = false;
@@ -1573,23 +1575,23 @@ xfs_blockgc_free_dquots( 
	 * Run a scan to free blocks using the union filter to cover all

	 * applicable quotas in a single scan.

	 */

	eofb.eof_flags = XFS_EOF_FLAGS_UNION | eof_flags;

	eofb.eof_flags = XFS_ICWALK_FLAG_UNION | iwalk_flags;



	if (XFS_IS_UQUOTA_ENFORCED(mp) && udqp && xfs_dquot_lowsp(udqp)) {

		eofb.eof_uid = make_kuid(mp->m_super->s_user_ns, udqp->q_id);

		eofb.eof_flags |= XFS_EOF_FLAGS_UID;

		eofb.eof_flags |= XFS_ICWALK_FLAG_UID;

		do_work = true;

	}



	if (XFS_IS_UQUOTA_ENFORCED(mp) && gdqp && xfs_dquot_lowsp(gdqp)) {

		eofb.eof_gid = make_kgid(mp->m_super->s_user_ns, gdqp->q_id);

		eofb.eof_flags |= XFS_EOF_FLAGS_GID;

		eofb.eof_flags |= XFS_ICWALK_FLAG_GID;

		do_work = true;

	}



	if (XFS_IS_PQUOTA_ENFORCED(mp) && pdqp && xfs_dquot_lowsp(pdqp)) {

		eofb.eof_prid = pdqp->q_id;

		eofb.eof_flags |= XFS_EOF_FLAGS_PRID;

		eofb.eof_flags |= XFS_ICWALK_FLAG_PRID;

		do_work = true;

	}
@@ -1603,12 +1605,12 @@ xfs_blockgc_free_dquots( 
int

xfs_blockgc_free_quota(

	struct xfs_inode	*ip,

	unsigned int		eof_flags)

	unsigned int		iwalk_flags)

{

	return xfs_blockgc_free_dquots(ip->i_mount,

			xfs_inode_dquot(ip, XFS_DQTYPE_USER),

			xfs_inode_dquot(ip, XFS_DQTYPE_GROUP),

			xfs_inode_dquot(ip, XFS_DQTYPE_PROJ), eof_flags);

			xfs_inode_dquot(ip, XFS_DQTYPE_PROJ), iwalk_flags);

}



/* XFS Inode Cache Walking Code */
@@ -1828,5 +1830,5 @@ xfs_icwalk( 
		}

	}

	return last_error;

	BUILD_BUG_ON(XFS_ICWALK_PRIVATE_FLAGS & XFS_EOF_FLAGS_VALID);

	BUILD_BUG_ON(XFS_ICWALK_PRIVATE_FLAGS & XFS_ICWALK_FLAGS_VALID);

}

fs/xfs/xfs_icache.h

+15 −2
Original line number Diff line number Diff line
@@ -18,6 +18,19 @@ struct xfs_eofblocks { 
	int		icw_scan_limit;

};



/* Flags that reflect xfs_fs_eofblocks functionality. */

#define XFS_ICWALK_FLAG_SYNC		(1U << 0) /* sync/wait mode scan */

#define XFS_ICWALK_FLAG_UID		(1U << 1) /* filter by uid */

#define XFS_ICWALK_FLAG_GID		(1U << 2) /* filter by gid */

#define XFS_ICWALK_FLAG_PRID		(1U << 3) /* filter by project id */

#define XFS_ICWALK_FLAG_MINFILESIZE	(1U << 4) /* filter by min file size */



#define XFS_ICWALK_FLAGS_VALID		(XFS_ICWALK_FLAG_SYNC | \

					 XFS_ICWALK_FLAG_UID | \

					 XFS_ICWALK_FLAG_GID | \

					 XFS_ICWALK_FLAG_PRID | \

					 XFS_ICWALK_FLAG_MINFILESIZE)



/*

 * Flags for xfs_iget()

 */
@@ -43,8 +56,8 @@ void xfs_inode_mark_reclaimable(struct xfs_inode *ip); 


int xfs_blockgc_free_dquots(struct xfs_mount *mp, struct xfs_dquot *udqp,

		struct xfs_dquot *gdqp, struct xfs_dquot *pdqp,

		unsigned int eof_flags);

int xfs_blockgc_free_quota(struct xfs_inode *ip, unsigned int eof_flags);

		unsigned int iwalk_flags);

int xfs_blockgc_free_quota(struct xfs_inode *ip, unsigned int iwalk_flags);

int xfs_blockgc_free_space(struct xfs_mount *mp, struct xfs_eofblocks *eofb);



void xfs_inode_set_eofblocks_tag(struct xfs_inode *ip);

fs/xfs/xfs_ioctl.c

+12 −1
Original line number Diff line number Diff line
@@ -1887,7 +1887,18 @@ xfs_fs_eofblocks_from_user( 
	    memchr_inv(src->pad64, 0, sizeof(src->pad64)))

		return -EINVAL;



	dst->eof_flags = src->eof_flags;

	dst->eof_flags = 0;

	if (src->eof_flags & XFS_EOF_FLAGS_SYNC)

		dst->eof_flags |= XFS_ICWALK_FLAG_SYNC;

	if (src->eof_flags & XFS_EOF_FLAGS_UID)

		dst->eof_flags |= XFS_ICWALK_FLAG_UID;

	if (src->eof_flags & XFS_EOF_FLAGS_GID)

		dst->eof_flags |= XFS_ICWALK_FLAG_GID;

	if (src->eof_flags & XFS_EOF_FLAGS_PRID)

		dst->eof_flags |= XFS_ICWALK_FLAG_PRID;

	if (src->eof_flags & XFS_EOF_FLAGS_MINFILESIZE)

		dst->eof_flags |= XFS_ICWALK_FLAG_MINFILESIZE;



	dst->eof_prid = src->eof_prid;

	dst->eof_min_file_size = src->eof_min_file_size;