2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public
4 * License v2 as published by the Free Software Foundation.
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
9 * General Public License for more details.
11 * You should have received a copy of the GNU General Public
12 * License along with this program; if not, write to the
13 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
14 * Boston, MA 021110-1307, USA.
17 #include "kerncompat.h"
24 #include <uuid/uuid.h>
30 #include "print-tree.h"
31 #include "transaction.h"
36 #include "cmds-inspect-dump-super.h"
38 static int check_csum_sblock(void *sb
, int csum_size
)
40 u8 result
[BTRFS_CSUM_SIZE
];
43 crc
= btrfs_csum_data(NULL
, (char *)sb
+ BTRFS_CSUM_SIZE
,
44 crc
, BTRFS_SUPER_INFO_SIZE
- BTRFS_CSUM_SIZE
);
45 btrfs_csum_final(crc
, result
);
47 return !memcmp(sb
, &result
, csum_size
);
50 static void print_sys_chunk_array(struct btrfs_super_block
*sb
)
52 struct extent_buffer
*buf
;
53 struct btrfs_disk_key
*disk_key
;
54 struct btrfs_chunk
*chunk
;
56 unsigned long sb_array_offset
;
64 buf
= malloc(sizeof(*buf
) + sizeof(*sb
));
66 error("not enough memory");
69 write_extent_buffer(buf
, sb
, 0, sizeof(*sb
));
70 array_size
= btrfs_super_sys_array_size(sb
);
72 array_ptr
= sb
->sys_chunk_array
;
73 sb_array_offset
= offsetof(struct btrfs_super_block
, sys_chunk_array
);
77 while (cur_offset
< array_size
) {
78 disk_key
= (struct btrfs_disk_key
*)array_ptr
;
79 len
= sizeof(*disk_key
);
80 if (cur_offset
+ len
> array_size
)
83 btrfs_disk_key_to_cpu(&key
, disk_key
);
86 sb_array_offset
+= len
;
89 printf("\titem %d ", item
);
90 btrfs_print_key(disk_key
);
93 if (key
.type
== BTRFS_CHUNK_ITEM_KEY
) {
94 chunk
= (struct btrfs_chunk
*)sb_array_offset
;
96 * At least one btrfs_chunk with one stripe must be
97 * present, exact stripe count check comes afterwards
99 len
= btrfs_chunk_item_size(1);
100 if (cur_offset
+ len
> array_size
)
103 num_stripes
= btrfs_chunk_num_stripes(buf
, chunk
);
106 "invalid number of stripes %u in sys_array at offset %u",
107 num_stripes
, cur_offset
);
110 len
= btrfs_chunk_item_size(num_stripes
);
111 if (cur_offset
+ len
> array_size
)
113 print_chunk(buf
, chunk
);
115 error("unexpected item type %u in sys_array at offset %u",
116 (u32
)key
.type
, cur_offset
);
120 sb_array_offset
+= len
;
131 error("sys_array too short to read %u bytes at offset %u",
136 static int empty_backup(struct btrfs_root_backup
*backup
)
138 if (backup
== NULL
||
139 (backup
->tree_root
== 0 &&
140 backup
->tree_root_gen
== 0))
145 static void print_root_backup(struct btrfs_root_backup
*backup
)
147 printf("\t\tbackup_tree_root:\t%llu\tgen: %llu\tlevel: %d\n",
148 btrfs_backup_tree_root(backup
),
149 btrfs_backup_tree_root_gen(backup
),
150 btrfs_backup_tree_root_level(backup
));
151 printf("\t\tbackup_chunk_root:\t%llu\tgen: %llu\tlevel: %d\n",
152 btrfs_backup_chunk_root(backup
),
153 btrfs_backup_chunk_root_gen(backup
),
154 btrfs_backup_chunk_root_level(backup
));
155 printf("\t\tbackup_extent_root:\t%llu\tgen: %llu\tlevel: %d\n",
156 btrfs_backup_extent_root(backup
),
157 btrfs_backup_extent_root_gen(backup
),
158 btrfs_backup_extent_root_level(backup
));
159 printf("\t\tbackup_fs_root:\t\t%llu\tgen: %llu\tlevel: %d\n",
160 btrfs_backup_fs_root(backup
),
161 btrfs_backup_fs_root_gen(backup
),
162 btrfs_backup_fs_root_level(backup
));
163 printf("\t\tbackup_dev_root:\t%llu\tgen: %llu\tlevel: %d\n",
164 btrfs_backup_dev_root(backup
),
165 btrfs_backup_dev_root_gen(backup
),
166 btrfs_backup_dev_root_level(backup
));
167 printf("\t\tbackup_csum_root:\t%llu\tgen: %llu\tlevel: %d\n",
168 btrfs_backup_csum_root(backup
),
169 btrfs_backup_csum_root_gen(backup
),
170 btrfs_backup_csum_root_level(backup
));
172 printf("\t\tbackup_total_bytes:\t%llu\n",
173 btrfs_backup_total_bytes(backup
));
174 printf("\t\tbackup_bytes_used:\t%llu\n",
175 btrfs_backup_bytes_used(backup
));
176 printf("\t\tbackup_num_devices:\t%llu\n",
177 btrfs_backup_num_devices(backup
));
181 static void print_backup_roots(struct btrfs_super_block
*sb
)
183 struct btrfs_root_backup
*backup
;
186 for (i
= 0; i
< BTRFS_NUM_BACKUP_ROOTS
; i
++) {
187 backup
= sb
->super_roots
+ i
;
188 if (!empty_backup(backup
)) {
189 printf("\tbackup %d:\n", i
);
190 print_root_backup(backup
);
195 struct readable_flag_entry
{
200 #define DEF_COMPAT_RO_FLAG_ENTRY(bit_name) \
201 {BTRFS_FEATURE_COMPAT_RO_##bit_name, #bit_name}
203 static struct readable_flag_entry compat_ro_flags_array
[] = {
204 DEF_COMPAT_RO_FLAG_ENTRY(FREE_SPACE_TREE
),
205 DEF_COMPAT_RO_FLAG_ENTRY(FREE_SPACE_TREE_VALID
),
207 static const int compat_ro_flags_num
= sizeof(compat_ro_flags_array
) /
208 sizeof(struct readable_flag_entry
);
210 #define DEF_INCOMPAT_FLAG_ENTRY(bit_name) \
211 {BTRFS_FEATURE_INCOMPAT_##bit_name, #bit_name}
213 static struct readable_flag_entry incompat_flags_array
[] = {
214 DEF_INCOMPAT_FLAG_ENTRY(MIXED_BACKREF
),
215 DEF_INCOMPAT_FLAG_ENTRY(DEFAULT_SUBVOL
),
216 DEF_INCOMPAT_FLAG_ENTRY(MIXED_GROUPS
),
217 DEF_INCOMPAT_FLAG_ENTRY(COMPRESS_LZO
),
218 DEF_INCOMPAT_FLAG_ENTRY(COMPRESS_LZOv2
),
219 DEF_INCOMPAT_FLAG_ENTRY(BIG_METADATA
),
220 DEF_INCOMPAT_FLAG_ENTRY(EXTENDED_IREF
),
221 DEF_INCOMPAT_FLAG_ENTRY(RAID56
),
222 DEF_INCOMPAT_FLAG_ENTRY(SKINNY_METADATA
),
223 DEF_INCOMPAT_FLAG_ENTRY(NO_HOLES
)
225 static const int incompat_flags_num
= sizeof(incompat_flags_array
) /
226 sizeof(struct readable_flag_entry
);
228 #define DEF_HEADER_FLAG_ENTRY(bit_name) \
229 {BTRFS_HEADER_FLAG_##bit_name, #bit_name}
230 #define DEF_SUPER_FLAG_ENTRY(bit_name) \
231 {BTRFS_SUPER_FLAG_##bit_name, #bit_name}
233 static struct readable_flag_entry super_flags_array
[] = {
234 DEF_HEADER_FLAG_ENTRY(WRITTEN
),
235 DEF_HEADER_FLAG_ENTRY(RELOC
),
236 DEF_SUPER_FLAG_ENTRY(CHANGING_FSID
),
237 DEF_SUPER_FLAG_ENTRY(SEEDING
),
238 DEF_SUPER_FLAG_ENTRY(METADUMP
),
239 DEF_SUPER_FLAG_ENTRY(METADUMP_V2
)
241 static const int super_flags_num
= ARRAY_SIZE(super_flags_array
);
243 #define BTRFS_SUPER_FLAG_SUPP (BTRFS_HEADER_FLAG_WRITTEN |\
244 BTRFS_HEADER_FLAG_RELOC |\
245 BTRFS_SUPER_FLAG_CHANGING_FSID |\
246 BTRFS_SUPER_FLAG_SEEDING |\
247 BTRFS_SUPER_FLAG_METADUMP |\
248 BTRFS_SUPER_FLAG_METADUMP_V2)
250 static void __print_readable_flag(u64 flag
, struct readable_flag_entry
*array
,
251 int array_size
, u64 supported_flags
)
255 struct readable_flag_entry
*entry
;
261 for (i
= 0; i
< array_size
; i
++) {
263 if (flag
& entry
->bit
) {
265 printf("%s ", entry
->output
);
267 printf("|\n\t\t\t %s ", entry
->output
);
271 flag
&= ~supported_flags
;
274 printf("unknown flag: 0x%llx ", flag
);
276 printf("|\n\t\t\t unknown flag: 0x%llx ", flag
);
281 static void print_readable_compat_ro_flag(u64 flag
)
284 * We know about the FREE_SPACE_TREE{,_VALID} bits, but we don't
285 * actually support them yet.
287 return __print_readable_flag(flag
, compat_ro_flags_array
,
289 BTRFS_FEATURE_COMPAT_RO_SUPP
|
290 BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE
|
291 BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID
);
294 static void print_readable_incompat_flag(u64 flag
)
296 return __print_readable_flag(flag
, incompat_flags_array
,
298 BTRFS_FEATURE_INCOMPAT_SUPP
);
301 static void print_readable_super_flag(u64 flag
)
303 return __print_readable_flag(flag
, super_flags_array
,
304 super_flags_num
, BTRFS_SUPER_FLAG_SUPP
);
307 static void dump_superblock(struct btrfs_super_block
*sb
, int full
)
310 char *s
, buf
[BTRFS_UUID_UNPARSED_SIZE
];
315 csum_type
= btrfs_super_csum_type(sb
);
316 csum_size
= BTRFS_CSUM_SIZE
;
317 printf("csum_type\t\t%hu (", csum_type
);
318 if (csum_type
>= ARRAY_SIZE(btrfs_csum_sizes
)) {
321 if (csum_type
== BTRFS_CSUM_TYPE_CRC32
) {
323 csum_size
= btrfs_csum_sizes
[csum_type
];
329 printf("csum_size\t\t%llu\n", (unsigned long long)csum_size
);
331 printf("csum\t\t\t0x");
332 for (i
= 0, p
= sb
->csum
; i
< csum_size
; i
++)
333 printf("%02x", p
[i
]);
334 if (check_csum_sblock(sb
, csum_size
))
337 printf(" [DON'T MATCH]");
340 printf("bytenr\t\t\t%llu\n",
341 (unsigned long long)btrfs_super_bytenr(sb
));
342 printf("flags\t\t\t0x%llx\n",
343 (unsigned long long)btrfs_super_flags(sb
));
344 print_readable_super_flag(btrfs_super_flags(sb
));
346 printf("magic\t\t\t");
347 s
= (char *) &sb
->magic
;
348 for (i
= 0; i
< 8; i
++)
349 putchar(isprint(s
[i
]) ? s
[i
] : '.');
350 if (btrfs_super_magic(sb
) == BTRFS_MAGIC
)
351 printf(" [match]\n");
353 printf(" [DON'T MATCH]\n");
355 uuid_unparse(sb
->fsid
, buf
);
356 printf("fsid\t\t\t%s\n", buf
);
358 printf("label\t\t\t");
360 for (i
= 0; i
< BTRFS_LABEL_SIZE
&& s
[i
]; i
++)
361 putchar(isprint(s
[i
]) ? s
[i
] : '.');
364 printf("generation\t\t%llu\n",
365 (unsigned long long)btrfs_super_generation(sb
));
366 printf("root\t\t\t%llu\n", (unsigned long long)btrfs_super_root(sb
));
367 printf("sys_array_size\t\t%llu\n",
368 (unsigned long long)btrfs_super_sys_array_size(sb
));
369 printf("chunk_root_generation\t%llu\n",
370 (unsigned long long)btrfs_super_chunk_root_generation(sb
));
371 printf("root_level\t\t%llu\n",
372 (unsigned long long)btrfs_super_root_level(sb
));
373 printf("chunk_root\t\t%llu\n",
374 (unsigned long long)btrfs_super_chunk_root(sb
));
375 printf("chunk_root_level\t%llu\n",
376 (unsigned long long)btrfs_super_chunk_root_level(sb
));
377 printf("log_root\t\t%llu\n",
378 (unsigned long long)btrfs_super_log_root(sb
));
379 printf("log_root_transid\t%llu\n",
380 (unsigned long long)btrfs_super_log_root_transid(sb
));
381 printf("log_root_level\t\t%llu\n",
382 (unsigned long long)btrfs_super_log_root_level(sb
));
383 printf("total_bytes\t\t%llu\n",
384 (unsigned long long)btrfs_super_total_bytes(sb
));
385 printf("bytes_used\t\t%llu\n",
386 (unsigned long long)btrfs_super_bytes_used(sb
));
387 printf("sectorsize\t\t%llu\n",
388 (unsigned long long)btrfs_super_sectorsize(sb
));
389 printf("nodesize\t\t%llu\n",
390 (unsigned long long)btrfs_super_nodesize(sb
));
391 printf("leafsize\t\t%llu\n",
392 (unsigned long long)btrfs_super_leafsize(sb
));
393 printf("stripesize\t\t%llu\n",
394 (unsigned long long)btrfs_super_stripesize(sb
));
395 printf("root_dir\t\t%llu\n",
396 (unsigned long long)btrfs_super_root_dir(sb
));
397 printf("num_devices\t\t%llu\n",
398 (unsigned long long)btrfs_super_num_devices(sb
));
399 printf("compat_flags\t\t0x%llx\n",
400 (unsigned long long)btrfs_super_compat_flags(sb
));
401 printf("compat_ro_flags\t\t0x%llx\n",
402 (unsigned long long)btrfs_super_compat_ro_flags(sb
));
403 print_readable_compat_ro_flag(btrfs_super_compat_ro_flags(sb
));
404 printf("incompat_flags\t\t0x%llx\n",
405 (unsigned long long)btrfs_super_incompat_flags(sb
));
406 print_readable_incompat_flag(btrfs_super_incompat_flags(sb
));
407 printf("cache_generation\t%llu\n",
408 (unsigned long long)btrfs_super_cache_generation(sb
));
409 printf("uuid_tree_generation\t%llu\n",
410 (unsigned long long)btrfs_super_uuid_tree_generation(sb
));
412 uuid_unparse(sb
->dev_item
.uuid
, buf
);
413 printf("dev_item.uuid\t\t%s\n", buf
);
415 uuid_unparse(sb
->dev_item
.fsid
, buf
);
416 printf("dev_item.fsid\t\t%s %s\n", buf
,
417 !memcmp(sb
->dev_item
.fsid
, sb
->fsid
, BTRFS_FSID_SIZE
) ?
418 "[match]" : "[DON'T MATCH]");
420 printf("dev_item.type\t\t%llu\n", (unsigned long long)
421 btrfs_stack_device_type(&sb
->dev_item
));
422 printf("dev_item.total_bytes\t%llu\n", (unsigned long long)
423 btrfs_stack_device_total_bytes(&sb
->dev_item
));
424 printf("dev_item.bytes_used\t%llu\n", (unsigned long long)
425 btrfs_stack_device_bytes_used(&sb
->dev_item
));
426 printf("dev_item.io_align\t%u\n", (unsigned int)
427 btrfs_stack_device_io_align(&sb
->dev_item
));
428 printf("dev_item.io_width\t%u\n", (unsigned int)
429 btrfs_stack_device_io_width(&sb
->dev_item
));
430 printf("dev_item.sector_size\t%u\n", (unsigned int)
431 btrfs_stack_device_sector_size(&sb
->dev_item
));
432 printf("dev_item.devid\t\t%llu\n",
433 btrfs_stack_device_id(&sb
->dev_item
));
434 printf("dev_item.dev_group\t%u\n", (unsigned int)
435 btrfs_stack_device_group(&sb
->dev_item
));
436 printf("dev_item.seek_speed\t%u\n", (unsigned int)
437 btrfs_stack_device_seek_speed(&sb
->dev_item
));
438 printf("dev_item.bandwidth\t%u\n", (unsigned int)
439 btrfs_stack_device_bandwidth(&sb
->dev_item
));
440 printf("dev_item.generation\t%llu\n", (unsigned long long)
441 btrfs_stack_device_generation(&sb
->dev_item
));
443 printf("sys_chunk_array[%d]:\n", BTRFS_SYSTEM_CHUNK_ARRAY_SIZE
);
444 print_sys_chunk_array(sb
);
445 printf("backup_roots[%d]:\n", BTRFS_NUM_BACKUP_ROOTS
);
446 print_backup_roots(sb
);
450 static int load_and_dump_sb(char *filename
, int fd
, u64 sb_bytenr
, int full
,
453 u8 super_block_data
[BTRFS_SUPER_INFO_SIZE
];
454 struct btrfs_super_block
*sb
;
457 sb
= (struct btrfs_super_block
*)super_block_data
;
459 ret
= pread64(fd
, super_block_data
, BTRFS_SUPER_INFO_SIZE
, sb_bytenr
);
460 if (ret
!= BTRFS_SUPER_INFO_SIZE
) {
461 /* check if the disk if too short for further superblock */
462 if (ret
== 0 && errno
== 0)
465 error("failed to read the superblock on %s at %llu",
466 filename
, (unsigned long long)sb_bytenr
);
467 error("error = '%s', errno = %d", strerror(errno
), errno
);
470 printf("superblock: bytenr=%llu, device=%s\n", sb_bytenr
, filename
);
471 printf("---------------------------------------------------------\n");
472 if (btrfs_super_magic(sb
) != BTRFS_MAGIC
&& !force
) {
473 error("bad magic on superblock on %s at %llu",
474 filename
, (unsigned long long)sb_bytenr
);
476 dump_superblock(sb
, full
);
481 const char * const cmd_inspect_dump_super_usage
[] = {
482 "btrfs inspect-internal dump-super [options] device [device...]",
483 "Dump superblock from a device in a textual form",
484 "-f|--full print full superblock information, backup roots etc.",
485 "-a|--all print information about all superblocks",
486 "-s|--super <super> specify which copy to print out (values: 0, 1, 2)",
487 "-F|--force attempt to dump superblocks with bad magic",
488 "--bytenr <offset> specify alternate superblock offset",
490 "Deprecated syntax:",
491 "-s <bytenr> specify alternate superblock offset, values other than 0, 1, 2",
492 " will be interpreted as --bytenr for backward compatibility,",
493 " option renamed for consistency with other tools (eg. check)",
494 "-i <super> specify which copy to print out (values: 0, 1, 2), now moved",
499 int cmd_inspect_dump_super(int argc
, char **argv
)
509 u64 sb_bytenr
= btrfs_sb_offset(0);
513 static const struct option long_options
[] = {
514 {"all", no_argument
, NULL
, 'a'},
515 {"full", no_argument
, NULL
, 'f'},
516 {"force", no_argument
, NULL
, 'F'},
517 {"super", required_argument
, NULL
, 's' },
521 c
= getopt_long(argc
, argv
, "fFai:s:", long_options
, NULL
);
528 "option -i is deprecated, please use -s or --super");
529 arg
= arg_strtou64(optarg
);
530 if (arg
>= BTRFS_SUPER_MIRROR_MAX
) {
531 error("super mirror too big: %llu >= %d",
532 arg
, BTRFS_SUPER_MIRROR_MAX
);
535 sb_bytenr
= btrfs_sb_offset(arg
);
548 arg
= arg_strtou64(optarg
);
549 if (BTRFS_SUPER_MIRROR_MAX
<= arg
) {
551 "deprecated use of -s <bytenr> with %llu, assuming --bytenr",
552 (unsigned long long)arg
);
555 sb_bytenr
= btrfs_sb_offset(arg
);
560 usage(cmd_inspect_dump_super_usage
);
564 if (check_argc_min(argc
- optind
, 1))
565 usage(cmd_inspect_dump_super_usage
);
567 for (i
= optind
; i
< argc
; i
++) {
569 fd
= open(filename
, O_RDONLY
);
571 error("cannot open %s: %s", filename
, strerror(errno
));
579 for (idx
= 0; idx
< BTRFS_SUPER_MIRROR_MAX
; idx
++) {
580 sb_bytenr
= btrfs_sb_offset(idx
);
581 if (load_and_dump_sb(filename
, fd
,
582 sb_bytenr
, full
, force
)) {
591 load_and_dump_sb(filename
, fd
, sb_bytenr
, full
, force
);