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
};
96 struct fuse_io_priv io
= { .async
= 0, .file
= file
};
98 return fuse_direct_io(&io
, &iov
, 1, count
, &pos
, FUSE_DIO_CUSE
);
101 static ssize_t
cuse_write(struct file
*file
, const char __user
*buf
,
102 size_t count
, loff_t
*ppos
)
105 struct iovec iov
= { .iov_base
= (void __user
*)buf
, .iov_len
= count
};
106 struct fuse_io_priv io
= { .async
= 0, .file
= file
};
109 * No locking or generic_write_checks(), the server is
110 * responsible for locking and sanity checks.
112 return fuse_direct_io(&io
, &iov
, 1, count
, &pos
,
113 FUSE_DIO_WRITE
| FUSE_DIO_CUSE
);
116 static int cuse_open(struct inode
*inode
, struct file
*file
)
118 dev_t devt
= inode
->i_cdev
->dev
;
119 struct cuse_conn
*cc
= NULL
, *pos
;
122 /* look up and get the connection */
123 mutex_lock(&cuse_lock
);
124 list_for_each_entry(pos
, cuse_conntbl_head(devt
), list
)
125 if (pos
->dev
->devt
== devt
) {
126 fuse_conn_get(&pos
->fc
);
130 mutex_unlock(&cuse_lock
);
137 * Generic permission check is already done against the chrdev
138 * file, proceed to open.
140 rc
= fuse_do_open(&cc
->fc
, 0, file
, 0);
142 fuse_conn_put(&cc
->fc
);
146 static int cuse_release(struct inode
*inode
, struct file
*file
)
148 struct fuse_file
*ff
= file
->private_data
;
149 struct fuse_conn
*fc
= ff
->fc
;
151 fuse_sync_release(ff
, file
->f_flags
);
157 static long cuse_file_ioctl(struct file
*file
, unsigned int cmd
,
160 struct fuse_file
*ff
= file
->private_data
;
161 struct cuse_conn
*cc
= fc_to_cc(ff
->fc
);
162 unsigned int flags
= 0;
164 if (cc
->unrestricted_ioctl
)
165 flags
|= FUSE_IOCTL_UNRESTRICTED
;
167 return fuse_do_ioctl(file
, cmd
, arg
, flags
);
170 static long cuse_file_compat_ioctl(struct file
*file
, unsigned int cmd
,
173 struct fuse_file
*ff
= file
->private_data
;
174 struct cuse_conn
*cc
= fc_to_cc(ff
->fc
);
175 unsigned int flags
= FUSE_IOCTL_COMPAT
;
177 if (cc
->unrestricted_ioctl
)
178 flags
|= FUSE_IOCTL_UNRESTRICTED
;
180 return fuse_do_ioctl(file
, cmd
, arg
, flags
);
183 static const struct file_operations cuse_frontend_fops
= {
184 .owner
= THIS_MODULE
,
188 .release
= cuse_release
,
189 .unlocked_ioctl
= cuse_file_ioctl
,
190 .compat_ioctl
= cuse_file_compat_ioctl
,
191 .poll
= fuse_file_poll
,
192 .llseek
= noop_llseek
,
196 /**************************************************************************
197 * CUSE channel initialization and destruction
200 struct cuse_devinfo
{
205 * cuse_parse_one - parse one key=value pair
206 * @pp: i/o parameter for the current position
207 * @end: points to one past the end of the packed string
208 * @keyp: out parameter for key
209 * @valp: out parameter for value
211 * *@pp points to packed strings - "key0=val0\0key1=val1\0" which ends
212 * at @end - 1. This function parses one pair and set *@keyp to the
213 * start of the key and *@valp to the start of the value. Note that
214 * the original string is modified such that the key string is
215 * terminated with '\0'. *@pp is updated to point to the next string.
218 * 1 on successful parse, 0 on EOF, -errno on failure.
220 static int cuse_parse_one(char **pp
, char *end
, char **keyp
, char **valp
)
225 while (p
< end
&& *p
== '\0')
230 if (end
[-1] != '\0') {
231 printk(KERN_ERR
"CUSE: info not properly terminated\n");
241 val
= key
+ strlen(key
);
248 printk(KERN_ERR
"CUSE: zero length info key specified\n");
261 * cuse_parse_dev_info - parse device info
262 * @p: device info string
263 * @len: length of device info string
264 * @devinfo: out parameter for parsed device info
266 * Parse @p to extract device info and store it into @devinfo. String
267 * pointed to by @p is modified by parsing and @devinfo points into
268 * them, so @p shouldn't be freed while @devinfo is in use.
271 * 0 on success, -errno on failure.
273 static int cuse_parse_devinfo(char *p
, size_t len
, struct cuse_devinfo
*devinfo
)
276 char *uninitialized_var(key
), *uninitialized_var(val
);
280 rc
= cuse_parse_one(&p
, end
, &key
, &val
);
285 if (strcmp(key
, "DEVNAME") == 0)
288 printk(KERN_WARNING
"CUSE: unknown device info \"%s\"\n",
292 if (!devinfo
->name
|| !strlen(devinfo
->name
)) {
293 printk(KERN_ERR
"CUSE: DEVNAME unspecified\n");
300 static void cuse_gendev_release(struct device
*dev
)
306 * cuse_process_init_reply - finish initializing CUSE channel
308 * This function creates the character device and sets up all the
309 * required data structures for it. Please read the comment at the
310 * top of this file for high level overview.
312 static void cuse_process_init_reply(struct fuse_conn
*fc
, struct fuse_req
*req
)
314 struct cuse_conn
*cc
= fc_to_cc(fc
), *pos
;
315 struct cuse_init_out
*arg
= req
->out
.args
[0].value
;
316 struct page
*page
= req
->pages
[0];
317 struct cuse_devinfo devinfo
= { };
323 if (req
->out
.h
.error
||
324 arg
->major
!= FUSE_KERNEL_VERSION
|| arg
->minor
< 11) {
328 fc
->minor
= arg
->minor
;
329 fc
->max_read
= max_t(unsigned, arg
->max_read
, 4096);
330 fc
->max_write
= max_t(unsigned, arg
->max_write
, 4096);
332 /* parse init reply */
333 cc
->unrestricted_ioctl
= arg
->flags
& CUSE_UNRESTRICTED_IOCTL
;
335 rc
= cuse_parse_devinfo(page_address(page
), req
->out
.args
[1].size
,
340 /* determine and reserve devt */
341 devt
= MKDEV(arg
->dev_major
, arg
->dev_minor
);
343 rc
= alloc_chrdev_region(&devt
, MINOR(devt
), 1, devinfo
.name
);
345 rc
= register_chrdev_region(devt
, 1, devinfo
.name
);
347 printk(KERN_ERR
"CUSE: failed to register chrdev region\n");
351 /* devt determined, create device */
353 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
357 device_initialize(dev
);
358 dev_set_uevent_suppress(dev
, 1);
359 dev
->class = cuse_class
;
361 dev
->release
= cuse_gendev_release
;
362 dev_set_drvdata(dev
, cc
);
363 dev_set_name(dev
, "%s", devinfo
.name
);
365 mutex_lock(&cuse_lock
);
367 /* make sure the device-name is unique */
368 for (i
= 0; i
< CUSE_CONNTBL_LEN
; ++i
) {
369 list_for_each_entry(pos
, &cuse_conntbl
[i
], list
)
370 if (!strcmp(dev_name(pos
->dev
), dev_name(dev
)))
374 rc
= device_add(dev
);
384 cdev
->owner
= THIS_MODULE
;
385 cdev
->ops
= &cuse_frontend_fops
;
387 rc
= cdev_add(cdev
, devt
, 1);
394 /* make the device available */
395 list_add(&cc
->list
, cuse_conntbl_head(devt
));
396 mutex_unlock(&cuse_lock
);
398 /* announce device availability */
399 dev_set_uevent_suppress(dev
, 0);
400 kobject_uevent(&dev
->kobj
, KOBJ_ADD
);
409 mutex_unlock(&cuse_lock
);
412 unregister_chrdev_region(devt
, 1);
418 static int cuse_send_init(struct cuse_conn
*cc
)
421 struct fuse_req
*req
;
423 struct fuse_conn
*fc
= &cc
->fc
;
424 struct cuse_init_in
*arg
;
427 BUILD_BUG_ON(CUSE_INIT_INFO_MAX
> PAGE_SIZE
);
429 req
= fuse_get_req_for_background(fc
, 1);
436 page
= alloc_page(GFP_KERNEL
| __GFP_ZERO
);
440 outarg
= kzalloc(sizeof(struct cuse_init_out
), GFP_KERNEL
);
444 arg
= &req
->misc
.cuse_init_in
;
445 arg
->major
= FUSE_KERNEL_VERSION
;
446 arg
->minor
= FUSE_KERNEL_MINOR_VERSION
;
447 arg
->flags
|= CUSE_UNRESTRICTED_IOCTL
;
448 req
->in
.h
.opcode
= CUSE_INIT
;
450 req
->in
.args
[0].size
= sizeof(struct cuse_init_in
);
451 req
->in
.args
[0].value
= arg
;
452 req
->out
.numargs
= 2;
453 req
->out
.args
[0].size
= sizeof(struct cuse_init_out
);
454 req
->out
.args
[0].value
= outarg
;
455 req
->out
.args
[1].size
= CUSE_INIT_INFO_MAX
;
457 req
->out
.argpages
= 1;
458 req
->pages
[0] = page
;
459 req
->page_descs
[0].length
= req
->out
.args
[1].size
;
461 req
->end
= cuse_process_init_reply
;
462 fuse_request_send_background(fc
, req
);
469 fuse_put_request(fc
, req
);
474 static void cuse_fc_release(struct fuse_conn
*fc
)
476 struct cuse_conn
*cc
= fc_to_cc(fc
);
477 kfree_rcu(cc
, fc
.rcu
);
481 * cuse_channel_open - open method for /dev/cuse
482 * @inode: inode for /dev/cuse
483 * @file: file struct being opened
485 * Userland CUSE server can create a CUSE device by opening /dev/cuse
486 * and replying to the initialization request kernel sends. This
487 * function is responsible for handling CUSE device initialization.
488 * Because the fd opened by this function is used during
489 * initialization, this function only creates cuse_conn and sends
490 * init. The rest is delegated to a kthread.
493 * 0 on success, -errno on failure.
495 static int cuse_channel_open(struct inode
*inode
, struct file
*file
)
497 struct cuse_conn
*cc
;
500 /* set up cuse_conn */
501 cc
= kzalloc(sizeof(*cc
), GFP_KERNEL
);
505 fuse_conn_init(&cc
->fc
);
507 INIT_LIST_HEAD(&cc
->list
);
508 cc
->fc
.release
= cuse_fc_release
;
510 cc
->fc
.connected
= 1;
511 cc
->fc
.initialized
= 1;
512 rc
= cuse_send_init(cc
);
514 fuse_conn_put(&cc
->fc
);
517 file
->private_data
= &cc
->fc
; /* channel owns base reference to cc */
523 * cuse_channel_release - release method for /dev/cuse
524 * @inode: inode for /dev/cuse
525 * @file: file struct being closed
527 * Disconnect the channel, deregister CUSE device and initiate
528 * destruction by putting the default reference.
531 * 0 on success, -errno on failure.
533 static int cuse_channel_release(struct inode
*inode
, struct file
*file
)
535 struct cuse_conn
*cc
= fc_to_cc(file
->private_data
);
538 /* remove from the conntbl, no more access from this point on */
539 mutex_lock(&cuse_lock
);
540 list_del_init(&cc
->list
);
541 mutex_unlock(&cuse_lock
);
545 device_unregister(cc
->dev
);
547 unregister_chrdev_region(cc
->cdev
->dev
, 1);
551 rc
= fuse_dev_release(inode
, file
); /* puts the base reference */
556 static struct file_operations cuse_channel_fops
; /* initialized during init */
559 /**************************************************************************
560 * Misc stuff and module initializatiion
562 * CUSE exports the same set of attributes to sysfs as fusectl.
565 static ssize_t
cuse_class_waiting_show(struct device
*dev
,
566 struct device_attribute
*attr
, char *buf
)
568 struct cuse_conn
*cc
= dev_get_drvdata(dev
);
570 return sprintf(buf
, "%d\n", atomic_read(&cc
->fc
.num_waiting
));
572 static DEVICE_ATTR(waiting
, 0400, cuse_class_waiting_show
, NULL
);
574 static ssize_t
cuse_class_abort_store(struct device
*dev
,
575 struct device_attribute
*attr
,
576 const char *buf
, size_t count
)
578 struct cuse_conn
*cc
= dev_get_drvdata(dev
);
580 fuse_abort_conn(&cc
->fc
);
583 static DEVICE_ATTR(abort
, 0200, NULL
, cuse_class_abort_store
);
585 static struct attribute
*cuse_class_dev_attrs
[] = {
586 &dev_attr_waiting
.attr
,
587 &dev_attr_abort
.attr
,
590 ATTRIBUTE_GROUPS(cuse_class_dev
);
592 static struct miscdevice cuse_miscdev
= {
595 .fops
= &cuse_channel_fops
,
598 MODULE_ALIAS_MISCDEV(CUSE_MINOR
);
599 MODULE_ALIAS("devname:cuse");
601 static int __init
cuse_init(void)
606 for (i
= 0; i
< CUSE_CONNTBL_LEN
; i
++)
607 INIT_LIST_HEAD(&cuse_conntbl
[i
]);
609 /* inherit and extend fuse_dev_operations */
610 cuse_channel_fops
= fuse_dev_operations
;
611 cuse_channel_fops
.owner
= THIS_MODULE
;
612 cuse_channel_fops
.open
= cuse_channel_open
;
613 cuse_channel_fops
.release
= cuse_channel_release
;
615 cuse_class
= class_create(THIS_MODULE
, "cuse");
616 if (IS_ERR(cuse_class
))
617 return PTR_ERR(cuse_class
);
619 cuse_class
->dev_groups
= cuse_class_dev_groups
;
621 rc
= misc_register(&cuse_miscdev
);
623 class_destroy(cuse_class
);
630 static void __exit
cuse_exit(void)
632 misc_deregister(&cuse_miscdev
);
633 class_destroy(cuse_class
);
636 module_init(cuse_init
);
637 module_exit(cuse_exit
);
639 MODULE_AUTHOR("Tejun Heo <tj@kernel.org>");
640 MODULE_DESCRIPTION("Character device in Userspace");
641 MODULE_LICENSE("GPL");