git.sesse.net Git - bcachefs-tools-debian/blob - cmd_debug.c

   1 #include <fcntl.h>
   2 #include <string.h>
   3 #include <sys/stat.h>
   4 #include <sys/types.h>
   5
   6 #include "cmds.h"
   7 #include "libbcachefs.h"
   8 #include "qcow2.h"
   9 #include "tools-util.h"
  10
  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"
  22
  23 static void dump_usage(void)
  24 {
  25         puts("bcachefs dump - dump filesystem metadata\n"
  26              "Usage: bcachefs dump [OPTION]... <devices>\n"
  27              "\n"
  28              "Options:\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>");
  33 }
  34
  35 static void dump_one_device(struct bch_fs *c, struct bch_dev *ca, int fd)
  36 {
  37         struct bch_sb *sb = ca->disk_sb.sb;
  38         ranges data;
  39         unsigned i;
  40
  41         darray_init(data);
  42
  43         /* Superblock: */
  44         range_add(&data, BCH_SB_LAYOUT_SECTOR << 9,
  45                   sizeof(struct bch_sb_layout));
  46
  47         for (i = 0; i < sb->layout.nr_superblocks; i++)
  48                 range_add(&data,
  49                           le64_to_cpu(sb->layout.sb_offset[i]) << 9,
  50                           vstruct_bytes(sb));
  51
  52         /* Journal: */
  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];
  56
  57                         range_add(&data,
  58                                   bucket_bytes(ca) * bucket,
  59                                   bucket_bytes(ca));
  60                 }
  61
  62         /* Btree: */
  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;
  68                 struct btree *b;
  69
  70                 bch2_trans_init(&trans, c, 0, 0);
  71
  72                 __for_each_btree_node(&trans, iter, i, POS_MIN, 0, 1, 0, b) {
  73                         struct btree_node_iter iter;
  74                         struct bkey u;
  75                         struct bkey_s_c k;
  76
  77                         for_each_btree_node_key_unpack(b, k, &iter, &u) {
  78                                 ptrs = bch2_bkey_ptrs_c(k);
  79
  80                                 bkey_for_each_ptr(ptrs, ptr)
  81                                         if (ptr->dev == ca->dev_idx)
  82                                                 range_add(&data,
  83                                                           ptr->offset << 9,
  84                                                           btree_bytes(c));
  85                         }
  86                 }
  87
  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));
  91
  92                         bkey_for_each_ptr(ptrs, ptr)
  93                                 if (ptr->dev == ca->dev_idx)
  94                                         range_add(&data,
  95                                                   ptr->offset << 9,
  96                                                   btree_bytes(c));
  97                 }
  98
  99                 bch2_trans_iter_exit(&trans, &iter);
 100                 bch2_trans_exit(&trans);
 101         }
 102
 103         qcow2_write_image(ca->disk_sb.bdev->bd_fd, fd, &data,
 104                           max_t(unsigned, btree_bytes(c) / 8, block_bytes(c)));
 105         darray_free(data);
 106 }
 107
 108 int cmd_dump(int argc, char *argv[])
 109 {
 110         struct bch_opts opts = bch2_opts_empty();
 111         struct bch_dev *ca;
 112         char *out = NULL;
 113         unsigned i, nr_devices = 0;
 114         bool force = false;
 115         int fd, opt;
 116
 117         opt_set(opts, nochanges,        true);
 118         opt_set(opts, norecovery,       true);
 119         opt_set(opts, degraded,         true);
 120         opt_set(opts, errors,           BCH_ON_ERROR_continue);
 121         opt_set(opts, fix_errors,       FSCK_OPT_NO);
 122
 123         while ((opt = getopt(argc, argv, "o:fvh")) != -1)
 124                 switch (opt) {
 125                 case 'o':
 126                         out = optarg;
 127                         break;
 128                 case 'f':
 129                         force = true;
 130                         break;
 131                 case 'v':
 132                         opt_set(opts, verbose, true);
 133                         break;
 134                 case 'h':
 135                         dump_usage();
 136                         exit(EXIT_SUCCESS);
 137                 }
 138         args_shift(optind);
 139
 140         if (!out)
 141                 die("Please supply output filename");
 142
 143         if (!argc)
 144                 die("Please supply device(s) to check");
 145
 146         struct bch_fs *c = bch2_fs_open(argv, argc, opts);
 147         if (IS_ERR(c))
 148                 die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c)));
 149
 150         down_read(&c->gc_lock);
 151
 152         for_each_online_member(ca, c, i)
 153                 nr_devices++;
 154
 155         BUG_ON(!nr_devices);
 156
 157         for_each_online_member(ca, c, i) {
 158                 int flags = O_WRONLY|O_CREAT|O_TRUNC;
 159
 160                 if (!force)
 161                         flags |= O_EXCL;
 162
 163                 if (!c->devs[i])
 164                         continue;
 165
 166                 char *path = nr_devices > 1
 167                         ? mprintf("%s.%u", out, i)
 168                         : strdup(out);
 169                 fd = xopen(path, flags, 0600);
 170                 free(path);
 171
 172                 dump_one_device(c, ca, fd);
 173                 close(fd);
 174         }
 175
 176         up_read(&c->gc_lock);
 177
 178         bch2_fs_stop(c);
 179         return 0;
 180 }
 181
 182 static void list_keys(struct bch_fs *c, enum btree_id btree_id,
 183                       struct bpos start, struct bpos end)
 184 {
 185         struct btree_trans trans;
 186         struct btree_iter iter;
 187         struct bkey_s_c k;
 188         char buf[512];
 189         int ret;
 190
 191         bch2_trans_init(&trans, c, 0, 0);
 192
 193         for_each_btree_key(&trans, iter, btree_id, start,
 194                            BTREE_ITER_ALL_SNAPSHOTS|
 195                            BTREE_ITER_PREFETCH, k, ret) {
 196                 if (bkey_cmp(k.k->p, end) > 0)
 197                         break;
 198
 199                 bch2_bkey_val_to_text(&PBUF(buf), c, k);
 200                 puts(buf);
 201         }
 202         bch2_trans_iter_exit(&trans, &iter);
 203
 204         bch2_trans_exit(&trans);
 205 }
 206
 207 static void list_btree_formats(struct bch_fs *c, enum btree_id btree_id, unsigned level,
 208                                struct bpos start, struct bpos end)
 209 {
 210         struct btree_trans trans;
 211         struct btree_iter iter;
 212         struct btree *b;
 213         char buf[4096];
 214
 215         bch2_trans_init(&trans, c, 0, 0);
 216
 217         __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b) {
 218                 if (bkey_cmp(b->key.k.p, end) > 0)
 219                         break;
 220
 221                 bch2_btree_node_to_text(&PBUF(buf), c, b);
 222                 puts(buf);
 223         }
 224         bch2_trans_iter_exit(&trans, &iter);
 225
 226         bch2_trans_exit(&trans);
 227 }
 228
 229 static void list_nodes(struct bch_fs *c, enum btree_id btree_id, unsigned level,
 230                        struct bpos start, struct bpos end)
 231 {
 232         struct btree_trans trans;
 233         struct btree_iter iter;
 234         struct btree *b;
 235         char buf[4096];
 236
 237         bch2_trans_init(&trans, c, 0, 0);
 238
 239         __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b) {
 240                 if (bkey_cmp(b->key.k.p, end) > 0)
 241                         break;
 242
 243                 bch2_bkey_val_to_text(&PBUF(buf), c, bkey_i_to_s_c(&b->key));
 244                 fputs(buf, stdout);
 245                 putchar('\n');
 246         }
 247         bch2_trans_iter_exit(&trans, &iter);
 248
 249         bch2_trans_exit(&trans);
 250 }
 251
 252 static void print_node_ondisk(struct bch_fs *c, struct btree *b)
 253 {
 254         struct btree_node *n_ondisk;
 255         struct extent_ptr_decoded pick;
 256         struct bch_dev *ca;
 257         struct bio *bio;
 258         unsigned offset = 0;
 259
 260         if (bch2_bkey_pick_read_device(c, bkey_i_to_s_c(&b->key), NULL, &pick) <= 0) {
 261                 printf("error getting device to read from\n");
 262                 return;
 263         }
 264
 265         ca = bch_dev_bkey_exists(c, pick.ptr.dev);
 266         if (!bch2_dev_get_ioref(ca, READ)) {
 267                 printf("error getting device to read from\n");
 268                 return;
 269         }
 270
 271         n_ondisk = malloc(btree_bytes(c));
 272
 273         bio = bio_alloc_bioset(GFP_NOIO,
 274                         buf_pages(n_ondisk, btree_bytes(c)),
 275                         &c->btree_bio);
 276         bio_set_dev(bio, ca->disk_sb.bdev);
 277         bio->bi_opf             = REQ_OP_READ|REQ_META;
 278         bio->bi_iter.bi_sector  = pick.ptr.offset;
 279         bch2_bio_map(bio, n_ondisk, btree_bytes(c));
 280
 281         submit_bio_wait(bio);
 282
 283         bio_put(bio);
 284         percpu_ref_put(&ca->io_ref);
 285
 286         while (offset < c->opts.btree_node_size) {
 287                 struct bset *i;
 288                 struct nonce nonce;
 289                 struct bch_csum csum;
 290                 struct bkey_packed *k;
 291                 unsigned sectors;
 292
 293                 if (!offset) {
 294                         i = &n_ondisk->keys;
 295
 296                         if (!bch2_checksum_type_valid(c, BSET_CSUM_TYPE(i)))
 297                                 die("unknown checksum type");
 298
 299                         nonce = btree_nonce(i, offset << 9);
 300                         csum = csum_vstruct(c, BSET_CSUM_TYPE(i), nonce, n_ondisk);
 301
 302                         if (bch2_crc_cmp(csum, n_ondisk->csum))
 303                                 die("invalid checksum\n");
 304
 305                         bset_encrypt(c, i, offset << 9);
 306
 307                         sectors = vstruct_sectors(n_ondisk, c->block_bits);
 308                 } else {
 309                         struct btree_node_entry *bne = (void *) n_ondisk + (offset << 9);
 310
 311                         i = &bne->keys;
 312
 313                         if (i->seq != n_ondisk->keys.seq)
 314                                 break;
 315
 316                         if (!bch2_checksum_type_valid(c, BSET_CSUM_TYPE(i)))
 317                                 die("unknown checksum type");
 318
 319                         nonce = btree_nonce(i, offset << 9);
 320                         csum = csum_vstruct(c, BSET_CSUM_TYPE(i), nonce, bne);
 321
 322                         if (bch2_crc_cmp(csum, bne->csum))
 323                                 die("invalid checksum");
 324
 325                         bset_encrypt(c, i, offset << 9);
 326
 327                         sectors = vstruct_sectors(bne, c->block_bits);
 328                 }
 329
 330                 fprintf(stdout, "  offset %u version %u, journal seq %llu\n",
 331                         offset,
 332                         le16_to_cpu(i->version),
 333                         le64_to_cpu(i->journal_seq));
 334                 offset += sectors;
 335
 336                 for (k = i->start; k != vstruct_last(i); k = bkey_next(k)) {
 337                         struct bkey u;
 338                         char buf[4096];
 339
 340                         bch2_bkey_val_to_text(&PBUF(buf), c, bkey_disassemble(b, k, &u));
 341                         fprintf(stdout, "    %s\n", buf);
 342                 }
 343         }
 344
 345         free(n_ondisk);
 346 }
 347
 348 static void list_nodes_ondisk(struct bch_fs *c, enum btree_id btree_id, unsigned level,
 349                               struct bpos start, struct bpos end)
 350 {
 351         struct btree_trans trans;
 352         struct btree_iter iter;
 353         struct btree *b;
 354         char buf[4096];
 355
 356         bch2_trans_init(&trans, c, 0, 0);
 357
 358         __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b) {
 359                 if (bkey_cmp(b->key.k.p, end) > 0)
 360                         break;
 361
 362                 bch2_bkey_val_to_text(&PBUF(buf), c, bkey_i_to_s_c(&b->key));
 363                 fputs(buf, stdout);
 364                 putchar('\n');
 365
 366                 print_node_ondisk(c, b);
 367         }
 368         bch2_trans_iter_exit(&trans, &iter);
 369
 370         bch2_trans_exit(&trans);
 371 }
 372
 373 static void list_nodes_keys(struct bch_fs *c, enum btree_id btree_id, unsigned level,
 374                             struct bpos start, struct bpos end)
 375 {
 376         struct btree_trans trans;
 377         struct btree_iter iter;
 378         struct btree_node_iter node_iter;
 379         struct bkey unpacked;
 380         struct bkey_s_c k;
 381         struct btree *b;
 382         char buf[4096];
 383
 384         bch2_trans_init(&trans, c, 0, 0);
 385
 386         __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b) {
 387                 if (bkey_cmp(b->key.k.p, end) > 0)
 388                         break;
 389
 390                 bch2_btree_node_to_text(&PBUF(buf), c, b);
 391                 fputs(buf, stdout);
 392
 393                 for_each_btree_node_key_unpack(b, k, &node_iter, &unpacked) {
 394                         bch2_bkey_val_to_text(&PBUF(buf), c, k);
 395                         putchar('\t');
 396                         puts(buf);
 397                 }
 398         }
 399         bch2_trans_iter_exit(&trans, &iter);
 400
 401         bch2_trans_exit(&trans);
 402 }
 403
 404 static void list_keys_usage(void)
 405 {
 406         puts("bcachefs list - list filesystem metadata to stdout\n"
 407              "Usage: bcachefs list [OPTION]... <devices>\n"
 408              "\n"
 409              "Options:\n"
 410              "  -b (extents|inodes|dirents|xattrs)    Btree to list from\n"
 411              "  -l level                              Btree depth to descend to (0 == leaves)\n"
 412              "  -s inode:offset                       Start position to list from\n"
 413              "  -e inode:offset                       End position\n"
 414              "  -i inode                              List keys for a given inode number\n"
 415              "  -m (keys|formats|nodes|nodes_ondisk|nodes_keys)\n"
 416              "                                        List mode\n"
 417              "  -f                                    Check (fsck) the filesystem first\n"
 418              "  -v                                    Verbose mode\n"
 419              "  -h                                    Display this help and exit\n"
 420              "Report bugs to <linux-bcache@vger.kernel.org>");
 421 }
 422
 423 #define LIST_MODES()            \
 424         x(keys)                 \
 425         x(formats)              \
 426         x(nodes)                \
 427         x(nodes_ondisk)         \
 428         x(nodes_keys)
 429
 430 enum list_modes {
 431 #define x(n)    LIST_MODE_##n,
 432         LIST_MODES()
 433 #undef x
 434 };
 435
 436 static const char * const list_modes[] = {
 437 #define x(n)    #n,
 438         LIST_MODES()
 439 #undef x
 440         NULL
 441 };
 442
 443 int cmd_list(int argc, char *argv[])
 444 {
 445         struct bch_opts opts = bch2_opts_empty();
 446         enum btree_id btree_id_start    = 0;
 447         enum btree_id btree_id_end      = BTREE_ID_NR;
 448         enum btree_id btree_id;
 449         unsigned level;
 450         struct bpos start = POS_MIN, end = POS_MAX;
 451         u64 inum;
 452         int mode = 0, opt;
 453
 454         opt_set(opts, nochanges,        true);
 455         opt_set(opts, norecovery,       true);
 456         opt_set(opts, degraded,         true);
 457         opt_set(opts, errors,           BCH_ON_ERROR_continue);
 458
 459         while ((opt = getopt(argc, argv, "b:l:s:e:i:m:fvh")) != -1)
 460                 switch (opt) {
 461                 case 'b':
 462                         btree_id_start = read_string_list_or_die(optarg,
 463                                                 bch2_btree_ids, "btree id");
 464                         btree_id_end = btree_id_start + 1;
 465                         break;
 466                 case 'l':
 467                         if (kstrtouint(optarg, 10, &level) || level >= BTREE_MAX_DEPTH)
 468                                 die("invalid level");
 469                         break;
 470                 case 's':
 471                         start   = bpos_parse(optarg);
 472                         break;
 473                 case 'e':
 474                         end     = bpos_parse(optarg);
 475                         break;
 476                 case 'i':
 477                         if (kstrtoull(optarg, 10, &inum))
 478                                 die("invalid inode %s", optarg);
 479                         start   = POS(inum, 0);
 480                         end     = POS(inum + 1, 0);
 481                         break;
 482                 case 'm':
 483                         mode = read_string_list_or_die(optarg,
 484                                                 list_modes, "list mode");
 485                         break;
 486                 case 'f':
 487                         opt_set(opts, fix_errors, FSCK_OPT_YES);
 488                         opt_set(opts, norecovery, false);
 489                         break;
 490                 case 'v':
 491                         opt_set(opts, verbose, true);
 492                         break;
 493                 case 'h':
 494                         list_keys_usage();
 495                         exit(EXIT_SUCCESS);
 496                 }
 497         args_shift(optind);
 498
 499         if (!argc)
 500                 die("Please supply device(s)");
 501
 502         struct bch_fs *c = bch2_fs_open(argv, argc, opts);
 503         if (IS_ERR(c))
 504                 die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c)));
 505
 506
 507         for (btree_id = btree_id_start;
 508              btree_id < btree_id_end;
 509              btree_id++) {
 510                 switch (mode) {
 511                 case LIST_MODE_keys:
 512                         list_keys(c, btree_id, start, end);
 513                         break;
 514                 case LIST_MODE_formats:
 515                         list_btree_formats(c, btree_id, level, start, end);
 516                         break;
 517                 case LIST_MODE_nodes:
 518                         list_nodes(c, btree_id, level, start, end);
 519                         break;
 520                 case LIST_MODE_nodes_ondisk:
 521                         list_nodes_ondisk(c, btree_id, level, start, end);
 522                         break;
 523                 case LIST_MODE_nodes_keys:
 524                         list_nodes_keys(c, btree_id, level, start, end);
 525                         break;
 526                 default:
 527                         die("Invalid mode");
 528                 }
 529         }
 530
 531         bch2_fs_stop(c);
 532         return 0;
 533 }
 534
 535 static void list_journal_usage(void)
 536 {
 537         puts("bcachefs list_journal - print contents of journal\n"
 538              "Usage: bcachefs list_journal [OPTION]... <devices>\n"
 539              "\n"
 540              "Options:\n"
 541              "  -a            Read entire journal, not just dirty entries\n"
 542              "  -h            Display this help and exit\n"
 543              "Report bugs to <linux-bcache@vger.kernel.org>");
 544 }
 545
 546 int cmd_list_journal(int argc, char *argv[])
 547 {
 548         struct bch_opts opts = bch2_opts_empty();
 549         int opt;
 550
 551         opt_set(opts, nochanges,        true);
 552         opt_set(opts, norecovery,       true);
 553         opt_set(opts, degraded,         true);
 554         opt_set(opts, errors,           BCH_ON_ERROR_continue);
 555         opt_set(opts, fix_errors,       FSCK_OPT_YES);
 556         opt_set(opts, keep_journal,     true);
 557
 558         while ((opt = getopt(argc, argv, "ah")) != -1)
 559                 switch (opt) {
 560                 case 'a':
 561                         opt_set(opts, read_entire_journal, true);
 562                         break;
 563                 case 'h':
 564                         list_journal_usage();
 565                         exit(EXIT_SUCCESS);
 566                 }
 567         args_shift(optind);
 568
 569         if (!argc)
 570                 die("Please supply device(s) to open");
 571
 572         struct bch_fs *c = bch2_fs_open(argv, argc, opts);
 573         if (IS_ERR(c))
 574                 die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c)));
 575
 576         struct journal_replay *p;
 577         struct jset_entry *entry;
 578         struct bkey_i *k, *_n;
 579
 580         /* This could be greatly expanded: */
 581
 582         list_for_each_entry(p, &c->journal_entries, list) {
 583                 printf("journal entry   %8llu\n"
 584                        "    version     %8u\n"
 585                        "    last seq    %8llu\n"
 586                        ,
 587                        le64_to_cpu(p->j.seq),
 588                        le32_to_cpu(p->j.version),
 589                        le64_to_cpu(p->j.last_seq));
 590
 591                 for_each_jset_key(k, _n, entry, &p->j) {
 592                         char buf[200];
 593
 594                         bch2_bkey_val_to_text(&PBUF(buf), c, bkey_i_to_s_c(k));
 595                         printf("btree %s l %u: %s\n",
 596                                bch2_btree_ids[entry->btree_id],
 597                                entry->level,
 598                                buf);
 599                 }
 600         }
 601
 602         bch2_fs_stop(c);
 603         return 0;
 604 }