1 #ifndef NO_BCACHEFS_CHARDEV
4 #include "bcachefs_ioctl.h"
11 #include <linux/anon_inodes.h>
12 #include <linux/cdev.h>
13 #include <linux/device.h>
14 #include <linux/file.h>
16 #include <linux/ioctl.h>
17 #include <linux/kthread.h>
18 #include <linux/major.h>
19 #include <linux/sched/task.h>
20 #include <linux/slab.h>
21 #include <linux/uaccess.h>
23 /* returns with ref on ca->ref */
24 static struct bch_dev *bch2_device_lookup(struct bch_fs *c, u64 dev,
29 if (flags & BCH_BY_INDEX) {
30 if (dev >= c->sb.nr_devices)
31 return ERR_PTR(-EINVAL);
34 ca = rcu_dereference(c->devs[dev]);
36 percpu_ref_get(&ca->ref);
40 return ERR_PTR(-EINVAL);
44 path = strndup_user((const char __user *)
45 (unsigned long) dev, PATH_MAX);
47 return ERR_CAST(path);
49 ca = bch2_dev_lookup(c, path);
57 static long bch2_ioctl_assemble(struct bch_ioctl_assemble __user *user_arg)
59 struct bch_ioctl_assemble arg;
61 u64 *user_devs = NULL;
66 if (copy_from_user(&arg, user_arg, sizeof(arg)))
69 if (arg.flags || arg.pad)
72 user_devs = kmalloc_array(arg.nr_devs, sizeof(u64), GFP_KERNEL);
76 devs = kcalloc(arg.nr_devs, sizeof(char *), GFP_KERNEL);
78 if (copy_from_user(user_devs, user_arg->devs,
79 sizeof(u64) * arg.nr_devs))
82 for (i = 0; i < arg.nr_devs; i++) {
83 devs[i] = strndup_user((const char __user *)(unsigned long)
92 c = bch2_fs_open(devs, arg.nr_devs, bch2_opts_empty());
93 ret = PTR_ERR_OR_ZERO(c);
98 for (i = 0; i < arg.nr_devs; i++)
104 static long bch2_ioctl_incremental(struct bch_ioctl_incremental __user *user_arg)
106 struct bch_ioctl_incremental arg;
110 if (copy_from_user(&arg, user_arg, sizeof(arg)))
113 if (arg.flags || arg.pad)
116 path = strndup_user((const char __user *)(unsigned long) arg.dev, PATH_MAX);
120 err = bch2_fs_open_incremental(path);
124 pr_err("Could not register bcachefs devices: %s", err);
132 static long bch2_global_ioctl(unsigned cmd, void __user *arg)
136 case BCH_IOCTL_ASSEMBLE:
137 return bch2_ioctl_assemble(arg);
138 case BCH_IOCTL_INCREMENTAL:
139 return bch2_ioctl_incremental(arg);
146 static long bch2_ioctl_query_uuid(struct bch_fs *c,
147 struct bch_ioctl_query_uuid __user *user_arg)
149 return copy_to_user(&user_arg->uuid,
151 sizeof(c->sb.user_uuid));
155 static long bch2_ioctl_start(struct bch_fs *c, struct bch_ioctl_start arg)
157 if (arg.flags || arg.pad)
160 return bch2_fs_start(c) ? -EIO : 0;
163 static long bch2_ioctl_stop(struct bch_fs *c)
170 static long bch2_ioctl_disk_add(struct bch_fs *c, struct bch_ioctl_disk arg)
175 if (arg.flags || arg.pad)
178 path = strndup_user((const char __user *)(unsigned long) arg.dev, PATH_MAX);
182 ret = bch2_dev_add(c, path);
188 static long bch2_ioctl_disk_remove(struct bch_fs *c, struct bch_ioctl_disk arg)
192 if ((arg.flags & ~(BCH_FORCE_IF_DATA_LOST|
193 BCH_FORCE_IF_METADATA_LOST|
194 BCH_FORCE_IF_DEGRADED|
199 ca = bch2_device_lookup(c, arg.dev, arg.flags);
203 return bch2_dev_remove(c, ca, arg.flags);
206 static long bch2_ioctl_disk_online(struct bch_fs *c, struct bch_ioctl_disk arg)
211 if (arg.flags || arg.pad)
214 path = strndup_user((const char __user *)(unsigned long) arg.dev, PATH_MAX);
218 ret = bch2_dev_online(c, path);
223 static long bch2_ioctl_disk_offline(struct bch_fs *c, struct bch_ioctl_disk arg)
228 if ((arg.flags & ~(BCH_FORCE_IF_DATA_LOST|
229 BCH_FORCE_IF_METADATA_LOST|
230 BCH_FORCE_IF_DEGRADED|
235 ca = bch2_device_lookup(c, arg.dev, arg.flags);
239 ret = bch2_dev_offline(c, ca, arg.flags);
240 percpu_ref_put(&ca->ref);
244 static long bch2_ioctl_disk_set_state(struct bch_fs *c,
245 struct bch_ioctl_disk_set_state arg)
250 if ((arg.flags & ~(BCH_FORCE_IF_DATA_LOST|
251 BCH_FORCE_IF_METADATA_LOST|
252 BCH_FORCE_IF_DEGRADED|
254 arg.pad[0] || arg.pad[1] || arg.pad[2])
257 ca = bch2_device_lookup(c, arg.dev, arg.flags);
261 ret = bch2_dev_set_state(c, ca, arg.new_state, arg.flags);
263 percpu_ref_put(&ca->ref);
267 struct bch_data_ctx {
269 struct bch_ioctl_data arg;
270 struct bch_move_stats stats;
274 struct task_struct *thread;
277 static int bch2_data_thread(void *arg)
279 struct bch_data_ctx *ctx = arg;
281 ctx->ret = bch2_data_job(ctx->c, &ctx->stats, ctx->arg);
283 ctx->stats.data_type = U8_MAX;
287 static int bch2_data_job_release(struct inode *inode, struct file *file)
289 struct bch_data_ctx *ctx = file->private_data;
291 kthread_stop(ctx->thread);
292 put_task_struct(ctx->thread);
297 static ssize_t bch2_data_job_read(struct file *file, char __user *buf,
298 size_t len, loff_t *ppos)
300 struct bch_data_ctx *ctx = file->private_data;
301 struct bch_fs *c = ctx->c;
302 struct bch_ioctl_data_event e = {
303 .type = BCH_DATA_EVENT_PROGRESS,
304 .p.data_type = ctx->stats.data_type,
305 .p.btree_id = ctx->stats.iter.btree_id,
306 .p.pos = ctx->stats.iter.pos,
307 .p.sectors_done = atomic64_read(&ctx->stats.sectors_seen),
308 .p.sectors_total = bch2_fs_usage_read_short(c).used,
314 return copy_to_user(buf, &e, sizeof(e)) ?: sizeof(e);
317 static const struct file_operations bcachefs_data_ops = {
318 .release = bch2_data_job_release,
319 .read = bch2_data_job_read,
323 static long bch2_ioctl_data(struct bch_fs *c,
324 struct bch_ioctl_data arg)
326 struct bch_data_ctx *ctx = NULL;
327 struct file *file = NULL;
328 unsigned flags = O_RDONLY|O_CLOEXEC|O_NONBLOCK;
331 if (arg.op >= BCH_DATA_OP_NR || arg.flags)
334 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
341 ctx->thread = kthread_create(bch2_data_thread, ctx, "[bcachefs]");
342 if (IS_ERR(ctx->thread)) {
343 ret = PTR_ERR(ctx->thread);
347 ret = get_unused_fd_flags(flags);
352 file = anon_inode_getfile("[bcachefs]", &bcachefs_data_ops, ctx, flags);
358 fd_install(fd, file);
360 get_task_struct(ctx->thread);
361 wake_up_process(ctx->thread);
367 if (!IS_ERR_OR_NULL(ctx->thread))
368 kthread_stop(ctx->thread);
373 static long bch2_ioctl_usage(struct bch_fs *c,
374 struct bch_ioctl_usage __user *user_arg)
376 struct bch_ioctl_usage arg;
381 if (!test_bit(BCH_FS_STARTED, &c->flags))
384 if (copy_from_user(&arg, user_arg, sizeof(arg)))
387 for (i = 0; i < arg.nr_devices; i++) {
388 struct bch_ioctl_dev_usage dst = { .alive = 0 };
390 ret = copy_to_user(&user_arg->devs[i], &dst, sizeof(dst));
396 struct bch_fs_usage src = bch2_fs_usage_read(c);
397 struct bch_ioctl_fs_usage dst = {
398 .capacity = c->capacity,
399 .used = bch2_fs_sectors_used(c, src),
400 .online_reserved = src.s.online_reserved,
403 for (i = 0; i < BCH_REPLICAS_MAX; i++) {
404 dst.persistent_reserved[i] =
405 src.replicas[i].persistent_reserved;
407 for (j = 0; j < BCH_DATA_NR; j++)
408 dst.sectors[j][i] = src.replicas[i].data[j];
411 ret = copy_to_user(&user_arg->fs, &dst, sizeof(dst));
416 for_each_member_device(ca, c, i) {
417 struct bch_dev_usage src = bch2_dev_usage_read(c, ca);
418 struct bch_ioctl_dev_usage dst = {
420 .state = ca->mi.state,
421 .bucket_size = ca->mi.bucket_size,
422 .nr_buckets = ca->mi.nbuckets - ca->mi.first_bucket,
425 if (ca->dev_idx >= arg.nr_devices) {
426 percpu_ref_put(&ca->ref);
430 if (percpu_ref_tryget(&ca->io_ref)) {
431 dst.dev = huge_encode_dev(ca->disk_sb.bdev->bd_dev);
432 percpu_ref_put(&ca->io_ref);
435 for (j = 0; j < BCH_DATA_NR; j++) {
436 dst.buckets[j] = src.buckets[j];
437 dst.sectors[j] = src.sectors[j];
440 ret = copy_to_user(&user_arg->devs[i], &dst, sizeof(dst));
448 static long bch2_ioctl_read_super(struct bch_fs *c,
449 struct bch_ioctl_read_super arg)
451 struct bch_dev *ca = NULL;
455 if ((arg.flags & ~(BCH_BY_INDEX|BCH_READ_DEV)) ||
459 mutex_lock(&c->sb_lock);
461 if (arg.flags & BCH_READ_DEV) {
462 ca = bch2_device_lookup(c, arg.dev, arg.flags);
474 if (vstruct_bytes(sb) > arg.size) {
479 ret = copy_to_user((void __user *)(unsigned long)arg.sb,
480 sb, vstruct_bytes(sb));
483 percpu_ref_put(&ca->ref);
484 mutex_unlock(&c->sb_lock);
488 static long bch2_ioctl_disk_get_idx(struct bch_fs *c,
489 struct bch_ioctl_disk_get_idx arg)
491 dev_t dev = huge_decode_dev(arg.dev);
495 for_each_online_member(ca, c, i)
496 if (ca->disk_sb.bdev->bd_dev == dev) {
497 percpu_ref_put(&ca->io_ref);
504 static long bch2_ioctl_disk_resize(struct bch_fs *c,
505 struct bch_ioctl_disk_resize arg)
510 if ((arg.flags & ~BCH_BY_INDEX) ||
514 ca = bch2_device_lookup(c, arg.dev, arg.flags);
518 ret = bch2_dev_resize(c, ca, arg.nbuckets);
520 percpu_ref_put(&ca->ref);
524 #define BCH_IOCTL(_name, _argtype) \
528 if (copy_from_user(&i, arg, sizeof(i))) \
530 return bch2_ioctl_##_name(c, i); \
533 long bch2_fs_ioctl(struct bch_fs *c, unsigned cmd, void __user *arg)
535 /* ioctls that don't require admin cap: */
537 case BCH_IOCTL_QUERY_UUID:
538 return bch2_ioctl_query_uuid(c, arg);
539 case BCH_IOCTL_USAGE:
540 return bch2_ioctl_usage(c, arg);
543 if (!capable(CAP_SYS_ADMIN))
548 case BCH_IOCTL_START:
549 BCH_IOCTL(start, struct bch_ioctl_start);
551 return bch2_ioctl_stop(c);
553 case BCH_IOCTL_READ_SUPER:
554 BCH_IOCTL(read_super, struct bch_ioctl_read_super);
555 case BCH_IOCTL_DISK_GET_IDX:
556 BCH_IOCTL(disk_get_idx, struct bch_ioctl_disk_get_idx);
559 if (!test_bit(BCH_FS_STARTED, &c->flags))
562 /* ioctls that do require admin cap: */
564 case BCH_IOCTL_DISK_ADD:
565 BCH_IOCTL(disk_add, struct bch_ioctl_disk);
566 case BCH_IOCTL_DISK_REMOVE:
567 BCH_IOCTL(disk_remove, struct bch_ioctl_disk);
568 case BCH_IOCTL_DISK_ONLINE:
569 BCH_IOCTL(disk_online, struct bch_ioctl_disk);
570 case BCH_IOCTL_DISK_OFFLINE:
571 BCH_IOCTL(disk_offline, struct bch_ioctl_disk);
572 case BCH_IOCTL_DISK_SET_STATE:
573 BCH_IOCTL(disk_set_state, struct bch_ioctl_disk_set_state);
575 BCH_IOCTL(data, struct bch_ioctl_data);
576 case BCH_IOCTL_DISK_RESIZE:
577 BCH_IOCTL(disk_resize, struct bch_ioctl_disk_resize);
584 static DEFINE_IDR(bch_chardev_minor);
586 static long bch2_chardev_ioctl(struct file *filp, unsigned cmd, unsigned long v)
588 unsigned minor = iminor(file_inode(filp));
589 struct bch_fs *c = minor < U8_MAX ? idr_find(&bch_chardev_minor, minor) : NULL;
590 void __user *arg = (void __user *) v;
593 ? bch2_fs_ioctl(c, cmd, arg)
594 : bch2_global_ioctl(cmd, arg);
597 static const struct file_operations bch_chardev_fops = {
598 .owner = THIS_MODULE,
599 .unlocked_ioctl = bch2_chardev_ioctl,
600 .open = nonseekable_open,
603 static int bch_chardev_major;
604 static struct class *bch_chardev_class;
605 static struct device *bch_chardev;
607 void bch2_fs_chardev_exit(struct bch_fs *c)
609 if (!IS_ERR_OR_NULL(c->chardev))
610 device_unregister(c->chardev);
612 idr_remove(&bch_chardev_minor, c->minor);
615 int bch2_fs_chardev_init(struct bch_fs *c)
617 c->minor = idr_alloc(&bch_chardev_minor, c, 0, 0, GFP_KERNEL);
621 c->chardev = device_create(bch_chardev_class, NULL,
622 MKDEV(bch_chardev_major, c->minor), c,
623 "bcachefs%u-ctl", c->minor);
624 if (IS_ERR(c->chardev))
625 return PTR_ERR(c->chardev);
630 void bch2_chardev_exit(void)
632 if (!IS_ERR_OR_NULL(bch_chardev_class))
633 device_destroy(bch_chardev_class,
634 MKDEV(bch_chardev_major, U8_MAX));
635 if (!IS_ERR_OR_NULL(bch_chardev_class))
636 class_destroy(bch_chardev_class);
637 if (bch_chardev_major > 0)
638 unregister_chrdev(bch_chardev_major, "bcachefs");
641 int __init bch2_chardev_init(void)
643 bch_chardev_major = register_chrdev(0, "bcachefs-ctl", &bch_chardev_fops);
644 if (bch_chardev_major < 0)
645 return bch_chardev_major;
647 bch_chardev_class = class_create(THIS_MODULE, "bcachefs");
648 if (IS_ERR(bch_chardev_class))
649 return PTR_ERR(bch_chardev_class);
651 bch_chardev = device_create(bch_chardev_class, NULL,
652 MKDEV(bch_chardev_major, U8_MAX),
653 NULL, "bcachefs-ctl");
654 if (IS_ERR(bch_chardev))
655 return PTR_ERR(bch_chardev);
660 #endif /* NO_BCACHEFS_CHARDEV */