more pretty printing - owners

WIP

Signed-off-by: David Sterba <dsterba@suse.cz>

cmds-inspect.c

@@ -19,9 +19,11 @@
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <errno.h>
+#include <sys/stat.h>
 
 #include "kerncompat.h"
 #include "ioctl.h"
+#include "ctree.h"
 
 #include "commands.h"
 #include "btrfs-list.h"
@@ -236,12 +238,205 @@ out:
 	return ret;
 }
 
+static const char * const cmd_bsum_usage[] = {
+	"btrfs inspect-internal _bsum <blockno> <file>",
+	"Get file block checksum of given file",
+	NULL
+};
+
+static int csum_for_offset(int fd, u64 offset, u8 *csums, int *count)
+{
+	struct btrfs_ioctl_search_args args;
+	struct btrfs_ioctl_search_key *sk = &args.key;
+	struct btrfs_ioctl_search_header *sh;
+	int ret = 0;
+	int i;
+	unsigned off;
+	u32 *realcsums = (u32*)csums;
+
+	sk->tree_id = BTRFS_CSUM_TREE_OBJECTID;
+	sk->min_objectid = BTRFS_EXTENT_CSUM_OBJECTID;
+	sk->max_objectid = BTRFS_EXTENT_CSUM_OBJECTID;
+	sk->max_type = BTRFS_EXTENT_CSUM_KEY;
+	sk->min_type = BTRFS_EXTENT_CSUM_KEY;
+	sk->min_offset = offset;
+	sk->max_offset = (u64)-1;
+	sk->max_transid = (u64)-1;
+	sk->nr_items = 1;
+
+	printf("Search block: %llu\n", (unsigned long long)sk->min_offset);
+	ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
+	if (ret) {
+		printf("%s: search ioctl: ioctl ret=%d, error: %s\n", __func__, ret, strerror(errno));
+		ret = -1;
+		goto out;
+	}
+	if (sk->nr_items == 0) {
+		printf("no items found\n");
+		ret = -2;
+		goto out;
+	}
+	off = 0;
+	*count = 0;
+	for (i = 0; i < sk->nr_items; i++) {
+		u32 item;
+		int j;
+		int csum_size = sizeof(item);
+
+		sh = (struct btrfs_ioctl_search_header *)(args.buf +
+				off);
+
+		printf("SH: tid %llu objid %llu off %llu type %u len %u\n",
+				(unsigned long long)sh->transid,
+				(unsigned long long)sh->objectid,
+				(unsigned long long)sh->offset,
+				(unsigned)sh->type,
+				(unsigned)sh->len);
+
+		off += sizeof(*sh);
+		for (j = 0; j < sh->len / csum_size; j++) {
+			memcpy(&item, args.buf + off + j * csum_size, sizeof(item));
+			printf("DATA[%d]: u32 = 0x%08x\n", j, item);
+			realcsums[*count] = item;
+			*count += 1;
+		}
+		off += sh->len;
+
+		sk->min_objectid = sh->objectid;
+		sk->min_type = sh->type;
+		sk->min_offset = sh->offset;
+	}
+out:
+	return ret;
+}
+
+static int extent_offset_to_physical(int fd, u64 ino, u64 offset, u64 *phys)
+{
+	struct btrfs_ioctl_search_args args;
+	struct btrfs_ioctl_search_key *sk = &args.key;
+	struct btrfs_ioctl_search_header *sh;
+	int ret = 0;
+	unsigned off;
+	int i;
+
+	sk->tree_id = BTRFS_FS_TREE_OBJECTID;
+	sk->min_objectid = ino;
+	sk->max_objectid = ino;
+	sk->max_type = BTRFS_EXTENT_DATA_KEY;
+	sk->min_type = BTRFS_EXTENT_DATA_KEY;
+	sk->min_offset = offset;
+	sk->max_offset = (u64)-1;
+	sk->max_transid = (u64)-1;
+	sk->nr_items = 1;
+
+	printf("Search extent offset: %llu\n", (unsigned long long)sk->min_offset);
+	ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
+	if (ret) {
+		printf("%s: search ioctl: ioctl ret=%d, error: %s\n", __func__, ret, strerror(errno));
+		ret = -1;
+		goto out;
+	}
+	if (sk->nr_items == 0) {
+		printf("no items found\n");
+		ret = -2;
+		goto out;
+	}
+	off = 0;
+	for (i = 0; i < sk->nr_items; i++) {
+		struct btrfs_file_extent_item fi;
+
+		sh = (struct btrfs_ioctl_search_header *)(args.buf +
+				off);
+
+		printf("SH: tid %llu objid %llu off %llu type %u len %u\n",
+				(unsigned long long)sh->transid,
+				(unsigned long long)sh->objectid,
+				(unsigned long long)sh->offset,
+				(unsigned)sh->type,
+				(unsigned)sh->len);
+
+		off += sizeof(*sh);
+		/* process data */
+		memcpy(&fi, args.buf + off, sizeof(fi));
+		printf("FI: disk_bytenr %llu disk_num_bytes %llu offset %llu\n",
+				(unsigned long long)fi.disk_bytenr,
+				(unsigned long long)fi.disk_num_bytes,
+				(unsigned long long)fi.offset);
+		*phys = fi.disk_bytenr;
+
+		off += sh->len;
+
+		sk->min_objectid = sh->objectid;
+		sk->min_type = sh->type;
+		sk->min_offset = sh->offset;
+	}
+out:
+	return ret;
+}
+
+static int cmd_bsum(int argc, char **argv)
+{
+	int fd;
+	int ret = 0;
+	int j;
+	struct stat st;
+	u8 csums[4096];
+	int count = 0;
+	u64 offset = 0;
+	u64 phys = 0;
+
+	optind = 1;
+	while (1) {
+		int c = getopt(argc, argv, "");
+		if (c < 0)
+			break;
+
+		switch (c) {
+		default:
+			usage(cmd_logical_resolve_usage);
+		}
+	}
+
+	if (check_argc_exact(argc - optind, 2)) {
+		usage(cmd_logical_resolve_usage);
+		return 1;
+	}
+
+	fd = open_file_or_dir(argv[optind+1]);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access '%s'\n", argv[optind+1]);
+		ret = 12;
+		goto out;
+	}
+	offset = atoi(argv[optind]);
+	if(fstat(fd, &st) == -1) {
+		fprintf(stderr, "ERROR: stat\n");
+		ret = 1;
+		goto out;
+	}
+	printf("Inode: %llu\n", (unsigned long long)st.st_ino);
+	printf("Offset: %llu\n", (unsigned long long)offset);
+	extent_offset_to_physical(fd, st.st_ino, offset, &phys);
+	printf("Physical: %llu\n", (unsigned long long)phys);
+	csum_for_offset(fd, phys, csums, &count);
+	for (j = 0; j < count; j++) {
+		u32 *items = (u32*)csums;
+		printf("BLOCK[%d] CSUM=0x%x\n",
+			j, items[j]);
+	}
+
+out:
+	return ret;
+}
+
 const struct cmd_group inspect_cmd_group = {
 	inspect_cmd_group_usage, NULL, {
 		{ "inode-resolve", cmd_inode_resolve, cmd_inode_resolve_usage,
 			NULL, 0 },
 		{ "logical-resolve", cmd_logical_resolve,
 			cmd_logical_resolve_usage, NULL, 0 },
+		{ "_bsum", cmd_bsum,
+			cmd_bsum_usage, NULL, 0 },
 		{ 0, 0, 0, 0, 0 }
 	}
 };

