git.sesse.net Git - bcachefs-tools-debian/blob - cmd_list.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/btree_cache.h"
  13 #include "libbcachefs/btree_io.h"
  14 #include "libbcachefs/btree_iter.h"
  15 #include "libbcachefs/checksum.h"
  16 #include "libbcachefs/error.h"
  17 #include "libbcachefs/extents.h"
  18 #include "libbcachefs/super.h"
  19
  20 static void list_keys(struct bch_fs *c, enum btree_id btree_id,
  21                       struct bpos start, struct bpos end)
  22 {
  23         struct btree_trans trans;
  24         struct btree_iter iter;
  25         struct bkey_s_c k;
  26         struct printbuf buf = PRINTBUF;
  27         int ret;
  28
  29         bch2_trans_init(&trans, c, 0, 0);
  30
  31         for_each_btree_key(&trans, iter, btree_id, start,
  32                            BTREE_ITER_ALL_SNAPSHOTS|
  33                            BTREE_ITER_PREFETCH, k, ret) {
  34                 if (bkey_cmp(k.k->p, end) > 0)
  35                         break;
  36
  37                 printbuf_reset(&buf);
  38                 bch2_bkey_val_to_text(&buf, c, k);
  39                 puts(buf.buf);
  40         }
  41         bch2_trans_iter_exit(&trans, &iter);
  42
  43         bch2_trans_exit(&trans);
  44
  45         printbuf_exit(&buf);
  46 }
  47
  48 static void list_btree_formats(struct bch_fs *c, enum btree_id btree_id, unsigned level,
  49                                struct bpos start, struct bpos end)
  50 {
  51         struct btree_trans trans;
  52         struct btree_iter iter;
  53         struct btree *b;
  54         struct printbuf buf = PRINTBUF;
  55         int ret;
  56
  57         bch2_trans_init(&trans, c, 0, 0);
  58
  59         __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b, ret) {
  60                 if (bkey_cmp(b->key.k.p, end) > 0)
  61                         break;
  62
  63                 printbuf_reset(&buf);
  64                 bch2_btree_node_to_text(&buf, c, b);
  65                 puts(buf.buf);
  66         }
  67         bch2_trans_iter_exit(&trans, &iter);
  68
  69         if (ret)
  70                 die("error %s walking btree nodes", strerror(-ret));
  71
  72         bch2_trans_exit(&trans);
  73         printbuf_exit(&buf);
  74 }
  75
  76 static void list_nodes(struct bch_fs *c, enum btree_id btree_id, unsigned level,
  77                        struct bpos start, struct bpos end)
  78 {
  79         struct btree_trans trans;
  80         struct btree_iter iter;
  81         struct btree *b;
  82         struct printbuf buf = PRINTBUF;
  83         int ret;
  84
  85         bch2_trans_init(&trans, c, 0, 0);
  86
  87         __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b, ret) {
  88                 if (bkey_cmp(b->key.k.p, end) > 0)
  89                         break;
  90
  91                 printbuf_reset(&buf);
  92                 bch2_bkey_val_to_text(&buf, c, bkey_i_to_s_c(&b->key));
  93                 fputs(buf.buf, stdout);
  94                 putchar('\n');
  95         }
  96         bch2_trans_iter_exit(&trans, &iter);
  97
  98         if (ret)
  99                 die("error %s walking btree nodes", strerror(-ret));
 100
 101         bch2_trans_exit(&trans);
 102         printbuf_exit(&buf);
 103 }
 104
 105 static void print_node_ondisk(struct bch_fs *c, struct btree *b)
 106 {
 107         struct btree_node *n_ondisk;
 108         struct extent_ptr_decoded pick;
 109         struct bch_dev *ca;
 110         struct bio *bio;
 111         unsigned offset = 0;
 112         int ret;
 113
 114         if (bch2_bkey_pick_read_device(c, bkey_i_to_s_c(&b->key), NULL, &pick) <= 0) {
 115                 printf("error getting device to read from\n");
 116                 return;
 117         }
 118
 119         ca = bch_dev_bkey_exists(c, pick.ptr.dev);
 120         if (!bch2_dev_get_ioref(ca, READ)) {
 121                 printf("error getting device to read from\n");
 122                 return;
 123         }
 124
 125         n_ondisk = aligned_alloc(block_bytes(c), btree_bytes(c));
 126
 127         bio = bio_alloc_bioset(ca->disk_sb.bdev,
 128                                buf_pages(n_ondisk, btree_bytes(c)),
 129                                REQ_OP_READ|REQ_META,
 130                                GFP_NOIO,
 131                                &c->btree_bio);
 132         bio->bi_iter.bi_sector  = pick.ptr.offset;
 133         bch2_bio_map(bio, n_ondisk, btree_bytes(c));
 134
 135         ret = submit_bio_wait(bio);
 136         if (ret)
 137                 die("error reading btree node: %i", ret);
 138
 139         bio_put(bio);
 140         percpu_ref_put(&ca->io_ref);
 141
 142         while (offset < btree_sectors(c)) {
 143                 struct bset *i;
 144                 struct nonce nonce;
 145                 struct bch_csum csum;
 146                 struct bkey_packed *k;
 147                 unsigned sectors;
 148
 149                 if (!offset) {
 150                         i = &n_ondisk->keys;
 151
 152                         if (!bch2_checksum_type_valid(c, BSET_CSUM_TYPE(i)))
 153                                 die("unknown checksum type at offset %u: %llu",
 154                                     offset, BSET_CSUM_TYPE(i));
 155
 156                         nonce = btree_nonce(i, offset << 9);
 157                         csum = csum_vstruct(c, BSET_CSUM_TYPE(i), nonce, n_ondisk);
 158
 159                         if (bch2_crc_cmp(csum, n_ondisk->csum))
 160                                 die("invalid checksum\n");
 161
 162                         bset_encrypt(c, i, offset << 9);
 163
 164                         sectors = vstruct_sectors(n_ondisk, c->block_bits);
 165                 } else {
 166                         struct btree_node_entry *bne = (void *) n_ondisk + (offset << 9);
 167
 168                         i = &bne->keys;
 169
 170                         if (i->seq != n_ondisk->keys.seq)
 171                                 break;
 172
 173                         if (!bch2_checksum_type_valid(c, BSET_CSUM_TYPE(i)))
 174                                 die("unknown checksum type at offset %u: %llu",
 175                                     offset, BSET_CSUM_TYPE(i));
 176
 177                         nonce = btree_nonce(i, offset << 9);
 178                         csum = csum_vstruct(c, BSET_CSUM_TYPE(i), nonce, bne);
 179
 180                         if (bch2_crc_cmp(csum, bne->csum))
 181                                 die("invalid checksum");
 182
 183                         bset_encrypt(c, i, offset << 9);
 184
 185                         sectors = vstruct_sectors(bne, c->block_bits);
 186                 }
 187
 188                 fprintf(stdout, "  offset %u version %u, journal seq %llu\n",
 189                         offset,
 190                         le16_to_cpu(i->version),
 191                         le64_to_cpu(i->journal_seq));
 192                 offset += sectors;
 193
 194                 for (k = i->start; k != vstruct_last(i); k = bkey_next(k)) {
 195                         struct bkey u;
 196                         struct printbuf buf = PRINTBUF;
 197
 198                         printbuf_indent_add(&buf, 4);
 199
 200                         bch2_bkey_val_to_text(&buf, c, bkey_disassemble(b, k, &u));
 201                         fprintf(stdout, "%s\n", buf.buf);
 202
 203                         printbuf_exit(&buf);
 204                 }
 205         }
 206
 207         free(n_ondisk);
 208 }
 209
 210 static void list_nodes_ondisk(struct bch_fs *c, enum btree_id btree_id, unsigned level,
 211                               struct bpos start, struct bpos end)
 212 {
 213         struct btree_trans trans;
 214         struct btree_iter iter;
 215         struct btree *b;
 216         struct printbuf buf = PRINTBUF;
 217         int ret;
 218
 219         bch2_trans_init(&trans, c, 0, 0);
 220
 221         __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b, ret) {
 222                 if (bkey_cmp(b->key.k.p, end) > 0)
 223                         break;
 224
 225                 printbuf_reset(&buf);
 226                 bch2_bkey_val_to_text(&buf, c, bkey_i_to_s_c(&b->key));
 227                 fputs(buf.buf, stdout);
 228                 putchar('\n');
 229
 230                 print_node_ondisk(c, b);
 231         }
 232         bch2_trans_iter_exit(&trans, &iter);
 233
 234         if (ret)
 235                 die("error %s walking btree nodes", strerror(-ret));
 236
 237         bch2_trans_exit(&trans);
 238         printbuf_exit(&buf);
 239 }
 240
 241 static void list_nodes_keys(struct bch_fs *c, enum btree_id btree_id, unsigned level,
 242                             struct bpos start, struct bpos end)
 243 {
 244         struct btree_trans trans;
 245         struct btree_iter iter;
 246         struct btree_node_iter node_iter;
 247         struct bkey unpacked;
 248         struct bkey_s_c k;
 249         struct btree *b;
 250         struct printbuf buf = PRINTBUF;
 251         int ret;
 252
 253         bch2_trans_init(&trans, c, 0, 0);
 254
 255         __for_each_btree_node(&trans, iter, btree_id, start, 0, level, 0, b, ret) {
 256                 if (bkey_cmp(b->key.k.p, end) > 0)
 257                         break;
 258
 259                 printbuf_reset(&buf);
 260                 bch2_btree_node_to_text(&buf, c, b);
 261                 fputs(buf.buf, stdout);
 262
 263                 for_each_btree_node_key_unpack(b, k, &node_iter, &unpacked) {
 264                         printbuf_reset(&buf);
 265                         bch2_bkey_val_to_text(&buf, c, k);
 266                         putchar('\t');
 267                         puts(buf.buf);
 268                 }
 269         }
 270         bch2_trans_iter_exit(&trans, &iter);
 271
 272         if (ret)
 273                 die("error %s walking btree nodes", strerror(-ret));
 274
 275         bch2_trans_exit(&trans);
 276         printbuf_exit(&buf);
 277 }
 278
 279 static void list_keys_usage(void)
 280 {
 281         puts("bcachefs list - list filesystem metadata to stdout\n"
 282              "Usage: bcachefs list [OPTION]... <devices>\n"
 283              "\n"
 284              "Options:\n"
 285              "  -b (extents|inodes|dirents|xattrs)    Btree to list from\n"
 286              "  -l level                              Btree depth to descend to (0 == leaves)\n"
 287              "  -s inode:offset                       Start position to list from\n"
 288              "  -e inode:offset                       End position\n"
 289              "  -i inode                              List keys for a given inode number\n"
 290              "  -m (keys|formats|nodes|nodes_ondisk|nodes_keys)\n"
 291              "                                        List mode\n"
 292              "  -f                                    Check (fsck) the filesystem first\n"
 293              "  -v                                    Verbose mode\n"
 294              "  -h                                    Display this help and exit\n"
 295              "Report bugs to <linux-bcachefs@vger.kernel.org>");
 296 }
 297
 298 #define LIST_MODES()            \
 299         x(keys)                 \
 300         x(formats)              \
 301         x(nodes)                \
 302         x(nodes_ondisk)         \
 303         x(nodes_keys)
 304
 305 enum list_modes {
 306 #define x(n)    LIST_MODE_##n,
 307         LIST_MODES()
 308 #undef x
 309 };
 310
 311 static const char * const list_modes[] = {
 312 #define x(n)    #n,
 313         LIST_MODES()
 314 #undef x
 315         NULL
 316 };
 317
 318 int cmd_list(int argc, char *argv[])
 319 {
 320         struct bch_opts opts = bch2_opts_empty();
 321         enum btree_id btree_id_start    = 0;
 322         enum btree_id btree_id_end      = BTREE_ID_NR;
 323         enum btree_id btree_id;
 324         unsigned level = 0;
 325         struct bpos start = POS_MIN, end = POS_MAX;
 326         u64 inum = 0;
 327         int mode = 0, opt;
 328
 329         opt_set(opts, nochanges,        true);
 330         opt_set(opts, norecovery,       true);
 331         opt_set(opts, degraded,         true);
 332         opt_set(opts, errors,           BCH_ON_ERROR_continue);
 333
 334         while ((opt = getopt(argc, argv, "b:l:s:e:i:m:fvh")) != -1)
 335                 switch (opt) {
 336                 case 'b':
 337                         btree_id_start = read_string_list_or_die(optarg,
 338                                                 bch2_btree_ids, "btree id");
 339                         btree_id_end = btree_id_start + 1;
 340                         break;
 341                 case 'l':
 342                         if (kstrtouint(optarg, 10, &level) || level >= BTREE_MAX_DEPTH)
 343                                 die("invalid level");
 344                         break;
 345                 case 's':
 346                         start   = bpos_parse(optarg);
 347                         break;
 348                 case 'e':
 349                         end     = bpos_parse(optarg);
 350                         break;
 351                 case 'i':
 352                         if (kstrtoull(optarg, 10, &inum))
 353                                 die("invalid inode %s", optarg);
 354                         start   = POS(inum, 0);
 355                         end     = POS(inum + 1, 0);
 356                         break;
 357                 case 'm':
 358                         mode = read_string_list_or_die(optarg,
 359                                                 list_modes, "list mode");
 360                         break;
 361                 case 'f':
 362                         opt_set(opts, fix_errors, FSCK_OPT_YES);
 363                         opt_set(opts, norecovery, false);
 364                         break;
 365                 case 'v':
 366                         opt_set(opts, verbose, true);
 367                         break;
 368                 case 'h':
 369                         list_keys_usage();
 370                         exit(EXIT_SUCCESS);
 371                 }
 372         args_shift(optind);
 373
 374         if (!argc)
 375                 die("Please supply device(s)");
 376
 377         struct bch_fs *c = bch2_fs_open(argv, argc, opts);
 378         if (IS_ERR(c))
 379                 die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c)));
 380
 381
 382         for (btree_id = btree_id_start;
 383              btree_id < btree_id_end;
 384              btree_id++) {
 385                 switch (mode) {
 386                 case LIST_MODE_keys:
 387                         list_keys(c, btree_id, start, end);
 388                         break;
 389                 case LIST_MODE_formats:
 390                         list_btree_formats(c, btree_id, level, start, end);
 391                         break;
 392                 case LIST_MODE_nodes:
 393                         list_nodes(c, btree_id, level, start, end);
 394                         break;
 395                 case LIST_MODE_nodes_ondisk:
 396                         list_nodes_ondisk(c, btree_id, level, start, end);
 397                         break;
 398                 case LIST_MODE_nodes_keys:
 399                         list_nodes_keys(c, btree_id, level, start, end);
 400                         break;
 401                 default:
 402                         die("Invalid mode");
 403                 }
 404         }
 405
 406         bch2_fs_stop(c);
 407         return 0;
 408 }