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 return 0; 323 } 324 325 static int bch2_data_job_release(struct inode *inode, struct file *file) 326 { 327 struct bch_data_ctx *ctx = container_of(file->private_data, struct bch_data_ctx, thr); 328 329 bch2_thread_with_file_exit(&ctx->thr); 330 kfree(ctx); 331 return 0; 332 } 333 334 static ssize_t bch2_data_job_read(struct file *file, char __user *buf, 335 size_t len, loff_t *ppos) 336 { 337 struct bch_data_ctx *ctx = container_of(file->private_data, struct bch_data_ctx, thr); 338 struct bch_fs *c = ctx->c; 339 struct bch_ioctl_data_event e = { 340 .type = BCH_DATA_EVENT_PROGRESS, 341 .ret = ctx->stats.ret, 342 .p.data_type = ctx->stats.data_type, 343 .p.btree_id = ctx->stats.pos.btree, 344 .p.pos = ctx->stats.pos.pos, 345 .p.sectors_done = atomic64_read(&ctx->stats.sectors_seen), 346 .p.sectors_error_corrected = atomic64_read(&ctx->stats.sectors_error_corrected), 347 .p.sectors_error_uncorrected = atomic64_read(&ctx->stats.sectors_error_uncorrected), 348 }; 349 350 if (ctx->arg.op == BCH_DATA_OP_scrub) { 351 struct bch_dev *ca = bch2_dev_tryget(c, ctx->arg.scrub.dev); 352 if (ca) { 353 struct bch_dev_usage_full u; 354 bch2_dev_usage_full_read_fast(ca, &u); 355 for (unsigned i = BCH_DATA_btree; i < ARRAY_SIZE(u.d); i++) 356 if (ctx->arg.scrub.data_types & BIT(i)) 357 e.p.sectors_total += u.d[i].sectors; 358 bch2_dev_put(ca); 359 } 360 } else { 361 e.p.sectors_total = bch2_fs_usage_read_short(c).used; 362 } 363 364 if (len < sizeof(e)) 365 return -EINVAL; 366 367 return copy_to_user_errcode(buf, &e, sizeof(e)) ?: sizeof(e); 368 } 369 370 static const struct file_operations bcachefs_data_ops = { 371 .release = bch2_data_job_release, 372 .read = bch2_data_job_read, 373 }; 374 375 static long bch2_ioctl_data(struct bch_fs *c, 376 struct bch_ioctl_data arg) 377 { 378 struct bch_data_ctx *ctx; 379 int ret; 380 381 if (!capable(CAP_SYS_ADMIN)) 382 return -EPERM; 383 384 if (arg.op >= BCH_DATA_OP_NR || arg.flags) 385 return -EINVAL; 386 387 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 388 if (!ctx) 389 return -ENOMEM; 390 391 ctx->c = c; 392 ctx->arg = arg; 393 394 ret = bch2_run_thread_with_file(&ctx->thr, 395 &bcachefs_data_ops, 396 bch2_data_thread); 397 if (ret < 0) 398 kfree(ctx); 399 return ret; 400 } 401 402 static noinline_for_stack long bch2_ioctl_fs_usage(struct bch_fs *c, 403 struct bch_ioctl_fs_usage __user *user_arg) 404 { 405 struct bch_ioctl_fs_usage arg = {}; 406 darray_char replicas = {}; 407 u32 replica_entries_bytes; 408 int ret = 0; 409 410 if (!test_bit(BCH_FS_started, &c->flags)) 411 return -EINVAL; 412 413 if (get_user(replica_entries_bytes, &user_arg->replica_entries_bytes)) 414 return -EFAULT; 415 416 ret = bch2_fs_replicas_usage_read(c, &replicas) ?: 417 (replica_entries_bytes < replicas.nr ? -ERANGE : 0) ?: 418 copy_to_user_errcode(&user_arg->replicas, replicas.data, replicas.nr); 419 if (ret) 420 goto err; 421 422 struct bch_fs_usage_short u = bch2_fs_usage_read_short(c); 423 arg.capacity = c->capacity; 424 arg.used = u.used; 425 arg.online_reserved = percpu_u64_get(c->online_reserved); 426 arg.replica_entries_bytes = replicas.nr; 427 428 for (unsigned i = 0; i < BCH_REPLICAS_MAX; i++) { 429 struct disk_accounting_pos k; 430 disk_accounting_key_init(k, persistent_reserved, .nr_replicas = i); 431 432 bch2_accounting_mem_read(c, 433 disk_accounting_pos_to_bpos(&k), 434 &arg.persistent_reserved[i], 1); 435 } 436 437 ret = copy_to_user_errcode(user_arg, &arg, sizeof(arg)); 438 err: 439 darray_exit(&replicas); 440 return ret; 441 } 442 443 static long bch2_ioctl_query_accounting(struct bch_fs *c, 444 struct bch_ioctl_query_accounting __user *user_arg) 445 { 446 struct bch_ioctl_query_accounting arg; 447 darray_char accounting = {}; 448 int ret = 0; 449 450 if (!test_bit(BCH_FS_started, &c->flags)) 451 return -EINVAL; 452 453 ret = copy_from_user_errcode(&arg, user_arg, sizeof(arg)) ?: 454 bch2_fs_accounting_read(c, &accounting, arg.accounting_types_mask) ?: 455 (arg.accounting_u64s * sizeof(u64) < accounting.nr ? -ERANGE : 0) ?: 456 copy_to_user_errcode(&user_arg->accounting, accounting.data, accounting.nr); 457 if (ret) 458 goto err; 459 460 arg.capacity = c->capacity; 461 arg.used = bch2_fs_usage_read_short(c).used; 462 arg.online_reserved = percpu_u64_get(c->online_reserved); 463 arg.accounting_u64s = accounting.nr / sizeof(u64); 464 465 ret = copy_to_user_errcode(user_arg, &arg, sizeof(arg)); 466 err: 467 darray_exit(&accounting); 468 return ret; 469 } 470 471 /* obsolete, didn't allow for new data types: */ 472 static noinline_for_stack long bch2_ioctl_dev_usage(struct bch_fs *c, 473 struct bch_ioctl_dev_usage __user *user_arg) 474 { 475 struct bch_ioctl_dev_usage arg; 476 struct bch_dev_usage_full src; 477 struct bch_dev *ca; 478 unsigned i; 479 480 if (!test_bit(BCH_FS_started, &c->flags)) 481 return -EINVAL; 482 483 if (copy_from_user(&arg, user_arg, sizeof(arg))) 484 return -EFAULT; 485 486 if ((arg.flags & ~BCH_BY_INDEX) || 487 arg.pad[0] || 488 arg.pad[1] || 489 arg.pad[2]) 490 return -EINVAL; 491 492 ca = bch2_device_lookup(c, arg.dev, arg.flags); 493 if (IS_ERR(ca)) 494 return PTR_ERR(ca); 495 496 src = bch2_dev_usage_full_read(ca); 497 498 arg.state = ca->mi.state; 499 arg.bucket_size = ca->mi.bucket_size; 500 arg.nr_buckets = ca->mi.nbuckets - ca->mi.first_bucket; 501 502 for (i = 0; i < ARRAY_SIZE(arg.d); i++) { 503 arg.d[i].buckets = src.d[i].buckets; 504 arg.d[i].sectors = src.d[i].sectors; 505 arg.d[i].fragmented = src.d[i].fragmented; 506 } 507 508 bch2_dev_put(ca); 509 510 return copy_to_user_errcode(user_arg, &arg, sizeof(arg)); 511 } 512 513 static long bch2_ioctl_dev_usage_v2(struct bch_fs *c, 514 struct bch_ioctl_dev_usage_v2 __user *user_arg) 515 { 516 struct bch_ioctl_dev_usage_v2 arg; 517 struct bch_dev_usage_full src; 518 struct bch_dev *ca; 519 int ret = 0; 520 521 if (!test_bit(BCH_FS_started, &c->flags)) 522 return -EINVAL; 523 524 if (copy_from_user(&arg, user_arg, sizeof(arg))) 525 return -EFAULT; 526 527 if ((arg.flags & ~BCH_BY_INDEX) || 528 arg.pad[0] || 529 arg.pad[1] || 530 arg.pad[2]) 531 return -EINVAL; 532 533 ca = bch2_device_lookup(c, arg.dev, arg.flags); 534 if (IS_ERR(ca)) 535 return PTR_ERR(ca); 536 537 src = bch2_dev_usage_full_read(ca); 538 539 arg.state = ca->mi.state; 540 arg.bucket_size = ca->mi.bucket_size; 541 arg.nr_data_types = min(arg.nr_data_types, BCH_DATA_NR); 542 arg.nr_buckets = ca->mi.nbuckets - ca->mi.first_bucket; 543 544 ret = copy_to_user_errcode(user_arg, &arg, sizeof(arg)); 545 if (ret) 546 goto err; 547 548 for (unsigned i = 0; i < arg.nr_data_types; i++) { 549 struct bch_ioctl_dev_usage_type t = { 550 .buckets = src.d[i].buckets, 551 .sectors = src.d[i].sectors, 552 .fragmented = src.d[i].fragmented, 553 }; 554 555 ret = copy_to_user_errcode(&user_arg->d[i], &t, sizeof(t)); 556 if (ret) 557 goto err; 558 } 559 err: 560 bch2_dev_put(ca); 561 return ret; 562 } 563 564 static long bch2_ioctl_read_super(struct bch_fs *c, 565 struct bch_ioctl_read_super arg) 566 { 567 struct bch_dev *ca = NULL; 568 struct bch_sb *sb; 569 int ret = 0; 570 571 if (!capable(CAP_SYS_ADMIN)) 572 return -EPERM; 573 574 if ((arg.flags & ~(BCH_BY_INDEX|BCH_READ_DEV)) || 575 arg.pad) 576 return -EINVAL; 577 578 mutex_lock(&c->sb_lock); 579 580 if (arg.flags & BCH_READ_DEV) { 581 ca = bch2_device_lookup(c, arg.dev, arg.flags); 582 ret = PTR_ERR_OR_ZERO(ca); 583 if (ret) 584 goto err_unlock; 585 586 sb = ca->disk_sb.sb; 587 } else { 588 sb = c->disk_sb.sb; 589 } 590 591 if (vstruct_bytes(sb) > arg.size) { 592 ret = -ERANGE; 593 goto err; 594 } 595 596 ret = copy_to_user_errcode((void __user *)(unsigned long)arg.sb, sb, 597 vstruct_bytes(sb)); 598 err: 599 bch2_dev_put(ca); 600 err_unlock: 601 mutex_unlock(&c->sb_lock); 602 return ret; 603 } 604 605 static long bch2_ioctl_disk_get_idx(struct bch_fs *c, 606 struct bch_ioctl_disk_get_idx arg) 607 { 608 dev_t dev = huge_decode_dev(arg.dev); 609 610 if (!capable(CAP_SYS_ADMIN)) 611 return -EPERM; 612 613 if (!dev) 614 return -EINVAL; 615 616 guard(rcu)(); 617 for_each_online_member_rcu(c, ca) 618 if (ca->dev == dev) 619 return ca->dev_idx; 620 621 return bch_err_throw(c, ENOENT_dev_idx_not_found); 622 } 623 624 static long bch2_ioctl_disk_resize(struct bch_fs *c, 625 struct bch_ioctl_disk_resize arg) 626 { 627 struct bch_dev *ca; 628 int ret; 629 630 if (!capable(CAP_SYS_ADMIN)) 631 return -EPERM; 632 633 if ((arg.flags & ~BCH_BY_INDEX) || 634 arg.pad) 635 return -EINVAL; 636 637 ca = bch2_device_lookup(c, arg.dev, arg.flags); 638 if (IS_ERR(ca)) 639 return PTR_ERR(ca); 640 641 ret = bch2_dev_resize(c, ca, arg.nbuckets); 642 643 bch2_dev_put(ca); 644 return ret; 645 } 646 647 static long bch2_ioctl_disk_resize_journal(struct bch_fs *c, 648 struct bch_ioctl_disk_resize_journal arg) 649 { 650 struct bch_dev *ca; 651 int ret; 652 653 if (!capable(CAP_SYS_ADMIN)) 654 return -EPERM; 655 656 if ((arg.flags & ~BCH_BY_INDEX) || 657 arg.pad) 658 return -EINVAL; 659 660 if (arg.nbuckets > U32_MAX) 661 return -EINVAL; 662 663 ca = bch2_device_lookup(c, arg.dev, arg.flags); 664 if (IS_ERR(ca)) 665 return PTR_ERR(ca); 666 667 ret = bch2_set_nr_journal_buckets(c, ca, arg.nbuckets); 668 669 bch2_dev_put(ca); 670 return ret; 671 } 672 673 #define BCH_IOCTL(_name, _argtype) \ 674 do { \ 675 _argtype i; \ 676 \ 677 if (copy_from_user(&i, arg, sizeof(i))) \ 678 return -EFAULT; \ 679 ret = bch2_ioctl_##_name(c, i); \ 680 goto out; \ 681 } while (0) 682 683 long bch2_fs_ioctl(struct bch_fs *c, unsigned cmd, void __user *arg) 684 { 685 long ret; 686 687 switch (cmd) { 688 case BCH_IOCTL_QUERY_UUID: 689 return bch2_ioctl_query_uuid(c, arg); 690 case BCH_IOCTL_FS_USAGE: 691 return bch2_ioctl_fs_usage(c, arg); 692 case BCH_IOCTL_DEV_USAGE: 693 return bch2_ioctl_dev_usage(c, arg); 694 case BCH_IOCTL_DEV_USAGE_V2: 695 return bch2_ioctl_dev_usage_v2(c, arg); 696 #if 0 697 case BCH_IOCTL_START: 698 BCH_IOCTL(start, struct bch_ioctl_start); 699 case BCH_IOCTL_STOP: 700 return bch2_ioctl_stop(c); 701 #endif 702 case BCH_IOCTL_READ_SUPER: 703 BCH_IOCTL(read_super, struct bch_ioctl_read_super); 704 case BCH_IOCTL_DISK_GET_IDX: 705 BCH_IOCTL(disk_get_idx, struct bch_ioctl_disk_get_idx); 706 } 707 708 if (!test_bit(BCH_FS_started, &c->flags)) 709 return -EINVAL; 710 711 switch (cmd) { 712 case BCH_IOCTL_DISK_ADD: 713 BCH_IOCTL(disk_add, struct bch_ioctl_disk); 714 case BCH_IOCTL_DISK_REMOVE: 715 BCH_IOCTL(disk_remove, struct bch_ioctl_disk); 716 case BCH_IOCTL_DISK_ONLINE: 717 BCH_IOCTL(disk_online, struct bch_ioctl_disk); 718 case BCH_IOCTL_DISK_OFFLINE: 719 BCH_IOCTL(disk_offline, struct bch_ioctl_disk); 720 case BCH_IOCTL_DISK_SET_STATE: 721 BCH_IOCTL(disk_set_state, struct bch_ioctl_disk_set_state); 722 case BCH_IOCTL_DATA: 723 BCH_IOCTL(data, struct bch_ioctl_data); 724 case BCH_IOCTL_DISK_RESIZE: 725 BCH_IOCTL(disk_resize, struct bch_ioctl_disk_resize); 726 case BCH_IOCTL_DISK_RESIZE_JOURNAL: 727 BCH_IOCTL(disk_resize_journal, struct bch_ioctl_disk_resize_journal); 728 case BCH_IOCTL_FSCK_ONLINE: 729 BCH_IOCTL(fsck_online, struct bch_ioctl_fsck_online); 730 case BCH_IOCTL_QUERY_ACCOUNTING: 731 return bch2_ioctl_query_accounting(c, arg); 732 case BCH_IOCTL_QUERY_COUNTERS: 733 return bch2_ioctl_query_counters(c, arg); 734 default: 735 return -ENOTTY; 736 } 737 out: 738 if (ret < 0) 739 ret = bch2_err_class(ret); 740 return ret; 741 } 742 743 static DEFINE_IDR(bch_chardev_minor); 744 745 static long bch2_chardev_ioctl(struct file *filp, unsigned cmd, unsigned long v) 746 { 747 unsigned minor = iminor(file_inode(filp)); 748 struct bch_fs *c = minor < U8_MAX ? idr_find(&bch_chardev_minor, minor) : NULL; 749 void __user *arg = (void __user *) v; 750 751 return c 752 ? bch2_fs_ioctl(c, cmd, arg) 753 : bch2_global_ioctl(cmd, arg); 754 } 755 756 static const struct file_operations bch_chardev_fops = { 757 .owner = THIS_MODULE, 758 .unlocked_ioctl = bch2_chardev_ioctl, 759 .open = nonseekable_open, 760 }; 761 762 static int bch_chardev_major; 763 static const struct class bch_chardev_class = { 764 .name = "bcachefs", 765 }; 766 static struct device *bch_chardev; 767 768 void bch2_fs_chardev_exit(struct bch_fs *c) 769 { 770 if (!IS_ERR_OR_NULL(c->chardev)) 771 device_unregister(c->chardev); 772 if (c->minor >= 0) 773 idr_remove(&bch_chardev_minor, c->minor); 774 } 775 776 int bch2_fs_chardev_init(struct bch_fs *c) 777 { 778 c->minor = idr_alloc(&bch_chardev_minor, c, 0, 0, GFP_KERNEL); 779 if (c->minor < 0) 780 return c->minor; 781 782 c->chardev = device_create(&bch_chardev_class, NULL, 783 MKDEV(bch_chardev_major, c->minor), c, 784 "bcachefs%u-ctl", c->minor); 785 if (IS_ERR(c->chardev)) 786 return PTR_ERR(c->chardev); 787 788 return 0; 789 } 790 791 void bch2_chardev_exit(void) 792 { 793 device_destroy(&bch_chardev_class, MKDEV(bch_chardev_major, U8_MAX)); 794 class_unregister(&bch_chardev_class); 795 if (bch_chardev_major > 0) 796 unregister_chrdev(bch_chardev_major, "bcachefs"); 797 } 798 799 int __init bch2_chardev_init(void) 800 { 801 int ret; 802 803 bch_chardev_major = register_chrdev(0, "bcachefs-ctl", &bch_chardev_fops); 804 if (bch_chardev_major < 0) 805 return bch_chardev_major; 806 807 ret = class_register(&bch_chardev_class); 808 if (ret) 809 goto major_out; 810 811 bch_chardev = device_create(&bch_chardev_class, NULL, 812 MKDEV(bch_chardev_major, U8_MAX), 813 NULL, "bcachefs-ctl"); 814 if (IS_ERR(bch_chardev)) { 815 ret = PTR_ERR(bch_chardev); 816 goto class_out; 817 } 818 819 return 0; 820 821 class_out: 822 class_unregister(&bch_chardev_class); 823 major_out: 824 unregister_chrdev(bch_chardev_major, "bcachefs-ctl"); 825 return ret; 826 } 827 828 #endif /* NO_BCACHEFS_CHARDEV */ 829