projects / deliverable / linux.git / blob
? search:


38272ad245516c272ab571bed1a5c962f4a0e808
[deliverable/linux.git] / drivers / xen / evtchn.c
1 /******************************************************************************
2 * evtchn.c
3 *
4 * Driver for receiving and demuxing event-channel signals.
5 *
6 * Copyright (c) 2004-2005, K A Fraser
7 * Multi-process extensions Copyright (c) 2004, Steven Smith
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version 2
11 * as published by the Free Software Foundation; or, when distributed
12 * separately from the Linux kernel or incorporated into other
13 * software packages, subject to the following license:
14 *
15 * Permission is hereby granted, free of charge, to any person obtaining a copy
16 * of this source file (the "Software"), to deal in the Software without
17 * restriction, including without limitation the rights to use, copy, modify,
18 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
19 * and to permit persons to whom the Software is furnished to do so, subject to
20 * the following conditions:
21 *
22 * The above copyright notice and this permission notice shall be included in
23 * all copies or substantial portions of the Software.
24 *
25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
26 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
27 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
28 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
29 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
30 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
31 * IN THE SOFTWARE.
32 */
33
34 #define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt
35
36 #include <linux/module.h>
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/slab.h>
40 #include <linux/string.h>
41 #include <linux/errno.h>
42 #include <linux/fs.h>
43 #include <linux/miscdevice.h>
44 #include <linux/major.h>
45 #include <linux/proc_fs.h>
46 #include <linux/stat.h>
47 #include <linux/poll.h>
48 #include <linux/irq.h>
49 #include <linux/init.h>
50 #include <linux/mutex.h>
51 #include <linux/cpu.h>
52 #include <linux/mm.h>
53 #include <linux/vmalloc.h>
54
55 #include <xen/xen.h>
56 #include <xen/events.h>
57 #include <xen/evtchn.h>
58 #include <asm/xen/hypervisor.h>
59
60 struct per_user_data {
61 struct mutex bind_mutex; /* serialize bind/unbind operations */
62 struct rb_root evtchns;
63 unsigned int nr_evtchns;
64
65 /* Notification ring, accessed via /dev/xen/evtchn. */
66 unsigned int ring_size;
67 evtchn_port_t *ring;
68 unsigned int ring_cons, ring_prod, ring_overflow;
69 struct mutex ring_cons_mutex; /* protect against concurrent readers */
70 spinlock_t ring_prod_lock; /* product against concurrent interrupts */
71
72 /* Processes wait on this queue when ring is empty. */
73 wait_queue_head_t evtchn_wait;
74 struct fasync_struct *evtchn_async_queue;
75 const char *name;
76 };
77
78 struct user_evtchn {
79 struct rb_node node;
80 struct per_user_data *user;
81 unsigned port;
82 bool enabled;
83 };
84
85 static evtchn_port_t *evtchn_alloc_ring(unsigned int size)
86 {
87 evtchn_port_t *ring;
88 size_t s = size * sizeof(*ring);
89
90 ring = kmalloc(s, GFP_KERNEL);
91 if (!ring)
92 ring = vmalloc(s);
93
94 return ring;
95 }
96
97 static void evtchn_free_ring(evtchn_port_t *ring)
98 {
99 kvfree(ring);
100 }
101
102 static unsigned int evtchn_ring_offset(struct per_user_data *u,
103 unsigned int idx)
104 {
105 return idx & (u->ring_size - 1);
106 }
107
108 static evtchn_port_t *evtchn_ring_entry(struct per_user_data *u,
109 unsigned int idx)
110 {
111 return u->ring + evtchn_ring_offset(u, idx);
112 }
113
114 static int add_evtchn(struct per_user_data *u, struct user_evtchn *evtchn)
115 {
116 struct rb_node **new = &(u->evtchns.rb_node), *parent = NULL;
117
118 u->nr_evtchns++;
119
120 while (*new) {
121 struct user_evtchn *this;
122
123 this = container_of(*new, struct user_evtchn, node);
124
125 parent = *new;
126 if (this->port < evtchn->port)
127 new = &((*new)->rb_left);
128 else if (this->port > evtchn->port)
129 new = &((*new)->rb_right);
130 else
131 return -EEXIST;
132 }
133
134 /* Add new node and rebalance tree. */
135 rb_link_node(&evtchn->node, parent, new);
136 rb_insert_color(&evtchn->node, &u->evtchns);
137
138 return 0;
139 }
140
141 static void del_evtchn(struct per_user_data *u, struct user_evtchn *evtchn)
142 {
143 u->nr_evtchns--;
144 rb_erase(&evtchn->node, &u->evtchns);
145 kfree(evtchn);
146 }
147
148 static struct user_evtchn *find_evtchn(struct per_user_data *u, unsigned port)
149 {
150 struct rb_node *node = u->evtchns.rb_node;
151
152 while (node) {
153 struct user_evtchn *evtchn;
154
155 evtchn = container_of(node, struct user_evtchn, node);
156
157 if (evtchn->port < port)
158 node = node->rb_left;
159 else if (evtchn->port > port)
160 node = node->rb_right;
161 else
162 return evtchn;
163 }
164 return NULL;
165 }
166
167 static irqreturn_t evtchn_interrupt(int irq, void *data)
168 {
169 struct user_evtchn *evtchn = data;
170 struct per_user_data *u = evtchn->user;
171
172 WARN(!evtchn->enabled,
173 "Interrupt for port %d, but apparently not enabled; per-user %p\n",
174 evtchn->port, u);
175
176 disable_irq_nosync(irq);
177 evtchn->enabled = false;
178
179 spin_lock(&u->ring_prod_lock);
180
181 if ((u->ring_prod - u->ring_cons) < u->ring_size) {
182 *evtchn_ring_entry(u, u->ring_prod) = evtchn->port;
183 wmb(); /* Ensure ring contents visible */
184 if (u->ring_cons == u->ring_prod++) {
185 wake_up_interruptible(&u->evtchn_wait);
186 kill_fasync(&u->evtchn_async_queue,
187 SIGIO, POLL_IN);
188 }
189 } else
190 u->ring_overflow = 1;
191
192 spin_unlock(&u->ring_prod_lock);
193
194 return IRQ_HANDLED;
195 }
196
197 static ssize_t evtchn_read(struct file *file, char __user *buf,
198 size_t count, loff_t *ppos)
199 {
200 int rc;
201 unsigned int c, p, bytes1 = 0, bytes2 = 0;
202 struct per_user_data *u = file->private_data;
203
204 /* Whole number of ports. */
205 count &= ~(sizeof(evtchn_port_t)-1);
206
207 if (count == 0)
208 return 0;
209
210 if (count > PAGE_SIZE)
211 count = PAGE_SIZE;
212
213 for (;;) {
214 mutex_lock(&u->ring_cons_mutex);
215
216 rc = -EFBIG;
217 if (u->ring_overflow)
218 goto unlock_out;
219
220 c = u->ring_cons;
221 p = u->ring_prod;
222 if (c != p)
223 break;
224
225 mutex_unlock(&u->ring_cons_mutex);
226
227 if (file->f_flags & O_NONBLOCK)
228 return -EAGAIN;
229
230 rc = wait_event_interruptible(u->evtchn_wait,
231 u->ring_cons != u->ring_prod);
232 if (rc)
233 return rc;
234 }
235
236 /* Byte lengths of two chunks. Chunk split (if any) is at ring wrap. */
237 if (((c ^ p) & u->ring_size) != 0) {
238 bytes1 = (u->ring_size - evtchn_ring_offset(u, c)) *
239 sizeof(evtchn_port_t);
240 bytes2 = evtchn_ring_offset(u, p) * sizeof(evtchn_port_t);
241 } else {
242 bytes1 = (p - c) * sizeof(evtchn_port_t);
243 bytes2 = 0;
244 }
245
246 /* Truncate chunks according to caller's maximum byte count. */
247 if (bytes1 > count) {
248 bytes1 = count;
249 bytes2 = 0;
250 } else if ((bytes1 + bytes2) > count) {
251 bytes2 = count - bytes1;
252 }
253
254 rc = -EFAULT;
255 rmb(); /* Ensure that we see the port before we copy it. */
256 if (copy_to_user(buf, evtchn_ring_entry(u, c), bytes1) ||
257 ((bytes2 != 0) &&
258 copy_to_user(&buf[bytes1], &u->ring[0], bytes2)))
259 goto unlock_out;
260
261 u->ring_cons += (bytes1 + bytes2) / sizeof(evtchn_port_t);
262 rc = bytes1 + bytes2;
263
264 unlock_out:
265 mutex_unlock(&u->ring_cons_mutex);
266 return rc;
267 }
268
269 static ssize_t evtchn_write(struct file *file, const char __user *buf,
270 size_t count, loff_t *ppos)
271 {
272 int rc, i;
273 evtchn_port_t *kbuf = (evtchn_port_t *)__get_free_page(GFP_KERNEL);
274 struct per_user_data *u = file->private_data;
275
276 if (kbuf == NULL)
277 return -ENOMEM;
278
279 /* Whole number of ports. */
280 count &= ~(sizeof(evtchn_port_t)-1);
281
282 rc = 0;
283 if (count == 0)
284 goto out;
285
286 if (count > PAGE_SIZE)
287 count = PAGE_SIZE;
288
289 rc = -EFAULT;
290 if (copy_from_user(kbuf, buf, count) != 0)
291 goto out;
292
293 mutex_lock(&u->bind_mutex);
294
295 for (i = 0; i < (count/sizeof(evtchn_port_t)); i++) {
296 unsigned port = kbuf[i];
297 struct user_evtchn *evtchn;
298
299 evtchn = find_evtchn(u, port);
300 if (evtchn && !evtchn->enabled) {
301 evtchn->enabled = true;
302 enable_irq(irq_from_evtchn(port));
303 }
304 }
305
306 mutex_unlock(&u->bind_mutex);
307
308 rc = count;
309
310 out:
311 free_page((unsigned long)kbuf);
312 return rc;
313 }
314
315 static int evtchn_resize_ring(struct per_user_data *u)
316 {
317 unsigned int new_size;
318 evtchn_port_t *new_ring, *old_ring;
319 unsigned int p, c;
320
321 /*
322 * Ensure the ring is large enough to capture all possible
323 * events. i.e., one free slot for each bound event.
324 */
325 if (u->nr_evtchns <= u->ring_size)
326 return 0;
327
328 if (u->ring_size == 0)
329 new_size = 64;
330 else
331 new_size = 2 * u->ring_size;
332
333 new_ring = evtchn_alloc_ring(new_size);
334 if (!new_ring)
335 return -ENOMEM;
336
337 old_ring = u->ring;
338
339 /*
340 * Access to the ring contents is serialized by either the
341 * prod /or/ cons lock so take both when resizing.
342 */
343 mutex_lock(&u->ring_cons_mutex);
344 spin_lock_irq(&u->ring_prod_lock);
345
346 /*
347 * Copy the old ring contents to the new ring.
348 *
349 * If the ring contents crosses the end of the current ring,
350 * it needs to be copied in two chunks.
351 *
352 * +---------+ +------------------+
353 * |34567 12| -> | 1234567 |
354 * +-----p-c-+ +------------------+
355 */
356 p = evtchn_ring_offset(u, u->ring_prod);
357 c = evtchn_ring_offset(u, u->ring_cons);
358 if (p < c) {
359 memcpy(new_ring + c, u->ring + c, (u->ring_size - c) * sizeof(*u->ring));
360 memcpy(new_ring + u->ring_size, u->ring, p * sizeof(*u->ring));
361 } else
362 memcpy(new_ring + c, u->ring + c, (p - c) * sizeof(*u->ring));
363
364 u->ring = new_ring;
365 u->ring_size = new_size;
366
367 spin_unlock_irq(&u->ring_prod_lock);
368 mutex_unlock(&u->ring_cons_mutex);
369
370 evtchn_free_ring(old_ring);
371
372 return 0;
373 }
374
375 static int evtchn_bind_to_user(struct per_user_data *u, int port)
376 {
377 struct user_evtchn *evtchn;
378 struct evtchn_close close;
379 int rc = 0;
380
381 /*
382 * Ports are never reused, so every caller should pass in a
383 * unique port.
384 *
385 * (Locking not necessary because we haven't registered the
386 * interrupt handler yet, and our caller has already
387 * serialized bind operations.)
388 */
389
390 evtchn = kzalloc(sizeof(*evtchn), GFP_KERNEL);
391 if (!evtchn)
392 return -ENOMEM;
393
394 evtchn->user = u;
395 evtchn->port = port;
396 evtchn->enabled = true; /* start enabled */
397
398 rc = add_evtchn(u, evtchn);
399 if (rc < 0)
400 goto err;
401
402 rc = evtchn_resize_ring(u);
403 if (rc < 0)
404 goto err;
405
406 rc = bind_evtchn_to_irqhandler(port, evtchn_interrupt, 0,
407 u->name, evtchn);
408 if (rc < 0)
409 goto err;
410
411 rc = evtchn_make_refcounted(port);
412 return rc;
413
414 err:
415 /* bind failed, should close the port now */
416 close.port = port;
417 if (HYPERVISOR_event_channel_op(EVTCHNOP_close, &close) != 0)
418 BUG();
419 del_evtchn(u, evtchn);
420 return rc;
421 }
422
423 static void evtchn_unbind_from_user(struct per_user_data *u,
424 struct user_evtchn *evtchn)
425 {
426 int irq = irq_from_evtchn(evtchn->port);
427
428 BUG_ON(irq < 0);
429
430 unbind_from_irqhandler(irq, evtchn);
431
432 del_evtchn(u, evtchn);
433 }
434
435 static long evtchn_ioctl(struct file *file,
436 unsigned int cmd, unsigned long arg)
437 {
438 int rc;
439 struct per_user_data *u = file->private_data;
440 void __user *uarg = (void __user *) arg;
441
442 /* Prevent bind from racing with unbind */
443 mutex_lock(&u->bind_mutex);
444
445 switch (cmd) {
446 case IOCTL_EVTCHN_BIND_VIRQ: {
447 struct ioctl_evtchn_bind_virq bind;
448 struct evtchn_bind_virq bind_virq;
449
450 rc = -EFAULT;
451 if (copy_from_user(&bind, uarg, sizeof(bind)))
452 break;
453
454 bind_virq.virq = bind.virq;
455 bind_virq.vcpu = 0;
456 rc = HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq,
457 &bind_virq);
458 if (rc != 0)
459 break;
460
461 rc = evtchn_bind_to_user(u, bind_virq.port);
462 if (rc == 0)
463 rc = bind_virq.port;
464 break;
465 }
466
467 case IOCTL_EVTCHN_BIND_INTERDOMAIN: {
468 struct ioctl_evtchn_bind_interdomain bind;
469 struct evtchn_bind_interdomain bind_interdomain;
470
471 rc = -EFAULT;
472 if (copy_from_user(&bind, uarg, sizeof(bind)))
473 break;
474
475 bind_interdomain.remote_dom = bind.remote_domain;
476 bind_interdomain.remote_port = bind.remote_port;
477 rc = HYPERVISOR_event_channel_op(EVTCHNOP_bind_interdomain,
478 &bind_interdomain);
479 if (rc != 0)
480 break;
481
482 rc = evtchn_bind_to_user(u, bind_interdomain.local_port);
483 if (rc == 0)
484 rc = bind_interdomain.local_port;
485 break;
486 }
487
488 case IOCTL_EVTCHN_BIND_UNBOUND_PORT: {
489 struct ioctl_evtchn_bind_unbound_port bind;
490 struct evtchn_alloc_unbound alloc_unbound;
491
492 rc = -EFAULT;
493 if (copy_from_user(&bind, uarg, sizeof(bind)))
494 break;
495
496 alloc_unbound.dom = DOMID_SELF;
497 alloc_unbound.remote_dom = bind.remote_domain;
498 rc = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
499 &alloc_unbound);
500 if (rc != 0)
501 break;
502
503 rc = evtchn_bind_to_user(u, alloc_unbound.port);
504 if (rc == 0)
505 rc = alloc_unbound.port;
506 break;
507 }
508
509 case IOCTL_EVTCHN_UNBIND: {
510 struct ioctl_evtchn_unbind unbind;
511 struct user_evtchn *evtchn;
512
513 rc = -EFAULT;
514 if (copy_from_user(&unbind, uarg, sizeof(unbind)))
515 break;
516
517 rc = -EINVAL;
518 if (unbind.port >= xen_evtchn_nr_channels())
519 break;
520
521 rc = -ENOTCONN;
522 evtchn = find_evtchn(u, unbind.port);
523 if (!evtchn)
524 break;
525
526 disable_irq(irq_from_evtchn(unbind.port));
527 evtchn_unbind_from_user(u, evtchn);
528 rc = 0;
529 break;
530 }
531
532 case IOCTL_EVTCHN_NOTIFY: {
533 struct ioctl_evtchn_notify notify;
534 struct user_evtchn *evtchn;
535
536 rc = -EFAULT;
537 if (copy_from_user(&notify, uarg, sizeof(notify)))
538 break;
539
540 rc = -ENOTCONN;
541 evtchn = find_evtchn(u, notify.port);
542 if (evtchn) {
543 notify_remote_via_evtchn(notify.port);
544 rc = 0;
545 }
546 break;
547 }
548
549 case IOCTL_EVTCHN_RESET: {
550 /* Initialise the ring to empty. Clear errors. */
551 mutex_lock(&u->ring_cons_mutex);
552 spin_lock_irq(&u->ring_prod_lock);
553 u->ring_cons = u->ring_prod = u->ring_overflow = 0;
554 spin_unlock_irq(&u->ring_prod_lock);
555 mutex_unlock(&u->ring_cons_mutex);
556 rc = 0;
557 break;
558 }
559
560 default:
561 rc = -ENOSYS;
562 break;
563 }
564 mutex_unlock(&u->bind_mutex);
565
566 return rc;
567 }
568
569 static unsigned int evtchn_poll(struct file *file, poll_table *wait)
570 {
571 unsigned int mask = POLLOUT | POLLWRNORM;
572 struct per_user_data *u = file->private_data;
573
574 poll_wait(file, &u->evtchn_wait, wait);
575 if (u->ring_cons != u->ring_prod)
576 mask |= POLLIN | POLLRDNORM;
577 if (u->ring_overflow)
578 mask = POLLERR;
579 return mask;
580 }
581
582 static int evtchn_fasync(int fd, struct file *filp, int on)
583 {
584 struct per_user_data *u = filp->private_data;
585 return fasync_helper(fd, filp, on, &u->evtchn_async_queue);
586 }
587
588 static int evtchn_open(struct inode *inode, struct file *filp)
589 {
590 struct per_user_data *u;
591
592 u = kzalloc(sizeof(*u), GFP_KERNEL);
593 if (u == NULL)
594 return -ENOMEM;
595
596 u->name = kasprintf(GFP_KERNEL, "evtchn:%s", current->comm);
597 if (u->name == NULL) {
598 kfree(u);
599 return -ENOMEM;
600 }
601
602 init_waitqueue_head(&u->evtchn_wait);
603
604 mutex_init(&u->bind_mutex);
605 mutex_init(&u->ring_cons_mutex);
606 spin_lock_init(&u->ring_prod_lock);
607
608 filp->private_data = u;
609
610 return nonseekable_open(inode, filp);
611 }
612
613 static int evtchn_release(struct inode *inode, struct file *filp)
614 {
615 struct per_user_data *u = filp->private_data;
616 struct rb_node *node;
617
618 while ((node = u->evtchns.rb_node)) {
619 struct user_evtchn *evtchn;
620
621 evtchn = rb_entry(node, struct user_evtchn, node);
622 disable_irq(irq_from_evtchn(evtchn->port));
623 evtchn_unbind_from_user(u, evtchn);
624 }
625
626 evtchn_free_ring(u->ring);
627 kfree(u->name);
628 kfree(u);
629
630 return 0;
631 }
632
633 static const struct file_operations evtchn_fops = {
634 .owner = THIS_MODULE,
635 .read = evtchn_read,
636 .write = evtchn_write,
637 .unlocked_ioctl = evtchn_ioctl,
638 .poll = evtchn_poll,
639 .fasync = evtchn_fasync,
640 .open = evtchn_open,
641 .release = evtchn_release,
642 .llseek = no_llseek,
643 };
644
645 static struct miscdevice evtchn_miscdev = {
646 .minor = MISC_DYNAMIC_MINOR,
647 .name = "xen/evtchn",
648 .fops = &evtchn_fops,
649 };
650 static int __init evtchn_init(void)
651 {
652 int err;
653
654 if (!xen_domain())
655 return -ENODEV;
656
657 /* Create '/dev/xen/evtchn'. */
658 err = misc_register(&evtchn_miscdev);
659 if (err != 0) {
660 pr_err("Could not register /dev/xen/evtchn\n");
661 return err;
662 }
663
664 pr_info("Event-channel device installed\n");
665
666 return 0;
667 }
668
669 static void __exit evtchn_cleanup(void)
670 {
671 misc_deregister(&evtchn_miscdev);
672 }
673
674 module_init(evtchn_init);
675 module_exit(evtchn_cleanup);
676
677 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.052663 seconds and 4 git commands to generate.