blob: b96a49b37d663e747d1caec30add48c84fdda14e [file] [log] [blame]
Tejun Heo151060a2009-04-14 10:54:54 +09001/*
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>
Kent Overstreeta27bb332013-05-07 16:19:08 -070041#include <linux/aio.h>
Tejun Heo151060a2009-04-14 10:54:54 +090042#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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090048#include <linux/slab.h>
Tejun Heo151060a2009-04-14 10:54:54 +090049#include <linux/stat.h>
Paul Gortmaker143cb492011-07-01 14:23:34 -040050#include <linux/module.h>
Tejun Heo151060a2009-04-14 10:54:54 +090051
52#include "fuse_i.h"
53
54#define CUSE_CONNTBL_LEN 64
55
56struct 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
David Herrmann8ce03fd2012-11-17 12:45:47 +010066static DEFINE_MUTEX(cuse_lock); /* protects registration */
Tejun Heo151060a2009-04-14 10:54:54 +090067static struct list_head cuse_conntbl[CUSE_CONNTBL_LEN];
68static struct class *cuse_class;
69
70static struct cuse_conn *fc_to_cc(struct fuse_conn *fc)
71{
72 return container_of(fc, struct cuse_conn, fc);
73}
74
75static 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
91static ssize_t cuse_read(struct file *file, char __user *buf, size_t count,
92 loff_t *ppos)
93{
94 loff_t pos = 0;
Miklos Szeredifb05f412012-11-10 16:55:56 +010095 struct iovec iov = { .iov_base = buf, .iov_len = count };
Maxim Patlasov36cf66e2012-12-14 19:20:51 +040096 struct fuse_io_priv io = { .async = 0, .file = file };
Tejun Heo151060a2009-04-14 10:54:54 +090097
Maxim Patlasov36cf66e2012-12-14 19:20:51 +040098 return fuse_direct_io(&io, &iov, 1, count, &pos, 0);
Tejun Heo151060a2009-04-14 10:54:54 +090099}
100
101static ssize_t cuse_write(struct file *file, const char __user *buf,
102 size_t count, loff_t *ppos)
103{
104 loff_t pos = 0;
Miklos Szeredifb05f412012-11-10 16:55:56 +0100105 struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = count };
Maxim Patlasov36cf66e2012-12-14 19:20:51 +0400106 struct fuse_io_priv io = { .async = 0, .file = file };
Miklos Szeredifb05f412012-11-10 16:55:56 +0100107
Tejun Heo151060a2009-04-14 10:54:54 +0900108 /*
109 * No locking or generic_write_checks(), the server is
110 * responsible for locking and sanity checks.
111 */
Maxim Patlasov36cf66e2012-12-14 19:20:51 +0400112 return fuse_direct_io(&io, &iov, 1, count, &pos, 1);
Tejun Heo151060a2009-04-14 10:54:54 +0900113}
114
115static int cuse_open(struct inode *inode, struct file *file)
116{
117 dev_t devt = inode->i_cdev->dev;
118 struct cuse_conn *cc = NULL, *pos;
119 int rc;
120
121 /* look up and get the connection */
David Herrmann8ce03fd2012-11-17 12:45:47 +0100122 mutex_lock(&cuse_lock);
Tejun Heo151060a2009-04-14 10:54:54 +0900123 list_for_each_entry(pos, cuse_conntbl_head(devt), list)
124 if (pos->dev->devt == devt) {
125 fuse_conn_get(&pos->fc);
126 cc = pos;
127 break;
128 }
David Herrmann8ce03fd2012-11-17 12:45:47 +0100129 mutex_unlock(&cuse_lock);
Tejun Heo151060a2009-04-14 10:54:54 +0900130
131 /* dead? */
132 if (!cc)
133 return -ENODEV;
134
135 /*
136 * Generic permission check is already done against the chrdev
137 * file, proceed to open.
138 */
139 rc = fuse_do_open(&cc->fc, 0, file, 0);
140 if (rc)
141 fuse_conn_put(&cc->fc);
142 return rc;
143}
144
145static int cuse_release(struct inode *inode, struct file *file)
146{
147 struct fuse_file *ff = file->private_data;
148 struct fuse_conn *fc = ff->fc;
149
150 fuse_sync_release(ff, file->f_flags);
151 fuse_conn_put(fc);
152
153 return 0;
154}
155
156static long cuse_file_ioctl(struct file *file, unsigned int cmd,
157 unsigned long arg)
158{
159 struct fuse_file *ff = file->private_data;
160 struct cuse_conn *cc = fc_to_cc(ff->fc);
161 unsigned int flags = 0;
162
163 if (cc->unrestricted_ioctl)
164 flags |= FUSE_IOCTL_UNRESTRICTED;
165
166 return fuse_do_ioctl(file, cmd, arg, flags);
167}
168
169static long cuse_file_compat_ioctl(struct file *file, unsigned int cmd,
170 unsigned long arg)
171{
172 struct fuse_file *ff = file->private_data;
173 struct cuse_conn *cc = fc_to_cc(ff->fc);
174 unsigned int flags = FUSE_IOCTL_COMPAT;
175
176 if (cc->unrestricted_ioctl)
177 flags |= FUSE_IOCTL_UNRESTRICTED;
178
179 return fuse_do_ioctl(file, cmd, arg, flags);
180}
181
182static const struct file_operations cuse_frontend_fops = {
183 .owner = THIS_MODULE,
184 .read = cuse_read,
185 .write = cuse_write,
186 .open = cuse_open,
187 .release = cuse_release,
188 .unlocked_ioctl = cuse_file_ioctl,
189 .compat_ioctl = cuse_file_compat_ioctl,
190 .poll = fuse_file_poll,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200191 .llseek = noop_llseek,
Tejun Heo151060a2009-04-14 10:54:54 +0900192};
193
194
195/**************************************************************************
196 * CUSE channel initialization and destruction
197 */
198
199struct cuse_devinfo {
200 const char *name;
201};
202
203/**
204 * cuse_parse_one - parse one key=value pair
205 * @pp: i/o parameter for the current position
206 * @end: points to one past the end of the packed string
207 * @keyp: out parameter for key
208 * @valp: out parameter for value
209 *
210 * *@pp points to packed strings - "key0=val0\0key1=val1\0" which ends
211 * at @end - 1. This function parses one pair and set *@keyp to the
212 * start of the key and *@valp to the start of the value. Note that
213 * the original string is modified such that the key string is
214 * terminated with '\0'. *@pp is updated to point to the next string.
215 *
216 * RETURNS:
217 * 1 on successful parse, 0 on EOF, -errno on failure.
218 */
219static int cuse_parse_one(char **pp, char *end, char **keyp, char **valp)
220{
221 char *p = *pp;
222 char *key, *val;
223
224 while (p < end && *p == '\0')
225 p++;
226 if (p == end)
227 return 0;
228
229 if (end[-1] != '\0') {
230 printk(KERN_ERR "CUSE: info not properly terminated\n");
231 return -EINVAL;
232 }
233
234 key = val = p;
235 p += strlen(p);
236
237 if (valp) {
238 strsep(&val, "=");
239 if (!val)
240 val = key + strlen(key);
241 key = strstrip(key);
242 val = strstrip(val);
243 } else
244 key = strstrip(key);
245
246 if (!strlen(key)) {
247 printk(KERN_ERR "CUSE: zero length info key specified\n");
248 return -EINVAL;
249 }
250
251 *pp = p;
252 *keyp = key;
253 if (valp)
254 *valp = val;
255
256 return 1;
257}
258
259/**
260 * cuse_parse_dev_info - parse device info
261 * @p: device info string
262 * @len: length of device info string
263 * @devinfo: out parameter for parsed device info
264 *
265 * Parse @p to extract device info and store it into @devinfo. String
266 * pointed to by @p is modified by parsing and @devinfo points into
267 * them, so @p shouldn't be freed while @devinfo is in use.
268 *
269 * RETURNS:
270 * 0 on success, -errno on failure.
271 */
272static int cuse_parse_devinfo(char *p, size_t len, struct cuse_devinfo *devinfo)
273{
274 char *end = p + len;
Miklos Szeredie2560362013-01-15 12:24:46 +0100275 char *uninitialized_var(key), *uninitialized_var(val);
Tejun Heo151060a2009-04-14 10:54:54 +0900276 int rc;
277
278 while (true) {
279 rc = cuse_parse_one(&p, end, &key, &val);
280 if (rc < 0)
281 return rc;
282 if (!rc)
283 break;
284 if (strcmp(key, "DEVNAME") == 0)
285 devinfo->name = val;
286 else
287 printk(KERN_WARNING "CUSE: unknown device info \"%s\"\n",
288 key);
289 }
290
291 if (!devinfo->name || !strlen(devinfo->name)) {
292 printk(KERN_ERR "CUSE: DEVNAME unspecified\n");
293 return -EINVAL;
294 }
295
296 return 0;
297}
298
299static void cuse_gendev_release(struct device *dev)
300{
301 kfree(dev);
302}
303
304/**
305 * cuse_process_init_reply - finish initializing CUSE channel
306 *
307 * This function creates the character device and sets up all the
308 * required data structures for it. Please read the comment at the
309 * top of this file for high level overview.
310 */
311static void cuse_process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
312{
David Herrmann30783582012-11-17 12:45:48 +0100313 struct cuse_conn *cc = fc_to_cc(fc), *pos;
Miklos Szeredi07d5f692011-03-21 13:58:05 +0100314 struct cuse_init_out *arg = req->out.args[0].value;
Tejun Heo151060a2009-04-14 10:54:54 +0900315 struct page *page = req->pages[0];
316 struct cuse_devinfo devinfo = { };
317 struct device *dev;
318 struct cdev *cdev;
319 dev_t devt;
David Herrmann30783582012-11-17 12:45:48 +0100320 int rc, i;
Tejun Heo151060a2009-04-14 10:54:54 +0900321
322 if (req->out.h.error ||
323 arg->major != FUSE_KERNEL_VERSION || arg->minor < 11) {
324 goto err;
325 }
326
327 fc->minor = arg->minor;
328 fc->max_read = max_t(unsigned, arg->max_read, 4096);
329 fc->max_write = max_t(unsigned, arg->max_write, 4096);
330
331 /* parse init reply */
332 cc->unrestricted_ioctl = arg->flags & CUSE_UNRESTRICTED_IOCTL;
333
334 rc = cuse_parse_devinfo(page_address(page), req->out.args[1].size,
335 &devinfo);
336 if (rc)
337 goto err;
338
339 /* determine and reserve devt */
340 devt = MKDEV(arg->dev_major, arg->dev_minor);
341 if (!MAJOR(devt))
342 rc = alloc_chrdev_region(&devt, MINOR(devt), 1, devinfo.name);
343 else
344 rc = register_chrdev_region(devt, 1, devinfo.name);
345 if (rc) {
346 printk(KERN_ERR "CUSE: failed to register chrdev region\n");
347 goto err;
348 }
349
350 /* devt determined, create device */
351 rc = -ENOMEM;
352 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
353 if (!dev)
354 goto err_region;
355
356 device_initialize(dev);
357 dev_set_uevent_suppress(dev, 1);
358 dev->class = cuse_class;
359 dev->devt = devt;
360 dev->release = cuse_gendev_release;
361 dev_set_drvdata(dev, cc);
362 dev_set_name(dev, "%s", devinfo.name);
363
David Herrmann30783582012-11-17 12:45:48 +0100364 mutex_lock(&cuse_lock);
365
366 /* make sure the device-name is unique */
367 for (i = 0; i < CUSE_CONNTBL_LEN; ++i) {
368 list_for_each_entry(pos, &cuse_conntbl[i], list)
369 if (!strcmp(dev_name(pos->dev), dev_name(dev)))
370 goto err_unlock;
371 }
372
Tejun Heo151060a2009-04-14 10:54:54 +0900373 rc = device_add(dev);
374 if (rc)
David Herrmann30783582012-11-17 12:45:48 +0100375 goto err_unlock;
Tejun Heo151060a2009-04-14 10:54:54 +0900376
377 /* register cdev */
378 rc = -ENOMEM;
379 cdev = cdev_alloc();
380 if (!cdev)
David Herrmann30783582012-11-17 12:45:48 +0100381 goto err_unlock;
Tejun Heo151060a2009-04-14 10:54:54 +0900382
383 cdev->owner = THIS_MODULE;
384 cdev->ops = &cuse_frontend_fops;
385
386 rc = cdev_add(cdev, devt, 1);
387 if (rc)
388 goto err_cdev;
389
390 cc->dev = dev;
391 cc->cdev = cdev;
392
393 /* make the device available */
Tejun Heo151060a2009-04-14 10:54:54 +0900394 list_add(&cc->list, cuse_conntbl_head(devt));
David Herrmann8ce03fd2012-11-17 12:45:47 +0100395 mutex_unlock(&cuse_lock);
Tejun Heo151060a2009-04-14 10:54:54 +0900396
397 /* announce device availability */
398 dev_set_uevent_suppress(dev, 0);
399 kobject_uevent(&dev->kobj, KOBJ_ADD);
400out:
Miklos Szeredi07d5f692011-03-21 13:58:05 +0100401 kfree(arg);
Tejun Heo151060a2009-04-14 10:54:54 +0900402 __free_page(page);
403 return;
404
405err_cdev:
406 cdev_del(cdev);
David Herrmann30783582012-11-17 12:45:48 +0100407err_unlock:
408 mutex_unlock(&cuse_lock);
Tejun Heo151060a2009-04-14 10:54:54 +0900409 put_device(dev);
410err_region:
411 unregister_chrdev_region(devt, 1);
412err:
Miklos Szeredi8d39d8012012-08-30 19:24:35 +0200413 fuse_conn_kill(fc);
Tejun Heo151060a2009-04-14 10:54:54 +0900414 goto out;
415}
416
417static int cuse_send_init(struct cuse_conn *cc)
418{
419 int rc;
420 struct fuse_req *req;
421 struct page *page;
422 struct fuse_conn *fc = &cc->fc;
423 struct cuse_init_in *arg;
Miklos Szeredi07d5f692011-03-21 13:58:05 +0100424 void *outarg;
Tejun Heo151060a2009-04-14 10:54:54 +0900425
426 BUILD_BUG_ON(CUSE_INIT_INFO_MAX > PAGE_SIZE);
427
Maxim Patlasov8b41e672013-03-21 18:02:04 +0400428 req = fuse_get_req_for_background(fc, 1);
Tejun Heo151060a2009-04-14 10:54:54 +0900429 if (IS_ERR(req)) {
430 rc = PTR_ERR(req);
431 goto err;
432 }
433
434 rc = -ENOMEM;
435 page = alloc_page(GFP_KERNEL | __GFP_ZERO);
436 if (!page)
437 goto err_put_req;
438
Miklos Szeredi07d5f692011-03-21 13:58:05 +0100439 outarg = kzalloc(sizeof(struct cuse_init_out), GFP_KERNEL);
440 if (!outarg)
441 goto err_free_page;
442
Tejun Heo151060a2009-04-14 10:54:54 +0900443 arg = &req->misc.cuse_init_in;
444 arg->major = FUSE_KERNEL_VERSION;
445 arg->minor = FUSE_KERNEL_MINOR_VERSION;
446 arg->flags |= CUSE_UNRESTRICTED_IOCTL;
447 req->in.h.opcode = CUSE_INIT;
448 req->in.numargs = 1;
449 req->in.args[0].size = sizeof(struct cuse_init_in);
450 req->in.args[0].value = arg;
451 req->out.numargs = 2;
452 req->out.args[0].size = sizeof(struct cuse_init_out);
Miklos Szeredi07d5f692011-03-21 13:58:05 +0100453 req->out.args[0].value = outarg;
Tejun Heo151060a2009-04-14 10:54:54 +0900454 req->out.args[1].size = CUSE_INIT_INFO_MAX;
455 req->out.argvar = 1;
456 req->out.argpages = 1;
457 req->pages[0] = page;
Maxim Patlasov85f40ae2012-10-26 19:49:33 +0400458 req->page_descs[0].length = req->out.args[1].size;
Tejun Heo151060a2009-04-14 10:54:54 +0900459 req->num_pages = 1;
460 req->end = cuse_process_init_reply;
461 fuse_request_send_background(fc, req);
462
463 return 0;
464
Miklos Szeredi07d5f692011-03-21 13:58:05 +0100465err_free_page:
466 __free_page(page);
Tejun Heo151060a2009-04-14 10:54:54 +0900467err_put_req:
468 fuse_put_request(fc, req);
469err:
470 return rc;
471}
472
473static void cuse_fc_release(struct fuse_conn *fc)
474{
475 struct cuse_conn *cc = fc_to_cc(fc);
Al Virodd3e2c52013-10-03 21:21:39 -0400476 kfree_rcu(cc, fc.rcu);
Tejun Heo151060a2009-04-14 10:54:54 +0900477}
478
479/**
480 * cuse_channel_open - open method for /dev/cuse
481 * @inode: inode for /dev/cuse
482 * @file: file struct being opened
483 *
484 * Userland CUSE server can create a CUSE device by opening /dev/cuse
Paul Bolle8272f4c2011-02-15 00:05:34 +0100485 * and replying to the initialization request kernel sends. This
Tejun Heo151060a2009-04-14 10:54:54 +0900486 * function is responsible for handling CUSE device initialization.
487 * Because the fd opened by this function is used during
488 * initialization, this function only creates cuse_conn and sends
489 * init. The rest is delegated to a kthread.
490 *
491 * RETURNS:
492 * 0 on success, -errno on failure.
493 */
494static int cuse_channel_open(struct inode *inode, struct file *file)
495{
496 struct cuse_conn *cc;
497 int rc;
498
499 /* set up cuse_conn */
500 cc = kzalloc(sizeof(*cc), GFP_KERNEL);
501 if (!cc)
502 return -ENOMEM;
503
504 fuse_conn_init(&cc->fc);
505
506 INIT_LIST_HEAD(&cc->list);
507 cc->fc.release = cuse_fc_release;
508
509 cc->fc.connected = 1;
Maxim Patlasov796523fb2013-03-21 18:02:15 +0400510 cc->fc.initialized = 1;
Tejun Heo151060a2009-04-14 10:54:54 +0900511 rc = cuse_send_init(cc);
512 if (rc) {
513 fuse_conn_put(&cc->fc);
514 return rc;
515 }
516 file->private_data = &cc->fc; /* channel owns base reference to cc */
517
518 return 0;
519}
520
521/**
522 * cuse_channel_release - release method for /dev/cuse
523 * @inode: inode for /dev/cuse
524 * @file: file struct being closed
525 *
526 * Disconnect the channel, deregister CUSE device and initiate
527 * destruction by putting the default reference.
528 *
529 * RETURNS:
530 * 0 on success, -errno on failure.
531 */
532static int cuse_channel_release(struct inode *inode, struct file *file)
533{
534 struct cuse_conn *cc = fc_to_cc(file->private_data);
535 int rc;
536
537 /* remove from the conntbl, no more access from this point on */
David Herrmann8ce03fd2012-11-17 12:45:47 +0100538 mutex_lock(&cuse_lock);
Tejun Heo151060a2009-04-14 10:54:54 +0900539 list_del_init(&cc->list);
David Herrmann8ce03fd2012-11-17 12:45:47 +0100540 mutex_unlock(&cuse_lock);
Tejun Heo151060a2009-04-14 10:54:54 +0900541
542 /* remove device */
543 if (cc->dev)
544 device_unregister(cc->dev);
545 if (cc->cdev) {
546 unregister_chrdev_region(cc->cdev->dev, 1);
547 cdev_del(cc->cdev);
548 }
549
Tejun Heo151060a2009-04-14 10:54:54 +0900550 rc = fuse_dev_release(inode, file); /* puts the base reference */
551
552 return rc;
553}
554
555static struct file_operations cuse_channel_fops; /* initialized during init */
556
557
558/**************************************************************************
559 * Misc stuff and module initializatiion
560 *
561 * CUSE exports the same set of attributes to sysfs as fusectl.
562 */
563
564static ssize_t cuse_class_waiting_show(struct device *dev,
565 struct device_attribute *attr, char *buf)
566{
567 struct cuse_conn *cc = dev_get_drvdata(dev);
568
569 return sprintf(buf, "%d\n", atomic_read(&cc->fc.num_waiting));
570}
Greg Kroah-Hartman4183fb92013-07-24 15:05:24 -0700571static DEVICE_ATTR(waiting, S_IFREG | 0400, cuse_class_waiting_show, NULL);
Tejun Heo151060a2009-04-14 10:54:54 +0900572
573static ssize_t cuse_class_abort_store(struct device *dev,
574 struct device_attribute *attr,
575 const char *buf, size_t count)
576{
577 struct cuse_conn *cc = dev_get_drvdata(dev);
578
579 fuse_abort_conn(&cc->fc);
580 return count;
581}
Greg Kroah-Hartman4183fb92013-07-24 15:05:24 -0700582static DEVICE_ATTR(abort, S_IFREG | 0200, NULL, cuse_class_abort_store);
Tejun Heo151060a2009-04-14 10:54:54 +0900583
Greg Kroah-Hartman4183fb92013-07-24 15:05:24 -0700584static struct attribute *cuse_class_dev_attrs[] = {
585 &dev_attr_waiting.attr,
586 &dev_attr_abort.attr,
587 NULL,
Tejun Heo151060a2009-04-14 10:54:54 +0900588};
Greg Kroah-Hartman4183fb92013-07-24 15:05:24 -0700589ATTRIBUTE_GROUPS(cuse_class_dev);
Tejun Heo151060a2009-04-14 10:54:54 +0900590
591static struct miscdevice cuse_miscdev = {
Tom Gundersencb2ffb22013-09-09 20:18:27 +0200592 .minor = CUSE_MINOR,
Tejun Heo151060a2009-04-14 10:54:54 +0900593 .name = "cuse",
594 .fops = &cuse_channel_fops,
595};
596
Tom Gundersencb2ffb22013-09-09 20:18:27 +0200597MODULE_ALIAS_MISCDEV(CUSE_MINOR);
598MODULE_ALIAS("devname:cuse");
599
Tejun Heo151060a2009-04-14 10:54:54 +0900600static int __init cuse_init(void)
601{
602 int i, rc;
603
604 /* init conntbl */
605 for (i = 0; i < CUSE_CONNTBL_LEN; i++)
606 INIT_LIST_HEAD(&cuse_conntbl[i]);
607
608 /* inherit and extend fuse_dev_operations */
609 cuse_channel_fops = fuse_dev_operations;
610 cuse_channel_fops.owner = THIS_MODULE;
611 cuse_channel_fops.open = cuse_channel_open;
612 cuse_channel_fops.release = cuse_channel_release;
613
614 cuse_class = class_create(THIS_MODULE, "cuse");
615 if (IS_ERR(cuse_class))
616 return PTR_ERR(cuse_class);
617
Greg Kroah-Hartman4183fb92013-07-24 15:05:24 -0700618 cuse_class->dev_groups = cuse_class_dev_groups;
Tejun Heo151060a2009-04-14 10:54:54 +0900619
620 rc = misc_register(&cuse_miscdev);
621 if (rc) {
622 class_destroy(cuse_class);
623 return rc;
624 }
625
626 return 0;
627}
628
629static void __exit cuse_exit(void)
630{
631 misc_deregister(&cuse_miscdev);
632 class_destroy(cuse_class);
633}
634
635module_init(cuse_init);
636module_exit(cuse_exit);
637
638MODULE_AUTHOR("Tejun Heo <tj@kernel.org>");
639MODULE_DESCRIPTION("Character device in Userspace");
640MODULE_LICENSE("GPL");