fs/bcachefs/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 "disk_accounting.h"
   9 #include "fsck.h"
  10 #include "journal.h"
  11 #include "move.h"
  12 #include "recovery_passes.h"
  13 #include "replicas.h"
  14 #include "sb-counters.h"
  15 #include "super-io.h"
  16 #include "thread_with_file.h"
  17
  18 #include <linux/cdev.h>
  19 #include <linux/device.h>
  20 #include <linux/fs.h>
  21 #include <linux/ioctl.h>
  22 #include <linux/major.h>
  23 #include <linux/sched/task.h>
  24 #include <linux/slab.h>
  25 #include <linux/uaccess.h>
  26
  27 /* returns with ref on ca->ref */
  28 static struct bch_dev *bch2_device_lookup(struct bch_fs *c, u64 dev,
  29                                           unsigned flags)
  30 {
  31         struct bch_dev *ca;
  32
  33         if (flags & BCH_BY_INDEX) {
  34                 if (dev >= c->sb.nr_devices)
  35                         return ERR_PTR(-EINVAL);
  36
  37                 ca = bch2_dev_tryget_noerror(c, dev);
  38                 if (!ca)
  39                         return ERR_PTR(-EINVAL);
  40         } else {
  41                 char *path;
  42
  43                 path = strndup_user((const char __user *)
  44                                     (unsigned long) dev, PATH_MAX);
  45                 if (IS_ERR(path))
  46                         return ERR_CAST(path);
  47
  48                 ca = bch2_dev_lookup(c, path);
  49                 kfree(path);
  50         }
  51
  52         return ca;
  53 }
  54
  55 #if 0
  56 static long bch2_ioctl_assemble(struct bch_ioctl_assemble __user *user_arg)
  57 {
  58         struct bch_ioctl_assemble arg;
  59         struct bch_fs *c;
  60         u64 *user_devs = NULL;
  61         char **devs = NULL;
  62         unsigned i;
  63         int ret = -EFAULT;
  64
  65         if (copy_from_user(&arg, user_arg, sizeof(arg)))
  66                 return -EFAULT;
  67
  68         if (arg.flags || arg.pad)
  69                 return -EINVAL;
  70
  71         user_devs = kmalloc_array(arg.nr_devs, sizeof(u64), GFP_KERNEL);
  72         if (!user_devs)
  73                 return -ENOMEM;
  74
  75         devs = kcalloc(arg.nr_devs, sizeof(char *), GFP_KERNEL);
  76
  77         if (copy_from_user(user_devs, user_arg->devs,
  78                            sizeof(u64) * arg.nr_devs))
  79                 goto err;
  80
  81         for (i = 0; i < arg.nr_devs; i++) {
  82                 devs[i] = strndup_user((const char __user *)(unsigned long)
  83                                        user_devs[i],
  84                                        PATH_MAX);
  85                 ret= PTR_ERR_OR_ZERO(devs[i]);
  86                 if (ret)
  87                         goto err;
  88         }
  89
  90         c = bch2_fs_open(devs, arg.nr_devs, bch2_opts_empty());
  91         ret = PTR_ERR_OR_ZERO(c);
  92         if (!ret)
  93                 closure_put(&c->cl);
  94 err:
  95         if (devs)
  96                 for (i = 0; i < arg.nr_devs; i++)
  97                         kfree(devs[i]);
  98         kfree(devs);
  99         return ret;
 100 }
 101
 102 static long bch2_ioctl_incremental(struct bch_ioctl_incremental __user *user_arg)
 103 {
 104         struct bch_ioctl_incremental arg;
 105         const char *err;
 106         char *path;
 107
 108         if (copy_from_user(&arg, user_arg, sizeof(arg)))
 109                 return -EFAULT;
 110
 111         if (arg.flags || arg.pad)
 112                 return -EINVAL;
 113
 114         path = strndup_user((const char __user *)(unsigned long) arg.dev, PATH_MAX);
 115         ret = PTR_ERR_OR_ZERO(path);
 116         if (ret)
 117                 return ret;
 118
 119         err = bch2_fs_open_incremental(path);
 120         kfree(path);
 121
 122         if (err) {
 123                 pr_err("Could not register bcachefs devices: %s", err);
 124                 return -EINVAL;
 125         }
 126
 127         return 0;
 128 }
 129 #endif
 130
 131 static long bch2_global_ioctl(unsigned cmd, void __user *arg)
 132 {
 133         long ret;
 134
 135         switch (cmd) {
 136 #if 0
 137         case BCH_IOCTL_ASSEMBLE:
 138                 return bch2_ioctl_assemble(arg);
 139         case BCH_IOCTL_INCREMENTAL:
 140                 return bch2_ioctl_incremental(arg);
 141 #endif
 142         case BCH_IOCTL_FSCK_OFFLINE: {
 143                 ret = bch2_ioctl_fsck_offline(arg);
 144                 break;
 145         }
 146         default:
 147                 ret = -ENOTTY;
 148                 break;
 149         }
 150
 151         if (ret < 0)
 152                 ret = bch2_err_class(ret);
 153         return ret;
 154 }
 155
 156 static long bch2_ioctl_query_uuid(struct bch_fs *c,
 157                         struct bch_ioctl_query_uuid __user *user_arg)
 158 {
 159         return copy_to_user_errcode(&user_arg->uuid, &c->sb.user_uuid,
 160                                     sizeof(c->sb.user_uuid));
 161 }
 162
 163 #if 0
 164 static long bch2_ioctl_start(struct bch_fs *c, struct bch_ioctl_start arg)
 165 {
 166         if (!capable(CAP_SYS_ADMIN))
 167                 return -EPERM;
 168
 169         if (arg.flags || arg.pad)
 170                 return -EINVAL;
 171
 172         return bch2_fs_start(c);
 173 }
 174
 175 static long bch2_ioctl_stop(struct bch_fs *c)
 176 {
 177         if (!capable(CAP_SYS_ADMIN))
 178                 return -EPERM;
 179
 180         bch2_fs_stop(c);
 181         return 0;
 182 }
 183 #endif
 184
 185 static long bch2_ioctl_disk_add(struct bch_fs *c, struct bch_ioctl_disk arg)
 186 {
 187         char *path;
 188         int ret;
 189
 190         if (!capable(CAP_SYS_ADMIN))
 191                 return -EPERM;
 192
 193         if (arg.flags || arg.pad)
 194                 return -EINVAL;
 195
 196         path = strndup_user((const char __user *)(unsigned long) arg.dev, PATH_MAX);
 197         ret = PTR_ERR_OR_ZERO(path);
 198         if (ret)
 199                 return ret;
 200
 201         ret = bch2_dev_add(c, path);
 202         if (!IS_ERR(path))
 203                 kfree(path);
 204
 205         return ret;
 206 }
 207
 208 static long bch2_ioctl_disk_remove(struct bch_fs *c, struct bch_ioctl_disk arg)
 209 {
 210         struct bch_dev *ca;
 211
 212         if (!capable(CAP_SYS_ADMIN))
 213                 return -EPERM;
 214
 215         if ((arg.flags & ~(BCH_FORCE_IF_DATA_LOST|
 216                            BCH_FORCE_IF_METADATA_LOST|
 217                            BCH_FORCE_IF_DEGRADED|
 218                            BCH_BY_INDEX)) ||
 219             arg.pad)
 220                 return -EINVAL;
 221
 222         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 223         if (IS_ERR(ca))
 224                 return PTR_ERR(ca);
 225
 226         return bch2_dev_remove(c, ca, arg.flags);
 227 }
 228
 229 static long bch2_ioctl_disk_online(struct bch_fs *c, struct bch_ioctl_disk arg)
 230 {
 231         char *path;
 232         int ret;
 233
 234         if (!capable(CAP_SYS_ADMIN))
 235                 return -EPERM;
 236
 237         if (arg.flags || arg.pad)
 238                 return -EINVAL;
 239
 240         path = strndup_user((const char __user *)(unsigned long) arg.dev, PATH_MAX);
 241         ret = PTR_ERR_OR_ZERO(path);
 242         if (ret)
 243                 return ret;
 244
 245         ret = bch2_dev_online(c, path);
 246         kfree(path);
 247         return ret;
 248 }
 249
 250 static long bch2_ioctl_disk_offline(struct bch_fs *c, struct bch_ioctl_disk arg)
 251 {
 252         struct bch_dev *ca;
 253         int ret;
 254
 255         if (!capable(CAP_SYS_ADMIN))
 256                 return -EPERM;
 257
 258         if ((arg.flags & ~(BCH_FORCE_IF_DATA_LOST|
 259                            BCH_FORCE_IF_METADATA_LOST|
 260                            BCH_FORCE_IF_DEGRADED|
 261                            BCH_BY_INDEX)) ||
 262             arg.pad)
 263                 return -EINVAL;
 264
 265         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 266         if (IS_ERR(ca))
 267                 return PTR_ERR(ca);
 268
 269         ret = bch2_dev_offline(c, ca, arg.flags);
 270         bch2_dev_put(ca);
 271         return ret;
 272 }
 273
 274 static long bch2_ioctl_disk_set_state(struct bch_fs *c,
 275                         struct bch_ioctl_disk_set_state arg)
 276 {
 277         struct bch_dev *ca;
 278         int ret;
 279
 280         if (!capable(CAP_SYS_ADMIN))
 281                 return -EPERM;
 282
 283         if ((arg.flags & ~(BCH_FORCE_IF_DATA_LOST|
 284                            BCH_FORCE_IF_METADATA_LOST|
 285                            BCH_FORCE_IF_DEGRADED|
 286                            BCH_BY_INDEX)) ||
 287             arg.pad[0] || arg.pad[1] || arg.pad[2] ||
 288             arg.new_state >= BCH_MEMBER_STATE_NR)
 289                 return -EINVAL;
 290
 291         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 292         if (IS_ERR(ca))
 293                 return PTR_ERR(ca);
 294
 295         ret = bch2_dev_set_state(c, ca, arg.new_state, arg.flags);
 296         if (ret)
 297                 bch_err(c, "Error setting device state: %s", bch2_err_str(ret));
 298
 299         bch2_dev_put(ca);
 300         return ret;
 301 }
 302
 303 struct bch_data_ctx {
 304         struct thread_with_file         thr;
 305
 306         struct bch_fs                   *c;
 307         struct bch_ioctl_data           arg;
 308         struct bch_move_stats           stats;
 309 };
 310
 311 static int bch2_data_thread(void *arg)
 312 {
 313         struct bch_data_ctx *ctx = container_of(arg, struct bch_data_ctx, thr);
 314
 315         ctx->thr.ret = bch2_data_job(ctx->c, &ctx->stats, ctx->arg);
 316         if (ctx->thr.ret == -BCH_ERR_device_offline)
 317                 ctx->stats.ret = BCH_IOCTL_DATA_EVENT_RET_device_offline;
 318         else {
 319                 ctx->stats.ret = BCH_IOCTL_DATA_EVENT_RET_done;
 320                 ctx->stats.data_type = (int) DATA_PROGRESS_DATA_TYPE_done;
 321         }
 322         enumerated_ref_put(&ctx->c->writes, BCH_WRITE_REF_ioctl_data);
 323         return 0;
 324 }
 325
 326 static int bch2_data_job_release(struct inode *inode, struct file *file)
 327 {
 328         struct bch_data_ctx *ctx = container_of(file->private_data, struct bch_data_ctx, thr);
 329
 330         bch2_thread_with_file_exit(&ctx->thr);
 331         kfree(ctx);
 332         return 0;
 333 }
 334
 335 static ssize_t bch2_data_job_read(struct file *file, char __user *buf,
 336                                   size_t len, loff_t *ppos)
 337 {
 338         struct bch_data_ctx *ctx = container_of(file->private_data, struct bch_data_ctx, thr);
 339         struct bch_fs *c = ctx->c;
 340         struct bch_ioctl_data_event e = {
 341                 .type                           = BCH_DATA_EVENT_PROGRESS,
 342                 .ret                            = ctx->stats.ret,
 343                 .p.data_type                    = ctx->stats.data_type,
 344                 .p.btree_id                     = ctx->stats.pos.btree,
 345                 .p.pos                          = ctx->stats.pos.pos,
 346                 .p.sectors_done                 = atomic64_read(&ctx->stats.sectors_seen),
 347                 .p.sectors_error_corrected      = atomic64_read(&ctx->stats.sectors_error_corrected),
 348                 .p.sectors_error_uncorrected    = atomic64_read(&ctx->stats.sectors_error_uncorrected),
 349         };
 350
 351         if (ctx->arg.op == BCH_DATA_OP_scrub) {
 352                 struct bch_dev *ca = bch2_dev_tryget(c, ctx->arg.scrub.dev);
 353                 if (ca) {
 354                         struct bch_dev_usage_full u;
 355                         bch2_dev_usage_full_read_fast(ca, &u);
 356                         for (unsigned i = BCH_DATA_btree; i < ARRAY_SIZE(u.d); i++)
 357                                 if (ctx->arg.scrub.data_types & BIT(i))
 358                                         e.p.sectors_total += u.d[i].sectors;
 359                         bch2_dev_put(ca);
 360                 }
 361         } else {
 362                 e.p.sectors_total       = bch2_fs_usage_read_short(c).used;
 363         }
 364
 365         if (len < sizeof(e))
 366                 return -EINVAL;
 367
 368         return copy_to_user_errcode(buf, &e, sizeof(e)) ?: sizeof(e);
 369 }
 370
 371 static const struct file_operations bcachefs_data_ops = {
 372         .release        = bch2_data_job_release,
 373         .read           = bch2_data_job_read,
 374 };
 375
 376 static long bch2_ioctl_data(struct bch_fs *c,
 377                             struct bch_ioctl_data arg)
 378 {
 379         struct bch_data_ctx *ctx;
 380         int ret;
 381
 382         if (!enumerated_ref_tryget(&c->writes, BCH_WRITE_REF_ioctl_data))
 383                 return -EROFS;
 384
 385         if (!capable(CAP_SYS_ADMIN)) {
 386                 ret = -EPERM;
 387                 goto put_ref;
 388         }
 389
 390         if (arg.op >= BCH_DATA_OP_NR || arg.flags) {
 391                 ret = -EINVAL;
 392                 goto put_ref;
 393         }
 394
 395         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 396         if (!ctx) {
 397                 ret = -ENOMEM;
 398                 goto put_ref;
 399         }
 400
 401         ctx->c = c;
 402         ctx->arg = arg;
 403
 404         ret = bch2_run_thread_with_file(&ctx->thr,
 405                         &bcachefs_data_ops,
 406                         bch2_data_thread);
 407         if (ret < 0)
 408                 goto cleanup;
 409         return ret;
 410 cleanup:
 411         kfree(ctx);
 412 put_ref:
 413         enumerated_ref_put(&c->writes, BCH_WRITE_REF_ioctl_data);
 414         return ret;
 415 }
 416
 417 static noinline_for_stack long bch2_ioctl_fs_usage(struct bch_fs *c,
 418                                 struct bch_ioctl_fs_usage __user *user_arg)
 419 {
 420         struct bch_ioctl_fs_usage arg = {};
 421         darray_char replicas = {};
 422         u32 replica_entries_bytes;
 423         int ret = 0;
 424
 425         if (!test_bit(BCH_FS_started, &c->flags))
 426                 return -EINVAL;
 427
 428         if (get_user(replica_entries_bytes, &user_arg->replica_entries_bytes))
 429                 return -EFAULT;
 430
 431         ret   = bch2_fs_replicas_usage_read(c, &replicas) ?:
 432                 (replica_entries_bytes < replicas.nr ? -ERANGE : 0) ?:
 433                 copy_to_user_errcode(&user_arg->replicas, replicas.data, replicas.nr);
 434         if (ret)
 435                 goto err;
 436
 437         struct bch_fs_usage_short u = bch2_fs_usage_read_short(c);
 438         arg.capacity            = c->capacity;
 439         arg.used                = u.used;
 440         arg.online_reserved     = percpu_u64_get(c->online_reserved);
 441         arg.replica_entries_bytes = replicas.nr;
 442
 443         for (unsigned i = 0; i < BCH_REPLICAS_MAX; i++) {
 444                 struct disk_accounting_pos k;
 445                 disk_accounting_key_init(k, persistent_reserved, .nr_replicas = i);
 446
 447                 bch2_accounting_mem_read(c,
 448                                          disk_accounting_pos_to_bpos(&k),
 449                                          &arg.persistent_reserved[i], 1);
 450         }
 451
 452         ret = copy_to_user_errcode(user_arg, &arg, sizeof(arg));
 453 err:
 454         darray_exit(&replicas);
 455         return ret;
 456 }
 457
 458 static long bch2_ioctl_query_accounting(struct bch_fs *c,
 459                         struct bch_ioctl_query_accounting __user *user_arg)
 460 {
 461         struct bch_ioctl_query_accounting arg;
 462         darray_char accounting = {};
 463         int ret = 0;
 464
 465         if (!test_bit(BCH_FS_started, &c->flags))
 466                 return -EINVAL;
 467
 468         ret   = copy_from_user_errcode(&arg, user_arg, sizeof(arg)) ?:
 469                 bch2_fs_accounting_read(c, &accounting, arg.accounting_types_mask) ?:
 470                 (arg.accounting_u64s * sizeof(u64) < accounting.nr ? -ERANGE : 0) ?:
 471                 copy_to_user_errcode(&user_arg->accounting, accounting.data, accounting.nr);
 472         if (ret)
 473                 goto err;
 474
 475         arg.capacity            = c->capacity;
 476         arg.used                = bch2_fs_usage_read_short(c).used;
 477         arg.online_reserved     = percpu_u64_get(c->online_reserved);
 478         arg.accounting_u64s     = accounting.nr / sizeof(u64);
 479
 480         ret = copy_to_user_errcode(user_arg, &arg, sizeof(arg));
 481 err:
 482         darray_exit(&accounting);
 483         return ret;
 484 }
 485
 486 /* obsolete, didn't allow for new data types: */
 487 static noinline_for_stack 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_full 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_full_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 < ARRAY_SIZE(arg.d); 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         bch2_dev_put(ca);
 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_full 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_full_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         bch2_dev_put(ca);
 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                 ret = PTR_ERR_OR_ZERO(ca);
 598                 if (ret)
 599                         goto err_unlock;
 600
 601                 sb = ca->disk_sb.sb;
 602         } else {
 603                 sb = c->disk_sb.sb;
 604         }
 605
 606         if (vstruct_bytes(sb) > arg.size) {
 607                 ret = -ERANGE;
 608                 goto err;
 609         }
 610
 611         ret = copy_to_user_errcode((void __user *)(unsigned long)arg.sb, sb,
 612                                    vstruct_bytes(sb));
 613 err:
 614         bch2_dev_put(ca);
 615 err_unlock:
 616         mutex_unlock(&c->sb_lock);
 617         return ret;
 618 }
 619
 620 static long bch2_ioctl_disk_get_idx(struct bch_fs *c,
 621                                     struct bch_ioctl_disk_get_idx arg)
 622 {
 623         dev_t dev = huge_decode_dev(arg.dev);
 624
 625         if (!capable(CAP_SYS_ADMIN))
 626                 return -EPERM;
 627
 628         if (!dev)
 629                 return -EINVAL;
 630
 631         guard(rcu)();
 632         for_each_online_member_rcu(c, ca)
 633                 if (ca->dev == dev)
 634                         return ca->dev_idx;
 635
 636         return bch_err_throw(c, ENOENT_dev_idx_not_found);
 637 }
 638
 639 static long bch2_ioctl_disk_resize(struct bch_fs *c,
 640                                    struct bch_ioctl_disk_resize arg)
 641 {
 642         struct bch_dev *ca;
 643         int ret;
 644
 645         if (!capable(CAP_SYS_ADMIN))
 646                 return -EPERM;
 647
 648         if ((arg.flags & ~BCH_BY_INDEX) ||
 649             arg.pad)
 650                 return -EINVAL;
 651
 652         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 653         if (IS_ERR(ca))
 654                 return PTR_ERR(ca);
 655
 656         ret = bch2_dev_resize(c, ca, arg.nbuckets);
 657
 658         bch2_dev_put(ca);
 659         return ret;
 660 }
 661
 662 static long bch2_ioctl_disk_resize_journal(struct bch_fs *c,
 663                                    struct bch_ioctl_disk_resize_journal arg)
 664 {
 665         struct bch_dev *ca;
 666         int ret;
 667
 668         if (!capable(CAP_SYS_ADMIN))
 669                 return -EPERM;
 670
 671         if ((arg.flags & ~BCH_BY_INDEX) ||
 672             arg.pad)
 673                 return -EINVAL;
 674
 675         if (arg.nbuckets > U32_MAX)
 676                 return -EINVAL;
 677
 678         ca = bch2_device_lookup(c, arg.dev, arg.flags);
 679         if (IS_ERR(ca))
 680                 return PTR_ERR(ca);
 681
 682         ret = bch2_set_nr_journal_buckets(c, ca, arg.nbuckets);
 683
 684         bch2_dev_put(ca);
 685         return ret;
 686 }
 687
 688 #define BCH_IOCTL(_name, _argtype)                                      \
 689 do {                                                                    \
 690         _argtype i;                                                     \
 691                                                                         \
 692         if (copy_from_user(&i, arg, sizeof(i)))                         \
 693                 return -EFAULT;                                         \
 694         ret = bch2_ioctl_##_name(c, i);                                 \
 695         goto out;                                                       \
 696 } while (0)
 697
 698 long bch2_fs_ioctl(struct bch_fs *c, unsigned cmd, void __user *arg)
 699 {
 700         long ret;
 701
 702         switch (cmd) {
 703         case BCH_IOCTL_QUERY_UUID:
 704                 return bch2_ioctl_query_uuid(c, arg);
 705         case BCH_IOCTL_FS_USAGE:
 706                 return bch2_ioctl_fs_usage(c, arg);
 707         case BCH_IOCTL_DEV_USAGE:
 708                 return bch2_ioctl_dev_usage(c, arg);
 709         case BCH_IOCTL_DEV_USAGE_V2:
 710                 return bch2_ioctl_dev_usage_v2(c, arg);
 711 #if 0
 712         case BCH_IOCTL_START:
 713                 BCH_IOCTL(start, struct bch_ioctl_start);
 714         case BCH_IOCTL_STOP:
 715                 return bch2_ioctl_stop(c);
 716 #endif
 717         case BCH_IOCTL_READ_SUPER:
 718                 BCH_IOCTL(read_super, struct bch_ioctl_read_super);
 719         case BCH_IOCTL_DISK_GET_IDX:
 720                 BCH_IOCTL(disk_get_idx, struct bch_ioctl_disk_get_idx);
 721         }
 722
 723         if (!test_bit(BCH_FS_started, &c->flags))
 724                 return -EINVAL;
 725
 726         switch (cmd) {
 727         case BCH_IOCTL_DISK_ADD:
 728                 BCH_IOCTL(disk_add, struct bch_ioctl_disk);
 729         case BCH_IOCTL_DISK_REMOVE:
 730                 BCH_IOCTL(disk_remove, struct bch_ioctl_disk);
 731         case BCH_IOCTL_DISK_ONLINE:
 732                 BCH_IOCTL(disk_online, struct bch_ioctl_disk);
 733         case BCH_IOCTL_DISK_OFFLINE:
 734                 BCH_IOCTL(disk_offline, struct bch_ioctl_disk);
 735         case BCH_IOCTL_DISK_SET_STATE:
 736                 BCH_IOCTL(disk_set_state, struct bch_ioctl_disk_set_state);
 737         case BCH_IOCTL_DATA:
 738                 BCH_IOCTL(data, struct bch_ioctl_data);
 739         case BCH_IOCTL_DISK_RESIZE:
 740                 BCH_IOCTL(disk_resize, struct bch_ioctl_disk_resize);
 741         case BCH_IOCTL_DISK_RESIZE_JOURNAL:
 742                 BCH_IOCTL(disk_resize_journal, struct bch_ioctl_disk_resize_journal);
 743         case BCH_IOCTL_FSCK_ONLINE:
 744                 BCH_IOCTL(fsck_online, struct bch_ioctl_fsck_online);
 745         case BCH_IOCTL_QUERY_ACCOUNTING:
 746                 return bch2_ioctl_query_accounting(c, arg);
 747         case BCH_IOCTL_QUERY_COUNTERS:
 748                 return bch2_ioctl_query_counters(c, arg);
 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 const struct class bch_chardev_class = {
 779         .name = "bcachefs",
 780 };
 781 static struct device *bch_chardev;
 782
 783 void bch2_fs_chardev_exit(struct bch_fs *c)
 784 {
 785         if (!IS_ERR_OR_NULL(c->chardev))
 786                 device_unregister(c->chardev);
 787         if (c->minor >= 0)
 788                 idr_remove(&bch_chardev_minor, c->minor);
 789 }
 790
 791 int bch2_fs_chardev_init(struct bch_fs *c)
 792 {
 793         c->minor = idr_alloc(&bch_chardev_minor, c, 0, 0, GFP_KERNEL);
 794         if (c->minor < 0)
 795                 return c->minor;
 796
 797         c->chardev = device_create(&bch_chardev_class, NULL,
 798                                    MKDEV(bch_chardev_major, c->minor), c,
 799                                    "bcachefs%u-ctl", c->minor);
 800         if (IS_ERR(c->chardev))
 801                 return PTR_ERR(c->chardev);
 802
 803         return 0;
 804 }
 805
 806 void bch2_chardev_exit(void)
 807 {
 808         device_destroy(&bch_chardev_class, MKDEV(bch_chardev_major, U8_MAX));
 809         class_unregister(&bch_chardev_class);
 810         if (bch_chardev_major > 0)
 811                 unregister_chrdev(bch_chardev_major, "bcachefs");
 812 }
 813
 814 int __init bch2_chardev_init(void)
 815 {
 816         int ret;
 817
 818         bch_chardev_major = register_chrdev(0, "bcachefs-ctl", &bch_chardev_fops);
 819         if (bch_chardev_major < 0)
 820                 return bch_chardev_major;
 821
 822         ret = class_register(&bch_chardev_class);
 823         if (ret)
 824                 goto major_out;
 825
 826         bch_chardev = device_create(&bch_chardev_class, NULL,
 827                                     MKDEV(bch_chardev_major, U8_MAX),
 828                                     NULL, "bcachefs-ctl");
 829         if (IS_ERR(bch_chardev)) {
 830                 ret = PTR_ERR(bch_chardev);
 831                 goto class_out;
 832         }
 833
 834         return 0;
 835
 836 class_out:
 837         class_unregister(&bch_chardev_class);
 838 major_out:
 839         unregister_chrdev(bch_chardev_major, "bcachefs-ctl");
 840         return ret;
 841 }
 842
 843 #endif /* NO_BCACHEFS_CHARDEV */