10 #include <sys/ioctl.h>
12 #include <sys/types.h>
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"
22 #include "libbcachefs.h"
23 #include "libbcachefs/opts.h"
24 #include "tools-util.h"
26 int device_usage(void)
28 puts("bcachefs device - manage devices within a running filesystem\n"
29 "Usage: bcachefs device <CMD> [OPTION]\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"
41 "Report bugs to <linux-bcachefs@vger.kernel.org>");
45 static void device_add_usage(void)
47 puts("bcachefs device add - add a device to an existing filesystem\n"
48 "Usage: bcachefs device add [OPTION]... filesystem device\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"
58 "Report bugs to <linux-bcachefs@vger.kernel.org>");
61 int cmd_device_add(int argc, char *argv[])
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' },
72 struct format_opts format_opts = format_opts_default();
73 struct dev_opts dev_opts = dev_opts_default();
77 while ((opt = getopt_long(argc, argv, "t:fh",
78 longopts, NULL)) != -1)
81 if (bch2_strtoull_h(optarg, &dev_opts.size))
82 die("invalid filesystem size");
85 if (bch2_strtoull_h(optarg, &dev_opts.bucket_size))
86 die("bad bucket_size %s", optarg);
89 dev_opts.discard = true;
92 dev_opts.label = strdup(optarg);
103 char *fs_path = arg_pop();
105 die("Please supply a filesystem");
107 dev_opts.path = arg_pop();
109 die("Please supply a device");
112 die("too many arguments");
114 struct bchfs_handle fs = bcache_fs_open(fs_path);
116 int ret = open_for_format(&dev_opts, force);
118 die("Error opening %s: %s", dev_opts.path, strerror(-ret));
120 struct bch_opt_strs fs_opt_strs;
121 memset(&fs_opt_strs, 0, sizeof(fs_opt_strs));
123 struct bch_opts fs_opts = bch2_parse_opts(fs_opt_strs);
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"));
130 struct bch_sb *sb = bch2_format(fs_opt_strs,
135 fsync(dev_opts.bdev->bd_buffered_fd);
136 close(dev_opts.bdev->bd_buffered_fd);
138 bchu_disk_add(fs, dev_opts.path);
142 static void device_remove_usage(void)
144 puts("bcachefs device_remove - remove a device from a filesystem\n"
146 " bcachefs device remove <device>|<devid> <path>\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>");
158 int cmd_device_remove(int argc, char *argv[])
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' },
167 struct bchfs_handle fs;
169 int opt, flags = BCH_FORCE_IF_DEGRADED, dev_idx;
171 while ((opt = getopt_long(argc, argv, "fh", longopts, NULL)) != -1)
174 flags |= BCH_FORCE_IF_DATA_LOST;
177 flags |= BCH_FORCE_IF_METADATA_LOST;
180 device_remove_usage();
184 char *dev_str = arg_pop();
186 die("Please supply a device");
189 dev_idx = strtoul(dev_str, &end, 10);
190 if (*dev_str && !*end)
193 char *fs_path = arg_pop();
195 fs = bcache_fs_open(fs_path);
198 dev_idx = bchu_dev_path_to_idx(fs, dev_str);
200 die("%s does not seem to be a member of %s",
204 fs = bchu_fs_open_by_dev(dev_str, &dev_idx);
206 die("Filesystem path required when specifying device by id");
209 bchu_disk_remove(fs, dev_idx, flags);
213 static void device_online_usage(void)
215 puts("bcachefs device online - readd a device to a running filesystem\n"
216 "Usage: bcachefs device online [OPTION]... device\n"
219 " -h, --help Display this help and exit\n"
221 "Report bugs to <linux-bcachefs@vger.kernel.org>");
224 int cmd_device_online(int argc, char *argv[])
228 while ((opt = getopt(argc, argv, "h")) != -1)
231 device_online_usage();
236 char *dev = arg_pop();
238 die("Please supply a device");
241 die("too many arguments");
244 struct bchfs_handle fs = bchu_fs_open_by_dev(dev, &dev_idx);
245 bchu_disk_online(fs, dev);
249 static void device_offline_usage(void)
251 puts("bcachefs device offline - take a device offline, without removing it\n"
252 "Usage: bcachefs device offline [OPTION]... device\n"
255 " -f, --force Force, if data redundancy will be degraded\n"
256 " -h, --help Display this help and exit\n"
258 "Report bugs to <linux-bcachefs@vger.kernel.org>");
261 int cmd_device_offline(int argc, char *argv[])
263 static const struct option longopts[] = {
264 { "force", 0, NULL, 'f' },
269 while ((opt = getopt_long(argc, argv, "fh",
270 longopts, NULL)) != -1)
273 flags |= BCH_FORCE_IF_DEGRADED;
276 device_offline_usage();
281 char *dev = arg_pop();
283 die("Please supply a device");
286 die("too many arguments");
289 struct bchfs_handle fs = bchu_fs_open_by_dev(dev, &dev_idx);
290 bchu_disk_offline(fs, dev_idx, flags);
294 static void device_evacuate_usage(void)
296 puts("bcachefs device evacuate - move data off of a given device\n"
297 "Usage: bcachefs device evacuate [OPTION]... device\n"
300 " -h, --help Display this help and exit\n"
302 "Report bugs to <linux-bcachefs@vger.kernel.org>");
305 int cmd_device_evacuate(int argc, char *argv[])
309 while ((opt = getopt(argc, argv, "h")) != -1)
312 device_evacuate_usage();
317 char *dev_path = arg_pop();
319 die("Please supply a device");
322 die("too many arguments");
325 struct bchfs_handle fs = bchu_fs_open_by_dev(dev_path, &dev_idx);
327 struct bch_ioctl_dev_usage u = bchu_dev_usage(fs, dev_idx);
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);
334 return bchu_data(fs, (struct bch_ioctl_data) {
335 .op = BCH_DATA_OP_migrate,
337 .start_pos = POS_MIN,
338 .end_btree = BTREE_ID_NR,
340 .migrate.dev = dev_idx,
344 static void device_set_state_usage(void)
346 puts("bcachefs device set-state\n"
347 "Usage: bcachefs device set-state <new-state> <device>|<devid> <path>\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"
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>");
361 int cmd_device_set_state(int argc, char *argv[])
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' },
370 struct bchfs_handle fs;
372 int opt, flags = 0, dev_idx;
373 bool offline = false;
375 while ((opt = getopt_long(argc, argv, "foh", longopts, NULL)) != -1)
378 flags |= BCH_FORCE_IF_DEGRADED;
381 flags |= BCH_FORCE_IF_DEGRADED;
382 flags |= BCH_FORCE_IF_LOST;
388 device_set_state_usage();
392 char *new_state_str = arg_pop();
394 die("Please supply a device state");
396 unsigned new_state = read_string_list_or_die(new_state_str,
397 bch2_member_states, "device state");
399 char *dev_str = arg_pop();
401 die("Please supply a device");
404 dev_idx = strtoul(dev_str, &end, 10);
405 if (*dev_str && !*end)
409 struct bch_opts opts = bch2_opts_empty();
410 struct bch_sb_handle sb = { NULL };
413 die("Cannot specify offline device by id");
415 int ret = bch2_read_super(dev_str, &opts, &sb);
417 die("error opening %s: %s", dev_str, bch2_err_str(ret));
419 struct bch_member *m = bch2_members_v2_get_mut(sb.sb, sb.sb->dev_idx);
421 SET_BCH_MEMBER_STATE(m, new_state);
423 le64_add_cpu(&sb.sb->seq, 1);
425 bch2_super_write(sb.bdev->bd_buffered_fd, sb.sb);
426 ret = fsync(sb.bdev->bd_buffered_fd);
428 fprintf(stderr, "error writing superblock: fsync error (%m)");
429 bch2_free_super(&sb);
433 char *fs_path = arg_pop();
435 fs = bcache_fs_open(fs_path);
438 dev_idx = bchu_dev_path_to_idx(fs, dev_str);
440 die("%s does not seem to be a member of %s",
444 fs = bchu_fs_open_by_dev(dev_str, &dev_idx);
446 die("Filesystem path required when specifying device by id");
449 bchu_disk_set_state(fs, dev_idx, new_state, flags);
454 static void device_resize_usage(void)
456 puts("bcachefs device resize \n"
457 "Usage: bcachefs device resize device [ size ]\n"
460 " -h, --help display this help and exit\n"
461 "Report bugs to <linux-bcachefs@vger.kernel.org>");
465 int cmd_device_resize(int argc, char *argv[])
467 static const struct option longopts[] = {
468 { "help", 0, NULL, 'h' },
474 while ((opt = getopt_long(argc, argv, "h", longopts, NULL)) != -1)
477 device_resize_usage();
481 char *dev = arg_pop();
483 die("Please supply a device to resize");
485 int dev_fd = xopen(dev, O_RDONLY);
487 char *size_arg = arg_pop();
489 size = get_size(dev_fd);
490 else if (bch2_strtoull_h(size_arg, &size))
496 die("Too many arguments");
498 struct stat dev_stat = xfstat(dev_fd);
500 struct mntent *mount = dev_to_mount(dev);
502 if (!S_ISBLK(dev_stat.st_mode))
503 die("%s is mounted but isn't a block device?!", dev);
505 printf("Doing online resize of %s\n", dev);
507 struct bchfs_handle fs = bcache_fs_open(mount->mnt_dir);
509 unsigned idx = bchu_disk_get_idx(fs, dev_stat.st_rdev);
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");
515 struct bch_member m = bch2_sb_member_get(sb, idx);
517 u64 nbuckets = size / le16_to_cpu(m.bucket_size);
519 if (nbuckets < le64_to_cpu(m.nbuckets))
520 die("Shrinking not supported yet");
522 printf("resizing %s to %llu buckets\n", dev, nbuckets);
523 bchu_disk_resize(fs, idx, nbuckets);
525 printf("Doing offline resize of %s\n", dev);
527 struct bch_fs *c = bch2_fs_open(&dev, 1, bch2_opts_empty());
529 die("error opening %s: %s", dev, bch2_err_str(PTR_ERR(c)));
531 struct bch_dev *ca, *resize = NULL;
534 for_each_online_member(ca, c, i) {
536 die("confused: more than one online device?");
538 percpu_ref_get(&resize->io_ref);
541 u64 nbuckets = size / le16_to_cpu(resize->mi.bucket_size);
543 if (nbuckets < le64_to_cpu(resize->mi.nbuckets))
544 die("Shrinking not supported yet");
546 printf("resizing %s to %llu buckets\n", dev, nbuckets);
547 int ret = bch2_dev_resize(c, resize, nbuckets);
549 fprintf(stderr, "resize error: %s\n", bch2_err_str(ret));
551 percpu_ref_put(&resize->io_ref);
557 static void device_resize_journal_usage(void)
559 puts("bcachefs device resize-journal \n"
560 "Usage: bcachefs device resize-journal device size\n"
563 " -h, --help display this help and exit\n"
564 "Report bugs to <linux-bcachefs@vger.kernel.org>");
568 int cmd_device_resize_journal(int argc, char *argv[])
570 static const struct option longopts[] = {
571 { "help", 0, NULL, 'h' },
577 while ((opt = getopt_long(argc, argv, "h", longopts, NULL)) != -1)
580 device_resize_journal_usage();
584 char *dev = arg_pop();
586 die("Please supply a device");
588 int dev_fd = xopen(dev, O_RDONLY);
590 char *size_arg = arg_pop();
592 die("Please supply a journal size");
593 else if (bch2_strtoull_h(size_arg, &size))
599 die("Too many arguments");
601 struct stat dev_stat = xfstat(dev_fd);
603 struct mntent *mount = dev_to_mount(dev);
605 if (!S_ISBLK(dev_stat.st_mode))
606 die("%s is mounted but isn't a block device?!", dev);
608 struct bchfs_handle fs = bcache_fs_open(mount->mnt_dir);
610 unsigned idx = bchu_disk_get_idx(fs, dev_stat.st_rdev);
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");
616 struct bch_member m = bch2_sb_member_get(sb, idx);
618 u64 nbuckets = size / le16_to_cpu(m.bucket_size);
620 printf("resizing journal on %s to %llu buckets\n", dev, nbuckets);
621 bchu_disk_resize_journal(fs, idx, nbuckets);
623 printf("%s is offline - starting:\n", dev);
625 struct bch_fs *c = bch2_fs_open(&dev, 1, bch2_opts_empty());
627 die("error opening %s: %s", dev, bch2_err_str(PTR_ERR(c)));
629 struct bch_dev *ca, *resize = NULL;
632 for_each_online_member(ca, c, i) {
634 die("confused: more than one online device?");
636 percpu_ref_get(&resize->io_ref);
639 u64 nbuckets = size / le16_to_cpu(resize->mi.bucket_size);
641 printf("resizing journal on %s to %llu buckets\n", dev, nbuckets);
642 int ret = bch2_set_nr_journal_buckets(c, resize, nbuckets);
644 fprintf(stderr, "resize error: %s\n", bch2_err_str(ret));
646 percpu_ref_put(&resize->io_ref);