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