/*
* nh_dump_nodes - dump info about nodes to stdout
*/
void nh_dump_nodes()
{
print_node_info(0);
print_node_info(NH_MEMS);
print_node_info(NH_CPUS);
print_node_info(NH_MEMS | NH_CPUS);
}
int main(int argc, char **argv) {
if(argc != 3) {
fprintf(stderr, "Usage: filepath print_chilren?");
}
if(atoi(argv[2]) > 0) {
print_node_info(argv[1], true, "");
} else {
print_node_info(argv[1], false, "");
}
return 0;
}
int dump_node(struct f2fs_sb_info *sbi, nid_t nid)
{
struct node_info ni;
struct f2fs_node *node_blk;
int ret;
ret = get_node_info(sbi, nid, &ni);
ASSERT(ret >= 0);
node_blk = calloc(BLOCK_SZ, 1);
dev_read_block(node_blk, ni.blk_addr);
DBG(1, "Node ID [0x%x]\n", nid);
DBG(1, "nat_entry.block_addr [0x%x]\n", ni.blk_addr);
DBG(1, "nat_entry.version [0x%x]\n", ni.version);
DBG(1, "nat_entry.ino [0x%x]\n", ni.ino);
if (ni.blk_addr == 0x0) {
MSG(0, "Invalid nat entry\n\n");
}
DBG(1, "node_blk.footer.ino [0x%x]\n", le32_to_cpu(node_blk->footer.ino));
DBG(1, "node_blk.footer.nid [0x%x]\n", le32_to_cpu(node_blk->footer.nid));
if (le32_to_cpu(node_blk->footer.ino) == ni.ino &&
le32_to_cpu(node_blk->footer.nid) == ni.nid) {
print_node_info(node_blk);
} else {
MSG(0, "Invalid node block\n\n");
}
free(node_blk);
return 0;
}
static void print_tree_recurse(FILE * stream,
utree_t * tree,
int indend_level,
int * active_node_order)
{
int i,j;
if (!tree) return;
for (i = 0; i < indend_level; ++i)
{
if (active_node_order[i])
fprintf(stream,"|");
else
fprintf(stream," ");
for (j = 0; j < indend_space-1; ++j)
fprintf(stream," ");
}
fprintf(stream,"\n");
for (i = 0; i < indend_level-1; ++i)
{
if (active_node_order[i])
fprintf(stream,"|");
else
fprintf(stream," ");
for (j = 0; j < indend_space-1; ++j)
fprintf(stream," ");
}
fprintf(stream,"+");
for (j = 0; j < indend_space-1; ++j)
fprintf (stream,"-");
if (tree->next) fprintf(stream,"+");
print_node_info(stream,tree);
if (active_node_order[indend_level-1] == 2)
active_node_order[indend_level-1] = 0;
if (tree->next)
{
active_node_order[indend_level] = 1;
print_tree_recurse(stream,
tree->next->back,
indend_level+1,
active_node_order);
active_node_order[indend_level] = 2;
print_tree_recurse(stream,
tree->next->next->back,
indend_level+1,
active_node_order);
}
}
static void print_tree_recurse(const snode_t * root,
int indent_level,
int * active_node_order,
int options)
{
int i,j;
if (!root) return;
for (i = 0; i < indent_level; ++i)
{
if (active_node_order[i])
printf("|");
else
printf(" ");
for (j = 0; j < indent_space-1; ++j)
printf(" ");
}
printf("\n");
for (i = 0; i < indent_level-1; ++i)
{
if (active_node_order[i])
printf("|");
else
printf(" ");
for (j = 0; j < indent_space-1; ++j)
printf(" ");
}
printf("+");
for (j = 0; j < indent_space-1; ++j)
printf ("-");
if (root->left || root->right) printf("+");
print_node_info(root, options);
if (active_node_order[indent_level-1] == 2)
active_node_order[indent_level-1] = 0;
active_node_order[indent_level] = 1;
print_tree_recurse(root->left,
indent_level+1,
active_node_order,
options);
active_node_order[indent_level] = 2;
print_tree_recurse(root->right,
indent_level+1,
active_node_order,
options);
}
void print_node_info(char* filename, bool print_children, char* parent){
//char *filename = "node_000001_root.dat";
node_t *node = read_node(filename);
printf("Node ID: %i\nNode filepath: %s\nParent: %s\nNode fanout: %i\nNode child_num: %i\n\n", node->id, node->filepath, parent, node->fanout, node->child_num );
int i;
if(print_children && !node->is_leaf) {
for (i = 0; i < node->child_num; i++){
print_node_info(node->children[i], true, node->filepath);
}
}
}
void stree_show_ascii(const snode_t * root, int options)
{
unsigned int indent_max = tree_indent_level(root,0);
int * active_node_order = (int *)xmalloc((indent_max+1) * sizeof(int));
active_node_order[0] = 1;
active_node_order[1] = 1;
print_node_info(root, options);
print_tree_recurse(root->left, 1, active_node_order, options);
print_tree_recurse(root->right, 1, active_node_order, options);
free(active_node_order);
}
static void dump_node_from_blkaddr(u32 blk_addr)
{
struct f2fs_node *node_blk;
int ret;
node_blk = calloc(BLOCK_SZ, 1);
ASSERT(node_blk);
ret = dev_read_block(node_blk, blk_addr);
ASSERT(ret >= 0);
if (config.dbg_lv > 0)
print_node_info(node_blk);
else
print_inode_info(&node_blk->i, 1);
free(node_blk);
}
int dump_inode_from_blkaddr(struct f2fs_sb_info *sbi, u32 blk_addr)
{
nid_t ino, nid;
int type, ret;
struct f2fs_summary sum_entry;
struct node_info ni;
struct f2fs_node *node_blk;
type = get_sum_entry(sbi, blk_addr, &sum_entry);
nid = le32_to_cpu(sum_entry.nid);
ret = get_node_info(sbi, nid, &ni);
ASSERT(ret >= 0);
DBG(1, "Note: blkaddr = main_blkaddr + segno * 512 + offset\n");
DBG(1, "Block_addr [0x%x]\n", blk_addr);
DBG(1, " - Segno [0x%x]\n", GET_SEGNO(sbi, blk_addr));
DBG(1, " - Offset [0x%x]\n", OFFSET_IN_SEG(sbi, blk_addr));
DBG(1, "SUM.nid [0x%x]\n", nid);
DBG(1, "SUM.type [%s]\n", seg_type_name[type]);
DBG(1, "SUM.version [%d]\n", sum_entry.version);
DBG(1, "SUM.ofs_in_node [%d]\n", sum_entry.ofs_in_node);
DBG(1, "NAT.blkaddr [0x%x]\n", ni.blk_addr);
DBG(1, "NAT.ino [0x%x]\n", ni.ino);
node_blk = calloc(BLOCK_SZ, 1);
read_node_blk:
dev_read_block(node_blk, blk_addr);
ino = le32_to_cpu(node_blk->footer.ino);
nid = le32_to_cpu(node_blk->footer.nid);
if (ino == nid) {
print_node_info(node_blk);
} else {
ret = get_node_info(sbi, ino, &ni);
goto read_node_blk;
}
free(node_blk);
return ino;
}
/*
* speedmap()
* is used to print node information (speed map, node number, GUID, etc.)
* about the 1394 devices currently attached to the 1394 bus.
*/
static int
speedmap(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
s1394_hal_t hal;
int ret;
if (flags & DCMD_ADDRSPEC) {
if (mdb_vread(&hal, sizeof (s1394_hal_t), addr) == -1) {
mdb_warn("failed to read the HAL structure");
return (DCMD_ERR);
}
ret = print_node_info(&hal);
if (ret == DCMD_ERR)
return (DCMD_ERR);
} else {
(void) mdb_walk_dcmd("speedmap", "speedmap", argc, argv);
}
return (DCMD_OK);
}
/**
* Displays all connected nodes
*/
enum shell_reply
shell_exec_nodes(struct gnutella_shell *sh, int argc, const char *argv[])
{
const GSList *sl;
shell_check(sh);
g_assert(argv);
g_assert(argc > 0);
shell_set_msg(sh, "");
shell_write(sh,
"100~ \n"
"Node Port Flags CC Since Uptime User-Agent\n");
for (sl = node_all_nodes(); sl; sl = g_slist_next(sl)) {
const struct gnutella_node *n = sl->data;
print_node_info(sh, n);
}
shell_write(sh, ".\n"); /* Terminate message body */
return REPLY_READY;
}
/**
* Displays all connected nodes
*/
enum shell_reply
shell_exec_nodes(struct gnutella_shell *sh, int argc, const char *argv[])
{
const pslist_t *sl;
shell_check(sh);
g_assert(argv);
g_assert(argc > 0);
shell_set_msg(sh, "");
shell_write(sh,
"100~ \n"
"Node Flags CC Since Uptime User-Agent\n");
PSLIST_FOREACH(node_all_nodes(), sl) {
const gnutella_node_t *n = sl->data;
print_node_info(sh, n);
}
shell_write(sh, ".\n"); /* Terminate message body */
return REPLY_READY;
}
int fsck_chk_inode_blk(struct f2fs_sb_info *sbi,
u32 nid,
enum FILE_TYPE ftype,
struct f2fs_node *node_blk,
u32 *blk_cnt,
struct node_info *ni)
{
struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
u32 child_cnt = 0, child_files = 0;
enum NODE_TYPE ntype;
u32 i_links = le32_to_cpu(node_blk->i.i_links);
u64 i_blocks = le64_to_cpu(node_blk->i.i_blocks);
int idx = 0;
int ret = 0;
ASSERT(node_blk->footer.nid == node_blk->footer.ino);
ASSERT(le32_to_cpu(node_blk->footer.nid) == nid);
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, ni->blk_addr), fsck->main_area_bitmap) == 0x0)
fsck->chk.valid_inode_cnt++;
/* Orphan node. i_links should be 0 */
if (ftype == F2FS_FT_ORPHAN) {
ASSERT(i_links == 0);
} else {
ASSERT(i_links > 0);
}
if (ftype == F2FS_FT_DIR) {
/* not included '.' & '..' */
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, ni->blk_addr), fsck->main_area_bitmap) != 0) {
DBG(0, "Duplicated inode blk. ino[0x%x][0x%x]\n", nid, ni->blk_addr);
ASSERT(0);
}
f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, ni->blk_addr), fsck->main_area_bitmap);
} else {
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, ni->blk_addr), fsck->main_area_bitmap) == 0x0) {
f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, ni->blk_addr), fsck->main_area_bitmap);
if (i_links > 1) {
/* First time. Create new hard link node */
add_into_hard_link_list(sbi, nid, i_links);
fsck->chk.multi_hard_link_files++;
}
} else {
if (i_links <= 1) {
DBG(0, "Error. Node ID [0x%x]."
" There are one more hard links."
" But i_links is [0x%x]\n",
nid, i_links);
ASSERT(0);
}
DBG(3, "ino[0x%x] has hard links [0x%x]\n", nid, i_links);
ret = find_and_dec_hard_link_list(sbi, nid);
ASSERT(ret >= 0);
/* No need to go deep into the node */
goto out;
}
}
fsck_chk_xattr_blk(sbi, nid, le32_to_cpu(node_blk->i.i_xattr_nid), blk_cnt);
if (ftype == F2FS_FT_CHRDEV || ftype == F2FS_FT_BLKDEV ||
ftype == F2FS_FT_FIFO || ftype == F2FS_FT_SOCK)
goto check;
if((node_blk->i.i_inline & F2FS_INLINE_DATA)){
DBG(3, "ino[0x%x] has inline data!\n", nid);
goto check;
}
/* check data blocks in inode */
for (idx = 0; idx < ADDRS_PER_INODE(&node_blk->i); idx++) {
if (le32_to_cpu(node_blk->i.i_addr[idx]) != 0) {
*blk_cnt = *blk_cnt + 1;
ret = fsck_chk_data_blk(sbi,
&node_blk->i,
le32_to_cpu(node_blk->i.i_addr[idx]),
&child_cnt,
&child_files,
(i_blocks == *blk_cnt),
ftype,
nid,
idx,
ni->version);
ASSERT(ret >= 0);
}
}
/* check node blocks in inode */
for (idx = 0; idx < 5; idx++) {
if (idx == 0 || idx == 1)
ntype = TYPE_DIRECT_NODE;
else if (idx == 2 || idx == 3)
ntype = TYPE_INDIRECT_NODE;
else if (idx == 4)
ntype = TYPE_DOUBLE_INDIRECT_NODE;
else
ASSERT(0);
if (le32_to_cpu(node_blk->i.i_nid[idx]) != 0) {
*blk_cnt = *blk_cnt + 1;
ret = fsck_chk_node_blk(sbi,
&node_blk->i,
le32_to_cpu(node_blk->i.i_nid[idx]),
ftype,
ntype,
blk_cnt);
ASSERT(ret >= 0);
}
}
check:
if (ftype == F2FS_FT_DIR)
DBG(1, "Directory Inode: ino: %x name: %s depth: %d child files: %d\n\n",
le32_to_cpu(node_blk->footer.ino), node_blk->i.i_name,
le32_to_cpu(node_blk->i.i_current_depth), child_files);
if (ftype == F2FS_FT_ORPHAN)
DBG(1, "Orphan Inode: ino: %x name: %s i_blocks: %lu\n\n",
le32_to_cpu(node_blk->footer.ino), node_blk->i.i_name,
i_blocks);
if ((ftype == F2FS_FT_DIR && i_links != child_cnt) ||
(i_blocks != *blk_cnt)) {
print_node_info(node_blk);
DBG(1, "blk cnt [0x%x]\n", *blk_cnt);
DBG(1, "child cnt [0x%x]\n", child_cnt);
}
ASSERT(i_blocks == *blk_cnt);
if (ftype == F2FS_FT_DIR)
ASSERT(i_links == child_cnt);
out:
return 0;
}
static int
dump_art_node_callback(void *data,
const unsigned char *key, uint32_t key_len,
const unsigned char *val, uint32_t val_len)
{
cb_data *cbd;
const art_node *an;
TOID(art_node4) an4;
TOID(art_node16) an16;
TOID(art_node48) an48;
TOID(art_node256) an256;
TOID(art_leaf) al;
TOID(art_node_u) child;
TOID(var_string) oid_key;
TOID(var_string) oid_value;
if (data != NULL) {
cbd = (cb_data *)data;
switch (D_RO(cbd->node)->art_node_type) {
case NODE4:
an4 = D_RO(cbd->node)->u.an4;
an = &(D_RO(an4)->n);
child = D_RO(an4)->children[cbd->child_idx];
if (!TOID_IS_NULL(child)) {
print_node_info("node4",
cbd->node.oid.off, an);
printf("N%lx -> N%lx [label=\"%c\"];\n",
cbd->node.oid.off,
child.oid.off,
D_RO(an4)->keys[cbd->child_idx]);
}
break;
case NODE16:
an16 = D_RO(cbd->node)->u.an16;
an = &(D_RO(an16)->n);
child = D_RO(an16)->children[cbd->child_idx];
if (!TOID_IS_NULL(child)) {
print_node_info("node16",
cbd->node.oid.off, an);
printf("N%lx -> N%lx [label=\"%c\"];\n",
cbd->node.oid.off,
child.oid.off,
D_RO(an16)->keys[cbd->child_idx]);
}
break;
case NODE48:
an48 = D_RO(cbd->node)->u.an48;
an = &(D_RO(an48)->n);
child = D_RO(an48)->children[cbd->child_idx];
if (!TOID_IS_NULL(child)) {
print_node_info("node48",
cbd->node.oid.off, an);
printf("N%lx -> N%lx [label=\"%c\"];\n",
cbd->node.oid.off,
child.oid.off,
D_RO(an48)->keys[cbd->child_idx]);
}
break;
case NODE256:
an256 = D_RO(cbd->node)->u.an256;
an = &(D_RO(an256)->n);
child = D_RO(an256)->children[cbd->child_idx];
if (!TOID_IS_NULL(child)) {
print_node_info("node256",
cbd->node.oid.off, an);
printf("N%lx -> N%lx [label=\"0x%x\"];\n",
cbd->node.oid.off,
child.oid.off,
(char)((cbd->child_idx) & 0xff));
}
break;
case art_leaf_t:
al = D_RO(cbd->node)->u.al;
oid_key = D_RO(al)->key;
oid_value = D_RO(al)->value;
printf("N%lx [shape=box,"
"label=\"leaf at\\n0x%lx\"];\n",
cbd->node.oid.off, cbd->node.oid.off);
printf("N%lx [shape=box,"
"label=\"key at 0x%lx: %s\"];\n",
oid_key.oid.off, oid_key.oid.off,
D_RO(oid_key)->s);
printf("N%lx [shape=box,"
"label=\"value at 0x%lx: %s\"];\n",
oid_value.oid.off, oid_value.oid.off,
D_RO(oid_value)->s);
printf("N%lx -> N%lx;\n",
cbd->node.oid.off, oid_key.oid.off);
printf("N%lx -> N%lx;\n",
cbd->node.oid.off, oid_value.oid.off);
break;
default:
break;
}
} else {
printf("leaf: key len %d = [%s], value len %d = [%s]\n",
key_len, key, val_len, val);
}
return 0;
}
