?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs-progs: move utils code out of header
[btrfs-progs-unstable/devel.git] / cmds-inspect-dump-super.c
blob318d6e6bdea4f5797eaf7f285f3954ea1b047fe3
1 /*
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.
5 *
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.
10 *
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.
15 */
16
17 #include "kerncompat.h"
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <unistd.h>
21 #include <fcntl.h>
22 #include <sys/stat.h>
23 #include <ctype.h>
24 #include <uuid/uuid.h>
25 #include <errno.h>
26 #include <getopt.h>
27
28 #include "ctree.h"
29 #include "disk-io.h"
30 #include "print-tree.h"
31 #include "transaction.h"
32 #include "list.h"
33 #include "utils.h"
34 #include "commands.h"
35 #include "crc32c.h"
36 #include "cmds-inspect-dump-super.h"
37 #include "help.h"
38
39 static int check_csum_sblock(void *sb, int csum_size)
40 {
41 u8 result[BTRFS_CSUM_SIZE];
42 u32 crc = ~(u32)0;
43
44 crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE,
45 crc, BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
46 btrfs_csum_final(crc, result);
47
48 return !memcmp(sb, &result, csum_size);
49 }
50
51 static void print_sys_chunk_array(struct btrfs_super_block *sb)
52 {
53 struct extent_buffer *buf;
54 struct btrfs_disk_key *disk_key;
55 struct btrfs_chunk *chunk;
56 u8 *array_ptr;
57 unsigned long sb_array_offset;
58 u32 num_stripes;
59 u32 array_size;
60 u32 len = 0;
61 u32 cur_offset;
62 struct btrfs_key key;
63 int item;
64
65 buf = malloc(sizeof(*buf) + sizeof(*sb));
66 if (!buf) {
67 error("not enough memory");
68 goto out;
69 }
70 write_extent_buffer(buf, sb, 0, sizeof(*sb));
71 array_size = btrfs_super_sys_array_size(sb);
72
73 array_ptr = sb->sys_chunk_array;
74 sb_array_offset = offsetof(struct btrfs_super_block, sys_chunk_array);
75 cur_offset = 0;
76 item = 0;
77
78 while (cur_offset < array_size) {
79 disk_key = (struct btrfs_disk_key *)array_ptr;
80 len = sizeof(*disk_key);
81 if (cur_offset + len > array_size)
82 goto out_short_read;
83
84 btrfs_disk_key_to_cpu(&key, disk_key);
85
86 array_ptr += len;
87 sb_array_offset += len;
88 cur_offset += len;
89
90 printf("\titem %d ", item);
91 btrfs_print_key(disk_key);
92 putchar('\n');
93
94 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
95 chunk = (struct btrfs_chunk *)sb_array_offset;
96 /*
97 * At least one btrfs_chunk with one stripe must be
98 * present, exact stripe count check comes afterwards
99 */
100 len = btrfs_chunk_item_size(1);
101 if (cur_offset + len > array_size)
102 goto out_short_read;
103
104 num_stripes = btrfs_chunk_num_stripes(buf, chunk);
105 if (!num_stripes) {
106 error(
107 "invalid number of stripes %u in sys_array at offset %u",
108 num_stripes, cur_offset);
109 break;
110 }
111 len = btrfs_chunk_item_size(num_stripes);
112 if (cur_offset + len > array_size)
113 goto out_short_read;
114 print_chunk(buf, chunk);
115 } else {
116 error("unexpected item type %u in sys_array at offset %u",
117 (u32)key.type, cur_offset);
118 break;
119 }
120 array_ptr += len;
121 sb_array_offset += len;
122 cur_offset += len;
123
124 item++;
125 }
126
127 free(buf);
128 out:
129 return;
130
131 out_short_read:
132 error("sys_array too short to read %u bytes at offset %u",
133 len, cur_offset);
134 free(buf);
135 }
136
137 static int empty_backup(struct btrfs_root_backup *backup)
138 {
139 if (backup == NULL ||
140 (backup->tree_root == 0 &&
141 backup->tree_root_gen == 0))
142 return 1;
143 return 0;
144 }
145
146 static void print_root_backup(struct btrfs_root_backup *backup)
147 {
148 printf("\t\tbackup_tree_root:\t%llu\tgen: %llu\tlevel: %d\n",
149 btrfs_backup_tree_root(backup),
150 btrfs_backup_tree_root_gen(backup),
151 btrfs_backup_tree_root_level(backup));
152 printf("\t\tbackup_chunk_root:\t%llu\tgen: %llu\tlevel: %d\n",
153 btrfs_backup_chunk_root(backup),
154 btrfs_backup_chunk_root_gen(backup),
155 btrfs_backup_chunk_root_level(backup));
156 printf("\t\tbackup_extent_root:\t%llu\tgen: %llu\tlevel: %d\n",
157 btrfs_backup_extent_root(backup),
158 btrfs_backup_extent_root_gen(backup),
159 btrfs_backup_extent_root_level(backup));
160 printf("\t\tbackup_fs_root:\t\t%llu\tgen: %llu\tlevel: %d\n",
161 btrfs_backup_fs_root(backup),
162 btrfs_backup_fs_root_gen(backup),
163 btrfs_backup_fs_root_level(backup));
164 printf("\t\tbackup_dev_root:\t%llu\tgen: %llu\tlevel: %d\n",
165 btrfs_backup_dev_root(backup),
166 btrfs_backup_dev_root_gen(backup),
167 btrfs_backup_dev_root_level(backup));
168 printf("\t\tbackup_csum_root:\t%llu\tgen: %llu\tlevel: %d\n",
169 btrfs_backup_csum_root(backup),
170 btrfs_backup_csum_root_gen(backup),
171 btrfs_backup_csum_root_level(backup));
172
173 printf("\t\tbackup_total_bytes:\t%llu\n",
174 btrfs_backup_total_bytes(backup));
175 printf("\t\tbackup_bytes_used:\t%llu\n",
176 btrfs_backup_bytes_used(backup));
177 printf("\t\tbackup_num_devices:\t%llu\n",
178 btrfs_backup_num_devices(backup));
179 putchar('\n');
180 }
181
182 static void print_backup_roots(struct btrfs_super_block *sb)
183 {
184 struct btrfs_root_backup *backup;
185 int i;
186
187 for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
188 backup = sb->super_roots + i;
189 if (!empty_backup(backup)) {
190 printf("\tbackup %d:\n", i);
191 print_root_backup(backup);
192 }
193 }
194 }
195
196 struct readable_flag_entry {
197 u64 bit;
198 char *output;
199 };
200
201 #define DEF_COMPAT_RO_FLAG_ENTRY(bit_name) \
202 {BTRFS_FEATURE_COMPAT_RO_##bit_name, #bit_name}
203
204 static struct readable_flag_entry compat_ro_flags_array[] = {
205 DEF_COMPAT_RO_FLAG_ENTRY(FREE_SPACE_TREE),
206 DEF_COMPAT_RO_FLAG_ENTRY(FREE_SPACE_TREE_VALID),
207 };
208 static const int compat_ro_flags_num = sizeof(compat_ro_flags_array) /
209 sizeof(struct readable_flag_entry);
210
211 #define DEF_INCOMPAT_FLAG_ENTRY(bit_name) \
212 {BTRFS_FEATURE_INCOMPAT_##bit_name, #bit_name}
213
214 static struct readable_flag_entry incompat_flags_array[] = {
215 DEF_INCOMPAT_FLAG_ENTRY(MIXED_BACKREF),
216 DEF_INCOMPAT_FLAG_ENTRY(DEFAULT_SUBVOL),
217 DEF_INCOMPAT_FLAG_ENTRY(MIXED_GROUPS),
218 DEF_INCOMPAT_FLAG_ENTRY(COMPRESS_LZO),
219 DEF_INCOMPAT_FLAG_ENTRY(COMPRESS_LZOv2),
220 DEF_INCOMPAT_FLAG_ENTRY(BIG_METADATA),
221 DEF_INCOMPAT_FLAG_ENTRY(EXTENDED_IREF),
222 DEF_INCOMPAT_FLAG_ENTRY(RAID56),
223 DEF_INCOMPAT_FLAG_ENTRY(SKINNY_METADATA),
224 DEF_INCOMPAT_FLAG_ENTRY(NO_HOLES)
225 };
226 static const int incompat_flags_num = sizeof(incompat_flags_array) /
227 sizeof(struct readable_flag_entry);
228
229 #define DEF_HEADER_FLAG_ENTRY(bit_name) \
230 {BTRFS_HEADER_FLAG_##bit_name, #bit_name}
231 #define DEF_SUPER_FLAG_ENTRY(bit_name) \
232 {BTRFS_SUPER_FLAG_##bit_name, #bit_name}
233
234 static struct readable_flag_entry super_flags_array[] = {
235 DEF_HEADER_FLAG_ENTRY(WRITTEN),
236 DEF_HEADER_FLAG_ENTRY(RELOC),
237 DEF_SUPER_FLAG_ENTRY(CHANGING_FSID),
238 DEF_SUPER_FLAG_ENTRY(SEEDING),
239 DEF_SUPER_FLAG_ENTRY(METADUMP),
240 DEF_SUPER_FLAG_ENTRY(METADUMP_V2)
241 };
242 static const int super_flags_num = ARRAY_SIZE(super_flags_array);
243
244 #define BTRFS_SUPER_FLAG_SUPP (BTRFS_HEADER_FLAG_WRITTEN |\
245 BTRFS_HEADER_FLAG_RELOC |\
246 BTRFS_SUPER_FLAG_CHANGING_FSID |\
247 BTRFS_SUPER_FLAG_SEEDING |\
248 BTRFS_SUPER_FLAG_METADUMP |\
249 BTRFS_SUPER_FLAG_METADUMP_V2)
250
251 static void __print_readable_flag(u64 flag, struct readable_flag_entry *array,
252 int array_size, u64 supported_flags)
253 {
254 int i;
255 int first = 1;
256 struct readable_flag_entry *entry;
257
258 if (!flag)
259 return;
260
261 printf("\t\t\t( ");
262 for (i = 0; i < array_size; i++) {
263 entry = array + i;
264 if (flag & entry->bit) {
265 if (first)
266 printf("%s ", entry->output);
267 else
268 printf("|\n\t\t\t %s ", entry->output);
269 first = 0;
270 }
271 }
272 flag &= ~supported_flags;
273 if (flag) {
274 if (first)
275 printf("unknown flag: 0x%llx ", flag);
276 else
277 printf("|\n\t\t\t unknown flag: 0x%llx ", flag);
278 }
279 printf(")\n");
280 }
281
282 static void print_readable_compat_ro_flag(u64 flag)
283 {
284 /*
285 * We know about the FREE_SPACE_TREE{,_VALID} bits, but we don't
286 * actually support them yet.
287 */
288 return __print_readable_flag(flag, compat_ro_flags_array,
289 compat_ro_flags_num,
290 BTRFS_FEATURE_COMPAT_RO_SUPP |
291 BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE |
292 BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID);
293 }
294
295 static void print_readable_incompat_flag(u64 flag)
296 {
297 return __print_readable_flag(flag, incompat_flags_array,
298 incompat_flags_num,
299 BTRFS_FEATURE_INCOMPAT_SUPP);
300 }
301
302 static void print_readable_super_flag(u64 flag)
303 {
304 return __print_readable_flag(flag, super_flags_array,
305 super_flags_num, BTRFS_SUPER_FLAG_SUPP);
306 }
307
308 static void dump_superblock(struct btrfs_super_block *sb, int full)
309 {
310 int i;
311 char *s, buf[BTRFS_UUID_UNPARSED_SIZE];
312 u8 *p;
313 u32 csum_size;
314 u16 csum_type;
315
316 csum_type = btrfs_super_csum_type(sb);
317 csum_size = BTRFS_CSUM_SIZE;
318 printf("csum_type\t\t%hu (", csum_type);
319 if (csum_type >= ARRAY_SIZE(btrfs_csum_sizes)) {
320 printf("INVALID");
321 } else {
322 if (csum_type == BTRFS_CSUM_TYPE_CRC32) {
323 printf("crc32c");
324 csum_size = btrfs_csum_sizes[csum_type];
325 } else {
326 printf("unknown");
327 }
328 }
329 printf(")\n");
330 printf("csum_size\t\t%llu\n", (unsigned long long)csum_size);
331
332 printf("csum\t\t\t0x");
333 for (i = 0, p = sb->csum; i < csum_size; i++)
334 printf("%02x", p[i]);
335 if (check_csum_sblock(sb, csum_size))
336 printf(" [match]");
337 else
338 printf(" [DON'T MATCH]");
339 putchar('\n');
340
341 printf("bytenr\t\t\t%llu\n",
342 (unsigned long long)btrfs_super_bytenr(sb));
343 printf("flags\t\t\t0x%llx\n",
344 (unsigned long long)btrfs_super_flags(sb));
345 print_readable_super_flag(btrfs_super_flags(sb));
346
347 printf("magic\t\t\t");
348 s = (char *) &sb->magic;
349 for (i = 0; i < 8; i++)
350 putchar(isprint(s[i]) ? s[i] : '.');
351 if (btrfs_super_magic(sb) == BTRFS_MAGIC)
352 printf(" [match]\n");
353 else
354 printf(" [DON'T MATCH]\n");
355
356 uuid_unparse(sb->fsid, buf);
357 printf("fsid\t\t\t%s\n", buf);
358
359 printf("label\t\t\t");
360 s = sb->label;
361 for (i = 0; i < BTRFS_LABEL_SIZE && s[i]; i++)
362 putchar(isprint(s[i]) ? s[i] : '.');
363 putchar('\n');
364
365 printf("generation\t\t%llu\n",
366 (unsigned long long)btrfs_super_generation(sb));
367 printf("root\t\t\t%llu\n", (unsigned long long)btrfs_super_root(sb));
368 printf("sys_array_size\t\t%llu\n",
369 (unsigned long long)btrfs_super_sys_array_size(sb));
370 printf("chunk_root_generation\t%llu\n",
371 (unsigned long long)btrfs_super_chunk_root_generation(sb));
372 printf("root_level\t\t%llu\n",
373 (unsigned long long)btrfs_super_root_level(sb));
374 printf("chunk_root\t\t%llu\n",
375 (unsigned long long)btrfs_super_chunk_root(sb));
376 printf("chunk_root_level\t%llu\n",
377 (unsigned long long)btrfs_super_chunk_root_level(sb));
378 printf("log_root\t\t%llu\n",
379 (unsigned long long)btrfs_super_log_root(sb));
380 printf("log_root_transid\t%llu\n",
381 (unsigned long long)btrfs_super_log_root_transid(sb));
382 printf("log_root_level\t\t%llu\n",
383 (unsigned long long)btrfs_super_log_root_level(sb));
384 printf("total_bytes\t\t%llu\n",
385 (unsigned long long)btrfs_super_total_bytes(sb));
386 printf("bytes_used\t\t%llu\n",
387 (unsigned long long)btrfs_super_bytes_used(sb));
388 printf("sectorsize\t\t%llu\n",
389 (unsigned long long)btrfs_super_sectorsize(sb));
390 printf("nodesize\t\t%llu\n",
391 (unsigned long long)btrfs_super_nodesize(sb));
392 printf("leafsize\t\t%llu\n",
393 (unsigned long long)btrfs_super_leafsize(sb));
394 printf("stripesize\t\t%llu\n",
395 (unsigned long long)btrfs_super_stripesize(sb));
396 printf("root_dir\t\t%llu\n",
397 (unsigned long long)btrfs_super_root_dir(sb));
398 printf("num_devices\t\t%llu\n",
399 (unsigned long long)btrfs_super_num_devices(sb));
400 printf("compat_flags\t\t0x%llx\n",
401 (unsigned long long)btrfs_super_compat_flags(sb));
402 printf("compat_ro_flags\t\t0x%llx\n",
403 (unsigned long long)btrfs_super_compat_ro_flags(sb));
404 print_readable_compat_ro_flag(btrfs_super_compat_ro_flags(sb));
405 printf("incompat_flags\t\t0x%llx\n",
406 (unsigned long long)btrfs_super_incompat_flags(sb));
407 print_readable_incompat_flag(btrfs_super_incompat_flags(sb));
408 printf("cache_generation\t%llu\n",
409 (unsigned long long)btrfs_super_cache_generation(sb));
410 printf("uuid_tree_generation\t%llu\n",
411 (unsigned long long)btrfs_super_uuid_tree_generation(sb));
412
413 uuid_unparse(sb->dev_item.uuid, buf);
414 printf("dev_item.uuid\t\t%s\n", buf);
415
416 uuid_unparse(sb->dev_item.fsid, buf);
417 printf("dev_item.fsid\t\t%s %s\n", buf,
418 !memcmp(sb->dev_item.fsid, sb->fsid, BTRFS_FSID_SIZE) ?
419 "[match]" : "[DON'T MATCH]");
420
421 printf("dev_item.type\t\t%llu\n", (unsigned long long)
422 btrfs_stack_device_type(&sb->dev_item));
423 printf("dev_item.total_bytes\t%llu\n", (unsigned long long)
424 btrfs_stack_device_total_bytes(&sb->dev_item));
425 printf("dev_item.bytes_used\t%llu\n", (unsigned long long)
426 btrfs_stack_device_bytes_used(&sb->dev_item));
427 printf("dev_item.io_align\t%u\n", (unsigned int)
428 btrfs_stack_device_io_align(&sb->dev_item));
429 printf("dev_item.io_width\t%u\n", (unsigned int)
430 btrfs_stack_device_io_width(&sb->dev_item));
431 printf("dev_item.sector_size\t%u\n", (unsigned int)
432 btrfs_stack_device_sector_size(&sb->dev_item));
433 printf("dev_item.devid\t\t%llu\n",
434 btrfs_stack_device_id(&sb->dev_item));
435 printf("dev_item.dev_group\t%u\n", (unsigned int)
436 btrfs_stack_device_group(&sb->dev_item));
437 printf("dev_item.seek_speed\t%u\n", (unsigned int)
438 btrfs_stack_device_seek_speed(&sb->dev_item));
439 printf("dev_item.bandwidth\t%u\n", (unsigned int)
440 btrfs_stack_device_bandwidth(&sb->dev_item));
441 printf("dev_item.generation\t%llu\n", (unsigned long long)
442 btrfs_stack_device_generation(&sb->dev_item));
443 if (full) {
444 printf("sys_chunk_array[%d]:\n", BTRFS_SYSTEM_CHUNK_ARRAY_SIZE);
445 print_sys_chunk_array(sb);
446 printf("backup_roots[%d]:\n", BTRFS_NUM_BACKUP_ROOTS);
447 print_backup_roots(sb);
448 }
449 }
450
451 static int load_and_dump_sb(char *filename, int fd, u64 sb_bytenr, int full,
452 int force)
453 {
454 u8 super_block_data[BTRFS_SUPER_INFO_SIZE];
455 struct btrfs_super_block *sb;
456 u64 ret;
457
458 sb = (struct btrfs_super_block *)super_block_data;
459
460 ret = pread64(fd, super_block_data, BTRFS_SUPER_INFO_SIZE, sb_bytenr);
461 if (ret != BTRFS_SUPER_INFO_SIZE) {
462 /* check if the disk if too short for further superblock */
463 if (ret == 0 && errno == 0)
464 return 0;
465
466 error("failed to read the superblock on %s at %llu",
467 filename, (unsigned long long)sb_bytenr);
468 error("error = '%s', errno = %d", strerror(errno), errno);
469 return 1;
470 }
471 printf("superblock: bytenr=%llu, device=%s\n", sb_bytenr, filename);
472 printf("---------------------------------------------------------\n");
473 if (btrfs_super_magic(sb) != BTRFS_MAGIC && !force) {
474 error("bad magic on superblock on %s at %llu",
475 filename, (unsigned long long)sb_bytenr);
476 } else {
477 dump_superblock(sb, full);
478 }
479 return 0;
480 }
481
482 const char * const cmd_inspect_dump_super_usage[] = {
483 "btrfs inspect-internal dump-super [options] device [device...]",
484 "Dump superblock from a device in a textual form",
485 "-f|--full print full superblock information, backup roots etc.",
486 "-a|--all print information about all superblocks",
487 "-s|--super <super> specify which copy to print out (values: 0, 1, 2)",
488 "-F|--force attempt to dump superblocks with bad magic",
489 "--bytenr <offset> specify alternate superblock offset",
490 "",
491 "Deprecated syntax:",
492 "-s <bytenr> specify alternate superblock offset, values other than 0, 1, 2",
493 " will be interpreted as --bytenr for backward compatibility,",
494 " option renamed for consistency with other tools (eg. check)",
495 "-i <super> specify which copy to print out (values: 0, 1, 2), now moved",
496 " to -s|--super",
497 NULL
498 };
499
500 int cmd_inspect_dump_super(int argc, char **argv)
501 {
502 int all = 0;
503 int full = 0;
504 int force = 0;
505 char *filename;
506 int fd = -1;
507 int i;
508 int ret = 0;
509 u64 arg;
510 u64 sb_bytenr = btrfs_sb_offset(0);
511
512 while (1) {
513 int c;
514 static const struct option long_options[] = {
515 {"all", no_argument, NULL, 'a'},
516 {"full", no_argument, NULL, 'f'},
517 {"force", no_argument, NULL, 'F'},
518 {"super", required_argument, NULL, 's' },
519 {NULL, 0, NULL, 0}
520 };
521
522 c = getopt_long(argc, argv, "fFai:s:", long_options, NULL);
523 if (c < 0)
524 break;
525
526 switch (c) {
527 case 'i':
528 warning(
529 "option -i is deprecated, please use -s or --super");
530 arg = arg_strtou64(optarg);
531 if (arg >= BTRFS_SUPER_MIRROR_MAX) {
532 error("super mirror too big: %llu >= %d",
533 arg, BTRFS_SUPER_MIRROR_MAX);
534 return 1;
535 }
536 sb_bytenr = btrfs_sb_offset(arg);
537 break;
538
539 case 'a':
540 all = 1;
541 break;
542 case 'f':
543 full = 1;
544 break;
545 case 'F':
546 force = 1;
547 break;
548 case 's':
549 arg = arg_strtou64(optarg);
550 if (BTRFS_SUPER_MIRROR_MAX <= arg) {
551 warning(
552 "deprecated use of -s <bytenr> with %llu, assuming --bytenr",
553 (unsigned long long)arg);
554 sb_bytenr = arg;
555 } else {
556 sb_bytenr = btrfs_sb_offset(arg);
557 }
558 all = 0;
559 break;
560 default:
561 usage(cmd_inspect_dump_super_usage);
562 }
563 }
564
565 if (check_argc_min(argc - optind, 1))
566 usage(cmd_inspect_dump_super_usage);
567
568 for (i = optind; i < argc; i++) {
569 filename = argv[i];
570 fd = open(filename, O_RDONLY);
571 if (fd < 0) {
572 error("cannot open %s: %s", filename, strerror(errno));
573 ret = 1;
574 goto out;
575 }
576
577 if (all) {
578 int idx;
579
580 for (idx = 0; idx < BTRFS_SUPER_MIRROR_MAX; idx++) {
581 sb_bytenr = btrfs_sb_offset(idx);
582 if (load_and_dump_sb(filename, fd,
583 sb_bytenr, full, force)) {
584 close(fd);
585 ret = 1;
586 goto out;
587 }
588
589 putchar('\n');
590 }
591 } else {
592 load_and_dump_sb(filename, fd, sb_bytenr, full, force);
593 putchar('\n');
594 }
595 close(fd);
596 }
597
598 out:
599 return ret;
600 }
(deprecated) Btrfs progs developments and patch integration