xfs: move xfs_dialloc_roll() into xfs_dialloc() (f3bf6e0f) · Commits · EulixOS / Software / Kernel

fs/xfs/libxfs/xfs_ialloc.c

+20 −39

Original line number	Diff line number	Diff line
		@@ -1682,7 +1682,7 @@ xfs_dialloc_ag(
		return error;
		}

		int
		static int
		xfs_dialloc_roll(
		struct xfs_trans **tpp,
		struct xfs_buf *agibp)
		@@ -1723,30 +1723,18 @@ xfs_dialloc_roll(
		* Mode is used to tell whether the new inode will need space, and whether it
		* is a directory.
		*
		* This function is designed to be called twice if it has to do an allocation
		* to make more free inodes. On the first call, *IO_agbp should be set to NULL.
		* If an inode is available without having to performn an allocation, an inode
		* number is returned. In this case, *IO_agbp is set to NULL. If an allocation
		* needs to be done, xfs_dialloc returns the current AGI buffer in *IO_agbp.
		* The caller should then commit the current transaction, allocate a
		* new transaction, and call xfs_dialloc() again, passing in the previous value
		* of *IO_agbp. IO_agbp should be held across the transactions. Since the AGI
		* buffer is locked across the two calls, the second call is guaranteed to have
		* a free inode available.
		*
		* Once we successfully pick an inode its number is returned and the on-disk
		* data structures are updated. The inode itself is not read in, since doing so
		* would break ordering constraints with xfs_reclaim.
		*/
		int
		xfs_dialloc(
		struct xfs_trans *tp,
		struct xfs_trans **tpp,
		xfs_ino_t parent,
		umode_t mode,
		struct xfs_buf **IO_agbp,
		xfs_ino_t *inop)
		{
		struct xfs_mount *mp = tp->t_mountp;
		struct xfs_mount mp = (tpp)->t_mountp;
		struct xfs_buf *agbp;
		xfs_agnumber_t agno;
		int error;
		@@ -1757,21 +1745,11 @@ xfs_dialloc(
		struct xfs_ino_geometry *igeo = M_IGEO(mp);
		bool okalloc = true;

		if (*IO_agbp) {
		/*
		* If the caller passes in a pointer to the AGI buffer,
		* continue where we left off before. In this case, we
		* know that the allocation group has free inodes.
		*/
		agbp = *IO_agbp;
		goto out_alloc;
		}

		/*
		* We do not have an agbp, so select an initial allocation
		* group for inode allocation.
		*/
		start_agno = xfs_ialloc_ag_select(tp, parent, mode);
		start_agno = xfs_ialloc_ag_select(*tpp, parent, mode);
		if (start_agno == NULLAGNUMBER) {
		*inop = NULLFSINO;
		return 0;
		@@ -1806,7 +1784,7 @@ xfs_dialloc(
		}

		if (!pag->pagi_init) {
		error = xfs_ialloc_pagi_init(mp, tp, agno);
		error = xfs_ialloc_pagi_init(mp, *tpp, agno);
		if (error)
		goto out_error;
		}
		@@ -1821,7 +1799,7 @@ xfs_dialloc(
		* Then read in the AGI buffer and recheck with the AGI buffer
		* lock held.
		*/
		error = xfs_ialloc_read_agi(mp, tp, agno, &agbp);
		error = xfs_ialloc_read_agi(mp, *tpp, agno, &agbp);
		if (error)
		goto out_error;

		@@ -1834,9 +1812,9 @@ xfs_dialloc(
		goto nextag_relse_buffer;


		error = xfs_ialloc_ag_alloc(tp, agbp, &ialloced);
		error = xfs_ialloc_ag_alloc(*tpp, agbp, &ialloced);
		if (error) {
		xfs_trans_brelse(tp, agbp);
		xfs_trans_brelse(*tpp, agbp);

		if (error != -ENOSPC)
		goto out_error;
		@@ -1848,21 +1826,25 @@ xfs_dialloc(

		if (ialloced) {
		/*
		* We successfully allocated some inodes, return
		* the current context to the caller so that it
		* can commit the current transaction and call
		* us again where we left off.
		* We successfully allocated space for an inode cluster
		* in this AG. Roll the transaction so that we can
		* allocate one of the new inodes.
		*/
		ASSERT(pag->pagi_freecount > 0);
		xfs_perag_put(pag);

		*IO_agbp = agbp;
		error = xfs_dialloc_roll(tpp, agbp);
		if (error) {
		xfs_buf_relse(agbp);
		return error;
		}

		*inop = NULLFSINO;
		return 0;
		goto out_alloc;
		}

		nextag_relse_buffer:
		xfs_trans_brelse(tp, agbp);
		xfs_trans_brelse(*tpp, agbp);
		nextag:
		xfs_perag_put(pag);
		if (++agno == mp->m_sb.sb_agcount)
		@@ -1874,8 +1856,7 @@ xfs_dialloc(
		}

		out_alloc:
		*IO_agbp = NULL;
		return xfs_dialloc_ag(tp, agbp, parent, inop);
		return xfs_dialloc_ag(*tpp, agbp, parent, inop);
		out_error:
		xfs_perag_put(pag);
		return error;

fs/xfs/libxfs/xfs_ialloc.h

+1 −20

Original line number	Diff line number	Diff line
		@@ -32,39 +32,20 @@ xfs_make_iptr(struct xfs_mount mp, struct xfs_buf b, int o)
		return xfs_buf_offset(b, o << (mp)->m_sb.sb_inodelog);
		}

		int
		xfs_dialloc_roll(
		struct xfs_trans **tpp,
		struct xfs_buf *agibp);

		/*
		* Allocate an inode on disk.
		* Mode is used to tell whether the new inode will need space, and whether
		* it is a directory.
		*
		* To work within the constraint of one allocation per transaction,
		* xfs_dialloc() is designed to be called twice if it has to do an
		* allocation to make more free inodes. If an inode is
		* available without an allocation, agbp would be set to the current
		* agbp and alloc_done set to false.
		* If an allocation needed to be done, agbp would be set to the
		* inode header of the allocation group and alloc_done set to true.
		* The caller should then commit the current transaction and allocate a new
		* transaction. xfs_dialloc() should then be called again with
		* the agbp value returned from the previous call.
		*
		* Once we successfully pick an inode its number is returned and the
		* on-disk data structures are updated. The inode itself is not read
		* in, since doing so would break ordering constraints with xfs_reclaim.
		*
		* agbp should be set to NULL on the first call, alloc_done set to FALSE.
		*/
		int /* error */
		xfs_dialloc(
		struct xfs_trans tp, / transaction pointer */
		struct xfs_trans *tpp, / double pointer of transaction */
		xfs_ino_t parent, /* parent inode (directory) */
		umode_t mode, /* mode bits for new inode */
		struct xfs_buf *agbp, / buf for a.g. inode header */
		xfs_ino_t inop); / inode number allocated */

		/*

fs/xfs/xfs_inode.c

+3 −35

Original line number	Diff line number	Diff line
		@@ -909,7 +909,6 @@ xfs_dir_ialloc(
		prid_t prid,
		struct xfs_inode **ipp)
		{
		struct xfs_buf *ialloc_context = NULL;
		xfs_ino_t parent_ino = dp ? dp->i_ino : 0;
		xfs_ino_t ino;
		int error;
		@@ -918,43 +917,12 @@ xfs_dir_ialloc(

		/*
		* 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.
		* allocated.
		*/
		error = xfs_dialloc(*tpp, parent_ino, mode, &ialloc_context, &ino);
		error = xfs_dialloc(tpp, parent_ino, mode, &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_dialloc() again. It is guaranteed
		* to succeed the second time.
		*/
		if (ialloc_context) {
		error = xfs_dialloc_roll(tpp, ialloc_context);
		if (error) {
		xfs_buf_relse(ialloc_context);
		return error;
		}
		/*
		* Call dialloc again. Since we've locked out all other
		* allocations in this allocation group, this call should
		* always succeed.
		*/
		error = xfs_dialloc(*tpp, parent_ino, mode, &ialloc_context,
		&ino);
		if (error)
		return error;
		ASSERT(!ialloc_context);
		}

		if (ino == NULLFSINO)
		return -ENOSPC;