[thirdparty/xfsprogs-dev.git] / db / faddr.c

/*
 * Copyright (c) 2000-2001,2004-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <xfs/libxfs.h>
#include "type.h"
#include "fprint.h"
#include "faddr.h"
#include "field.h"
#include "inode.h"
#include "io.h"
#include "bit.h"
#include "bmap.h"
#include "output.h"
#include "init.h"

void
fa_agblock(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	xfs_agblock_t	bno;

	if (cur_agno == NULLAGNUMBER) {
		dbprintf("no current allocation group, cannot set new addr\n");
		return;
	}
	bno = (xfs_agblock_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	if (bno == NULLAGBLOCK) {
		dbprintf("null block number, cannot set new addr\n");
		return;
	}
	ASSERT(typtab[next].typnm == next);
	set_cur(&typtab[next], XFS_AGB_TO_DADDR(mp, cur_agno, bno), blkbb,
		DB_RING_ADD, NULL);
}

/*ARGSUSED*/
void
fa_agino(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	xfs_agino_t	agino;

	if (cur_agno == NULLAGNUMBER) {
		dbprintf("no current allocation group, cannot set new addr\n");
		return;
	}
	agino = (xfs_agino_t)getbitval(obj, bit, bitsz(agino), BVUNSIGNED);
	if (agino == NULLAGINO) {
		dbprintf("null inode number, cannot set new addr\n");
		return;
	}
	set_cur_inode(XFS_AGINO_TO_INO(mp, cur_agno, agino));
}

/*ARGSUSED*/
void
fa_attrblock(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	bmap_ext_t	bm;
	__uint32_t	bno;
	xfs_dfsbno_t	dfsbno;
	int		nex;

	bno = (__uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	if (bno == 0) {
		dbprintf("null attribute block number, cannot set new addr\n");
		return;
	}
	nex = 1;
	bmap(bno, 1, XFS_ATTR_FORK, &nex, &bm);
	if (nex == 0) {
		dbprintf("attribute block is unmapped\n");
		return;
	}
	dfsbno = bm.startblock + (bno - bm.startoff);
	ASSERT(typtab[next].typnm == next);
	set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), blkbb,
		DB_RING_ADD, NULL);
}

void
fa_cfileoffa(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	bmap_ext_t	bm;
	xfs_dfiloff_t	bno;
	xfs_dfsbno_t	dfsbno;
	int		nex;

	bno = (xfs_dfiloff_t)getbitval(obj, bit, BMBT_STARTOFF_BITLEN,
		BVUNSIGNED);
	if (bno == NULLDFILOFF) {
		dbprintf("null block number, cannot set new addr\n");
		return;
	}
	nex = 1;
	bmap(bno, 1, XFS_ATTR_FORK, &nex, &bm);
	if (nex == 0) {
		dbprintf("file block is unmapped\n");
		return;
	}
	dfsbno = bm.startblock + (bno - bm.startoff);
	ASSERT(typtab[next].typnm == next);
	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, dfsbno), blkbb, DB_RING_ADD,
		NULL);
}

void
fa_cfileoffd(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	bbmap_t		bbmap;
	bmap_ext_t	*bmp;
	xfs_dfiloff_t	bno;
	xfs_dfsbno_t	dfsbno;
	int		nb;
	int		nex;

	bno = (xfs_dfiloff_t)getbitval(obj, bit, BMBT_STARTOFF_BITLEN,
		BVUNSIGNED);
	if (bno == NULLDFILOFF) {
		dbprintf("null block number, cannot set new addr\n");
		return;
	}
	nex = nb = next == TYP_DIR2 ? mp->m_dirblkfsbs : 1;
	bmp = malloc(nb * sizeof(*bmp));
	bmap(bno, nb, XFS_DATA_FORK, &nex, bmp);
	if (nex == 0) {
		dbprintf("file block is unmapped\n");
		free(bmp);
		return;
	}
	dfsbno = bmp->startblock + (bno - bmp->startoff);
	ASSERT(typtab[next].typnm == next);
	if (nex > 1)
		make_bbmap(&bbmap, nex, bmp);
	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, dfsbno), nb * blkbb,
		DB_RING_ADD, nex > 1 ? &bbmap: NULL);
	free(bmp);
}

