7 #include "libbcachefs.h"
9 #include "tools-util.h"
11 #include "libbcachefs/bcachefs.h"
12 #include "libbcachefs/bset.h"
13 #include "libbcachefs/btree_cache.h"
14 #include "libbcachefs/btree_io.h"
15 #include "libbcachefs/btree_iter.h"
16 #include "libbcachefs/buckets.h"
17 #include "libbcachefs/checksum.h"
18 #include "libbcachefs/error.h"
19 #include "libbcachefs/journal.h"
20 #include "libbcachefs/journal_io.h"
21 #include "libbcachefs/super.h"
23 static void dump_usage(void)
25 puts("bcachefs dump - dump filesystem metadata\n"
26 "Usage: bcachefs dump [OPTION]... <devices>\n"
29 " -o output Output qcow2 image(s)\n"
30 " -f Force; overwrite when needed\n"
31 " -h Display this help and exit\n"
32 "Report bugs to <linux-bcache@vger.kernel.org>");
35 static void dump_one_device(struct bch_fs *c, struct bch_dev *ca, int fd)
37 struct bch_sb *sb = ca->disk_sb.sb;
45 range_add(&data, BCH_SB_LAYOUT_SECTOR << 9,
46 sizeof(struct bch_sb_layout));
48 for (i = 0; i < sb->layout.nr_superblocks; i++)
50 le64_to_cpu(sb->layout.sb_offset[i]) << 9,
54 for (i = 0; i < ca->journal.nr; i++)
55 if (ca->journal.bucket_seq[i] >= c->journal.last_seq_ondisk) {
56 u64 bucket = ca->journal.buckets[i];
59 bucket_bytes(ca) * bucket,
64 for (i = 0; i < BTREE_ID_NR; i++) {
65 const struct bch_extent_ptr *ptr;
66 struct bkey_ptrs_c ptrs;
67 struct btree_trans trans;
68 struct btree_iter iter;
71 bch2_trans_init(&trans, c, 0, 0);
73 __for_each_btree_node(&trans, iter, i, POS_MIN, 0, 1, 0, b, ret) {
74 struct btree_node_iter iter;
78 for_each_btree_node_key_unpack(b, k, &iter, &u) {
79 ptrs = bch2_bkey_ptrs_c(k);
81 bkey_for_each_ptr(ptrs, ptr)
82 if (ptr->dev == ca->dev_idx)
90 die("error %s walking btree nodes", strerror(-ret));
92 b = c->btree_roots[i].b;
93 if (!btree_node_fake(b)) {
94 ptrs = bch2_bkey_ptrs_c(bkey_i_to_s_c(&b->key));
96 bkey_for_each_ptr(ptrs, ptr)
97 if (ptr->dev == ca->dev_idx)
103 bch2_trans_iter_exit(&trans, &iter);
104 bch2_trans_exit(&trans);
107 qcow2_write_image(ca->disk_sb.bdev->bd_fd, fd, &data,
108 max_t(unsigned, btree_bytes(c) / 8, block_bytes(c)));
112 int cmd_dump(int argc, char *argv[])
114 struct bch_opts opts = bch2_opts_empty();
117 unsigned i, nr_devices = 0;
121 opt_set(opts, nochanges, true);
122 opt_set(opts, norecovery, true);
123 opt_set(opts, degraded, true);
124 opt_set(opts, errors, BCH_ON_ERROR_continue);
125 opt_set(opts, fix_errors, FSCK_OPT_NO);
127 while ((opt = getopt(argc, argv, "o:fvh")) != -1)
136 opt_set(opts, verbose, true);
145 die("Please supply output filename");
148 die("Please supply device(s) to check");
150 struct bch_fs *c = bch2_fs_open(argv, argc, opts);
152 die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c)));
154 down_read(&c->gc_lock);
156 for_each_online_member(ca, c, i)
161 for_each_online_member(ca, c, i) {
162 int flags = O_WRONLY|O_CREAT|O_TRUNC;
170 char *path = nr_devices > 1
171 ? mprintf("%s.%u", out, i)
173 fd = xopen(path, flags, 0600);
176 dump_one_device(c, ca, fd);
180 up_read(&c->gc_lock);
186 static void list_keys(struct bch_fs *c, enum btree_id btree_id,
187 struct bpos start, struct bpos end)
189 struct btree_trans trans;
190 struct btree_iter iter;
195 bch2_trans_init(&trans, c, 0, 0);
197 for_each_btree_key(&trans, iter, btree_id, start,
198 BTREE_ITER_ALL_SNAPSHOTS|
199 BTREE_ITER_PREFETCH, k, ret) {
200 if (bkey_cmp(k.k->p, end) > 0)
203 bch2_bkey_val_to_text(&PBUF(buf), c, k);
206 bch2_trans_iter_exit(&trans, &iter);
208 bch2_trans_exit(&trans);
211 static void list_btree_formats(struct bch_fs *c, enum btree_id btree_id, unsigned level,
212 struct bpos start, struct bpos end)
214 struct btree_trans trans;
215 struct btree_iter iter;
220 bch2_trans_init(&trans, c, 0, 0);
222 __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b, ret) {
223 if (bkey_cmp(b->key.k.p, end) > 0)
226 bch2_btree_node_to_text(&PBUF(buf), c, b);
229 bch2_trans_iter_exit(&trans, &iter);
232 die("error %s walking btree nodes", strerror(-ret));
234 bch2_trans_exit(&trans);
237 static void list_nodes(struct bch_fs *c, enum btree_id btree_id, unsigned level,
238 struct bpos start, struct bpos end)
240 struct btree_trans trans;
241 struct btree_iter iter;
246 bch2_trans_init(&trans, c, 0, 0);
248 __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b, ret) {
249 if (bkey_cmp(b->key.k.p, end) > 0)
252 bch2_bkey_val_to_text(&PBUF(buf), c, bkey_i_to_s_c(&b->key));
256 bch2_trans_iter_exit(&trans, &iter);
259 die("error %s walking btree nodes", strerror(-ret));
261 bch2_trans_exit(&trans);
264 static void print_node_ondisk(struct bch_fs *c, struct btree *b)
266 struct btree_node *n_ondisk;
267 struct extent_ptr_decoded pick;
272 if (bch2_bkey_pick_read_device(c, bkey_i_to_s_c(&b->key), NULL, &pick) <= 0) {
273 printf("error getting device to read from\n");
277 ca = bch_dev_bkey_exists(c, pick.ptr.dev);
278 if (!bch2_dev_get_ioref(ca, READ)) {
279 printf("error getting device to read from\n");
283 n_ondisk = malloc(btree_bytes(c));
285 bio = bio_alloc_bioset(GFP_NOIO,
286 buf_pages(n_ondisk, btree_bytes(c)),
288 bio_set_dev(bio, ca->disk_sb.bdev);
289 bio->bi_opf = REQ_OP_READ|REQ_META;
290 bio->bi_iter.bi_sector = pick.ptr.offset;
291 bch2_bio_map(bio, n_ondisk, btree_bytes(c));
293 submit_bio_wait(bio);
296 percpu_ref_put(&ca->io_ref);
298 while (offset < btree_sectors(c)) {
301 struct bch_csum csum;
302 struct bkey_packed *k;
308 if (!bch2_checksum_type_valid(c, BSET_CSUM_TYPE(i)))
309 die("unknown checksum type");
311 nonce = btree_nonce(i, offset << 9);
312 csum = csum_vstruct(c, BSET_CSUM_TYPE(i), nonce, n_ondisk);
314 if (bch2_crc_cmp(csum, n_ondisk->csum))
315 die("invalid checksum\n");
317 bset_encrypt(c, i, offset << 9);
319 sectors = vstruct_sectors(n_ondisk, c->block_bits);
321 struct btree_node_entry *bne = (void *) n_ondisk + (offset << 9);
325 if (i->seq != n_ondisk->keys.seq)
328 if (!bch2_checksum_type_valid(c, BSET_CSUM_TYPE(i)))
329 die("unknown checksum type");
331 nonce = btree_nonce(i, offset << 9);
332 csum = csum_vstruct(c, BSET_CSUM_TYPE(i), nonce, bne);
334 if (bch2_crc_cmp(csum, bne->csum))
335 die("invalid checksum");
337 bset_encrypt(c, i, offset << 9);
339 sectors = vstruct_sectors(bne, c->block_bits);
342 fprintf(stdout, " offset %u version %u, journal seq %llu\n",
344 le16_to_cpu(i->version),
345 le64_to_cpu(i->journal_seq));
348 for (k = i->start; k != vstruct_last(i); k = bkey_next(k)) {
352 bch2_bkey_val_to_text(&PBUF(buf), c, bkey_disassemble(b, k, &u));
353 fprintf(stdout, " %s\n", buf);
360 static void list_nodes_ondisk(struct bch_fs *c, enum btree_id btree_id, unsigned level,
361 struct bpos start, struct bpos end)
363 struct btree_trans trans;
364 struct btree_iter iter;
369 bch2_trans_init(&trans, c, 0, 0);
371 __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b, ret) {
372 if (bkey_cmp(b->key.k.p, end) > 0)
375 bch2_bkey_val_to_text(&PBUF(buf), c, bkey_i_to_s_c(&b->key));
379 print_node_ondisk(c, b);
381 bch2_trans_iter_exit(&trans, &iter);
384 die("error %s walking btree nodes", strerror(-ret));
386 bch2_trans_exit(&trans);
389 static void list_nodes_keys(struct bch_fs *c, enum btree_id btree_id, unsigned level,
390 struct bpos start, struct bpos end)
392 struct btree_trans trans;
393 struct btree_iter iter;
394 struct btree_node_iter node_iter;
395 struct bkey unpacked;
401 bch2_trans_init(&trans, c, 0, 0);
403 __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b, ret) {
404 if (bkey_cmp(b->key.k.p, end) > 0)
407 bch2_btree_node_to_text(&PBUF(buf), c, b);
410 for_each_btree_node_key_unpack(b, k, &node_iter, &unpacked) {
411 bch2_bkey_val_to_text(&PBUF(buf), c, k);
416 bch2_trans_iter_exit(&trans, &iter);
419 die("error %s walking btree nodes", strerror(-ret));
421 bch2_trans_exit(&trans);
424 static void list_keys_usage(void)
426 puts("bcachefs list - list filesystem metadata to stdout\n"
427 "Usage: bcachefs list [OPTION]... <devices>\n"
430 " -b (extents|inodes|dirents|xattrs) Btree to list from\n"
431 " -l level Btree depth to descend to (0 == leaves)\n"
432 " -s inode:offset Start position to list from\n"
433 " -e inode:offset End position\n"
434 " -i inode List keys for a given inode number\n"
435 " -m (keys|formats|nodes|nodes_ondisk|nodes_keys)\n"
437 " -f Check (fsck) the filesystem first\n"
439 " -h Display this help and exit\n"
440 "Report bugs to <linux-bcache@vger.kernel.org>");
443 #define LIST_MODES() \
451 #define x(n) LIST_MODE_##n,
456 static const char * const list_modes[] = {
463 int cmd_list(int argc, char *argv[])
465 struct bch_opts opts = bch2_opts_empty();
466 enum btree_id btree_id_start = 0;
467 enum btree_id btree_id_end = BTREE_ID_NR;
468 enum btree_id btree_id;
470 struct bpos start = POS_MIN, end = POS_MAX;
474 opt_set(opts, nochanges, true);
475 opt_set(opts, norecovery, true);
476 opt_set(opts, degraded, true);
477 opt_set(opts, errors, BCH_ON_ERROR_continue);
479 while ((opt = getopt(argc, argv, "b:l:s:e:i:m:fvh")) != -1)
482 btree_id_start = read_string_list_or_die(optarg,
483 bch2_btree_ids, "btree id");
484 btree_id_end = btree_id_start + 1;
487 if (kstrtouint(optarg, 10, &level) || level >= BTREE_MAX_DEPTH)
488 die("invalid level");
491 start = bpos_parse(optarg);
494 end = bpos_parse(optarg);
497 if (kstrtoull(optarg, 10, &inum))
498 die("invalid inode %s", optarg);
499 start = POS(inum, 0);
500 end = POS(inum + 1, 0);
503 mode = read_string_list_or_die(optarg,
504 list_modes, "list mode");
507 opt_set(opts, fix_errors, FSCK_OPT_YES);
508 opt_set(opts, norecovery, false);
511 opt_set(opts, verbose, true);
520 die("Please supply device(s)");
522 struct bch_fs *c = bch2_fs_open(argv, argc, opts);
524 die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c)));
527 for (btree_id = btree_id_start;
528 btree_id < btree_id_end;
532 list_keys(c, btree_id, start, end);
534 case LIST_MODE_formats:
535 list_btree_formats(c, btree_id, level, start, end);
537 case LIST_MODE_nodes:
538 list_nodes(c, btree_id, level, start, end);
540 case LIST_MODE_nodes_ondisk:
541 list_nodes_ondisk(c, btree_id, level, start, end);
543 case LIST_MODE_nodes_keys:
544 list_nodes_keys(c, btree_id, level, start, end);
555 static void list_journal_usage(void)
557 puts("bcachefs list_journal - print contents of journal\n"
558 "Usage: bcachefs list_journal [OPTION]... <devices>\n"
561 " -a Read entire journal, not just dirty entries\n"
562 " -h Display this help and exit\n"
563 "Report bugs to <linux-bcache@vger.kernel.org>");
566 int cmd_list_journal(int argc, char *argv[])
568 struct bch_opts opts = bch2_opts_empty();
571 opt_set(opts, nochanges, true);
572 opt_set(opts, norecovery, true);
573 opt_set(opts, degraded, true);
574 opt_set(opts, errors, BCH_ON_ERROR_continue);
575 opt_set(opts, fix_errors, FSCK_OPT_YES);
576 opt_set(opts, keep_journal, true);
578 while ((opt = getopt(argc, argv, "ah")) != -1)
581 opt_set(opts, read_entire_journal, true);
584 list_journal_usage();
590 die("Please supply device(s) to open");
592 struct bch_fs *c = bch2_fs_open(argv, argc, opts);
594 die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c)));
596 struct journal_replay *p;
597 struct jset_entry *entry;
599 list_for_each_entry(p, &c->journal_entries, list) {
600 printf("journal entry %8llu\n"
604 le64_to_cpu(p->j.seq),
605 le32_to_cpu(p->j.version),
606 le64_to_cpu(p->j.last_seq));
608 vstruct_for_each(&p->j, entry) {
610 struct printbuf buf = PBUF(_buf);
612 printbuf_indent_push(&buf, 2);
613 bch2_journal_entry_to_text(&buf, c, entry);
614 printf("%s\n", _buf);