static void
scan_ag(
xfs_agnumber_t agno)
{
xfs_agf_t *agf;
xfs_agi_t *agi;
push_cur();
set_cur(&typtab[TYP_AGF],
XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
XFS_FSS_TO_BB(mp, 1), DB_RING_IGN, NULL);
if ((agf = iocur_top->data) == NULL) {
dbprintf(_("can't read agf block for ag %u\n"), agno);
pop_cur();
return;
}
push_cur();
set_cur(&typtab[TYP_AGI],
XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
XFS_FSS_TO_BB(mp, 1), DB_RING_IGN, NULL);
if ((agi = iocur_top->data) == NULL) {
dbprintf(_("can't read agi block for ag %u\n"), agno);
pop_cur();
pop_cur();
return;
}
scan_sbtree(agf, be32_to_cpu(agi->agi_root),
be32_to_cpu(agi->agi_level), scanfunc_ino, TYP_INOBT);
pop_cur();
pop_cur();
}
void
NavFn::initCost(int k, float v)
{
potarr[k] = v;
push_cur(k+1);
push_cur(k-1);
push_cur(k-nx);
push_cur(k+nx);
}
static int
get_sb(xfs_agnumber_t agno, xfs_sb_t *sb)
{
push_cur();
set_cur(&typtab[TYP_SB],
XFS_AG_DADDR(mp, agno, XFS_SB_DADDR),
XFS_FSS_TO_BB(mp, 1), DB_RING_IGN, NULL);
if (!iocur_top->data) {
dbprintf(_("can't read superblock for AG %u\n"), agno);
pop_cur();
return 0;
}
libxfs_sb_from_disk(sb, iocur_top->data);
if (sb->sb_magicnum != XFS_SB_MAGIC) {
dbprintf(_("bad sb magic # %#x in AG %u\n"),
sb->sb_magicnum, agno);
return 0;
}
if (!xfs_sb_good_version(sb)) {
dbprintf(_("bad sb version # %#x in AG %u\n"),
sb->sb_versionnum, agno);
return 0;
}
if (agno == 0 && sb->sb_inprogress != 0) {
dbprintf(_("mkfs not completed successfully\n"));
return 0;
}
return 1;
}
static int
get_sb(xfs_agnumber_t agno, xfs_sb_t *sb)
{
push_cur();
set_cur(&typtab[TYP_SB], XFS_AG_DADDR(mp, agno, XFS_SB_DADDR), 1,
DB_RING_IGN, NULL);
if (!iocur_top->data) {
dbprintf("can't read superblock for AG %u\n", agno);
pop_cur();
return 0;
}
libxfs_xlate_sb(iocur_top->data, sb, 1, ARCH_CONVERT, XFS_SB_ALL_BITS);
if (sb->sb_magicnum != XFS_SB_MAGIC) {
dbprintf("bad sb magic # %#x in AG %u\n",
sb->sb_magicnum, agno);
return 0;
}
if (!XFS_SB_GOOD_VERSION(sb)) {
dbprintf("bad sb version # %#x in AG %u\n",
sb->sb_versionnum, agno);
return 0;
}
if (agno == 0 && sb->sb_inprogress != 0) {
dbprintf("mkfs not completed successfully\n");
return 0;
}
return 1;
}
static void
scanfunc_ino(
struct xfs_btree_block *block,
int level,
xfs_agf_t *agf)
{
xfs_agino_t agino;
xfs_agnumber_t seqno = be32_to_cpu(agf->agf_seqno);
int i;
int j;
int off;
xfs_inobt_ptr_t *pp;
xfs_inobt_rec_t *rp;
if (level == 0) {
rp = XFS_INOBT_REC_ADDR(mp, block, 1);
for (i = 0; i < be16_to_cpu(block->bb_numrecs); i++) {
agino = be32_to_cpu(rp[i].ir_startino);
off = XFS_INO_TO_OFFSET(mp, agino);
push_cur();
set_cur(&typtab[TYP_INODE],
XFS_AGB_TO_DADDR(mp, seqno,
XFS_AGINO_TO_AGBNO(mp, agino)),
XFS_FSB_TO_BB(mp, XFS_IALLOC_BLOCKS(mp)),
DB_RING_IGN, NULL);
if (iocur_top->data == NULL) {
dbprintf(_("can't read inode block %u/%u\n"),
seqno, XFS_AGINO_TO_AGBNO(mp, agino));
continue;
}
for (j = 0; j < XFS_INODES_PER_CHUNK; j++) {
if (XFS_INOBT_IS_FREE_DISK(&rp[i], j))
continue;
process_inode(agf, agino + j, (xfs_dinode_t *)
((char *)iocur_top->data +
((off + j) << mp->m_sb.sb_inodelog)));
}
pop_cur();
}
return;
}
pp = XFS_INOBT_PTR_ADDR(mp, block, 1, mp->m_inobt_mxr[1]);
for (i = 0; i < be16_to_cpu(block->bb_numrecs); i++)
scan_sbtree(agf, be32_to_cpu(pp[i]), level, scanfunc_ino,
TYP_INOBT);
}
static void
scan_sbtree(
xfs_agf_t *agf,
xfs_agblock_t root,
int nlevels,
scan_sbtree_f_t func,
typnm_t btype)
{
xfs_agnumber_t seqno = be32_to_cpu(agf->agf_seqno);
push_cur();
set_cur(&typtab[btype], XFS_AGB_TO_DADDR(mp, seqno, root),
blkbb, DB_RING_IGN, NULL);
if (iocur_top->data == NULL) {
dbprintf(_("can't read btree block %u/%u\n"), seqno, root);
return;
}
(*func)(iocur_top->data, nlevels - 1, agf);
pop_cur();
}
static void
scan_lbtree(
xfs_fsblock_t root,
int nlevels,
scan_lbtree_f_t func,
extmap_t **extmapp,
typnm_t btype)
{
push_cur();
set_cur(&typtab[btype], XFS_FSB_TO_DADDR(mp, root), blkbb, DB_RING_IGN,
NULL);
if (iocur_top->data == NULL) {
dbprintf(_("can't read btree block %u/%u\n"),
XFS_FSB_TO_AGNO(mp, root),
XFS_FSB_TO_AGBNO(mp, root));
return;
}
(*func)(iocur_top->data, nlevels - 1, extmapp, btype);
pop_cur();
}
void
init(
int argc,
char **argv)
{
xfs_sb_t *sbp;
void *bufp = NULL;
int c;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
progname = basename(argv[0]);
while ((c = getopt(argc, argv, "c:fFip:rxVl:")) != EOF) {
switch (c) {
case 'c':
cmdline = xrealloc(cmdline, (ncmdline+1)*sizeof(char*));
cmdline[ncmdline++] = optarg;
break;
case 'f':
x.disfile = 1;
break;
case 'F':
force = 1;
break;
case 'i':
x.isreadonly = (LIBXFS_ISREADONLY|LIBXFS_ISINACTIVE);
break;
case 'p':
progname = optarg;
break;
case 'r':
x.isreadonly = LIBXFS_ISREADONLY;
break;
case 'l':
x.logname = optarg;
break;
case 'x':
expert_mode = 1;
break;
case 'V':
printf(_("%s version %s\n"), progname, VERSION);
exit(0);
case '?':
usage();
/*NOTREACHED*/
}
}
if (optind + 1 != argc) {
usage();
/*NOTREACHED*/
}
fsdevice = argv[optind];
if (!x.disfile)
x.volname = fsdevice;
else
x.dname = fsdevice;
if (!libxfs_init(&x)) {
fputs(_("\nfatal error -- couldn't initialize XFS library\n"),
stderr);
exit(1);
}
if (read_bbs(XFS_SB_DADDR, 1, &bufp, NULL)) {
fprintf(stderr, _("%s: %s is invalid (cannot read first 512 "
"bytes)\n"), progname, fsdevice);
exit(1);
}
/* copy SB from buffer to in-core, converting architecture as we go */
libxfs_sb_from_disk(&xmount.m_sb, bufp);
xfree(bufp);
sbp = &xmount.m_sb;
if (sbp->sb_magicnum != XFS_SB_MAGIC) {
fprintf(stderr, _("%s: %s is not a valid XFS filesystem (unexpected SB magic number 0x%08x)\n"),
progname, fsdevice, sbp->sb_magicnum);
if (!force)
exit(EXIT_FAILURE);
}
mp = libxfs_mount(&xmount, sbp, x.ddev, x.logdev, x.rtdev,
LIBXFS_MOUNT_ROOTINOS | LIBXFS_MOUNT_DEBUGGER);
if (!mp) {
mp = libxfs_mount(&xmount, sbp, x.ddev, x.logdev, x.rtdev,
LIBXFS_MOUNT_DEBUGGER);
if (!mp) {
fprintf(stderr, _("%s: device %s unusable (not an XFS "
"filesystem?)\n"), progname, fsdevice);
exit(1);
}
}
blkbb = 1 << mp->m_blkbb_log;
push_cur();
init_commands();
init_sig();
}
static int
dquot_f(
int argc,
char **argv)
{
bmap_ext_t bm;
int c;
int dogrp;
int doprj;
xfs_dqid_t id;
xfs_ino_t ino;
int nex;
char *p;
int perblock;
xfs_fileoff_t qbno;
int qoff;
char *s;
dogrp = doprj = optind = 0;
while ((c = getopt(argc, argv, "gpu")) != EOF) {
switch (c) {
case 'g':
dogrp = 1;
doprj = 0;
break;
case 'p':
doprj = 1;
dogrp = 0;
break;
case 'u':
dogrp = doprj = 0;
break;
default:
dbprintf(_("bad option for dquot command\n"));
return 0;
}
}
s = doprj ? _("project") : dogrp ? _("group") : _("user");
if (optind != argc - 1) {
dbprintf(_("dquot command requires one %s id argument\n"), s);
return 0;
}
ino = mp->m_sb.sb_uquotino;
if (doprj)
ino = mp->m_sb.sb_pquotino;
else if (dogrp)
ino = mp->m_sb.sb_gquotino;
if (ino == 0 || ino == NULLFSINO) {
dbprintf(_("no %s quota inode present\n"), s);
return 0;
}
id = (xfs_dqid_t)strtol(argv[optind], &p, 0);
if (*p != '\0') {
dbprintf(_("bad %s id for dquot %s\n"), s, argv[optind]);
return 0;
}
perblock = (int)(mp->m_sb.sb_blocksize / sizeof(xfs_dqblk_t));
qbno = (xfs_fileoff_t)id / perblock;
qoff = (int)(id % perblock);
push_cur();
set_cur_inode(ino);
nex = 1;
bmap(qbno, 1, XFS_DATA_FORK, &nex, &bm);
pop_cur();
if (nex == 0) {
dbprintf(_("no %s quota data for id %d\n"), s, id);
return 0;
}
set_cur(&typtab[TYP_DQBLK], XFS_FSB_TO_DADDR(mp, bm.startblock), blkbb,
DB_RING_IGN, NULL);
off_cur(qoff * (int)sizeof(xfs_dqblk_t), sizeof(xfs_dqblk_t));
ring_add();
return 0;
}
void
bmap(
xfs_dfiloff_t offset,
xfs_dfilblks_t len,
int whichfork,
int *nexp,
bmap_ext_t *bep)
{
struct xfs_btree_block *block;
xfs_fsblock_t bno;
xfs_dfiloff_t curoffset;
xfs_dinode_t *dip;
xfs_dfiloff_t eoffset;
xfs_bmbt_rec_64_t *ep;
xfs_dinode_fmt_t fmt;
int fsize;
xfs_bmbt_key_t *kp;
int n;
int nex;
xfs_fsblock_t nextbno;
int nextents;
xfs_bmbt_ptr_t *pp;
xfs_bmdr_block_t *rblock;
typnm_t typ;
xfs_bmbt_rec_64_t *xp;
push_cur();
set_cur_inode(iocur_top->ino);
nex = *nexp;
*nexp = 0;
ASSERT(nex > 0);
dip = iocur_top->data;
n = 0;
eoffset = offset + len - 1;
curoffset = offset;
fmt = (xfs_dinode_fmt_t)XFS_DFORK_FORMAT(dip, whichfork);
typ = whichfork == XFS_DATA_FORK ? TYP_BMAPBTD : TYP_BMAPBTA;
ASSERT(typtab[typ].typnm == typ);
ASSERT(fmt == XFS_DINODE_FMT_LOCAL || fmt == XFS_DINODE_FMT_EXTENTS ||
fmt == XFS_DINODE_FMT_BTREE);
if (fmt == XFS_DINODE_FMT_EXTENTS) {
nextents = XFS_DFORK_NEXTENTS(dip, whichfork);
xp = (xfs_bmbt_rec_64_t *)XFS_DFORK_PTR(dip, whichfork);
for (ep = xp; ep < &xp[nextents] && n < nex; ep++) {
if (!bmap_one_extent(ep, &curoffset, eoffset, &n, bep))
break;
}
} else if (fmt == XFS_DINODE_FMT_BTREE) {
push_cur();
bno = NULLFSBLOCK;
rblock = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork);
fsize = XFS_DFORK_SIZE(dip, mp, whichfork);
pp = XFS_BMDR_PTR_ADDR(rblock, 1, xfs_bmdr_maxrecs(mp, fsize, 0));
kp = XFS_BMDR_KEY_ADDR(rblock, 1);
bno = select_child(curoffset, kp, pp,
be16_to_cpu(rblock->bb_numrecs));
for (;;) {
set_cur(&typtab[typ], XFS_FSB_TO_DADDR(mp, bno),
blkbb, DB_RING_IGN, NULL);
block = (struct xfs_btree_block *)iocur_top->data;
if (be16_to_cpu(block->bb_level) == 0)
break;
pp = XFS_BMDR_PTR_ADDR(block, 1,
xfs_bmbt_maxrecs(mp, mp->m_sb.sb_blocksize, 0));
kp = XFS_BMDR_KEY_ADDR(block, 1);
bno = select_child(curoffset, kp, pp,
be16_to_cpu(block->bb_numrecs));
}
for (;;) {
nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
nextents = be16_to_cpu(block->bb_numrecs);
xp = (xfs_bmbt_rec_64_t *)
XFS_BMBT_REC_ADDR(mp, block, 1);
for (ep = xp; ep < &xp[nextents] && n < nex; ep++) {
if (!bmap_one_extent(ep, &curoffset, eoffset,
&n, bep)) {
nextbno = NULLFSBLOCK;
break;
}
}
bno = nextbno;
if (bno == NULLFSBLOCK)
break;
set_cur(&typtab[typ], XFS_FSB_TO_DADDR(mp, bno),
blkbb, DB_RING_IGN, NULL);
block = (struct xfs_btree_block *)iocur_top->data;
}
pop_cur();
}
pop_cur();
*nexp = n;
}
static int
bmap_f(
int argc,
char **argv)
{
int afork = 0;
bmap_ext_t be;
int c;
xfs_dfiloff_t co, cosave;
int dfork = 0;
xfs_dinode_t *dip;
xfs_dfiloff_t eo;
xfs_dfilblks_t len;
int nex;
char *p;
int whichfork;
if (iocur_top->ino == NULLFSINO) {
dbprintf(_("no current inode\n"));
return 0;
}
optind = 0;
if (argc) while ((c = getopt(argc, argv, "ad")) != EOF) {
switch (c) {
case 'a':
afork = 1;
break;
case 'd':
dfork = 1;
break;
default:
dbprintf(_("bad option for bmap command\n"));
return 0;
}
}
if (afork + dfork == 0) {
push_cur();
set_cur_inode(iocur_top->ino);
dip = iocur_top->data;
if (be32_to_cpu(dip->di_core.di_nextents))
dfork = 1;
if (be16_to_cpu(dip->di_core.di_anextents))
afork = 1;
pop_cur();
}
if (optind < argc) {
co = (xfs_dfiloff_t)strtoull(argv[optind], &p, 0);
if (*p != '\0') {
dbprintf(_("bad block number for bmap %s\n"),
argv[optind]);
return 0;
}
optind++;
if (optind < argc) {
len = (xfs_dfilblks_t)strtoull(argv[optind], &p, 0);
if (*p != '\0') {
dbprintf(_("bad len for bmap %s\n"), argv[optind]);
return 0;
}
eo = co + len - 1;
} else
eo = co;
} else {
co = 0;
eo = -1;
}
cosave = co;
for (whichfork = XFS_DATA_FORK;
whichfork <= XFS_ATTR_FORK;
whichfork++) {
if (whichfork == XFS_DATA_FORK && !dfork)
continue;
if (whichfork == XFS_ATTR_FORK && !afork)
continue;
for (;;) {
nex = 1;
bmap(co, eo - co + 1, whichfork, &nex, &be);
if (nex == 0)
break;
dbprintf(_("%s offset %lld startblock %llu (%u/%u) count "
"%llu flag %u\n"),
whichfork == XFS_DATA_FORK ? _("data") : _("attr"),
be.startoff, be.startblock,
XFS_FSB_TO_AGNO(mp, be.startblock),
XFS_FSB_TO_AGBNO(mp, be.startblock),
be.blockcount, be.flag);
co = be.startoff + be.blockcount;
}
co = cosave;
}
return 0;
}