2 * Copyright (C) 2012 STRATO AG. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
19 #define _XOPEN_SOURCE 500
27 #include <uuid/uuid.h>
30 #include "kerncompat.h"
33 #include "print-tree.h"
34 #include "transaction.h"
40 static void print_usage(void);
41 static void dump_superblock(struct btrfs_super_block
*sb
, int full
);
42 int main(int argc
, char **argv
);
43 static int load_and_dump_sb(char *, int fd
, u64 sb_bytenr
, int full
, int force
);
46 static void print_usage(void)
49 "usage: btrfs-show-super [-i super_mirror|-a|-f|-F] dev [dev..]\n");
50 fprintf(stderr
, "\t-f : print full superblock information\n");
51 fprintf(stderr
, "\t-a : print information of all superblocks\n");
52 fprintf(stderr
, "\t-i <super_mirror> : specify which mirror to print out\n");
53 fprintf(stderr
, "\t-F : attempt to dump superblocks with bad magic\n");
54 fprintf(stderr
, "%s\n", BTRFS_BUILD_VERSION
);
57 int main(int argc
, char **argv
)
67 u64 sb_bytenr
= btrfs_sb_offset(0);
69 while ((opt
= getopt(argc
, argv
, "fFai:")) != -1) {
72 arg
= arg_strtou64(optarg
);
73 if (arg
>= BTRFS_SUPER_MIRROR_MAX
) {
75 "Illegal super_mirror %llu\n",
80 sb_bytenr
= btrfs_sb_offset(arg
);
99 if (check_argc_min(argc
- optind
, 1)) {
104 for (i
= optind
; i
< argc
; i
++) {
106 fd
= open(filename
, O_RDONLY
, 0666);
108 fprintf(stderr
, "Could not open %s\n", filename
);
114 for (idx
= 0; idx
< BTRFS_SUPER_MIRROR_MAX
; idx
++) {
115 sb_bytenr
= btrfs_sb_offset(idx
);
116 if (load_and_dump_sb(filename
, fd
,
117 sb_bytenr
, full
, force
)) {
125 load_and_dump_sb(filename
, fd
, sb_bytenr
, full
, force
);
134 static int load_and_dump_sb(char *filename
, int fd
, u64 sb_bytenr
, int full
,
137 u8 super_block_data
[BTRFS_SUPER_INFO_SIZE
];
138 struct btrfs_super_block
*sb
;
141 sb
= (struct btrfs_super_block
*)super_block_data
;
143 ret
= pread64(fd
, super_block_data
, BTRFS_SUPER_INFO_SIZE
, sb_bytenr
);
144 if (ret
!= BTRFS_SUPER_INFO_SIZE
) {
147 /* check if the disk if too short for further superblock */
148 if (ret
== 0 && e
== 0)
152 "ERROR: Failed to read the superblock on %s at %llu\n",
153 filename
, (unsigned long long)sb_bytenr
);
155 "ERROR: error = '%s', errno = %d\n", strerror(e
), e
);
158 printf("superblock: bytenr=%llu, device=%s\n", sb_bytenr
, filename
);
159 printf("---------------------------------------------------------\n");
160 if (btrfs_super_magic(sb
) != BTRFS_MAGIC
&& !force
) {
162 "ERROR: bad magic on superblock on %s at %llu\n",
163 filename
, (unsigned long long)sb_bytenr
);
165 dump_superblock(sb
, full
);
170 static int check_csum_sblock(void *sb
, int csum_size
)
172 char result
[BTRFS_CSUM_SIZE
];
175 crc
= btrfs_csum_data(NULL
, (char *)sb
+ BTRFS_CSUM_SIZE
,
176 crc
, BTRFS_SUPER_INFO_SIZE
- BTRFS_CSUM_SIZE
);
177 btrfs_csum_final(crc
, result
);
179 return !memcmp(sb
, &result
, csum_size
);
182 static void print_sys_chunk_array(struct btrfs_super_block
*sb
)
184 struct extent_buffer
*buf
;
185 struct btrfs_disk_key
*disk_key
;
186 struct btrfs_chunk
*chunk
;
187 struct btrfs_key key
;
193 buf
= malloc(sizeof(*buf
) + sizeof(*sb
));
195 fprintf(stderr
, "%s\n", strerror(ENOMEM
));
198 write_extent_buffer(buf
, sb
, 0, sizeof(*sb
));
199 ptr
= sb
->sys_chunk_array
;
200 array_end
= ptr
+ btrfs_super_sys_array_size(sb
);
202 while (ptr
< array_end
) {
203 disk_key
= (struct btrfs_disk_key
*)ptr
;
204 btrfs_disk_key_to_cpu(&key
, disk_key
);
206 printf("\titem %d ", i
);
207 btrfs_print_key(disk_key
);
209 len
= sizeof(*disk_key
);
213 if (key
.type
== BTRFS_CHUNK_ITEM_KEY
) {
214 chunk
= (struct btrfs_chunk
*)(ptr
- (u8
*)sb
);
215 print_chunk(buf
, chunk
);
216 num_stripes
= btrfs_chunk_num_stripes(buf
, chunk
);
217 len
= btrfs_chunk_item_size(num_stripes
);
229 static int empty_backup(struct btrfs_root_backup
*backup
)
231 if (backup
== NULL
||
232 (backup
->tree_root
== 0 &&
233 backup
->tree_root_gen
== 0))
238 static void print_root_backup(struct btrfs_root_backup
*backup
)
240 printf("\t\tbackup_tree_root:\t%llu\tgen: %llu\tlevel: %d\n",
241 btrfs_backup_tree_root(backup
),
242 btrfs_backup_tree_root_gen(backup
),
243 btrfs_backup_tree_root_level(backup
));
244 printf("\t\tbackup_chunk_root:\t%llu\tgen: %llu\tlevel: %d\n",
245 btrfs_backup_chunk_root(backup
),
246 btrfs_backup_chunk_root_gen(backup
),
247 btrfs_backup_chunk_root_level(backup
));
248 printf("\t\tbackup_extent_root:\t%llu\tgen: %llu\tlevel: %d\n",
249 btrfs_backup_extent_root(backup
),
250 btrfs_backup_extent_root_gen(backup
),
251 btrfs_backup_extent_root_level(backup
));
252 printf("\t\tbackup_fs_root:\t\t%llu\tgen: %llu\tlevel: %d\n",
253 btrfs_backup_fs_root(backup
),
254 btrfs_backup_fs_root_gen(backup
),
255 btrfs_backup_fs_root_level(backup
));
256 printf("\t\tbackup_dev_root:\t%llu\tgen: %llu\tlevel: %d\n",
257 btrfs_backup_dev_root(backup
),
258 btrfs_backup_dev_root_gen(backup
),
259 btrfs_backup_dev_root_level(backup
));
260 printf("\t\tbackup_csum_root:\t%llu\tgen: %llu\tlevel: %d\n",
261 btrfs_backup_csum_root(backup
),
262 btrfs_backup_csum_root_gen(backup
),
263 btrfs_backup_csum_root_level(backup
));
265 printf("\t\tbackup_total_bytes:\t%llu\n",
266 btrfs_backup_total_bytes(backup
));
267 printf("\t\tbackup_bytes_used:\t%llu\n",
268 btrfs_backup_bytes_used(backup
));
269 printf("\t\tbackup_num_devices:\t%llu\n",
270 btrfs_backup_num_devices(backup
));
274 static void print_backup_roots(struct btrfs_super_block
*sb
)
276 struct btrfs_root_backup
*backup
;
279 for (i
= 0; i
< BTRFS_NUM_BACKUP_ROOTS
; i
++) {
280 backup
= sb
->super_roots
+ i
;
281 if (!empty_backup(backup
)) {
282 printf("\tbackup %d:\n", i
);
283 print_root_backup(backup
);
288 struct readable_flag_entry
{
293 #define DEF_INCOMPAT_FLAG_ENTRY(bit_name) \
294 {BTRFS_FEATURE_INCOMPAT_##bit_name, #bit_name}
296 struct readable_flag_entry incompat_flags_array
[] = {
297 DEF_INCOMPAT_FLAG_ENTRY(MIXED_BACKREF
),
298 DEF_INCOMPAT_FLAG_ENTRY(DEFAULT_SUBVOL
),
299 DEF_INCOMPAT_FLAG_ENTRY(MIXED_GROUPS
),
300 DEF_INCOMPAT_FLAG_ENTRY(COMPRESS_LZO
),
301 DEF_INCOMPAT_FLAG_ENTRY(COMPRESS_LZOv2
),
302 DEF_INCOMPAT_FLAG_ENTRY(BIG_METADATA
),
303 DEF_INCOMPAT_FLAG_ENTRY(EXTENDED_IREF
),
304 DEF_INCOMPAT_FLAG_ENTRY(RAID56
),
305 DEF_INCOMPAT_FLAG_ENTRY(SKINNY_METADATA
),
306 DEF_INCOMPAT_FLAG_ENTRY(NO_HOLES
)
308 static const int incompat_flags_num
= sizeof(incompat_flags_array
) /
309 sizeof(struct readable_flag_entry
);
311 static void print_readable_incompat_flag(u64 flag
)
315 struct readable_flag_entry
*entry
;
320 for (i
= 0; i
< incompat_flags_num
; i
++) {
321 entry
= incompat_flags_array
+ i
;
322 if (flag
& entry
->bit
) {
324 printf("%s ", entry
->output
);
326 printf("|\n\t\t\t %s ", entry
->output
);
330 flag
&= ~BTRFS_FEATURE_INCOMPAT_SUPP
;
333 printf("unknown flag: 0x%llx ", flag
);
335 printf("|\n\t\t\t unknown flag: 0x%llx ", flag
);
340 static void dump_superblock(struct btrfs_super_block
*sb
, int full
)
343 char *s
, buf
[BTRFS_UUID_UNPARSED_SIZE
];
346 printf("csum\t\t\t0x");
347 for (i
= 0, p
= sb
->csum
; i
< btrfs_super_csum_size(sb
); i
++)
348 printf("%02x", p
[i
]);
349 if (check_csum_sblock(sb
, btrfs_super_csum_size(sb
)))
352 printf(" [DON'T MATCH]");
355 printf("bytenr\t\t\t%llu\n",
356 (unsigned long long)btrfs_super_bytenr(sb
));
357 printf("flags\t\t\t0x%llx\n",
358 (unsigned long long)btrfs_super_flags(sb
));
360 printf("magic\t\t\t");
361 s
= (char *) &sb
->magic
;
362 for (i
= 0; i
< 8; i
++)
363 putchar(isprint(s
[i
]) ? s
[i
] : '.');
364 if (btrfs_super_magic(sb
) == BTRFS_MAGIC
)
365 printf(" [match]\n");
367 printf(" [DON'T MATCH]\n");
369 uuid_unparse(sb
->fsid
, buf
);
370 printf("fsid\t\t\t%s\n", buf
);
372 printf("label\t\t\t");
374 for (i
= 0; i
< BTRFS_LABEL_SIZE
&& s
[i
]; i
++)
375 putchar(isprint(s
[i
]) ? s
[i
] : '.');
378 printf("generation\t\t%llu\n",
379 (unsigned long long)btrfs_super_generation(sb
));
380 printf("root\t\t\t%llu\n", (unsigned long long)btrfs_super_root(sb
));
381 printf("sys_array_size\t\t%llu\n",
382 (unsigned long long)btrfs_super_sys_array_size(sb
));
383 printf("chunk_root_generation\t%llu\n",
384 (unsigned long long)btrfs_super_chunk_root_generation(sb
));
385 printf("root_level\t\t%llu\n",
386 (unsigned long long)btrfs_super_root_level(sb
));
387 printf("chunk_root\t\t%llu\n",
388 (unsigned long long)btrfs_super_chunk_root(sb
));
389 printf("chunk_root_level\t%llu\n",
390 (unsigned long long)btrfs_super_chunk_root_level(sb
));
391 printf("log_root\t\t%llu\n",
392 (unsigned long long)btrfs_super_log_root(sb
));
393 printf("log_root_transid\t%llu\n",
394 (unsigned long long)btrfs_super_log_root_transid(sb
));
395 printf("log_root_level\t\t%llu\n",
396 (unsigned long long)btrfs_super_log_root_level(sb
));
397 printf("total_bytes\t\t%llu\n",
398 (unsigned long long)btrfs_super_total_bytes(sb
));
399 printf("bytes_used\t\t%llu\n",
400 (unsigned long long)btrfs_super_bytes_used(sb
));
401 printf("sectorsize\t\t%llu\n",
402 (unsigned long long)btrfs_super_sectorsize(sb
));
403 printf("nodesize\t\t%llu\n",
404 (unsigned long long)btrfs_super_nodesize(sb
));
405 printf("leafsize\t\t%llu\n",
406 (unsigned long long)btrfs_super_leafsize(sb
));
407 printf("stripesize\t\t%llu\n",
408 (unsigned long long)btrfs_super_stripesize(sb
));
409 printf("root_dir\t\t%llu\n",
410 (unsigned long long)btrfs_super_root_dir(sb
));
411 printf("num_devices\t\t%llu\n",
412 (unsigned long long)btrfs_super_num_devices(sb
));
413 printf("compat_flags\t\t0x%llx\n",
414 (unsigned long long)btrfs_super_compat_flags(sb
));
415 printf("compat_ro_flags\t\t0x%llx\n",
416 (unsigned long long)btrfs_super_compat_ro_flags(sb
));
417 printf("incompat_flags\t\t0x%llx\n",
418 (unsigned long long)btrfs_super_incompat_flags(sb
));
419 print_readable_incompat_flag(btrfs_super_incompat_flags(sb
));
420 printf("csum_type\t\t%llu\n",
421 (unsigned long long)btrfs_super_csum_type(sb
));
422 printf("csum_size\t\t%llu\n",
423 (unsigned long long)btrfs_super_csum_size(sb
));
424 printf("cache_generation\t%llu\n",
425 (unsigned long long)btrfs_super_cache_generation(sb
));
426 printf("uuid_tree_generation\t%llu\n",
427 (unsigned long long)btrfs_super_uuid_tree_generation(sb
));
429 uuid_unparse(sb
->dev_item
.uuid
, buf
);
430 printf("dev_item.uuid\t\t%s\n", buf
);
432 uuid_unparse(sb
->dev_item
.fsid
, buf
);
433 printf("dev_item.fsid\t\t%s %s\n", buf
,
434 !memcmp(sb
->dev_item
.fsid
, sb
->fsid
, BTRFS_FSID_SIZE
) ?
435 "[match]" : "[DON'T MATCH]");
437 printf("dev_item.type\t\t%llu\n", (unsigned long long)
438 btrfs_stack_device_type(&sb
->dev_item
));
439 printf("dev_item.total_bytes\t%llu\n", (unsigned long long)
440 btrfs_stack_device_total_bytes(&sb
->dev_item
));
441 printf("dev_item.bytes_used\t%llu\n", (unsigned long long)
442 btrfs_stack_device_bytes_used(&sb
->dev_item
));
443 printf("dev_item.io_align\t%u\n", (unsigned int)
444 btrfs_stack_device_io_align(&sb
->dev_item
));
445 printf("dev_item.io_width\t%u\n", (unsigned int)
446 btrfs_stack_device_io_width(&sb
->dev_item
));
447 printf("dev_item.sector_size\t%u\n", (unsigned int)
448 btrfs_stack_device_sector_size(&sb
->dev_item
));
449 printf("dev_item.devid\t\t%llu\n",
450 btrfs_stack_device_id(&sb
->dev_item
));
451 printf("dev_item.dev_group\t%u\n", (unsigned int)
452 btrfs_stack_device_group(&sb
->dev_item
));
453 printf("dev_item.seek_speed\t%u\n", (unsigned int)
454 btrfs_stack_device_seek_speed(&sb
->dev_item
));
455 printf("dev_item.bandwidth\t%u\n", (unsigned int)
456 btrfs_stack_device_bandwidth(&sb
->dev_item
));
457 printf("dev_item.generation\t%llu\n", (unsigned long long)
458 btrfs_stack_device_generation(&sb
->dev_item
));
460 printf("sys_chunk_array[%d]:\n", BTRFS_SYSTEM_CHUNK_ARRAY_SIZE
);
461 print_sys_chunk_array(sb
);
462 printf("backup_roots[%d]:\n", BTRFS_NUM_BACKUP_ROOTS
);
463 print_backup_roots(sb
);