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