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 enumerated_ref_put(&ctx->c->writes, BCH_WRITE_REF_ioctl_data);
323 return 0;
324 }
325
bch2_data_job_release(struct inode * inode,struct file * file)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
bch2_data_job_read(struct file * file,char __user * buf,size_t len,loff_t * ppos)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
bch2_ioctl_data(struct bch_fs * c,struct bch_ioctl_data arg)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
bch2_ioctl_fs_usage(struct bch_fs * c,struct bch_ioctl_fs_usage __user * user_arg)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
bch2_ioctl_query_accounting(struct bch_fs * c,struct bch_ioctl_query_accounting __user * user_arg)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: */
bch2_ioctl_dev_usage(struct bch_fs * c,struct bch_ioctl_dev_usage __user * user_arg)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
bch2_ioctl_dev_usage_v2(struct bch_fs * c,struct bch_ioctl_dev_usage_v2 __user * user_arg)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
bch2_ioctl_read_super(struct bch_fs * c,struct bch_ioctl_read_super arg)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
bch2_ioctl_disk_get_idx(struct bch_fs * c,struct bch_ioctl_disk_get_idx arg)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
bch2_ioctl_disk_resize(struct bch_fs * c,struct bch_ioctl_disk_resize arg)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
bch2_ioctl_disk_resize_journal(struct bch_fs * c,struct bch_ioctl_disk_resize_journal arg)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
bch2_fs_ioctl(struct bch_fs * c,unsigned cmd,void __user * arg)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
bch2_chardev_ioctl(struct file * filp,unsigned cmd,unsigned long v)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
bch2_fs_chardev_exit(struct bch_fs * c)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
bch2_fs_chardev_init(struct bch_fs * c)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
bch2_chardev_exit(void)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
bch2_chardev_init(void)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 */
844