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

   1 #include <ctype.h>
   2 #include <dirent.h>
   3 #include <errno.h>
   4 #include <fcntl.h>
   5 #include <stdbool.h>
   6 #include <stdint.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <sys/stat.h>
  11 #include <sys/sysmacros.h>
  12 #include <sys/types.h>
  13 #include <time.h>
  14 #include <unistd.h>
  15
  16 #include <uuid/uuid.h>
  17
  18 #include "libbcachefs.h"
  19 #include "crypto.h"
  20 #include "libbcachefs/bcachefs_format.h"
  21 #include "libbcachefs/btree_cache.h"
  22 #include "libbcachefs/checksum.h"
  23 #include "libbcachefs/disk_groups.h"
  24 #include "libbcachefs/journal_seq_blacklist.h"
  25 #include "libbcachefs/opts.h"
  26 #include "libbcachefs/replicas.h"
  27 #include "libbcachefs/super-io.h"
  28 #include "tools-util.h"
  29
  30 #define NSEC_PER_SEC    1000000000L
  31
  32 /* minimum size filesystem we can create, given a bucket size: */
  33 static u64 min_size(unsigned bucket_size)
  34 {
  35         return BCH_MIN_NR_NBUCKETS * bucket_size;
  36 }
  37
  38 static void init_layout(struct bch_sb_layout *l, unsigned block_size,
  39                         u64 start, u64 end)
  40 {
  41         unsigned sb_size;
  42         u64 backup; /* offset of 2nd sb */
  43
  44         memset(l, 0, sizeof(*l));
  45
  46         if (start != BCH_SB_SECTOR)
  47                 start = round_up(start, block_size);
  48         end = round_down(end, block_size);
  49
  50         if (start >= end)
  51                 die("insufficient space for superblocks");
  52
  53         /*
  54          * Create two superblocks in the allowed range: reserve a maximum of 64k
  55          */
  56         sb_size = min_t(u64, 128, end - start / 2);
  57
  58         backup = start + sb_size;
  59         backup = round_up(backup, block_size);
  60
  61         backup = min(backup, end);
  62
  63         sb_size = min(end - backup, backup- start);
  64         sb_size = rounddown_pow_of_two(sb_size);
  65
  66         if (sb_size < 8)
  67                 die("insufficient space for superblocks");
  68
  69         l->magic                = BCACHE_MAGIC;
  70         l->layout_type          = 0;
  71         l->nr_superblocks       = 2;
  72         l->sb_max_size_bits     = ilog2(sb_size);
  73         l->sb_offset[0]         = cpu_to_le64(start);
  74         l->sb_offset[1]         = cpu_to_le64(backup);
  75 }
  76
  77 void bch2_pick_bucket_size(struct bch_opts opts, struct dev_opts *dev)
  78 {
  79         if (!dev->sb_offset) {
  80                 dev->sb_offset  = BCH_SB_SECTOR;
  81                 dev->sb_end     = BCH_SB_SECTOR + 256;
  82         }
  83
  84         if (!dev->size)
  85                 dev->size = get_size(dev->path, dev->fd) >> 9;
  86
  87         if (!dev->bucket_size) {
  88                 if (dev->size < min_size(opts.block_size))
  89                         die("cannot format %s, too small (%llu sectors, min %llu)",
  90                             dev->path, dev->size, min_size(opts.block_size));
  91
  92                 /* Bucket size must be >= block size: */
  93                 dev->bucket_size = opts.block_size;
  94
  95                 /* Bucket size must be >= btree node size: */
  96                 if (opt_defined(opts, btree_node_size))
  97                         dev->bucket_size = max_t(unsigned, dev->bucket_size,
  98                                                  opts.btree_node_size);
  99
 100                 /* Want a bucket size of at least 128k, if possible: */
 101                 dev->bucket_size = max(dev->bucket_size, 256U);
 102
 103                 if (dev->size >= min_size(dev->bucket_size)) {
 104                         unsigned scale = max(1,
 105                                              ilog2(dev->size / min_size(dev->bucket_size)) / 4);
 106
 107                         scale = rounddown_pow_of_two(scale);
 108
 109                         /* max bucket size 1 mb */
 110                         dev->bucket_size = min(dev->bucket_size * scale, 1U << 11);
 111                 } else {
 112                         do {
 113                                 dev->bucket_size /= 2;
 114                         } while (dev->size < min_size(dev->bucket_size));
 115                 }
 116         }
 117
 118         dev->nbuckets   = dev->size / dev->bucket_size;
 119
 120         if (dev->bucket_size < opts.block_size)
 121                 die("Bucket size cannot be smaller than block size");
 122
 123         if (opt_defined(opts, btree_node_size) &&
 124             dev->bucket_size < opts.btree_node_size)
 125                 die("Bucket size cannot be smaller than btree node size");
 126
 127         if (dev->nbuckets < BCH_MIN_NR_NBUCKETS)
 128                 die("Not enough buckets: %llu, need %u (bucket size %u)",
 129                     dev->nbuckets, BCH_MIN_NR_NBUCKETS, dev->bucket_size);
 130
 131 }
 132
 133 static unsigned parse_target(struct bch_sb_handle *sb,
 134                              struct dev_opts *devs, size_t nr_devs,
 135                              const char *s)
 136 {
 137         struct dev_opts *i;
 138         int idx;
 139
 140         if (!s)
 141                 return 0;
 142
 143         for (i = devs; i < devs + nr_devs; i++)
 144                 if (!strcmp(s, i->path))
 145                         return dev_to_target(i - devs);
 146
 147         idx = bch2_disk_path_find(sb, s);
 148         if (idx >= 0)
 149                 return group_to_target(idx);
 150
 151         die("Invalid target %s", s);
 152         return 0;
 153 }
 154
 155 struct bch_sb *bch2_format(struct bch_opt_strs  fs_opt_strs,
 156                            struct bch_opts      fs_opts,
 157                            struct format_opts   opts,
 158                            struct dev_opts      *devs,
 159                            size_t               nr_devs)
 160 {
 161         struct bch_sb_handle sb = { NULL };
 162         struct dev_opts *i;
 163         struct bch_sb_field_members *mi;
 164         unsigned max_dev_block_size = 0;
 165         unsigned opt_id;
 166
 167         for (i = devs; i < devs + nr_devs; i++)
 168                 max_dev_block_size = max(max_dev_block_size,
 169                                          get_blocksize(i->path, i->fd));
 170
 171         /* calculate block size: */
 172         if (!opt_defined(fs_opts, block_size)) {
 173                 opt_set(fs_opts, block_size, max_dev_block_size);
 174         } else if (fs_opts.block_size < max_dev_block_size)
 175                 die("blocksize too small: %u, must be greater than device blocksize %u",
 176                     fs_opts.block_size, max_dev_block_size);
 177
 178         /* calculate bucket sizes: */
 179         for (i = devs; i < devs + nr_devs; i++)
 180                 bch2_pick_bucket_size(fs_opts, i);
 181
 182         /* calculate btree node size: */
 183         if (!opt_defined(fs_opts, btree_node_size)) {
 184                 /* 256k default btree node size */
 185                 opt_set(fs_opts, btree_node_size, 512);
 186
 187                 for (i = devs; i < devs + nr_devs; i++)
 188                         fs_opts.btree_node_size =
 189                                 min_t(unsigned, fs_opts.btree_node_size,
 190                                       i->bucket_size);
 191         }
 192
 193         if (!is_power_of_2(fs_opts.block_size))
 194                 die("block size must be power of 2");
 195
 196         if (!is_power_of_2(fs_opts.btree_node_size))
 197                 die("btree node size must be power of 2");
 198
 199         if (uuid_is_null(opts.uuid.b))
 200                 uuid_generate(opts.uuid.b);
 201
 202         if (bch2_sb_realloc(&sb, 0))
 203                 die("insufficient memory");
 204
 205         sb.sb->version          = le16_to_cpu(opts.version);
 206         sb.sb->version_min      = le16_to_cpu(opts.version);
 207         sb.sb->magic            = BCACHE_MAGIC;
 208         sb.sb->block_size       = cpu_to_le16(fs_opts.block_size);
 209         sb.sb->user_uuid        = opts.uuid;
 210         sb.sb->nr_devices       = nr_devs;
 211
 212         if (opts.version == bcachefs_metadata_version_current)
 213                 sb.sb->features[0] |= BCH_SB_FEATURES_ALL;
 214
 215         uuid_generate(sb.sb->uuid.b);
 216
 217         if (opts.label)
 218                 memcpy(sb.sb->label,
 219                        opts.label,
 220                        min(strlen(opts.label), sizeof(sb.sb->label)));
 221
 222         for (opt_id = 0;
 223              opt_id < bch2_opts_nr;
 224              opt_id++) {
 225                 const struct bch_option *opt = &bch2_opt_table[opt_id];
 226                 u64 v;
 227
 228                 if (opt->set_sb == SET_NO_SB_OPT)
 229                         continue;
 230
 231                 v = bch2_opt_defined_by_id(&fs_opts, opt_id)
 232                         ? bch2_opt_get_by_id(&fs_opts, opt_id)
 233                         : bch2_opt_get_by_id(&bch2_opts_default, opt_id);
 234
 235                 opt->set_sb(sb.sb, v);
 236         }
 237
 238         SET_BCH_SB_ENCODED_EXTENT_MAX_BITS(sb.sb,
 239                                 ilog2(opts.encoded_extent_max));
 240
 241         struct timespec now;
 242         if (clock_gettime(CLOCK_REALTIME, &now))
 243                 die("error getting current time: %m");
 244
 245         sb.sb->time_base_lo     = cpu_to_le64(now.tv_sec * NSEC_PER_SEC + now.tv_nsec);
 246         sb.sb->time_precision   = cpu_to_le32(1);
 247
 248         /* Member info: */
 249         mi = bch2_sb_resize_members(&sb,
 250                         (sizeof(*mi) + sizeof(struct bch_member) *
 251                          nr_devs) / sizeof(u64));
 252
 253         for (i = devs; i < devs + nr_devs; i++) {
 254                 struct bch_member *m = mi->members + (i - devs);
 255
 256                 uuid_generate(m->uuid.b);
 257                 m->nbuckets     = cpu_to_le64(i->nbuckets);
 258                 m->first_bucket = 0;
 259                 m->bucket_size  = cpu_to_le16(i->bucket_size);
 260
 261                 SET_BCH_MEMBER_REPLACEMENT(m,   BCH_CACHE_REPLACEMENT_lru);
 262                 SET_BCH_MEMBER_DISCARD(m,       i->discard);
 263                 SET_BCH_MEMBER_DATA_ALLOWED(m,  i->data_allowed);
 264                 SET_BCH_MEMBER_DURABILITY(m,    i->durability + 1);
 265         }
 266
 267         /* Disk groups */
 268         for (i = devs; i < devs + nr_devs; i++) {
 269                 struct bch_member *m = mi->members + (i - devs);
 270                 int idx;
 271
 272                 if (!i->group)
 273                         continue;
 274
 275                 idx = bch2_disk_path_find_or_create(&sb, i->group);
 276                 if (idx < 0)
 277                         die("error creating disk path: %s", idx);
 278
 279                 SET_BCH_MEMBER_GROUP(m, idx + 1);
 280         }
 281
 282         SET_BCH_SB_FOREGROUND_TARGET(sb.sb,
 283                 parse_target(&sb, devs, nr_devs, fs_opt_strs.foreground_target));
 284         SET_BCH_SB_BACKGROUND_TARGET(sb.sb,
 285                 parse_target(&sb, devs, nr_devs, fs_opt_strs.background_target));
 286         SET_BCH_SB_PROMOTE_TARGET(sb.sb,
 287                 parse_target(&sb, devs, nr_devs, fs_opt_strs.promote_target));
 288         SET_BCH_SB_METADATA_TARGET(sb.sb,
 289                 parse_target(&sb, devs, nr_devs, fs_opt_strs.metadata_target));
 290
 291         /* Crypt: */
 292         if (opts.encrypted) {
 293                 struct bch_sb_field_crypt *crypt =
 294                         bch2_sb_resize_crypt(&sb, sizeof(*crypt) / sizeof(u64));
 295
 296                 bch_sb_crypt_init(sb.sb, crypt, opts.passphrase);
 297                 SET_BCH_SB_ENCRYPTION_TYPE(sb.sb, 1);
 298         }
 299
 300         for (i = devs; i < devs + nr_devs; i++) {
 301                 sb.sb->dev_idx = i - devs;
 302
 303                 init_layout(&sb.sb->layout, fs_opts.block_size,
 304                             i->sb_offset, i->sb_end);
 305
 306                 if (i->sb_offset == BCH_SB_SECTOR) {
 307                         /* Zero start of disk */
 308                         static const char zeroes[BCH_SB_SECTOR << 9];
 309
 310                         xpwrite(i->fd, zeroes, BCH_SB_SECTOR << 9, 0);
 311                 }
 312
 313                 bch2_super_write(i->fd, sb.sb);
 314                 close(i->fd);
 315         }
 316
 317         return sb.sb;
 318 }
 319
 320 void bch2_super_write(int fd, struct bch_sb *sb)
 321 {
 322         struct nonce nonce = { 0 };
 323
 324         unsigned i;
 325         for (i = 0; i < sb->layout.nr_superblocks; i++) {
 326                 sb->offset = sb->layout.sb_offset[i];
 327
 328                 if (sb->offset == BCH_SB_SECTOR) {
 329                         /* Write backup layout */
 330                         xpwrite(fd, &sb->layout, sizeof(sb->layout),
 331                                 BCH_SB_LAYOUT_SECTOR << 9);
 332                 }
 333
 334                 sb->csum = csum_vstruct(NULL, BCH_SB_CSUM_TYPE(sb), nonce, sb);
 335                 xpwrite(fd, sb, vstruct_bytes(sb),
 336                         le64_to_cpu(sb->offset) << 9);
 337         }
 338
 339         fsync(fd);
 340 }
 341
 342 struct bch_sb *__bch2_super_read(int fd, u64 sector)
 343 {
 344         struct bch_sb sb, *ret;
 345
 346         xpread(fd, &sb, sizeof(sb), sector << 9);
 347
 348         if (memcmp(&sb.magic, &BCACHE_MAGIC, sizeof(sb.magic)))
 349                 die("not a bcachefs superblock");
 350
 351         size_t bytes = vstruct_bytes(&sb);
 352
 353         ret = malloc(bytes);
 354
 355         xpread(fd, ret, bytes, sector << 9);
 356
 357         return ret;
 358 }
 359
 360 static unsigned get_dev_has_data(struct bch_sb *sb, unsigned dev)
 361 {
 362         struct bch_sb_field_replicas *replicas;
 363         struct bch_replicas_entry *r;
 364         unsigned i, data_has = 0;
 365
 366         replicas = bch2_sb_get_replicas(sb);
 367
 368         if (replicas)
 369                 for_each_replicas_entry(replicas, r)
 370                         for (i = 0; i < r->nr_devs; i++)
 371                                 if (r->devs[i] == dev)
 372                                         data_has |= 1 << r->data_type;
 373
 374         return data_has;
 375 }
 376
 377 static int bch2_sb_get_target(struct bch_sb *sb, char *buf, size_t len, u64 v)
 378 {
 379         struct target t = target_decode(v);
 380         int ret;
 381
 382         switch (t.type) {
 383         case TARGET_NULL:
 384                 return scnprintf(buf, len, "none");
 385         case TARGET_DEV: {
 386                 struct bch_sb_field_members *mi = bch2_sb_get_members(sb);
 387                 struct bch_member *m = mi->members + t.dev;
 388
 389                 if (bch2_dev_exists(sb, mi, t.dev)) {
 390                         char uuid_str[40];
 391
 392                         uuid_unparse(m->uuid.b, uuid_str);
 393
 394                         ret = scnprintf(buf, len, "Device %u (%s)", t.dev,
 395                                 uuid_str);
 396                 } else {
 397                         ret = scnprintf(buf, len, "Bad device %u", t.dev);
 398                 }
 399
 400                 break;
 401         }
 402         case TARGET_GROUP: {
 403                 struct bch_sb_field_disk_groups *gi;
 404                 gi = bch2_sb_get_disk_groups(sb);
 405
 406                 struct bch_disk_group *g = gi->entries + t.group;
 407
 408                 if (t.group < disk_groups_nr(gi) && !BCH_GROUP_DELETED(g)) {
 409                         ret = scnprintf(buf, len, "Group %u (%.*s)", t.group,
 410                                 BCH_SB_LABEL_SIZE, g->label);
 411                 } else {
 412                         ret = scnprintf(buf, len, "Bad group %u", t.group);
 413                 }
 414                 break;
 415         }
 416         default:
 417                 BUG();
 418         }
 419
 420         return ret;
 421 }
 422
 423 /* superblock printing: */
 424
 425 static void bch2_sb_print_layout(struct bch_sb *sb, enum units units)
 426 {
 427         struct bch_sb_layout *l = &sb->layout;
 428         unsigned i;
 429
 430         printf("  type:                         %u\n"
 431                "  superblock max size:          %s\n"
 432                "  nr superblocks:               %u\n"
 433                "  Offsets:                      ",
 434                l->layout_type,
 435                pr_units(1 << l->sb_max_size_bits, units),
 436                l->nr_superblocks);
 437
 438         for (i = 0; i < l->nr_superblocks; i++) {
 439                 if (i)
 440                         printf(", ");
 441                 printf("%llu", le64_to_cpu(l->sb_offset[i]));
 442         }
 443         putchar('\n');
 444 }
 445
 446 static void bch2_sb_print_journal(struct bch_sb *sb, struct bch_sb_field *f,
 447                                   enum units units)
 448 {
 449         struct bch_sb_field_journal *journal = field_to_type(f, journal);
 450         unsigned i, nr = bch2_nr_journal_buckets(journal);
 451
 452         printf("  Buckets:                      ");
 453         for (i = 0; i < nr; i++) {
 454                 if (i)
 455                         putchar(' ');
 456                 printf("%llu", le64_to_cpu(journal->buckets[i]));
 457         }
 458         putchar('\n');
 459 }
 460
 461 static void bch2_sb_print_members(struct bch_sb *sb, struct bch_sb_field *f,
 462                                   enum units units)
 463 {
 464         struct bch_sb_field_members *mi = field_to_type(f, members);
 465         struct bch_sb_field_disk_groups *gi = bch2_sb_get_disk_groups(sb);
 466         unsigned i;
 467
 468         for (i = 0; i < sb->nr_devices; i++) {
 469                 struct bch_member *m = mi->members + i;
 470                 time_t last_mount = le64_to_cpu(m->last_mount);
 471                 char member_uuid_str[40];
 472                 char data_allowed_str[100];
 473                 char data_has_str[100];
 474                 char group[BCH_SB_LABEL_SIZE+10];
 475                 char time_str[64];
 476
 477                 if (!bch2_member_exists(m))
 478                         continue;
 479
 480                 uuid_unparse(m->uuid.b, member_uuid_str);
 481
 482                 if (BCH_MEMBER_GROUP(m)) {
 483                         unsigned idx = BCH_MEMBER_GROUP(m) - 1;
 484
 485                         if (idx < disk_groups_nr(gi)) {
 486                                 snprintf(group, sizeof(group), "%.*s (%u)",
 487                                         BCH_SB_LABEL_SIZE,
 488                                         gi->entries[idx].label, idx);
 489                         } else {
 490                                 strcpy(group, "(bad disk groups section)");
 491                         }
 492                 } else {
 493                         strcpy(group, "(none)");
 494                 }
 495
 496                 bch2_flags_to_text(&PBUF(data_allowed_str),
 497                                    bch2_data_types,
 498                                    BCH_MEMBER_DATA_ALLOWED(m));
 499                 if (!data_allowed_str[0])
 500                         strcpy(data_allowed_str, "(none)");
 501
 502                 bch2_flags_to_text(&PBUF(data_has_str),
 503                                    bch2_data_types,
 504                                    get_dev_has_data(sb, i));
 505                 if (!data_has_str[0])
 506                         strcpy(data_has_str, "(none)");
 507
 508                 if (last_mount) {
 509                         struct tm *tm = localtime(&last_mount);
 510                         size_t err = strftime(time_str, sizeof(time_str), "%c", tm);
 511                         if (!err)
 512                                 strcpy(time_str, "(formatting error)");
 513                 } else {
 514                         strcpy(time_str, "(never)");
 515                 }
 516
 517                 printf("  Device %u:\n"
 518                        "    UUID:                       %s\n"
 519                        "    Size:                       %s\n"
 520                        "    Bucket size:                %s\n"
 521                        "    First bucket:               %u\n"
 522                        "    Buckets:                    %llu\n"
 523                        "    Last mount:                 %s\n"
 524                        "    State:                      %s\n"
 525                        "    Group:                      %s\n"
 526                        "    Data allowed:               %s\n"
 527
 528                        "    Has data:                   %s\n"
 529
 530                        "    Replacement policy:         %s\n"
 531                        "    Discard:                    %llu\n",
 532                        i, member_uuid_str,
 533                        pr_units(le16_to_cpu(m->bucket_size) *
 534                                 le64_to_cpu(m->nbuckets), units),
 535                        pr_units(le16_to_cpu(m->bucket_size), units),
 536                        le16_to_cpu(m->first_bucket),
 537                        le64_to_cpu(m->nbuckets),
 538                        time_str,
 539
 540                        BCH_MEMBER_STATE(m) < BCH_MEMBER_STATE_NR
 541                        ? bch2_member_states[BCH_MEMBER_STATE(m)]
 542                        : "unknown",
 543
 544                        group,
 545                        data_allowed_str,
 546                        data_has_str,
 547
 548                        BCH_MEMBER_REPLACEMENT(m) < BCH_CACHE_REPLACEMENT_NR
 549                        ? bch2_cache_replacement_policies[BCH_MEMBER_REPLACEMENT(m)]
 550                        : "unknown",
 551
 552                        BCH_MEMBER_DISCARD(m));
 553         }
 554 }
 555
 556 static void bch2_sb_print_crypt(struct bch_sb *sb, struct bch_sb_field *f,
 557                                 enum units units)
 558 {
 559         struct bch_sb_field_crypt *crypt = field_to_type(f, crypt);
 560
 561         printf("  KFD:                  %llu\n"
 562                "  scrypt n:             %llu\n"
 563                "  scrypt r:             %llu\n"
 564                "  scrypt p:             %llu\n",
 565                BCH_CRYPT_KDF_TYPE(crypt),
 566                BCH_KDF_SCRYPT_N(crypt),
 567                BCH_KDF_SCRYPT_R(crypt),
 568                BCH_KDF_SCRYPT_P(crypt));
 569 }
 570
 571 static void bch2_sb_print_replicas_v0(struct bch_sb *sb, struct bch_sb_field *f,
 572                                    enum units units)
 573 {
 574         struct bch_sb_field_replicas_v0 *replicas = field_to_type(f, replicas_v0);
 575         struct bch_replicas_entry_v0 *e;
 576         unsigned i;
 577
 578         for_each_replicas_entry(replicas, e) {
 579                 printf_pad(32, "  %s:", bch2_data_types[e->data_type]);
 580
 581                 putchar('[');
 582                 for (i = 0; i < e->nr_devs; i++) {
 583                         if (i)
 584                                 putchar(' ');
 585                         printf("%u", e->devs[i]);
 586                 }
 587                 printf("]\n");
 588         }
 589 }
 590
 591 static void bch2_sb_print_replicas(struct bch_sb *sb, struct bch_sb_field *f,
 592                                    enum units units)
 593 {
 594         struct bch_sb_field_replicas *replicas = field_to_type(f, replicas);
 595         struct bch_replicas_entry *e;
 596         unsigned i;
 597
 598         for_each_replicas_entry(replicas, e) {
 599                 printf_pad(32, "  %s: %u/%u",
 600                            bch2_data_types[e->data_type],
 601                            e->nr_required,
 602                            e->nr_devs);
 603
 604                 putchar('[');
 605                 for (i = 0; i < e->nr_devs; i++) {
 606                         if (i)
 607                                 putchar(' ');
 608                         printf("%u", e->devs[i]);
 609                 }
 610                 printf("]\n");
 611         }
 612 }
 613
 614 static void bch2_sb_print_quota(struct bch_sb *sb, struct bch_sb_field *f,
 615                                 enum units units)
 616 {
 617 }
 618
 619 static void bch2_sb_print_disk_groups(struct bch_sb *sb, struct bch_sb_field *f,
 620                                       enum units units)
 621 {
 622 }
 623
 624 static void bch2_sb_print_clean(struct bch_sb *sb, struct bch_sb_field *f,
 625                                 enum units units)
 626 {
 627         struct bch_sb_field_clean *clean = field_to_type(f, clean);
 628
 629
 630         printf("  flags:       %x", le32_to_cpu(clean->flags));
 631         printf("  journal seq: %llx", le64_to_cpu(clean->journal_seq));
 632 }
 633
 634 static void bch2_sb_print_journal_seq_blacklist(struct bch_sb *sb, struct bch_sb_field *f,
 635                                 enum units units)
 636 {
 637         struct bch_sb_field_journal_seq_blacklist *bl = field_to_type(f, journal_seq_blacklist);
 638         unsigned i, nr = blacklist_nr_entries(bl);
 639
 640         for (i = 0; i < nr; i++) {
 641                 struct journal_seq_blacklist_entry *e =
 642                         bl->start + i;
 643
 644                 printf("  %llu-%llu\n",
 645                        le64_to_cpu(e->start),
 646                        le64_to_cpu(e->end));
 647         }
 648 }
 649
 650 typedef void (*sb_field_print_fn)(struct bch_sb *, struct bch_sb_field *, enum units);
 651
 652 struct bch_sb_field_toolops {
 653         sb_field_print_fn       print;
 654 };
 655
 656 static const struct bch_sb_field_toolops bch2_sb_field_ops[] = {
 657 #define x(f, nr)                                        \
 658         [BCH_SB_FIELD_##f] = {                          \
 659                 .print  = bch2_sb_print_##f,            \
 660         },
 661         BCH_SB_FIELDS()
 662 #undef x
 663 };
 664
 665 static inline void bch2_sb_field_print(struct bch_sb *sb,
 666                                        struct bch_sb_field *f,
 667                                        enum units units)
 668 {
 669         unsigned type = le32_to_cpu(f->type);
 670
 671         if (type < BCH_SB_FIELD_NR)
 672                 bch2_sb_field_ops[type].print(sb, f, units);
 673         else
 674                 printf("(unknown field %u)\n", type);
 675 }
 676
 677 void bch2_sb_print(struct bch_sb *sb, bool print_layout,
 678                    unsigned fields, enum units units)
 679 {
 680         struct bch_sb_field_members *mi;
 681         char user_uuid_str[40], internal_uuid_str[40];
 682         char features_str[500];
 683         char fields_have_str[200];
 684         char label[BCH_SB_LABEL_SIZE + 1];
 685         char time_str[64];
 686         char foreground_str[64];
 687         char background_str[64];
 688         char promote_str[64];
 689         char metadata_str[64];
 690         struct bch_sb_field *f;
 691         u64 fields_have = 0;
 692         unsigned nr_devices = 0;
 693         time_t time_base = le64_to_cpu(sb->time_base_lo) / NSEC_PER_SEC;
 694
 695         memcpy(label, sb->label, BCH_SB_LABEL_SIZE);
 696         label[BCH_SB_LABEL_SIZE] = '\0';
 697
 698         uuid_unparse(sb->user_uuid.b, user_uuid_str);
 699         uuid_unparse(sb->uuid.b, internal_uuid_str);
 700
 701         if (time_base) {
 702                 struct tm *tm = localtime(&time_base);
 703                 size_t err = strftime(time_str, sizeof(time_str), "%c", tm);
 704                 if (!err)
 705                         strcpy(time_str, "(formatting error)");
 706         } else {
 707                 strcpy(time_str, "(not set)");
 708         }
 709
 710         mi = bch2_sb_get_members(sb);
 711         if (mi) {
 712                 struct bch_member *m;
 713
 714                 for (m = mi->members;
 715                      m < mi->members + sb->nr_devices;
 716                      m++)
 717                         nr_devices += bch2_member_exists(m);
 718         }
 719
 720         bch2_sb_get_target(sb, foreground_str, sizeof(foreground_str),
 721                 BCH_SB_FOREGROUND_TARGET(sb));
 722
 723         bch2_sb_get_target(sb, background_str, sizeof(background_str),
 724                 BCH_SB_BACKGROUND_TARGET(sb));
 725
 726         bch2_sb_get_target(sb, promote_str, sizeof(promote_str),
 727                 BCH_SB_PROMOTE_TARGET(sb));
 728
 729         bch2_sb_get_target(sb, metadata_str, sizeof(metadata_str),
 730                 BCH_SB_METADATA_TARGET(sb));
 731
 732         bch2_flags_to_text(&PBUF(features_str),
 733                            bch2_sb_features,
 734                            le64_to_cpu(sb->features[0]));
 735
 736         vstruct_for_each(sb, f)
 737                 fields_have |= 1 << le32_to_cpu(f->type);
 738         bch2_flags_to_text(&PBUF(fields_have_str),
 739                            bch2_sb_fields, fields_have);
 740
 741         printf("External UUID:                  %s\n"
 742                "Internal UUID:                  %s\n"
 743                "Device index:                   %u\n"
 744                "Label:                          %s\n"
 745                "Version:                        %u\n"
 746                "Oldest version on disk:         %u\n"
 747                "Created:                        %s\n"
 748                "Squence number:                 %llu\n"
 749                "Block_size:                     %s\n"
 750                "Btree node size:                %s\n"
 751                "Error action:                   %s\n"
 752                "Clean:                          %llu\n"
 753                "Features:                       %s\n"
 754
 755                "Metadata replicas:              %llu\n"
 756                "Data replicas:                  %llu\n"
 757
 758                "Metadata checksum type:         %s (%llu)\n"
 759                "Data checksum type:             %s (%llu)\n"
 760                "Compression type:               %s (%llu)\n"
 761
 762                "Foreground write target:        %s\n"
 763                "Background write target:        %s\n"
 764                "Promote target:                 %s\n"
 765                "Metadata target:                %s\n"
 766
 767                "String hash type:               %s (%llu)\n"
 768                "32 bit inodes:                  %llu\n"
 769                "GC reserve percentage:          %llu%%\n"
 770                "Root reserve percentage:        %llu%%\n"
 771
 772                "Devices:                        %u live, %u total\n"
 773                "Sections:                       %s\n"
 774                "Superblock size:                %llu\n",
 775                user_uuid_str,
 776                internal_uuid_str,
 777                sb->dev_idx,
 778                label,
 779                le16_to_cpu(sb->version),
 780                le16_to_cpu(sb->version_min),
 781                time_str,
 782                le64_to_cpu(sb->seq),
 783                pr_units(le16_to_cpu(sb->block_size), units),
 784                pr_units(BCH_SB_BTREE_NODE_SIZE(sb), units),
 785
 786                BCH_SB_ERROR_ACTION(sb) < BCH_ON_ERROR_NR
 787                ? bch2_error_actions[BCH_SB_ERROR_ACTION(sb)]
 788                : "unknown",
 789
 790                BCH_SB_CLEAN(sb),
 791                features_str,
 792
 793                BCH_SB_META_REPLICAS_WANT(sb),
 794                BCH_SB_DATA_REPLICAS_WANT(sb),
 795
 796                BCH_SB_META_CSUM_TYPE(sb) < BCH_CSUM_OPT_NR
 797                ? bch2_csum_opts[BCH_SB_META_CSUM_TYPE(sb)]
 798                : "unknown",
 799                BCH_SB_META_CSUM_TYPE(sb),
 800
 801                BCH_SB_DATA_CSUM_TYPE(sb) < BCH_CSUM_OPT_NR
 802                ? bch2_csum_opts[BCH_SB_DATA_CSUM_TYPE(sb)]
 803                : "unknown",
 804                BCH_SB_DATA_CSUM_TYPE(sb),
 805
 806                BCH_SB_COMPRESSION_TYPE(sb) < BCH_COMPRESSION_OPT_NR
 807                ? bch2_compression_opts[BCH_SB_COMPRESSION_TYPE(sb)]
 808                : "unknown",
 809                BCH_SB_COMPRESSION_TYPE(sb),
 810
 811                foreground_str,
 812                background_str,
 813                promote_str,
 814                metadata_str,
 815
 816                BCH_SB_STR_HASH_TYPE(sb) < BCH_STR_HASH_NR
 817                ? bch2_str_hash_types[BCH_SB_STR_HASH_TYPE(sb)]
 818                : "unknown",
 819                BCH_SB_STR_HASH_TYPE(sb),
 820
 821                BCH_SB_INODE_32BIT(sb),
 822                BCH_SB_GC_RESERVE(sb),
 823                BCH_SB_ROOT_RESERVE(sb),
 824
 825                nr_devices, sb->nr_devices,
 826                fields_have_str,
 827                vstruct_bytes(sb));
 828
 829         if (print_layout) {
 830                 printf("\n"
 831                        "Layout:\n");
 832                 bch2_sb_print_layout(sb, units);
 833         }
 834
 835         vstruct_for_each(sb, f) {
 836                 unsigned type = le32_to_cpu(f->type);
 837                 char name[60];
 838
 839                 if (!(fields & (1 << type)))
 840                         continue;
 841
 842                 if (type < BCH_SB_FIELD_NR) {
 843                         scnprintf(name, sizeof(name), "%s", bch2_sb_fields[type]);
 844                         name[0] = toupper(name[0]);
 845                 } else {
 846                         scnprintf(name, sizeof(name), "(unknown field %u)", type);
 847                 }
 848
 849                 printf("\n%s (size %llu):\n", name, vstruct_bytes(f));
 850                 if (type < BCH_SB_FIELD_NR)
 851                         bch2_sb_field_print(sb, f, units);
 852         }
 853 }
 854
 855 /* ioctl interface: */
 856
 857 /* Global control device: */
 858 int bcachectl_open(void)
 859 {
 860         return xopen("/dev/bcachefs-ctl", O_RDWR);
 861 }
 862
 863 /* Filesystem handles (ioctl, sysfs dir): */
 864
 865 #define SYSFS_BASE "/sys/fs/bcachefs/"
 866
 867 void bcache_fs_close(struct bchfs_handle fs)
 868 {
 869         close(fs.ioctl_fd);
 870         close(fs.sysfs_fd);
 871 }
 872
 873 struct bchfs_handle bcache_fs_open(const char *path)
 874 {
 875         struct bchfs_handle ret;
 876
 877         if (!uuid_parse(path, ret.uuid.b)) {
 878                 /* It's a UUID, look it up in sysfs: */
 879                 char *sysfs = mprintf(SYSFS_BASE "%s", path);
 880                 ret.sysfs_fd = xopen(sysfs, O_RDONLY);
 881
 882                 char *minor = read_file_str(ret.sysfs_fd, "minor");
 883                 char *ctl = mprintf("/dev/bcachefs%s-ctl", minor);
 884                 ret.ioctl_fd = xopen(ctl, O_RDWR);
 885
 886                 free(sysfs);
 887                 free(minor);
 888                 free(ctl);
 889         } else {
 890                 /* It's a path: */
 891                 ret.ioctl_fd = xopen(path, O_RDONLY);
 892
 893                 struct bch_ioctl_query_uuid uuid;
 894                 if (ioctl(ret.ioctl_fd, BCH_IOCTL_QUERY_UUID, &uuid) < 0)
 895                         die("error opening %s: not a bcachefs filesystem", path);
 896
 897                 ret.uuid = uuid.uuid;
 898
 899                 char uuid_str[40];
 900                 uuid_unparse(uuid.uuid.b, uuid_str);
 901
 902                 char *sysfs = mprintf(SYSFS_BASE "%s", uuid_str);
 903                 ret.sysfs_fd = xopen(sysfs, O_RDONLY);
 904                 free(sysfs);
 905         }
 906
 907         return ret;
 908 }
 909
 910 /*
 911  * Given a path to a block device, open the filesystem it belongs to; also
 912  * return the device's idx:
 913  */
 914 struct bchfs_handle bchu_fs_open_by_dev(const char *path, unsigned *idx)
 915 {
 916         char buf[1024], *uuid_str;
 917
 918         struct stat stat = xstat(path);
 919
 920         if (!S_ISBLK(stat.st_mode))
 921                 die("%s is not a block device", path);
 922
 923         char *sysfs = mprintf("/sys/dev/block/%u:%u/bcachefs",
 924                               major(stat.st_dev),
 925                               minor(stat.st_dev));
 926         ssize_t len = readlink(sysfs, buf, sizeof(buf));
 927         free(sysfs);
 928
 929         if (len > 0) {
 930                 char *p = strrchr(buf, '/');
 931                 if (!p || sscanf(p + 1, "dev-%u", idx) != 1)
 932                         die("error parsing sysfs");
 933
 934                 *p = '\0';
 935                 p = strrchr(buf, '/');
 936                 uuid_str = p + 1;
 937         } else {
 938                 struct bch_opts opts = bch2_opts_empty();
 939
 940                 opt_set(opts, noexcl,   true);
 941                 opt_set(opts, nochanges, true);
 942
 943                 struct bch_sb_handle sb;
 944                 int ret = bch2_read_super(path, &opts, &sb);
 945                 if (ret)
 946                         die("Error opening %s: %s", path, strerror(-ret));
 947
 948                 *idx = sb.sb->dev_idx;
 949                 uuid_str = buf;
 950                 uuid_unparse(sb.sb->user_uuid.b, uuid_str);
 951
 952                 bch2_free_super(&sb);
 953         }
 954
 955         return bcache_fs_open(uuid_str);
 956 }
 957
 958 int bchu_data(struct bchfs_handle fs, struct bch_ioctl_data cmd)
 959 {
 960         int progress_fd = xioctl(fs.ioctl_fd, BCH_IOCTL_DATA, &cmd);
 961
 962         while (1) {
 963                 struct bch_ioctl_data_event e;
 964
 965                 if (read(progress_fd, &e, sizeof(e)) != sizeof(e))
 966                         die("error reading from progress fd %m");
 967
 968                 if (e.type)
 969                         continue;
 970
 971                 if (e.p.data_type == U8_MAX)
 972                         break;
 973
 974                 printf("\33[2K\r");
 975
 976                 printf("%llu%% complete: current position %s",
 977                        e.p.sectors_total
 978                        ? e.p.sectors_done * 100 / e.p.sectors_total
 979                        : 0,
 980                        bch2_data_types[e.p.data_type]);
 981
 982                 switch (e.p.data_type) {
 983                 case BCH_DATA_btree:
 984                 case BCH_DATA_user:
 985                         printf(" %s:%llu:%llu",
 986                                bch2_btree_ids[e.p.btree_id],
 987                                e.p.pos.inode,
 988                                e.p.pos.offset);
 989                 }
 990
 991                 fflush(stdout);
 992                 sleep(1);
 993         }
 994         printf("\nDone\n");
 995
 996         close(progress_fd);
 997         return 0;
 998 }
 999
