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

   1 #include <ctype.h>
   2 #include <errno.h>
   3 #include <fcntl.h>
   4 #include <stdbool.h>
   5 #include <stdint.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/stat.h>
  10 #include <sys/sysmacros.h>
  11 #include <sys/types.h>
  12 #include <time.h>
  13 #include <unistd.h>
  14
  15 #include <uuid/uuid.h>
  16
  17 #include "libbcachefs/bcachefs_format.h"
  18 #include "libbcachefs/checksum.h"
  19 #include "crypto.h"
  20 #include "libbcachefs.h"
  21 #include "libbcachefs/btree_cache.h"
  22 #include "libbcachefs/opts.h"
  23 #include "libbcachefs/super-io.h"
  24
  25 #define NSEC_PER_SEC    1000000000L
  26
  27 #define BCH_MIN_NR_NBUCKETS     (1 << 10)
  28
  29 /* minimum size filesystem we can create, given a bucket size: */
  30 static u64 min_size(unsigned bucket_size)
  31 {
  32         return BCH_MIN_NR_NBUCKETS * bucket_size;
  33 }
  34
  35 static void init_layout(struct bch_sb_layout *l, unsigned block_size,
  36                         u64 start, u64 end)
  37 {
  38         unsigned sb_size;
  39         u64 backup; /* offset of 2nd sb */
  40
  41         memset(l, 0, sizeof(*l));
  42
  43         if (start != BCH_SB_SECTOR)
  44                 start = round_up(start, block_size);
  45         end = round_down(end, block_size);
  46
  47         if (start >= end)
  48                 die("insufficient space for superblocks");
  49
  50         /*
  51          * Create two superblocks in the allowed range: reserve a maximum of 64k
  52          */
  53         sb_size = min_t(u64, 128, end - start / 2);
  54
  55         backup = start + sb_size;
  56         backup = round_up(backup, block_size);
  57
  58         backup = min(backup, end);
  59
  60         sb_size = min(end - backup, backup- start);
  61         sb_size = rounddown_pow_of_two(sb_size);
  62
  63         if (sb_size < 8)
  64                 die("insufficient space for superblocks");
  65
  66         l->magic                = BCACHE_MAGIC;
  67         l->layout_type          = 0;
  68         l->nr_superblocks       = 2;
  69         l->sb_max_size_bits     = ilog2(sb_size);
  70         l->sb_offset[0]         = cpu_to_le64(start);
  71         l->sb_offset[1]         = cpu_to_le64(backup);
  72 }
  73
  74 void bch2_pick_bucket_size(struct format_opts opts, struct dev_opts *dev)
  75 {
  76         if (!dev->sb_offset) {
  77                 dev->sb_offset  = BCH_SB_SECTOR;
  78                 dev->sb_end     = BCH_SB_SECTOR + 256;
  79         }
  80
  81         if (!dev->size)
  82                 dev->size = get_size(dev->path, dev->fd) >> 9;
  83
  84         if (!dev->bucket_size) {
  85                 if (dev->size < min_size(opts.block_size))
  86                         die("cannot format %s, too small (%llu sectors, min %llu)",
  87                             dev->path, dev->size, min_size(opts.block_size));
  88
  89                 /* Bucket size must be >= block size: */
  90                 dev->bucket_size = opts.block_size;
  91
  92                 /* Bucket size must be >= btree node size: */
  93                 dev->bucket_size = max(dev->bucket_size, opts.btree_node_size);
  94
  95                 /* Want a bucket size of at least 128k, if possible: */
  96                 dev->bucket_size = max(dev->bucket_size, 256U);
  97
  98                 if (dev->size >= min_size(dev->bucket_size)) {
  99                         unsigned scale = max(1,
 100                                              ilog2(dev->size / min_size(dev->bucket_size)) / 4);
 101
 102                         scale = rounddown_pow_of_two(scale);
 103
 104                         /* max bucket size 1 mb */
 105                         dev->bucket_size = min(dev->bucket_size * scale, 1U << 11);
 106                 } else {
 107                         do {
 108                                 dev->bucket_size /= 2;
 109                         } while (dev->size < min_size(dev->bucket_size));
 110                 }
 111         }
 112
 113         dev->nbuckets   = dev->size / dev->bucket_size;
 114
 115         if (dev->bucket_size < opts.block_size)
 116                 die("Bucket size cannot be smaller than block size");
 117
 118         if (dev->bucket_size < opts.btree_node_size)
 119                 die("Bucket size cannot be smaller than btree node size");
 120
 121         if (dev->nbuckets < BCH_MIN_NR_NBUCKETS)
 122                 die("Not enough buckets: %llu, need %u (bucket size %u)",
 123                     dev->nbuckets, BCH_MIN_NR_NBUCKETS, dev->bucket_size);
 124
 125 }
 126
 127 struct bch_sb *bch2_format(struct format_opts opts,
 128                            struct dev_opts *devs, size_t nr_devs)
 129 {
 130         struct bch_sb *sb;
 131         struct dev_opts *i;
 132         struct bch_sb_field_members *mi;
 133         unsigned u64s;
 134
 135         /* calculate block size: */
 136         if (!opts.block_size)
 137                 for (i = devs; i < devs + nr_devs; i++)
 138                         opts.block_size = max(opts.block_size,
 139                                               get_blocksize(i->path, i->fd));
 140
 141         /* calculate bucket sizes: */
 142         for (i = devs; i < devs + nr_devs; i++)
 143                 bch2_pick_bucket_size(opts, i);
 144
 145         /* calculate btree node size: */
 146         if (!opts.btree_node_size) {
 147                 /* 256k default btree node size */
 148                 opts.btree_node_size = 512;
 149
 150                 for (i = devs; i < devs + nr_devs; i++)
 151                         opts.btree_node_size =
 152                                 min(opts.btree_node_size, i->bucket_size);
 153         }
 154
 155         if (!is_power_of_2(opts.block_size))
 156                 die("block size must be power of 2");
 157
 158         if (!is_power_of_2(opts.btree_node_size))
 159                 die("btree node size must be power of 2");
 160
 161         if (uuid_is_null(opts.uuid.b))
 162                 uuid_generate(opts.uuid.b);
 163
 164         sb = calloc(1, sizeof(*sb) +
 165                     sizeof(struct bch_sb_field_members) +
 166                     sizeof(struct bch_member) * nr_devs +
 167                     sizeof(struct bch_sb_field_crypt));
 168
 169         sb->version     = cpu_to_le64(BCH_SB_VERSION_MAX);
 170         sb->magic       = BCACHE_MAGIC;
 171         sb->block_size  = cpu_to_le16(opts.block_size);
 172         sb->user_uuid   = opts.uuid;
 173         sb->nr_devices  = nr_devs;
 174
 175         uuid_generate(sb->uuid.b);
 176
 177         if (opts.label)
 178                 strncpy((char *) sb->label, opts.label, sizeof(sb->label));
 179
 180         SET_BCH_SB_CSUM_TYPE(sb,                opts.meta_csum_type);
 181         SET_BCH_SB_META_CSUM_TYPE(sb,           opts.meta_csum_type);
 182         SET_BCH_SB_DATA_CSUM_TYPE(sb,           opts.data_csum_type);
 183         SET_BCH_SB_COMPRESSION_TYPE(sb,         opts.compression_type);
 184
 185         SET_BCH_SB_BTREE_NODE_SIZE(sb,          opts.btree_node_size);
 186         SET_BCH_SB_GC_RESERVE(sb,               8);
 187         SET_BCH_SB_META_REPLICAS_WANT(sb,       opts.meta_replicas);
 188         SET_BCH_SB_META_REPLICAS_REQ(sb,        opts.meta_replicas_required);
 189         SET_BCH_SB_DATA_REPLICAS_WANT(sb,       opts.data_replicas);
 190         SET_BCH_SB_DATA_REPLICAS_REQ(sb,        opts.data_replicas_required);
 191         SET_BCH_SB_ERROR_ACTION(sb,             opts.on_error_action);
 192         SET_BCH_SB_STR_HASH_TYPE(sb,            BCH_STR_HASH_SIPHASH);
 193         SET_BCH_SB_ENCODED_EXTENT_MAX_BITS(sb,  ilog2(opts.encoded_extent_max));
 194
 195         SET_BCH_SB_POSIX_ACL(sb,                1);
 196
 197         struct timespec now;
 198         if (clock_gettime(CLOCK_REALTIME, &now))
 199                 die("error getting current time: %m");
 200
 201         sb->time_base_lo        = cpu_to_le64(now.tv_sec * NSEC_PER_SEC + now.tv_nsec);
 202         sb->time_precision      = cpu_to_le32(1);
 203
 204         if (opts.encrypted) {
 205                 struct bch_sb_field_crypt *crypt = vstruct_end(sb);
 206
 207                 u64s = sizeof(struct bch_sb_field_crypt) / sizeof(u64);
 208
 209                 le32_add_cpu(&sb->u64s, u64s);
 210                 crypt->field.u64s = cpu_to_le32(u64s);
 211                 crypt->field.type = BCH_SB_FIELD_crypt;
 212
 213                 bch_sb_crypt_init(sb, crypt, opts.passphrase);
 214                 SET_BCH_SB_ENCRYPTION_TYPE(sb, 1);
 215         }
 216
 217         mi = vstruct_end(sb);
 218         u64s = (sizeof(struct bch_sb_field_members) +
 219                 sizeof(struct bch_member) * nr_devs) / sizeof(u64);
 220
 221         le32_add_cpu(&sb->u64s, u64s);
 222         mi->field.u64s = cpu_to_le32(u64s);
 223         mi->field.type = BCH_SB_FIELD_members;
 224
 225         for (i = devs; i < devs + nr_devs; i++) {
 226                 struct bch_member *m = mi->members + (i - devs);
 227
 228                 uuid_generate(m->uuid.b);
 229                 m->nbuckets     = cpu_to_le64(i->nbuckets);
 230                 m->first_bucket = 0;
 231                 m->bucket_size  = cpu_to_le16(i->bucket_size);
 232
 233                 SET_BCH_MEMBER_TIER(m,          i->tier);
 234                 SET_BCH_MEMBER_REPLACEMENT(m,   CACHE_REPLACEMENT_LRU);
 235                 SET_BCH_MEMBER_DISCARD(m,       i->discard);
 236                 SET_BCH_MEMBER_DATA_ALLOWED(m,  i->data_allowed);
 237         }
 238
 239         for (i = devs; i < devs + nr_devs; i++) {
 240                 sb->dev_idx = i - devs;
 241
 242                 init_layout(&sb->layout, opts.block_size,
 243                             i->sb_offset, i->sb_end);
 244
 245                 if (i->sb_offset == BCH_SB_SECTOR) {
 246                         /* Zero start of disk */
 247                         static const char zeroes[BCH_SB_SECTOR << 9];
 248
 249                         xpwrite(i->fd, zeroes, BCH_SB_SECTOR << 9, 0);
 250                 }
 251
 252                 bch2_super_write(i->fd, sb);
 253                 close(i->fd);
 254         }
 255
 256         return sb;
 257 }
 258
 259 void bch2_super_write(int fd, struct bch_sb *sb)
 260 {
 261         struct nonce nonce = { 0 };
 262
 263         unsigned i;
 264         for (i = 0; i < sb->layout.nr_superblocks; i++) {
 265                 sb->offset = sb->layout.sb_offset[i];
 266
 267                 if (sb->offset == BCH_SB_SECTOR) {
 268                         /* Write backup layout */
 269                         xpwrite(fd, &sb->layout, sizeof(sb->layout),
 270                                 BCH_SB_LAYOUT_SECTOR << 9);
 271                 }
 272
 273                 sb->csum = csum_vstruct(NULL, BCH_SB_CSUM_TYPE(sb), nonce, sb);
 274                 xpwrite(fd, sb, vstruct_bytes(sb),
 275                         le64_to_cpu(sb->offset) << 9);
 276         }
 277
 278         fsync(fd);
 279 }
 280
 281 struct bch_sb *__bch2_super_read(int fd, u64 sector)
 282 {
 283         struct bch_sb sb, *ret;
 284
 285         xpread(fd, &sb, sizeof(sb), sector << 9);
 286
 287         if (memcmp(&sb.magic, &BCACHE_MAGIC, sizeof(sb.magic)))
 288                 die("not a bcachefs superblock");
 289
 290         size_t bytes = vstruct_bytes(&sb);
 291
 292         ret = malloc(bytes);
 293
 294         xpread(fd, ret, bytes, sector << 9);
 295
 296         return ret;
 297 }
 298
 299 static unsigned get_dev_has_data(struct bch_sb *sb, unsigned dev)
 300 {
 301         struct bch_sb_field_replicas *replicas;
 302         struct bch_replicas_entry *r;
 303         unsigned i, data_has = 0;
 304
 305         replicas = bch2_sb_get_replicas(sb);
 306
 307         if (replicas)
 308                 for_each_replicas_entry(replicas, r)
 309                         for (i = 0; i < r->nr; i++)
 310                                 if (r->devs[i] == dev)
 311                                         data_has |= 1 << r->data_type;
 312
 313         return data_has;
 314 }
 315
 316 /* superblock printing: */
 317
 318 static void bch2_sb_print_layout(struct bch_sb *sb, enum units units)
 319 {
 320         struct bch_sb_layout *l = &sb->layout;
 321         unsigned i;
 322
 323         printf("  type:                         %u\n"
 324                "  superblock max size:          %s\n"
 325                "  nr superblocks:               %u\n"
 326                "  Offsets:                      ",
 327                l->layout_type,
 328                pr_units(1 << l->sb_max_size_bits, units),
 329                l->nr_superblocks);
 330
 331         for (i = 0; i < l->nr_superblocks; i++) {
 332                 if (i)
 333                         printf(", ");
 334                 printf("%llu", le64_to_cpu(l->sb_offset[i]));
 335         }
 336         putchar('\n');
 337 }
 338
 339 static void bch2_sb_print_journal(struct bch_sb *sb, struct bch_sb_field *f,
 340                                   enum units units)
 341 {
 342         struct bch_sb_field_journal *journal = field_to_type(f, journal);
 343         unsigned i, nr = bch2_nr_journal_buckets(journal);
 344
 345         printf("  Buckets:                      ");
 346         for (i = 0; i < nr; i++) {
 347                 if (i)
 348                         putchar(' ');
 349                 printf("%llu", le64_to_cpu(journal->buckets[i]));
 350         }
 351         putchar('\n');
 352 }
 353
 354 static void bch2_sb_print_members(struct bch_sb *sb, struct bch_sb_field *f,
 355                                   enum units units)
 356 {
 357         struct bch_sb_field_members *mi = field_to_type(f, members);
 358         unsigned i;
 359
 360         for (i = 0; i < sb->nr_devices; i++) {
 361                 struct bch_member *m = mi->members + i;
 362                 time_t last_mount = le64_to_cpu(m->last_mount);
 363                 char member_uuid_str[40];
 364                 char data_allowed_str[100];
 365                 char data_has_str[100];
 366
 367                 if (!bch2_member_exists(m))
 368                         continue;
 369
 370                 uuid_unparse(m->uuid.b, member_uuid_str);
 371                 bch2_scnprint_flag_list(data_allowed_str,
 372                                         sizeof(data_allowed_str),
 373                                         bch2_data_types,
 374                                         BCH_MEMBER_DATA_ALLOWED(m));
 375                 if (!data_allowed_str[0])
 376                         strcpy(data_allowed_str, "(none)");
 377
 378                 bch2_scnprint_flag_list(data_has_str,
 379                                         sizeof(data_has_str),
 380                                         bch2_data_types,
 381                                         get_dev_has_data(sb, i));
 382                 if (!data_has_str[0])
 383                         strcpy(data_has_str, "(none)");
 384
 385                 printf("  Device %u:\n"
 386                        "    UUID:                       %s\n"
 387                        "    Size:                       %s\n"
 388                        "    Bucket size:                %s\n"
 389                        "    First bucket:               %u\n"
 390                        "    Buckets:                    %llu\n"
 391                        "    Last mount:                 %s\n"
 392                        "    State:                      %s\n"
 393                        "    Tier:                       %llu\n"
 394                        "    Data allowed:               %s\n"
 395
 396                        "    Has data:                   %s\n"
 397
 398                        "    Replacement policy:         %s\n"
 399                        "    Discard:                    %llu\n",
 400                        i, member_uuid_str,
 401                        pr_units(le16_to_cpu(m->bucket_size) *
 402                                 le64_to_cpu(m->nbuckets), units),
 403                        pr_units(le16_to_cpu(m->bucket_size), units),
 404                        le16_to_cpu(m->first_bucket),
 405                        le64_to_cpu(m->nbuckets),
 406                        last_mount ? ctime(&last_mount) : "(never)",
 407
 408                        BCH_MEMBER_STATE(m) < BCH_MEMBER_STATE_NR
 409                        ? bch2_dev_state[BCH_MEMBER_STATE(m)]
 410                        : "unknown",
 411
 412                        BCH_MEMBER_TIER(m),
 413                        data_allowed_str,
 414                        data_has_str,
 415
 416                        BCH_MEMBER_REPLACEMENT(m) < CACHE_REPLACEMENT_NR
 417                        ? bch2_cache_replacement_policies[BCH_MEMBER_REPLACEMENT(m)]
 418                        : "unknown",
 419
 420                        BCH_MEMBER_DISCARD(m));
 421         }
 422 }
 423
 424 static void bch2_sb_print_crypt(struct bch_sb *sb, struct bch_sb_field *f,
 425                                 enum units units)
 426 {
 427         struct bch_sb_field_crypt *crypt = field_to_type(f, crypt);
 428
 429         printf("  KFD:                  %llu\n"
 430                "  scrypt n:             %llu\n"
 431                "  scrypt r:             %llu\n"
 432                "  scrypt p:             %llu\n",
 433                BCH_CRYPT_KDF_TYPE(crypt),
 434                BCH_KDF_SCRYPT_N(crypt),
 435                BCH_KDF_SCRYPT_R(crypt),
 436                BCH_KDF_SCRYPT_P(crypt));
 437 }
 438
 439 static void bch2_sb_print_replicas(struct bch_sb *sb, struct bch_sb_field *f,
 440                                    enum units units)
 441 {
 442         struct bch_sb_field_replicas *replicas = field_to_type(f, replicas);
 443         struct bch_replicas_entry *e;
 444         unsigned i;
 445
 446         for_each_replicas_entry(replicas, e) {
 447                 printf_pad(32, "  %s:", bch2_data_types[e->data_type]);
 448
 449                 putchar('[');
 450                 for (i = 0; i < e->nr; i++) {
 451                         if (i)
 452                                 putchar(' ');
 453                         printf("%u", e->devs[i]);
 454                 }
 455                 printf("]\n");
 456         }
 457 }
 458
 459 static void bch2_sb_print_quota(struct bch_sb *sb, struct bch_sb_field *f,
 460                                 enum units units)
 461 {
 462 }
 463
 464 static void bch2_sb_print_disk_groups(struct bch_sb *sb, struct bch_sb_field *f,
 465                                       enum units units)
 466 {
 467 }
 468
 469 typedef void (*sb_field_print_fn)(struct bch_sb *, struct bch_sb_field *, enum units);
 470
 471 struct bch_sb_field_ops {
 472         sb_field_print_fn       print;
 473 };
 474
 475 static const struct bch_sb_field_ops bch2_sb_field_ops[] = {
 476 #define x(f, nr)                                        \
 477         [BCH_SB_FIELD_##f] = {                          \
 478                 .print  = bch2_sb_print_##f,            \
 479         },
 480         BCH_SB_FIELDS()
 481 #undef x
 482 };
 483
 484 static inline void bch2_sb_field_print(struct bch_sb *sb,
 485                                        struct bch_sb_field *f,
 486                                        enum units units)
 487 {
 488         unsigned type = le32_to_cpu(f->type);
 489
 490         if (type < BCH_SB_FIELD_NR)
 491                 bch2_sb_field_ops[type].print(sb, f, units);
 492         else
 493                 printf("(unknown field %u)\n", type);
 494 }
 495
 496 void bch2_sb_print(struct bch_sb *sb, bool print_layout,
 497                    unsigned fields, enum units units)
 498 {
 499         struct bch_sb_field_members *mi;
 500         char user_uuid_str[40], internal_uuid_str[40];
 501         char fields_have_str[200];
 502         char label[BCH_SB_LABEL_SIZE + 1];
 503         struct bch_sb_field *f;
 504         u64 fields_have = 0;
 505         unsigned nr_devices = 0;
 506
 507         memset(label, 0, sizeof(label));
 508         memcpy(label, sb->label, sizeof(sb->label));
 509         uuid_unparse(sb->user_uuid.b, user_uuid_str);
 510         uuid_unparse(sb->uuid.b, internal_uuid_str);
 511
 512         mi = bch2_sb_get_members(sb);
 513         if (mi) {
 514                 struct bch_member *m;
 515
 516                 for (m = mi->members;
 517                      m < mi->members + sb->nr_devices;
 518                      m++)
 519                         nr_devices += bch2_member_exists(m);
 520         }
 521
 522         vstruct_for_each(sb, f)
 523                 fields_have |= 1 << le32_to_cpu(f->type);
 524         bch2_scnprint_flag_list(fields_have_str, sizeof(fields_have_str),
 525                                 bch2_sb_fields, fields_have);
 526
 527         printf("External UUID:                  %s\n"
 528                "Internal UUID:                  %s\n"
 529                "Label:                          %s\n"
 530                "Version:                        %llu\n"
 531                "Block_size:                     %s\n"
 532                "Btree node size:                %s\n"
 533                "Error action:                   %s\n"
 534                "Clean:                          %llu\n"
 535
 536                "Metadata replicas:              %llu\n"
 537                "Data replicas:                  %llu\n"
 538
 539                "Metadata checksum type:         %s (%llu)\n"
 540                "Data checksum type:             %s (%llu)\n"
 541                "Compression type:               %s (%llu)\n"
 542
 543                "String hash type:               %s (%llu)\n"
 544                "32 bit inodes:                  %llu\n"
 545                "GC reserve percentage:          %llu%%\n"
 546                "Root reserve percentage:        %llu%%\n"
 547
 548                "Devices:                        %u live, %u total\n"
 549                "Sections:                       %s\n"
 550                "Superblock size:                %llu\n",
 551                user_uuid_str,
 552                internal_uuid_str,
 553                label,
 554                le64_to_cpu(sb->version),
 555                pr_units(le16_to_cpu(sb->block_size), units),
 556                pr_units(BCH_SB_BTREE_NODE_SIZE(sb), units),
 557
 558                BCH_SB_ERROR_ACTION(sb) < BCH_NR_ERROR_ACTIONS
 559                ? bch2_error_actions[BCH_SB_ERROR_ACTION(sb)]
 560                : "unknown",
 561
 562                BCH_SB_CLEAN(sb),
 563
 564                BCH_SB_META_REPLICAS_WANT(sb),
 565                BCH_SB_DATA_REPLICAS_WANT(sb),
 566
 567                BCH_SB_META_CSUM_TYPE(sb) < BCH_CSUM_OPT_NR
 568                ? bch2_csum_types[BCH_SB_META_CSUM_TYPE(sb)]
 569                : "unknown",
 570                BCH_SB_META_CSUM_TYPE(sb),
 571
 572                BCH_SB_DATA_CSUM_TYPE(sb) < BCH_CSUM_OPT_NR
 573                ? bch2_csum_types[BCH_SB_DATA_CSUM_TYPE(sb)]
 574                : "unknown",
 575                BCH_SB_DATA_CSUM_TYPE(sb),
 576
 577                BCH_SB_COMPRESSION_TYPE(sb) < BCH_COMPRESSION_OPT_NR
 578                ? bch2_compression_types[BCH_SB_COMPRESSION_TYPE(sb)]
 579                : "unknown",
 580                BCH_SB_COMPRESSION_TYPE(sb),
 581
 582                BCH_SB_STR_HASH_TYPE(sb) < BCH_STR_HASH_NR
 583                ? bch2_str_hash_types[BCH_SB_STR_HASH_TYPE(sb)]
 584                : "unknown",
 585                BCH_SB_STR_HASH_TYPE(sb),
 586
 587                BCH_SB_INODE_32BIT(sb),
 588                BCH_SB_GC_RESERVE(sb),
 589                BCH_SB_ROOT_RESERVE(sb),
 590
 591                nr_devices, sb->nr_devices,
 592                fields_have_str,
 593                vstruct_bytes(sb));
 594
 595         if (print_layout) {
 596                 printf("\n"
 597                        "Layout:\n");
 598                 bch2_sb_print_layout(sb, units);
 599         }
 600
 601         vstruct_for_each(sb, f) {
 602                 unsigned type = le32_to_cpu(f->type);
 603                 char name[60];
 604
 605                 if (!(fields & (1 << type)))
 606                         continue;
 607
 608                 if (type < BCH_SB_FIELD_NR) {
 609                         scnprintf(name, sizeof(name), "%s", bch2_sb_fields[type]);
 610                         name[0] = toupper(name[0]);
 611                 } else {
 612                         scnprintf(name, sizeof(name), "(unknown field %u)", type);
 613                 }
 614
 615                 printf("\n%s (size %llu):\n", name, vstruct_bytes(f));
 616                 if (type < BCH_SB_FIELD_NR)
 617                         bch2_sb_field_print(sb, f, units);
 618         }
 619 }
 620
 621 /* ioctl interface: */
 622
 623 /* Global control device: */
 624 int bcachectl_open(void)
 625 {
 626         return xopen("/dev/bcachefs-ctl", O_RDWR);
 627 }
 628
 629 /* Filesystem handles (ioctl, sysfs dir): */
 630
 631 #define SYSFS_BASE "/sys/fs/bcachefs/"
 632
 633 void bcache_fs_close(struct bchfs_handle fs)
 634 {
 635         close(fs.ioctl_fd);
 636         close(fs.sysfs_fd);
 637 }
 638
 639 struct bchfs_handle bcache_fs_open(const char *path)
 640 {
 641         struct bchfs_handle ret;
 642
 643         if (!uuid_parse(path, ret.uuid.b)) {
 644                 /* It's a UUID, look it up in sysfs: */
 645                 char *sysfs = mprintf(SYSFS_BASE "%s", path);
 646                 ret.sysfs_fd = xopen(sysfs, O_RDONLY);
 647
 648                 char *minor = read_file_str(ret.sysfs_fd, "minor");
 649                 char *ctl = mprintf("/dev/bcachefs%s-ctl", minor);
 650                 ret.ioctl_fd = xopen(ctl, O_RDWR);
 651
 652                 free(sysfs);
 653                 free(minor);
 654                 free(ctl);
 655         } else {
 656                 /* It's a path: */
 657                 ret.ioctl_fd = xopen(path, O_RDONLY);
 658
 659                 struct bch_ioctl_query_uuid uuid;
 660                 xioctl(ret.ioctl_fd, BCH_IOCTL_QUERY_UUID, &uuid);
 661
 662                 ret.uuid = uuid.uuid;
 663
 664                 char uuid_str[40];
 665                 uuid_unparse(uuid.uuid.b, uuid_str);
 666
 667                 char *sysfs = mprintf(SYSFS_BASE "%s", uuid_str);
 668                 ret.sysfs_fd = xopen(sysfs, O_RDONLY);
 669                 free(sysfs);
 670         }
 671
 672         return ret;
 673 }
 674
 675 /*
 676  * Given a path to a block device, open the filesystem it belongs to; also
 677  * return the device's idx:
 678  */
 679 struct bchfs_handle bchu_fs_open_by_dev(const char *path, unsigned *idx)
 680 {
 681         char buf[1024], *uuid_str;
 682
 683         struct stat stat = xstat(path);
 684
 685         if (!S_ISBLK(stat.st_mode))
 686                 die("%s is not a block device", path);
 687
 688         char *sysfs = mprintf("/sys/dev/block/%u:%u/bcachefs",
 689                               major(stat.st_dev),
 690                               minor(stat.st_dev));
 691         ssize_t len = readlink(sysfs, buf, sizeof(buf));
 692         free(sysfs);
 693
 694         if (len > 0) {
 695                 char *p = strrchr(buf, '/');
 696                 if (!p || sscanf(p + 1, "dev-%u", idx) != 1)
 697                         die("error parsing sysfs");
 698
 699                 *p = '\0';
 700                 p = strrchr(buf, '/');
 701                 uuid_str = p + 1;
 702         } else {
 703                 struct bch_opts opts = bch2_opts_empty();
 704
 705                 opt_set(opts, noexcl,   true);
 706                 opt_set(opts, nochanges, true);
 707
 708                 struct bch_sb_handle sb;
 709                 int ret = bch2_read_super(path, &opts, &sb);
 710                 if (ret)
 711                         die("Error opening %s: %s", path, strerror(-ret));
 712
 713                 *idx = sb.sb->dev_idx;
 714                 uuid_str = buf;
 715                 uuid_unparse(sb.sb->user_uuid.b, uuid_str);
 716
 717                 bch2_free_super(&sb);
 718         }
 719
 720         return bcache_fs_open(uuid_str);
 721 }
 722
 723 int bchu_data(struct bchfs_handle fs, struct bch_ioctl_data cmd)
 724 {
 725         int progress_fd = xioctl(fs.ioctl_fd, BCH_IOCTL_DATA, &cmd);
 726
 727         while (1) {
 728                 struct bch_ioctl_data_progress p;
 729
 730                 if (read(progress_fd, &p, sizeof(p)) != sizeof(p))
 731                         die("error reading from progress fd");
 732
 733                 if (p.data_type == U8_MAX)
 734                         break;
 735
 736                 printf("\33[2K\r");
 737
 738                 printf("%llu%% complete: current position %s",
 739                        p.sectors_done * 100 / p.sectors_total,
 740                        bch2_data_types[p.data_type]);
 741
 742                 switch (p.data_type) {
 743                 case BCH_DATA_BTREE:
 744                 case BCH_DATA_USER:
 745                         printf(" %s:%llu:%llu",
 746                                bch2_btree_ids[p.btree_id],
 747                                p.pos.inode,
 748                                p.pos.offset);
 749                 }
 750
 751                 sleep(1);
 752         }
 753         printf("\nDone\n");
 754
 755         close(progress_fd);
 756         return 0;
 757 }