[XFS] Traverse inode trees when releasing dquots

/*

 * Go thru all the inodes in the file system, releasing their dquots.

 * Note that the mount structure gets modified to indicate that quotas are off

 * AFTER this, in the case of quotaoff. This also gets called from

 * xfs_rootumount.

 * Release all the dquots on the inodes in an AG.

 */

void

xfs_qm_dqrele_all_inodes(

	struct xfs_mount *mp,

STATIC void

xfs_qm_dqrele_inodes_ag(

	xfs_mount_t	*mp,

	int		ag,

	uint		flags)

{

	xfs_inode_t	*ip, *topino;

	uint		ireclaims;

	struct inode	*vp;

	boolean_t	vnode_refd;

	ASSERT(mp->m_quotainfo);

	xfs_inode_t	*ip = NULL;

	struct inode	*vp = NULL;

	xfs_perag_t	*pag = &mp->m_perag[ag];

	int		first_index = 0;

	int		nr_found;

	XFS_MOUNT_ILOCK(mp);

again:

	ip = mp->m_inodes;

	if (ip == NULL) {

		XFS_MOUNT_IUNLOCK(mp);

		return;

	}

	do {

		/* Skip markers inserted by xfs_sync */

		if (ip->i_mount == NULL) {

			ip = ip->i_mnext;

			continue;

		}

		/* Root inode, rbmip and rsumip have associated blocks */

		if (ip == XFS_QI_UQIP(mp) || ip == XFS_QI_GQIP(mp)) {

			ASSERT(ip->i_udquot == NULL);

			ASSERT(ip->i_gdquot == NULL);

			ip = ip->i_mnext;

			continue;

		boolean_t	vnode_refd = B_FALSE;

		/*

		 * use a gang lookup to find the next inode in the tree

		 * as the tree is sparse and a gang lookup walks to find

		 * the number of objects requested.

		 */

		read_lock(&pag->pag_ici_lock);

		nr_found = radix_tree_gang_lookup(&pag->pag_ici_root,

				(void**)&ip, first_index, 1);

		if (!nr_found) {

			read_unlock(&pag->pag_ici_lock);

			break;

		}

		/* update the index for the next lookup */

		first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1);

		/* skip quota inodes and those in reclaim */

		vp = VFS_I(ip);

		if (!vp) {

		if (!vp || ip == XFS_QI_UQIP(mp) || ip == XFS_QI_GQIP(mp)) {

			ASSERT(ip->i_udquot == NULL);

			ASSERT(ip->i_gdquot == NULL);

			ip = ip->i_mnext;

			read_unlock(&pag->pag_ici_lock);

			continue;

		}

		vnode_refd = B_FALSE;

		if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL) == 0) {

			ireclaims = mp->m_ireclaims;

			topino = mp->m_inodes;

			vp = vn_grab(vp);

			read_unlock(&pag->pag_ici_lock);

			if (!vp)

				goto again;

			XFS_MOUNT_IUNLOCK(mp);

			/* XXX restart limit ? */

			xfs_ilock(ip, XFS_ILOCK_EXCL);

				continue;

			vnode_refd = B_TRUE;

			xfs_ilock(ip, XFS_ILOCK_EXCL);

		} else {

			ireclaims = mp->m_ireclaims;

			topino = mp->m_inodes;

			XFS_MOUNT_IUNLOCK(mp);

			read_unlock(&pag->pag_ici_lock);

		}

		/*

		 * We don't keep the mountlock across the dqrele() call,

		 * since it can take a while..

		 */

		if ((flags & XFS_UQUOTA_ACCT) && ip->i_udquot) {

			xfs_qm_dqrele(ip->i_udquot);

			ip->i_udquot = NULL;

		}

		if (flags & (XFS_PQUOTA_ACCT|XFS_GQUOTA_ACCT) && ip->i_gdquot) {

		if (flags & (XFS_PQUOTA_ACCT|XFS_GQUOTA_ACCT) &&

		    ip->i_gdquot) {

			xfs_qm_dqrele(ip->i_gdquot);

			ip->i_gdquot = NULL;

		}

		xfs_iunlock(ip, XFS_ILOCK_EXCL);

		/*

		 * Wait until we've dropped the ilock and mountlock to

		 * do the vn_rele. Or be condemned to an eternity in the

		 * inactive code in hell.

		 */

		if (vnode_refd)

			IRELE(ip);

		XFS_MOUNT_ILOCK(mp);

	} while (nr_found);

}

/*

		 * If an inode was inserted or removed, we gotta

		 * start over again.

 * Go thru all the inodes in the file system, releasing their dquots.

 * Note that the mount structure gets modified to indicate that quotas are off

 * AFTER this, in the case of quotaoff. This also gets called from

 * xfs_rootumount.

 */

		if (topino != mp->m_inodes || mp->m_ireclaims != ireclaims) {

			/* XXX use a sentinel */

			goto again;

		}

		ip = ip->i_mnext;

	} while (ip != mp->m_inodes);

void

xfs_qm_dqrele_all_inodes(

	struct xfs_mount *mp,

	uint		 flags)

{

	int		i;

	XFS_MOUNT_IUNLOCK(mp);

	ASSERT(mp->m_quotainfo);

	for (i = 0; i < mp->m_sb.sb_agcount; i++) {

		if (!mp->m_perag[i].pag_ici_init)

			continue;

		xfs_qm_dqrele_inodes_ag(mp, i, flags);

	}

}

/*------------------------------------------------------------------------*/