Commit 1abcf261 authored by Dave Chinner's avatar Dave Chinner Committed by Darrick J. Wong
Browse files

xfs: move on-disk inode allocation out of xfs_ialloc() 



So xfs_ialloc() will only address in-core inode allocation then,
Also, rename xfs_ialloc() to xfs_dir_ialloc_init() in order to
keep everything in xfs_inode.c under the same namespace.

Reviewed-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarDave Chinner <dchinner@redhat.com>
Signed-off-by: default avatarGao Xiang <hsiangkao@redhat.com>
Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
parent aececc9f

fs/xfs/xfs_inode.c

+70 −145
Original line number Diff line number Diff line
@@ -761,69 +761,27 @@ xfs_inode_inherit_flags2( 
}



/*

 * Allocate an inode on disk and return a copy of its in-core version.

 * The in-core inode is locked exclusively.  Set mode, nlink, and rdev

 * appropriately within the inode.  The uid and gid for the inode are

 * set according to the contents of the given cred structure.

 *

 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()

 * has a free inode available, call xfs_iget() to obtain the in-core

 * version of the allocated inode.  Finally, fill in the inode and

 * log its initial contents.  In this case, ialloc_context would be

 * set to NULL.

 *

 * If xfs_dialloc() does not have an available inode, it will replenish

 * its supply by doing an allocation. Since we can only do one

 * allocation within a transaction without deadlocks, we must commit

 * the current transaction before returning the inode itself.

 * In this case, therefore, we will set ialloc_context and return.

 * The caller should then commit the current transaction, start a new

 * transaction, and call xfs_ialloc() again to actually get the inode.

 *

 * To ensure that some other process does not grab the inode that

 * was allocated during the first call to xfs_ialloc(), this routine

 * also returns the [locked] bp pointing to the head of the freelist

 * as ialloc_context.  The caller should hold this buffer across

 * the commit and pass it back into this routine on the second call.

 *

 * If we are allocating quota inodes, we do not have a parent inode

 * to attach to or associate with (i.e. pip == NULL) because they

 * are not linked into the directory structure - they are attached

 * directly to the superblock - and so have no parent.

 * Initialise a newly allocated inode and return the in-core inode to the

 * caller locked exclusively.

 */

static int

xfs_ialloc(

	xfs_trans_t	*tp,

	xfs_inode_t	*pip,

xfs_init_new_inode(

	struct xfs_trans	*tp,

	struct xfs_inode	*pip,

	xfs_ino_t		ino,

	umode_t			mode,

	xfs_nlink_t		nlink,

	dev_t			rdev,

	prid_t			prid,

	xfs_buf_t	**ialloc_context,

	xfs_inode_t	**ipp)

	struct xfs_inode	**ipp)

{

	struct xfs_mount	*mp = tp->t_mountp;

	xfs_ino_t	ino;

	xfs_inode_t	*ip;

	uint		flags;

	struct xfs_inode	*ip;

	unsigned int		flags;

	int			error;

	struct timespec64	tv;

	struct inode		*inode;



	/*

	 * Call the space management code to pick

	 * the on-disk inode to be allocated.

	 */

	error = xfs_dialloc(tp, pip ? pip->i_ino : 0, mode,

			    ialloc_context, &ino);

	if (error)

		return error;

	if (*ialloc_context || ino == NULLFSINO) {

		*ipp = NULL;

		return 0;

	}

	ASSERT(*ialloc_context == NULL);



	/*

	 * Protect against obviously corrupt allocation btree records. Later

	 * xfs_iget checks will catch re-allocation of other active in-memory
@@ -837,14 +795,13 @@ xfs_ialloc( 
	}



	/*

	 * Get the in-core inode with the lock held exclusively.

	 * This is because we're setting fields here we need

	 * to prevent others from looking at until we're done.

	 * Get the in-core inode with the lock held exclusively to prevent

	 * others from looking at until we're done.

	 */

	error = xfs_iget(mp, tp, ino, XFS_IGET_CREATE,

			 XFS_ILOCK_EXCL, &ip);

	error = xfs_iget(mp, tp, ino, XFS_IGET_CREATE, XFS_ILOCK_EXCL, &ip);

	if (error)

		return error;



	ASSERT(ip != NULL);

	inode = VFS_I(ip);

