xfs
[Top] [All Lists]

[PATCH 21/21] clean up xfs_bmap_btree.c

To: xfs@xxxxxxxxxxx
Subject: [PATCH 21/21] clean up xfs_bmap_btree.c
From: Christoph Hellwig <hch@xxxxxx>
Date: Tue, 29 Jul 2008 21:32:00 +0200
Sender: xfs-bounce@xxxxxxxxxxx
User-agent: Mutt/1.3.28i
From: Dave Chinner <dgc@xxxxxxx>

Reimplement xfs_bmbt_newroot and xfs_bmbt_kill_root using the new generic
btree helpers and clean out all cruft needed for the old implementations.

This requires exporting some functionality from xfs_btree.c that's only
used locally otherwise.


Signed-off-by: Christoph Hellwig <hch@xxxxxx>

Index: linux-2.6-xfs/fs/xfs/xfs_bmap_btree.c
===================================================================
--- linux-2.6-xfs.orig/fs/xfs/xfs_bmap_btree.c  2008-07-29 17:04:41.000000000 
+0200
+++ linux-2.6-xfs/fs/xfs/xfs_bmap_btree.c       2008-07-29 17:08:43.000000000 
+0200
@@ -44,82 +44,6 @@
 #include "xfs_error.h"
 #include "xfs_quota.h"
 
