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

   1 #include <errno.h>
   2 #include <fcntl.h>
   3 #include <getopt.h>
   4 #include <libgen.h>
   5 #include <stdbool.h>
   6 #include <stdint.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <sys/ioctl.h>
  11 #include <sys/stat.h>
  12 #include <sys/types.h>
  13 #include <unistd.h>
  14
  15 #include "libbcachefs/bcachefs.h"
  16 #include "libbcachefs/bcachefs_ioctl.h"
  17 #include "libbcachefs/errcode.h"
  18 #include "libbcachefs/journal.h"
  19 #include "libbcachefs/sb-members.h"
  20 #include "libbcachefs/super-io.h"
  21 #include "cmds.h"
  22 #include "libbcachefs.h"
  23 #include "libbcachefs/opts.h"
  24 #include "tools-util.h"
  25
  26 int device_usage(void)
  27 {
  28        puts("bcachefs device - manage devices within a running filesystem\n"
  29             "Usage: bcachefs device <CMD> [OPTION]\n"
  30             "\n"
  31             "Commands:\n"
  32             "  add                     add a new device to an existing filesystem\n"
  33             "  remove                  remove a device from an existing filesystem\n"
  34             "  online                  re-add an existing member to a filesystem\n"
  35             "  offline                 take a device offline, without removing it\n"
  36             "  evacuate                migrate data off a specific device\n"
  37             "  set-state               mark a device as failed\n"
  38             "  resize                  resize filesystem on a device\n"
  39             "  resize-journal          resize journal on a device\n"
  40             "\n"
  41             "Report bugs to <linux-bcachefs@vger.kernel.org>");
  42        return 0;
  43 }
  44
  45 static void device_add_usage(void)
  46 {
  47         puts("bcachefs device add - add a device to an existing filesystem\n"
  48              "Usage: bcachefs device add [OPTION]... filesystem device\n"
  49              "\n"
  50              "Options:\n"
  51              "  -S, --fs_size=size          Size of filesystem on device\n"
  52              "  -B, --bucket=size           Bucket size\n"
  53              "  -D, --discard               Enable discards\n"
  54              "  -l, --label=label           Disk label\n"
  55              "  -f, --force                 Use device even if it appears to already be formatted\n"
  56              "  -h, --help                  Display this help and exit\n"
  57              "\n"
  58              "Report bugs to <linux-bcachefs@vger.kernel.org>");
  59 }
  60
  61 int cmd_device_add(int argc, char *argv[])
  62 {
  63         static const struct option longopts[] = {
  64                 { "fs_size",            required_argument,      NULL, 'S' },
  65                 { "bucket",             required_argument,      NULL, 'B' },
  66                 { "discard",            no_argument,            NULL, 'D' },
  67                 { "label",              required_argument,      NULL, 'l' },
  68                 { "force",              no_argument,            NULL, 'f' },
  69                 { "help",               no_argument,            NULL, 'h' },
  70                 { NULL }
  71         };
  72         struct format_opts format_opts  = format_opts_default();
  73         struct dev_opts dev_opts        = dev_opts_default();
  74         bool force = false;
  75         int opt;
  76
  77         while ((opt = getopt_long(argc, argv, "t:fh",
  78                                   longopts, NULL)) != -1)
  79                 switch (opt) {
  80                 case 'S':
  81                         if (bch2_strtoull_h(optarg, &dev_opts.size))
  82                                 die("invalid filesystem size");
  83                         break;
  84                 case 'B':
  85                         if (bch2_strtoull_h(optarg, &dev_opts.bucket_size))
  86                                 die("bad bucket_size %s", optarg);
  87                         break;
  88                 case 'D':
  89                         dev_opts.discard = true;
  90                         break;
  91                 case 'l':
  92                         dev_opts.label = strdup(optarg);
  93                         break;
  94                 case 'f':
  95                         force = true;
  96                         break;
  97                 case 'h':
  98                         device_add_usage();
  99                         exit(EXIT_SUCCESS);
 100                 }
 101         args_shift(optind);
 102
 103         char *fs_path = arg_pop();
 104         if (!fs_path)
 105                 die("Please supply a filesystem");
 106
 107         dev_opts.path = arg_pop();
 108         if (!dev_opts.path)
 109                 die("Please supply a device");
 110
 111         if (argc)
 112                 die("too many arguments");
 113
 114         struct bchfs_handle fs = bcache_fs_open(fs_path);
 115
 116         int ret = open_for_format(&dev_opts, force);
 117         if (ret)
 118                 die("Error opening %s: %s", dev_opts.path, strerror(-ret));
 119
 120         struct bch_opt_strs fs_opt_strs;
 121         memset(&fs_opt_strs, 0, sizeof(fs_opt_strs));
 122
 123         struct bch_opts fs_opts = bch2_parse_opts(fs_opt_strs);
 124
 125         opt_set(fs_opts, block_size,
 126                 read_file_u64(fs.sysfs_fd, "options/block_size"));
 127         opt_set(fs_opts, btree_node_size,
 128                 read_file_u64(fs.sysfs_fd, "options/btree_node_size"));
 129
 130         struct bch_sb *sb = bch2_format(fs_opt_strs,
 131                                         fs_opts,
 132                                         format_opts,
 133                                         &dev_opts, 1);
 134         free(sb);
 135         fsync(dev_opts.bdev->bd_buffered_fd);
 136         close(dev_opts.bdev->bd_buffered_fd);
 137
 138         bchu_disk_add(fs, dev_opts.path);
 139         return 0;
 140 }
 141
 142 static void device_remove_usage(void)
 143 {
 144         puts("bcachefs device_remove - remove a device from a filesystem\n"
 145              "Usage:\n"
 146              "  bcachefs device remove <device>|<devid> <path>\n"
 147              "\n"
 148              "Options:\n"
 149              "  -f, --force                 Force removal, even if some data\n"
 150              "                              couldn't be migrated\n"
 151              "  -F, --force-metadata        Force removal, even if some metadata\n"
 152              "                              couldn't be migrated\n"
 153              "  -h, --help                  display this help and exit\n"
 154              "Report bugs to <linux-bcachefs@vger.kernel.org>");
 155         exit(EXIT_SUCCESS);
 156 }
 157
 158 int cmd_device_remove(int argc, char *argv[])
 159 {
 160         static const struct option longopts[] = {
 161                 { "by-id",              0, NULL, 'i' },
 162                 { "force",              0, NULL, 'f' },
 163                 { "force-metadata",     0, NULL, 'F' },
 164                 { "help",               0, NULL, 'h' },
 165                 { NULL }
 166         };
 167         struct bchfs_handle fs;
 168         bool by_id = false;
 169         int opt, flags = BCH_FORCE_IF_DEGRADED, dev_idx;
 170
 171         while ((opt = getopt_long(argc, argv, "fh", longopts, NULL)) != -1)
 172                 switch (opt) {
 173                 case 'f':
 174                         flags |= BCH_FORCE_IF_DATA_LOST;
 175                         break;
 176                 case 'F':
 177                         flags |= BCH_FORCE_IF_METADATA_LOST;
 178                         break;
 179                 case 'h':
 180                         device_remove_usage();
 181                 }
 182         args_shift(optind);
 183
 184         char *dev_str = arg_pop();
 185         if (!dev_str)
 186                 die("Please supply a device");
 187
 188         char *end;
 189         dev_idx = strtoul(dev_str, &end, 10);
 190         if (*dev_str && !*end)
 191                 by_id = true;
 192
 193         char *fs_path = arg_pop();
 194         if (fs_path) {
 195                 fs = bcache_fs_open(fs_path);
 196
 197                 if (!by_id) {
 198                         dev_idx = bchu_dev_path_to_idx(fs, dev_str);
 199                         if (dev_idx < 0)
 200                                 die("%s does not seem to be a member of %s",
 201                                     dev_str, fs_path);
 202                 }
 203         } else if (!by_id) {
 204                 fs = bchu_fs_open_by_dev(dev_str, &dev_idx);
 205         } else {
 206                 die("Filesystem path required when specifying device by id");
 207         }
 208
 209         bchu_disk_remove(fs, dev_idx, flags);
 210         return 0;
 211 }
 212
 213 static void device_online_usage(void)
 214 {
 215         puts("bcachefs device online - readd a device to a running filesystem\n"
 216              "Usage: bcachefs device online [OPTION]... device\n"
 217              "\n"
 218              "Options:\n"
 219              "  -h, --help                  Display this help and exit\n"
 220              "\n"
 221              "Report bugs to <linux-bcachefs@vger.kernel.org>");
 222 }
 223
 224 int cmd_device_online(int argc, char *argv[])
 225 {
 226         int opt;
 227
 228         while ((opt = getopt(argc, argv, "h")) != -1)
 229                 switch (opt) {
 230                 case 'h':
 231                         device_online_usage();
 232                         exit(EXIT_SUCCESS);
 233                 }
 234         args_shift(optind);
 235
 236         char *dev = arg_pop();
 237         if (!dev)
 238                 die("Please supply a device");
 239
 240         if (argc)
 241                 die("too many arguments");
 242
 243         int dev_idx;
 244         struct bchfs_handle fs = bchu_fs_open_by_dev(dev, &dev_idx);
 245         bchu_disk_online(fs, dev);
 246         return 0;
 247 }
 248
 249 static void device_offline_usage(void)
 250 {
 251         puts("bcachefs device offline - take a device offline, without removing it\n"
 252              "Usage: bcachefs device offline [OPTION]... device\n"
 253              "\n"
 254              "Options:\n"
 255              "  -f, --force                 Force, if data redundancy will be degraded\n"
 256              "  -h, --help                  Display this help and exit\n"
 257              "\n"
 258              "Report bugs to <linux-bcachefs@vger.kernel.org>");
 259 }
 260
 261 int cmd_device_offline(int argc, char *argv[])
 262 {
 263         static const struct option longopts[] = {
 264                 { "force",              0, NULL, 'f' },
 265                 { NULL }
 266         };
 267         int opt, flags = 0;
 268
 269         while ((opt = getopt_long(argc, argv, "fh",
 270                                   longopts, NULL)) != -1)
 271                 switch (opt) {
 272                 case 'f':
 273                         flags |= BCH_FORCE_IF_DEGRADED;
 274                         break;
 275                 case 'h':
 276                         device_offline_usage();
 277                         exit(EXIT_SUCCESS);
 278                 }
 279         args_shift(optind);
 280
 281         char *dev = arg_pop();
 282         if (!dev)
 283                 die("Please supply a device");
 284
 285         if (argc)
 286                 die("too many arguments");
 287
 288         int dev_idx;
 289         struct bchfs_handle fs = bchu_fs_open_by_dev(dev, &dev_idx);
 290         bchu_disk_offline(fs, dev_idx, flags);
 291         return 0;
 292 }
 293
 294 static void device_evacuate_usage(void)
 295 {
 296         puts("bcachefs device evacuate - move data off of a given device\n"
 297              "Usage: bcachefs device evacuate [OPTION]... device\n"
 298              "\n"
 299              "Options:\n"
 300              "  -h, --help                  Display this help and exit\n"
 301              "\n"
 302              "Report bugs to <linux-bcachefs@vger.kernel.org>");
 303 }
 304
 305 int cmd_device_evacuate(int argc, char *argv[])
 306 {
 307         int opt;
 308
 309         while ((opt = getopt(argc, argv, "h")) != -1)
 310                 switch (opt) {
 311                 case 'h':
 312                         device_evacuate_usage();
 313                         exit(EXIT_SUCCESS);
 314                 }
 315         args_shift(optind);
 316
 317         char *dev_path = arg_pop();
 318         if (!dev_path)
 319                 die("Please supply a device");
 320
 321         if (argc)
 322                 die("too many arguments");
 323
 324         int dev_idx;
 325         struct bchfs_handle fs = bchu_fs_open_by_dev(dev_path, &dev_idx);
 326
 327         struct bch_ioctl_dev_usage u = bchu_dev_usage(fs, dev_idx);
 328
 329         if (u.state == BCH_MEMBER_STATE_rw) {
 330                 printf("Setting %s readonly\n", dev_path);
 331                 bchu_disk_set_state(fs, dev_idx, BCH_MEMBER_STATE_ro, 0);
 332         }
 333
 334         return bchu_data(fs, (struct bch_ioctl_data) {
 335                 .op             = BCH_DATA_OP_MIGRATE,
 336                 .start_btree    = 0,
 337                 .start_pos      = POS_MIN,
 338                 .end_btree      = BTREE_ID_NR,
 339                 .end_pos        = POS_MAX,
 340                 .migrate.dev    = dev_idx,
 341         });
 342 }
 343
 344 static void device_set_state_usage(void)
 345 {
 346         puts("bcachefs device set-state\n"
 347              "Usage: bcachefs device set-state <new-state> <device>|<devid> <path>\n"
 348              "\n"
 349              "<new-state>: one of rw, ro, failed or spare\n"
 350              "<path>: path to mounted filesystem, optional unless specifying device by id\n"
 351              "\n"
 352              "Options:\n"
 353              "  -f, --force                 Force, if data redundancy will be degraded\n"
 354              "      --force-if-data-lost    Force, if data will be lost\n"
 355              "  -o, --offline               Set state of an offline device\n"
 356              "  -h, --help                  display this help and exit\n"
 357              "Report bugs to <linux-bcachefs@vger.kernel.org>");
 358         exit(EXIT_SUCCESS);
 359 }
 360
 361 int cmd_device_set_state(int argc, char *argv[])
 362 {
 363         static const struct option longopts[] = {
 364                 { "force",                      0, NULL, 'f' },
 365                 { "force-if-data-lost",         0, NULL, 'F' },
 366                 { "offline",                    0, NULL, 'o' },
 367                 { "help",                       0, NULL, 'h' },
 368                 { NULL }
 369         };
 370         struct bchfs_handle fs;
 371         bool by_id = false;
 372         int opt, flags = 0, dev_idx;
 373         bool offline = false;
 374
 375         while ((opt = getopt_long(argc, argv, "foh", longopts, NULL)) != -1)
 376                 switch (opt) {
 377                 case 'f':
 378                         flags |= BCH_FORCE_IF_DEGRADED;
 379                         break;
 380                 case 'F':
 381                         flags |= BCH_FORCE_IF_DEGRADED;
 382                         flags |= BCH_FORCE_IF_LOST;
 383                         break;
 384                 case 'o':
 385                         offline = true;
 386                         break;
 387                 case 'h':
 388                         device_set_state_usage();
 389                 }
 390         args_shift(optind);
 391
 392         char *new_state_str = arg_pop();
 393         if (!new_state_str)
 394                 die("Please supply a device state");
 395
 396         unsigned new_state = read_string_list_or_die(new_state_str,
 397                                         bch2_member_states, "device state");
 398
 399         char *dev_str = arg_pop();
 400         if (!dev_str)
 401                 die("Please supply a device");
 402
 403         char *end;
 404         dev_idx = strtoul(dev_str, &end, 10);
 405         if (*dev_str && !*end)
 406                 by_id = true;
 407
 408         if (offline) {
 409                 struct bch_opts opts = bch2_opts_empty();
 410                 struct bch_sb_handle sb = { NULL };
 411
 412                 if (by_id)
 413                         die("Cannot specify offline device by id");
 414
 415                 int ret = bch2_read_super(dev_str, &opts, &sb);
 416                 if (ret)
 417                         die("error opening %s: %s", dev_str, bch2_err_str(ret));
 418
 419                 struct bch_member *m = bch2_members_v2_get_mut(sb.sb, sb.sb->dev_idx);
 420
 421                 SET_BCH_MEMBER_STATE(m, new_state);
 422
 423                 le64_add_cpu(&sb.sb->seq, 1);
 424
 425                 bch2_super_write(sb.bdev->bd_buffered_fd, sb.sb);
 426                 ret = fsync(sb.bdev->bd_buffered_fd);
 427                 if (ret)
 428                         fprintf(stderr, "error writing superblock: fsync error (%m)");
 429                 bch2_free_super(&sb);
 430                 return ret;
 431         }
 432
 433         char *fs_path = arg_pop();
 434         if (fs_path) {
 435                 fs = bcache_fs_open(fs_path);
 436
 437                 if (!by_id) {
 438                         dev_idx = bchu_dev_path_to_idx(fs, dev_str);
 439                         if (dev_idx < 0)
 440                                 die("%s does not seem to be a member of %s",
 441                                     dev_str, fs_path);
 442                 }
 443         } else if (!by_id) {
 444                 fs = bchu_fs_open_by_dev(dev_str, &dev_idx);
 445         } else {
 446                 die("Filesystem path required when specifying device by id");
 447         }
 448
 449         bchu_disk_set_state(fs, dev_idx, new_state, flags);
 450
 451         return 0;
 452 }
 453
 454 static void device_resize_usage(void)
 455 {
 456         puts("bcachefs device resize \n"
 457              "Usage: bcachefs device resize device [ size ]\n"
 458              "\n"
 459              "Options:\n"
 460              "  -h, --help                  display this help and exit\n"
 461              "Report bugs to <linux-bcachefs@vger.kernel.org>");
 462         exit(EXIT_SUCCESS);
 463 }
 464
 465 int cmd_device_resize(int argc, char *argv[])
 466 {
 467         static const struct option longopts[] = {
 468                 { "help",                       0, NULL, 'h' },
 469                 { NULL }
 470         };
 471         u64 size;
 472         int opt;
 473
 474         while ((opt = getopt_long(argc, argv, "h", longopts, NULL)) != -1)
 475                 switch (opt) {
 476                 case 'h':
 477                         device_resize_usage();
 478                 }
 479         args_shift(optind);
 480
 481         char *dev = arg_pop();
 482         if (!dev)
 483                 die("Please supply a device to resize");
 484
 485         int dev_fd = xopen(dev, O_RDONLY);
 486
 487         char *size_arg = arg_pop();
 488         if (!size_arg)
 489                 size = get_size(dev_fd);
 490         else if (bch2_strtoull_h(size_arg, &size))
 491                 die("invalid size");
 492
 493         size >>= 9;
 494
 495         if (argc)
 496                 die("Too many arguments");
 497
 498         struct stat dev_stat = xfstat(dev_fd);
 499
 500         struct mntent *mount = dev_to_mount(dev);
 501         if (mount) {
 502                 if (!S_ISBLK(dev_stat.st_mode))
 503                         die("%s is mounted but isn't a block device?!", dev);
 504
 505                 printf("Doing online resize of %s\n", dev);
 506
 507                 struct bchfs_handle fs = bcache_fs_open(mount->mnt_dir);
 508
 509                 unsigned idx = bchu_disk_get_idx(fs, dev_stat.st_rdev);
 510
 511                 struct bch_sb *sb = bchu_read_super(fs, -1);
 512                 if (idx >= sb->nr_devices)
 513                         die("error reading superblock: dev idx >= sb->nr_devices");
 514
 515                 struct bch_member m = bch2_sb_member_get(sb, idx);
 516
 517                 u64 nbuckets = size / le16_to_cpu(m.bucket_size);
 518
 519                 if (nbuckets < le64_to_cpu(m.nbuckets))
 520                         die("Shrinking not supported yet");
 521
 522                 printf("resizing %s to %llu buckets\n", dev, nbuckets);
 523                 bchu_disk_resize(fs, idx, nbuckets);
 524         } else {
 525                 printf("Doing offline resize of %s\n", dev);
 526
 527                 struct bch_fs *c = bch2_fs_open(&dev, 1, bch2_opts_empty());
 528                 if (IS_ERR(c))
 529                         die("error opening %s: %s", dev, bch2_err_str(PTR_ERR(c)));
 530
 531                 struct bch_dev *ca, *resize = NULL;
 532                 unsigned i;
 533
 534                 for_each_online_member(ca, c, i) {
 535                         if (resize)
 536                                 die("confused: more than one online device?");
 537                         resize = ca;
 538                         percpu_ref_get(&resize->io_ref);
 539                 }
 540
 541                 u64 nbuckets = size / le16_to_cpu(resize->mi.bucket_size);
 542
 543                 if (nbuckets < le64_to_cpu(resize->mi.nbuckets))
 544                         die("Shrinking not supported yet");
 545
 546                 printf("resizing %s to %llu buckets\n", dev, nbuckets);
 547                 int ret = bch2_dev_resize(c, resize, nbuckets);
 548                 if (ret)
 549                         fprintf(stderr, "resize error: %s\n", bch2_err_str(ret));
 550
 551                 percpu_ref_put(&resize->io_ref);
 552                 bch2_fs_stop(c);
 553         }
 554         return 0;
 555 }
 556
 557 static void device_resize_journal_usage(void)
 558 {
 559         puts("bcachefs device resize-journal \n"
 560              "Usage: bcachefs device resize-journal device size\n"
 561              "\n"
 562              "Options:\n"
 563              "  -h, --help                  display this help and exit\n"
 564              "Report bugs to <linux-bcachefs@vger.kernel.org>");
 565         exit(EXIT_SUCCESS);
 566 }
 567
 568 int cmd_device_resize_journal(int argc, char *argv[])
 569 {
 570         static const struct option longopts[] = {
 571                 { "help",                       0, NULL, 'h' },
 572                 { NULL }
 573         };
 574         u64 size;
 575         int opt;
 576
 577         while ((opt = getopt_long(argc, argv, "h", longopts, NULL)) != -1)
 578                 switch (opt) {
 579                 case 'h':
 580                         device_resize_journal_usage();
 581                 }
 582         args_shift(optind);
 583
 584         char *dev = arg_pop();
 585         if (!dev)
 586                 die("Please supply a device");
 587
 588         int dev_fd = xopen(dev, O_RDONLY);
 589
 590         char *size_arg = arg_pop();
 591         if (!size_arg)
 592                 die("Please supply a journal size");
 593         else if (bch2_strtoull_h(size_arg, &size))
 594                 die("invalid size");
 595
 596         size >>= 9;
 597
 598         if (argc)
 599                 die("Too many arguments");
 600
 601         struct stat dev_stat = xfstat(dev_fd);
 602
 603         struct mntent *mount = dev_to_mount(dev);
 604         if (mount) {
 605                 if (!S_ISBLK(dev_stat.st_mode))
 606                         die("%s is mounted but isn't a block device?!", dev);
 607
 608                 struct bchfs_handle fs = bcache_fs_open(mount->mnt_dir);
 609
 610                 unsigned idx = bchu_disk_get_idx(fs, dev_stat.st_rdev);
 611
 612                 struct bch_sb *sb = bchu_read_super(fs, -1);
 613                 if (idx >= sb->nr_devices)
 614                         die("error reading superblock: dev idx >= sb->nr_devices");
 615
 616                 struct bch_member m = bch2_sb_member_get(sb, idx);
 617
 618                 u64 nbuckets = size / le16_to_cpu(m.bucket_size);
 619
 620                 printf("resizing journal on %s to %llu buckets\n", dev, nbuckets);
 621                 bchu_disk_resize_journal(fs, idx, nbuckets);
 622         } else {
 623                 printf("%s is offline - starting:\n", dev);
 624
 625                 struct bch_fs *c = bch2_fs_open(&dev, 1, bch2_opts_empty());
 626                 if (IS_ERR(c))
 627                         die("error opening %s: %s", dev, bch2_err_str(PTR_ERR(c)));
 628
 629                 struct bch_dev *ca, *resize = NULL;
 630                 unsigned i;
 631
 632                 for_each_online_member(ca, c, i) {
 633                         if (resize)
 634                                 die("confused: more than one online device?");
 635                         resize = ca;
 636                         percpu_ref_get(&resize->io_ref);
 637                 }
 638
 639                 u64 nbuckets = size / le16_to_cpu(resize->mi.bucket_size);
 640
 641                 printf("resizing journal on %s to %llu buckets\n", dev, nbuckets);
 642                 int ret = bch2_set_nr_journal_buckets(c, resize, nbuckets);
 643                 if (ret)
 644                         fprintf(stderr, "resize error: %s\n", bch2_err_str(ret));
 645
 646                 percpu_ref_put(&resize->io_ref);
 647                 bch2_fs_stop(c);
 648         }
 649         return 0;
 650 }