Commit 5806165a authored by Dave Chinner's avatar Dave Chinner Committed by Darrick J. Wong
Browse files

xfs: factor inode lookup from xfs_ifree_cluster 



There's lots of indent in this code which makes it a bit hard to
follow. We are also going to completely rework the inode lookup code
as part of the inode reclaim rework, so factor out the inode lookup
code from the inode cluster freeing code.

Based on prototype code from Christoph Hellwig.

Signed-off-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarBrian Foster <bfoster@redhat.com>
Reviewed-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
parent 8eb807bd

fs/xfs/xfs_inode.c

+84 −68
Original line number Diff line number Diff line
@@ -2503,6 +2503,88 @@ out: 
	return error;

}



/*

 * Look up the inode number specified and mark it stale if it is found. If it is

 * dirty, return the inode so it can be attached to the cluster buffer so it can

 * be processed appropriately when the cluster free transaction completes.

 */

static struct xfs_inode *

xfs_ifree_get_one_inode(

	struct xfs_perag	*pag,

	struct xfs_inode	*free_ip,

	int			inum)

{

	struct xfs_mount	*mp = pag->pag_mount;

	struct xfs_inode	*ip;



retry:

	rcu_read_lock();

	ip = radix_tree_lookup(&pag->pag_ici_root, XFS_INO_TO_AGINO(mp, inum));



	/* Inode not in memory, nothing to do */

	if (!ip)

		goto out_rcu_unlock;



	/*

	 * because this is an RCU protected lookup, we could find a recently

	 * freed or even reallocated inode during the lookup. We need to check

	 * under the i_flags_lock for a valid inode here. Skip it if it is not

	 * valid, the wrong inode or stale.

	 */

	spin_lock(&ip->i_flags_lock);

	if (ip->i_ino != inum || __xfs_iflags_test(ip, XFS_ISTALE)) {

		spin_unlock(&ip->i_flags_lock);

		goto out_rcu_unlock;

	}

	spin_unlock(&ip->i_flags_lock);



	/*

	 * Don't try to lock/unlock the current inode, but we _cannot_ skip the

	 * other inodes that we did not find in the list attached to the buffer

	 * and are not already marked stale. If we can't lock it, back off and

	 * retry.

	 */

	if (ip != free_ip) {

		if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {

			rcu_read_unlock();

			delay(1);

			goto retry;

		}



		/*

		 * Check the inode number again in case we're racing with

		 * freeing in xfs_reclaim_inode().  See the comments in that

		 * function for more information as to why the initial check is

		 * not sufficient.

		 */

		if (ip->i_ino != inum) {

			xfs_iunlock(ip, XFS_ILOCK_EXCL);

			goto out_rcu_unlock;

		}

	}

	rcu_read_unlock();



	xfs_iflock(ip);

	xfs_iflags_set(ip, XFS_ISTALE);



	/*

	 * We don't need to attach clean inodes or those only with unlogged

	 * changes (which we throw away, anyway).

	 */

	if (!ip->i_itemp || xfs_inode_clean(ip)) {

		ASSERT(ip != free_ip);

		xfs_ifunlock(ip);

		xfs_iunlock(ip, XFS_ILOCK_EXCL);

		goto out_no_inode;

	}

	return ip;



out_rcu_unlock:

	rcu_read_unlock();

out_no_inode:

	return NULL;

}



/*

 * A big issue when freeing the inode cluster is that we _cannot_ skip any

 * inodes that are in memory - they all must be marked stale and attached to
@@ -2603,77 +2685,11 @@ xfs_ifree_cluster( 
		 * even trying to lock them.

		 */

		for (i = 0; i < igeo->inodes_per_cluster; i++) {

retry:

			rcu_read_lock();

			ip = radix_tree_lookup(&pag->pag_ici_root,

					XFS_INO_TO_AGINO(mp, (inum + i)));



			/* Inode not in memory, nothing to do */

			if (!ip) {

				rcu_read_unlock();

				continue;

			}



			/*

			 * because this is an RCU protected lookup, we could

			 * find a recently freed or even reallocated inode

			 * during the lookup. We need to check under the

			 * i_flags_lock for a valid inode here. Skip it if it

			 * is not valid, the wrong inode or stale.

			 */

			spin_lock(&ip->i_flags_lock);

			if (ip->i_ino != inum + i ||

			    __xfs_iflags_test(ip, XFS_ISTALE)) {

				spin_unlock(&ip->i_flags_lock);

				rcu_read_unlock();

				continue;

			}

			spin_unlock(&ip->i_flags_lock);



			/*

			 * Don't try to lock/unlock the current inode, but we

			 * _cannot_ skip the other inodes that we did not find

			 * in the list attached to the buffer and are not

			 * already marked stale. If we can't lock it, back off

			 * and retry.

			 */

			if (ip != free_ip) {

				if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {

					rcu_read_unlock();

					delay(1);

					goto retry;

				}



				/*

				 * Check the inode number again in case we're

				 * racing with freeing in xfs_reclaim_inode().

				 * See the comments in that function for more

				 * information as to why the initial check is

				 * not sufficient.

				 */

				if (ip->i_ino != inum + i) {

					xfs_iunlock(ip, XFS_ILOCK_EXCL);

					rcu_read_unlock();

			ip = xfs_ifree_get_one_inode(pag, free_ip, inum + i);

			if (!ip)

				continue;

				}

			}

			rcu_read_unlock();



			xfs_iflock(ip);

			xfs_iflags_set(ip, XFS_ISTALE);



			/*

			 * we don't need to attach clean inodes or those only

			 * with unlogged changes (which we throw away, anyway).

			 */

			iip = ip->i_itemp;

			if (!iip || xfs_inode_clean(ip)) {

				ASSERT(ip != free_ip);

				xfs_ifunlock(ip);

				xfs_iunlock(ip, XFS_ILOCK_EXCL);

				continue;

			}



			iip->ili_last_fields = iip->ili_fields;

			iip->ili_fields = 0;

			iip->ili_fsync_fields = 0;

CRA Git | Maintained and supported by SUSTech CRA and CCSE