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;
44 range_add(&data, BCH_SB_LAYOUT_SECTOR << 9,
45 sizeof(struct bch_sb_layout));
47 for (i = 0; i < sb->layout.nr_superblocks; i++)
49 le64_to_cpu(sb->layout.sb_offset[i]) << 9,
53 for (i = 0; i < ca->journal.nr; i++)
54 if (ca->journal.bucket_seq[i] >= c->journal.last_seq_ondisk) {
55 u64 bucket = ca->journal.buckets[i];
58 bucket_bytes(ca) * bucket,
63 for (i = 0; i < BTREE_ID_NR; i++) {
64 const struct bch_extent_ptr *ptr;
65 struct bkey_ptrs_c ptrs;
66 struct btree_trans trans;
67 struct btree_iter *iter;
70 bch2_trans_init(&trans, c, 0, 0);
72 __for_each_btree_node(&trans, iter, i, POS_MIN, 0, 1, 0, b) {
73 struct btree_node_iter iter;
77 for_each_btree_node_key_unpack(b, k, &iter, &u) {
78 ptrs = bch2_bkey_ptrs_c(k);
80 bkey_for_each_ptr(ptrs, ptr)
81 if (ptr->dev == ca->dev_idx)
88 b = c->btree_roots[i].b;
89 if (!btree_node_fake(b)) {
90 ptrs = bch2_bkey_ptrs_c(bkey_i_to_s_c(&b->key));
92 bkey_for_each_ptr(ptrs, ptr)
93 if (ptr->dev == ca->dev_idx)
98 bch2_trans_exit(&trans);
101 qcow2_write_image(ca->disk_sb.bdev->bd_fd, fd, &data,
102 max_t(unsigned, btree_bytes(c) / 8, block_bytes(c)));
105 int cmd_dump(int argc, char *argv[])
107 struct bch_opts opts = bch2_opts_empty();
110 unsigned i, nr_devices = 0;
114 opt_set(opts, nochanges, true);
115 opt_set(opts, norecovery, true);
116 opt_set(opts, degraded, true);
117 opt_set(opts, errors, BCH_ON_ERROR_continue);
118 opt_set(opts, fix_errors, FSCK_OPT_YES);
120 while ((opt = getopt(argc, argv, "o:fvh")) != -1)
129 opt_set(opts, verbose, true);
138 die("Please supply output filename");
141 die("Please supply device(s) to check");
143 struct bch_fs *c = bch2_fs_open(argv, argc, opts);
145 die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c)));
147 down_read(&c->gc_lock);
149 for_each_online_member(ca, c, i)
154 for_each_online_member(ca, c, i) {
155 int flags = O_WRONLY|O_CREAT|O_TRUNC;
163 char *path = nr_devices > 1
164 ? mprintf("%s.%u", out, i)
166 fd = xopen(path, flags, 0600);
169 dump_one_device(c, ca, fd);
173 up_read(&c->gc_lock);
179 static void list_keys(struct bch_fs *c, enum btree_id btree_id,
180 struct bpos start, struct bpos end)
182 struct btree_trans trans;
183 struct btree_iter *iter;
188 bch2_trans_init(&trans, c, 0, 0);
190 for_each_btree_key(&trans, iter, btree_id, start,
191 BTREE_ITER_PREFETCH, k, ret) {
192 if (bkey_cmp(k.k->p, end) > 0)
195 bch2_bkey_val_to_text(&PBUF(buf), c, k);
198 bch2_trans_exit(&trans);
201 static void list_btree_formats(struct bch_fs *c, enum btree_id btree_id,
202 struct bpos start, struct bpos end)
204 struct btree_trans trans;
205 struct btree_iter *iter;
209 bch2_trans_init(&trans, c, 0, 0);
211 for_each_btree_node(&trans, iter, btree_id, start, 0, b) {
212 if (bkey_cmp(b->key.k.p, end) > 0)
215 bch2_btree_node_to_text(&PBUF(buf), c, b);
218 bch2_trans_exit(&trans);
221 static void list_nodes(struct bch_fs *c, enum btree_id btree_id,
222 struct bpos start, struct bpos end)
224 struct btree_trans trans;
225 struct btree_iter *iter;
229 bch2_trans_init(&trans, c, 0, 0);
231 for_each_btree_node(&trans, iter, btree_id, start, 0, b) {
232 if (bkey_cmp(b->key.k.p, end) > 0)
235 bch2_bkey_val_to_text(&PBUF(buf), c, bkey_i_to_s_c(&b->key));
239 bch2_trans_exit(&trans);
242 static void print_node_ondisk(struct bch_fs *c, struct btree *b)
244 struct btree_node *n_ondisk;
245 struct extent_ptr_decoded pick;
250 if (bch2_bkey_pick_read_device(c, bkey_i_to_s_c(&b->key), NULL, &pick) <= 0) {
251 printf("error getting device to read from\n");
255 ca = bch_dev_bkey_exists(c, pick.ptr.dev);
256 if (!bch2_dev_get_ioref(ca, READ)) {
257 printf("error getting device to read from\n");
261 n_ondisk = malloc(btree_bytes(c));
263 bio = bio_alloc_bioset(GFP_NOIO,
264 buf_pages(n_ondisk, btree_bytes(c)),
266 bio_set_dev(bio, ca->disk_sb.bdev);
267 bio->bi_opf = REQ_OP_READ|REQ_META;
268 bio->bi_iter.bi_sector = pick.ptr.offset;
269 bch2_bio_map(bio, n_ondisk, btree_bytes(c));
271 submit_bio_wait(bio);
274 percpu_ref_put(&ca->io_ref);
276 while (offset < c->opts.btree_node_size) {
279 struct bch_csum csum;
280 struct bkey_packed *k;
286 if (!bch2_checksum_type_valid(c, BSET_CSUM_TYPE(i)))
287 die("unknown checksum type");
289 nonce = btree_nonce(i, offset << 9);
290 csum = csum_vstruct(c, BSET_CSUM_TYPE(i), nonce, n_ondisk);
292 if (bch2_crc_cmp(csum, n_ondisk->csum))
293 die("invalid checksum\n");
295 bset_encrypt(c, i, offset << 9);
297 sectors = vstruct_sectors(n_ondisk, c->block_bits);
299 struct btree_node_entry *bne = (void *) n_ondisk + (offset << 9);
303 if (i->seq != n_ondisk->keys.seq)
306 if (!bch2_checksum_type_valid(c, BSET_CSUM_TYPE(i)))
307 die("unknown checksum type");
309 nonce = btree_nonce(i, offset << 9);
310 csum = csum_vstruct(c, BSET_CSUM_TYPE(i), nonce, bne);
312 if (bch2_crc_cmp(csum, bne->csum))
313 die("invalid checksum");
315 bset_encrypt(c, i, offset << 9);
317 sectors = vstruct_sectors(bne, c->block_bits);
320 fprintf(stdout, " offset %u version %u, journal seq %llu\n",
322 le16_to_cpu(i->version),
323 le64_to_cpu(i->journal_seq));
327 k != vstruct_last(i);
328 k = bkey_next_skip_noops(k, vstruct_last(i))) {
332 bch2_bkey_val_to_text(&PBUF(buf), c, bkey_disassemble(b, k, &u));
333 fprintf(stdout, " %s\n", buf);
340 static void list_nodes_ondisk(struct bch_fs *c, enum btree_id btree_id,
341 struct bpos start, struct bpos end)
343 struct btree_trans trans;
344 struct btree_iter *iter;
348 bch2_trans_init(&trans, c, 0, 0);
350 for_each_btree_node(&trans, iter, btree_id, start, 0, b) {
351 if (bkey_cmp(b->key.k.p, end) > 0)
354 bch2_bkey_val_to_text(&PBUF(buf), c, bkey_i_to_s_c(&b->key));
358 print_node_ondisk(c, b);
360 bch2_trans_exit(&trans);
363 static void list_nodes_keys(struct bch_fs *c, enum btree_id btree_id,
364 struct bpos start, struct bpos end)
366 struct btree_trans trans;
367 struct btree_iter *iter;
368 struct btree_node_iter node_iter;
369 struct bkey unpacked;
374 bch2_trans_init(&trans, c, 0, 0);
376 for_each_btree_node(&trans, iter, btree_id, start, 0, b) {
377 if (bkey_cmp(b->key.k.p, end) > 0)
380 bch2_btree_node_to_text(&PBUF(buf), c, b);
383 for_each_btree_node_key_unpack(b, k, &node_iter, &unpacked) {
384 bch2_bkey_val_to_text(&PBUF(buf), c, k);
389 bch2_trans_exit(&trans);
392 static void list_keys_usage(void)
394 puts("bcachefs list - list filesystem metadata to stdout\n"
395 "Usage: bcachefs list [OPTION]... <devices>\n"
398 " -b (extents|inodes|dirents|xattrs) Btree to list from\n"
399 " -s inode:offset Start position to list from\n"
400 " -e inode:offset End position\n"
401 " -i inode List keys for a given inode number\n"
402 " -m (keys|formats) List mode\n"
403 " -f Check (fsck) the filesystem first\n"
405 " -h Display this help and exit\n"
406 "Report bugs to <linux-bcache@vger.kernel.org>");
409 static const char * const list_modes[] = {
418 int cmd_list(int argc, char *argv[])
420 struct bch_opts opts = bch2_opts_empty();
421 enum btree_id btree_id_start = 0;
422 enum btree_id btree_id_end = BTREE_ID_NR;
423 enum btree_id btree_id;
424 struct bpos start = POS_MIN, end = POS_MAX;
428 opt_set(opts, nochanges, true);
429 opt_set(opts, norecovery, true);
430 opt_set(opts, degraded, true);
431 opt_set(opts, errors, BCH_ON_ERROR_continue);
433 while ((opt = getopt(argc, argv, "b:s:e:i:m:fvh")) != -1)
436 btree_id_start = read_string_list_or_die(optarg,
437 bch2_btree_ids, "btree id");
438 btree_id_end = btree_id_start + 1;
441 start = bpos_parse(optarg);
444 end = bpos_parse(optarg);
447 if (kstrtoull(optarg, 10, &inum))
448 die("invalid inode %s", optarg);
449 start = POS(inum, 0);
450 end = POS(inum + 1, 0);
453 mode = read_string_list_or_die(optarg,
454 list_modes, "list mode");
457 opt_set(opts, fix_errors, FSCK_OPT_YES);
458 opt_set(opts, norecovery, false);
461 opt_set(opts, verbose, true);
470 die("Please supply device(s)");
472 struct bch_fs *c = bch2_fs_open(argv, argc, opts);
474 die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c)));
477 for (btree_id = btree_id_start;
478 btree_id < btree_id_end;
482 list_keys(c, btree_id, start, end);
485 list_btree_formats(c, btree_id, start, end);
488 list_nodes(c, btree_id, start, end);
491 list_nodes_ondisk(c, btree_id, start, end);
494 list_nodes_keys(c, btree_id, start, end);
505 static void list_journal_usage(void)
507 puts("bcachefs list_journal - print contents of journal\n"
508 "Usage: bcachefs list_journal [OPTION]... <devices>\n"
511 " -a Read entire journal, not just dirty entries\n"
512 " -h Display this help and exit\n"
513 "Report bugs to <linux-bcache@vger.kernel.org>");
516 int cmd_list_journal(int argc, char *argv[])
518 struct bch_opts opts = bch2_opts_empty();
521 opt_set(opts, nochanges, true);
522 opt_set(opts, norecovery, true);
523 opt_set(opts, degraded, true);
524 opt_set(opts, errors, BCH_ON_ERROR_continue);
525 opt_set(opts, fix_errors, FSCK_OPT_YES);
526 opt_set(opts, keep_journal, true);
528 while ((opt = getopt(argc, argv, "ah")) != -1)
531 opt_set(opts, read_entire_journal, true);
534 list_journal_usage();
540 die("Please supply device(s) to open");
542 struct bch_fs *c = bch2_fs_open(argv, argc, opts);
544 die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c)));
546 struct journal_replay *p;
547 struct jset_entry *entry;
548 struct bkey_i *k, *_n;
550 /* This could be greatly expanded: */
552 list_for_each_entry(p, &c->journal_entries, list) {
553 printf("journal entry %8llu\n"
557 le64_to_cpu(p->j.seq),
558 le32_to_cpu(p->j.version),
559 le64_to_cpu(p->j.last_seq));
561 for_each_jset_key(k, _n, entry, &p->j) {
564 bch2_bkey_val_to_text(&PBUF(buf), c, bkey_i_to_s_c(k));
565 printf("btree %s l %u: %s\n",
566 bch2_btree_ids[entry->btree_id],