1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * CUSE: Character device in Userspace |
4 | * |
5 | * Copyright (C) 2008-2009 SUSE Linux Products GmbH |
6 | * Copyright (C) 2008-2009 Tejun Heo <tj@kernel.org> |
7 | * |
8 | * CUSE enables character devices to be implemented from userland much |
9 | * like FUSE allows filesystems. On initialization /dev/cuse is |
10 | * created. By opening the file and replying to the CUSE_INIT request |
11 | * userland CUSE server can create a character device. After that the |
12 | * operation is very similar to FUSE. |
13 | * |
14 | * A CUSE instance involves the following objects. |
15 | * |
16 | * cuse_conn : contains fuse_conn and serves as bonding structure |
17 | * channel : file handle connected to the userland CUSE server |
18 | * cdev : the implemented character device |
19 | * dev : generic device for cdev |
20 | * |
21 | * Note that 'channel' is what 'dev' is in FUSE. As CUSE deals with |
22 | * devices, it's called 'channel' to reduce confusion. |
23 | * |
24 | * channel determines when the character device dies. When channel is |
25 | * closed, everything begins to destruct. The cuse_conn is taken off |
26 | * the lookup table preventing further access from cdev, cdev and |
27 | * generic device are removed and the base reference of cuse_conn is |
28 | * put. |
29 | * |
30 | * On each open, the matching cuse_conn is looked up and if found an |
31 | * additional reference is taken which is released when the file is |
32 | * closed. |
33 | */ |
34 | |
35 | #define pr_fmt(fmt) "CUSE: " fmt |
36 | |
37 | #include <linux/fuse.h> |
38 | #include <linux/cdev.h> |
39 | #include <linux/device.h> |
40 | #include <linux/file.h> |
41 | #include <linux/fs.h> |
42 | #include <linux/kdev_t.h> |
43 | #include <linux/kthread.h> |
44 | #include <linux/list.h> |
45 | #include <linux/magic.h> |
46 | #include <linux/miscdevice.h> |
47 | #include <linux/mutex.h> |
48 | #include <linux/slab.h> |
49 | #include <linux/stat.h> |
50 | #include <linux/module.h> |
51 | #include <linux/uio.h> |
52 | #include <linux/user_namespace.h> |
53 | |
54 | #include "fuse_i.h" |
55 | |
56 | #define CUSE_CONNTBL_LEN 64 |
57 | |
58 | struct cuse_conn { |
59 | struct list_head list; /* linked on cuse_conntbl */ |
60 | struct fuse_mount fm; /* Dummy mount referencing fc */ |
61 | struct fuse_conn fc; /* fuse connection */ |
62 | struct cdev *cdev; /* associated character device */ |
63 | struct device *dev; /* device representing @cdev */ |
64 | |
65 | /* init parameters, set once during initialization */ |
66 | bool unrestricted_ioctl; |
67 | }; |
68 | |
69 | static DEFINE_MUTEX(cuse_lock); /* protects registration */ |
70 | static struct list_head cuse_conntbl[CUSE_CONNTBL_LEN]; |
71 | static struct class *cuse_class; |
72 | |
73 | static struct cuse_conn *fc_to_cc(struct fuse_conn *fc) |
74 | { |
75 | return container_of(fc, struct cuse_conn, fc); |
76 | } |
77 | |
78 | static struct list_head *cuse_conntbl_head(dev_t devt) |
79 | { |
80 | return &cuse_conntbl[(MAJOR(devt) + MINOR(devt)) % CUSE_CONNTBL_LEN]; |
81 | } |
82 | |
83 | |
84 | /************************************************************************** |
85 | * CUSE frontend operations |
86 | * |
87 | * These are file operations for the character device. |
88 | * |
89 | * On open, CUSE opens a file from the FUSE mnt and stores it to |
90 | * private_data of the open file. All other ops call FUSE ops on the |
91 | * FUSE file. |
92 | */ |
93 | |
94 | static ssize_t cuse_read_iter(struct kiocb *kiocb, struct iov_iter *to) |
95 | { |
96 | struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(kiocb); |
97 | loff_t pos = 0; |
98 | |
99 | return fuse_direct_io(io: &io, iter: to, ppos: &pos, FUSE_DIO_CUSE); |
100 | } |
101 | |
102 | static ssize_t cuse_write_iter(struct kiocb *kiocb, struct iov_iter *from) |
103 | { |
104 | struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(kiocb); |
105 | loff_t pos = 0; |
106 | /* |
107 | * No locking or generic_write_checks(), the server is |
108 | * responsible for locking and sanity checks. |
109 | */ |
110 | return fuse_direct_io(io: &io, iter: from, ppos: &pos, |
111 | FUSE_DIO_WRITE | FUSE_DIO_CUSE); |
112 | } |
113 | |
114 | static int cuse_open(struct inode *inode, struct file *file) |
115 | { |
116 | dev_t devt = inode->i_cdev->dev; |
117 | struct cuse_conn *cc = NULL, *pos; |
118 | int rc; |
119 | |
120 | /* look up and get the connection */ |
121 | mutex_lock(&cuse_lock); |
122 | list_for_each_entry(pos, cuse_conntbl_head(devt), list) |
123 | if (pos->dev->devt == devt) { |
124 | fuse_conn_get(fc: &pos->fc); |
125 | cc = pos; |
126 | break; |
127 | } |
128 | mutex_unlock(lock: &cuse_lock); |
129 | |
130 | /* dead? */ |
131 | if (!cc) |
132 | return -ENODEV; |
133 | |
134 | /* |
135 | * Generic permission check is already done against the chrdev |
136 | * file, proceed to open. |
137 | */ |
138 | rc = fuse_do_open(fm: &cc->fm, nodeid: 0, file, isdir: 0); |
139 | if (rc) |
140 | fuse_conn_put(fc: &cc->fc); |
141 | return rc; |
142 | } |
143 | |
144 | static int cuse_release(struct inode *inode, struct file *file) |
145 | { |
146 | struct fuse_file *ff = file->private_data; |
147 | struct fuse_mount *fm = ff->fm; |
148 | |
149 | fuse_sync_release(NULL, ff, flags: file->f_flags); |
150 | fuse_conn_put(fc: fm->fc); |
151 | |
152 | return 0; |
153 | } |
154 | |
155 | static long cuse_file_ioctl(struct file *file, unsigned int cmd, |
156 | unsigned long arg) |
157 | { |
158 | struct fuse_file *ff = file->private_data; |
159 | struct cuse_conn *cc = fc_to_cc(fc: ff->fm->fc); |
160 | unsigned int flags = 0; |
161 | |
162 | if (cc->unrestricted_ioctl) |
163 | flags |= FUSE_IOCTL_UNRESTRICTED; |
164 | |
165 | return fuse_do_ioctl(file, cmd, arg, flags); |
166 | } |
167 | |
168 | static long cuse_file_compat_ioctl(struct file *file, unsigned int cmd, |
169 | unsigned long arg) |
170 | { |
171 | struct fuse_file *ff = file->private_data; |
172 | struct cuse_conn *cc = fc_to_cc(fc: ff->fm->fc); |
173 | unsigned int flags = FUSE_IOCTL_COMPAT; |
174 | |
175 | if (cc->unrestricted_ioctl) |
176 | flags |= FUSE_IOCTL_UNRESTRICTED; |
177 | |
178 | return fuse_do_ioctl(file, cmd, arg, flags); |
179 | } |
180 | |
181 | static const struct file_operations cuse_frontend_fops = { |
182 | .owner = THIS_MODULE, |
183 | .read_iter = cuse_read_iter, |
184 | .write_iter = cuse_write_iter, |
185 | .open = cuse_open, |
186 | .release = cuse_release, |
187 | .unlocked_ioctl = cuse_file_ioctl, |
188 | .compat_ioctl = cuse_file_compat_ioctl, |
189 | .poll = fuse_file_poll, |
190 | .llseek = noop_llseek, |
191 | }; |
192 | |
193 | |
194 | /************************************************************************** |
195 | * CUSE channel initialization and destruction |
196 | */ |
197 | |
198 | struct cuse_devinfo { |
199 | const char *name; |
200 | }; |
201 | |
202 | /** |
203 | * cuse_parse_one - parse one key=value pair |
204 | * @pp: i/o parameter for the current position |
205 | * @end: points to one past the end of the packed string |
206 | * @keyp: out parameter for key |
207 | * @valp: out parameter for value |
208 | * |
209 | * *@pp points to packed strings - "key0=val0\0key1=val1\0" which ends |
210 | * at @end - 1. This function parses one pair and set *@keyp to the |
211 | * start of the key and *@valp to the start of the value. Note that |
212 | * the original string is modified such that the key string is |
213 | * terminated with '\0'. *@pp is updated to point to the next string. |
214 | * |
215 | * RETURNS: |
216 | * 1 on successful parse, 0 on EOF, -errno on failure. |
217 | */ |
218 | static int cuse_parse_one(char **pp, char *end, char **keyp, char **valp) |
219 | { |
220 | char *p = *pp; |
221 | char *key, *val; |
222 | |
223 | while (p < end && *p == '\0') |
224 | p++; |
225 | if (p == end) |
226 | return 0; |
227 | |
228 | if (end[-1] != '\0') { |
229 | pr_err("info not properly terminated\n" ); |
230 | return -EINVAL; |
231 | } |
232 | |
233 | key = val = p; |
234 | p += strlen(p); |
235 | |
236 | if (valp) { |
237 | strsep(&val, "=" ); |
238 | if (!val) |
239 | val = key + strlen(key); |
240 | key = strstrip(str: key); |
241 | val = strstrip(str: val); |
242 | } else |
243 | key = strstrip(str: key); |
244 | |
245 | if (!strlen(key)) { |
246 | pr_err("zero length info key specified\n" ); |
247 | return -EINVAL; |
248 | } |
249 | |
250 | *pp = p; |
251 | *keyp = key; |
252 | if (valp) |
253 | *valp = val; |
254 | |
255 | return 1; |
256 | } |
257 | |
258 | /** |
259 | * cuse_parse_devinfo - parse device info |
260 | * @p: device info string |
261 | * @len: length of device info string |
262 | * @devinfo: out parameter for parsed device info |
263 | * |
264 | * Parse @p to extract device info and store it into @devinfo. String |
265 | * pointed to by @p is modified by parsing and @devinfo points into |
266 | * them, so @p shouldn't be freed while @devinfo is in use. |
267 | * |
268 | * RETURNS: |
269 | * 0 on success, -errno on failure. |
270 | */ |
271 | static int cuse_parse_devinfo(char *p, size_t len, struct cuse_devinfo *devinfo) |
272 | { |
273 | char *end = p + len; |
274 | char *key, *val; |
275 | int rc; |
276 | |
277 | while (true) { |
278 | rc = cuse_parse_one(pp: &p, end, keyp: &key, valp: &val); |
279 | if (rc < 0) |
280 | return rc; |
281 | if (!rc) |
282 | break; |
283 | if (strcmp(key, "DEVNAME" ) == 0) |
284 | devinfo->name = val; |
285 | else |
286 | pr_warn("unknown device info \"%s\"\n" , key); |
287 | } |
288 | |
289 | if (!devinfo->name || !strlen(devinfo->name)) { |
290 | pr_err("DEVNAME unspecified\n" ); |
291 | return -EINVAL; |
292 | } |
293 | |
294 | return 0; |
295 | } |
296 | |
297 | static void cuse_gendev_release(struct device *dev) |
298 | { |
299 | kfree(objp: dev); |
300 | } |
301 | |
302 | struct cuse_init_args { |
303 | struct fuse_args_pages ap; |
304 | struct cuse_init_in in; |
305 | struct cuse_init_out out; |
306 | struct page *page; |
307 | struct fuse_page_desc desc; |
308 | }; |
309 | |
310 | /** |
311 | * cuse_process_init_reply - finish initializing CUSE channel |
312 | * |
313 | * @fm: The fuse mount information containing the CUSE connection. |
314 | * @args: The arguments passed to the init reply. |
315 | * @error: The error code signifying if any error occurred during the process. |
316 | * |
317 | * This function creates the character device and sets up all the |
318 | * required data structures for it. Please read the comment at the |
319 | * top of this file for high level overview. |
320 | */ |
321 | static void cuse_process_init_reply(struct fuse_mount *fm, |
322 | struct fuse_args *args, int error) |
323 | { |
324 | struct fuse_conn *fc = fm->fc; |
325 | struct cuse_init_args *ia = container_of(args, typeof(*ia), ap.args); |
326 | struct fuse_args_pages *ap = &ia->ap; |
327 | struct cuse_conn *cc = fc_to_cc(fc), *pos; |
328 | struct cuse_init_out *arg = &ia->out; |
329 | struct page *page = ap->pages[0]; |
330 | struct cuse_devinfo devinfo = { }; |
331 | struct device *dev; |
332 | struct cdev *cdev; |
333 | dev_t devt; |
334 | int rc, i; |
335 | |
336 | if (error || arg->major != FUSE_KERNEL_VERSION || arg->minor < 11) |
337 | goto err; |
338 | |
339 | fc->minor = arg->minor; |
340 | fc->max_read = max_t(unsigned, arg->max_read, 4096); |
341 | fc->max_write = max_t(unsigned, arg->max_write, 4096); |
342 | |
343 | /* parse init reply */ |
344 | cc->unrestricted_ioctl = arg->flags & CUSE_UNRESTRICTED_IOCTL; |
345 | |
346 | rc = cuse_parse_devinfo(page_address(page), len: ap->args.out_args[1].size, |
347 | devinfo: &devinfo); |
348 | if (rc) |
349 | goto err; |
350 | |
351 | /* determine and reserve devt */ |
352 | devt = MKDEV(arg->dev_major, arg->dev_minor); |
353 | if (!MAJOR(devt)) |
354 | rc = alloc_chrdev_region(&devt, MINOR(devt), 1, devinfo.name); |
355 | else |
356 | rc = register_chrdev_region(devt, 1, devinfo.name); |
357 | if (rc) { |
358 | pr_err("failed to register chrdev region\n" ); |
359 | goto err; |
360 | } |
361 | |
362 | /* devt determined, create device */ |
363 | rc = -ENOMEM; |
364 | dev = kzalloc(size: sizeof(*dev), GFP_KERNEL); |
365 | if (!dev) |
366 | goto err_region; |
367 | |
368 | device_initialize(dev); |
369 | dev_set_uevent_suppress(dev, val: 1); |
370 | dev->class = cuse_class; |
371 | dev->devt = devt; |
372 | dev->release = cuse_gendev_release; |
373 | dev_set_drvdata(dev, data: cc); |
374 | dev_set_name(dev, name: "%s" , devinfo.name); |
375 | |
376 | mutex_lock(&cuse_lock); |
377 | |
378 | /* make sure the device-name is unique */ |
379 | for (i = 0; i < CUSE_CONNTBL_LEN; ++i) { |
380 | list_for_each_entry(pos, &cuse_conntbl[i], list) |
381 | if (!strcmp(dev_name(dev: pos->dev), dev_name(dev))) |
382 | goto err_unlock; |
383 | } |
384 | |
385 | rc = device_add(dev); |
386 | if (rc) |
387 | goto err_unlock; |
388 | |
389 | /* register cdev */ |
390 | rc = -ENOMEM; |
391 | cdev = cdev_alloc(); |
392 | if (!cdev) |
393 | goto err_unlock; |
394 | |
395 | cdev->owner = THIS_MODULE; |
396 | cdev->ops = &cuse_frontend_fops; |
397 | |
398 | rc = cdev_add(cdev, devt, 1); |
399 | if (rc) |
400 | goto err_cdev; |
401 | |
402 | cc->dev = dev; |
403 | cc->cdev = cdev; |
404 | |
405 | /* make the device available */ |
406 | list_add(new: &cc->list, head: cuse_conntbl_head(devt)); |
407 | mutex_unlock(lock: &cuse_lock); |
408 | |
409 | /* announce device availability */ |
410 | dev_set_uevent_suppress(dev, val: 0); |
411 | kobject_uevent(kobj: &dev->kobj, action: KOBJ_ADD); |
412 | out: |
413 | kfree(objp: ia); |
414 | __free_page(page); |
415 | return; |
416 | |
417 | err_cdev: |
418 | cdev_del(cdev); |
419 | err_unlock: |
420 | mutex_unlock(lock: &cuse_lock); |
421 | put_device(dev); |
422 | err_region: |
423 | unregister_chrdev_region(devt, 1); |
424 | err: |
425 | fuse_abort_conn(fc); |
426 | goto out; |
427 | } |
428 | |
429 | static int cuse_send_init(struct cuse_conn *cc) |
430 | { |
431 | int rc; |
432 | struct page *page; |
433 | struct fuse_mount *fm = &cc->fm; |
434 | struct cuse_init_args *ia; |
435 | struct fuse_args_pages *ap; |
436 | |
437 | BUILD_BUG_ON(CUSE_INIT_INFO_MAX > PAGE_SIZE); |
438 | |
439 | rc = -ENOMEM; |
440 | page = alloc_page(GFP_KERNEL | __GFP_ZERO); |
441 | if (!page) |
442 | goto err; |
443 | |
444 | ia = kzalloc(size: sizeof(*ia), GFP_KERNEL); |
445 | if (!ia) |
446 | goto err_free_page; |
447 | |
448 | ap = &ia->ap; |
449 | ia->in.major = FUSE_KERNEL_VERSION; |
450 | ia->in.minor = FUSE_KERNEL_MINOR_VERSION; |
451 | ia->in.flags |= CUSE_UNRESTRICTED_IOCTL; |
452 | ap->args.opcode = CUSE_INIT; |
453 | ap->args.in_numargs = 1; |
454 | ap->args.in_args[0].size = sizeof(ia->in); |
455 | ap->args.in_args[0].value = &ia->in; |
456 | ap->args.out_numargs = 2; |
457 | ap->args.out_args[0].size = sizeof(ia->out); |
458 | ap->args.out_args[0].value = &ia->out; |
459 | ap->args.out_args[1].size = CUSE_INIT_INFO_MAX; |
460 | ap->args.out_argvar = true; |
461 | ap->args.out_pages = true; |
462 | ap->num_pages = 1; |
463 | ap->pages = &ia->page; |
464 | ap->descs = &ia->desc; |
465 | ia->page = page; |
466 | ia->desc.length = ap->args.out_args[1].size; |
467 | ap->args.end = cuse_process_init_reply; |
468 | |
469 | rc = fuse_simple_background(fm, args: &ap->args, GFP_KERNEL); |
470 | if (rc) { |
471 | kfree(objp: ia); |
472 | err_free_page: |
473 | __free_page(page); |
474 | } |
475 | err: |
476 | return rc; |
477 | } |
478 | |
479 | static void cuse_fc_release(struct fuse_conn *fc) |
480 | { |
481 | kfree(objp: fc_to_cc(fc)); |
482 | } |
483 | |
484 | /** |
485 | * cuse_channel_open - open method for /dev/cuse |
486 | * @inode: inode for /dev/cuse |
487 | * @file: file struct being opened |
488 | * |
489 | * Userland CUSE server can create a CUSE device by opening /dev/cuse |
490 | * and replying to the initialization request kernel sends. This |
491 | * function is responsible for handling CUSE device initialization. |
492 | * Because the fd opened by this function is used during |
493 | * initialization, this function only creates cuse_conn and sends |
494 | * init. The rest is delegated to a kthread. |
495 | * |
496 | * RETURNS: |
497 | * 0 on success, -errno on failure. |
498 | */ |
499 | static int cuse_channel_open(struct inode *inode, struct file *file) |
500 | { |
501 | struct fuse_dev *fud; |
502 | struct cuse_conn *cc; |
503 | int rc; |
504 | |
505 | /* set up cuse_conn */ |
506 | cc = kzalloc(size: sizeof(*cc), GFP_KERNEL); |
507 | if (!cc) |
508 | return -ENOMEM; |
509 | |
510 | /* |
511 | * Limit the cuse channel to requests that can |
512 | * be represented in file->f_cred->user_ns. |
513 | */ |
514 | fuse_conn_init(fc: &cc->fc, fm: &cc->fm, user_ns: file->f_cred->user_ns, |
515 | fiq_ops: &fuse_dev_fiq_ops, NULL); |
516 | |
517 | cc->fc.release = cuse_fc_release; |
518 | fud = fuse_dev_alloc_install(fc: &cc->fc); |
519 | fuse_conn_put(fc: &cc->fc); |
520 | if (!fud) |
521 | return -ENOMEM; |
522 | |
523 | INIT_LIST_HEAD(list: &cc->list); |
524 | |
525 | cc->fc.initialized = 1; |
526 | rc = cuse_send_init(cc); |
527 | if (rc) { |
528 | fuse_dev_free(fud); |
529 | return rc; |
530 | } |
531 | file->private_data = fud; |
532 | |
533 | return 0; |
534 | } |
535 | |
536 | /** |
537 | * cuse_channel_release - release method for /dev/cuse |
538 | * @inode: inode for /dev/cuse |
539 | * @file: file struct being closed |
540 | * |
541 | * Disconnect the channel, deregister CUSE device and initiate |
542 | * destruction by putting the default reference. |
543 | * |
544 | * RETURNS: |
545 | * 0 on success, -errno on failure. |
546 | */ |
547 | static int cuse_channel_release(struct inode *inode, struct file *file) |
548 | { |
549 | struct fuse_dev *fud = file->private_data; |
550 | struct cuse_conn *cc = fc_to_cc(fc: fud->fc); |
551 | |
552 | /* remove from the conntbl, no more access from this point on */ |
553 | mutex_lock(&cuse_lock); |
554 | list_del_init(entry: &cc->list); |
555 | mutex_unlock(lock: &cuse_lock); |
556 | |
557 | /* remove device */ |
558 | if (cc->dev) |
559 | device_unregister(dev: cc->dev); |
560 | if (cc->cdev) { |
561 | unregister_chrdev_region(cc->cdev->dev, 1); |
562 | cdev_del(cc->cdev); |
563 | } |
564 | |
565 | return fuse_dev_release(inode, file); |
566 | } |
567 | |
568 | static struct file_operations cuse_channel_fops; /* initialized during init */ |
569 | |
570 | |
571 | /************************************************************************** |
572 | * Misc stuff and module initializatiion |
573 | * |
574 | * CUSE exports the same set of attributes to sysfs as fusectl. |
575 | */ |
576 | |
577 | static ssize_t cuse_class_waiting_show(struct device *dev, |
578 | struct device_attribute *attr, char *buf) |
579 | { |
580 | struct cuse_conn *cc = dev_get_drvdata(dev); |
581 | |
582 | return sprintf(buf, fmt: "%d\n" , atomic_read(v: &cc->fc.num_waiting)); |
583 | } |
584 | static DEVICE_ATTR(waiting, 0400, cuse_class_waiting_show, NULL); |
585 | |
586 | static ssize_t cuse_class_abort_store(struct device *dev, |
587 | struct device_attribute *attr, |
588 | const char *buf, size_t count) |
589 | { |
590 | struct cuse_conn *cc = dev_get_drvdata(dev); |
591 | |
592 | fuse_abort_conn(fc: &cc->fc); |
593 | return count; |
594 | } |
595 | static DEVICE_ATTR(abort, 0200, NULL, cuse_class_abort_store); |
596 | |
597 | static struct attribute *cuse_class_dev_attrs[] = { |
598 | &dev_attr_waiting.attr, |
599 | &dev_attr_abort.attr, |
600 | NULL, |
601 | }; |
602 | ATTRIBUTE_GROUPS(cuse_class_dev); |
603 | |
604 | static struct miscdevice cuse_miscdev = { |
605 | .minor = CUSE_MINOR, |
606 | .name = "cuse" , |
607 | .fops = &cuse_channel_fops, |
608 | }; |
609 | |
610 | MODULE_ALIAS_MISCDEV(CUSE_MINOR); |
611 | MODULE_ALIAS("devname:cuse" ); |
612 | |
613 | static int __init cuse_init(void) |
614 | { |
615 | int i, rc; |
616 | |
617 | /* init conntbl */ |
618 | for (i = 0; i < CUSE_CONNTBL_LEN; i++) |
619 | INIT_LIST_HEAD(list: &cuse_conntbl[i]); |
620 | |
621 | /* inherit and extend fuse_dev_operations */ |
622 | cuse_channel_fops = fuse_dev_operations; |
623 | cuse_channel_fops.owner = THIS_MODULE; |
624 | cuse_channel_fops.open = cuse_channel_open; |
625 | cuse_channel_fops.release = cuse_channel_release; |
626 | /* CUSE is not prepared for FUSE_DEV_IOC_CLONE */ |
627 | cuse_channel_fops.unlocked_ioctl = NULL; |
628 | |
629 | cuse_class = class_create(name: "cuse" ); |
630 | if (IS_ERR(ptr: cuse_class)) |
631 | return PTR_ERR(ptr: cuse_class); |
632 | |
633 | cuse_class->dev_groups = cuse_class_dev_groups; |
634 | |
635 | rc = misc_register(misc: &cuse_miscdev); |
636 | if (rc) { |
637 | class_destroy(cls: cuse_class); |
638 | return rc; |
639 | } |
640 | |
641 | return 0; |
642 | } |
643 | |
644 | static void __exit cuse_exit(void) |
645 | { |
646 | misc_deregister(misc: &cuse_miscdev); |
647 | class_destroy(cls: cuse_class); |
648 | } |
649 | |
650 | module_init(cuse_init); |
651 | module_exit(cuse_exit); |
652 | |
653 | MODULE_AUTHOR("Tejun Heo <tj@kernel.org>" ); |
654 | MODULE_DESCRIPTION("Character device in Userspace" ); |
655 | MODULE_LICENSE("GPL" ); |
656 | |