1000 /* option parsing */
1001
1002 struct bch_opt_strs bch2_cmdline_opts_get(int *argc, char *argv[],
1003                                           unsigned opt_types)
1004 {
1005         struct bch_opt_strs opts;
1006         unsigned i = 1;
1007
1008         memset(&opts, 0, sizeof(opts));
1009
1010         while (i < *argc) {
1011                 char *optstr = strcmp_prefix(argv[i], "--");
1012                 char *valstr = NULL, *p;
1013                 int optid, nr_args = 1;
1014
1015                 if (!optstr) {
1016                         i++;
1017                         continue;
1018                 }
1019
1020                 optstr = strdup(optstr);
1021
1022                 p = optstr;
1023                 while (isalpha(*p) || *p == '_')
1024                         p++;
1025
1026                 if (*p == '=') {
1027                         *p = '\0';
1028                         valstr = p + 1;
1029                 }
1030
1031                 optid = bch2_opt_lookup(optstr);
1032                 if (optid < 0 ||
1033                     !(bch2_opt_table[optid].mode & opt_types)) {
1034                         free(optstr);
1035                         i++;
1036                         continue;
1037                 }
1038
1039                 if (!valstr &&
1040                     bch2_opt_table[optid].type != BCH_OPT_BOOL) {
1041                         nr_args = 2;
1042                         valstr = argv[i + 1];
1043                 }
1044
1045                 if (!valstr)
1046                         valstr = "1";
1047
1048                 opts.by_id[optid] = valstr;
1049
1050                 *argc -= nr_args;
1051                 memmove(&argv[i],
1052                         &argv[i + nr_args],
1053                         sizeof(char *) * (*argc - i));
1054                 argv[*argc] = NULL;
1055         }
1056
1057         return opts;
1058 }
1059
1060 struct bch_opts bch2_parse_opts(struct bch_opt_strs strs)
1061 {
1062         struct bch_opts opts = bch2_opts_empty();
1063         unsigned i;
1064         int ret;
1065         u64 v;
1066
1067         for (i = 0; i < bch2_opts_nr; i++) {
1068                 if (!strs.by_id[i] ||
1069                     bch2_opt_table[i].type == BCH_OPT_FN)
1070                         continue;
1071
1072                 ret = bch2_opt_parse(NULL, &bch2_opt_table[i],
1073                                      strs.by_id[i], &v);
1074                 if (ret < 0)
1075                         die("Invalid %s: %s",
1076                             bch2_opt_table[i].attr.name,
1077                             strerror(-ret));
1078
1079                 bch2_opt_set_by_id(&opts, i, v);
1080         }
1081
1082         return opts;
1083 }
1084
1085 void bch2_opts_usage(unsigned opt_types)
1086 {
1087         const struct bch_option *opt;
1088         unsigned i, c = 0, helpcol = 30;
1089
1090         void tabalign() {
1091                 while (c < helpcol) {
1092                         putchar(' ');
1093                         c++;
1094                 }
1095         }
1096
1097         void newline() {
1098                 printf("\n");
1099                 c = 0;
1100         }
1101
1102         for (opt = bch2_opt_table;
1103              opt < bch2_opt_table + bch2_opts_nr;
1104              opt++) {
1105                 if (!(opt->mode & opt_types))
1106                         continue;
1107
1108                 c += printf("      --%s", opt->attr.name);
1109
1110                 switch (opt->type) {
1111                 case BCH_OPT_BOOL:
1112                         break;
1113                 case BCH_OPT_STR:
1114                         c += printf("=(");
1115                         for (i = 0; opt->choices[i]; i++) {
1116                                 if (i)
1117                                         c += printf("|");
1118                                 c += printf("%s", opt->choices[i]);
1119                         }
1120                         c += printf(")");
1121                         break;
1122                 default:
1123                         c += printf("=%s", opt->hint);
1124                         break;
1125                 }
1126
1127                 if (opt->help) {
1128                         const char *l = opt->help;
1129
1130                         if (c >= helpcol)
1131                                 newline();
1132
1133                         while (1) {
1134                                 const char *n = strchrnul(l, '\n');
1135
1136                                 tabalign();
1137                                 printf("%.*s", (int) (n - l), l);
1138                                 newline();
1139
1140                                 if (!*n)
1141                                         break;
1142                                 l = n + 1;
1143                         }
1144                 } else {
1145                         newline();
1146                 }
1147         }
1148 }
1149
1150 dev_names bchu_fs_get_devices(struct bchfs_handle fs)
1151 {
1152         DIR *dir = fdopendir(fs.sysfs_fd);
1153         struct dirent *d;
1154         dev_names devs;
1155
1156         darray_init(devs);
1157
1158         while ((errno = 0), (d = readdir(dir))) {
1159                 struct dev_name n = { 0, NULL, NULL };
1160
1161                 if (sscanf(d->d_name, "dev-%u", &n.idx) != 1)
1162                         continue;
1163
1164                 char *block_attr = mprintf("dev-%u/block", n.idx);
1165
1166                 char sysfs_block_buf[4096];
1167                 ssize_t r = readlinkat(fs.sysfs_fd, block_attr,
1168                                        sysfs_block_buf, sizeof(sysfs_block_buf));
1169                 if (r > 0) {
1170                         sysfs_block_buf[r] = '\0';
1171                         n.dev = strdup(basename(sysfs_block_buf));
1172                 }
1173
1174                 free(block_attr);
1175
1176                 char *label_attr = mprintf("dev-%u/label", n.idx);
1177                 n.label = read_file_str(fs.sysfs_fd, label_attr);
1178                 free(label_attr);
1179
1180                 darray_append(devs, n);
1181         }
1182
1183         closedir(dir);
1184
1185         return devs;
1186 }