i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* The "bfs" KDL command can now also convert block offsets to block_runs and

Browse Source 
vice versa.
* Some cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25248 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2008-04-29 16:08:42 +00:00
parent 76824051fd
commit e7ad26598a
1 changed files with 80 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/file_systems/bfs/Debug.cpp
+80 -45
View File
@@ -15,7 +15,7 @@
#define Print __out #define Print __out
char * char*
get_tupel(uint32 id) get_tupel(uint32 id)
{ {
static unsigned char tupel[5]; static unsigned char tupel[5];
@@ -30,12 +30,12 @@ get_tupel(uint32 id)
tupel[i] = '.'; tupel[i] = '.';
} }
return (char *)tupel; return (char*)tupel;
} }
void void
dump_block_run(const char *prefix, const block_run &run) dump_block_run(const char* prefix, const block_run& run)
{ {
Print("%s(%d, %d, %d)\n", prefix, (int)run.allocation_group, run.start, Print("%s(%d, %d, %d)\n", prefix, (int)run.allocation_group, run.start,
run.length); run.length);
@@ -43,7 +43,7 @@ dump_block_run(const char *prefix, const block_run &run)
void void
dump_super_block(const disk_super_block *superBlock) dump_super_block(const disk_super_block* superBlock)
{ {
Print("disk_super_block:\n"); Print("disk_super_block:\n");
Print(" name = %s\n", superBlock->name); Print(" name = %s\n", superBlock->name);
@@ -80,7 +80,7 @@ dump_super_block(const disk_super_block *superBlock)
void void
dump_data_stream(const data_stream *stream) dump_data_stream(const data_stream* stream)
{ {
Print("data_stream:\n"); Print("data_stream:\n");
for (int i = 0; i < NUM_DIRECT_BLOCKS; i++) { for (int i = 0; i < NUM_DIRECT_BLOCKS; i++) {
@@ -108,7 +108,7 @@ dump_data_stream(const data_stream *stream)
void void
dump_inode(const bfs_inode *inode) dump_inode(const bfs_inode* inode)
{ {
Print("inode:\n"); Print("inode:\n");
Print(" magic1 = %08x (%s) %s\n", (int)inode->Magic1(), Print(" magic1 = %08x (%s) %s\n", (int)inode->Magic1(),
@@ -140,7 +140,7 @@ dump_inode(const bfs_inode *inode)
void void
dump_bplustree_header(const bplustree_header *header) dump_bplustree_header(const bplustree_header* header)
{ {
Print("bplustree_header:\n"); Print("bplustree_header:\n");
Print(" magic = %#08x (%s) %s\n", (int)header->Magic(), Print(" magic = %#08x (%s) %s\n", (int)header->Magic(),
@@ -159,30 +159,30 @@ dump_bplustree_header(const bplustree_header *header)
#define DUMPED_BLOCK_SIZE 16 #define DUMPED_BLOCK_SIZE 16
void void
dump_block(const char *buffer,int size) dump_block(const char* buffer,int size)
{ {
for(int i = 0;i < size;) { for (int i = 0; i < size;) {
int start = i; int start = i;
for(;i < start+DUMPED_BLOCK_SIZE;i++) { for (; i < start + DUMPED_BLOCK_SIZE; i++) {
if (!(i % 4)) if (!(i % 4))
Print(" "); Print(" ");
if (i >= size) if (i >= size)
Print(" "); Print(" ");
else else
Print("%02x",*(unsigned char *)(buffer+i)); Print("%02x", *(unsigned char *)(buffer + i));
} }
Print(" "); Print(" ");
for(i = start;i < start + DUMPED_BLOCK_SIZE;i++) { for (i = start; i < start + DUMPED_BLOCK_SIZE; i++) {
if (i < size) { if (i < size) {
char c = *(buffer+i); char c = *(buffer + i);
if (c < 30) if (c < 30)
Print("."); Print(".");
else else
Print("%c",c); Print("%c", c);
} else } else
break; break;
} }
@@ -192,8 +192,8 @@ dump_block(const char *buffer,int size)
void void
dump_bplustree_node(const bplustree_node *node, const bplustree_header *header, dump_bplustree_node(const bplustree_node* node, const bplustree_header* header,
Volume *volume) Volume* volume)
{ {
Print("bplustree_node:\n"); Print("bplustree_node:\n");
Print(" left_link = %Ld\n", node->left_link); Print(" left_link = %Ld\n", node->left_link);
@@ -225,20 +225,24 @@ dump_bplustree_node(const bplustree_node *node, const bplustree_header *header,
memcpy(buffer, key, length); memcpy(buffer, key, length);
buffer[length] = '\0'; buffer[length] = '\0';
off_t *value = node->Values() + i; off_t* value = node->Values() + i;
if ((addr_t)value < (addr_t)node || (addr_t)value > (addr_t)node + header->node_size) if ((addr_t)value < (addr_t)node
|| (addr_t)value > (addr_t)node + header->node_size)
Print(" %2d. Invalid Offset!!\n", (int)i); Print(" %2d. Invalid Offset!!\n", (int)i);
else { else {
Print(" %2d. ", (int)i); Print(" %2d. ", (int)i);
if (header->data_type == BPLUSTREE_STRING_TYPE) if (header->data_type == BPLUSTREE_STRING_TYPE)
Print("\"%s\"", buffer); Print("\"%s\"", buffer);
else if (header->data_type == BPLUSTREE_INT32_TYPE) else if (header->data_type == BPLUSTREE_INT32_TYPE) {
Print("int32 = %d (0x%x)", (int)*(int32 *)&buffer, (int)*(int32 *)&buffer); Print("int32 = %d (0x%x)", (int)*(int32 *)&buffer,
else if (header->data_type == BPLUSTREE_UINT32_TYPE) (int)*(int32 *)&buffer);
Print("uint32 = %u (0x%x)", (unsigned)*(uint32 *)&buffer, (unsigned)*(uint32 *)&buffer); } else if (header->data_type == BPLUSTREE_UINT32_TYPE) {
else if (header->data_type == BPLUSTREE_INT64_TYPE) Print("uint32 = %u (0x%x)", (unsigned)*(uint32 *)&buffer,
Print("int64 = %Ld (0x%Lx)", *(int64 *)&buffer, *(int64 *)&buffer); (unsigned)*(uint32 *)&buffer);
else } else if (header->data_type == BPLUSTREE_INT64_TYPE) {
Print("int64 = %Ld (0x%Lx)", *(int64 *)&buffer,
*(int64 *)&buffer);
} else
Print("???"); Print("???");
off_t offset = *value & 0x3fffffffffffffffLL; off_t offset = *value & 0x3fffffffffffffffLL;
@@ -247,9 +251,11 @@ dump_bplustree_node(const bplustree_node *node, const bplustree_header *header,
block_run run = volume->ToBlockRun(offset); block_run run = volume->ToBlockRun(offset);
Print(" (%d, %d)", (int)run.allocation_group, run.start); Print(" (%d, %d)", (int)run.allocation_group, run.start);
} }
if (bplustree_node::LinkType(*value) == BPLUSTREE_DUPLICATE_FRAGMENT) if (bplustree_node::LinkType(*value)
== BPLUSTREE_DUPLICATE_FRAGMENT)
Print(" (duplicate fragment %Ld)\n", *value & 0x3ff); Print(" (duplicate fragment %Ld)\n", *value & 0x3ff);
else if (bplustree_node::LinkType(*value) == BPLUSTREE_DUPLICATE_NODE) else if (bplustree_node::LinkType(*value)
== BPLUSTREE_DUPLICATE_NODE)
Print(" (duplicate node)\n"); Print(" (duplicate node)\n");
else else
Print("\n"); Print("\n");
@@ -265,23 +271,25 @@ dump_bplustree_node(const bplustree_node *node, const bplustree_header *header,
static int static int
dump_inode(int argc, char **argv) dump_inode(int argc, char** argv)
{ {
bool block = false; bool block = false;
if (argc == 3 && !strcmp(argv[1], "-b")) if (argc == 3 && !strcmp(argv[1], "-b"))
block = true; block = true;
if (argc != 2 + (block ? 1 : 0) || !strcmp(argv[1], "--help")) { if (argc != 2 + (block ? 1 : 0) || !strcmp(argv[1], "--help")) {
kprintf("usage: bfsinode [-b] <ptr-to-inode>\n"); kprintf("usage: bfsinode [-b] <ptr-to-inode>\n"
" -b the address is regarded as pointer to a block instead of one "
"to an inode.\n");
return 0; return 0;
} }
addr_t address = parse_expression(argv[argc - 1]); addr_t address = parse_expression(argv[argc - 1]);
bfs_inode *node; bfs_inode* node;
if (block) if (block)
node = (bfs_inode *)address; node = (bfs_inode*)address;
else else
node = &((Inode *)address)->Node(); node = &((Inode*)address)->Node();
dump_inode(node); dump_inode(node);
return 0; return 0;
@@ -289,14 +297,42 @@ dump_inode(int argc, char **argv)
static int static int
dump_volume(int argc, char **argv) dump_volume(int argc, char** argv)
{ {
if (argc != 2 || !strcmp(argv[1], "--help")) { if (argc < 2 || !strcmp(argv[1], "--help")) {
kprintf("usage: bfs <ptr-to-volume>\n"); kprintf("usage: bfs <ptr-to-volume> [<block-run>]\n"
"Dumps a BFS volume - <block-run> is given, it is converted to a "
"block offset instead (and vice versa).\n");
return 0; return 0;
} }
Volume *volume = (Volume *)parse_expression(argv[1]); Volume* volume = (Volume*)parse_expression(argv[1]);
if (argc > 2) {
// convert block_runs/offsets
for (int i = 2; i < argc; i++) {
char* arg = argv[i];
if (strchr(arg, '.') != NULL) {
// block_run to offset
block_run run;
run.allocation_group = HOST_ENDIAN_TO_BFS_INT32(
strtoul(arg, &arg, 0));
run.start = HOST_ENDIAN_TO_BFS_INT16(strtoul(arg, NULL, 0));
run.length = 0;
kprintf("%ld.%u -> block %Ld\n", run.AllocationGroup(),
run.Start(), volume->ToBlock(run));
} else {
// offset to block_run
off_t offset = parse_expression(arg);
block_run run = volume->ToBlockRun(offset);
kprintf("block %Ld -> %ld.%u\n", offset, run.AllocationGroup(),
run.Start());
}
}
return 0;
}
kprintf("block cache: %p\n", volume->BlockCache()); kprintf("block cache: %p\n", volume->BlockCache());
kprintf("root node: %p\n", volume->RootNode()); kprintf("root node: %p\n", volume->RootNode());
@@ -313,7 +349,7 @@ dump_volume(int argc, char **argv)
static int static int
dump_bplustree_node(int argc, char **argv) dump_bplustree_node(int argc, char** argv)
{ {
if (argc < 2 || argc > 4 || !strcmp(argv[1], "--help")) { if (argc < 2 || argc > 4 || !strcmp(argv[1], "--help")) {
kprintf("usage: %s <ptr-to-node> [ptr-to-header] [ptr-to-volume]\n", kprintf("usage: %s <ptr-to-node> [ptr-to-header] [ptr-to-volume]\n",
@@ -321,14 +357,14 @@ dump_bplustree_node(int argc, char **argv)
return 0; return 0;
} }
bplustree_node *node = (bplustree_node *)parse_expression(argv[1]); bplustree_node* node = (bplustree_node*)parse_expression(argv[1]);
bplustree_header *header = NULL; bplustree_header* header = NULL;
Volume *volume = NULL; Volume* volume = NULL;
if (argc > 2) if (argc > 2)
header = (bplustree_header *)parse_expression(argv[2]); header = (bplustree_header*)parse_expression(argv[2]);
if (argc > 3) if (argc > 3)
volume = (Volume *)parse_expression(argv[3]); volume = (Volume*)parse_expression(argv[3]);
dump_bplustree_node(node, header, volume); dump_bplustree_node(node, header, volume);
@@ -337,14 +373,14 @@ dump_bplustree_node(int argc, char **argv)
static int static int
dump_bplustree_header(int argc, char **argv) dump_bplustree_header(int argc, char** argv)
{ {
if (argc != 2 || !strcmp(argv[1], "--help")) { if (argc != 2 || !strcmp(argv[1], "--help")) {
kprintf("usage: %s <ptr-to-header>\n", argv[0]); kprintf("usage: %s <ptr-to-header>\n", argv[0]);
return 0; return 0;
} }
bplustree_header *header = (bplustree_header *)parse_expression(argv[1]); bplustree_header* header = (bplustree_header*)parse_expression(argv[1]);
dump_bplustree_header(header); dump_bplustree_header(header);
return 0; return 0;
@@ -380,4 +416,3 @@ add_debugger_commands()
#endif // BFS_DEBUGGER_COMMANDS #endif // BFS_DEBUGGER_COMMANDS