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 */
bch2_device_lookup(struct bch_fs * c,u64 dev,unsigned flags)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
bch2_global_ioctl(unsigned cmd,void __user * arg)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
bch2_ioctl_query_uuid(struct bch_fs * c,struct bch_ioctl_query_uuid __user * user_arg)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
bch2_ioctl_disk_add(struct bch_fs * c,struct bch_ioctl_disk arg)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
bch2_ioctl_disk_remove(struct bch_fs * c,struct bch_ioctl_disk arg)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
bch2_ioctl_disk_online(struct bch_fs * c,struct bch_ioctl_disk arg)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
bch2_ioctl_disk_offline(struct bch_fs * c,struct bch_ioctl_disk arg)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
bch2_ioctl_disk_set_state(struct bch_fs * c,struct bch_ioctl_disk_set_state arg)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
bch2_data_thread(void * arg)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
bch2_data_job_release(struct inode * inode,struct file * file)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
bch2_data_job_read(struct file * file,char __user * buf,size_t len,loff_t * ppos)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 u;
354 bch2_dev_usage_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
bch2_ioctl_data(struct bch_fs * c,struct bch_ioctl_data arg)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
bch2_ioctl_fs_usage(struct bch_fs * c,struct bch_ioctl_fs_usage __user * user_arg)402 static 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 .type = BCH_DISK_ACCOUNTING_persistent_reserved,
431 .persistent_reserved.nr_replicas = i,
432 };
433
434 bch2_accounting_mem_read(c,
435 disk_accounting_pos_to_bpos(&k),
436 &arg.persistent_reserved[i], 1);
437 }
438
439 ret = copy_to_user_errcode(user_arg, &arg, sizeof(arg));
440 err:
441 darray_exit(&replicas);
442 return ret;
443 }
444
bch2_ioctl_query_accounting(struct bch_fs * c,struct bch_ioctl_query_accounting __user * user_arg)445 static long bch2_ioctl_query_accounting(struct bch_fs *c,
446 struct bch_ioctl_query_accounting __user *user_arg)
447 {
448 struct bch_ioctl_query_accounting arg;
449 darray_char accounting = {};
450 int ret = 0;
451
452 if (!test_bit(BCH_FS_started, &c->flags))
453 return -EINVAL;
454
455 ret = copy_from_user_errcode(&arg, user_arg, sizeof(arg)) ?:
456 bch2_fs_accounting_read(c, &accounting, arg.accounting_types_mask) ?:
457 (arg.accounting_u64s * sizeof(u64) < accounting.nr ? -ERANGE : 0) ?:
458 copy_to_user_errcode(&user_arg->accounting, accounting.data, accounting.nr);
459 if (ret)
460 goto err;
461
462 arg.capacity = c->capacity;
463 arg.used = bch2_fs_usage_read_short(c).used;
464 arg.online_reserved = percpu_u64_get(c->online_reserved);
465 arg.accounting_u64s = accounting.nr / sizeof(u64);
466
467 ret = copy_to_user_errcode(user_arg, &arg, sizeof(arg));
468 err:
469 darray_exit(&accounting);
470 return ret;
471 }
472
473 /* obsolete, didn't allow for new data types: */
bch2_ioctl_dev_usage(struct bch_fs * c,struct bch_ioctl_dev_usage __user * user_arg)474 static long bch2_ioctl_dev_usage(struct bch_fs *c,
475 struct bch_ioctl_dev_usage __user *user_arg)
476 {
477 struct bch_ioctl_dev_usage arg;
478 struct bch_dev_usage src;
479 struct bch_dev *ca;
480 unsigned i;
481
482 if (!test_bit(BCH_FS_started, &c->flags))
483 return -EINVAL;
484
485 if (copy_from_user(&arg, user_arg, sizeof(arg)))
486 return -EFAULT;
487
488 if ((arg.flags & ~BCH_BY_INDEX) ||
489 arg.pad[0] ||
490 arg.pad[1] ||
491 arg.pad[2])
492 return -EINVAL;
493
494 ca = bch2_device_lookup(c, arg.dev, arg.flags);
495 if (IS_ERR(ca))
496 return PTR_ERR(ca);
497
498 src = bch2_dev_usage_read(ca);
499
500 arg.state = ca->mi.state;
501 arg.bucket_size = ca->mi.bucket_size;
502 arg.nr_buckets = ca->mi.nbuckets - ca->mi.first_bucket;
503
504 for (i = 0; i < ARRAY_SIZE(arg.d); i++) {
505 arg.d[i].buckets = src.d[i].buckets;
506 arg.d[i].sectors = src.d[i].sectors;
507 arg.d[i].fragmented = src.d[i].fragmented;
508 }
509
510 bch2_dev_put(ca);
511
512 return copy_to_user_errcode(user_arg, &arg, sizeof(arg));
513 }
514
bch2_ioctl_dev_usage_v2(struct bch_fs * c,struct bch_ioctl_dev_usage_v2 __user * user_arg)515 static long bch2_ioctl_dev_usage_v2(struct bch_fs *c,
516 struct bch_ioctl_dev_usage_v2 __user *user_arg)
517 {
518 struct bch_ioctl_dev_usage_v2 arg;
519 struct bch_dev_usage src;
520 struct bch_dev *ca;
521 int ret = 0;
522
523 if (!test_bit(BCH_FS_started, &c->flags))
524 return -EINVAL;
525
526 if (copy_from_user(&arg, user_arg, sizeof(arg)))
527 return -EFAULT;
528
529 if ((arg.flags & ~BCH_BY_INDEX) ||
530 arg.pad[0] ||
531 arg.pad[1] ||
532 arg.pad[2])
533 return -EINVAL;
534
535 ca = bch2_device_lookup(c, arg.dev, arg.flags);
536 if (IS_ERR(ca))
537 return PTR_ERR(ca);
538
539 src = bch2_dev_usage_read(ca);
540
541 arg.state = ca->mi.state;
542 arg.bucket_size = ca->mi.bucket_size;
543 arg.nr_data_types = min(arg.nr_data_types, BCH_DATA_NR);
544 arg.nr_buckets = ca->mi.nbuckets - ca->mi.first_bucket;
545
546 ret = copy_to_user_errcode(user_arg, &arg, sizeof(arg));
547 if (ret)
548 goto err;
549
550 for (unsigned i = 0; i < arg.nr_data_types; i++) {
551 struct bch_ioctl_dev_usage_type t = {
552 .buckets = src.d[i].buckets,
553 .sectors = src.d[i].sectors,
554 .fragmented = src.d[i].fragmented,
555 };
556
557 ret = copy_to_user_errcode(&user_arg->d[i], &t, sizeof(t));
558 if (ret)
559 goto err;
560 }
561 err:
562 bch2_dev_put(ca);
563 return ret;
564 }
565
bch2_ioctl_read_super(struct bch_fs * c,struct bch_ioctl_read_super arg)566 static long bch2_ioctl_read_super(struct bch_fs *c,
567 struct bch_ioctl_read_super arg)
568 {
569 struct bch_dev *ca = NULL;
570 struct bch_sb *sb;
571 int ret = 0;
572
573 if (!capable(CAP_SYS_ADMIN))
574 return -EPERM;
575
576 if ((arg.flags & ~(BCH_BY_INDEX|BCH_READ_DEV)) ||
577 arg.pad)
578 return -EINVAL;
579
580 mutex_lock(&c->sb_lock);
581
582 if (arg.flags & BCH_READ_DEV) {
583 ca = bch2_device_lookup(c, arg.dev, arg.flags);
584 ret = PTR_ERR_OR_ZERO(ca);
585 if (ret)
586 goto err_unlock;
587
588 sb = ca->disk_sb.sb;
589 } else {
590 sb = c->disk_sb.sb;
591 }
592
593 if (vstruct_bytes(sb) > arg.size) {
594 ret = -ERANGE;
595 goto err;
596 }
597
598 ret = copy_to_user_errcode((void __user *)(unsigned long)arg.sb, sb,
599 vstruct_bytes(sb));
600 err:
601 bch2_dev_put(ca);
602 err_unlock:
603 mutex_unlock(&c->sb_lock);
604 return ret;
605 }
606
bch2_ioctl_disk_get_idx(struct bch_fs * c,struct bch_ioctl_disk_get_idx arg)607 static long bch2_ioctl_disk_get_idx(struct bch_fs *c,
608 struct bch_ioctl_disk_get_idx arg)
609 {
610 dev_t dev = huge_decode_dev(arg.dev);
611
612 if (!capable(CAP_SYS_ADMIN))
613 return -EPERM;
614
615 if (!dev)
616 return -EINVAL;
617
618 for_each_online_member(c, ca)
619 if (ca->dev == dev) {
620 percpu_ref_put(&ca->io_ref);
621 return ca->dev_idx;
622 }
623
624 return -BCH_ERR_ENOENT_dev_idx_not_found;
625 }
626
bch2_ioctl_disk_resize(struct bch_fs * c,struct bch_ioctl_disk_resize arg)627 static long bch2_ioctl_disk_resize(struct bch_fs *c,
628 struct bch_ioctl_disk_resize arg)
629 {
630 struct bch_dev *ca;
631 int ret;
632
633 if (!capable(CAP_SYS_ADMIN))
634 return -EPERM;
635
636 if ((arg.flags & ~BCH_BY_INDEX) ||
637 arg.pad)
638 return -EINVAL;
639
640 ca = bch2_device_lookup(c, arg.dev, arg.flags);
641 if (IS_ERR(ca))
642 return PTR_ERR(ca);
643
644 ret = bch2_dev_resize(c, ca, arg.nbuckets);
645
646 bch2_dev_put(ca);
647 return ret;
648 }
649
bch2_ioctl_disk_resize_journal(struct bch_fs * c,struct bch_ioctl_disk_resize_journal arg)650 static long bch2_ioctl_disk_resize_journal(struct bch_fs *c,
651 struct bch_ioctl_disk_resize_journal arg)
652 {
653 struct bch_dev *ca;
654 int ret;
655
656 if (!capable(CAP_SYS_ADMIN))
657 return -EPERM;
658
659 if ((arg.flags & ~BCH_BY_INDEX) ||
660 arg.pad)
661 return -EINVAL;
662
663 if (arg.nbuckets > U32_MAX)
664 return -EINVAL;
665
666 ca = bch2_device_lookup(c, arg.dev, arg.flags);
667 if (IS_ERR(ca))
668 return PTR_ERR(ca);
669
670 ret = bch2_set_nr_journal_buckets(c, ca, arg.nbuckets);
671
672 bch2_dev_put(ca);
673 return ret;
674 }
675
676 #define BCH_IOCTL(_name, _argtype) \
677 do { \
678 _argtype i; \
679 \
680 if (copy_from_user(&i, arg, sizeof(i))) \
681 return -EFAULT; \
682 ret = bch2_ioctl_##_name(c, i); \
683 goto out; \
684 } while (0)
685
bch2_fs_ioctl(struct bch_fs * c,unsigned cmd,void __user * arg)686 long bch2_fs_ioctl(struct bch_fs *c, unsigned cmd, void __user *arg)
687 {
688 long ret;
689
690 switch (cmd) {
691 case BCH_IOCTL_QUERY_UUID:
692 return bch2_ioctl_query_uuid(c, arg);
693 case BCH_IOCTL_FS_USAGE:
694 return bch2_ioctl_fs_usage(c, arg);
695 case BCH_IOCTL_DEV_USAGE:
696 return bch2_ioctl_dev_usage(c, arg);
697 case BCH_IOCTL_DEV_USAGE_V2:
698 return bch2_ioctl_dev_usage_v2(c, arg);
699 #if 0
700 case BCH_IOCTL_START:
701 BCH_IOCTL(start, struct bch_ioctl_start);
702 case BCH_IOCTL_STOP:
703 return bch2_ioctl_stop(c);
704 #endif
705 case BCH_IOCTL_READ_SUPER:
706 BCH_IOCTL(read_super, struct bch_ioctl_read_super);
707 case BCH_IOCTL_DISK_GET_IDX:
708 BCH_IOCTL(disk_get_idx, struct bch_ioctl_disk_get_idx);
709 }
710
711 if (!test_bit(BCH_FS_started, &c->flags))
712 return -EINVAL;
713
714 switch (cmd) {
715 case BCH_IOCTL_DISK_ADD:
716 BCH_IOCTL(disk_add, struct bch_ioctl_disk);
717 case BCH_IOCTL_DISK_REMOVE:
718 BCH_IOCTL(disk_remove, struct bch_ioctl_disk);
719 case BCH_IOCTL_DISK_ONLINE:
720 BCH_IOCTL(disk_online, struct bch_ioctl_disk);
721 case BCH_IOCTL_DISK_OFFLINE:
722 BCH_IOCTL(disk_offline, struct bch_ioctl_disk);
723 case BCH_IOCTL_DISK_SET_STATE:
724 BCH_IOCTL(disk_set_state, struct bch_ioctl_disk_set_state);
725 case BCH_IOCTL_DATA:
726 BCH_IOCTL(data, struct bch_ioctl_data);
727 case BCH_IOCTL_DISK_RESIZE:
728 BCH_IOCTL(disk_resize, struct bch_ioctl_disk_resize);
729 case BCH_IOCTL_DISK_RESIZE_JOURNAL:
730 BCH_IOCTL(disk_resize_journal, struct bch_ioctl_disk_resize_journal);
731 case BCH_IOCTL_FSCK_ONLINE:
732 BCH_IOCTL(fsck_online, struct bch_ioctl_fsck_online);
733 case BCH_IOCTL_QUERY_ACCOUNTING:
734 return bch2_ioctl_query_accounting(c, arg);
735 case BCH_IOCTL_QUERY_COUNTERS:
736 return bch2_ioctl_query_counters(c, arg);
737 default:
738 return -ENOTTY;
739 }
740 out:
741 if (ret < 0)
742 ret = bch2_err_class(ret);
743 return ret;
744 }
745
746 static DEFINE_IDR(bch_chardev_minor);
747
bch2_chardev_ioctl(struct file * filp,unsigned cmd,unsigned long v)748 static long bch2_chardev_ioctl(struct file *filp, unsigned cmd, unsigned long v)
749 {
750 unsigned minor = iminor(file_inode(filp));
751 struct bch_fs *c = minor < U8_MAX ? idr_find(&bch_chardev_minor, minor) : NULL;
752 void __user *arg = (void __user *) v;
753
754 return c
755 ? bch2_fs_ioctl(c, cmd, arg)
756 : bch2_global_ioctl(cmd, arg);
757 }
758
759 static const struct file_operations bch_chardev_fops = {
760 .owner = THIS_MODULE,
761 .unlocked_ioctl = bch2_chardev_ioctl,
762 .open = nonseekable_open,
763 };
764
765 static int bch_chardev_major;
766 static const struct class bch_chardev_class = {
767 .name = "bcachefs",
768 };
769 static struct device *bch_chardev;
770
bch2_fs_chardev_exit(struct bch_fs * c)771 void bch2_fs_chardev_exit(struct bch_fs *c)
772 {
773 if (!IS_ERR_OR_NULL(c->chardev))
774 device_unregister(c->chardev);
775 if (c->minor >= 0)
776 idr_remove(&bch_chardev_minor, c->minor);
777 }
778
bch2_fs_chardev_init(struct bch_fs * c)779 int bch2_fs_chardev_init(struct bch_fs *c)
780 {
781 c->minor = idr_alloc(&bch_chardev_minor, c, 0, 0, GFP_KERNEL);
782 if (c->minor < 0)
783 return c->minor;
784
785 c->chardev = device_create(&bch_chardev_class, NULL,
786 MKDEV(bch_chardev_major, c->minor), c,
787 "bcachefs%u-ctl", c->minor);
788 if (IS_ERR(c->chardev))
789 return PTR_ERR(c->chardev);
790
791 return 0;
792 }
793
bch2_chardev_exit(void)794 void bch2_chardev_exit(void)
795 {
796 device_destroy(&bch_chardev_class, MKDEV(bch_chardev_major, U8_MAX));
797 class_unregister(&bch_chardev_class);
798 if (bch_chardev_major > 0)
799 unregister_chrdev(bch_chardev_major, "bcachefs");
800 }
801
bch2_chardev_init(void)802 int __init bch2_chardev_init(void)
803 {
804 int ret;
805
806 bch_chardev_major = register_chrdev(0, "bcachefs-ctl", &bch_chardev_fops);
807 if (bch_chardev_major < 0)
808 return bch_chardev_major;
809
810 ret = class_register(&bch_chardev_class);
811 if (ret)
812 goto major_out;
813
814 bch_chardev = device_create(&bch_chardev_class, NULL,
815 MKDEV(bch_chardev_major, U8_MAX),
816 NULL, "bcachefs-ctl");
817 if (IS_ERR(bch_chardev)) {
818 ret = PTR_ERR(bch_chardev);
819 goto class_out;
820 }
821
822 return 0;
823
824 class_out:
825 class_unregister(&bch_chardev_class);
826 major_out:
827 unregister_chrdev(bch_chardev_major, "bcachefs-ctl");
828 return ret;
829 }
830
831 #endif /* NO_BCACHEFS_CHARDEV */
832