@@ -33,8 +33,9 @@ all: $(progs)
debug_btrfs_cmds.c: debug_btrfs_cmds.ct
$(MK_CMDS) debug_btrfs_cmds.ct
-debug-btrfs: $(TOPDIR)/lib/libbtrfs.a debug_btrfs.o cmds.o debug_btrfs_cmds.o debug_tree.o
- $(CC) $(CFLAGS) -o debug-btrfs debug_btrfs.o cmds.o debug_btrfs_cmds.o debug_tree.o $(TOPDIR)/lib/libbtrfs.a $(LDFLAGS) $(LIBS)
+debug-btrfs: $(TOPDIR)/lib/libbtrfs.a debug_btrfs.o cmds.o debug_btrfs_cmds.o debug_tree.o pager.o
+ $(CC) $(CFLAGS) -o debug-btrfs debug_btrfs.o cmds.o debug_btrfs_cmds.o debug_tree.o \
+ pager.o $(TOPDIR)/lib/libbtrfs.a $(LDFLAGS) $(LIBS)
clean:
rm -f *.o debug_btrfs_cmds.c
@@ -19,6 +19,7 @@
#ifndef DEBUG_BTRFS_H
#define DEBUG_BTRFS_H
+#include <stdio.h>
#include <getopt.h>
extern const char *current_device;
@@ -27,4 +28,6 @@ static inline void reset_getopt(void)
{
optind = 0;
}
+extern FILE *open_pager(void);
+extern void close_pager(FILE *);
#endif
@@ -30,87 +30,109 @@
void do_dump_extent_tree(int argc, char *argv[])
{
+ FILE *fp;
if (!current_fs_root) {
fprintf(stderr, "File system not yet opened: %s\n", current_device);
return;
}
- printf("Extent tree\n");
- btrfs_print_tree(current_fs_root->fs_info->extent_root,
+ fp = open_pager();
+ fprintf(fp, "Extent tree\n");
+ btrfs_print_tree(fp, current_fs_root->fs_info->extent_root,
current_fs_root->fs_info->extent_root->node);
+ close_pager(fp);
}
void do_dump_root_tree(int argc, char *argv[])
{
+ FILE *fp;
if (!current_fs_root) {
fprintf(stderr, "File system not yet opened: %s\n", current_device);
return;
}
- printf("root tree\n");
- btrfs_print_tree(current_fs_root->fs_info->tree_root,
+ fp = open_pager();
+ fprintf(fp, "root tree\n");
+ btrfs_print_tree(fp, current_fs_root->fs_info->tree_root,
current_fs_root->fs_info->tree_root->node);
+ close_pager(fp);
}
void do_dump_chunk_tree(int argc, char *argv[])
{
+ FILE *fp;
if (!current_fs_root) {
fprintf(stderr, "File system not yet opened: %s\n", current_device);
return;
}
- printf("chunk tree\n");
- btrfs_print_tree(current_fs_root->fs_info->chunk_root,
+ fp = open_pager();
+ fprintf(fp, "chunk tree\n");
+ btrfs_print_tree(fp, current_fs_root->fs_info->chunk_root,
current_fs_root->fs_info->chunk_root->node);
+ close_pager(fp);
}
void do_dump_dev_tree(int argc, char *argv[])
{
+ FILE *fp;
if (!current_fs_root) {
fprintf(stderr, "File system not yet opened: %s\n", current_device);
return;
}
- printf("Device tree\n");
- btrfs_print_tree(current_fs_root->fs_info->dev_root,
+ fp = open_pager();
+ fprintf(fp, "Device tree\n");
+ btrfs_print_tree(fp, current_fs_root->fs_info->dev_root,
current_fs_root->fs_info->dev_root->node);
+ close_pager(fp);
}
void do_dump_fs_tree(int argc, char *argv[])
{
+ FILE *fp;
if (!current_fs_root) {
fprintf(stderr, "File system not yet opened: %s\n", current_device);
return;
}
- printf("FS tree\n");
- btrfs_print_tree(current_fs_root->fs_info->fs_root,
+ fp = open_pager();
+ fprintf(fp, "FS tree\n");
+ btrfs_print_tree(fp, current_fs_root->fs_info->fs_root,
current_fs_root->fs_info->fs_root->node);
+ close_pager(fp);
}
void do_dump_csum_tree(int argc, char *argv[])
{
+ FILE *fp;
if (!current_fs_root) {
fprintf(stderr, "File system not yet opened: %s\n", current_device);
return;
}
- printf("Checksum tree\n");
- btrfs_print_tree(current_fs_root->fs_info->csum_root,
+ fp = open_pager();
+ fprintf(fp, "Checksum tree\n");
+ btrfs_print_tree(fp, current_fs_root->fs_info->csum_root,
current_fs_root->fs_info->csum_root->node);
+ close_pager(fp);
}
void do_dump_log_tree(int argc, char *argv[])
{
+ FILE *fp;
if (!current_fs_root) {
fprintf(stderr, "File system not yet opened: %s\n", current_device);
return;
}
- printf("Log tree\n");
+ fp = open_pager();
+ fprintf(fp, "Log tree\n");
if (!current_fs_root->fs_info->log_root_tree) {
- printf("Nothing to replay \n");
+ fprintf(fp, "Nothing to replay \n");
return;
}
- btrfs_print_tree(current_fs_root->fs_info->log_root_tree,
+ btrfs_print_tree(fp, current_fs_root->fs_info->log_root_tree,
current_fs_root->fs_info->log_root_tree->node);
+ close_pager(fp);
}
void do_dump_tree(int argc, char *argv[])
{
+ FILE *fp;
struct btrfs_path path;
struct btrfs_key key;
struct btrfs_root_item ri;
@@ -126,12 +148,13 @@ void do_dump_tree(int argc, char *argv[])
fprintf(stderr, "File system not yet opened: %s\n", current_device);
return;
}
- printf("root tree\n");
- btrfs_print_tree(current_fs_root->fs_info->tree_root,
+ fp = open_pager();
+ fprintf(fp, "root tree\n");
+ btrfs_print_tree(fp, current_fs_root->fs_info->tree_root,
current_fs_root->fs_info->tree_root->node);
- printf("chunk tree\n");
- btrfs_print_tree(current_fs_root->fs_info->chunk_root,
+ fprintf(fp, "chunk tree\n");
+ btrfs_print_tree(fp, current_fs_root->fs_info->chunk_root,
current_fs_root->fs_info->chunk_root->node);
tree_root_scan = current_fs_root->fs_info->tree_root;
@@ -166,55 +189,55 @@ again:
tree_root_scan->leafsize, 0);
switch(found_key.objectid) {
case BTRFS_ROOT_TREE_OBJECTID:
- printf("root");
+ fprintf(fp, "root");
break;
case BTRFS_EXTENT_TREE_OBJECTID:
- printf("extent");
+ fprintf(fp, "extent");
break;
case BTRFS_CHUNK_TREE_OBJECTID:
- printf("chunk");
+ fprintf(fp, "chunk");
break;
case BTRFS_DEV_TREE_OBJECTID:
- printf("device");
+ fprintf(fp, "device");
break;
case BTRFS_FS_TREE_OBJECTID:
- printf("fs");
+ fprintf(fp, "fs");
break;
case BTRFS_ROOT_TREE_DIR_OBJECTID:
- printf("directory");
+ fprintf(fp, "directory");
break;
case BTRFS_CSUM_TREE_OBJECTID:
- printf("checksum");
+ fprintf(fp, "checksum");
break;
case BTRFS_ORPHAN_OBJECTID:
- printf("orphan");
+ fprintf(fp, "orphan");
break;
case BTRFS_TREE_LOG_OBJECTID:
- printf("log");
+ fprintf(fp, "log");
break;
case BTRFS_TREE_LOG_FIXUP_OBJECTID:
- printf("log fixup");
+ fprintf(fp, "log fixup");
break;
case BTRFS_TREE_RELOC_OBJECTID:
- printf("reloc");
+ fprintf(fp, "reloc");
break;
case BTRFS_DATA_RELOC_TREE_OBJECTID:
- printf("data reloc");
+ fprintf(fp, "data reloc");
break;
case BTRFS_EXTENT_CSUM_OBJECTID:
- printf("extent checksum");
+ fprintf(fp, "extent checksum");
break;
case BTRFS_MULTIPLE_OBJECTIDS:
- printf("multiple");
+ fprintf(fp, "multiple");
break;
default:
- printf("file");
+ fprintf(fp, "file");
}
- printf(" tree ");
- btrfs_print_key(&disk_key);
- printf(" \n");
- btrfs_print_tree(tree_root_scan, buf);
+ fprintf(fp, " tree ");
+ btrfs_print_key(fp, &disk_key);
+ fprintf(fp, " \n");
+ btrfs_print_tree(fp, tree_root_scan, buf);
}
path.slots[0]++;
@@ -227,12 +250,13 @@ again:
goto again;
}
- printf("total bytes %llu\n",
+ fprintf(fp, "total bytes %llu\n",
(unsigned long long)btrfs_super_total_bytes(¤t_fs_root->fs_info->super_copy));
- printf("bytes used %llu\n",
+ fprintf(fp, "bytes used %llu\n",
(unsigned long long)btrfs_super_bytes_used(¤t_fs_root->fs_info->super_copy));
uuidbuf[36] = '\0';
uuid_unparse(current_fs_root->fs_info->super_copy.fsid, uuidbuf);
- printf("uuid %s\n", uuidbuf);
+ fprintf(fp, "uuid %s\n", uuidbuf);
+ close_pager(fp);
return;
}
new file mode 100644
@@ -0,0 +1,49 @@
+/* derived from e2fsprogs debugfs/util.c */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+#include <string.h>
+
+static const char *pager_search_list[] = { "pager", "more", "less", 0 };
+static const char *pager_dir_list[] = { "/usr/bin", "/bin", 0 };
+
+static const char *find_pager(char *buf)
+{
+ const char **i, **j;
+
+ for (i = pager_search_list; *i; i++) {
+ for (j = pager_dir_list; *j; j++) {
+ sprintf(buf, "%s/%s", *j, *i);
+ if (access(buf, X_OK) == 0)
+ return(buf);
+ }
+ }
+ return 0;
+}
+
+FILE *open_pager(void)
+{
+ FILE *outfile = 0;
+ const char *pager = getenv("DEBUGFS_PAGER");
+ char buf[80];
+
+ signal(SIGPIPE, SIG_IGN);
+ if (!isatty(1))
+ return stdout;
+ if (!pager)
+ pager = getenv("PAGER");
+ if (!pager)
+ pager = find_pager(buf);
+ if (!pager ||
+ (strcmp(pager, "__none__") == 0) ||
+ ((outfile = popen(pager, "w")) == 0))
+ return stdout;
+ return outfile;
+}
+
+void close_pager(FILE *stream)
+{
+ if (stream && stream != stdout) pclose(stream);
+}
@@ -657,13 +657,13 @@ static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
btrfs_item_key(leaf, &leaf_key, slot);
btrfs_item_key_to_cpu(leaf, &cpukey, slot - 1);
if (btrfs_comp_keys(&leaf_key, &cpukey) <= 0) {
- btrfs_print_leaf(root, leaf);
+ btrfs_print_leaf(stdout, root, leaf);
printk("slot %d offset bad key\n", slot);
BUG_ON(1);
}
if (btrfs_item_offset_nr(leaf, slot - 1) !=
btrfs_item_end_nr(leaf, slot)) {
- btrfs_print_leaf(root, leaf);
+ btrfs_print_leaf(stdout, root, leaf);
printk("slot %d offset bad\n", slot);
BUG_ON(1);
}
@@ -674,7 +674,7 @@ static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
BUG_ON(btrfs_comp_keys(&leaf_key, &cpukey) >= 0);
if (btrfs_item_offset_nr(leaf, slot) !=
btrfs_item_end_nr(leaf, slot + 1)) {
- btrfs_print_leaf(root, leaf);
+ btrfs_print_leaf(stdout, root, leaf);
printk("slot %d offset bad\n", slot);
BUG_ON(1);
}
@@ -2356,7 +2356,7 @@ split:
ret = 0;
if (btrfs_leaf_free_space(root, leaf) < 0) {
- btrfs_print_leaf(root, leaf);
+ btrfs_print_leaf(stdout, root, leaf);
BUG();
}
kfree(buf);
@@ -2456,7 +2456,7 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans,
ret = 0;
if (btrfs_leaf_free_space(root, leaf) < 0) {
- btrfs_print_leaf(root, leaf);
+ btrfs_print_leaf(stdout, root, leaf);
BUG();
}
return ret;
@@ -2484,7 +2484,7 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans,
data_end = leaf_data_end(root, leaf);
if (btrfs_leaf_free_space(root, leaf) < data_size) {
- btrfs_print_leaf(root, leaf);
+ btrfs_print_leaf(stdout, root, leaf);
BUG();
}
slot = path->slots[0];
@@ -2492,7 +2492,7 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans,
BUG_ON(slot < 0);
if (slot >= nritems) {
- btrfs_print_leaf(root, leaf);
+ btrfs_print_leaf(stdout, root, leaf);
printk("slot %d too large, nritems %d\n", slot, nritems);
BUG_ON(1);
}
@@ -2521,7 +2521,7 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans,
ret = 0;
if (btrfs_leaf_free_space(root, leaf) < 0) {
- btrfs_print_leaf(root, leaf);
+ btrfs_print_leaf(stdout, root, leaf);
BUG();
}
return ret;
@@ -2572,7 +2572,7 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
data_end = leaf_data_end(root, leaf);
if (btrfs_leaf_free_space(root, leaf) < total_size) {
- btrfs_print_leaf(root, leaf);
+ btrfs_print_leaf(stdout, root, leaf);
printk("not enough freespace need %u have %d\n",
total_size, btrfs_leaf_free_space(root, leaf));
BUG();
@@ -2586,7 +2586,7 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
unsigned int old_data = btrfs_item_end_nr(leaf, slot);
if (old_data < data_end) {
- btrfs_print_leaf(root, leaf);
+ btrfs_print_leaf(stdout, root, leaf);
printk("slot %d old_data %d data_end %d\n",
slot, old_data, data_end);
BUG_ON(1);
@@ -2634,7 +2634,7 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
}
if (btrfs_leaf_free_space(root, leaf) < 0) {
- btrfs_print_leaf(root, leaf);
+ btrfs_print_leaf(stdout, root, leaf);
BUG();
}
@@ -1447,7 +1447,7 @@ int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
if (ret < 0)
goto out;
if (ret != 0) {
- btrfs_print_leaf(root, path->nodes[0]);
+ btrfs_print_leaf(stdout, root, path->nodes[0]);
printk("failed to find block number %Lu\n", bytenr);
BUG();
}
@@ -1505,7 +1505,7 @@ int btrfs_set_block_flags(struct btrfs_trans_handle *trans,
if (ret < 0)
goto out;
if (ret != 0) {
- btrfs_print_leaf(root, path->nodes[0]);
+ btrfs_print_leaf(stdout, root, path->nodes[0]);
printk("failed to find block number %Lu\n",
(unsigned long long)bytenr);
BUG();
@@ -2126,13 +2126,13 @@ static int __free_extent(struct btrfs_trans_handle *trans,
printk(KERN_ERR "umm, got %d back from search"
", was looking for %llu\n", ret,
(unsigned long long)bytenr);
- btrfs_print_leaf(extent_root, path->nodes[0]);
+ btrfs_print_leaf(stdout, extent_root, path->nodes[0]);
}
BUG_ON(ret);
extent_slot = path->slots[0];
}
} else {
- btrfs_print_leaf(extent_root, path->nodes[0]);
+ btrfs_print_leaf(stdout, extent_root, path->nodes[0]);
WARN_ON(1);
printk(KERN_ERR "btrfs unable to find ref byte nr %llu "
"parent %llu root %llu owner %llu offset %llu\n",
@@ -2165,7 +2165,7 @@ static int __free_extent(struct btrfs_trans_handle *trans,
printk(KERN_ERR "umm, got %d back from search"
", was looking for %llu\n", ret,
(unsigned long long)bytenr);
- btrfs_print_leaf(extent_root, path->nodes[0]);
+ btrfs_print_leaf(stdout, extent_root, path->nodes[0]);
}
BUG_ON(ret);
extent_slot = path->slots[0];
@@ -25,7 +25,7 @@
#include "disk-io.h"
#include "print-tree.h"
-static int print_dir_item(struct extent_buffer *eb, struct btrfs_item *item,
+static int print_dir_item(FILE *out, struct extent_buffer *eb, struct btrfs_item *item,
struct btrfs_dir_item *di)
{
u32 total;
@@ -39,14 +39,14 @@ static int print_dir_item(struct extent_buffer *eb, struct btrfs_item *item,
total = btrfs_item_size(eb, item);
while(cur < total) {
btrfs_dir_item_key(eb, di, &location);
- printf("\t\tlocation ");
- btrfs_print_key(&location);
- printf(" type %u\n", btrfs_dir_type(eb, di));
+ fprintf(out, "\t\tlocation ");
+ btrfs_print_key(out, &location);
+ fprintf(out, " type %u\n", btrfs_dir_type(eb, di));
name_len = btrfs_dir_name_len(eb, di);
data_len = btrfs_dir_data_len(eb, di);
len = (name_len <= sizeof(namebuf))? name_len: sizeof(namebuf);
read_extent_buffer(eb, namebuf, (unsigned long)(di + 1), len);
- printf("\t\tnamelen %u datalen %u name: %.*s\n",
+ fprintf(out, "\t\tnamelen %u datalen %u name: %.*s\n",
name_len, data_len, len, namebuf);
len = sizeof(*di) + name_len + data_len;
di = (struct btrfs_dir_item *)((char *)di + len);
@@ -55,7 +55,7 @@ static int print_dir_item(struct extent_buffer *eb, struct btrfs_item *item,
return 0;
}
-static int print_inode_ref_item(struct extent_buffer *eb, struct btrfs_item *item,
+static int print_inode_ref_item(FILE *out, struct extent_buffer *eb, struct btrfs_item *item,
struct btrfs_inode_ref *ref)
{
u32 total;
@@ -70,7 +70,7 @@ static int print_inode_ref_item(struct extent_buffer *eb, struct btrfs_item *ite
index = btrfs_inode_ref_index(eb, ref);
len = (name_len <= sizeof(namebuf))? name_len: sizeof(namebuf);
read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
- printf("\t\tinode ref index %llu namelen %u name: %.*s\n",
+ fprintf(out, "\t\tinode ref index %llu namelen %u name: %.*s\n",
(unsigned long long)index, name_len, len, namebuf);
len = sizeof(*ref) + name_len;
ref = (struct btrfs_inode_ref *)((char *)ref + len);
@@ -79,32 +79,32 @@ static int print_inode_ref_item(struct extent_buffer *eb, struct btrfs_item *ite
return 0;
}
-static void print_chunk(struct extent_buffer *eb, struct btrfs_chunk *chunk)
+static void print_chunk(FILE *out, struct extent_buffer *eb, struct btrfs_chunk *chunk)
{
int num_stripes = btrfs_chunk_num_stripes(eb, chunk);
int i;
- printf("\t\tchunk length %llu owner %llu type %llu num_stripes %d\n",
+ fprintf(out, "\t\tchunk length %llu owner %llu type %llu num_stripes %d\n",
(unsigned long long)btrfs_chunk_length(eb, chunk),
(unsigned long long)btrfs_chunk_owner(eb, chunk),
(unsigned long long)btrfs_chunk_type(eb, chunk),
num_stripes);
for (i = 0 ; i < num_stripes ; i++) {
- printf("\t\t\tstripe %d devid %llu offset %llu\n", i,
+ fprintf(out, "\t\t\tstripe %d devid %llu offset %llu\n", i,
(unsigned long long)btrfs_stripe_devid_nr(eb, chunk, i),
(unsigned long long)btrfs_stripe_offset_nr(eb, chunk, i));
}
}
-static void print_dev_item(struct extent_buffer *eb,
+static void print_dev_item(FILE *out, struct extent_buffer *eb,
struct btrfs_dev_item *dev_item)
{
- printf("\t\tdev item devid %llu "
+ fprintf(out, "\t\tdev item devid %llu "
"total_bytes %llu bytes used %Lu\n",
(unsigned long long)btrfs_device_id(eb, dev_item),
(unsigned long long)btrfs_device_total_bytes(eb, dev_item),
(unsigned long long)btrfs_device_bytes_used(eb, dev_item));
}
-static void print_uuids(struct extent_buffer *eb)
+static void print_uuids(FILE *out, struct extent_buffer *eb)
{
char fs_uuid[37];
char chunk_uuid[37];
@@ -122,17 +122,17 @@ static void print_uuids(struct extent_buffer *eb)
chunk_uuid[36] = '\0';
uuid_unparse(disk_uuid, chunk_uuid);
- printf("fs uuid %s\nchunk uuid %s\n", fs_uuid, chunk_uuid);
+ fprintf(out, "fs uuid %s\nchunk uuid %s\n", fs_uuid, chunk_uuid);
}
-static void print_file_extent_item(struct extent_buffer *eb,
+static void print_file_extent_item(FILE *out, struct extent_buffer *eb,
struct btrfs_item *item,
struct btrfs_file_extent_item *fi)
{
int extent_type = btrfs_file_extent_type(eb, fi);
if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
- printf("\t\tinline extent data size %u "
+ fprintf(out, "\t\tinline extent data size %u "
"ram %u compress %d\n",
btrfs_file_extent_inline_item_len(eb, item),
btrfs_file_extent_inline_len(eb, fi),
@@ -140,26 +140,26 @@ static void print_file_extent_item(struct extent_buffer *eb,
return;
}
if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
- printf("\t\tprealloc data disk byte %llu nr %llu\n",
+ fprintf(out, "\t\tprealloc data disk byte %llu nr %llu\n",
(unsigned long long)btrfs_file_extent_disk_bytenr(eb, fi),
(unsigned long long)btrfs_file_extent_disk_num_bytes(eb, fi));
- printf("\t\tprealloc data offset %llu nr %llu\n",
+ fprintf(out, "\t\tprealloc data offset %llu nr %llu\n",
(unsigned long long)btrfs_file_extent_offset(eb, fi),
(unsigned long long)btrfs_file_extent_num_bytes(eb, fi));
return;
}
- printf("\t\textent data disk byte %llu nr %llu\n",
+ fprintf(out, "\t\textent data disk byte %llu nr %llu\n",
(unsigned long long)btrfs_file_extent_disk_bytenr(eb, fi),
(unsigned long long)btrfs_file_extent_disk_num_bytes(eb, fi));
- printf("\t\textent data offset %llu nr %llu ram %llu\n",
+ fprintf(out, "\t\textent data offset %llu nr %llu ram %llu\n",
(unsigned long long)btrfs_file_extent_offset(eb, fi),
(unsigned long long)btrfs_file_extent_num_bytes(eb, fi),
(unsigned long long)btrfs_file_extent_ram_bytes(eb, fi));
- printf("\t\textent compression %d\n",
+ fprintf(out, "\t\textent compression %d\n",
btrfs_file_extent_compression(eb, fi));
}
-static void print_extent_item(struct extent_buffer *eb, int slot)
+static void print_extent_item(FILE *out, struct extent_buffer *eb, int slot)
{
struct btrfs_extent_item *ei;
struct btrfs_extent_inline_ref *iref;
@@ -178,7 +178,7 @@ static void print_extent_item(struct extent_buffer *eb, int slot)
struct btrfs_extent_item_v0 *ei0;
BUG_ON(item_size != sizeof(*ei0));
ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
- printf("\t\textent refs %u\n",
+ fprintf(out, "\t\textent refs %u\n",
btrfs_extent_refs_v0(eb, ei0));
return;
#else
@@ -189,7 +189,7 @@ static void print_extent_item(struct extent_buffer *eb, int slot)
ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
flags = btrfs_extent_flags(eb, ei);
- printf("\t\textent refs %llu gen %llu flags %llu\n",
+ fprintf(out, "\t\textent refs %llu gen %llu flags %llu\n",
(unsigned long long)btrfs_extent_refs(eb, ei),
(unsigned long long)btrfs_extent_generation(eb, ei),
(unsigned long long)flags);
@@ -198,7 +198,7 @@ static void print_extent_item(struct extent_buffer *eb, int slot)
struct btrfs_tree_block_info *info;
info = (struct btrfs_tree_block_info *)(ei + 1);
btrfs_tree_block_key(eb, info, &key);
- printf("\t\ttree block key (%llu %x %llu) level %d\n",
+ fprintf(out, "\t\ttree block key (%llu %x %llu) level %d\n",
(unsigned long long)btrfs_disk_key_objectid(&key),
key.type,
(unsigned long long)btrfs_disk_key_offset(&key),
@@ -216,16 +216,16 @@ static void print_extent_item(struct extent_buffer *eb, int slot)
offset = btrfs_extent_inline_ref_offset(eb, iref);
switch (type) {
case BTRFS_TREE_BLOCK_REF_KEY:
- printf("\t\ttree block backref root %llu\n",
+ fprintf(out, "\t\ttree block backref root %llu\n",
(unsigned long long)offset);
break;
case BTRFS_SHARED_BLOCK_REF_KEY:
- printf("\t\tshared block backref parent %llu\n",
+ fprintf(out, "\t\tshared block backref parent %llu\n",
(unsigned long long)offset);
break;
case BTRFS_EXTENT_DATA_REF_KEY:
dref = (struct btrfs_extent_data_ref *)(&iref->offset);
- printf("\t\textent data backref root %llu "
+ fprintf(out, "\t\textent data backref root %llu "
"objectid %llu offset %llu count %u\n",
(unsigned long long)btrfs_extent_data_ref_root(eb, dref),
(unsigned long long)btrfs_extent_data_ref_objectid(eb, dref),
@@ -234,7 +234,7 @@ static void print_extent_item(struct extent_buffer *eb, int slot)
break;
case BTRFS_SHARED_DATA_REF_KEY:
sref = (struct btrfs_shared_data_ref *)(iref + 1);
- printf("\t\tshared data backref parent %llu count %u\n",
+ fprintf(out, "\t\tshared data backref parent %llu count %u\n",
(unsigned long long)offset,
btrfs_shared_data_ref_count(eb, sref));
break;
@@ -247,12 +247,12 @@ static void print_extent_item(struct extent_buffer *eb, int slot)
}
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
-static void print_extent_ref_v0(struct extent_buffer *eb, int slot)
+static void print_extent_ref_v0(FILE *out, struct extent_buffer *eb, int slot)
{
struct btrfs_extent_ref_v0 *ref0;
ref0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_ref_v0);
- printf("\t\textent back ref root %llu gen %llu "
+ fprintf(out, "\t\textent back ref root %llu gen %llu "
"owner %llu num_refs %lu\n",
(unsigned long long)btrfs_ref_root_v0(eb, ref0),
(unsigned long long)btrfs_ref_generation_v0(eb, ref0),
@@ -261,7 +261,7 @@ static void print_extent_ref_v0(struct extent_buffer *eb, int slot)
}
#endif
-static void print_root_ref(struct extent_buffer *leaf, int slot, char *tag)
+static void print_root_ref(FILE *out, struct extent_buffer *leaf, int slot, char *tag)
{
struct btrfs_root_ref *ref;
char namebuf[BTRFS_NAME_LEN];
@@ -270,169 +270,169 @@ static void print_root_ref(struct extent_buffer *leaf, int slot, char *tag)
ref = btrfs_item_ptr(leaf, slot, struct btrfs_root_ref);
namelen = btrfs_root_ref_name_len(leaf, ref);
read_extent_buffer(leaf, namebuf, (unsigned long)(ref + 1), namelen);
- printf("\t\troot %s key dirid %llu sequence %llu name %.*s\n", tag,
+ fprintf(out, "\t\troot %s key dirid %llu sequence %llu name %.*s\n", tag,
(unsigned long long)btrfs_root_ref_dirid(leaf, ref),
(unsigned long long)btrfs_root_ref_sequence(leaf, ref),
namelen, namebuf);
}
-static void print_key_type(u8 type)
+static void print_key_type(FILE *out, u8 type)
{
switch (type) {
case BTRFS_INODE_ITEM_KEY:
- printf("INODE_ITEM");
+ fprintf(out, "INODE_ITEM");
break;
case BTRFS_INODE_REF_KEY:
- printf("INODE_REF");
+ fprintf(out, "INODE_REF");
break;
case BTRFS_DIR_ITEM_KEY:
- printf("DIR_ITEM");
+ fprintf(out, "DIR_ITEM");
break;
case BTRFS_DIR_INDEX_KEY:
- printf("DIR_INDEX");
+ fprintf(out, "DIR_INDEX");
break;
case BTRFS_DIR_LOG_ITEM_KEY:
- printf("DIR_LOG_ITEM");
+ fprintf(out, "DIR_LOG_ITEM");
break;
case BTRFS_DIR_LOG_INDEX_KEY:
- printf("DIR_LOG_INDEX");
+ fprintf(out, "DIR_LOG_INDEX");
break;
case BTRFS_XATTR_ITEM_KEY:
- printf("XATTR_ITEM");
+ fprintf(out, "XATTR_ITEM");
break;
case BTRFS_ORPHAN_ITEM_KEY:
- printf("ORPHAN_ITEM");
+ fprintf(out, "ORPHAN_ITEM");
break;
case BTRFS_ROOT_ITEM_KEY:
- printf("ROOT_ITEM");
+ fprintf(out, "ROOT_ITEM");
break;
case BTRFS_ROOT_REF_KEY:
- printf("ROOT_REF");
+ fprintf(out, "ROOT_REF");
break;
case BTRFS_ROOT_BACKREF_KEY:
- printf("ROOT_BACKREF");
+ fprintf(out, "ROOT_BACKREF");
break;
case BTRFS_EXTENT_ITEM_KEY:
- printf("EXTENT_ITEM");
+ fprintf(out, "EXTENT_ITEM");
break;
case BTRFS_TREE_BLOCK_REF_KEY:
- printf("TREE_BLOCK_REF");
+ fprintf(out, "TREE_BLOCK_REF");
break;
case BTRFS_SHARED_BLOCK_REF_KEY:
- printf("SHARED_BLOCK_REF");
+ fprintf(out, "SHARED_BLOCK_REF");
break;
case BTRFS_EXTENT_DATA_REF_KEY:
- printf("EXTENT_DATA_REF");
+ fprintf(out, "EXTENT_DATA_REF");
break;
case BTRFS_SHARED_DATA_REF_KEY:
- printf("SHARED_DATA_REF");
+ fprintf(out, "SHARED_DATA_REF");
break;
case BTRFS_EXTENT_REF_V0_KEY:
- printf("EXTENT_REF_V0");
+ fprintf(out, "EXTENT_REF_V0");
break;
case BTRFS_CSUM_ITEM_KEY:
- printf("CSUM_ITEM");
+ fprintf(out, "CSUM_ITEM");
break;
case BTRFS_EXTENT_CSUM_KEY:
- printf("EXTENT_CSUM");
+ fprintf(out, "EXTENT_CSUM");
break;
case BTRFS_EXTENT_DATA_KEY:
- printf("EXTENT_DATA");
+ fprintf(out, "EXTENT_DATA");
break;
case BTRFS_BLOCK_GROUP_ITEM_KEY:
- printf("BLOCK_GROUP_ITEM");
+ fprintf(out, "BLOCK_GROUP_ITEM");
break;
case BTRFS_CHUNK_ITEM_KEY:
- printf("CHUNK_ITEM");
+ fprintf(out, "CHUNK_ITEM");
break;
case BTRFS_DEV_ITEM_KEY:
- printf("DEV_ITEM");
+ fprintf(out, "DEV_ITEM");
break;
case BTRFS_DEV_EXTENT_KEY:
- printf("DEV_EXTENT");
+ fprintf(out, "DEV_EXTENT");
break;
case BTRFS_STRING_ITEM_KEY:
- printf("STRING_ITEM");
+ fprintf(out, "STRING_ITEM");
break;
default:
- printf("UNKNOWN");
+ fprintf(out, "UNKNOWN");
};
}
-static void print_objectid(unsigned long long objectid, u8 type)
+static void print_objectid(FILE *out, unsigned long long objectid, u8 type)
{
if (type == BTRFS_DEV_EXTENT_KEY) {
- printf("%llu", objectid); /* device id */
+ fprintf(out, "%llu", objectid); /* device id */
return;
}
switch (objectid) {
case BTRFS_ROOT_TREE_OBJECTID:
if (type == BTRFS_DEV_ITEM_KEY)
- printf("DEV_ITEMS");
+ fprintf(out, "DEV_ITEMS");
else
- printf("ROOT_TREE");
+ fprintf(out, "ROOT_TREE");
break;
case BTRFS_EXTENT_TREE_OBJECTID:
- printf("EXTENT_TREE");
+ fprintf(out, "EXTENT_TREE");
break;
case BTRFS_CHUNK_TREE_OBJECTID:
- printf("CHUNK_TREE");
+ fprintf(out, "CHUNK_TREE");
break;
case BTRFS_DEV_TREE_OBJECTID:
- printf("DEV_TREE");
+ fprintf(out, "DEV_TREE");
break;
case BTRFS_FS_TREE_OBJECTID:
- printf("FS_TREE");
+ fprintf(out, "FS_TREE");
break;
case BTRFS_ROOT_TREE_DIR_OBJECTID:
- printf("ROOT_TREE_DIR");
+ fprintf(out, "ROOT_TREE_DIR");
break;
case BTRFS_CSUM_TREE_OBJECTID:
- printf("CSUM_TREE");
+ fprintf(out, "CSUM_TREE");
break;
case BTRFS_ORPHAN_OBJECTID:
- printf("ORPHAN");
+ fprintf(out, "ORPHAN");
break;
case BTRFS_TREE_LOG_OBJECTID:
- printf("TREE_LOG");
+ fprintf(out, "TREE_LOG");
break;
case BTRFS_TREE_LOG_FIXUP_OBJECTID:
- printf("LOG_FIXUP");
+ fprintf(out, "LOG_FIXUP");
break;
case BTRFS_TREE_RELOC_OBJECTID:
- printf("TREE_RELOC");
+ fprintf(out, "TREE_RELOC");
break;
case BTRFS_DATA_RELOC_TREE_OBJECTID:
- printf("DATA_RELOC_TREE");
+ fprintf(out, "DATA_RELOC_TREE");
break;
case BTRFS_EXTENT_CSUM_OBJECTID:
- printf("EXTENT_CSUM");
+ fprintf(out, "EXTENT_CSUM");
break;
case BTRFS_MULTIPLE_OBJECTIDS:
- printf("MULTIPLE");
+ fprintf(out, "MULTIPLE");
break;
case BTRFS_FIRST_CHUNK_TREE_OBJECTID:
- printf("FIRST_CHUNK_TREE");
+ fprintf(out, "FIRST_CHUNK_TREE");
break;
default:
- printf("%llu", objectid);
+ fprintf(out, "%llu", objectid);
}
}
-void btrfs_print_key(struct btrfs_disk_key *disk_key)
+void btrfs_print_key(FILE *out, struct btrfs_disk_key *disk_key)
{
u8 type;
- printf("key (");
+ fprintf(out, "key (");
type = btrfs_disk_key_type(disk_key);
- print_objectid((unsigned long long)btrfs_disk_key_objectid(disk_key),
+ print_objectid(out, (unsigned long long)btrfs_disk_key_objectid(disk_key),
type);
- printf(" ");
- print_key_type(type);
- printf(" %llu)", (unsigned long long)btrfs_disk_key_offset(disk_key));
+ fprintf(out, " ");
+ print_key_type(out, type);
+ fprintf(out, " %llu)", (unsigned long long)btrfs_disk_key_offset(disk_key));
}
-void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
+void btrfs_print_leaf(FILE *out, struct btrfs_root *root, struct extent_buffer *l)
{
int i;
char *str;
@@ -454,26 +454,26 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
u32 nr = btrfs_header_nritems(l);
u32 type;
- printf("leaf %llu items %d free space %d generation %llu owner %llu\n",
+ fprintf(out, "leaf %llu items %d free space %d generation %llu owner %llu\n",
(unsigned long long)btrfs_header_bytenr(l), nr,
btrfs_leaf_free_space(root, l),
(unsigned long long)btrfs_header_generation(l),
(unsigned long long)btrfs_header_owner(l));
- print_uuids(l);
- fflush(stdout);
+ print_uuids(out, l);
+ fflush(out);
for (i = 0 ; i < nr ; i++) {
item = btrfs_item_nr(l, i);
btrfs_item_key(l, &disk_key, i);
type = btrfs_disk_key_type(&disk_key);
- printf("\titem %d ", i);
- btrfs_print_key(&disk_key);
- printf(" itemoff %d itemsize %d\n",
+ fprintf(out, "\titem %d ", i);
+ btrfs_print_key(out, &disk_key);
+ fprintf(out, " itemoff %d itemsize %d\n",
btrfs_item_offset(l, item),
btrfs_item_size(l, item));
switch (type) {
case BTRFS_INODE_ITEM_KEY:
ii = btrfs_item_ptr(l, i, struct btrfs_inode_item);
- printf("\t\tinode generation %llu size %llu block group %llu mode %o links %u\n",
+ fprintf(out, "\t\tinode generation %llu size %llu block group %llu mode %o links %u\n",
(unsigned long long)btrfs_inode_generation(l, ii),
(unsigned long long)btrfs_inode_size(l, ii),
(unsigned long long)btrfs_inode_block_group(l,ii),
@@ -482,27 +482,27 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
break;
case BTRFS_INODE_REF_KEY:
iref = btrfs_item_ptr(l, i, struct btrfs_inode_ref);
- print_inode_ref_item(l, item, iref);
+ print_inode_ref_item(out, l, item, iref);
break;
case BTRFS_DIR_ITEM_KEY:
case BTRFS_DIR_INDEX_KEY:
case BTRFS_XATTR_ITEM_KEY:
di = btrfs_item_ptr(l, i, struct btrfs_dir_item);
- print_dir_item(l, item, di);
+ print_dir_item(out, l, item, di);
break;
case BTRFS_DIR_LOG_INDEX_KEY:
case BTRFS_DIR_LOG_ITEM_KEY:
dlog = btrfs_item_ptr(l, i, struct btrfs_dir_log_item);
- printf("\t\tdir log end %Lu\n",
+ fprintf(out, "\t\tdir log end %Lu\n",
btrfs_dir_log_end(l, dlog));
break;
case BTRFS_ORPHAN_ITEM_KEY:
- printf("\t\torphan item\n");
+ fprintf(out, "\t\torphan item\n");
break;
case BTRFS_ROOT_ITEM_KEY:
ri = btrfs_item_ptr(l, i, struct btrfs_root_item);
read_extent_buffer(l, &root_item, (unsigned long)ri, sizeof(root_item));
- printf("\t\troot data bytenr %llu level %d dirid %llu refs %u\n",
+ fprintf(out, "\t\troot data bytenr %llu level %d dirid %llu refs %u\n",
(unsigned long long)btrfs_root_bytenr(&root_item),
btrfs_root_level(&root_item),
(unsigned long long)btrfs_root_dirid(&root_item),
@@ -511,29 +511,29 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
struct btrfs_key drop_key;
btrfs_disk_key_to_cpu(&drop_key,
&root_item.drop_progress);
- printf("\t\tdrop ");
- btrfs_print_key(&root_item.drop_progress);
- printf(" level %d\n", root_item.drop_level);
+ fprintf(out, "\t\tdrop ");
+ btrfs_print_key(out, &root_item.drop_progress);
+ fprintf(out, " level %d\n", root_item.drop_level);
}
break;
case BTRFS_ROOT_REF_KEY:
- print_root_ref(l, i, "ref");
+ print_root_ref(out, l, i, "ref");
break;
case BTRFS_ROOT_BACKREF_KEY:
- print_root_ref(l, i, "backref");
+ print_root_ref(out, l, i, "backref");
break;
case BTRFS_EXTENT_ITEM_KEY:
- print_extent_item(l, i);
+ print_extent_item(out, l, i);
break;
case BTRFS_TREE_BLOCK_REF_KEY:
- printf("\t\ttree block backref\n");
+ fprintf(out, "\t\ttree block backref\n");
break;
case BTRFS_SHARED_BLOCK_REF_KEY:
- printf("\t\tshared block backref\n");
+ fprintf(out, "\t\tshared block backref\n");
break;
case BTRFS_EXTENT_DATA_REF_KEY:
dref = btrfs_item_ptr(l, i, struct btrfs_extent_data_ref);
- printf("\t\textent data backref root %llu "
+ fprintf(out, "\t\textent data backref root %llu "
"objectid %llu offset %llu count %u\n",
(unsigned long long)btrfs_extent_data_ref_root(l, dref),
(unsigned long long)btrfs_extent_data_ref_objectid(l, dref),
@@ -542,50 +542,50 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
break;
case BTRFS_SHARED_DATA_REF_KEY:
sref = btrfs_item_ptr(l, i, struct btrfs_shared_data_ref);
- printf("\t\tshared data backref count %u\n",
+ fprintf(out, "\t\tshared data backref count %u\n",
btrfs_shared_data_ref_count(l, sref));
break;
case BTRFS_EXTENT_REF_V0_KEY:
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
- print_extent_ref_v0(l, i);
+ print_extent_ref_v0(out, l, i);
#else
BUG();
#endif
break;
case BTRFS_CSUM_ITEM_KEY:
ci = btrfs_item_ptr(l, i, struct btrfs_csum_item);
- printf("\t\tcsum item\n");
+ fprintf(out, "\t\tcsum item\n");
break;
case BTRFS_EXTENT_CSUM_KEY:
ci = btrfs_item_ptr(l, i, struct btrfs_csum_item);
- printf("\t\textent csum item\n");
+ fprintf(out, "\t\textent csum item\n");
break;
case BTRFS_EXTENT_DATA_KEY:
fi = btrfs_item_ptr(l, i,
struct btrfs_file_extent_item);
- print_file_extent_item(l, item, fi);
+ print_file_extent_item(out, l, item, fi);
break;
case BTRFS_BLOCK_GROUP_ITEM_KEY:
bi = btrfs_item_ptr(l, i,
struct btrfs_block_group_item);
read_extent_buffer(l, &bg_item, (unsigned long)bi,
sizeof(bg_item));
- printf("\t\tblock group used %llu chunk_objectid %llu flags %llu\n",
+ fprintf(out, "\t\tblock group used %llu chunk_objectid %llu flags %llu\n",
(unsigned long long)btrfs_block_group_used(&bg_item),
(unsigned long long)btrfs_block_group_chunk_objectid(&bg_item),
(unsigned long long)btrfs_block_group_flags(&bg_item));
break;
case BTRFS_CHUNK_ITEM_KEY:
- print_chunk(l, btrfs_item_ptr(l, i, struct btrfs_chunk));
+ print_chunk(out, l, btrfs_item_ptr(l, i, struct btrfs_chunk));
break;
case BTRFS_DEV_ITEM_KEY:
- print_dev_item(l, btrfs_item_ptr(l, i,
+ print_dev_item(out, l, btrfs_item_ptr(l, i,
struct btrfs_dev_item));
break;
case BTRFS_DEV_EXTENT_KEY:
dev_extent = btrfs_item_ptr(l, i,
struct btrfs_dev_extent);
- printf("\t\tdev extent chunk_tree %llu\n"
+ fprintf(out, "\t\tdev extent chunk_tree %llu\n"
"\t\tchunk objectid %llu chunk offset %llu "
"length %llu\n",
(unsigned long long)
@@ -600,14 +600,14 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
case BTRFS_STRING_ITEM_KEY:
/* dirty, but it's simple */
str = l->data + btrfs_item_ptr_offset(l, i);
- printf("\t\titem data %.*s\n", btrfs_item_size(l, item), str);
+ fprintf(out, "\t\titem data %.*s\n", btrfs_item_size(l, item), str);
break;
};
- fflush(stdout);
+ fflush(out);
}
}
-void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *eb)
+void btrfs_print_tree(FILE *out, struct btrfs_root *root, struct extent_buffer *eb)
{
int i;
u32 nr;
@@ -619,29 +619,29 @@ void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *eb)
return;
nr = btrfs_header_nritems(eb);
if (btrfs_is_leaf(eb)) {
- btrfs_print_leaf(root, eb);
+ btrfs_print_leaf(out, root, eb);
return;
}
- printf("node %llu level %d items %d free %u generation %llu owner %llu\n",
+ fprintf(out, "node %llu level %d items %d free %u generation %llu owner %llu\n",
(unsigned long long)eb->start,
btrfs_header_level(eb), nr,
(u32)BTRFS_NODEPTRS_PER_BLOCK(root) - nr,
(unsigned long long)btrfs_header_generation(eb),
(unsigned long long)btrfs_header_owner(eb));
- print_uuids(eb);
- fflush(stdout);
+ print_uuids(out, eb);
+ fflush(out);
size = btrfs_level_size(root, btrfs_header_level(eb) - 1);
for (i = 0; i < nr; i++) {
u64 blocknr = btrfs_node_blockptr(eb, i);
btrfs_node_key(eb, &disk_key, i);
btrfs_disk_key_to_cpu(&key, &disk_key);
- printf("\t");
- btrfs_print_key(&disk_key);
- printf(" block %llu (%llu) gen %llu\n",
+ fprintf(out, "\t");
+ btrfs_print_key(out, &disk_key);
+ fprintf(out, " block %llu (%llu) gen %llu\n",
(unsigned long long)blocknr,
(unsigned long long)blocknr / size,
(unsigned long long)btrfs_node_ptr_generation(eb, i));
- fflush(stdout);
+ fflush(out);
}
for (i = 0; i < nr; i++) {
struct extent_buffer *next = read_tree_block(root,
@@ -660,7 +660,7 @@ void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *eb)
if (btrfs_header_level(next) !=
btrfs_header_level(eb) - 1)
BUG();
- btrfs_print_tree(root, next);
+ btrfs_print_tree(out, root, next);
free_extent_buffer(next);
}
}
@@ -18,7 +18,9 @@
#ifndef __PRINT_TREE_
#define __PRINT_TREE_
-void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l);
-void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *t);
-void btrfs_print_key(struct btrfs_disk_key *disk_key);
+#include <stdio.h>
+
+void btrfs_print_leaf(FILE *out, struct btrfs_root *root, struct extent_buffer *l);
+void btrfs_print_tree(FILE *out, struct btrfs_root *root, struct extent_buffer *t);
+void btrfs_print_key(FILE *out, struct btrfs_disk_key *disk_key);
#endif
@@ -182,12 +182,11 @@ int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
if (ret < 0)
goto out;
if (ret) {
-btrfs_print_leaf(root, path->nodes[0]);
-printk("failed to del %llu %u %llu\n",
- (unsigned long long)key->objectid,
- key->type,
- (unsigned long long)key->offset);
-
+ btrfs_print_leaf(stdout, root, path->nodes[0]);
+ printk("failed to del %llu %u %llu\n",
+ (unsigned long long)key->objectid,
+ key->type,
+ (unsigned long long)key->offset);
}
BUG_ON(ret != 0);
leaf = path->nodes[0];
@@ -144,11 +144,11 @@ int main(int ac, char **av)
}
if (!extent_only) {
printf("root tree\n");
- btrfs_print_tree(root->fs_info->tree_root,
+ btrfs_print_tree(stdout, root->fs_info->tree_root,
root->fs_info->tree_root->node);
printf("chunk tree\n");
- btrfs_print_tree(root->fs_info->chunk_root,
+ btrfs_print_tree(stdout, root->fs_info->chunk_root,
root->fs_info->chunk_root->node);
}
tree_root_scan = root->fs_info->tree_root;
@@ -258,9 +258,9 @@ again:
}
if (!skip && !extent_only) {
printf(" tree ");
- btrfs_print_key(&disk_key);
+ btrfs_print_key(stdout, &disk_key);
printf(" \n");
- btrfs_print_tree(tree_root_scan, buf);
+ btrfs_print_tree(stdout, tree_root_scan, buf);
} else if (extent_only && !skip) {
print_extents(tree_root_scan, buf);
}