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/aio.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>
54 #define CUSE_CONNTBL_LEN 64
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 */
62 /* init parameters, set once during initialization */
63 bool unrestricted_ioctl
;
66 static DEFINE_MUTEX(cuse_lock
); /* protects registration */
67 static struct list_head cuse_conntbl
[CUSE_CONNTBL_LEN
];
68 static struct class *cuse_class
;
70 static struct cuse_conn
*fc_to_cc(struct fuse_conn
*fc
)
72 return container_of(fc
, struct cuse_conn
, fc
);
75 static struct list_head
*cuse_conntbl_head(dev_t devt
)
77 return &cuse_conntbl
[(MAJOR(devt
) + MINOR(devt
)) % CUSE_CONNTBL_LEN
];
81 /**************************************************************************
82 * CUSE frontend operations
84 * These are file operations for the character device.
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
91 static ssize_t
cuse_read(struct file
*file
, char __user
*buf
, size_t count
,
95 struct iovec iov
= { .iov_base
= buf
, .iov_len
= count
};
97 return fuse_direct_io(file
, &iov
, 1, count
, &pos
, 0);
100 static ssize_t
cuse_write(struct file
*file
, const char __user
*buf
,
101 size_t count
, loff_t
*ppos
)
104 struct iovec iov
= { .iov_base
= (void __user
*)buf
, .iov_len
= count
};
107 * No locking or generic_write_checks(), the server is
108 * responsible for locking and sanity checks.
110 return fuse_direct_io(file
, &iov
, 1, count
, &pos
, 1);
113 static int cuse_open(struct inode
*inode
, struct file
*file
)
115 dev_t devt
= inode
->i_cdev
->dev
;
116 struct cuse_conn
*cc
= NULL
, *pos
;
119 /* look up and get the connection */
120 mutex_lock(&cuse_lock
);
121 list_for_each_entry(pos
, cuse_conntbl_head(devt
), list
)
122 if (pos
->dev
->devt
== devt
) {
123 fuse_conn_get(&pos
->fc
);
127 mutex_unlock(&cuse_lock
);
134 * Generic permission check is already done against the chrdev
135 * file, proceed to open.
137 rc
= fuse_do_open(&cc
->fc
, 0, file
, 0);
139 fuse_conn_put(&cc
->fc
);
143 static int cuse_release(struct inode
*inode
, struct file
*file
)
145 struct fuse_file
*ff
= file
->private_data
;
146 struct fuse_conn
*fc
= ff
->fc
;
148 fuse_sync_release(ff
, file
->f_flags
);
154 static long cuse_file_ioctl(struct file
*file
, unsigned int cmd
,
157 struct fuse_file
*ff
= file
->private_data
;
158 struct cuse_conn
*cc
= fc_to_cc(ff
->fc
);
159 unsigned int flags
= 0;
161 if (cc
->unrestricted_ioctl
)
162 flags
|= FUSE_IOCTL_UNRESTRICTED
;
164 return fuse_do_ioctl(file
, cmd
, arg
, flags
);
167 static long cuse_file_compat_ioctl(struct file
*file
, unsigned int cmd
,
170 struct fuse_file
*ff
= file
->private_data
;
171 struct cuse_conn
*cc
= fc_to_cc(ff
->fc
);
172 unsigned int flags
= FUSE_IOCTL_COMPAT
;
174 if (cc
->unrestricted_ioctl
)
175 flags
|= FUSE_IOCTL_UNRESTRICTED
;
177 return fuse_do_ioctl(file
, cmd
, arg
, flags
);
180 static const struct file_operations cuse_frontend_fops
= {
181 .owner
= THIS_MODULE
,
185 .release
= cuse_release
,
186 .unlocked_ioctl
= cuse_file_ioctl
,
187 .compat_ioctl
= cuse_file_compat_ioctl
,
188 .poll
= fuse_file_poll
,
189 .llseek
= noop_llseek
,
193 /**************************************************************************
194 * CUSE channel initialization and destruction
197 struct cuse_devinfo
{
202 * cuse_parse_one - parse one key=value pair
203 * @pp: i/o parameter for the current position
204 * @end: points to one past the end of the packed string
205 * @keyp: out parameter for key
206 * @valp: out parameter for value
208 * *@pp points to packed strings - "key0=val0\0key1=val1\0" which ends
209 * at @end - 1. This function parses one pair and set *@keyp to the
210 * start of the key and *@valp to the start of the value. Note that
211 * the original string is modified such that the key string is
212 * terminated with '\0'. *@pp is updated to point to the next string.
215 * 1 on successful parse, 0 on EOF, -errno on failure.
217 static int cuse_parse_one(char **pp
, char *end
, char **keyp
, char **valp
)
222 while (p
< end
&& *p
== '\0')
227 if (end
[-1] != '\0') {
228 printk(KERN_ERR
"CUSE: info not properly terminated\n");
238 val
= key
+ strlen(key
);
245 printk(KERN_ERR
"CUSE: zero length info key specified\n");
258 * cuse_parse_dev_info - parse device info
259 * @p: device info string
260 * @len: length of device info string
261 * @devinfo: out parameter for parsed device info
263 * Parse @p to extract device info and store it into @devinfo. String
264 * pointed to by @p is modified by parsing and @devinfo points into
265 * them, so @p shouldn't be freed while @devinfo is in use.
268 * 0 on success, -errno on failure.
270 static int cuse_parse_devinfo(char *p
, size_t len
, struct cuse_devinfo
*devinfo
)
273 char *uninitialized_var(key
), *uninitialized_var(val
);
277 rc
= cuse_parse_one(&p
, end
, &key
, &val
);
282 if (strcmp(key
, "DEVNAME") == 0)
285 printk(KERN_WARNING
"CUSE: unknown device info \"%s\"\n",
289 if (!devinfo
->name
|| !strlen(devinfo
->name
)) {
290 printk(KERN_ERR
"CUSE: DEVNAME unspecified\n");
297 static void cuse_gendev_release(struct device
*dev
)
303 * cuse_process_init_reply - finish initializing CUSE channel
305 * This function creates the character device and sets up all the
306 * required data structures for it. Please read the comment at the
307 * top of this file for high level overview.
309 static void cuse_process_init_reply(struct fuse_conn
*fc
, struct fuse_req
*req
)
311 struct cuse_conn
*cc
= fc_to_cc(fc
), *pos
;
312 struct cuse_init_out
*arg
= req
->out
.args
[0].value
;
313 struct page
*page
= req
->pages
[0];
314 struct cuse_devinfo devinfo
= { };
320 if (req
->out
.h
.error
||
321 arg
->major
!= FUSE_KERNEL_VERSION
|| arg
->minor
< 11) {
325 fc
->minor
= arg
->minor
;
326 fc
->max_read
= max_t(unsigned, arg
->max_read
, 4096);
327 fc
->max_write
= max_t(unsigned, arg
->max_write
, 4096);
329 /* parse init reply */
330 cc
->unrestricted_ioctl
= arg
->flags
& CUSE_UNRESTRICTED_IOCTL
;
332 rc
= cuse_parse_devinfo(page_address(page
), req
->out
.args
[1].size
,
337 /* determine and reserve devt */
338 devt
= MKDEV(arg
->dev_major
, arg
->dev_minor
);
340 rc
= alloc_chrdev_region(&devt
, MINOR(devt
), 1, devinfo
.name
);
342 rc
= register_chrdev_region(devt
, 1, devinfo
.name
);
344 printk(KERN_ERR
"CUSE: failed to register chrdev region\n");
348 /* devt determined, create device */
350 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
354 device_initialize(dev
);
355 dev_set_uevent_suppress(dev
, 1);
356 dev
->class = cuse_class
;
358 dev
->release
= cuse_gendev_release
;
359 dev_set_drvdata(dev
, cc
);
360 dev_set_name(dev
, "%s", devinfo
.name
);
362 mutex_lock(&cuse_lock
);
364 /* make sure the device-name is unique */
365 for (i
= 0; i
< CUSE_CONNTBL_LEN
; ++i
) {
366 list_for_each_entry(pos
, &cuse_conntbl
[i
], list
)
367 if (!strcmp(dev_name(pos
->dev
), dev_name(dev
)))
371 rc
= device_add(dev
);
381 cdev
->owner
= THIS_MODULE
;
382 cdev
->ops
= &cuse_frontend_fops
;
384 rc
= cdev_add(cdev
, devt
, 1);
391 /* make the device available */
392 list_add(&cc
->list
, cuse_conntbl_head(devt
));
393 mutex_unlock(&cuse_lock
);
395 /* announce device availability */
396 dev_set_uevent_suppress(dev
, 0);
397 kobject_uevent(&dev
->kobj
, KOBJ_ADD
);
406 mutex_unlock(&cuse_lock
);
409 unregister_chrdev_region(devt
, 1);
415 static int cuse_send_init(struct cuse_conn
*cc
)
418 struct fuse_req
*req
;
420 struct fuse_conn
*fc
= &cc
->fc
;
421 struct cuse_init_in
*arg
;
424 BUILD_BUG_ON(CUSE_INIT_INFO_MAX
> PAGE_SIZE
);
426 req
= fuse_get_req(fc
, 1);
433 page
= alloc_page(GFP_KERNEL
| __GFP_ZERO
);
437 outarg
= kzalloc(sizeof(struct cuse_init_out
), GFP_KERNEL
);
441 arg
= &req
->misc
.cuse_init_in
;
442 arg
->major
= FUSE_KERNEL_VERSION
;
443 arg
->minor
= FUSE_KERNEL_MINOR_VERSION
;
444 arg
->flags
|= CUSE_UNRESTRICTED_IOCTL
;
445 req
->in
.h
.opcode
= CUSE_INIT
;
447 req
->in
.args
[0].size
= sizeof(struct cuse_init_in
);
448 req
->in
.args
[0].value
= arg
;
449 req
->out
.numargs
= 2;
450 req
->out
.args
[0].size
= sizeof(struct cuse_init_out
);
451 req
->out
.args
[0].value
= outarg
;
452 req
->out
.args
[1].size
= CUSE_INIT_INFO_MAX
;
454 req
->out
.argpages
= 1;
455 req
->pages
[0] = page
;
456 req
->page_descs
[0].length
= req
->out
.args
[1].size
;
458 req
->end
= cuse_process_init_reply
;
459 fuse_request_send_background(fc
, req
);
466 fuse_put_request(fc
, req
);
471 static void cuse_fc_release(struct fuse_conn
*fc
)
473 struct cuse_conn
*cc
= fc_to_cc(fc
);
478 * cuse_channel_open - open method for /dev/cuse
479 * @inode: inode for /dev/cuse
480 * @file: file struct being opened
482 * Userland CUSE server can create a CUSE device by opening /dev/cuse
483 * and replying to the initialization request kernel sends. This
484 * function is responsible for handling CUSE device initialization.
485 * Because the fd opened by this function is used during
486 * initialization, this function only creates cuse_conn and sends
487 * init. The rest is delegated to a kthread.
490 * 0 on success, -errno on failure.
492 static int cuse_channel_open(struct inode
*inode
, struct file
*file
)
494 struct cuse_conn
*cc
;
497 /* set up cuse_conn */
498 cc
= kzalloc(sizeof(*cc
), GFP_KERNEL
);
502 fuse_conn_init(&cc
->fc
);
504 INIT_LIST_HEAD(&cc
->list
);
505 cc
->fc
.release
= cuse_fc_release
;
507 cc
->fc
.connected
= 1;
509 rc
= cuse_send_init(cc
);
511 fuse_conn_put(&cc
->fc
);
514 file
->private_data
= &cc
->fc
; /* channel owns base reference to cc */
520 * cuse_channel_release - release method for /dev/cuse
521 * @inode: inode for /dev/cuse
522 * @file: file struct being closed
524 * Disconnect the channel, deregister CUSE device and initiate
525 * destruction by putting the default reference.
528 * 0 on success, -errno on failure.
530 static int cuse_channel_release(struct inode
*inode
, struct file
*file
)
532 struct cuse_conn
*cc
= fc_to_cc(file
->private_data
);
535 /* remove from the conntbl, no more access from this point on */
536 mutex_lock(&cuse_lock
);
537 list_del_init(&cc
->list
);
538 mutex_unlock(&cuse_lock
);
542 device_unregister(cc
->dev
);
544 unregister_chrdev_region(cc
->cdev
->dev
, 1);
548 rc
= fuse_dev_release(inode
, file
); /* puts the base reference */
553 static struct file_operations cuse_channel_fops
; /* initialized during init */
556 /**************************************************************************
557 * Misc stuff and module initializatiion
559 * CUSE exports the same set of attributes to sysfs as fusectl.
562 static ssize_t
cuse_class_waiting_show(struct device
*dev
,
563 struct device_attribute
*attr
, char *buf
)
565 struct cuse_conn
*cc
= dev_get_drvdata(dev
);
567 return sprintf(buf
, "%d\n", atomic_read(&cc
->fc
.num_waiting
));
570 static ssize_t
cuse_class_abort_store(struct device
*dev
,
571 struct device_attribute
*attr
,
572 const char *buf
, size_t count
)
574 struct cuse_conn
*cc
= dev_get_drvdata(dev
);
576 fuse_abort_conn(&cc
->fc
);
580 static struct device_attribute cuse_class_dev_attrs
[] = {
581 __ATTR(waiting
, S_IFREG
| 0400, cuse_class_waiting_show
, NULL
),
582 __ATTR(abort
, S_IFREG
| 0200, NULL
, cuse_class_abort_store
),
586 static struct miscdevice cuse_miscdev
= {
587 .minor
= MISC_DYNAMIC_MINOR
,
589 .fops
= &cuse_channel_fops
,
592 static int __init
cuse_init(void)
597 for (i
= 0; i
< CUSE_CONNTBL_LEN
; i
++)
598 INIT_LIST_HEAD(&cuse_conntbl
[i
]);
600 /* inherit and extend fuse_dev_operations */
601 cuse_channel_fops
= fuse_dev_operations
;
602 cuse_channel_fops
.owner
= THIS_MODULE
;
603 cuse_channel_fops
.open
= cuse_channel_open
;
604 cuse_channel_fops
.release
= cuse_channel_release
;
606 cuse_class
= class_create(THIS_MODULE
, "cuse");
607 if (IS_ERR(cuse_class
))
608 return PTR_ERR(cuse_class
);
610 cuse_class
->dev_attrs
= cuse_class_dev_attrs
;
612 rc
= misc_register(&cuse_miscdev
);
614 class_destroy(cuse_class
);
621 static void __exit
cuse_exit(void)
623 misc_deregister(&cuse_miscdev
);
624 class_destroy(cuse_class
);
627 module_init(cuse_init
);
628 module_exit(cuse_exit
);
630 MODULE_AUTHOR("Tejun Heo <tj@kernel.org>");
631 MODULE_DESCRIPTION("Character device in Userspace");
632 MODULE_LICENSE("GPL");