kerncompat.h

@@ -260,3 +260,7 @@ typedef u64 __bitwise __be64;
 #ifndef noinline
 #define noinline
 #endif
+
+#define __ALIGN_KERNEL(x, a)            __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1)
+#define __ALIGN_KERNEL_MASK(x, mask)    (((x) + (mask)) & ~(mask))
+#define ALIGN(x, a)             __ALIGN_KERNEL((x), (a))

print-tree.c

@@ -25,6 +25,24 @@
 #include "disk-io.h"
 #include "print-tree.h"
 
+static const char* pretty_owner(u64 owner)
+{
+	static buf[32];
+
+	switch (owner) {
+	case BTRFS_ROOT_TREE_OBJECTID: return "ROOT_TREE(1)";
+	case BTRFS_EXTENT_TREE_OBJECTID: return "EXTENT_TREE(2)";
+	case BTRFS_CHUNK_TREE_OBJECTID: return "CHUNK_TREE(3)";
+	case BTRFS_DEV_TREE_OBJECTID: return "DEV_TREE(4)";
+	case BTRFS_FS_TREE_OBJECTID: return "FS_TREE(5)";
+	case BTRFS_CSUM_TREE_OBJECTID: return "CSUM_TREE(7)";
+	case BTRFS_QUOTA_TREE_OBJECTID: return "QUOTA_TREE(8)";
+	case BTRFS_TREE_RELOC_OBJECTID: return 	"TREE_RELOC(-8)";
+	case BTRFS_DATA_RELOC_TREE_OBJECTID: return "DATA_RELOC_TREE(-9)";
+	default: snprintf(buf, sizeof(buf), "%llu", (unsigned long long)owner); return buf;
+	}
+}
+
 static int print_dir_item(struct extent_buffer *eb, struct btrfs_item *item,
 			  struct btrfs_dir_item *di)
 {
@@ -89,9 +107,9 @@ static void print_chunk(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",
+	printf("\t\tchunk length %llu owner %s type %llu num_stripes %d\n",
 	       (unsigned long long)btrfs_chunk_length(eb, chunk),
-	       (unsigned long long)btrfs_chunk_owner(eb, chunk),
+	       pretty_owner(btrfs_chunk_owner(eb, chunk)),
 	       (unsigned long long)btrfs_chunk_type(eb, chunk),
 	       num_stripes);
 	for (i = 0 ; i < num_stripes ; i++) {
@@ -221,8 +239,8 @@ 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",
-			       (unsigned long long)offset);
+			printf("\t\ttree block backref root %s\n",
+			       pretty_owner(offset));
 			break;
 		case BTRFS_SHARED_BLOCK_REF_KEY:
 			printf("\t\tshared block backref parent %llu\n",
@@ -230,9 +248,9 @@ static void print_extent_item(struct extent_buffer *eb, int slot)
 			break;
 		case BTRFS_EXTENT_DATA_REF_KEY:
 			dref = (struct btrfs_extent_data_ref *)(&iref->offset);
-			printf("\t\textent data backref root %llu "
+			printf("\t\textent data backref root %s "
 			       "objectid %llu offset %llu count %u\n",
-			       (unsigned long long)btrfs_extent_data_ref_root(eb, dref),
+			       pretty_owner(btrfs_extent_data_ref_root(eb, dref)),
 			       (unsigned long long)btrfs_extent_data_ref_objectid(eb, dref),
 			       (unsigned long long)btrfs_extent_data_ref_offset(eb, dref),
 			       btrfs_extent_data_ref_count(eb, dref));
@@ -559,7 +577,10 @@ void btrfs_print_key(struct btrfs_disk_key *disk_key)
 			(unsigned long long)(offset & ((1ll << 48) - 1)));
 		break;
 	default:
-		printf(" %llu)", (unsigned long long)offset);
+		if (offset == (u64)-1)
+			printf(" (u64)-1)");
+		else
+			printf(" %llu)", (unsigned long long)offset);
 		break;
 	}
 }
@@ -587,11 +608,11 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
 	u64 objectid;
 	u32 type;
 
-	printf("leaf %llu items %d free space %d generation %llu owner %llu\n",
+	printf("leaf %llu items %d free space %d generation %llu owner %s\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));
+		pretty_owner(btrfs_header_owner(l)));
 	print_uuids(l);
 	fflush(stdout);
 	for (i = 0 ; i < nr ; i++) {
@@ -658,9 +679,9 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
 			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 "
+			printf("\t\textent data backref root %s "
 			       "objectid %llu offset %llu count %u\n",
-			       (unsigned long long)btrfs_extent_data_ref_root(l, dref),
+			       pretty_owner(btrfs_extent_data_ref_root(l, dref)),
 			       (unsigned long long)btrfs_extent_data_ref_objectid(l, dref),
 			       (unsigned long long)btrfs_extent_data_ref_offset(l, dref),
 			       btrfs_extent_data_ref_count(l, dref));
@@ -797,12 +818,12 @@ void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *eb, int fol
 		btrfs_print_leaf(root, eb);
 		return;
 	}
-	printf("node %llu level %d items %d free %u generation %llu owner %llu\n",
+	printf("node %llu level %d items %d free %u generation %llu owner %s\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));
+		pretty_owner(btrfs_header_owner(eb)));
 	print_uuids(eb);
 	fflush(stdout);
 	size = btrfs_level_size(root, btrfs_header_level(eb) - 1);
@@ -827,9 +848,9 @@ void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *eb, int fol
 					     size,
 					     btrfs_node_ptr_generation(eb, i));
 		if (!next) {
-			fprintf(stderr, "failed to read %llu in tree %llu\n",
+			fprintf(stderr, "failed to read %llu in tree %s\n",
 				(unsigned long long)btrfs_node_blockptr(eb, i),
-				(unsigned long long)btrfs_header_owner(eb));
+				pretty_owner(btrfs_header_owner(eb)));
 			continue;
 		}
 		if (btrfs_is_leaf(next) &&