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