	inode->i_mode = mode;
@@ -932,108 +889,76 @@ xfs_ialloc( 
}



/*

 * Allocates a new inode from disk and return a pointer to the

 * incore copy. This routine will internally commit the current

 * transaction and allocate a new one if the Space Manager needed

 * to do an allocation to replenish the inode free-list.

 *

 * This routine is designed to be called from xfs_create and

 * xfs_create_dir.

 * Allocates a new inode from disk and return a pointer to the incore copy. This

 * routine will internally commit the current transaction and allocate a new one

 * if we needed to allocate more on-disk free inodes to perform the requested

 * operation.

 *

 * If we are allocating quota inodes, we do not have a parent inode to attach to

 * or associate with (i.e. dp == NULL) because they are not linked into the

 * directory structure - they are attached directly to the superblock - and so

 * have no parent.

 */

int

xfs_dir_ialloc(

	xfs_trans_t	**tpp,		/* input: current transaction;

					   output: may be a new transaction. */

	xfs_inode_t	*dp,		/* directory within whose allocate

					   the inode. */

	struct xfs_trans	**tpp,

	struct xfs_inode	*dp,

	umode_t			mode,

	xfs_nlink_t		nlink,

	dev_t			rdev,

	prid_t		prid,		/* project id */

	xfs_inode_t	**ipp)		/* pointer to inode; it will be

					   locked. */

	prid_t			prid,

	struct xfs_inode	**ipp)

{

	xfs_trans_t	*tp;

	xfs_inode_t	*ip;

	xfs_buf_t	*ialloc_context = NULL;

	int		code;

	struct xfs_buf		*ialloc_context = NULL;

	xfs_ino_t		parent_ino = dp ? dp->i_ino : 0;

	xfs_ino_t		ino;

	int			error;



	tp = *tpp;

	ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);

	ASSERT((*tpp)->t_flags & XFS_TRANS_PERM_LOG_RES);



	/*

	 * xfs_ialloc will return a pointer to an incore inode if

	 * the Space Manager has an available inode on the free

	 * list. Otherwise, it will do an allocation and replenish

	 * the freelist.  Since we can only do one allocation per

	 * transaction without deadlocks, we will need to commit the

	 * current transaction and start a new one.  We will then

	 * need to call xfs_ialloc again to get the inode.

	 *

	 * If xfs_ialloc did an allocation to replenish the freelist,

	 * it returns the bp containing the head of the freelist as

	 * ialloc_context. We will hold a lock on it across the

	 * transaction commit so that no other process can steal

	 * the inode(s) that we've just allocated.

	 * Call the space management code to pick the on-disk inode to be

	 * allocated and replenish the freelist.  Since we can only do one

	 * allocation per transaction without deadlocks, we will need to

	 * commit the current transaction and start a new one.

	 * If xfs_dialloc did an allocation to replenish the freelist, it

	 * returns the bp containing the head of the freelist as

	 * ialloc_context. We will hold a lock on it across the transaction

	 * commit so that no other process can steal the inode(s) that we've

	 * just allocated.

	 */

	code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid, &ialloc_context,

			&ip);



	/*

	 * Return an error if we were unable to allocate a new inode.

	 * This should only happen if we run out of space on disk or

	 * encounter a disk error.

	 */

	if (code) {

		*ipp = NULL;

		return code;

	}

	if (!ialloc_context && !ip) {

		*ipp = NULL;

		return -ENOSPC;

	}

	error = xfs_dialloc(*tpp, parent_ino, mode, &ialloc_context, &ino);

	if (error)

		return error;



	/*

	 * If the AGI buffer is non-NULL, then we were unable to get an

	 * inode in one operation.  We need to commit the current

	 * transaction and call xfs_ialloc() again.  It is guaranteed

	 * transaction and call xfs_dialloc() again.  It is guaranteed

	 * to succeed the second time.

	 */

	if (ialloc_context) {

		code = xfs_dialloc_roll(&tp, ialloc_context);

		if (code) {

		error = xfs_dialloc_roll(tpp, ialloc_context);

		if (error) {

			xfs_buf_relse(ialloc_context);

			*tpp = tp;

			*ipp = NULL;

			return code;

			return error;

		}



		/*

		 * Call ialloc again. Since we've locked out all

		 * other allocations in this allocation group,

		 * this call should always succeed.

		 */

		code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid,

				  &ialloc_context, &ip);



		/*

		 * If we get an error at this point, return to the caller

		 * so that the current transaction can be aborted.

		 * Call dialloc again. Since we've locked out all other

		 * allocations in this allocation group, this call should

		 * always succeed.

		 */

		if (code) {

			*tpp = tp;

			*ipp = NULL;

			return code;

		}

		ASSERT(!ialloc_context && ip);



		error = xfs_dialloc(*tpp, parent_ino, mode, &ialloc_context,

				&ino);

		if (error)

			return error;

		ASSERT(!ialloc_context);

	}



	*ipp = ip;

	*tpp = tp;

	if (ino == NULLFSINO)

		return -ENOSPC;



	return 0;

	return xfs_init_new_inode(*tpp, dp, ino, mode, nlink, rdev, prid, ipp);

}



