10SN/A/****************************************************************************** 211926Sserb * evtchn.c 30SN/A * 40SN/A * Driver for receiving and demuxing event-channel signals. 50SN/A * 60SN/A * Copyright (c) 2004-2005, K A Fraser 72362SN/A * Multi-process extensions Copyright (c) 2004, Steven Smith 80SN/A * 92362SN/A * This program is free software; you can redistribute it and/or 100SN/A * modify it under the terms of the GNU General Public License version 2 110SN/A * as published by the Free Software Foundation; or, when distributed 120SN/A * separately from the Linux kernel or incorporated into other 130SN/A * software packages, subject to the following license: 140SN/A * 150SN/A * Permission is hereby granted, free of charge, to any person obtaining a copy 160SN/A * of this source file (the "Software"), to deal in the Software without 170SN/A * restriction, including without limitation the rights to use, copy, modify, 180SN/A * merge, publish, distribute, sublicense, and/or sell copies of the Software, 190SN/A * and to permit persons to whom the Software is furnished to do so, subject to 200SN/A * the following conditions: 212362SN/A * 222362SN/A * The above copyright notice and this permission notice shall be included in 232362SN/A * all copies or substantial portions of the Software. 240SN/A * 250SN/A * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 260SN/A * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 270SN/A * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 280SN/A * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 290SN/A * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 300SN/A * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 3115780Srchamyal * IN THE SOFTWARE. 320SN/A */ 330SN/A 340SN/A#define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt 350SN/A 3615780Srchamyal#include <linux/module.h> 370SN/A#include <linux/kernel.h> 380SN/A#include <linux/sched.h> 3911926Sserb#include <linux/slab.h> 4011926Sserb#include <linux/string.h> 410SN/A#include <linux/errno.h> 420SN/A#include <linux/fs.h> 4315780Srchamyal#include <linux/miscdevice.h> 440SN/A#include <linux/major.h> 459424SN/A#include <linux/proc_fs.h> 4612839Sprr#include <linux/stat.h> 4712839Sprr#include <linux/poll.h> 4812839Sprr#include <linux/irq.h> 490SN/A#include <linux/init.h> 500SN/A#include <linux/mutex.h> 510SN/A#include <linux/cpu.h> 520SN/A#include <linux/mm.h> 530SN/A#include <linux/vmalloc.h> 540SN/A 559424SN/A#include <xen/xen.h> 560SN/A#include <xen/events.h> 570SN/A#include <xen/evtchn.h> 580SN/A#include <xen/xen-ops.h> 590SN/A#include <asm/xen/hypervisor.h> 600SN/A 610SN/Astruct per_user_data { 620SN/A struct mutex bind_mutex; /* serialize bind/unbind operations */ 630SN/A struct rb_root evtchns; 640SN/A unsigned int nr_evtchns; 650SN/A 660SN/A /* Notification ring, accessed via /dev/xen/evtchn. */ 670SN/A unsigned int ring_size; 680SN/A evtchn_port_t *ring; 690SN/A unsigned int ring_cons, ring_prod, ring_overflow; 700SN/A struct mutex ring_cons_mutex; /* protect against concurrent readers */ 710SN/A spinlock_t ring_prod_lock; /* product against concurrent interrupts */ 729424SN/A 730SN/A /* Processes wait on this queue when ring is empty. */ 740SN/A wait_queue_head_t evtchn_wait; 750SN/A struct fasync_struct *evtchn_async_queue; 760SN/A const char *name; 770SN/A 780SN/A domid_t restrict_domid; 790SN/A}; 809424SN/A 810SN/A#define UNRESTRICTED_DOMID ((domid_t)-1) 820SN/A 839424SN/Astruct user_evtchn { 840SN/A struct rb_node node; 850SN/A struct per_user_data *user; 860SN/A evtchn_port_t port; 870SN/A bool enabled; 8811926Sserb bool unbinding; 8911926Sserb}; 9011926Sserb 9111926Sserbstatic void evtchn_free_ring(evtchn_port_t *ring) 9211926Sserb{ 9311926Sserb kvfree(ring); 9411926Sserb} 9511926Sserb 960SN/Astatic unsigned int evtchn_ring_offset(struct per_user_data *u, 9711926Sserb unsigned int idx) 9811926Sserb{ 9911926Sserb return idx & (u->ring_size - 1); 10011926Sserb} 10111926Sserb 10211926Sserbstatic evtchn_port_t *evtchn_ring_entry(struct per_user_data *u, 10311926Sserb unsigned int idx) 10411926Sserb{ 1050SN/A return u->ring + evtchn_ring_offset(u, idx); 1060SN/A} 1079424SN/A 1080SN/Astatic int add_evtchn(struct per_user_data *u, struct user_evtchn *evtchn) 1090SN/A{ 1100SN/A struct rb_node **new = &(u->evtchns.rb_node), *parent = NULL; 1110SN/A 1120SN/A u->nr_evtchns++; 1130SN/A 1140SN/A while (*new) { 1150SN/A struct user_evtchn *this; 1160SN/A 1170SN/A this = rb_entry(*new, struct user_evtchn, node); 1180SN/A 1190SN/A parent = *new; 1200SN/A if (this->port < evtchn->port) 1210SN/A new = &((*new)->rb_left); 1220SN/A else if (this->port > evtchn->port) 1230SN/A new = &((*new)->rb_right); 1240SN/A else 1250SN/A return -EEXIST; 1260SN/A } 1270SN/A 1280SN/A /* Add new node and rebalance tree. */ 12915780Srchamyal rb_link_node(&evtchn->node, parent, new); 13015780Srchamyal rb_insert_color(&evtchn->node, &u->evtchns); 13115780Srchamyal 13215780Srchamyal return 0; 13315780Srchamyal} 13415780Srchamyal 13515780Srchamyalstatic void del_evtchn(struct per_user_data *u, struct user_evtchn *evtchn) 13615780Srchamyal{ 13715780Srchamyal u->nr_evtchns--; 1380SN/A rb_erase(&evtchn->node, &u->evtchns); 1390SN/A kfree(evtchn); 1400SN/A} 1410SN/A 1420SN/Astatic struct user_evtchn *find_evtchn(struct per_user_data *u, 14315780Srchamyal evtchn_port_t port) 14415780Srchamyal{ 1450SN/A struct rb_node *node = u->evtchns.rb_node; 1460SN/A 1470SN/A while (node) { 1480SN/A struct user_evtchn *evtchn; 1490SN/A 1500SN/A evtchn = rb_entry(node, struct user_evtchn, node); 1510SN/A 1520SN/A if (evtchn->port < port) 1530SN/A node = node->rb_left; 1540SN/A else if (evtchn->port > port) 1550SN/A node = node->rb_right; 1560SN/A else 1570SN/A return evtchn; 1580SN/A } 1590SN/A return NULL; 1600SN/A} 1610SN/A 1620SN/Astatic irqreturn_t evtchn_interrupt(int irq, void *data) 1630SN/A{ 1640SN/A struct user_evtchn *evtchn = data; 1650SN/A struct per_user_data *u = evtchn->user; 1660SN/A unsigned int prod, cons; 1670SN/A 1680SN/A /* Handler might be called when tearing down the IRQ. */ 1690SN/A if (evtchn->unbinding) 1700SN/A return IRQ_HANDLED; 1710SN/A 1720SN/A WARN(!evtchn->enabled, 1730SN/A "Interrupt for port %u, but apparently not enabled; per-user %p\n", 1740SN/A evtchn->port, u); 1750SN/A 1760SN/A evtchn->enabled = false; 1770SN/A 1780SN/A spin_lock(&u->ring_prod_lock); 1790SN/A 1800SN/A prod = READ_ONCE(u->ring_prod); 1810SN/A cons = READ_ONCE(u->ring_cons); 1820SN/A 1830SN/A if ((prod - cons) < u->ring_size) { 1840SN/A *evtchn_ring_entry(u, prod) = evtchn->port; 1850SN/A smp_wmb(); /* Ensure ring contents visible */ 1860SN/A WRITE_ONCE(u->ring_prod, prod + 1); 1870SN/A if (cons == prod) { 1880SN/A wake_up_interruptible(&u->evtchn_wait); 1890SN/A kill_fasync(&u->evtchn_async_queue, 1900SN/A SIGIO, POLL_IN); 1910SN/A } 19213629Savstepan } else 1930SN/A u->ring_overflow = 1; 1940SN/A 1950SN/A spin_unlock(&u->ring_prod_lock); 1960SN/A 1970SN/A return IRQ_HANDLED; 1980SN/A} 1990SN/A 2000SN/Astatic ssize_t evtchn_read(struct file *file, char __user *buf, 2010SN/A size_t count, loff_t *ppos) 2020SN/A{ 2039424SN/A int rc; 2040SN/A unsigned int c, p, bytes1 = 0, bytes2 = 0; 2050SN/A struct per_user_data *u = file->private_data; 2060SN/A 2070SN/A /* Whole number of ports. */ 2080SN/A count &= ~(sizeof(evtchn_port_t)-1); 2090SN/A 2100SN/A if (count == 0) 2110SN/A return 0; 2120SN/A 2130SN/A if (count > PAGE_SIZE) 2140SN/A count = PAGE_SIZE; 2150SN/A 2160SN/A for (;;) { 2170SN/A mutex_lock(&u->ring_cons_mutex); 2180SN/A 219 rc = -EFBIG; 220 if (u->ring_overflow) 221 goto unlock_out; 222 223 c = READ_ONCE(u->ring_cons); 224 p = READ_ONCE(u->ring_prod); 225 if (c != p) 226 break; 227 228 mutex_unlock(&u->ring_cons_mutex); 229 230 if (file->f_flags & O_NONBLOCK) 231 return -EAGAIN; 232 233 rc = wait_event_interruptible(u->evtchn_wait, 234 READ_ONCE(u->ring_cons) != READ_ONCE(u->ring_prod)); 235 if (rc) 236 return rc; 237 } 238 239 /* Byte lengths of two chunks. Chunk split (if any) is at ring wrap. */ 240 if (((c ^ p) & u->ring_size) != 0) { 241 bytes1 = (u->ring_size - evtchn_ring_offset(u, c)) * 242 sizeof(evtchn_port_t); 243 bytes2 = evtchn_ring_offset(u, p) * sizeof(evtchn_port_t); 244 } else { 245 bytes1 = (p - c) * sizeof(evtchn_port_t); 246 bytes2 = 0; 247 } 248 249 /* Truncate chunks according to caller's maximum byte count. */ 250 if (bytes1 > count) { 251 bytes1 = count; 252 bytes2 = 0; 253 } else if ((bytes1 + bytes2) > count) { 254 bytes2 = count - bytes1; 255 } 256 257 rc = -EFAULT; 258 smp_rmb(); /* Ensure that we see the port before we copy it. */ 259 if (copy_to_user(buf, evtchn_ring_entry(u, c), bytes1) || 260 ((bytes2 != 0) && 261 copy_to_user(&buf[bytes1], &u->ring[0], bytes2))) 262 goto unlock_out; 263 264 WRITE_ONCE(u->ring_cons, c + (bytes1 + bytes2) / sizeof(evtchn_port_t)); 265 rc = bytes1 + bytes2; 266 267 unlock_out: 268 mutex_unlock(&u->ring_cons_mutex); 269 return rc; 270} 271 272static ssize_t evtchn_write(struct file *file, const char __user *buf, 273 size_t count, loff_t *ppos) 274{ 275 int rc, i; 276 evtchn_port_t *kbuf = (evtchn_port_t *)__get_free_page(GFP_KERNEL); 277 struct per_user_data *u = file->private_data; 278 279 if (kbuf == NULL) 280 return -ENOMEM; 281 282 /* Whole number of ports. */ 283 count &= ~(sizeof(evtchn_port_t)-1); 284 285 rc = 0; 286 if (count == 0) 287 goto out; 288 289 if (count > PAGE_SIZE) 290 count = PAGE_SIZE; 291 292 rc = -EFAULT; 293 if (copy_from_user(kbuf, buf, count) != 0) 294 goto out; 295 296 mutex_lock(&u->bind_mutex); 297 298 for (i = 0; i < (count/sizeof(evtchn_port_t)); i++) { 299 evtchn_port_t port = kbuf[i]; 300 struct user_evtchn *evtchn; 301 302 evtchn = find_evtchn(u, port); 303 if (evtchn && !evtchn->enabled) { 304 evtchn->enabled = true; 305 xen_irq_lateeoi(irq_from_evtchn(port), 0); 306 } 307 } 308 309 mutex_unlock(&u->bind_mutex); 310 311 rc = count; 312 313 out: 314 free_page((unsigned long)kbuf); 315 return rc; 316} 317 318static int evtchn_resize_ring(struct per_user_data *u) 319{ 320 unsigned int new_size; 321 evtchn_port_t *new_ring, *old_ring; 322 323 /* 324 * Ensure the ring is large enough to capture all possible 325 * events. i.e., one free slot for each bound event. 326 */ 327 if (u->nr_evtchns <= u->ring_size) 328 return 0; 329 330 if (u->ring_size == 0) 331 new_size = 64; 332 else 333 new_size = 2 * u->ring_size; 334 335 new_ring = kvmalloc_array(new_size, sizeof(*new_ring), GFP_KERNEL); 336 if (!new_ring) 337 return -ENOMEM; 338 339 old_ring = u->ring; 340 341 /* 342 * Access to the ring contents is serialized by either the 343 * prod /or/ cons lock so take both when resizing. 344 */ 345 mutex_lock(&u->ring_cons_mutex); 346 spin_lock_irq(&u->ring_prod_lock); 347 348 /* 349 * Copy the old ring contents to the new ring. 350 * 351 * To take care of wrapping, a full ring, and the new index 352 * pointing into the second half, simply copy the old contents 353 * twice. 354 * 355 * +---------+ +------------------+ 356 * |34567 12| -> |34567 1234567 12| 357 * +-----p-c-+ +-------c------p---+ 358 */ 359 memcpy(new_ring, old_ring, u->ring_size * sizeof(*u->ring)); 360 memcpy(new_ring + u->ring_size, old_ring, 361 u->ring_size * sizeof(*u->ring)); 362 363 u->ring = new_ring; 364 u->ring_size = new_size; 365 366 spin_unlock_irq(&u->ring_prod_lock); 367 mutex_unlock(&u->ring_cons_mutex); 368 369 evtchn_free_ring(old_ring); 370 371 return 0; 372} 373 374static int evtchn_bind_to_user(struct per_user_data *u, evtchn_port_t port, 375 bool is_static) 376{ 377 struct user_evtchn *evtchn; 378 int rc = 0; 379 380 /* 381 * Ports are never reused, so every caller should pass in a 382 * unique port. 383 * 384 * (Locking not necessary because we haven't registered the 385 * interrupt handler yet, and our caller has already 386 * serialized bind operations.) 387 */ 388 389 evtchn = kzalloc(sizeof(*evtchn), GFP_KERNEL); 390 if (!evtchn) 391 return -ENOMEM; 392 393 evtchn->user = u; 394 evtchn->port = port; 395 evtchn->enabled = true; /* start enabled */ 396 397 rc = add_evtchn(u, evtchn); 398 if (rc < 0) 399 goto err; 400 401 rc = evtchn_resize_ring(u); 402 if (rc < 0) 403 goto err; 404 405 rc = bind_evtchn_to_irqhandler_lateeoi(port, evtchn_interrupt, IRQF_SHARED, 406 u->name, evtchn); 407 if (rc < 0) 408 goto err; 409 410 rc = evtchn_make_refcounted(port, is_static); 411 return rc; 412 413err: 414 /* bind failed, should close the port now */ 415 if (!is_static) 416 xen_evtchn_close(port); 417 418 del_evtchn(u, evtchn); 419 return rc; 420} 421 422static void evtchn_unbind_from_user(struct per_user_data *u, 423 struct user_evtchn *evtchn) 424{ 425 int irq = irq_from_evtchn(evtchn->port); 426 427 BUG_ON(irq < 0); 428 429 evtchn->unbinding = true; 430 unbind_from_irqhandler(irq, evtchn); 431 432 del_evtchn(u, evtchn); 433} 434 435static 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, false); 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, false); 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, false); 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_BIND_STATIC: { 546 struct ioctl_evtchn_bind bind; 547 struct user_evtchn *evtchn; 548 549 rc = -EFAULT; 550 if (copy_from_user(&bind, uarg, sizeof(bind))) 551 break; 552 553 rc = -EISCONN; 554 evtchn = find_evtchn(u, bind.port); 555 if (evtchn) 556 break; 557 558 rc = evtchn_bind_to_user(u, bind.port, true); 559 break; 560 } 561 562 case IOCTL_EVTCHN_NOTIFY: { 563 struct ioctl_evtchn_notify notify; 564 struct user_evtchn *evtchn; 565 566 rc = -EFAULT; 567 if (copy_from_user(¬ify, uarg, sizeof(notify))) 568 break; 569 570 rc = -ENOTCONN; 571 evtchn = find_evtchn(u, notify.port); 572 if (evtchn) { 573 notify_remote_via_evtchn(notify.port); 574 rc = 0; 575 } 576 break; 577 } 578 579 case IOCTL_EVTCHN_RESET: { 580 /* Initialise the ring to empty. Clear errors. */ 581 mutex_lock(&u->ring_cons_mutex); 582 spin_lock_irq(&u->ring_prod_lock); 583 WRITE_ONCE(u->ring_cons, 0); 584 WRITE_ONCE(u->ring_prod, 0); 585 u->ring_overflow = 0; 586 spin_unlock_irq(&u->ring_prod_lock); 587 mutex_unlock(&u->ring_cons_mutex); 588 rc = 0; 589 break; 590 } 591 592 case IOCTL_EVTCHN_RESTRICT_DOMID: { 593 struct ioctl_evtchn_restrict_domid ierd; 594 595 rc = -EACCES; 596 if (u->restrict_domid != UNRESTRICTED_DOMID) 597 break; 598 599 rc = -EFAULT; 600 if (copy_from_user(&ierd, uarg, sizeof(ierd))) 601 break; 602 603 rc = -EINVAL; 604 if (ierd.domid == 0 || ierd.domid >= DOMID_FIRST_RESERVED) 605 break; 606 607 u->restrict_domid = ierd.domid; 608 rc = 0; 609 610 break; 611 } 612 613 default: 614 rc = -ENOSYS; 615 break; 616 } 617 mutex_unlock(&u->bind_mutex); 618 619 return rc; 620} 621 622static __poll_t evtchn_poll(struct file *file, poll_table *wait) 623{ 624 __poll_t mask = EPOLLOUT | EPOLLWRNORM; 625 struct per_user_data *u = file->private_data; 626 627 poll_wait(file, &u->evtchn_wait, wait); 628 if (READ_ONCE(u->ring_cons) != READ_ONCE(u->ring_prod)) 629 mask |= EPOLLIN | EPOLLRDNORM; 630 if (u->ring_overflow) 631 mask = EPOLLERR; 632 return mask; 633} 634 635static int evtchn_fasync(int fd, struct file *filp, int on) 636{ 637 struct per_user_data *u = filp->private_data; 638 return fasync_helper(fd, filp, on, &u->evtchn_async_queue); 639} 640 641static int evtchn_open(struct inode *inode, struct file *filp) 642{ 643 struct per_user_data *u; 644 645 u = kzalloc(sizeof(*u), GFP_KERNEL); 646 if (u == NULL) 647 return -ENOMEM; 648 649 u->name = kasprintf(GFP_KERNEL, "evtchn:%s", current->comm); 650 if (u->name == NULL) { 651 kfree(u); 652 return -ENOMEM; 653 } 654 655 init_waitqueue_head(&u->evtchn_wait); 656 657 mutex_init(&u->bind_mutex); 658 mutex_init(&u->ring_cons_mutex); 659 spin_lock_init(&u->ring_prod_lock); 660 661 u->restrict_domid = UNRESTRICTED_DOMID; 662 663 filp->private_data = u; 664 665 return stream_open(inode, filp); 666} 667 668static int evtchn_release(struct inode *inode, struct file *filp) 669{ 670 struct per_user_data *u = filp->private_data; 671 struct rb_node *node; 672 673 while ((node = u->evtchns.rb_node)) { 674 struct user_evtchn *evtchn; 675 676 evtchn = rb_entry(node, struct user_evtchn, node); 677 disable_irq(irq_from_evtchn(evtchn->port)); 678 evtchn_unbind_from_user(u, evtchn); 679 } 680 681 evtchn_free_ring(u->ring); 682 kfree(u->name); 683 kfree(u); 684 685 return 0; 686} 687 688static const struct file_operations evtchn_fops = { 689 .owner = THIS_MODULE, 690 .read = evtchn_read, 691 .write = evtchn_write, 692 .unlocked_ioctl = evtchn_ioctl, 693 .poll = evtchn_poll, 694 .fasync = evtchn_fasync, 695 .open = evtchn_open, 696 .release = evtchn_release, 697 .llseek = no_llseek, 698}; 699 700static struct miscdevice evtchn_miscdev = { 701 .minor = MISC_DYNAMIC_MINOR, 702 .name = "xen/evtchn", 703 .fops = &evtchn_fops, 704}; 705static int __init evtchn_init(void) 706{ 707 int err; 708 709 if (!xen_domain()) 710 return -ENODEV; 711 712 /* Create '/dev/xen/evtchn'. */ 713 err = misc_register(&evtchn_miscdev); 714 if (err != 0) { 715 pr_err("Could not register /dev/xen/evtchn\n"); 716 return err; 717 } 718 719 pr_info("Event-channel device installed\n"); 720 721 return 0; 722} 723 724static void __exit evtchn_cleanup(void) 725{ 726 misc_deregister(&evtchn_miscdev); 727} 728 729module_init(evtchn_init); 730module_exit(evtchn_cleanup); 731 732MODULE_LICENSE("GPL"); 733