void
fa_cfsblock(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	xfs_dfsbno_t	bno;
	int		nb;

	bno = (xfs_dfsbno_t)getbitval(obj, bit, BMBT_STARTBLOCK_BITLEN,
		BVUNSIGNED);
	if (bno == NULLDFSBNO) {
		dbprintf("null block number, cannot set new addr\n");
		return;
	}
	nb = next == TYP_DIR2 ? mp->m_dirblkfsbs : 1;
	ASSERT(typtab[next].typnm == next);
	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, bno), nb * blkbb,
		DB_RING_ADD, NULL);
}

void
fa_dfiloffa(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	bmap_ext_t	bm;
	xfs_dfiloff_t	bno;
	xfs_dfsbno_t	dfsbno;
	int		nex;

	bno = (xfs_dfiloff_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	if (bno == NULLDFILOFF) {
		dbprintf("null block number, cannot set new addr\n");
		return;
	}
	nex = 1;
	bmap(bno, 1, XFS_ATTR_FORK, &nex, &bm);
	if (nex == 0) {
		dbprintf("file block is unmapped\n");
		return;
	}
	dfsbno = bm.startblock + (bno - bm.startoff);
	ASSERT(typtab[next].typnm == next);
	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, dfsbno), blkbb, DB_RING_ADD,
		NULL);
}

void
fa_dfiloffd(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	bbmap_t		bbmap;
	bmap_ext_t	*bmp;
	xfs_dfiloff_t	bno;
	xfs_dfsbno_t	dfsbno;
	int		nb;
	int		nex;

	bno = (xfs_dfiloff_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	if (bno == NULLDFILOFF) {
		dbprintf("null block number, cannot set new addr\n");
		return;
	}
	nex = nb = next == TYP_DIR2 ? mp->m_dirblkfsbs : 1;
	bmp = malloc(nb * sizeof(*bmp));
	bmap(bno, nb, XFS_DATA_FORK, &nex, bmp);
	if (nex == 0) {
		dbprintf("file block is unmapped\n");
		free(bmp);
		return;
	}
	dfsbno = bmp->startblock + (bno - bmp->startoff);
	ASSERT(typtab[next].typnm == next);
	if (nex > 1)
		make_bbmap(&bbmap, nex, bmp);
	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, dfsbno), nb * blkbb,
		DB_RING_ADD, nex > 1 ? &bbmap : NULL);
	free(bmp);
}

void
fa_dfsbno(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	xfs_dfsbno_t	bno;

	bno = (xfs_dfsbno_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	if (bno == NULLDFSBNO) {
		dbprintf("null block number, cannot set new addr\n");
		return;
	}
	ASSERT(typtab[next].typnm == next);
	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, bno), blkbb, DB_RING_ADD,
		NULL);
}

/*ARGSUSED*/
void
fa_dirblock(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	bbmap_t		bbmap;
	bmap_ext_t	*bmp;
	__uint32_t	bno;
	xfs_dfsbno_t	dfsbno;
	int		nex;

	bno = (__uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	if (bno == 0) {
		dbprintf("null directory block number, cannot set new addr\n");
		return;
	}
	nex = mp->m_dirblkfsbs;
	bmp = malloc(nex * sizeof(*bmp));
	bmap(bno, mp->m_dirblkfsbs, XFS_DATA_FORK, &nex, bmp);
	if (nex == 0) {
		dbprintf("directory block is unmapped\n");
		free(bmp);
		return;
	}
	dfsbno = bmp->startblock + (bno - bmp->startoff);
	ASSERT(typtab[next].typnm == next);
	if (nex > 1)
		make_bbmap(&bbmap, nex, bmp);
	set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno),
		XFS_FSB_TO_BB(mp, mp->m_dirblkfsbs), DB_RING_ADD,
		nex > 1 ? &bbmap : NULL);
	free(bmp);
}

