* Boston, MA 021110-1307, USA.
*/
-#define _XOPEN_SOURCE 500
-#define _GNU_SOURCE 1
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "print-tree.h"
#include "transaction.h"
#include "list.h"
-#include "version.h"
#include "utils.h"
#include "crc32c.h"
static void print_usage(void);
-static void dump_superblock(struct btrfs_super_block *sb);
+static void dump_superblock(struct btrfs_super_block *sb, int full);
int main(int argc, char **argv);
-static int load_and_dump_sb(char *, int fd, u64 sb_bytenr);
+static int load_and_dump_sb(char *, int fd, u64 sb_bytenr, int full, int force);
static void print_usage(void)
{
fprintf(stderr,
- "usage: btrfs-show-super [-i super_mirror|-a] dev [dev..]\n");
- fprintf(stderr, "\tThe super_mirror number is between 0 and %d.\n",
- BTRFS_SUPER_MIRROR_MAX - 1);
- fprintf(stderr, "\tIf -a is passed all the superblocks are showed.\n");
- fprintf(stderr, "%s\n", BTRFS_BUILD_VERSION);
+ "usage: btrfs-show-super [-i super_mirror|-a|-f|-F] dev [dev..]\n");
+ fprintf(stderr, "\t-f : print full superblock information\n");
+ fprintf(stderr, "\t-a : print information of all superblocks\n");
+ fprintf(stderr, "\t-i <super_mirror> : specify which mirror to print out\n");
+ fprintf(stderr, "\t-F : attempt to dump superblocks with bad magic\n");
+ fprintf(stderr, "\t-s <bytenr> : specify alternate superblock offset\n");
+ fprintf(stderr, "%s\n", PACKAGE_STRING);
}
int main(int argc, char **argv)
{
int opt;
int all = 0;
+ int full = 0;
+ int force = 0;
char *filename;
int fd = -1;
- int arg, i;
+ int i;
+ u64 arg;
u64 sb_bytenr = btrfs_sb_offset(0);
- while ((opt = getopt(argc, argv, "ai:")) != -1) {
+ while ((opt = getopt(argc, argv, "fFai:s:")) != -1) {
switch (opt) {
case 'i':
- arg = atoi(optarg);
-
- if (arg < 0 || arg >= BTRFS_SUPER_MIRROR_MAX) {
+ arg = arg_strtou64(optarg);
+ if (arg >= BTRFS_SUPER_MIRROR_MAX) {
fprintf(stderr,
- "Illegal super_mirror %d\n",
+ "Illegal super_mirror %llu\n",
arg);
print_usage();
exit(1);
case 'a':
all = 1;
break;
-
+ case 'f':
+ full = 1;
+ break;
+ case 'F':
+ force = 1;
+ break;
+ case 's':
+ sb_bytenr = arg_strtou64(optarg);
+ all = 0;
+ break;
default:
print_usage();
exit(1);
}
}
- if (argc < optind + 1) {
+ set_argv0(argv);
+ if (check_argc_min(argc - optind, 1)) {
print_usage();
exit(1);
}
int idx;
for (idx = 0; idx < BTRFS_SUPER_MIRROR_MAX; idx++) {
sb_bytenr = btrfs_sb_offset(idx);
- if (load_and_dump_sb(filename, fd, sb_bytenr)) {
+ if (load_and_dump_sb(filename, fd,
+ sb_bytenr, full, force)) {
close(fd);
exit(1);
}
putchar('\n');
}
} else {
- load_and_dump_sb(filename, fd, sb_bytenr);
+ load_and_dump_sb(filename, fd, sb_bytenr, full, force);
putchar('\n');
}
close(fd);
exit(0);
}
-static int load_and_dump_sb(char *filename, int fd, u64 sb_bytenr)
+static int load_and_dump_sb(char *filename, int fd, u64 sb_bytenr, int full,
+ int force)
{
u8 super_block_data[BTRFS_SUPER_INFO_SIZE];
struct btrfs_super_block *sb;
}
printf("superblock: bytenr=%llu, device=%s\n", sb_bytenr, filename);
printf("---------------------------------------------------------\n");
- dump_superblock(sb);
+ if (btrfs_super_magic(sb) != BTRFS_MAGIC && !force) {
+ fprintf(stderr,
+ "ERROR: bad magic on superblock on %s at %llu\n",
+ filename, (unsigned long long)sb_bytenr);
+ } else {
+ dump_superblock(sb, full);
+ }
return 0;
}
return !memcmp(sb, &result, csum_size);
}
-static void dump_superblock(struct btrfs_super_block *sb)
+static void print_sys_chunk_array(struct btrfs_super_block *sb)
+{
+ struct extent_buffer *buf;
+ struct btrfs_disk_key *disk_key;
+ struct btrfs_chunk *chunk;
+ struct btrfs_key key;
+ u8 *ptr, *array_end;
+ u32 num_stripes;
+ u32 len = 0;
+ int i = 0;
+
+ buf = malloc(sizeof(*buf) + sizeof(*sb));
+ if (!buf) {
+ fprintf(stderr, "%s\n", strerror(ENOMEM));
+ exit(1);
+ }
+ write_extent_buffer(buf, sb, 0, sizeof(*sb));
+ ptr = sb->sys_chunk_array;
+ array_end = ptr + btrfs_super_sys_array_size(sb);
+
+ while (ptr < array_end) {
+ disk_key = (struct btrfs_disk_key *)ptr;
+ btrfs_disk_key_to_cpu(&key, disk_key);
+
+ printf("\titem %d ", i);
+ btrfs_print_key(disk_key);
+
+ len = sizeof(*disk_key);
+ putchar('\n');
+ ptr += len;
+
+ if (key.type == BTRFS_CHUNK_ITEM_KEY) {
+ chunk = (struct btrfs_chunk *)(ptr - (u8 *)sb);
+ print_chunk(buf, chunk);
+ num_stripes = btrfs_chunk_num_stripes(buf, chunk);
+ len = btrfs_chunk_item_size(num_stripes);
+ } else {
+ BUG();
+ }
+
+ ptr += len;
+ i++;
+ }
+
+ free(buf);
+}
+
+static int empty_backup(struct btrfs_root_backup *backup)
+{
+ if (backup == NULL ||
+ (backup->tree_root == 0 &&
+ backup->tree_root_gen == 0))
+ return 1;
+ return 0;
+}
+
+static void print_root_backup(struct btrfs_root_backup *backup)
+{
+ printf("\t\tbackup_tree_root:\t%llu\tgen: %llu\tlevel: %d\n",
+ btrfs_backup_tree_root(backup),
+ btrfs_backup_tree_root_gen(backup),
+ btrfs_backup_tree_root_level(backup));
+ printf("\t\tbackup_chunk_root:\t%llu\tgen: %llu\tlevel: %d\n",
+ btrfs_backup_chunk_root(backup),
+ btrfs_backup_chunk_root_gen(backup),
+ btrfs_backup_chunk_root_level(backup));
+ printf("\t\tbackup_extent_root:\t%llu\tgen: %llu\tlevel: %d\n",
+ btrfs_backup_extent_root(backup),
+ btrfs_backup_extent_root_gen(backup),
+ btrfs_backup_extent_root_level(backup));
+ printf("\t\tbackup_fs_root:\t\t%llu\tgen: %llu\tlevel: %d\n",
+ btrfs_backup_fs_root(backup),
+ btrfs_backup_fs_root_gen(backup),
+ btrfs_backup_fs_root_level(backup));
+ printf("\t\tbackup_dev_root:\t%llu\tgen: %llu\tlevel: %d\n",
+ btrfs_backup_dev_root(backup),
+ btrfs_backup_dev_root_gen(backup),
+ btrfs_backup_dev_root_level(backup));
+ printf("\t\tbackup_csum_root:\t%llu\tgen: %llu\tlevel: %d\n",
+ btrfs_backup_csum_root(backup),
+ btrfs_backup_csum_root_gen(backup),
+ btrfs_backup_csum_root_level(backup));
+
+ printf("\t\tbackup_total_bytes:\t%llu\n",
+ btrfs_backup_total_bytes(backup));
+ printf("\t\tbackup_bytes_used:\t%llu\n",
+ btrfs_backup_bytes_used(backup));
+ printf("\t\tbackup_num_devices:\t%llu\n",
+ btrfs_backup_num_devices(backup));
+ putchar('\n');
+}
+
+static void print_backup_roots(struct btrfs_super_block *sb)
+{
+ struct btrfs_root_backup *backup;
+ int i;
+
+ for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
+ backup = sb->super_roots + i;
+ if (!empty_backup(backup)) {
+ printf("\tbackup %d:\n", i);
+ print_root_backup(backup);
+ }
+ }
+}
+
+struct readable_flag_entry {
+ u64 bit;
+ char *output;
+};
+
+#define DEF_INCOMPAT_FLAG_ENTRY(bit_name) \
+ {BTRFS_FEATURE_INCOMPAT_##bit_name, #bit_name}
+
+struct readable_flag_entry incompat_flags_array[] = {
+ DEF_INCOMPAT_FLAG_ENTRY(MIXED_BACKREF),
+ DEF_INCOMPAT_FLAG_ENTRY(DEFAULT_SUBVOL),
+ DEF_INCOMPAT_FLAG_ENTRY(MIXED_GROUPS),
+ DEF_INCOMPAT_FLAG_ENTRY(COMPRESS_LZO),
+ DEF_INCOMPAT_FLAG_ENTRY(COMPRESS_LZOv2),
+ DEF_INCOMPAT_FLAG_ENTRY(BIG_METADATA),
+ DEF_INCOMPAT_FLAG_ENTRY(EXTENDED_IREF),
+ DEF_INCOMPAT_FLAG_ENTRY(RAID56),
+ DEF_INCOMPAT_FLAG_ENTRY(SKINNY_METADATA),
+ DEF_INCOMPAT_FLAG_ENTRY(NO_HOLES)
+};
+static const int incompat_flags_num = sizeof(incompat_flags_array) /
+ sizeof(struct readable_flag_entry);
+
+#define DEF_HEADER_FLAG_ENTRY(bit_name) \
+ {BTRFS_HEADER_FLAG_##bit_name, #bit_name}
+#define DEF_SUPER_FLAG_ENTRY(bit_name) \
+ {BTRFS_SUPER_FLAG_##bit_name, #bit_name}
+
+struct readable_flag_entry super_flags_array[] = {
+ DEF_HEADER_FLAG_ENTRY(WRITTEN),
+ DEF_HEADER_FLAG_ENTRY(RELOC),
+ DEF_SUPER_FLAG_ENTRY(CHANGING_FSID),
+ DEF_SUPER_FLAG_ENTRY(SEEDING),
+ DEF_SUPER_FLAG_ENTRY(METADUMP),
+ DEF_SUPER_FLAG_ENTRY(METADUMP_V2)
+};
+static const int super_flags_num = ARRAY_SIZE(super_flags_array);
+
+#define BTRFS_SUPER_FLAG_SUPP (BTRFS_HEADER_FLAG_WRITTEN |\
+ BTRFS_HEADER_FLAG_RELOC |\
+ BTRFS_SUPER_FLAG_CHANGING_FSID |\
+ BTRFS_SUPER_FLAG_SEEDING |\
+ BTRFS_SUPER_FLAG_METADUMP |\
+ BTRFS_SUPER_FLAG_METADUMP_V2)
+
+static void __print_readable_flag(u64 flag, struct readable_flag_entry *array,
+ int array_size, u64 supported_flags)
+{
+ int i;
+ int first = 1;
+ struct readable_flag_entry *entry;
+
+ if (!flag)
+ return;
+
+ printf("\t\t\t( ");
+ for (i = 0; i < array_size; i++) {
+ entry = array + i;
+ if (flag & entry->bit) {
+ if (first)
+ printf("%s ", entry->output);
+ else
+ printf("|\n\t\t\t %s ", entry->output);
+ first = 0;
+ }
+ }
+ flag &= ~supported_flags;
+ if (flag) {
+ if (first)
+ printf("unknown flag: 0x%llx ", flag);
+ else
+ printf("|\n\t\t\t unknown flag: 0x%llx ", flag);
+ }
+ printf(")\n");
+}
+
+static void print_readable_incompat_flag(u64 flag)
+{
+ return __print_readable_flag(flag, incompat_flags_array,
+ incompat_flags_num,
+ BTRFS_FEATURE_INCOMPAT_SUPP);
+}
+
+static void print_readable_super_flag(u64 flag)
+{
+ return __print_readable_flag(flag, super_flags_array,
+ super_flags_num, BTRFS_SUPER_FLAG_SUPP);
+}
+
+static void dump_superblock(struct btrfs_super_block *sb, int full)
{
int i;
- char *s, buf[36+1];
+ char *s, buf[BTRFS_UUID_UNPARSED_SIZE];
u8 *p;
printf("csum\t\t\t0x");
(unsigned long long)btrfs_super_bytenr(sb));
printf("flags\t\t\t0x%llx\n",
(unsigned long long)btrfs_super_flags(sb));
+ print_readable_super_flag(btrfs_super_flags(sb));
printf("magic\t\t\t");
s = (char *) &sb->magic;
(unsigned long long)btrfs_super_compat_ro_flags(sb));
printf("incompat_flags\t\t0x%llx\n",
(unsigned long long)btrfs_super_incompat_flags(sb));
+ print_readable_incompat_flag(btrfs_super_incompat_flags(sb));
printf("csum_type\t\t%llu\n",
(unsigned long long)btrfs_super_csum_type(sb));
printf("csum_size\t\t%llu\n",
btrfs_stack_device_bandwidth(&sb->dev_item));
printf("dev_item.generation\t%llu\n", (unsigned long long)
btrfs_stack_device_generation(&sb->dev_item));
+ if (full) {
+ printf("sys_chunk_array[%d]:\n", BTRFS_SYSTEM_CHUNK_ARRAY_SIZE);
+ print_sys_chunk_array(sb);
+ printf("backup_roots[%d]:\n", BTRFS_NUM_BACKUP_ROOTS);
+ print_backup_roots(sb);
+ }
}