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();
}
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 uuid_t *
do_uuid(xfs_agnumber_t agno, uuid_t *uuid)
{
xfs_sb_t tsb;
static uuid_t uu;
if (!get_sb(agno, &tsb))
return NULL;
if (!uuid) { /* get uuid */
memcpy(&uu, &tsb.sb_uuid, sizeof(uuid_t));
pop_cur();
return &uu;
}
/* set uuid */
if (!xfs_sb_version_hascrc(&tsb))
goto write;
/*
* If we have CRCs, and this UUID differs from that stamped in the
* metadata, set the incompat flag and copy the old one to the
* metadata-specific location.
*
* If we are setting the user-visible UUID back to match the metadata
* UUID, clear the metadata-specific location and the incompat flag.
*/
if (!xfs_sb_version_hasmetauuid(&tsb) &&
!uuid_equal(uuid, &mp->m_sb.sb_meta_uuid)) {
mp->m_sb.sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_META_UUID;
tsb.sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_META_UUID;
memcpy(&tsb.sb_meta_uuid, &tsb.sb_uuid, sizeof(uuid_t));
} else if (xfs_sb_version_hasmetauuid(&tsb) &&
uuid_equal(uuid, &mp->m_sb.sb_meta_uuid)) {
memset(&tsb.sb_meta_uuid, 0, sizeof(uuid_t));
/* Write those zeros now; it's ignored once we clear the flag */
libxfs_sb_to_disk(iocur_top->data, &tsb);
mp->m_sb.sb_features_incompat &=
~XFS_SB_FEAT_INCOMPAT_META_UUID;
tsb.sb_features_incompat &= ~XFS_SB_FEAT_INCOMPAT_META_UUID;
}
write:
memcpy(&tsb.sb_uuid, uuid, sizeof(uuid_t));
libxfs_sb_to_disk(iocur_top->data, &tsb);
write_cur();
return uuid;
}
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();
}
static uuid_t *
do_uuid(xfs_agnumber_t agno, uuid_t *uuid)
{
xfs_sb_t tsb;
static uuid_t uu;
if (!get_sb(agno, &tsb))
return NULL;
if (!uuid) { /* get uuid */
memcpy(&uu, &tsb.sb_uuid, sizeof(uuid_t));
pop_cur();
return &uu;
}
/* set uuid */
memcpy(&tsb.sb_uuid, uuid, sizeof(uuid_t));
libxfs_xlate_sb(iocur_top->data, &tsb, -1, ARCH_CONVERT, XFS_SB_UUID);
write_cur();
return uuid;
}
static char *
do_label(xfs_agnumber_t agno, char *label)
{
size_t len;
xfs_sb_t tsb;
static char lbl[sizeof(tsb.sb_fname) + 1];
if (!get_sb(agno, &tsb))
return NULL;
memset(&lbl[0], 0, sizeof(lbl));
if (!label) { /* get label */
pop_cur();
memcpy(&lbl[0], &tsb.sb_fname, sizeof(tsb.sb_fname));
return &lbl[0];
}
/* set label */
if ((len = strlen(label)) > sizeof(tsb.sb_fname)) {
if (!warned++)
dbprintf("warning: truncating label from %lld to %lld "
"characters\n",
(long long)len, (long long)sizeof(tsb.sb_fname));
len = sizeof(tsb.sb_fname);
}
if ( len == 2 &&
(strcmp(label, "\"\"") == 0 ||
strcmp(label, "''") == 0 ||
strcmp(label, "--") == 0) )
label[0] = label[1] = '\0';
memset(&tsb.sb_fname, 0, sizeof(tsb.sb_fname));
memcpy(&tsb.sb_fname, label, len);
memcpy(&lbl[0], &tsb.sb_fname, sizeof(tsb.sb_fname));
libxfs_xlate_sb(iocur_top->data, &tsb, -1, ARCH_CONVERT, XFS_SB_FNAME);
write_cur();
return &lbl[0];
}
static char *
do_label(xfs_agnumber_t agno, char *label)
{
size_t len;
xfs_sb_t tsb;
static char lbl[sizeof(tsb.sb_fname) + 1];
if (!get_sb(agno, &tsb))
return NULL;
memset(&lbl[0], 0, sizeof(lbl));
if (!label) { /* get label */
pop_cur();
memcpy(&lbl[0], &tsb.sb_fname, sizeof(tsb.sb_fname));
return &lbl[0];
}
/* set label */
if ((len = strlen(label)) > sizeof(tsb.sb_fname)) {
if (agno == 0)
dbprintf(_("%s: truncating label length from %d to %d\n"),
progname, (int)len, (int)sizeof(tsb.sb_fname));
len = sizeof(tsb.sb_fname);
}
if ( len == 2 &&
(strcmp(label, "\"\"") == 0 ||
strcmp(label, "''") == 0 ||
strcmp(label, "--") == 0) )
label[0] = label[1] = '\0';
memset(&tsb.sb_fname, 0, sizeof(tsb.sb_fname));
memcpy(&tsb.sb_fname, label, len);
memcpy(&lbl[0], &tsb.sb_fname, sizeof(tsb.sb_fname));
libxfs_sb_to_disk(iocur_top->data, &tsb);
write_cur();
return &lbl[0];
}
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;
}
