2 * CUSE: Character device in Userspace
4 * Copyright (C) 2008-2009 SUSE Linux Products GmbH
5 * Copyright (C) 2008-2009 Tejun Heo <tj@kernel.org>
7 * This file is released under the GPLv2.
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.
15 * A CUSE instance involves the following objects.
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
22 * Note that 'channel' is what 'dev' is in FUSE. As CUSE deals with
23 * devices, it's called 'channel' to reduce confusion.
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
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
36 #include <linux/fuse.h>
37 #include <linux/cdev.h>
38 #include <linux/device.h>
39 #include <linux/file.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>
47 #include <linux/slab.h>
48 #include <linux/stat.h>
49 #include <linux/module.h>
53 #define CUSE_CONNTBL_LEN 64
56 struct list_head list
; /* linked on cuse_conntbl */
57 struct fuse_conn fc
; /* fuse connection */
58 struct cdev
*cdev
; /* associated character device */
59 struct device
*dev
; /* device representing @cdev */
61 /* init parameters, set once during initialization */
62 bool unrestricted_ioctl
;
65 static DEFINE_MUTEX(cuse_lock
); /* protects registration */
66 static struct list_head cuse_conntbl
[CUSE_CONNTBL_LEN
];
67 static struct class *cuse_class
;
69 static struct cuse_conn
*fc_to_cc(struct fuse_conn
*fc
)
71 return container_of(fc
, struct cuse_conn
, fc
);
74 static struct list_head
*cuse_conntbl_head(dev_t devt
)
76 return &cuse_conntbl
[(MAJOR(devt
) + MINOR(devt
)) % CUSE_CONNTBL_LEN
];
80 /**************************************************************************
81 * CUSE frontend operations
83 * These are file operations for the character device.
85 * On open, CUSE opens a file from the FUSE mnt and stores it to
86 * private_data of the open file. All other ops call FUSE ops on the
90 static ssize_t
cuse_read(struct file
*file
, char __user
*buf
, size_t count
,
94 struct iovec iov
= { .iov_base
= buf
, .iov_len
= count
};
96 return fuse_direct_io(file
, &iov
, 1, count
, &pos
, 0);
99 static ssize_t
cuse_write(struct file
*file
, const char __user
*buf
,
100 size_t count
, loff_t
*ppos
)
103 struct iovec iov
= { .iov_base
= (void __user
*)buf
, .iov_len
= count
};
106 * No locking or generic_write_checks(), the server is
107 * responsible for locking and sanity checks.
109 return fuse_direct_io(file
, &iov
, 1, count
, &pos
, 1);
112 static int cuse_open(struct inode
*inode
, struct file
*file
)
114 dev_t devt
= inode
->i_cdev
->dev
;
115 struct cuse_conn
*cc
= NULL
, *pos
;
118 /* look up and get the connection */
119 mutex_lock(&cuse_lock
);
120 list_for_each_entry(pos
, cuse_conntbl_head(devt
), list
)
121 if (pos
->dev
->devt
== devt
) {
122 fuse_conn_get(&pos
->fc
);
126 mutex_unlock(&cuse_lock
);
133 * Generic permission check is already done against the chrdev
134 * file, proceed to open.
136 rc
= fuse_do_open(&cc
->fc
, 0, file
, 0);
138 fuse_conn_put(&cc
->fc
);
142 static int cuse_release(struct inode
*inode
, struct file
*file
)
144 struct fuse_file
*ff
= file
->private_data
;
145 struct fuse_conn
*fc
= ff
->fc
;
147 fuse_sync_release(ff
, file
->f_flags
);
153 static long cuse_file_ioctl(struct file
*file
, unsigned int cmd
,
156 struct fuse_file
*ff
= file
->private_data
;
157 struct cuse_conn
*cc
= fc_to_cc(ff
->fc
);
158 unsigned int flags
= 0;
160 if (cc
->unrestricted_ioctl
)
161 flags
|= FUSE_IOCTL_UNRESTRICTED
;
163 return fuse_do_ioctl(file
, cmd
, arg
, flags
);
166 static long cuse_file_compat_ioctl(struct file
*file
, unsigned int cmd
,
169 struct fuse_file
*ff
= file
->private_data
;
170 struct cuse_conn
*cc
= fc_to_cc(ff
->fc
);
171 unsigned int flags
= FUSE_IOCTL_COMPAT
;
173 if (cc
->unrestricted_ioctl
)
174 flags
|= FUSE_IOCTL_UNRESTRICTED
;
176 return fuse_do_ioctl(file
, cmd
, arg
, flags
);
179 static const struct file_operations cuse_frontend_fops
= {
180 .owner
= THIS_MODULE
,
184 .release
= cuse_release
,
185 .unlocked_ioctl
= cuse_file_ioctl
,
186 .compat_ioctl
= cuse_file_compat_ioctl
,
187 .poll
= fuse_file_poll
,
188 .llseek
= noop_llseek
,
192 /**************************************************************************
193 * CUSE channel initialization and destruction
196 struct cuse_devinfo
{
201 * cuse_parse_one - parse one key=value pair
202 * @pp: i/o parameter for the current position
203 * @end: points to one past the end of the packed string
204 * @keyp: out parameter for key
205 * @valp: out parameter for value
207 * *@pp points to packed strings - "key0=val0\0key1=val1\0" which ends
208 * at @end - 1. This function parses one pair and set *@keyp to the
209 * start of the key and *@valp to the start of the value. Note that
210 * the original string is modified such that the key string is
211 * terminated with '\0'. *@pp is updated to point to the next string.
214 * 1 on successful parse, 0 on EOF, -errno on failure.
216 static int cuse_parse_one(char **pp
, char *end
, char **keyp
, char **valp
)
221 while (p
< end
&& *p
== '\0')
226 if (end
[-1] != '\0') {
227 printk(KERN_ERR
"CUSE: info not properly terminated\n");
237 val
= key
+ strlen(key
);
244 printk(KERN_ERR
"CUSE: zero length info key specified\n");
257 * cuse_parse_dev_info - parse device info
258 * @p: device info string
259 * @len: length of device info string
260 * @devinfo: out parameter for parsed device info
262 * Parse @p to extract device info and store it into @devinfo. String
263 * pointed to by @p is modified by parsing and @devinfo points into
264 * them, so @p shouldn't be freed while @devinfo is in use.
267 * 0 on success, -errno on failure.
269 static int cuse_parse_devinfo(char *p
, size_t len
, struct cuse_devinfo
*devinfo
)
272 char *uninitialized_var(key
), *uninitialized_var(val
);
276 rc
= cuse_parse_one(&p
, end
, &key
, &val
);
281 if (strcmp(key
, "DEVNAME") == 0)
284 printk(KERN_WARNING
"CUSE: unknown device info \"%s\"\n",
288 if (!devinfo
->name
|| !strlen(devinfo
->name
)) {
289 printk(KERN_ERR
"CUSE: DEVNAME unspecified\n");
296 static void cuse_gendev_release(struct device
*dev
)
302 * cuse_process_init_reply - finish initializing CUSE channel
304 * This function creates the character device and sets up all the
305 * required data structures for it. Please read the comment at the
306 * top of this file for high level overview.
308 static void cuse_process_init_reply(struct fuse_conn
*fc
, struct fuse_req
*req
)
310 struct cuse_conn
*cc
= fc_to_cc(fc
), *pos
;
311 struct cuse_init_out
*arg
= req
->out
.args
[0].value
;
312 struct page
*page
= req
->pages
[0];
313 struct cuse_devinfo devinfo
= { };
319 if (req
->out
.h
.error
||
320 arg
->major
!= FUSE_KERNEL_VERSION
|| arg
->minor
< 11) {
324 fc
->minor
= arg
->minor
;
325 fc
->max_read
= max_t(unsigned, arg
->max_read
, 4096);
326 fc
->max_write
= max_t(unsigned, arg
->max_write
, 4096);
328 /* parse init reply */
329 cc
->unrestricted_ioctl
= arg
->flags
& CUSE_UNRESTRICTED_IOCTL
;
331 rc
= cuse_parse_devinfo(page_address(page
), req
->out
.args
[1].size
,
336 /* determine and reserve devt */
337 devt
= MKDEV(arg
->dev_major
, arg
->dev_minor
);
339 rc
= alloc_chrdev_region(&devt
, MINOR(devt
), 1, devinfo
.name
);
341 rc
= register_chrdev_region(devt
, 1, devinfo
.name
);
343 printk(KERN_ERR
"CUSE: failed to register chrdev region\n");
347 /* devt determined, create device */
349 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
353 device_initialize(dev
);
354 dev_set_uevent_suppress(dev
, 1);
355 dev
->class = cuse_class
;
357 dev
->release
= cuse_gendev_release
;
358 dev_set_drvdata(dev
, cc
);
359 dev_set_name(dev
, "%s", devinfo
.name
);
361 mutex_lock(&cuse_lock
);
363 /* make sure the device-name is unique */
364 for (i
= 0; i
< CUSE_CONNTBL_LEN
; ++i
) {
365 list_for_each_entry(pos
, &cuse_conntbl
[i
], list
)
366 if (!strcmp(dev_name(pos
->dev
), dev_name(dev
)))
370 rc
= device_add(dev
);
380 cdev
->owner
= THIS_MODULE
;
381 cdev
->ops
= &cuse_frontend_fops
;
383 rc
= cdev_add(cdev
, devt
, 1);
390 /* make the device available */
391 list_add(&cc
->list
, cuse_conntbl_head(devt
));
392 mutex_unlock(&cuse_lock
);
394 /* announce device availability */
395 dev_set_uevent_suppress(dev
, 0);
396 kobject_uevent(&dev
->kobj
, KOBJ_ADD
);
405 mutex_unlock(&cuse_lock
);
408 unregister_chrdev_region(devt
, 1);
414 static int cuse_send_init(struct cuse_conn
*cc
)
417 struct fuse_req
*req
;
419 struct fuse_conn
*fc
= &cc
->fc
;
420 struct cuse_init_in
*arg
;
423 BUILD_BUG_ON(CUSE_INIT_INFO_MAX
> PAGE_SIZE
);
425 req
= fuse_get_req(fc
, 1);
432 page
= alloc_page(GFP_KERNEL
| __GFP_ZERO
);
436 outarg
= kzalloc(sizeof(struct cuse_init_out
), GFP_KERNEL
);
440 arg
= &req
->misc
.cuse_init_in
;
441 arg
->major
= FUSE_KERNEL_VERSION
;
442 arg
->minor
= FUSE_KERNEL_MINOR_VERSION
;
443 arg
->flags
|= CUSE_UNRESTRICTED_IOCTL
;
444 req
->in
.h
.opcode
= CUSE_INIT
;
446 req
->in
.args
[0].size
= sizeof(struct cuse_init_in
);
447 req
->in
.args
[0].value
= arg
;
448 req
->out
.numargs
= 2;
449 req
->out
.args
[0].size
= sizeof(struct cuse_init_out
);
450 req
->out
.args
[0].value
= outarg
;
451 req
->out
.args
[1].size
= CUSE_INIT_INFO_MAX
;
453 req
->out
.argpages
= 1;
454 req
->pages
[0] = page
;
455 req
->page_descs
[0].length
= req
->out
.args
[1].size
;
457 req
->end
= cuse_process_init_reply
;
458 fuse_request_send_background(fc
, req
);
465 fuse_put_request(fc
, req
);
470 static void cuse_fc_release(struct fuse_conn
*fc
)
472 struct cuse_conn
*cc
= fc_to_cc(fc
);
477 * cuse_channel_open - open method for /dev/cuse
478 * @inode: inode for /dev/cuse
479 * @file: file struct being opened
481 * Userland CUSE server can create a CUSE device by opening /dev/cuse
482 * and replying to the initialization request kernel sends. This
483 * function is responsible for handling CUSE device initialization.
484 * Because the fd opened by this function is used during
485 * initialization, this function only creates cuse_conn and sends
486 * init. The rest is delegated to a kthread.
489 * 0 on success, -errno on failure.
491 static int cuse_channel_open(struct inode
*inode
, struct file
*file
)
493 struct cuse_conn
*cc
;
496 /* set up cuse_conn */
497 cc
= kzalloc(sizeof(*cc
), GFP_KERNEL
);
501 fuse_conn_init(&cc
->fc
);
503 INIT_LIST_HEAD(&cc
->list
);
504 cc
->fc
.release
= cuse_fc_release
;
506 cc
->fc
.connected
= 1;
508 rc
= cuse_send_init(cc
);
510 fuse_conn_put(&cc
->fc
);
513 file
->private_data
= &cc
->fc
; /* channel owns base reference to cc */
519 * cuse_channel_release - release method for /dev/cuse
520 * @inode: inode for /dev/cuse
521 * @file: file struct being closed
523 * Disconnect the channel, deregister CUSE device and initiate
524 * destruction by putting the default reference.
527 * 0 on success, -errno on failure.
529 static int cuse_channel_release(struct inode
*inode
, struct file
*file
)
531 struct cuse_conn
*cc
= fc_to_cc(file
->private_data
);
534 /* remove from the conntbl, no more access from this point on */
535 mutex_lock(&cuse_lock
);
536 list_del_init(&cc
->list
);
537 mutex_unlock(&cuse_lock
);
541 device_unregister(cc
->dev
);
543 unregister_chrdev_region(cc
->cdev
->dev
, 1);
547 rc
= fuse_dev_release(inode
, file
); /* puts the base reference */
552 static struct file_operations cuse_channel_fops
; /* initialized during init */
555 /**************************************************************************
556 * Misc stuff and module initializatiion
558 * CUSE exports the same set of attributes to sysfs as fusectl.
561 static ssize_t
cuse_class_waiting_show(struct device
*dev
,
562 struct device_attribute
*attr
, char *buf
)
564 struct cuse_conn
*cc
= dev_get_drvdata(dev
);
566 return sprintf(buf
, "%d\n", atomic_read(&cc
->fc
.num_waiting
));
569 static ssize_t
cuse_class_abort_store(struct device
*dev
,
570 struct device_attribute
*attr
,
571 const char *buf
, size_t count
)
573 struct cuse_conn
*cc
= dev_get_drvdata(dev
);
575 fuse_abort_conn(&cc
->fc
);
579 static struct device_attribute cuse_class_dev_attrs
[] = {
580 __ATTR(waiting
, S_IFREG
| 0400, cuse_class_waiting_show
, NULL
),
581 __ATTR(abort
, S_IFREG
| 0200, NULL
, cuse_class_abort_store
),
585 static struct miscdevice cuse_miscdev
= {
586 .minor
= MISC_DYNAMIC_MINOR
,
588 .fops
= &cuse_channel_fops
,
591 static int __init
cuse_init(void)
596 for (i
= 0; i
< CUSE_CONNTBL_LEN
; i
++)
597 INIT_LIST_HEAD(&cuse_conntbl
[i
]);
599 /* inherit and extend fuse_dev_operations */
600 cuse_channel_fops
= fuse_dev_operations
;
601 cuse_channel_fops
.owner
= THIS_MODULE
;
602 cuse_channel_fops
.open
= cuse_channel_open
;
603 cuse_channel_fops
.release
= cuse_channel_release
;
605 cuse_class
= class_create(THIS_MODULE
, "cuse");
606 if (IS_ERR(cuse_class
))
607 return PTR_ERR(cuse_class
);
609 cuse_class
->dev_attrs
= cuse_class_dev_attrs
;
611 rc
= misc_register(&cuse_miscdev
);
613 class_destroy(cuse_class
);
620 static void __exit
cuse_exit(void)
622 misc_deregister(&cuse_miscdev
);
623 class_destroy(cuse_class
);
626 module_init(cuse_init
);
627 module_exit(cuse_exit
);
629 MODULE_AUTHOR("Tejun Heo <tj@kernel.org>");
630 MODULE_DESCRIPTION("Character device in Userspace");
631 MODULE_LICENSE("GPL");