void
fa_drfsbno(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	xfs_drfsbno_t	bno;

	bno = (xfs_drfsbno_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	if (bno == NULLDRFSBNO) {
		dbprintf("null block number, cannot set new addr\n");
		return;
	}
	ASSERT(typtab[next].typnm == next);
	set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_BB(mp, bno), blkbb,
		DB_RING_ADD, NULL);
}

/*ARGSUSED*/
void
fa_drtbno(
	void	*obj,
	int	bit,
	typnm_t	next)
{
	xfs_drtbno_t	bno;

	bno = (xfs_drtbno_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	if (bno == NULLDRTBNO) {
		dbprintf("null block number, cannot set new addr\n");
		return;
	}
	/* need set_cur to understand rt subvolume */
}

/*ARGSUSED*/
void
fa_ino(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	xfs_ino_t	ino;

	ASSERT(next == TYP_INODE);
	ino = (xfs_ino_t)getbitval(obj, bit, bitsz(ino), BVUNSIGNED);
	if (ino == NULLFSINO) {
		dbprintf("null inode number, cannot set new addr\n");
		return;
	}
	set_cur_inode(ino);
}

void
fa_ino4(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	xfs_ino_t	ino;
	xfs_dir2_ino4_t	ino4;

	ASSERT(next == TYP_INODE);
	ino = (xfs_ino_t)getbitval(obj, bit, bitsz(ino4), BVUNSIGNED);
	if (ino == NULLFSINO) {
		dbprintf("null inode number, cannot set new addr\n");
		return;
	}
	set_cur_inode(ino);
}

void
fa_ino8(
	void		*obj,
	int		bit,
	typnm_t		next)
{
	xfs_ino_t	ino;
	xfs_dir2_ino8_t	ino8;

	ASSERT(next == TYP_INODE);
	ino = (xfs_ino_t)getbitval(obj, bit, bitsz(ino8), BVUNSIGNED);
	if (ino == NULLFSINO) {
		dbprintf("null inode number, cannot set new addr\n");
		return;
	}
	set_cur_inode(ino);
}
Commit	Line	Data
2bd0ea18	1	/*
da23017d NS	2	* Copyright (c) 2000-2001,2004-2005 Silicon Graphics, Inc.
da23017d NS	3	* All Rights Reserved.
dfc130f3	4	*
da23017d NS	5	* This program is free software; you can redistribute it and/or
da23017d NS	6	* modify it under the terms of the GNU General Public License as
2bd0ea18	7	* published by the Free Software Foundation.
dfc130f3	8	*
da23017d NS	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
dfc130f3	13	*
da23017d NS	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2bd0ea18 NS	17	*/
2bd0ea18 NS	18
1d7e80ee	19	#include <xfs/libxfs.h>
2bd0ea18	20	#include "type.h"
128efca1	21	#include "fprint.h"
2bd0ea18	22	#include "faddr.h"
128efca1	23	#include "field.h"
2bd0ea18 NS	24	#include "inode.h"
	25	#include "io.h"
	26	#include "bit.h"
	27	#include "bmap.h"
	28	#include "output.h"
4ca431fc	29	#include "init.h"
2bd0ea18 NS	30
	31	void
	32	fa_agblock(
	33	void *obj,
	34	int bit,
	35	typnm_t next)
	36	{
	37	xfs_agblock_t bno;
	38
	39	if (cur_agno == NULLAGNUMBER) {
	40	dbprintf("no current allocation group, cannot set new addr\n");
	41	return;
	42	}
	43	bno = (xfs_agblock_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	44	if (bno == NULLAGBLOCK) {
	45	dbprintf("null block number, cannot set new addr\n");
	46	return;
	47	}
	48	ASSERT(typtab[next].typnm == next);
	49	set_cur(&typtab[next], XFS_AGB_TO_DADDR(mp, cur_agno, bno), blkbb,
	50	DB_RING_ADD, NULL);
	51	}
	52
	53	/ARGSUSED/
	54	void
	55	fa_agino(
	56	void *obj,
	57	int bit,
	58	typnm_t next)
	59	{
	60	xfs_agino_t agino;
	61
	62	if (cur_agno == NULLAGNUMBER) {
	63	dbprintf("no current allocation group, cannot set new addr\n");
	64	return;
	65	}
	66	agino = (xfs_agino_t)getbitval(obj, bit, bitsz(agino), BVUNSIGNED);
	67	if (agino == NULLAGINO) {
	68	dbprintf("null inode number, cannot set new addr\n");
	69	return;
	70	}
	71	set_cur_inode(XFS_AGINO_TO_INO(mp, cur_agno, agino));
	72	}
	73
	74	/ARGSUSED/
	75	void
	76	fa_attrblock(
	77	void *obj,
	78	int bit,
	79	typnm_t next)
	80	{
	81	bmap_ext_t bm;
	82	__uint32_t bno;
	83	xfs_dfsbno_t dfsbno;
	84	int nex;
	85
	86	bno = (__uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	87	if (bno == 0) {
	88	dbprintf("null attribute block number, cannot set new addr\n");
	89	return;
	90	}
	91	nex = 1;
	92	bmap(bno, 1, XFS_ATTR_FORK, &nex, &bm);
	93	if (nex == 0) {
94	dbprintf("attribute block is unmapped\n");
95	return;
96	}
97	dfsbno = bm.startblock + (bno - bm.startoff);
98	ASSERT(typtab[next].typnm == next);
99	set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), blkbb,
100	DB_RING_ADD, NULL);
101	}
102
103	void
104	fa_cfileoffa(
105	void *obj,
106	int bit,
107	typnm_t next)
108	{
109	bmap_ext_t bm;
110	xfs_dfiloff_t bno;
111	xfs_dfsbno_t dfsbno;
112	int nex;
113
114	bno = (xfs_dfiloff_t)getbitval(obj, bit, BMBT_STARTOFF_BITLEN,
115	BVUNSIGNED);
116	if (bno == NULLDFILOFF) {
117	dbprintf("null block number, cannot set new addr\n");
118	return;
119	}
120	nex = 1;
121	bmap(bno, 1, XFS_ATTR_FORK, &nex, &bm);
122	if (nex == 0) {
123	dbprintf("file block is unmapped\n");
124	return;
125	}
126	dfsbno = bm.startblock + (bno - bm.startoff);
127	ASSERT(typtab[next].typnm == next);
128	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, dfsbno), blkbb, DB_RING_ADD,
129	NULL);
130	}
131
132	void
133	fa_cfileoffd(
134	void *obj,
135	int bit,
136	typnm_t next)
137	{
138	bbmap_t bbmap;
139	bmap_ext_t *bmp;
140	xfs_dfiloff_t bno;
141	xfs_dfsbno_t dfsbno;
142	int nb;
143	int nex;
144
145	bno = (xfs_dfiloff_t)getbitval(obj, bit, BMBT_STARTOFF_BITLEN,
146	BVUNSIGNED);
147	if (bno == NULLDFILOFF) {
148	dbprintf("null block number, cannot set new addr\n");
149	return;
150	}
151	nex = nb = next == TYP_DIR2 ? mp->m_dirblkfsbs : 1;
152	bmp = malloc(nb * sizeof(*bmp));
153	bmap(bno, nb, XFS_DATA_FORK, &nex, bmp);
154	if (nex == 0) {
155	dbprintf("file block is unmapped\n");
156	free(bmp);
157	return;
158	}
159	dfsbno = bmp->startblock + (bno - bmp->startoff);
160	ASSERT(typtab[next].typnm == next);
161	if (nex > 1)
162	make_bbmap(&bbmap, nex, bmp);
163	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, dfsbno), nb * blkbb,
164	DB_RING_ADD, nex > 1 ? &bbmap: NULL);
165	free(bmp);
166	}
167
168	void
169	fa_cfsblock(
170	void *obj,
171	int bit,
172	typnm_t next)
173	{
174	xfs_dfsbno_t bno;
cbead9df	175	int nb;
2bd0ea18 NS	176
	177	bno = (xfs_dfsbno_t)getbitval(obj, bit, BMBT_STARTBLOCK_BITLEN,
	178	BVUNSIGNED);
	179	if (bno == NULLDFSBNO) {
	180	dbprintf("null block number, cannot set new addr\n");
	181	return;
	182	}
cbead9df	183	nb = next == TYP_DIR2 ? mp->m_dirblkfsbs : 1;
2bd0ea18	184	ASSERT(typtab[next].typnm == next);
cbead9df NS	185	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, bno), nb * blkbb,
cbead9df NS	186	DB_RING_ADD, NULL);
2bd0ea18 NS	187	}
	188
	189	void
	190	fa_dfiloffa(
	191	void *obj,
	192	int bit,
	193	typnm_t next)
	194	{
	195	bmap_ext_t bm;
	196	xfs_dfiloff_t bno;
	197	xfs_dfsbno_t dfsbno;
	198	int nex;
	199
	200	bno = (xfs_dfiloff_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	201	if (bno == NULLDFILOFF) {
	202	dbprintf("null block number, cannot set new addr\n");
	203	return;
	204	}
	205	nex = 1;
	206	bmap(bno, 1, XFS_ATTR_FORK, &nex, &bm);
	207	if (nex == 0) {
	208	dbprintf("file block is unmapped\n");
	209	return;
	210	}
	211	dfsbno = bm.startblock + (bno - bm.startoff);
	212	ASSERT(typtab[next].typnm == next);
	213	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, dfsbno), blkbb, DB_RING_ADD,
	214	NULL);
	215	}
	216
	217	void
	218	fa_dfiloffd(
	219	void *obj,
	220	int bit,
	221	typnm_t next)
	222	{
	223	bbmap_t bbmap;
	224	bmap_ext_t *bmp;
	225	xfs_dfiloff_t bno;
	226	xfs_dfsbno_t dfsbno;
	227	int nb;
	228	int nex;
	229
	230	bno = (xfs_dfiloff_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	231	if (bno == NULLDFILOFF) {
	232	dbprintf("null block number, cannot set new addr\n");
	233	return;
	234	}
	235	nex = nb = next == TYP_DIR2 ? mp->m_dirblkfsbs : 1;
	236	bmp = malloc(nb * sizeof(*bmp));
	237	bmap(bno, nb, XFS_DATA_FORK, &nex, bmp);
	238	if (nex == 0) {
	239	dbprintf("file block is unmapped\n");
	240	free(bmp);
	241	return;
	242	}
	243	dfsbno = bmp->startblock + (bno - bmp->startoff);
	244	ASSERT(typtab[next].typnm == next);
	245	if (nex > 1)
	246	make_bbmap(&bbmap, nex, bmp);
	247	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, dfsbno), nb * blkbb,
	248	DB_RING_ADD, nex > 1 ? &bbmap : NULL);
	249	free(bmp);
	250	}
