[XFS] implement generic xfs_btree_decrement

From: Dave Chinner <dgc@sgi.com>

[hch: split out from bigger patch and minor adaptions]

SGI-PV: 985583

SGI-Modid: xfs-linux-melb:xfs-kern:32191a

Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
Signed-off-by: Bill O'Donnell <billodo@sgi.com>
Signed-off-by: David Chinner <david@fromorbit.com>

1 files changed, 7 insertions, 91 deletions

diff --git a/fs/xfs/xfs_alloc_btree.c b/fs/xfs/xfs_alloc_btree.c
index febc2d5ea295..6b45481ad5b0 100644
--- a/fs/xfs/xfs_alloc_btree.c
+++ b/fs/xfs/xfs_alloc_btree.c
@@ -256,7 +256,7 @@ xfs_alloc_delrec(
                         xfs_btree_setbuf(cur, level, NULL);
                         cur->bc_nlevels--;
                 } else if (level > 0 &&
-                           (error = xfs_alloc_decrement(cur, level, &i)))
+                           (error = xfs_btree_decrement(cur, level, &i)))
                         return error;
                 *stat = 1;
                 return 0;
@@ -272,7 +272,7 @@ xfs_alloc_delrec(
          * the minimum, we're done.
          */
         if (numrecs >= XFS_ALLOC_BLOCK_MINRECS(level, cur)) {
-                if (level > 0 && (error = xfs_alloc_decrement(cur, level, &i)))
+                if (level > 0 && (error = xfs_btree_decrement(cur, level, &i)))
                         return error;
                 *stat = 1;
                 return 0;
@@ -336,7 +336,7 @@ xfs_alloc_delrec(
                                 xfs_btree_del_cursor(tcur,
                                                      XFS_BTREE_NOERROR);
                                 if (level > 0 &&
-                                    (error = xfs_alloc_decrement(cur, level,
+                                    (error = xfs_btree_decrement(cur, level,
                                             &i)))
                                         return error;
                                 *stat = 1;
@@ -352,7 +352,7 @@ xfs_alloc_delrec(
                 if (lbno != NULLAGBLOCK) {
                         i = xfs_btree_firstrec(tcur, level);
                         XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
-                        if ((error = xfs_alloc_decrement(tcur, level, &i)))
+                        if ((error = xfs_btree_decrement(tcur, level, &i)))
                                 goto error0;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
                 }
@@ -368,7 +368,7 @@ xfs_alloc_delrec(
                  */
                 i = xfs_btree_firstrec(tcur, level);
                 XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
-                if ((error = xfs_alloc_decrement(tcur, level, &i)))
+                if ((error = xfs_btree_decrement(tcur, level, &i)))
                         goto error0;
                 XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
                 xfs_btree_firstrec(tcur, level);
@@ -468,7 +468,7 @@ xfs_alloc_delrec(
          * Just return.  This is probably a logic error, but it's not fatal.
          */
         else {
-                if (level > 0 && (error = xfs_alloc_decrement(cur, level, &i)))
+                if (level > 0 && (error = xfs_btree_decrement(cur, level, &i)))
                         return error;
                 *stat = 1;
                 return 0;
@@ -1780,90 +1780,6 @@ xfs_alloc_updkey(
  */
 
 /*
- * Decrement cursor by one record at the level.
- * For nonzero levels the leaf-ward information is untouched.
- */
-int                                     /* error */
-xfs_alloc_decrement(
-        xfs_btree_cur_t         *cur,   /* btree cursor */
-        int                     level,  /* level in btree, 0 is leaf */
-        int                     *stat)  /* success/failure */
-{
-        xfs_alloc_block_t       *block; /* btree block */
-        int                     error;  /* error return value */
-        int                     lev;    /* btree level */
-
-        ASSERT(level < cur->bc_nlevels);
-        /*
-         * Read-ahead to the left at this level.
-         */
-        xfs_btree_readahead(cur, level, XFS_BTCUR_LEFTRA);
-        /*
-         * Decrement the ptr at this level.  If we're still in the block
-         * then we're done.
-         */
-        if (--cur->bc_ptrs[level] > 0) {
-                *stat = 1;
-                return 0;
-        }
-        /*
-         * Get a pointer to the btree block.
-         */
-        block = XFS_BUF_TO_ALLOC_BLOCK(cur->bc_bufs[level]);
-#ifdef DEBUG
-        if ((error = xfs_btree_check_sblock(cur, block, level,
-                        cur->bc_bufs[level])))
-                return error;
-#endif
-        /*
-         * If we just went off the left edge of the tree, return failure.
-         */
-        if (be32_to_cpu(block->bb_leftsib) == NULLAGBLOCK) {
-                *stat = 0;
-                return 0;
-        }
-        /*
-         * March up the tree decrementing pointers.
-         * Stop when we don't go off the left edge of a block.
-         */
-        for (lev = level + 1; lev < cur->bc_nlevels; lev++) {
-                if (--cur->bc_ptrs[lev] > 0)
-                        break;
-                /*
-                 * Read-ahead the left block, we're going to read it
-                 * in the next loop.
-                 */
-                xfs_btree_readahead(cur, lev, XFS_BTCUR_LEFTRA);
-        }
-        /*
-         * If we went off the root then we are seriously confused.
-         */
-        ASSERT(lev < cur->bc_nlevels);
-        /*
-         * Now walk back down the tree, fixing up the cursor's buffer
-         * pointers and key numbers.
-         */
-        for (block = XFS_BUF_TO_ALLOC_BLOCK(cur->bc_bufs[lev]); lev > level; ) {
-                xfs_agblock_t   agbno;  /* block number of btree block */
-                xfs_buf_t       *bp;    /* buffer pointer for block */
-
-                agbno = be32_to_cpu(*XFS_ALLOC_PTR_ADDR(block, cur->bc_ptrs[lev], cur));
-                if ((error = xfs_btree_read_bufs(cur->bc_mp, cur->bc_tp,
-                                cur->bc_private.a.agno, agbno, 0, &bp,
-                                XFS_ALLOC_BTREE_REF)))
-                        return error;
-                lev--;
-                xfs_btree_setbuf(cur, lev, bp);
-                block = XFS_BUF_TO_ALLOC_BLOCK(bp);
-                if ((error = xfs_btree_check_sblock(cur, block, lev, bp)))
-                        return error;
-                cur->bc_ptrs[lev] = be16_to_cpu(block->bb_numrecs);
-        }
-        *stat = 1;
-        return 0;
-}
-
-/*
  * Delete the record pointed to by cur.
  * The cursor refers to the place where the record was (could be inserted)
  * when the operation returns.
@@ -1889,7 +1805,7 @@ xfs_alloc_delete(
         if (i == 0) {
                 for (level = 1; level < cur->bc_nlevels; level++) {
                         if (cur->bc_ptrs[level] == 0) {
-                                if ((error = xfs_alloc_decrement(cur, level, &i)))
+                                if ((error = xfs_btree_decrement(cur, level, &i)))
                                         return error;
                                 break;
                         }