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

   1 /*
   2  * Authors: Kent Overstreet <kent.overstreet@gmail.com>
   3  *          Gabriel de Perthuis <g2p.code@gmail.com>
   4  *          Jacob Malevich <jam@datera.io>
   5  *
   6  * GPLv2
   7  */
   8 #include <ctype.h>
   9 #include <errno.h>
  10 #include <fcntl.h>
  11 #include <getopt.h>
  12 #include <stdbool.h>
  13 #include <stdint.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <unistd.h>
  20
  21 #include <uuid/uuid.h>
  22
  23 #include "ccan/darray/darray.h"
  24
  25 #include "cmds.h"
  26 #include "libbcachefs.h"
  27 #include "crypto.h"
  28 #include "libbcachefs/opts.h"
  29 #include "libbcachefs/super-io.h"
  30 #include "libbcachefs/util.h"
  31
  32 #define OPTS                                            \
  33 x(0,    replicas,               required_argument)      \
  34 x(0,    encrypted,              no_argument)            \
  35 x(0,    no_passphrase,          no_argument)            \
  36 x('L',  fs_label,               required_argument)      \
  37 x('U',  uuid,                   required_argument)      \
  38 x(0,    fs_size,                required_argument)      \
  39 x(0,    superblock_size,        required_argument)      \
  40 x(0,    bucket_size,            required_argument)      \
  41 x('l',  label,                  required_argument)      \
  42 x(0,    discard,                no_argument)            \
  43 x(0,    data_allowed,           required_argument)      \
  44 x(0,    durability,             required_argument)      \
  45 x(0,    version,                required_argument)      \
  46 x(0,    no_initialize,          no_argument)            \
  47 x('f',  force,                  no_argument)            \
  48 x('q',  quiet,                  no_argument)            \
  49 x('h',  help,                   no_argument)
  50
  51 static void usage(void)
  52 {
  53         puts("bcachefs format - create a new bcachefs filesystem on one or more devices\n"
  54              "Usage: bcachefs format [OPTION]... <devices>\n"
  55              "\n"
  56              "Options:");
  57
  58         bch2_opts_usage(OPT_FORMAT);
  59
  60         puts(
  61              "      --replicas=#            Sets both data and metadata replicas\n"
  62              "      --encrypted             Enable whole filesystem encryption (chacha20/poly1305)\n"
  63              "      --no_passphrase         Don't encrypt master encryption key\n"
  64              "  -L, --fs_label=label\n"
  65              "  -U, --uuid=uuid\n"
  66              "      --superblock_size=size\n"
  67              "\n"
  68              "Device specific options:");
  69
  70         bch2_opts_usage(OPT_DEVICE);
  71
  72         puts("  -l, --label=label           Disk label\n"
  73              "\n"
  74              "  -f, --force\n"
  75              "  -q, --quiet                 Only print errors\n"
  76              "  -h, --help                  Display this help and exit\n"
  77              "\n"
  78              "Device specific options must come before corresponding devices, e.g.\n"
  79              "  bcachefs format --label cache /dev/sdb /dev/sdc\n"
  80              "\n"
  81              "Report bugs to <linux-bcache@vger.kernel.org>");
  82 }
  83
  84 enum {
  85         O_no_opt = 1,
  86 #define x(shortopt, longopt, arg)       O_##longopt,
  87         OPTS
  88 #undef x
  89 };
  90
  91 #define x(shortopt, longopt, arg) {                     \
  92         .name           = #longopt,                     \
  93         .has_arg        = arg,                          \
  94         .flag           = NULL,                         \
  95         .val            = O_##longopt,                  \
  96 },
  97 static const struct option format_opts[] = {
  98         OPTS
  99         { NULL }
 100 };
 101 #undef x
 102
 103 u64 read_flag_list_or_die(char *opt, const char * const list[],
 104                           const char *msg)
 105 {
 106         u64 v = bch2_read_flag_list(opt, list);
 107         if (v == (u64) -1)
 108                 die("Bad %s %s", msg, opt);
 109
 110         return v;
 111 }
 112
 113 int cmd_format(int argc, char *argv[])
 114 {
 115         darray(struct dev_opts) devices;
 116         darray(char *) device_paths;
 117         struct format_opts opts = format_opts_default();
 118         struct dev_opts dev_opts = dev_opts_default(), *dev;
 119         bool force = false, no_passphrase = false, quiet = false, initialize = true;
 120         unsigned v;
 121         int opt;
 122
 123         darray_init(devices);
 124         darray_init(device_paths);
 125
 126         struct bch_opt_strs fs_opt_strs =
 127                 bch2_cmdline_opts_get(&argc, argv, OPT_FORMAT);
 128         struct bch_opts fs_opts = bch2_parse_opts(fs_opt_strs);
 129
 130         while ((opt = getopt_long(argc, argv,
 131                                   "-L:U:g:fqh",
 132                                   format_opts,
 133                                   NULL)) != -1)
 134                 switch (opt) {
 135                 case O_replicas:
 136                         if (kstrtouint(optarg, 10, &v) ||
 137                             !v ||
 138                             v > BCH_REPLICAS_MAX)
 139                                 die("invalid replicas");
 140
 141                         opt_set(fs_opts, metadata_replicas, v);
 142                         opt_set(fs_opts, data_replicas, v);
 143                         break;
 144                 case O_encrypted:
 145                         opts.encrypted = true;
 146                         break;
 147                 case O_no_passphrase:
 148                         no_passphrase = true;
 149                         break;
 150                 case O_fs_label:
 151                 case 'L':
 152                         opts.label = optarg;
 153                         break;
 154                 case O_uuid:
 155                 case 'U':
 156                         if (uuid_parse(optarg, opts.uuid.b))
 157                                 die("Bad uuid");
 158                         break;
 159                 case O_force:
 160                 case 'f':
 161                         force = true;
 162                         break;
 163                 case O_fs_size:
 164                         if (bch2_strtoull_h(optarg, &dev_opts.size))
 165                                 die("invalid filesystem size");
 166                         break;
 167                 case O_superblock_size:
 168                         if (bch2_strtouint_h(optarg, &opts.superblock_size))
 169                                 die("invalid filesystem size");
 170
 171                         opts.superblock_size >>= 9;
 172                         break;
 173                 case O_bucket_size:
 174                         if (bch2_strtoull_h(optarg, &dev_opts.bucket_size))
 175                                 die("bad bucket_size %s", optarg);
 176                         break;
 177                 case O_label:
 178                 case 'l':
 179                         dev_opts.label = optarg;
 180                         break;
 181                 case O_discard:
 182                         dev_opts.discard = true;
 183                         break;
 184                 case O_data_allowed:
 185                         dev_opts.data_allowed =
 186                                 read_flag_list_or_die(optarg,
 187                                         bch2_data_types, "data type");
 188                         break;
 189                 case O_durability:
 190                         if (kstrtouint(optarg, 10, &dev_opts.durability) ||
 191                             dev_opts.durability > BCH_REPLICAS_MAX)
 192                                 die("invalid durability");
 193                         break;
 194                 case O_version:
 195                         if (kstrtouint(optarg, 10, &opts.version))
 196                                 die("invalid version");
 197                         break;
 198                 case O_no_initialize:
 199                         initialize = false;
 200                         break;
 201                 case O_no_opt:
 202                         darray_append(device_paths, optarg);
 203                         dev_opts.path = optarg;
 204                         darray_append(devices, dev_opts);
 205                         dev_opts.size = 0;
 206                         break;
 207                 case O_quiet:
 208                 case 'q':
 209                         quiet = true;
 210                         break;
 211                 case O_help:
 212                 case 'h':
 213                         usage();
 214                         exit(EXIT_SUCCESS);
 215                         break;
 216                 case '?':
 217                         exit(EXIT_FAILURE);
 218                         break;
 219                 }
 220
 221         if (darray_empty(devices))
 222                 die("Please supply a device");
 223
 224         if (opts.encrypted && !no_passphrase) {
 225                 opts.passphrase = read_passphrase_twice("Enter passphrase: ");
 226                 initialize = false;
 227         }
 228
 229         darray_foreach(dev, devices)
 230                 dev->fd = open_for_format(dev->path, force);
 231
 232         struct bch_sb *sb =
 233                 bch2_format(fs_opt_strs,
 234                             fs_opts,
 235                             opts,
 236                             devices.item, darray_size(devices));
 237         bch2_opt_strs_free(&fs_opt_strs);
 238
 239         if (!quiet) {
 240                 struct printbuf buf = PRINTBUF;
 241
 242                 buf.units = PRINTBUF_UNITS_HUMAN_READABLE;
 243
 244                 bch2_sb_to_text(&buf, sb, false, 1 << BCH_SB_FIELD_members);
 245                 printf("%s", buf.buf);
 246
 247                 printbuf_exit(&buf);
 248         }
 249         free(sb);
 250
 251         if (opts.passphrase) {
 252                 memzero_explicit(opts.passphrase, strlen(opts.passphrase));
 253                 free(opts.passphrase);
 254         }
 255
 256         darray_free(devices);
 257
 258         if (initialize) {
 259                 struct bch_opts mount_opts = bch2_opts_empty();
 260
 261
 262                 opt_set(mount_opts, verbose, true);
 263
 264                 /*
 265                  * Start the filesystem once, to allocate the journal and create
 266                  * the root directory:
 267                  */
 268                 struct bch_fs *c = bch2_fs_open(device_paths.item,
 269                                                 darray_size(device_paths),
 270                                                 mount_opts);
 271                 if (IS_ERR(c))
 272                         die("error opening %s: %s", device_paths.item[0],
 273                             strerror(-PTR_ERR(c)));
 274
 275                 bch2_fs_stop(c);
 276         }
 277
 278         darray_free(device_paths);
 279
 280         return 0;
 281 }
 282
 283 static void show_super_usage(void)
 284 {
 285         puts("bcachefs show-super \n"
 286              "Usage: bcachefs show-super [OPTION].. device\n"
 287              "\n"
 288              "Options:\n"
 289              "  -f, --fields=(fields)       list of sections to print\n"
 290              "  -l, --layout                print superblock layout\n"
 291              "  -h, --help                  display this help and exit\n"
 292              "Report bugs to <linux-bcache@vger.kernel.org>");
 293         exit(EXIT_SUCCESS);
 294 }
 295
 296 int cmd_show_super(int argc, char *argv[])
 297 {
 298         static const struct option longopts[] = {
 299                 { "fields",                     1, NULL, 'f' },
 300                 { "layout",                     0, NULL, 'l' },
 301                 { "help",                       0, NULL, 'h' },
 302                 { NULL }
 303         };
 304         unsigned fields = 1 << BCH_SB_FIELD_members;
 305         bool print_layout = false;
 306         int opt;
 307
 308         while ((opt = getopt_long(argc, argv, "f:lh", longopts, NULL)) != -1)
 309                 switch (opt) {
 310                 case 'f':
 311                         fields = !strcmp(optarg, "all")
 312                                 ? ~0
 313                                 : read_flag_list_or_die(optarg,
 314                                         bch2_sb_fields, "superblock field");
 315                         break;
 316                 case 'l':
 317                         print_layout = true;
 318                         break;
 319                 case 'h':
 320                         show_super_usage();
 321                         break;
 322                 }
 323         args_shift(optind);
 324
 325         char *dev = arg_pop();
 326         if (!dev)
 327                 die("please supply a device");
 328         if (argc)
 329                 die("too many arguments");
 330
 331         struct bch_opts opts = bch2_opts_empty();
 332
 333         opt_set(opts, noexcl,   true);
 334         opt_set(opts, nochanges, true);
 335
 336         struct bch_sb_handle sb;
 337         int ret = bch2_read_super(dev, &opts, &sb);
 338         if (ret)
 339                 die("Error opening %s: %s", dev, strerror(-ret));
 340
 341         struct printbuf buf = PRINTBUF;
 342
 343         buf.units = PRINTBUF_UNITS_HUMAN_READABLE;
 344
 345         bch2_sb_to_text(&buf, sb.sb, print_layout, fields);
 346         printf("%s", buf.buf);
 347
 348         bch2_free_super(&sb);
 349         printbuf_exit(&buf);
 350         return 0;
 351 }