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 <xen/xen-ops.h>
  59 #include <asm/xen/hypervisor.h>
  60
  61 struct per_user_data {
  62         struct mutex bind_mutex; /* serialize bind/unbind operations */
  63         struct rb_root evtchns;
  64         unsigned int nr_evtchns;
  65
  66         /* Notification ring, accessed via /dev/xen/evtchn. */
  67         unsigned int ring_size;
  68         evtchn_port_t *ring;
  69         unsigned int ring_cons, ring_prod, ring_overflow;
  70         struct mutex ring_cons_mutex; /* protect against concurrent readers */
  71         spinlock_t ring_prod_lock; /* product against concurrent interrupts */
  72
  73         /* Processes wait on this queue when ring is empty. */
  74         wait_queue_head_t evtchn_wait;
  75         struct fasync_struct *evtchn_async_queue;
  76         const char *name;
  77
  78         domid_t restrict_domid;
  79 };
  80
  81 #define UNRESTRICTED_DOMID ((domid_t)-1)
  82
  83 struct user_evtchn {
  84         struct rb_node node;
  85         struct per_user_data *user;
  86         unsigned port;
  87         bool enabled;
  88 };
  89
  90 static evtchn_port_t *evtchn_alloc_ring(unsigned int size)
  91 {
  92         evtchn_port_t *ring;
  93         size_t s = size * sizeof(*ring);
  94
  95         ring = kmalloc(s, GFP_KERNEL);
  96         if (!ring)
  97                 ring = vmalloc(s);
  98
  99         return ring;
 100 }
 101
 102 static void evtchn_free_ring(evtchn_port_t *ring)
 103 {
 104         kvfree(ring);
 105 }
 106
 107 static unsigned int evtchn_ring_offset(struct per_user_data *u,
 108                                        unsigned int idx)
 109 {
 110         return idx & (u->ring_size - 1);
 111 }
 112
 113 static evtchn_port_t *evtchn_ring_entry(struct per_user_data *u,
 114                                         unsigned int idx)
 115 {
 116         return u->ring + evtchn_ring_offset(u, idx);
 117 }
 118
 119 static int add_evtchn(struct per_user_data *u, struct user_evtchn *evtchn)
 120 {
 121         struct rb_node **new = &(u->evtchns.rb_node), *parent = NULL;
 122
 123         u->nr_evtchns++;
 124
 125         while (*new) {
 126                 struct user_evtchn *this;
 127
 128                 this = container_of(*new, struct user_evtchn, node);
 129
 130                 parent = *new;
 131                 if (this->port < evtchn->port)
 132                         new = &((*new)->rb_left);
 133                 else if (this->port > evtchn->port)
 134                         new = &((*new)->rb_right);
 135                 else
 136                         return -EEXIST;
 137         }
 138
 139         /* Add new node and rebalance tree. */
 140         rb_link_node(&evtchn->node, parent, new);
 141         rb_insert_color(&evtchn->node, &u->evtchns);
 142
 143         return 0;
 144 }
 145
 146 static void del_evtchn(struct per_user_data *u, struct user_evtchn *evtchn)
 147 {
 148         u->nr_evtchns--;
 149         rb_erase(&evtchn->node, &u->evtchns);
 150         kfree(evtchn);
 151 }
 152
 153 static struct user_evtchn *find_evtchn(struct per_user_data *u, unsigned port)
 154 {
 155         struct rb_node *node = u->evtchns.rb_node;
 156
 157         while (node) {
 158                 struct user_evtchn *evtchn;
 159
 160                 evtchn = container_of(node, struct user_evtchn, node);
 161
 162                 if (evtchn->port < port)
 163                         node = node->rb_left;
 164                 else if (evtchn->port > port)
 165                         node = node->rb_right;
 166                 else
 167                         return evtchn;
 168         }
 169         return NULL;
 170 }
 171
 172 static irqreturn_t evtchn_interrupt(int irq, void *data)
 173 {
 174         struct user_evtchn *evtchn = data;
 175         struct per_user_data *u = evtchn->user;
 176
 177         WARN(!evtchn->enabled,
 178              "Interrupt for port %d, but apparently not enabled; per-user %p\n",
 179              evtchn->port, u);
 180
 181         evtchn->enabled = false;
 182
 183         spin_lock(&u->ring_prod_lock);
 184
 185         if ((u->ring_prod - u->ring_cons) < u->ring_size) {
 186                 *evtchn_ring_entry(u, u->ring_prod) = evtchn->port;
 187                 wmb(); /* Ensure ring contents visible */
 188                 if (u->ring_cons == u->ring_prod++) {
 189                         wake_up_interruptible(&u->evtchn_wait);
 190                         kill_fasync(&u->evtchn_async_queue,
 191                                     SIGIO, POLL_IN);
 192                 }
 193         } else
 194                 u->ring_overflow = 1;
 195
 196         spin_unlock(&u->ring_prod_lock);
 197
 198         return IRQ_HANDLED;
 199 }
 200
 201 static ssize_t evtchn_read(struct file *file, char __user *buf,
 202                            size_t count, loff_t *ppos)
 203 {
 204         int rc;
 205         unsigned int c, p, bytes1 = 0, bytes2 = 0;
 206         struct per_user_data *u = file->private_data;
 207
 208         /* Whole number of ports. */
 209         count &= ~(sizeof(evtchn_port_t)-1);
 210
 211         if (count == 0)
 212                 return 0;
 213
 214         if (count > PAGE_SIZE)
 215                 count = PAGE_SIZE;
 216
 217         for (;;) {
 218                 mutex_lock(&u->ring_cons_mutex);
 219
 220                 rc = -EFBIG;
 221                 if (u->ring_overflow)
 222                         goto unlock_out;
 223
 224                 c = u->ring_cons;
 225                 p = u->ring_prod;
 226                 if (c != p)
 227                         break;
 228
 229                 mutex_unlock(&u->ring_cons_mutex);
 230
 231                 if (file->f_flags & O_NONBLOCK)
 232                         return -EAGAIN;
 233
 234                 rc = wait_event_interruptible(u->evtchn_wait,
 235                                               u->ring_cons != u->ring_prod);
 236                 if (rc)
 237                         return rc;
 238         }
 239
 240         /* Byte lengths of two chunks. Chunk split (if any) is at ring wrap. */
 241         if (((c ^ p) & u->ring_size) != 0) {
 242                 bytes1 = (u->ring_size - evtchn_ring_offset(u, c)) *
 243                         sizeof(evtchn_port_t);
 244                 bytes2 = evtchn_ring_offset(u, p) * sizeof(evtchn_port_t);
 245         } else {
 246                 bytes1 = (p - c) * sizeof(evtchn_port_t);
 247                 bytes2 = 0;
 248         }
 249
 250         /* Truncate chunks according to caller's maximum byte count. */
 251         if (bytes1 > count) {
 252                 bytes1 = count;
 253                 bytes2 = 0;
 254         } else if ((bytes1 + bytes2) > count) {
 255                 bytes2 = count - bytes1;
 256         }
 257
 258         rc = -EFAULT;
 259         rmb(); /* Ensure that we see the port before we copy it. */
 260         if (copy_to_user(buf, evtchn_ring_entry(u, c), bytes1) ||
 261             ((bytes2 != 0) &&
 262              copy_to_user(&buf[bytes1], &u->ring[0], bytes2)))
 263                 goto unlock_out;
 264
 265         u->ring_cons += (bytes1 + bytes2) / sizeof(evtchn_port_t);
 266         rc = bytes1 + bytes2;
 267
 268  unlock_out:
 269         mutex_unlock(&u->ring_cons_mutex);
 270         return rc;
 271 }
 272
 273 static ssize_t evtchn_write(struct file *file, const char __user *buf,
 274                             size_t count, loff_t *ppos)
 275 {
 276         int rc, i;
 277         evtchn_port_t *kbuf = (evtchn_port_t *)__get_free_page(GFP_KERNEL);
 278         struct per_user_data *u = file->private_data;
 279
 280         if (kbuf == NULL)
 281                 return -ENOMEM;
 282
 283         /* Whole number of ports. */
 284         count &= ~(sizeof(evtchn_port_t)-1);
 285
 286         rc = 0;
 287         if (count == 0)
 288                 goto out;
 289
 290         if (count > PAGE_SIZE)
 291                 count = PAGE_SIZE;
 292
 293         rc = -EFAULT;
 294         if (copy_from_user(kbuf, buf, count) != 0)
 295                 goto out;
 296
 297         mutex_lock(&u->bind_mutex);
 298
 299         for (i = 0; i < (count/sizeof(evtchn_port_t)); i++) {
 300                 unsigned port = kbuf[i];
 301                 struct user_evtchn *evtchn;
 302
 303                 evtchn = find_evtchn(u, port);
 304                 if (evtchn && !evtchn->enabled) {
 305                         evtchn->enabled = true;
 306                         xen_irq_lateeoi(irq_from_evtchn(port), 0);
 307                 }
 308         }
 309
 310         mutex_unlock(&u->bind_mutex);
 311
 312         rc = count;
 313
 314  out:
 315         free_page((unsigned long)kbuf);
 316         return rc;
 317 }
 318
 319 static int evtchn_resize_ring(struct per_user_data *u)
 320 {
 321         unsigned int new_size;
 322         evtchn_port_t *new_ring, *old_ring;
 323
 324         /*
 325          * Ensure the ring is large enough to capture all possible
 326          * events. i.e., one free slot for each bound event.
 327          */
 328         if (u->nr_evtchns <= u->ring_size)
 329                 return 0;
 330
 331         if (u->ring_size == 0)
 332                 new_size = 64;
 333         else
 334                 new_size = 2 * u->ring_size;
 335
 336         new_ring = evtchn_alloc_ring(new_size);
 337         if (!new_ring)
 338                 return -ENOMEM;
 339
 340         old_ring = u->ring;
 341
 342         /*
 343          * Access to the ring contents is serialized by either the
 344          * prod /or/ cons lock so take both when resizing.
 345          */
 346         mutex_lock(&u->ring_cons_mutex);
 347         spin_lock_irq(&u->ring_prod_lock);
 348
 349         /*
 350          * Copy the old ring contents to the new ring.
 351          *
 352          * To take care of wrapping, a full ring, and the new index
 353          * pointing into the second half, simply copy the old contents
 354          * twice.
 355          *
 356          * +---------+    +------------------+
 357          * |34567  12| -> |34567  1234567  12|
 358          * +-----p-c-+    +-------c------p---+
 359          */
 360         memcpy(new_ring, old_ring, u->ring_size * sizeof(*u->ring));
 361         memcpy(new_ring + u->ring_size, old_ring,
 362                u->ring_size * 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_lateeoi(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 = -EACCES;
 451                 if (u->restrict_domid != UNRESTRICTED_DOMID)
 452                         break;
 453
 454                 rc = -EFAULT;
 455                 if (copy_from_user(&bind, uarg, sizeof(bind)))
 456                         break;
 457
 458                 bind_virq.virq = bind.virq;
 459                 bind_virq.vcpu = xen_vcpu_nr(0);
 460                 rc = HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq,
 461                                                  &bind_virq);
 462                 if (rc != 0)
 463                         break;
 464
 465                 rc = evtchn_bind_to_user(u, bind_virq.port);
 466                 if (rc == 0)
 467                         rc = bind_virq.port;
 468                 break;
 469         }
 470
 471         case IOCTL_EVTCHN_BIND_INTERDOMAIN: {
 472                 struct ioctl_evtchn_bind_interdomain bind;
 473                 struct evtchn_bind_interdomain bind_interdomain;
 474
 475                 rc = -EFAULT;
 476                 if (copy_from_user(&bind, uarg, sizeof(bind)))
 477                         break;
 478
 479                 rc = -EACCES;
 480                 if (u->restrict_domid != UNRESTRICTED_DOMID &&
 481                     u->restrict_domid != bind.remote_domain)
 482                         break;
 483
 484                 bind_interdomain.remote_dom  = bind.remote_domain;
 485                 bind_interdomain.remote_port = bind.remote_port;
 486                 rc = HYPERVISOR_event_channel_op(EVTCHNOP_bind_interdomain,
 487                                                  &bind_interdomain);
 488                 if (rc != 0)
 489                         break;
 490
 491                 rc = evtchn_bind_to_user(u, bind_interdomain.local_port);
 492                 if (rc == 0)
 493                         rc = bind_interdomain.local_port;
 494                 break;
 495         }
 496
 497         case IOCTL_EVTCHN_BIND_UNBOUND_PORT: {
 498                 struct ioctl_evtchn_bind_unbound_port bind;
 499                 struct evtchn_alloc_unbound alloc_unbound;
 500
 501                 rc = -EACCES;
 502                 if (u->restrict_domid != UNRESTRICTED_DOMID)
 503                         break;
 504
 505                 rc = -EFAULT;
 506                 if (copy_from_user(&bind, uarg, sizeof(bind)))
 507                         break;
 508
 509                 alloc_unbound.dom        = DOMID_SELF;
 510                 alloc_unbound.remote_dom = bind.remote_domain;
 511                 rc = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
 512                                                  &alloc_unbound);
 513                 if (rc != 0)
 514                         break;
 515
 516                 rc = evtchn_bind_to_user(u, alloc_unbound.port);
 517                 if (rc == 0)
 518                         rc = alloc_unbound.port;
 519                 break;
 520         }
 521
 522         case IOCTL_EVTCHN_UNBIND: {
 523                 struct ioctl_evtchn_unbind unbind;
 524                 struct user_evtchn *evtchn;
 525
 526                 rc = -EFAULT;
 527                 if (copy_from_user(&unbind, uarg, sizeof(unbind)))
 528                         break;
 529
 530                 rc = -EINVAL;
 531                 if (unbind.port >= xen_evtchn_nr_channels())
 532                         break;
 533
 534                 rc = -ENOTCONN;
 535                 evtchn = find_evtchn(u, unbind.port);
 536                 if (!evtchn)
 537                         break;
 538
 539                 disable_irq(irq_from_evtchn(unbind.port));
 540                 evtchn_unbind_from_user(u, evtchn);
 541                 rc = 0;
 542                 break;
 543         }
 544
 545         case IOCTL_EVTCHN_NOTIFY: {
 546                 struct ioctl_evtchn_notify notify;
 547                 struct user_evtchn *evtchn;
 548
 549                 rc = -EFAULT;
 550                 if (copy_from_user(&notify, uarg, sizeof(notify)))
 551                         break;
 552
 553                 rc = -ENOTCONN;
 554                 evtchn = find_evtchn(u, notify.port);
 555                 if (evtchn) {
 556                         notify_remote_via_evtchn(notify.port);
 557                         rc = 0;
 558                 }
 559                 break;
 560         }
 561
 562         case IOCTL_EVTCHN_RESET: {
 563                 /* Initialise the ring to empty. Clear errors. */
 564                 mutex_lock(&u->ring_cons_mutex);
 565                 spin_lock_irq(&u->ring_prod_lock);
 566                 u->ring_cons = u->ring_prod = u->ring_overflow = 0;
 567                 spin_unlock_irq(&u->ring_prod_lock);
 568                 mutex_unlock(&u->ring_cons_mutex);
 569                 rc = 0;
 570                 break;
 571         }
 572
 573         case IOCTL_EVTCHN_RESTRICT_DOMID: {
 574                 struct ioctl_evtchn_restrict_domid ierd;
 575
 576                 rc = -EACCES;
 577                 if (u->restrict_domid != UNRESTRICTED_DOMID)
 578                         break;
 579
 580                 rc = -EFAULT;
 581                 if (copy_from_user(&ierd, uarg, sizeof(ierd)))
 582                     break;
 583
 584                 rc = -EINVAL;
 585                 if (ierd.domid == 0 || ierd.domid >= DOMID_FIRST_RESERVED)
 586                         break;
 587
 588                 u->restrict_domid = ierd.domid;
 589                 rc = 0;
 590
 591                 break;
 592         }
 593
 594         default:
 595                 rc = -ENOSYS;
 596                 break;
 597         }
 598         mutex_unlock(&u->bind_mutex);
 599
 600         return rc;
 601 }
 602
 603 static unsigned int evtchn_poll(struct file *file, poll_table *wait)
 604 {
 605         unsigned int mask = POLLOUT | POLLWRNORM;
 606         struct per_user_data *u = file->private_data;
 607
 608         poll_wait(file, &u->evtchn_wait, wait);
 609         if (u->ring_cons != u->ring_prod)
 610                 mask |= POLLIN | POLLRDNORM;
 611         if (u->ring_overflow)
 612                 mask = POLLERR;
 613         return mask;
 614 }
 615
 616 static int evtchn_fasync(int fd, struct file *filp, int on)
 617 {
 618         struct per_user_data *u = filp->private_data;
 619         return fasync_helper(fd, filp, on, &u->evtchn_async_queue);
 620 }
 621
 622 static int evtchn_open(struct inode *inode, struct file *filp)
 623 {
 624         struct per_user_data *u;
 625
 626         u = kzalloc(sizeof(*u), GFP_KERNEL);
 627         if (u == NULL)
 628                 return -ENOMEM;
 629
 630         u->name = kasprintf(GFP_KERNEL, "evtchn:%s", current->comm);
 631         if (u->name == NULL) {
 632                 kfree(u);
 633                 return -ENOMEM;
 634         }
 635
 636         init_waitqueue_head(&u->evtchn_wait);
 637
 638         mutex_init(&u->bind_mutex);
 639         mutex_init(&u->ring_cons_mutex);
 640         spin_lock_init(&u->ring_prod_lock);
 641
 642         u->restrict_domid = UNRESTRICTED_DOMID;
 643
 644         filp->private_data = u;
 645
 646         return nonseekable_open(inode, filp);
 647 }
 648
 649 static int evtchn_release(struct inode *inode, struct file *filp)
 650 {
 651         struct per_user_data *u = filp->private_data;
 652         struct rb_node *node;
 653
 654         while ((node = u->evtchns.rb_node)) {
 655                 struct user_evtchn *evtchn;
 656
 657                 evtchn = rb_entry(node, struct user_evtchn, node);
 658                 disable_irq(irq_from_evtchn(evtchn->port));
 659                 evtchn_unbind_from_user(u, evtchn);
 660         }
 661
 662         evtchn_free_ring(u->ring);
 663         kfree(u->name);
 664         kfree(u);
 665
 666         return 0;
 667 }
 668
 669 static const struct file_operations evtchn_fops = {
 670         .owner   = THIS_MODULE,
 671         .read    = evtchn_read,
 672         .write   = evtchn_write,
 673         .unlocked_ioctl = evtchn_ioctl,
 674         .poll    = evtchn_poll,
 675         .fasync  = evtchn_fasync,
 676         .open    = evtchn_open,
 677         .release = evtchn_release,
 678         .llseek  = no_llseek,
 679 };
 680
 681 static struct miscdevice evtchn_miscdev = {
 682         .minor        = MISC_DYNAMIC_MINOR,
 683         .name         = "xen/evtchn",
 684         .fops         = &evtchn_fops,
 685 };
 686 static int __init evtchn_init(void)
 687 {
 688         int err;
 689
 690         if (!xen_domain())
 691                 return -ENODEV;
 692
 693         /* Create '/dev/xen/evtchn'. */
 694         err = misc_register(&evtchn_miscdev);
 695         if (err != 0) {
 696                 pr_err("Could not register /dev/xen/evtchn\n");
 697                 return err;
 698         }
 699
 700         pr_info("Event-channel device installed\n");
 701
 702         return 0;
 703 }
 704
 705 static void __exit evtchn_cleanup(void)
 706 {
 707         misc_deregister(&evtchn_miscdev);
 708 }
 709
 710 module_init(evtchn_init);
 711 module_exit(evtchn_cleanup);
 712
 713 MODULE_LICENSE("GPL");