251
252	void
253	fa_dfsbno(
254	void *obj,
255	int bit,
256	typnm_t next)
257	{
258	xfs_dfsbno_t bno;
259
260	bno = (xfs_dfsbno_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
261	if (bno == NULLDFSBNO) {
262	dbprintf("null block number, cannot set new addr\n");
263	return;
264	}
265	ASSERT(typtab[next].typnm == next);
266	set_cur(&typtab[next], XFS_FSB_TO_DADDR(mp, bno), blkbb, DB_RING_ADD,
267	NULL);
268	}
269
270	/ARGSUSED/
271	void
272	fa_dirblock(
273	void *obj,
274	int bit,
275	typnm_t next)
276	{
277	bbmap_t bbmap;
278	bmap_ext_t *bmp;
279	__uint32_t bno;
280	xfs_dfsbno_t dfsbno;
281	int nex;
282
283	bno = (__uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
284	if (bno == 0) {
285	dbprintf("null directory block number, cannot set new addr\n");
286	return;
287	}
288	nex = mp->m_dirblkfsbs;
289	bmp = malloc(nex * sizeof(*bmp));
290	bmap(bno, mp->m_dirblkfsbs, XFS_DATA_FORK, &nex, bmp);
291	if (nex == 0) {
292	dbprintf("directory block is unmapped\n");
293	free(bmp);
294	return;
295	}
296	dfsbno = bmp->startblock + (bno - bmp->startoff);
297	ASSERT(typtab[next].typnm == next);
298	if (nex > 1)
299	make_bbmap(&bbmap, nex, bmp);
300	set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno),
dfc130f3	301	XFS_FSB_TO_BB(mp, mp->m_dirblkfsbs), DB_RING_ADD,
2bd0ea18 NS	302	nex > 1 ? &bbmap : NULL);
	303	free(bmp);
	304	}
	305
	306	void
	307	fa_drfsbno(
	308	void *obj,
	309	int bit,
	310	typnm_t next)
	311	{
	312	xfs_drfsbno_t bno;
	313
	314	bno = (xfs_drfsbno_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	315	if (bno == NULLDRFSBNO) {
	316	dbprintf("null block number, cannot set new addr\n");
	317	return;
	318	}
	319	ASSERT(typtab[next].typnm == next);
	320	set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_BB(mp, bno), blkbb,
	321	DB_RING_ADD, NULL);
	322	}
	323
	324	/ARGSUSED/
	325	void
	326	fa_drtbno(
	327	void *obj,
	328	int bit,
	329	typnm_t next)
	330	{
	331	xfs_drtbno_t bno;
	332
	333	bno = (xfs_drtbno_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
	334	if (bno == NULLDRTBNO) {
	335	dbprintf("null block number, cannot set new addr\n");
	336	return;
	337	}
	338	/* need set_cur to understand rt subvolume */
	339	}
	340
	341	/ARGSUSED/
	342	void
	343	fa_ino(
	344	void *obj,
	345	int bit,
	346	typnm_t next)
	347	{
	348	xfs_ino_t ino;
	349
	350	ASSERT(next == TYP_INODE);
	351	ino = (xfs_ino_t)getbitval(obj, bit, bitsz(ino), BVUNSIGNED);
	352	if (ino == NULLFSINO) {
	353	dbprintf("null inode number, cannot set new addr\n");
	354	return;
	355	}
	356	set_cur_inode(ino);
	357	}
	358
	359	void
	360	fa_ino4(
	361	void *obj,
	362	int bit,
	363	typnm_t next)
	364	{
	365	xfs_ino_t ino;
366	xfs_dir2_ino4_t ino4;
367
368	ASSERT(next == TYP_INODE);
369	ino = (xfs_ino_t)getbitval(obj, bit, bitsz(ino4), BVUNSIGNED);
370	if (ino == NULLFSINO) {
371	dbprintf("null inode number, cannot set new addr\n");
372	return;
373	}
374	set_cur_inode(ino);
375	}
376
377	void
378	fa_ino8(
379	void *obj,
380	int bit,
381	typnm_t next)
382	{
383	xfs_ino_t ino;
384	xfs_dir2_ino8_t ino8;
385
386	ASSERT(next == TYP_INODE);
387	ino = (xfs_ino_t)getbitval(obj, bit, bitsz(ino8), BVUNSIGNED);
388	if (ino == NULLFSINO) {
389	dbprintf("null inode number, cannot set new addr\n");
390	return;
391	}
392	set_cur_inode(ino);
393	}