-/*
- * Prototypes for internal btree functions.
- */
-
-
-STATIC void xfs_bmbt_log_keys(xfs_btree_cur_t *, xfs_buf_t *, int, int);
-STATIC void xfs_bmbt_log_ptrs(xfs_btree_cur_t *, xfs_buf_t *, int, int);
-
-#undef EXIT
-
-#define ENTRY  XBT_ENTRY
-#define ERROR  XBT_ERROR
-#define EXIT   XBT_EXIT
-
-/*
- * Keep the XFS_BMBT_TRACE_ names around for now until all code using them
- * is converted to be generic and thus switches to the XFS_BTREE_TRACE_ names.
- */
-#define        XFS_BMBT_TRACE_ARGBI(c,b,i) \
-       XFS_BTREE_TRACE_ARGBI(c,b,i)
-#define        XFS_BMBT_TRACE_ARGBII(c,b,i,j) \
-       XFS_BTREE_TRACE_ARGBII(c,b,i,j)
-#define        XFS_BMBT_TRACE_ARGFFFI(c,o,b,i,j) \
-       XFS_BTREE_TRACE_ARGFFFI(c,o,b,i,j)
-#define        XFS_BMBT_TRACE_ARGI(c,i) \
-       XFS_BTREE_TRACE_ARGI(c,i)
-#define        XFS_BMBT_TRACE_ARGIFK(c,i,f,s) \
-       XFS_BTREE_TRACE_ARGIPK(c,i,(union xfs_btree_ptr)f,s)
-#define        XFS_BMBT_TRACE_ARGIFR(c,i,f,r) \
-       XFS_BTREE_TRACE_ARGIPR(c,i, \
-               (union xfs_btree_ptr)f, (union xfs_btree_rec *)r)
-#define        XFS_BMBT_TRACE_ARGIK(c,i,k) \
-       XFS_BTREE_TRACE_ARGIK(c,i,(union xfs_btree_key *)k)
-#define        XFS_BMBT_TRACE_CURSOR(c,s) \
-       XFS_BTREE_TRACE_CURSOR(c,s)
-
-
-/*
- * Internal functions.
- */
-
-/*
- * Log pointer values from the btree block.
- */
-STATIC void
-xfs_bmbt_log_ptrs(
-       xfs_btree_cur_t *cur,
-       xfs_buf_t       *bp,
-       int             pfirst,
-       int             plast)
-{
-       xfs_trans_t     *tp;
-
-       XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
-       XFS_BMBT_TRACE_ARGBII(cur, bp, pfirst, plast);
-       tp = cur->bc_tp;
-       if (bp) {
-               xfs_bmbt_block_t        *block;
-               int                     first;
-               int                     last;
-               xfs_bmbt_ptr_t          *pp;
-
-               block = XFS_BUF_TO_BMBT_BLOCK(bp);
-               pp = XFS_BMAP_PTR_DADDR(block, 1, cur);
-               first = (int)((xfs_caddr_t)&pp[pfirst - 1] - 
(xfs_caddr_t)block);
-               last = (int)(((xfs_caddr_t)&pp[plast] - 1) - 
(xfs_caddr_t)block);
-               xfs_trans_log_buf(tp, bp, first, last);
-       } else {
-               xfs_inode_t             *ip;
-
-               ip = cur->bc_private.b.ip;
-               xfs_trans_log_inode(tp, ip,
-                       XFS_ILOG_FBROOT(cur->bc_private.b.whichfork));
-       }
-       XFS_BMBT_TRACE_CURSOR(cur, EXIT);
-}
 
 /*
  * Determine the extent state.
@@ -334,151 +258,6 @@ xfs_bmbt_disk_get_startoff(
 }
 
 /*
- * Log fields from the btree block header.
- */
-void
-xfs_bmbt_log_block(
-       xfs_btree_cur_t         *cur,
-       xfs_buf_t               *bp,
-       int                     fields)
-{
-       int                     first;
-       int                     last;
-       xfs_trans_t             *tp;
-       static const short      offsets[] = {
-               offsetof(xfs_bmbt_block_t, bb_magic),
-               offsetof(xfs_bmbt_block_t, bb_level),
-               offsetof(xfs_bmbt_block_t, bb_numrecs),
-               offsetof(xfs_bmbt_block_t, bb_leftsib),
-               offsetof(xfs_bmbt_block_t, bb_rightsib),
-               sizeof(xfs_bmbt_block_t)
-       };
-
-       XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
-       XFS_BMBT_TRACE_ARGBI(cur, bp, fields);
-       tp = cur->bc_tp;
-       if (bp) {
-               xfs_btree_offsets(fields, offsets, XFS_BB_NUM_BITS, &first,
-                                 &last);
-               xfs_trans_log_buf(tp, bp, first, last);
-       } else
-               xfs_trans_log_inode(tp, cur->bc_private.b.ip,
-                       XFS_ILOG_FBROOT(cur->bc_private.b.whichfork));
-       XFS_BMBT_TRACE_CURSOR(cur, EXIT);
-}
-
-/*
- * Give the bmap btree a new root block.  Copy the old broot contents
- * down into a real block and make the broot point to it.
- */
-int                                            /* error */
-xfs_bmbt_newroot(
-       xfs_btree_cur_t         *cur,           /* btree cursor */
-       int                     *logflags,      /* logging flags for inode */
-       int                     *stat)          /* return status - 0 fail */
-{
-       xfs_alloc_arg_t         args;           /* allocation arguments */
-       xfs_bmbt_block_t        *block;         /* bmap btree block */
-       xfs_buf_t               *bp;            /* buffer for block */
-       xfs_bmbt_block_t        *cblock;        /* child btree block */
-       xfs_bmbt_key_t          *ckp;           /* child key pointer */
-       xfs_bmbt_ptr_t          *cpp;           /* child ptr pointer */
-       int                     error;          /* error return code */
-#ifdef DEBUG
-       int                     i;              /* loop counter */
-#endif
-       xfs_bmbt_key_t          *kp;            /* pointer to bmap btree key */
-       int                     level;          /* btree level */
-       xfs_bmbt_ptr_t          *pp;            /* pointer to bmap block addr */
-
-       XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
-       level = cur->bc_nlevels - 1;
-       block = xfs_bmbt_get_block(cur, level, &bp);
-       /*
-        * Copy the root into a real block.
-        */
-       args.mp = cur->bc_mp;
-       pp = XFS_BMAP_PTR_IADDR(block, 1, cur);
-       args.tp = cur->bc_tp;
-       args.fsbno = cur->bc_private.b.firstblock;
-       args.mod = args.minleft = args.alignment = args.total = args.isfl =
-               args.userdata = args.minalignslop = 0;
-       args.minlen = args.maxlen = args.prod = 1;
-       args.wasdel = cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL;
-       args.firstblock = args.fsbno;
-       if (args.fsbno == NULLFSBLOCK) {
-#ifdef DEBUG
-               if ((error = xfs_btree_check_lptr_disk(cur, *pp, level))) {
-                       XFS_BMBT_TRACE_CURSOR(cur, ERROR);
-                       return error;
-               }
-#endif
-               args.fsbno = be64_to_cpu(*pp);
-               args.type = XFS_ALLOCTYPE_START_BNO;
-       } else if (cur->bc_private.b.flist->xbf_low)
-               args.type = XFS_ALLOCTYPE_START_BNO;
-       else
-               args.type = XFS_ALLOCTYPE_NEAR_BNO;
-       if ((error = xfs_alloc_vextent(&args))) {
-               XFS_BMBT_TRACE_CURSOR(cur, ERROR);
-               return error;
-       }
-       if (args.fsbno == NULLFSBLOCK) {
-               XFS_BMBT_TRACE_CURSOR(cur, EXIT);
-               *stat = 0;
-               return 0;
-       }
-       ASSERT(args.len == 1);
-       cur->bc_private.b.firstblock = args.fsbno;
-       cur->bc_private.b.allocated++;
-       cur->bc_private.b.ip->i_d.di_nblocks++;
-       XFS_TRANS_MOD_DQUOT_BYINO(args.mp, args.tp, cur->bc_private.b.ip,
-                         XFS_TRANS_DQ_BCOUNT, 1L);
-       bp = xfs_btree_get_bufl(args.mp, cur->bc_tp, args.fsbno, 0);
-       cblock = XFS_BUF_TO_BMBT_BLOCK(bp);
-       *cblock = *block;
-       be16_add(&block->bb_level, 1);
-       block->bb_numrecs = cpu_to_be16(1);
-       cur->bc_nlevels++;
-       cur->bc_ptrs[level + 1] = 1;
-       kp = XFS_BMAP_KEY_IADDR(block, 1, cur);
-       ckp = XFS_BMAP_KEY_IADDR(cblock, 1, cur);
-       memcpy(ckp, kp, be16_to_cpu(cblock->bb_numrecs) * sizeof(*kp));
-       cpp = XFS_BMAP_PTR_IADDR(cblock, 1, cur);
-#ifdef DEBUG
-       for (i = 0; i < be16_to_cpu(cblock->bb_numrecs); i++) {
-               if ((error = xfs_btree_check_lptr_disk(cur, pp[i], level))) {
-                       XFS_BMBT_TRACE_CURSOR(cur, ERROR);
-                       return error;
-               }
-       }
-#endif
-       memcpy(cpp, pp, be16_to_cpu(cblock->bb_numrecs) * sizeof(*pp));
-#ifdef DEBUG
-       if ((error = xfs_btree_check_lptr(cur, args.fsbno, level))) {
-               XFS_BMBT_TRACE_CURSOR(cur, ERROR);
-               return error;
-       }
-#endif
-       *pp = cpu_to_be64(args.fsbno);
-       xfs_iroot_realloc(cur->bc_private.b.ip, 1 - 
be16_to_cpu(cblock->bb_numrecs),
-               cur->bc_private.b.whichfork);
-       xfs_btree_setbuf(cur, level, bp);
-       /*
-        * Do all this logging at the end so that
-        * the root is at the right level.
-        */
-       xfs_bmbt_log_block(cur, bp, XFS_BB_ALL_BITS);
-       xfs_bmbt_log_keys(cur, bp, 1, be16_to_cpu(cblock->bb_numrecs));
-       xfs_bmbt_log_ptrs(cur, bp, 1, be16_to_cpu(cblock->bb_numrecs));
-       XFS_BMBT_TRACE_CURSOR(cur, EXIT);
-       *logflags |=
-               XFS_ILOG_CORE | XFS_ILOG_FBROOT(cur->bc_private.b.whichfork);
-       *stat = 1;
-       return 0;
-}
-
-/*
  * Set all the fields in a bmap extent record from the arguments.
  */
 void
@@ -875,114 +654,6 @@ xfs_bmbt_get_root_from_inode(
        return (struct xfs_btree_block *)ifp->if_broot;
 }
 
-STATIC int                                             /* error */
-xfs_bmbt_new_root(
-       struct xfs_btree_cur    *cur,           /* btree cursor */
-       int                     *stat)          /* return status - 0 fail */
-{
-       int                     logflags = 0;
-       int                     error;
-
-       error = xfs_bmbt_newroot(cur, &logflags, stat);
-       if (error || *stat == 0)
-               return error;
-
-       xfs_trans_log_inode(cur->bc_tp, cur->bc_private.b.ip, logflags);
-       return 0;
-}
-
-STATIC int
-xfs_bmbt_kill_root(
-       struct xfs_btree_cur    *cur,
-       int                     level,
-       union xfs_btree_ptr     *newroot)
-{
-       struct xfs_inode        *ip;
-       struct xfs_ifork        *ifp;
-       struct xfs_btree_lblock *block;
-       struct xfs_btree_lblock *cblock;
-       struct xfs_buf          *cbp;
-       xfs_bmbt_key_t          *ckp;
-       xfs_bmbt_ptr_t          *cpp;
-       xfs_bmbt_key_t          *kp;
-       xfs_bmbt_ptr_t          *pp;
-       int                     i;
-       int                     lev;
-
-       ASSERT(newroot == NULL);
-       ASSERT(level == -1);
-
-       XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
-       lev = cur->bc_nlevels - 1;
-       ASSERT(lev >= 1);
-       /*
-        * Don't deal with the root block needs to be a leaf case.
-        * We're just going to turn the thing back into extents anyway.
-        */
-       if (lev == 1)
-               goto out0;
-
-       block = xfs_bmbt_get_block(cur, lev, &cbp);
-
-       /* Give up if the root has multiple children. */
-       if (be16_to_cpu(block->bb_numrecs) != 1)
-               goto out0;
-       /*
-        * Only do this if the next level will fit.
-        * Then the data must be copied up to the inode,
-        * instead of freeing the root you free the next level.
-        */
-       cblock = xfs_bmbt_get_block(cur, lev - 1, &cbp);
-       if (be16_to_cpu(cblock->bb_numrecs) > XFS_BMAP_BLOCK_DMAXRECS(level, 
cur))
-               goto out0;
-       XFS_BTREE_STATS_INC(cur, killroot);
-
-       ASSERT(be64_to_cpu(cblock->bb_leftsib) == NULLDFSBNO);
-       ASSERT(be64_to_cpu(cblock->bb_rightsib) == NULLDFSBNO);
-       ip = cur->bc_private.b.ip;
-       ifp = XFS_IFORK_PTR(ip, cur->bc_private.b.whichfork);
-       ASSERT(XFS_BMAP_BLOCK_IMAXRECS(lev, cur) ==
-              XFS_BMAP_BROOT_MAXRECS(ifp->if_broot_bytes));
-       i = (int)(be16_to_cpu(cblock->bb_numrecs) -
-                 XFS_BMAP_BLOCK_IMAXRECS(lev, cur));
-       if (i) {
-               xfs_iroot_realloc(ip, i, cur->bc_private.b.whichfork);
-               block = (struct xfs_btree_lblock *)ifp->if_broot;
-       }
-       be16_add(&block->bb_numrecs, i);
-       ASSERT(block->bb_numrecs == cblock->bb_numrecs);
-       kp = XFS_BMAP_KEY_IADDR(block, 1, cur);
-       ckp = XFS_BMAP_KEY_IADDR(cblock, 1, cur);
-       memcpy(kp, ckp, be16_to_cpu(block->bb_numrecs) * sizeof(*kp));
-       pp = XFS_BMAP_PTR_IADDR(block, 1, cur);
-       cpp = XFS_BMAP_PTR_IADDR(cblock, 1, cur);
-
-#ifdef DEBUG
-       for (i = 0; i < be16_to_cpu(cblock->bb_numrecs); i++) {
-               int     error;
-
-               error = xfs_btree_check_lptr_disk(cur, cpp[i], level - 1);
-               if (error) {
-                       XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
-                       return error;
-               }
-       }
-#endif
-
-       memcpy(pp, cpp, be16_to_cpu(block->bb_numrecs) * sizeof(*pp));
-
-       xfs_bmbt_free_block(cur, cbp, 1);
-       XFS_BTREE_STATS_INC(cur, free);
-       cur->bc_bufs[lev - 1] = NULL;
-       be16_add(&block->bb_level, -1);
-       xfs_trans_log_inode(cur->bc_tp, ip,
-               XFS_ILOG_CORE | XFS_ILOG_FBROOT(cur->bc_private.b.whichfork));
-       cur->bc_nlevels--;
-out0:
-       XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
-       return 0;
-}
-
 STATIC void
 xfs_bmbt_realloc_root(
        struct xfs_btree_cur    *cur,
@@ -1231,6 +902,217 @@ xfs_bmbt_log_recs(
        XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 }
 
+/*
+ * Give the bmap btree a new root block.  Copy the old broot contents
+ * down into a real block and make the broot point to it.
+ */
+int                                            /* error */
+xfs_bmbt_newroot(
+       struct xfs_btree_cur    *cur,           /* btree cursor */
+       int                     *logflags,      /* logging flags for inode */
+       int                     *stat)          /* return status - 0 fail */
+{
+       struct xfs_btree_block  *block;         /* bmap btree block */
+       struct xfs_buf          *bp;            /* buffer for block */
+       struct xfs_btree_block  *cblock;        /* child btree block */
+       union xfs_btree_key     *kp;            /* pointer to bmap btree key */
+       union xfs_btree_key     *ckp;           /* child key pointer */
+       union xfs_btree_ptr     *cpp;           /* child ptr pointer */
+       int                     error;          /* error return code */
+#ifdef DEBUG
+       int                     i;              /* loop counter */
+#endif
+       int                     level;          /* btree level */
+       union xfs_btree_ptr     *pp;            /* pointer to bmap block addr */
+       union xfs_btree_ptr     nptr;
+       int                     crecs;
+
+       XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
+       XFS_BTREE_STATS_INC(cur, newroot);
+
+       level = cur->bc_nlevels - 1;
+       block = xfs_btree_get_block(cur, level, &bp);
+       pp = xfs_bmbt_ptr_addr(cur, 1, block);
+
+       error = xfs_bmbt_alloc_block(cur, pp, &nptr, 1, stat);
+       if (error)
+               goto error0;
+
+       if (*stat == 0) {
+               XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
+               return 0;
+       }
+
+       XFS_BTREE_STATS_INC(cur, alloc);
+
+       /* Copy the root into a real block. */
+       error = xfs_btree_get_buf_block(cur, &nptr, 0, &cblock, &bp);
+       if (error)
+               goto error0;
+
+       *cblock = *block;
+       be16_add(&block->bb_h.bb_level, 1);
+       xfs_btree_set_numrecs(block, 1);
+       cur->bc_nlevels++;
+       cur->bc_ptrs[level + 1] = 1;
+       kp = xfs_bmbt_key_addr(cur, 1, block);
+       ckp = xfs_bmbt_key_addr(cur, 1, cblock);
+
+       crecs = xfs_btree_get_numrecs(cblock);
+       xfs_bmbt_copy_keys(cur, kp, ckp, crecs);
+
+       cpp = xfs_bmbt_ptr_addr(cur, 1, cblock);
+
+#ifdef DEBUG
+       for (i = 0; i < crecs; i++) {
+               error = xfs_btree_check_ptr(cur, pp, i, level);
+               if (error)
+                       goto error0;
+       }
+#endif
+
+       xfs_btree_copy_ptrs(cur, pp, cpp, crecs);
+
+#ifdef DEBUG
+       error = xfs_btree_check_ptr(cur, &nptr, 0, level);
+       if (error)
+               goto error0;
+#endif
+
+       *pp = nptr;
+       xfs_bmbt_realloc_root(cur, 1 - crecs);
+       xfs_btree_setbuf(cur, level, bp);
+
+       /* Log it at the end so that the root is at the right level. */
+       xfs_btree_log_block(cur, bp, XFS_BB_ALL_BITS);
+       xfs_bmbt_log_keys(cur, bp, 1, crecs);
+       xfs_btree_log_ptrs(cur, bp, 1, crecs);
+
+       XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
+
+       *logflags |=
+               XFS_ILOG_CORE | XFS_ILOG_FBROOT(cur->bc_private.b.whichfork);
+       *stat = 1;
+       return 0;
+error0:
+       XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
+       return error;
+}
+
+STATIC int                                             /* error */
+xfs_bmbt_new_root(
+       struct xfs_btree_cur    *cur,           /* btree cursor */
+       int                     *stat)          /* return status - 0 fail */
+{
+       int                     logflags = 0;
+       int                     error;
+
+       error = xfs_bmbt_newroot(cur, &logflags, stat);
+       if (error || *stat == 0)
+               return error;
+
+       xfs_trans_log_inode(cur->bc_tp, cur->bc_private.b.ip, logflags);
+       return 0;
+}
+
+STATIC int
+xfs_bmbt_kill_root(
+       struct xfs_btree_cur    *cur,
+       int                     level,
+       union xfs_btree_ptr     *newroot)
+{
+       struct xfs_inode        *ip;
+       struct xfs_ifork        *ifp;
+       struct xfs_btree_block  *block;
+       struct xfs_btree_block  *cblock;
+       struct xfs_buf          *cbp;
+       union xfs_btree_key     *ckp;
+       union xfs_btree_key     *kp;
+       union xfs_btree_ptr     *cpp;
+       union xfs_btree_ptr     *pp;
+       int                     i;
+       int                     lev;
+       int                     nrecs;
+       int                     crecs;
+
+       ASSERT(newroot == NULL);
+       ASSERT(level == -1);
+
+       XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
+       lev = cur->bc_nlevels - 1;
+       ASSERT(lev >= 1);
+       /*
+        * Don't deal with the root block needs to be a leaf case.
+        * We're just going to turn the thing back into extents anyway.
+        */
+       if (lev == 1)
+               goto out0;
+
+       block = xfs_btree_get_block(cur, lev, &cbp);
+
+       /* Give up if the root has multiple children. */
+       nrecs = xfs_btree_get_numrecs(block);
+       if (nrecs != 1)
+               goto out0;
+       /*
+        * Only do this if the next level will fit.
+        * Then the data must be copied up to the inode,
+        * instead of freeing the root you free the next level.
+        */
+       cblock = xfs_btree_get_block(cur, lev - 1, &cbp);
+       crecs = xfs_btree_get_numrecs(cblock);
+       if (crecs > XFS_BMAP_BLOCK_DMAXRECS(level, cur))
+               goto out0;
+
+       XFS_BTREE_STATS_INC(cur, killroot);
+
+       ip = cur->bc_private.b.ip;
+       ifp = XFS_IFORK_PTR(ip, cur->bc_private.b.whichfork);
+       ASSERT(XFS_BMAP_BLOCK_IMAXRECS(lev, cur) ==
+              XFS_BMAP_BROOT_MAXRECS(ifp->if_broot_bytes));
+
+       i = crecs - XFS_BMAP_BLOCK_IMAXRECS(lev, cur);
+       if (i) {
+               xfs_iroot_realloc(ip, i, cur->bc_private.b.whichfork);
+               block = (struct xfs_btree_block *)ifp->if_broot;
+       }
+
+       nrecs += i;
+       xfs_btree_set_numrecs(block, nrecs);
+
+       ASSERT(nrecs == crecs);
+       kp = xfs_bmbt_key_addr(cur, 1, block);
+       ckp = xfs_bmbt_key_addr(cur, 1, cblock);
+       memcpy(kp, ckp, nrecs * sizeof(xfs_bmbt_key_t));
+       pp = xfs_bmbt_ptr_addr(cur, 1, block);
+       cpp = xfs_bmbt_ptr_addr(cur, 1, cblock);
+
+#ifdef DEBUG
+       for (i = 0; i < crecs; i++) {
+               int     error;
+
+               error = xfs_btree_check_ptr(cur, cpp, i, level - 1);
+               if (error) {
+                       XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
+                       return error;
+               }
+       }
+#endif
+
+       memcpy(pp, cpp, nrecs * sizeof(xfs_bmbt_key_t));
+
+       xfs_bmbt_free_block(cur, cbp, 1);
+       XFS_BTREE_STATS_INC(cur, free);
+       cur->bc_bufs[lev - 1] = NULL;
+       be16_add(&block->bb_h.bb_level, -1);
+       xfs_trans_log_inode(cur->bc_tp, ip,
+               XFS_ILOG_CORE | XFS_ILOG_FBROOT(cur->bc_private.b.whichfork));
+       cur->bc_nlevels--;
+out0:
+       XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
+       return 0;
+}
+
 #ifdef XFS_BTREE_TRACE
 
 ktrace_t       *xfs_bmbt_trace_buf;
Index: linux-2.6-xfs/fs/xfs/xfs_btree.c
===================================================================
--- linux-2.6-xfs.orig/fs/xfs/xfs_btree.c       2008-07-29 17:04:41.000000000 
+0200
+++ linux-2.6-xfs/fs/xfs/xfs_btree.c    2008-07-29 17:04:44.000000000 +0200
@@ -409,7 +409,7 @@ xfs_btree_dup_cursor(
  * Retrieve the block pointer from the cursor at the given level.
  * This may be a bmap btree root or from a buffer.
  */
-STATIC struct xfs_btree_block *                /* generic btree block pointer 
*/
+struct xfs_btree_block *               /* generic btree block pointer */
 xfs_btree_get_block(
        struct xfs_btree_cur    *cur,   /* btree cursor */
        int                     level,  /* level in btree */
@@ -987,7 +987,7 @@ xfs_btree_set_refs(
        }
 }
 
-STATIC int
+int
 xfs_btree_get_buf_block(
        struct xfs_btree_cur    *cur,
        union xfs_btree_ptr     *ptr,
@@ -1047,7 +1047,7 @@ xfs_btree_read_buf_block(
        return xfs_btree_check_block(cur, *block, level, *bpp);
 }
 
-STATIC void
+void
 xfs_btree_set_ptr(
        struct xfs_btree_cur    *cur,
        union xfs_btree_ptr     *ptr_addr,
@@ -1088,7 +1088,7 @@ xfs_btree_move_ptrs(
        }
 }
 
-STATIC void
+void
 xfs_btree_copy_ptrs(
        struct xfs_btree_cur    *cur,
        union xfs_btree_ptr     *src_ptr,
@@ -1106,7 +1106,7 @@ xfs_btree_copy_ptrs(
 /*
  * Log block pointer fields from a btree block (nonleaf).
  */
-STATIC void
+void
 xfs_btree_log_ptrs(
        struct xfs_btree_cur    *cur,   /* btree cursor */
        struct xfs_buf          *bp,    /* buffer containing btree block */
@@ -1153,7 +1153,7 @@ xfs_btree_log_ptrs(
 /*
  * Log fields from the short from btree block header.
  */
-STATIC void
+void
 xfs_btree_log_block(
        struct xfs_btree_cur    *cur,   /* btree cursor */
        struct xfs_buf          *bp,    /* buffer containing btree block */
Index: linux-2.6-xfs/fs/xfs/xfs_btree.h
===================================================================
--- linux-2.6-xfs.orig/fs/xfs/xfs_btree.h       2008-07-29 17:04:41.000000000 
+0200
+++ linux-2.6-xfs/fs/xfs/xfs_btree.h    2008-07-29 17:04:44.000000000 +0200
@@ -612,6 +612,19 @@ int xfs_btree_delete(struct xfs_btree_cu
 
 
 /*
+ * Internal helpers also needed by xfs_bmap_btree.c.
+ */
+struct xfs_btree_block *xfs_btree_get_block(struct xfs_btree_cur *, int,
+               struct xfs_buf **);
+int xfs_btree_get_buf_block(struct xfs_btree_cur *, union xfs_btree_ptr *,
+               int, struct xfs_btree_block **, struct xfs_buf **);
+void xfs_btree_copy_ptrs(struct xfs_btree_cur *, union xfs_btree_ptr *,
+               union xfs_btree_ptr *, int);
+void xfs_btree_log_ptrs(struct xfs_btree_cur *, struct xfs_buf *, int, int);
+void xfs_btree_log_block(struct xfs_btree_cur *, struct xfs_buf *, int);
+
+
+/*
  * Helpers.
  */
 
Index: linux-2.6-xfs/fs/xfs/xfs_bmap.c
===================================================================
--- linux-2.6-xfs.orig/fs/xfs/xfs_bmap.c        2008-07-29 17:04:41.000000000 
+0200
+++ linux-2.6-xfs/fs/xfs/xfs_bmap.c     2008-07-29 17:04:44.000000000 +0200
@@ -3563,7 +3563,7 @@ xfs_bmap_extents_to_btree(
         * Do all this logging at the end so that
         * the root is at the right level.
         */
-       xfs_bmbt_log_block(cur, abp, XFS_BB_ALL_BITS);
+       xfs_btree_log_block(cur, abp, XFS_BB_ALL_BITS);
        xfs_bmbt_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs));
        ASSERT(*curp == NULL);
        *curp = cur;

-- 


<Prev in Thread] Current Thread [Next in Thread>