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