/*

fs/xfs/xfs_inode.h

+3 −3
Original line number Diff line number Diff line
@@ -407,9 +407,9 @@ void xfs_lock_two_inodes(struct xfs_inode *ip0, uint ip0_mode, 
xfs_extlen_t	xfs_get_extsz_hint(struct xfs_inode *ip);

xfs_extlen_t	xfs_get_cowextsz_hint(struct xfs_inode *ip);



int		xfs_dir_ialloc(struct xfs_trans **, struct xfs_inode *, umode_t,

			       xfs_nlink_t, dev_t, prid_t,

			       struct xfs_inode **);

int xfs_dir_ialloc(struct xfs_trans **tpp, struct xfs_inode *dp, umode_t mode,

		   xfs_nlink_t nlink, dev_t dev, prid_t prid,

		   struct xfs_inode **ipp);



static inline int

xfs_itruncate_extents(

fs/xfs/xfs_qm.c

+13 −13
Original line number Diff line number Diff line
@@ -737,15 +737,15 @@ xfs_qm_destroy_quotainfo( 
 */

STATIC int

xfs_qm_qino_alloc(

	xfs_mount_t	*mp,

	xfs_inode_t	**ip,

	uint		flags)

	struct xfs_mount	*mp,

	struct xfs_inode	**ipp,

	unsigned int		flags)

{

	xfs_trans_t	*tp;

	struct xfs_trans	*tp;

	int			error;

	bool			need_alloc = true;



	*ip = NULL;

	*ipp = NULL;

	/*

	 * With superblock that doesn't have separate pquotino, we

	 * share an inode between gquota and pquota. If the on-disk
@@ -771,7 +771,7 @@ xfs_qm_qino_alloc( 
				return -EFSCORRUPTED;

		}

		if (ino != NULLFSINO) {

			error = xfs_iget(mp, NULL, ino, 0, 0, ip);

			error = xfs_iget(mp, NULL, ino, 0, 0, ipp);

			if (error)

				return error;

			mp->m_sb.sb_gquotino = NULLFSINO;
@@ -787,7 +787,7 @@ xfs_qm_qino_alloc( 
		return error;



	if (need_alloc) {

		error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, ip);

		error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, ipp);

		if (error) {

			xfs_trans_cancel(tp);

			return error;
@@ -812,11 +812,11 @@ xfs_qm_qino_alloc( 
		mp->m_sb.sb_qflags = mp->m_qflags & XFS_ALL_QUOTA_ACCT;

	}

	if (flags & XFS_QMOPT_UQUOTA)

		mp->m_sb.sb_uquotino = (*ip)->i_ino;

		mp->m_sb.sb_uquotino = (*ipp)->i_ino;

	else if (flags & XFS_QMOPT_GQUOTA)

		mp->m_sb.sb_gquotino = (*ip)->i_ino;

		mp->m_sb.sb_gquotino = (*ipp)->i_ino;

	else

		mp->m_sb.sb_pquotino = (*ip)->i_ino;

		mp->m_sb.sb_pquotino = (*ipp)->i_ino;

	spin_unlock(&mp->m_sb_lock);

	xfs_log_sb(tp);
@@ -826,7 +826,7 @@ xfs_qm_qino_alloc( 
		xfs_alert(mp, "%s failed (error %d)!", __func__, error);

	}

	if (need_alloc)

		xfs_finish_inode_setup(*ip);

		xfs_finish_inode_setup(*ipp);

	return error;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE