libxfs_sb_from_disk(sb, XFS_BUF_TO_SBP(sbp));
/* Do it again, now with proper length and verifier */
- libxfs_putbuf(sbp);
+ libxfs_buf_relse(sbp);
libxfs_purgebuf(sbp);
sbp = libxfs_readbuf(mbuf.m_ddev_targp, XFS_SB_DADDR,
1 << (sb->sb_sectlog - BBSHIFT),
0, &xfs_sb_buf_ops);
- libxfs_putbuf(sbp);
+ libxfs_buf_relse(sbp);
mp = libxfs_mount(&mbuf, sb, xargs.ddev, xargs.logdev, xargs.rtdev, 0);
if (mp == NULL) {
bt_cur = libxfs_rmapbt_init_cursor(mp, NULL, agbp, agno);
if (!bt_cur) {
- libxfs_putbuf(agbp);
+ libxfs_buf_relse(agbp);
dbprintf(_("Not enough memory.\n"));
return;
}
fsmap_fn, &info);
if (error) {
libxfs_btree_del_cursor(bt_cur, XFS_BTREE_ERROR);
- libxfs_putbuf(agbp);
+ libxfs_buf_relse(agbp);
dbprintf(_("Error %d while querying fsmap btree.\n"),
error);
return;
}
libxfs_btree_del_cursor(bt_cur, XFS_BTREE_NOERROR);
- libxfs_putbuf(agbp);
+ libxfs_buf_relse(agbp);
if (agno == start_ag)
low.rm_startblock = 0;
length = be32_to_cpu(agf->agf_length);
free = be32_to_cpu(agf->agf_freeblks) +
be32_to_cpu(agf->agf_flcount);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
printf("AG %d: length: %u free: %u reserved: %u used: %u",
agno, length, free, ask, used);
/* copy SB from buffer to in-core, converting architecture as we go */
libxfs_sb_from_disk(&xmount.m_sb, XFS_BUF_TO_SBP(bp));
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
libxfs_purgebuf(bp);
sbp = &xmount.m_sb;
return;
}
if (iocur_top->bp) {
- libxfs_putbuf(iocur_top->bp);
+ libxfs_buf_relse(iocur_top->bp);
iocur_top->bp = NULL;
}
if (iocur_top->bbmap) {
progname);
return -1;
}
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 0;
}
if (!debugger)
return NULL;
} else
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
if (mp->m_logdev_targp->dev &&
mp->m_logdev_targp->dev != mp->m_ddev_targp->dev) {
return NULL;
}
if (bp)
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
/* Initialize realtime fields in the mount structure */
progname);
sbp->sb_agcount = 1;
}
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
error = libxfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
#define xfs_btree_del_cursor libxfs_btree_del_cursor
#define xfs_btree_init_block libxfs_btree_init_block
#define xfs_buf_delwri_submit libxfs_buf_delwri_submit
+#define xfs_buf_relse libxfs_buf_relse
#define xfs_bunmapi libxfs_bunmapi
#define xfs_calc_dquots_per_chunk libxfs_calc_dquots_per_chunk
#define xfs_da3_node_hdr_from_disk libxfs_da3_node_hdr_from_disk
#define libxfs_getbuf_flags(dev, daddr, len, flags) \
libxfs_trace_getbuf_flags(__FUNCTION__, __FILE__, __LINE__, \
(dev), (daddr), (len), (flags))
-#define libxfs_putbuf(buf) \
+#define libxfs_buf_relse(buf) \
libxfs_trace_putbuf(__FUNCTION__, __FILE__, __LINE__, (buf))
extern xfs_buf_t *libxfs_trace_readbuf(const char *, const char *, int,
struct xfs_buf_map *, int, int);
extern xfs_buf_t *libxfs_getbuf_flags(struct xfs_buftarg *, xfs_daddr_t,
int, unsigned int);
-extern void libxfs_putbuf (xfs_buf_t *);
+void libxfs_buf_relse(struct xfs_buf *bp);
#endif
(len) = __bar; /* no set-but-unused warning */ \
NULL; \
})
-#define xfs_buf_relse(bp) libxfs_putbuf(bp)
#define xfs_buf_get(devp,blkno,len) (libxfs_getbuf((devp), (blkno), (len)))
#define xfs_bwrite(bp) libxfs_writebuf((bp), 0)
#define xfs_buf_oneshot(bp) ((void) 0)
*
* The result of this is that until the userspace code outside libxfs is cleaned
* up, functions that release buffers from userspace control (i.e
- * libxfs_writebuf/libxfs_putbuf) need to zero bp->b_error to prevent
+ * libxfs_writebuf/libxfs_buf_relse) need to zero bp->b_error to prevent
* propagation of stale errors into future buffer operations.
*/
#undef libxfs_getbuf
#undef libxfs_getbuf_map
#undef libxfs_getbuf_flags
-#undef libxfs_putbuf
xfs_buf_t *libxfs_readbuf(struct xfs_buftarg *, xfs_daddr_t, int, int,
const struct xfs_buf_ops *);
int, int);
xfs_buf_t *libxfs_getbuf_flags(struct xfs_buftarg *, xfs_daddr_t, int,
unsigned int);
-void libxfs_putbuf (xfs_buf_t *);
+void libxfs_buf_relse(struct xfs_buf *bp);
#define __add_trace(bp, func, file, line) \
do { \
libxfs_trace_putbuf(const char *func, const char *file, int line, xfs_buf_t *bp)
{
__add_trace(bp, func, file, line);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
}
void
-libxfs_putbuf(xfs_buf_t *bp)
+libxfs_buf_relse(
+ struct xfs_buf *bp)
{
/*
* ensure that any errors on this use of the buffer don't carry
bp->b_error = 0;
bp->b_flags &= ~LIBXFS_B_STALE;
bp->b_flags |= (LIBXFS_B_DIRTY | flags);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 0;
}
error2 = libxfs_writebufr(bp);
if (!error)
error = error2;
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
return error;
ASSERT(bp->b_transp == tp);
if (!tp) {
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return;
}
xfs_buf_item_put(bip);
bp->b_transp = NULL;
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
/*
if (error) {
fprintf(stderr, _("%s: warning - iflush_int failed (%d)\n"),
progname, error);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto free;
}
xfs_buf_item_put(bip);
if (hold)
return;
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
static void
bip->bli_flags &= ~XFS_BLI_HOLD;
xfs_buf_item_put(bip);
if (!hold)
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
static void
if (bp->b_error == -EFSBADCRC || bp->b_error == -EFSCORRUPTED) {
do_warn(
_("Corrupt remote block for attributes of inode %" PRIu64 "\n"), ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
clearit = 1;
break;
}
amountdone += length;
value += length;
i++;
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
return (clearit);
}
do_warn(
_("bad attribute leaf magic %#x for inode %" PRIu64 "\n"),
leafhdr.magic, ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto error_out;
}
if (process_leaf_attr_block(mp, leaf, da_bno, ino,
da_cursor->blkmap, current_hashval,
&greatest_hashval, &repair)) {
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto error_out;
}
do_warn(
_("bad sibling back pointer for block %u in attribute fork for inode %" PRIu64 "\n"),
da_bno, ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto error_out;
}
if (da_bno != 0) {
if (verify_da_path(mp, da_cursor, 0, XFS_ATTR_FORK)) {
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto error_out;
}
}
if (repair && !no_modify)
libxfs_writebuf(bp, 0);
else
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
} while (da_bno != 0);
if (verify_final_da_path(mp, da_cursor, 0, XFS_ATTR_FORK)) {
if (badness) {
*repair = 0;
/* the block is bad. lose the attribute fork. */
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
if (*repair && !no_modify)
libxfs_writebuf(bp, 0);
else
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 0;
}
*repair = 1;
libxfs_writebuf(bp, 0);
} else
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
error = process_node_attr(mp, ino, dip, blkmap); /* + repair */
if (error)
*repair = 0;
/* is this block sane? */
if (__check_attr_header(mp, bp, ino)) {
*repair = 0;
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
do_warn(
_("bad attribute leaf magic # %#x for dir ino %" PRIu64 "\n"),
be16_to_cpu(info->magic), ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
*repair = 0;
return 1;
}
da_cursor->ino, bno);
}
*rbno = 0;
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
_("bad %s magic number 0x%x in inode %" PRIu64 " bno = %u\n"),
FORKNAME(whichfork), nodehdr.magic,
da_cursor->ino, bno);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto error_out;
}
/* corrupt node; rebuild the dir. */
if (bp->b_error == -EFSBADCRC || bp->b_error == -EFSCORRUPTED) {
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
do_warn(
_("corrupt %s tree block %u for inode %" PRIu64 "\n"),
FORKNAME(whichfork), bno, da_cursor->ino);
_("bad %s record count in inode %" PRIu64 ", count = %d, max = %d\n"),
FORKNAME(whichfork), da_cursor->ino,
nodehdr.count, geo->node_ents);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto error_out;
}
do_warn(
_("bad header depth for directory inode %" PRIu64 "\n"),
da_cursor->ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
i = -1;
goto error_out;
}
do_warn(
_("bad %s btree for inode %" PRIu64 "\n"),
FORKNAME(whichfork), da_cursor->ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto error_out;
}
}
error_out:
while (i > 1 && i <= da_cursor->active) {
- libxfs_putbuf(da_cursor->level[i].bp);
+ libxfs_buf_relse(da_cursor->level[i].bp);
i++;
}
}
ASSERT(error != 0);
- libxfs_putbuf(cursor->level[level].bp);
+ libxfs_buf_relse(cursor->level[level].bp);
cursor->level[level].bp = NULL;
}
if (cursor->level[this_level].dirty && !no_modify)
libxfs_writebuf(cursor->level[this_level].bp, 0);
else
- libxfs_putbuf(cursor->level[this_level].bp);
+ libxfs_buf_relse(cursor->level[this_level].bp);
cursor->level[this_level].bp = NULL;
#ifdef XR_DIR_TRACE
fprintf(stderr, "verify_da_path returns 1 (bad) #4\n");
#endif
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
if (cursor->level[this_level].dirty && !no_modify)
libxfs_writebuf(cursor->level[this_level].bp, 0);
else
- libxfs_putbuf(cursor->level[this_level].bp);
+ libxfs_buf_relse(cursor->level[this_level].bp);
/* switch cursor to point at the new buffer we just read */
cursor->level[this_level].bp = bp;
if (cnt)
bp->b_ops = &xfs_inode_buf_ops;
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return(cnt);
}
M_IGEO(mp)->blocks_per_cluster));
while (bp_index > 0) {
bp_index--;
- libxfs_putbuf(bplist[bp_index]);
+ libxfs_buf_relse(bplist[bp_index]);
}
free(bplist);
return(1);
*bogus = 1;
for (bp_index = 0; bp_index < cluster_count; bp_index++)
if (bplist[bp_index])
- libxfs_putbuf(bplist[bp_index]);
+ libxfs_buf_relse(bplist[bp_index]);
free(bplist);
return(0);
}
if (dirty && !no_modify)
libxfs_writebuf(bplist[bp_index], 0);
else
- libxfs_putbuf(bplist[bp_index]);
+ libxfs_buf_relse(bplist[bp_index]);
}
free(bplist);
break;
if (writebuf && !no_modify)
libxfs_writebuf(bp, 0);
else
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
return 0;
}
do_warn(
_("Corrupt symlink remote block %" PRIu64 ", inode %" PRIu64 ".\n"),
fsbno, lino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
if (bp->b_error == -EFSBADCRC) {
do_warn(
_("bad symlink header ino %" PRIu64 ", file block %d, disk block %" PRIu64 "\n"),
lino, i, fsbno);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
src += sizeof(struct xfs_dsymlink_hdr);
if (badcrc && !no_modify)
libxfs_writebuf(bp, 0);
else
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
return 0;
}
*repair = 1;
libxfs_writebuf(bp, 0);
} else
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return rval;
}
do_warn(
_("bad directory leaf magic # %#x for directory inode %" PRIu64 " block %u\n"),
leafhdr.magic, ino, da_bno);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto error_out;
}
buf_dirty = 0;
*/
if (process_leaf_block_dir2(mp, leaf, da_bno, ino,
current_hashval, &greatest_hashval)) {
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto error_out;
}
/*
do_warn(
_("bad sibling back pointer for block %u in directory inode %" PRIu64 "\n"),
da_bno, ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto error_out;
}
prev_bno = da_bno;
da_bno = leafhdr.forw;
if (da_bno != 0) {
if (verify_da_path(mp, da_cursor, 0, XFS_DATA_FORK)) {
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
goto error_out;
}
}
*repair = 1;
libxfs_writebuf(bp, 0);
} else
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
} while (da_bno != 0);
if (verify_final_da_path(mp, da_cursor, 0, XFS_DATA_FORK)) {
/*
*repair = 1;
libxfs_writebuf(bp, 0);
} else
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
if (good == 0)
return 1;
if (agi_dirty)
libxfs_writebuf(bp, 0);
else
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
static void
dir2_kill_block(mp, ip, da_bno, bp);
} else {
do_warn(_("would junk block\n"));
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
freetab->ents[db].v = NULLDATAOFF;
*bpp = NULL;
do_warn(
_("leaf block %u for directory inode %" PRIu64 " bad header\n"),
da_bno, ip->i_ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
if (leafhdr.magic == XFS_DIR3_LEAF1_MAGIC) {
error = check_da3_header(mp, bp, ip->i_ino);
if (error) {
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return error;
}
}
seeval = dir_hash_see_all(hashtab, ents, leafhdr.count, leafhdr.stale);
if (dir_hash_check(hashtab, ip, seeval)) {
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
badtail = freetab->nents != be32_to_cpu(ltp->bestcount);
do_warn(
_("leaf block %u for directory inode %" PRIu64 " bad tail\n"),
da_bno, ip->i_ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return fixit;
}
do_warn(
_("unknown magic number %#x for block %u in directory inode %" PRIu64 "\n"),
leafhdr.magic, da_bno, ip->i_ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
leafhdr.magic == XFS_DA3_NODE_MAGIC) {
error = check_da3_header(mp, bp, ip->i_ino);
if (error) {
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return error;
}
}
/* ignore nodes */
if (leafhdr.magic == XFS_DA_NODE_MAGIC ||
leafhdr.magic == XFS_DA3_NODE_MAGIC) {
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
continue;
}
do_warn(
_("leaf block %u for directory inode %" PRIu64 " bad header\n"),
da_bno, ip->i_ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
seeval = dir_hash_see_all(hashtab, ents,
leafhdr.count, leafhdr.stale);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
if (seeval != DIR_HASH_CK_OK)
return 1;
}
do_warn(
_("free block %u for directory inode %" PRIu64 " bad header\n"),
da_bno, ip->i_ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
if (freehdr.magic == XFS_DIR3_FREE_MAGIC) {
error = check_dir3_header(mp, bp, ip->i_ino);
if (error) {
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return error;
}
}
do_warn(
_("free block %u entry %i for directory ino %" PRIu64 " bad\n"),
da_bno, i, ip->i_ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
used += be16_to_cpu(bests[i]) != NULLDATAOFF;
do_warn(
_("free block %u for directory inode %" PRIu64 " bad nused\n"),
da_bno, ip->i_ino);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 1;
}
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
for (i = 0; i < freetab->nents; i++) {
if ((freetab->ents[i].s == 0) &&
dir_hash_dup_names(hashtab);
for (i = 0; i < num_bps; i++)
if (bplist[i])
- libxfs_putbuf(bplist[i]);
+ libxfs_buf_relse(bplist[i]);
longform_dir2_rebuild(mp, ino, ip, irec, ino_offset, hashtab);
*num_illegal = 0;
*need_dot = 0;
} else {
for (i = 0; i < num_bps; i++)
if (bplist[i])
- libxfs_putbuf(bplist[i]);
+ libxfs_buf_relse(bplist[i]);
}
free(bplist);
pf_read_inode_dirs(args, bp);
XFS_BUF_SET_PRIORITY(bp, XFS_BUF_PRIORITY(bp) +
CACHE_PREFETCH_PRIORITY);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return;
}
XFS_BUF_SET_PRIORITY(bp, flag);
*/
if (bp->b_error) {
bp->b_flags |= LIBXFS_B_UNCHECKED;
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return 0;
}
rc = (*func)(XFS_BUF_TO_BLOCK(bp), level - 1, isadir, args);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return rc;
}
if ((bplist[num - 1]->b_flags & LIBXFS_B_DISCONTIG)) {
libxfs_readbufr_map(mp->m_ddev_targp, bplist[num - 1], 0);
bplist[num - 1]->b_flags |= LIBXFS_B_UNCHECKED;
- libxfs_putbuf(bplist[num - 1]);
+ libxfs_buf_relse(bplist[num - 1]);
num--;
}
B_IS_INODE(XFS_BUF_PRIORITY(bplist[i])) ? 'I' : 'M',
bplist[i], (long long)XFS_BUF_ADDR(bplist[i]),
args->agno);
- libxfs_putbuf(bplist[i]);
+ libxfs_buf_relse(bplist[i]);
}
pthread_mutex_lock(&args->lock);
if (which != PF_SECONDARY) {
}
b++;
}
- libxfs_putbuf(agflbp);
+ libxfs_buf_relse(agflbp);
agflbp = NULL;
bitmap_free(&own_ag_bitmap);
free_slab_cursor(&rm_cur);
err:
if (agflbp)
- libxfs_putbuf(agflbp);
+ libxfs_buf_relse(agflbp);
if (own_ag_bitmap)
bitmap_free(&own_ag_bitmap);
return error;
if (bt_cur)
libxfs_btree_del_cursor(bt_cur, XFS_BTREE_NOERROR);
if (agbp)
- libxfs_putbuf(agbp);
+ libxfs_buf_relse(agbp);
free_slab_cursor(&rm_cur);
return 0;
}
libxfs_btree_del_cursor(bt_cur, error ? XFS_BTREE_ERROR :
XFS_BTREE_NOERROR);
if (agbp)
- libxfs_putbuf(agbp);
+ libxfs_buf_relse(agbp);
free_slab_cursor(&rl_cur);
return 0;
}
prevbit = 0;
}
}
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
if (extno == mp->m_sb.sb_rextents)
break;
}
bytes = bp->b_un.b_addr;
memmove((char *)sumfile + sumbno * mp->m_sb.sb_blocksize, bytes,
mp->m_sb.sb_blocksize);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
}
#endif
(*func)(XFS_BUF_TO_BLOCK(bp), nlevels - 1, root, agno, suspect,
isroot, magic, priv, ops);
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
}
/*
if ((dirty || badcrc) && !no_modify)
libxfs_writebuf(bp, 0);
else
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
return(err);
}
agcnts->fdblocks += state.count;
- libxfs_putbuf(agflbuf);
+ libxfs_buf_relse(agflbuf);
}
static void
if (agi_dirty && !no_modify)
libxfs_writebuf(agibuf, 0);
else
- libxfs_putbuf(agibuf);
+ libxfs_buf_relse(agibuf);
if (agf_dirty && !no_modify)
libxfs_writebuf(agfbuf, 0);
else
- libxfs_putbuf(agfbuf);
+ libxfs_buf_relse(agfbuf);
if (sb_dirty && !no_modify) {
if (agno == 0)
libxfs_sb_to_disk(XFS_BUF_TO_SBP(sbbuf), sb);
libxfs_writebuf(sbbuf, 0);
} else
- libxfs_putbuf(sbbuf);
+ libxfs_buf_relse(sbbuf);
free(sb);
PROG_RPT_INC(prog_rpt_done[agno], 1);
return;
out_free_agibuf:
- libxfs_putbuf(agibuf);
+ libxfs_buf_relse(agibuf);
out_free_agfbuf:
- libxfs_putbuf(agfbuf);
+ libxfs_buf_relse(agfbuf);
out_free_sbbuf:
- libxfs_putbuf(sbbuf);
+ libxfs_buf_relse(sbbuf);
out_free_sb:
free(sb);
if (error)
continue;
libxfs_sb_from_disk(&sb, XFS_BUF_TO_SBP(bp));
- libxfs_putbuf(bp);
+ libxfs_buf_relse(bp);
calc_rootino = libxfs_ialloc_calc_rootino(mp, sb.sb_unit);
if (calc_rootino == mp->m_sb.sb_rootino)