From: Dave Chinner <dchinner@xxxxxxxxxx>
Get rid of the confusing ialloc_context and failure handling around
xfs_dialloc() by moving xfs_dialloc_roll() into xfs_dialloc().
Reviewed-by: Darrick J. Wong <darrick.wong@xxxxxxxxxx>
Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
Signed-off-by: Gao Xiang <hsiangkao@xxxxxxxxxx>
---
fs/xfs/libxfs/xfs_ialloc.c | 57 ++++++++++++--------------------------
fs/xfs/libxfs/xfs_ialloc.h | 22 +--------------
fs/xfs/xfs_inode.c | 35 ++---------------------
3 files changed, 22 insertions(+), 92 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index 3d2862e3ff41..b00bbd680177 100644
--- a/fs/xfs/libxfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -1682,7 +1682,7 @@ xfs_dialloc_ag(
return error;
}
-int
+static int
xfs_dialloc_roll(
struct xfs_trans **tpp,
struct xfs_buf *agibp)
@@ -1733,30 +1733,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;
@@ -1767,21 +1755,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;
@@ -1816,7 +1794,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;
}
@@ -1831,7 +1809,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;
@@ -1844,9 +1822,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;
@@ -1858,21 +1836,23 @@ 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 some inodes, roll the
+ * transaction so they can allocate one of the free
+ * inodes we just prepared for them.
*/
ASSERT(pag->pagi_freecount > 0);
xfs_perag_put(pag);
- *IO_agbp = agbp;
+ error = xfs_dialloc_roll(tpp, agbp);
+ if (error)
+ 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)
@@ -1884,8 +1864,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;
diff --git a/fs/xfs/libxfs/xfs_ialloc.h b/fs/xfs/libxfs/xfs_ialloc.h
index a145e2a72530..13810ffe4af9 100644
--- a/fs/xfs/libxfs/xfs_ialloc.h
+++ b/fs/xfs/libxfs/xfs_ialloc.h
@@ -32,40 +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);
}
-/* XXX: will be removed in the following patch */
-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 */
/*
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 22843e81bccf..78ecfdf77320 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -909,7 +909,6 @@ xfs_dir_ialloc(
locked. */
{
xfs_inode_t *ip;
- xfs_buf_t *ialloc_context = NULL;
xfs_ino_t pino = dp ? dp->i_ino : 0;
xfs_ino_t ino;
int error;
@@ -919,40 +918,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.
- */
- error = xfs_dialloc(*tpp, pino, mode, &ialloc_context, &ino);
+ * allocated.
+ */
+ error = xfs_dialloc(tpp, pino, 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)
- 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, pino, mode, &ialloc_context, &ino);
- if (error)
- return error;
- ASSERT(!ialloc_context);
- }
-
if (ino == NULLFSINO)
return -ENOSPC;
--
2.18.4
