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

   1 // SPDX-License-Identifier: GPL-2.0
   2 #ifndef NO_BCACHEFS_CHARDEV
   3
   4 #include "bcachefs.h"
   5 #include "bcachefs_ioctl.h"
   6 #include "buckets.h"
   7 #include "chardev.h"
   8 #include "journal.h"
   9 #include "move.h"
  10 #include "replicas.h"
  11 #include "super.h"
  12 #include "super-io.h"
  13
  14 #include <linux/anon_inodes.h>
  15 #include <linux/cdev.h>
  16 #include <linux/device.h>
  17 #include <linux/file.h>
  18 #include <linux/fs.h>
  19 #include <linux/ioctl.h>
  20 #include <linux/kthread.h>
  21 #include <linux/major.h>
  22 #include <linux/sched/task.h>
  23 #include <linux/slab.h>
  24 #include <linux/uaccess.h>
  25
  26 __must_check
  27 static int copy_to_user_errcode(void __user *to, const void *from, unsigned long n)
  28 {
  29         return copy_to_user(to, from, n) ? -EFAULT : 0;
  30 }
  31
  32 /* returns with ref on ca->ref */
  33 static struct bch_dev *bch2_device_lookup(struct bch_fs *c, u64 dev,
  34                                           unsigned flags)
  35 {
  36         struct bch_dev *ca;
  37
  38         if (flags & BCH_BY_INDEX) {
  39                 if (dev >= c->sb.nr_devices)
  40                         return ERR_PTR(-EINVAL);
  41
  42                 rcu_read_lock();
  43                 ca = rcu_dereference(c->devs[dev]);
  44                 if (ca)
  45                         percpu_ref_get(&ca->ref);
  46                 rcu_read_unlock();
  47
  48                 if (!ca)
  49                         return ERR_PTR(-EINVAL);
  50         } else {
  51                 char *path;
  52
  53                 path = strndup_user((const char __user *)
  54                                     (unsigned long) dev, PATH_MAX);
  55                 if (IS_ERR(path))
  56                         return ERR_CAST(path);
  57
  58                 ca = bch2_dev_lookup(c, path);
  59                 kfree(path);
  60         }
  61
  62         return ca;
  63 }
  64
  65 #if 0
  66 static long bch2_ioctl_assemble(struct bch_ioctl_assemble __user *user_arg)
  67 {
  68         struct bch_ioctl_assemble arg;
  69         struct bch_fs *c;
  70         u64 *user_devs = NULL;
  71         char **devs = NULL;
  72         unsigned i;
  73         int ret = -EFAULT;
  74
  75         if (copy_from_user(&arg, user_arg, sizeof(arg)))
  76                 return -EFAULT;
  77
  78         if (arg.flags || arg.pad)
  79                 return -EINVAL;
  80
  81         user_devs = kmalloc_array(arg.nr_devs, sizeof(u64), GFP_KERNEL);
  82         if (!user_devs)
  83                 return -ENOMEM;
  84
  85         devs = kcalloc(arg.nr_devs, sizeof(char *), GFP_KERNEL);
  86
  87         if (copy_from_user(user_devs, user_arg->devs,
  88                            sizeof(u64) * arg.nr_devs))
  89                 goto err;
  90
  91         for (i = 0; i < arg.nr_devs; i++) {
  92                 devs[i] = strndup_user((const char __user *)(unsigned long)
  93                                        user_devs[i],
  94                                        PATH_MAX);
  95                 ret= PTR_ERR_OR_ZERO(devs[i]);
  96                 if (ret)
  97                         goto err;
  98         }
  99
 100         c = bch2_fs_open(devs, arg.nr_devs, bch2_opts_empty());
 101         ret = PTR_ERR_OR_ZERO(c);
 102         if (!ret)
 103                 closure_put(&c->cl);
 104 err:
 105         if (devs)
 106                 for (i = 0; i < arg.nr_devs; i++)
 107                         kfree(devs[i]);
 108         kfree(devs);
 109         return ret;
 110 }
 111
 112 static long bch2_ioctl_incremental(struct bch_ioctl_incremental __user *user_arg)
 113 {
 114         struct bch_ioctl_incremental arg;
 115         const char *err;
 116         char *path;
 117
 118         if (copy_from_user(&arg, user_arg, sizeof(arg)))
 119                 return -EFAULT;
 120
 121         if (arg.flags || arg.pad)
 122                 return -EINVAL;
 123
 124         path = strndup_user((const char __user *)(unsigned long) arg.dev, PATH_MAX);
 125         ret = PTR_ERR_OR_ZERO(path);
 126         if (ret)
 127                 return ret;
 128
 129         err = bch2_fs_open_incremental(path);
 130         kfree(path);
 131
 132         if (err) {
 133                 pr_err("Could not register bcachefs devices: %s", err);
 134                 return -EINVAL;
 135         }
 136
 137         return 0;
 138 }
 139 #endif
 140
 141 static long bch2_global_ioctl(unsigned cmd, void __user *arg)
 142 {
 143         switch (cmd) {
 144 #if 0
 145         case BCH_IOCTL_ASSEMBLE:
 146                 return bch2_ioctl_assemble(arg);
 147         case BCH_IOCTL_INCREMENTAL:
 148                 return bch2_ioctl_incremental(arg);
 149 #endif
 150         default:
 151                 return -ENOTTY;
 152         }
 153 }
 154
 155 static long bch2_ioctl_query_uuid(struct bch_fs *c,
 156                         struct bch_ioctl_query_uuid __user *user_arg)
 157 {
 158         return copy_to_user_errcode(&user_arg->uuid, &c->sb.user_uuid,
 159                                     sizeof(c->sb.user_uuid));
 160 }
 161
 162 #if 0
 163 static long bch2_ioctl_start(struct bch_fs *c, struct bch_ioctl_start arg)
 164 {
 165         if (!capable(CAP_SYS_ADMIN))
 166                 return -EPERM;
 167
 168         if (arg.flags || arg.pad)
 169                 return -EINVAL;
 170
 171         return bch2_fs_start(c);
 172 }
 173
 174 static long bch2_ioctl_stop(struct bch_fs *c)
 175 {
 176         if (!capable(CAP_SYS_ADMIN))
 177                 return -EPERM;
 178
 179         bch2_fs_stop(c);
 180         return 0;
 181 }
 182 #endif
 183
 184 static long bch2_ioctl_disk_add(struct bch_fs *c, struct bch_ioctl_disk arg)
 185 {
 186         char *path;
 187         int ret;
 188
 189         if (!capable(CAP_SYS_ADMIN))
 190                 return -EPERM;
 191
 192         if (arg.flags || arg.pad)
 193                 return -EINVAL;
 194
 195         path = strndup_user((const char __user *)(unsigned long) arg.dev, PATH_MAX);
 196         ret = PTR_ERR_OR_ZERO(path);
 197         if (ret)
 198                 return ret;
 199
 200         ret = bch2_dev_add(c, path);
 201         kfree(path);
 202
 203         return ret;
 204 }
 205
 206 static long bch2_ioctl_disk_remove(struct bch_fs *c, struct bch_ioctl_disk arg)
 207 {
 208         struct bch_dev *ca;
 209
 210         if (!capable(CAP_SYS_ADMIN))
 211                 return -EPERM;
 212
 213         if ((arg.flags & ~(BCH_FORCE_IF_DATA_LOST|
 214                            BCH_FORCE_IF_METADATA_LOST|
 215                            BCH_FORCE_IF_DEGRADED|
 216                            BCH_BY_INDEX)) ||
 217             arg.pad)
 218                 return -EINVAL;
 219
 220         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 221         if (IS_ERR(ca))
 222                 return PTR_ERR(ca);
 223
 224         return bch2_dev_remove(c, ca, arg.flags);
 225 }
 226
 227 static long bch2_ioctl_disk_online(struct bch_fs *c, struct bch_ioctl_disk arg)
 228 {
 229         char *path;
 230         int ret;
 231
 232         if (!capable(CAP_SYS_ADMIN))
 233                 return -EPERM;
 234
 235         if (arg.flags || arg.pad)
 236                 return -EINVAL;
 237
 238         path = strndup_user((const char __user *)(unsigned long) arg.dev, PATH_MAX);
 239         ret = PTR_ERR_OR_ZERO(path);
 240         if (ret)
 241                 return ret;
 242
 243         ret = bch2_dev_online(c, path);
 244         kfree(path);
 245         return ret;
 246 }
 247
 248 static long bch2_ioctl_disk_offline(struct bch_fs *c, struct bch_ioctl_disk arg)
 249 {
 250         struct bch_dev *ca;
 251         int ret;
 252
 253         if (!capable(CAP_SYS_ADMIN))
 254                 return -EPERM;
 255
 256         if ((arg.flags & ~(BCH_FORCE_IF_DATA_LOST|
 257                            BCH_FORCE_IF_METADATA_LOST|
 258                            BCH_FORCE_IF_DEGRADED|
 259                            BCH_BY_INDEX)) ||
 260             arg.pad)
 261                 return -EINVAL;
 262
 263         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 264         if (IS_ERR(ca))
 265                 return PTR_ERR(ca);
 266
 267         ret = bch2_dev_offline(c, ca, arg.flags);
 268         percpu_ref_put(&ca->ref);
 269         return ret;
 270 }
 271
 272 static long bch2_ioctl_disk_set_state(struct bch_fs *c,
 273                         struct bch_ioctl_disk_set_state arg)
 274 {
 275         struct bch_dev *ca;
 276         int ret;
 277
 278         if (!capable(CAP_SYS_ADMIN))
 279                 return -EPERM;
 280
 281         if ((arg.flags & ~(BCH_FORCE_IF_DATA_LOST|
 282                            BCH_FORCE_IF_METADATA_LOST|
 283                            BCH_FORCE_IF_DEGRADED|
 284                            BCH_BY_INDEX)) ||
 285             arg.pad[0] || arg.pad[1] || arg.pad[2] ||
 286             arg.new_state >= BCH_MEMBER_STATE_NR)
 287                 return -EINVAL;
 288
 289         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 290         if (IS_ERR(ca))
 291                 return PTR_ERR(ca);
 292
 293         ret = bch2_dev_set_state(c, ca, arg.new_state, arg.flags);
 294         if (ret)
 295                 bch_err(c, "Error setting device state: %s", bch2_err_str(ret));
 296
 297         percpu_ref_put(&ca->ref);
 298         return ret;
 299 }
 300
 301 struct bch_data_ctx {
 302         struct bch_fs                   *c;
 303         struct bch_ioctl_data           arg;
 304         struct bch_move_stats           stats;
 305
 306         int                             ret;
 307
 308         struct task_struct              *thread;
 309 };
 310
 311 static int bch2_data_thread(void *arg)
 312 {
 313         struct bch_data_ctx *ctx = arg;
 314
 315         ctx->ret = bch2_data_job(ctx->c, &ctx->stats, ctx->arg);
 316
 317         ctx->stats.data_type = U8_MAX;
 318         return 0;
 319 }
 320
 321 static int bch2_data_job_release(struct inode *inode, struct file *file)
 322 {
 323         struct bch_data_ctx *ctx = file->private_data;
 324
 325         kthread_stop(ctx->thread);
 326         put_task_struct(ctx->thread);
 327         kfree(ctx);
 328         return 0;
 329 }
 330
 331 static ssize_t bch2_data_job_read(struct file *file, char __user *buf,
 332                                   size_t len, loff_t *ppos)
 333 {
 334         struct bch_data_ctx *ctx = file->private_data;
 335         struct bch_fs *c = ctx->c;
 336         struct bch_ioctl_data_event e = {
 337                 .type                   = BCH_DATA_EVENT_PROGRESS,
 338                 .p.data_type            = ctx->stats.data_type,
 339                 .p.btree_id             = ctx->stats.pos.btree,
 340                 .p.pos                  = ctx->stats.pos.pos,
 341                 .p.sectors_done         = atomic64_read(&ctx->stats.sectors_seen),
 342                 .p.sectors_total        = bch2_fs_usage_read_short(c).used,
 343         };
 344
 345         if (len < sizeof(e))
 346                 return -EINVAL;
 347
 348         return copy_to_user_errcode(buf, &e, sizeof(e)) ?: sizeof(e);
 349 }
 350
 351 static const struct file_operations bcachefs_data_ops = {
 352         .release        = bch2_data_job_release,
 353         .read           = bch2_data_job_read,
 354         .llseek         = no_llseek,
 355 };
 356
 357 static long bch2_ioctl_data(struct bch_fs *c,
 358                             struct bch_ioctl_data arg)
 359 {
 360         struct bch_data_ctx *ctx = NULL;
 361         struct file *file = NULL;
 362         unsigned flags = O_RDONLY|O_CLOEXEC|O_NONBLOCK;
 363         int ret, fd = -1;
 364
 365         if (!capable(CAP_SYS_ADMIN))
 366                 return -EPERM;
 367
 368         if (arg.op >= BCH_DATA_OP_NR || arg.flags)
 369                 return -EINVAL;
 370
 371         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 372         if (!ctx)
 373                 return -ENOMEM;
 374
 375         ctx->c = c;
 376         ctx->arg = arg;
 377
 378         ctx->thread = kthread_create(bch2_data_thread, ctx,
 379                                      "bch-data/%s", c->name);
 380         if (IS_ERR(ctx->thread)) {
 381                 ret = PTR_ERR(ctx->thread);
 382                 goto err;
 383         }
 384
 385         ret = get_unused_fd_flags(flags);
 386         if (ret < 0)
 387                 goto err;
 388         fd = ret;
 389
 390         file = anon_inode_getfile("[bcachefs]", &bcachefs_data_ops, ctx, flags);
 391         if (IS_ERR(file)) {
 392                 ret = PTR_ERR(file);
 393                 goto err;
 394         }
 395
 396         fd_install(fd, file);
 397
 398         get_task_struct(ctx->thread);
 399         wake_up_process(ctx->thread);
 400
 401         return fd;
 402 err:
 403         if (fd >= 0)
 404                 put_unused_fd(fd);
 405         if (!IS_ERR_OR_NULL(ctx->thread))
 406                 kthread_stop(ctx->thread);
 407         kfree(ctx);
 408         return ret;
 409 }
 410
 411 static long bch2_ioctl_fs_usage(struct bch_fs *c,
 412                                 struct bch_ioctl_fs_usage __user *user_arg)
 413 {
 414         struct bch_ioctl_fs_usage *arg = NULL;
 415         struct bch_replicas_usage *dst_e, *dst_end;
 416         struct bch_fs_usage_online *src;
 417         u32 replica_entries_bytes;
 418         unsigned i;
 419         int ret = 0;
 420
 421         if (!test_bit(BCH_FS_STARTED, &c->flags))
 422                 return -EINVAL;
 423
 424         if (get_user(replica_entries_bytes, &user_arg->replica_entries_bytes))
 425                 return -EFAULT;
 426
 427         arg = kzalloc(size_add(sizeof(*arg), replica_entries_bytes), GFP_KERNEL);
 428         if (!arg)
 429                 return -ENOMEM;
 430
 431         src = bch2_fs_usage_read(c);
 432         if (!src) {
 433                 ret = -ENOMEM;
 434                 goto err;
 435         }
 436
 437         arg->capacity           = c->capacity;
 438         arg->used               = bch2_fs_sectors_used(c, src);
 439         arg->online_reserved    = src->online_reserved;
 440
 441         for (i = 0; i < BCH_REPLICAS_MAX; i++)
 442                 arg->persistent_reserved[i] = src->u.persistent_reserved[i];
 443
 444         dst_e   = arg->replicas;
 445         dst_end = (void *) arg->replicas + replica_entries_bytes;
 446
 447         for (i = 0; i < c->replicas.nr; i++) {
 448                 struct bch_replicas_entry_v1 *src_e =
 449                         cpu_replicas_entry(&c->replicas, i);
 450
 451                 /* check that we have enough space for one replicas entry */
 452                 if (dst_e + 1 > dst_end) {
 453                         ret = -ERANGE;
 454                         break;
 455                 }
 456
 457                 dst_e->sectors          = src->u.replicas[i];
 458                 dst_e->r                = *src_e;
 459
 460                 /* recheck after setting nr_devs: */
 461                 if (replicas_usage_next(dst_e) > dst_end) {
 462                         ret = -ERANGE;
 463                         break;
 464                 }
 465
 466                 memcpy(dst_e->r.devs, src_e->devs, src_e->nr_devs);
 467
 468                 dst_e = replicas_usage_next(dst_e);
 469         }
 470
 471         arg->replica_entries_bytes = (void *) dst_e - (void *) arg->replicas;
 472
 473         percpu_up_read(&c->mark_lock);
 474         kfree(src);
 475
 476         if (ret)
 477                 goto err;
 478
 479         ret = copy_to_user_errcode(user_arg, arg,
 480                         sizeof(*arg) + arg->replica_entries_bytes);
 481 err:
 482         kfree(arg);
 483         return ret;
 484 }
 485
 486 /* obsolete, didn't allow for new data types: */
 487 static long bch2_ioctl_dev_usage(struct bch_fs *c,
 488                                  struct bch_ioctl_dev_usage __user *user_arg)
 489 {
 490         struct bch_ioctl_dev_usage arg;
 491         struct bch_dev_usage src;
 492         struct bch_dev *ca;
 493         unsigned i;
 494
 495         if (!test_bit(BCH_FS_STARTED, &c->flags))
 496                 return -EINVAL;
 497
 498         if (copy_from_user(&arg, user_arg, sizeof(arg)))
 499                 return -EFAULT;
 500
 501         if ((arg.flags & ~BCH_BY_INDEX) ||
 502             arg.pad[0] ||
 503             arg.pad[1] ||
 504             arg.pad[2])
 505                 return -EINVAL;
 506
 507         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 508         if (IS_ERR(ca))
 509                 return PTR_ERR(ca);
 510
 511         src = bch2_dev_usage_read(ca);
 512
 513         arg.state               = ca->mi.state;
 514         arg.bucket_size         = ca->mi.bucket_size;
 515         arg.nr_buckets          = ca->mi.nbuckets - ca->mi.first_bucket;
 516
 517         for (i = 0; i < BCH_DATA_NR; i++) {
 518                 arg.d[i].buckets        = src.d[i].buckets;
 519                 arg.d[i].sectors        = src.d[i].sectors;
 520                 arg.d[i].fragmented     = src.d[i].fragmented;
 521         }
 522
 523         percpu_ref_put(&ca->ref);
 524
 525         return copy_to_user_errcode(user_arg, &arg, sizeof(arg));
 526 }
 527
 528 static long bch2_ioctl_dev_usage_v2(struct bch_fs *c,
 529                                  struct bch_ioctl_dev_usage_v2 __user *user_arg)
 530 {
 531         struct bch_ioctl_dev_usage_v2 arg;
 532         struct bch_dev_usage src;
 533         struct bch_dev *ca;
 534         int ret = 0;
 535
 536         if (!test_bit(BCH_FS_STARTED, &c->flags))
 537                 return -EINVAL;
 538
 539         if (copy_from_user(&arg, user_arg, sizeof(arg)))
 540                 return -EFAULT;
 541
 542         if ((arg.flags & ~BCH_BY_INDEX) ||
 543             arg.pad[0] ||
 544             arg.pad[1] ||
 545             arg.pad[2])
 546                 return -EINVAL;
 547
 548         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 549         if (IS_ERR(ca))
 550                 return PTR_ERR(ca);
 551
 552         src = bch2_dev_usage_read(ca);
 553
 554         arg.state               = ca->mi.state;
 555         arg.bucket_size         = ca->mi.bucket_size;
 556         arg.nr_data_types       = min(arg.nr_data_types, BCH_DATA_NR);
 557         arg.nr_buckets          = ca->mi.nbuckets - ca->mi.first_bucket;
 558
 559         ret = copy_to_user_errcode(user_arg, &arg, sizeof(arg));
 560         if (ret)
 561                 goto err;
 562
 563         for (unsigned i = 0; i < arg.nr_data_types; i++) {
 564                 struct bch_ioctl_dev_usage_type t = {
 565                         .buckets        = src.d[i].buckets,
 566                         .sectors        = src.d[i].sectors,
 567                         .fragmented     = src.d[i].fragmented,
 568                 };
 569
 570                 ret = copy_to_user_errcode(&user_arg->d[i], &t, sizeof(t));
 571                 if (ret)
 572                         goto err;
 573         }
 574 err:
 575         percpu_ref_put(&ca->ref);
 576         return ret;
 577 }
 578
 579 static long bch2_ioctl_read_super(struct bch_fs *c,
 580                                   struct bch_ioctl_read_super arg)
 581 {
 582         struct bch_dev *ca = NULL;
 583         struct bch_sb *sb;
 584         int ret = 0;
 585
 586         if (!capable(CAP_SYS_ADMIN))
 587                 return -EPERM;
 588
 589         if ((arg.flags & ~(BCH_BY_INDEX|BCH_READ_DEV)) ||
 590             arg.pad)
 591                 return -EINVAL;
 592
 593         mutex_lock(&c->sb_lock);
 594
 595         if (arg.flags & BCH_READ_DEV) {
 596                 ca = bch2_device_lookup(c, arg.dev, arg.flags);
 597
 598                 if (IS_ERR(ca)) {
 599                         ret = PTR_ERR(ca);
 600                         goto err;
 601                 }
 602
 603                 sb = ca->disk_sb.sb;
 604         } else {
 605                 sb = c->disk_sb.sb;
 606         }
 607
 608         if (vstruct_bytes(sb) > arg.size) {
 609                 ret = -ERANGE;
 610                 goto err;
 611         }
 612
 613         ret = copy_to_user_errcode((void __user *)(unsigned long)arg.sb, sb,
 614                                    vstruct_bytes(sb));
 615 err:
 616         if (!IS_ERR_OR_NULL(ca))
 617                 percpu_ref_put(&ca->ref);
 618         mutex_unlock(&c->sb_lock);
 619         return ret;
 620 }
 621
 622 static long bch2_ioctl_disk_get_idx(struct bch_fs *c,
 623                                     struct bch_ioctl_disk_get_idx arg)
 624 {
 625         dev_t dev = huge_decode_dev(arg.dev);
 626         struct bch_dev *ca;
 627         unsigned i;
 628
 629         if (!capable(CAP_SYS_ADMIN))
 630                 return -EPERM;
 631
 632         if (!dev)
 633                 return -EINVAL;
 634
 635         for_each_online_member(ca, c, i)
 636                 if (ca->dev == dev) {
 637                         percpu_ref_put(&ca->io_ref);
 638                         return i;
 639                 }
 640
 641         return -BCH_ERR_ENOENT_dev_idx_not_found;
 642 }
 643
 644 static long bch2_ioctl_disk_resize(struct bch_fs *c,
 645                                    struct bch_ioctl_disk_resize arg)
 646 {
 647         struct bch_dev *ca;
 648         int ret;
 649
 650         if (!capable(CAP_SYS_ADMIN))
 651                 return -EPERM;
 652
 653         if ((arg.flags & ~BCH_BY_INDEX) ||
 654             arg.pad)
 655                 return -EINVAL;
 656
 657         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 658         if (IS_ERR(ca))
 659                 return PTR_ERR(ca);
 660
 661         ret = bch2_dev_resize(c, ca, arg.nbuckets);
 662
 663         percpu_ref_put(&ca->ref);
 664         return ret;
 665 }
 666
 667 static long bch2_ioctl_disk_resize_journal(struct bch_fs *c,
 668                                    struct bch_ioctl_disk_resize_journal arg)
 669 {
 670         struct bch_dev *ca;
 671         int ret;
 672
 673         if (!capable(CAP_SYS_ADMIN))
 674                 return -EPERM;
 675
 676         if ((arg.flags & ~BCH_BY_INDEX) ||
 677             arg.pad)
 678                 return -EINVAL;
 679
 680         if (arg.nbuckets > U32_MAX)
 681                 return -EINVAL;
 682
 683         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 684         if (IS_ERR(ca))
 685                 return PTR_ERR(ca);
 686
 687         ret = bch2_set_nr_journal_buckets(c, ca, arg.nbuckets);
 688
 689         percpu_ref_put(&ca->ref);
 690         return ret;
 691 }
 692
 693 #define BCH_IOCTL(_name, _argtype)                                      \
 694 do {                                                                    \
 695         _argtype i;                                                     \
 696                                                                         \
 697         if (copy_from_user(&i, arg, sizeof(i)))                         \
 698                 return -EFAULT;                                         \
 699         ret = bch2_ioctl_##_name(c, i);                                 \
 700         goto out;                                                       \
 701 } while (0)
 702
 703 long bch2_fs_ioctl(struct bch_fs *c, unsigned cmd, void __user *arg)
 704 {
 705         long ret;
 706
 707         switch (cmd) {
 708         case BCH_IOCTL_QUERY_UUID:
 709                 return bch2_ioctl_query_uuid(c, arg);
 710         case BCH_IOCTL_FS_USAGE:
 711                 return bch2_ioctl_fs_usage(c, arg);
 712         case BCH_IOCTL_DEV_USAGE:
 713                 return bch2_ioctl_dev_usage(c, arg);
 714         case BCH_IOCTL_DEV_USAGE_V2:
 715                 return bch2_ioctl_dev_usage_v2(c, arg);
 716 #if 0
 717         case BCH_IOCTL_START:
 718                 BCH_IOCTL(start, struct bch_ioctl_start);
 719         case BCH_IOCTL_STOP:
 720                 return bch2_ioctl_stop(c);
 721 #endif
 722         case BCH_IOCTL_READ_SUPER:
 723                 BCH_IOCTL(read_super, struct bch_ioctl_read_super);
 724         case BCH_IOCTL_DISK_GET_IDX:
 725                 BCH_IOCTL(disk_get_idx, struct bch_ioctl_disk_get_idx);
 726         }
 727
 728         if (!test_bit(BCH_FS_STARTED, &c->flags))
 729                 return -EINVAL;
 730
 731         switch (cmd) {
 732         case BCH_IOCTL_DISK_ADD:
 733                 BCH_IOCTL(disk_add, struct bch_ioctl_disk);
 734         case BCH_IOCTL_DISK_REMOVE:
 735                 BCH_IOCTL(disk_remove, struct bch_ioctl_disk);
 736         case BCH_IOCTL_DISK_ONLINE:
 737                 BCH_IOCTL(disk_online, struct bch_ioctl_disk);
 738         case BCH_IOCTL_DISK_OFFLINE:
 739                 BCH_IOCTL(disk_offline, struct bch_ioctl_disk);
 740         case BCH_IOCTL_DISK_SET_STATE:
 741                 BCH_IOCTL(disk_set_state, struct bch_ioctl_disk_set_state);
 742         case BCH_IOCTL_DATA:
 743                 BCH_IOCTL(data, struct bch_ioctl_data);
 744         case BCH_IOCTL_DISK_RESIZE:
 745                 BCH_IOCTL(disk_resize, struct bch_ioctl_disk_resize);
 746         case BCH_IOCTL_DISK_RESIZE_JOURNAL:
 747                 BCH_IOCTL(disk_resize_journal, struct bch_ioctl_disk_resize_journal);
 748
 749         default:
 750                 return -ENOTTY;
 751         }
 752 out:
 753         if (ret < 0)
 754                 ret = bch2_err_class(ret);
 755         return ret;
 756 }
 757
 758 static DEFINE_IDR(bch_chardev_minor);
 759
 760 static long bch2_chardev_ioctl(struct file *filp, unsigned cmd, unsigned long v)
 761 {
 762         unsigned minor = iminor(file_inode(filp));
 763         struct bch_fs *c = minor < U8_MAX ? idr_find(&bch_chardev_minor, minor) : NULL;
 764         void __user *arg = (void __user *) v;
 765
 766         return c
 767                 ? bch2_fs_ioctl(c, cmd, arg)
 768                 : bch2_global_ioctl(cmd, arg);
 769 }
 770
 771 static const struct file_operations bch_chardev_fops = {
 772         .owner          = THIS_MODULE,
 773         .unlocked_ioctl = bch2_chardev_ioctl,
 774         .open           = nonseekable_open,
 775 };
 776
 777 static int bch_chardev_major;
 778 static struct class *bch_chardev_class;
 779 static struct device *bch_chardev;
 780
 781 void bch2_fs_chardev_exit(struct bch_fs *c)
 782 {
 783         if (!IS_ERR_OR_NULL(c->chardev))
 784                 device_unregister(c->chardev);
 785         if (c->minor >= 0)
 786                 idr_remove(&bch_chardev_minor, c->minor);
 787 }
 788
 789 int bch2_fs_chardev_init(struct bch_fs *c)
 790 {
 791         c->minor = idr_alloc(&bch_chardev_minor, c, 0, 0, GFP_KERNEL);
 792         if (c->minor < 0)
 793                 return c->minor;
 794
 795         c->chardev = device_create(bch_chardev_class, NULL,
 796                                    MKDEV(bch_chardev_major, c->minor), c,
 797                                    "bcachefs%u-ctl", c->minor);
 798         if (IS_ERR(c->chardev))
 799                 return PTR_ERR(c->chardev);
 800
 801         return 0;
 802 }
 803
 804 void bch2_chardev_exit(void)
 805 {
 806         if (!IS_ERR_OR_NULL(bch_chardev_class))
 807                 device_destroy(bch_chardev_class,
 808                                MKDEV(bch_chardev_major, U8_MAX));
 809         if (!IS_ERR_OR_NULL(bch_chardev_class))
 810                 class_destroy(bch_chardev_class);
 811         if (bch_chardev_major > 0)
 812                 unregister_chrdev(bch_chardev_major, "bcachefs");
 813 }
 814
 815 int __init bch2_chardev_init(void)
 816 {
 817         bch_chardev_major = register_chrdev(0, "bcachefs-ctl", &bch_chardev_fops);
 818         if (bch_chardev_major < 0)
 819                 return bch_chardev_major;
 820
 821         bch_chardev_class = class_create("bcachefs");
 822         if (IS_ERR(bch_chardev_class))
 823                 return PTR_ERR(bch_chardev_class);
 824
 825         bch_chardev = device_create(bch_chardev_class, NULL,
 826                                     MKDEV(bch_chardev_major, U8_MAX),
 827                                     NULL, "bcachefs-ctl");
 828         if (IS_ERR(bch_chardev))
 829                 return PTR_ERR(bch_chardev);
 830
 831         return 0;
 832 }
 833
 834 #endif /* NO_BCACHEFS_CHARDEV */