vfio_pci_intrs.c revision 9dbdfd23b7638d054f3b0e70c64dfb9f297f2a9f
1/* 2 * VFIO PCI interrupt handling 3 * 4 * Copyright (C) 2012 Red Hat, Inc. All rights reserved. 5 * Author: Alex Williamson <alex.williamson@redhat.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * Derived from original vfio: 12 * Copyright 2010 Cisco Systems, Inc. All rights reserved. 13 * Author: Tom Lyon, pugs@cisco.com 14 */ 15 16#include <linux/device.h> 17#include <linux/interrupt.h> 18#include <linux/eventfd.h> 19#include <linux/pci.h> 20#include <linux/file.h> 21#include <linux/poll.h> 22#include <linux/vfio.h> 23#include <linux/wait.h> 24#include <linux/workqueue.h> 25 26#include "vfio_pci_private.h" 27 28/* 29 * IRQfd - generic 30 */ 31struct virqfd { 32 struct vfio_pci_device *vdev; 33 struct eventfd_ctx *eventfd; 34 int (*handler)(struct vfio_pci_device *, void *); 35 void (*thread)(struct vfio_pci_device *, void *); 36 void *data; 37 struct work_struct inject; 38 wait_queue_t wait; 39 poll_table pt; 40 struct work_struct shutdown; 41 struct virqfd **pvirqfd; 42}; 43 44static struct workqueue_struct *vfio_irqfd_cleanup_wq; 45 46int __init vfio_pci_virqfd_init(void) 47{ 48 vfio_irqfd_cleanup_wq = 49 create_singlethread_workqueue("vfio-irqfd-cleanup"); 50 if (!vfio_irqfd_cleanup_wq) 51 return -ENOMEM; 52 53 return 0; 54} 55 56void vfio_pci_virqfd_exit(void) 57{ 58 destroy_workqueue(vfio_irqfd_cleanup_wq); 59} 60 61static void virqfd_deactivate(struct virqfd *virqfd) 62{ 63 queue_work(vfio_irqfd_cleanup_wq, &virqfd->shutdown); 64} 65 66static int virqfd_wakeup(wait_queue_t *wait, unsigned mode, int sync, void *key) 67{ 68 struct virqfd *virqfd = container_of(wait, struct virqfd, wait); 69 unsigned long flags = (unsigned long)key; 70 71 if (flags & POLLIN) { 72 /* An event has been signaled, call function */ 73 if ((!virqfd->handler || 74 virqfd->handler(virqfd->vdev, virqfd->data)) && 75 virqfd->thread) 76 schedule_work(&virqfd->inject); 77 } 78 79 if (flags & POLLHUP) { 80 unsigned long flags; 81 spin_lock_irqsave(&virqfd->vdev->irqlock, flags); 82 83 /* 84 * The eventfd is closing, if the virqfd has not yet been 85 * queued for release, as determined by testing whether the 86 * vdev pointer to it is still valid, queue it now. As 87 * with kvm irqfds, we know we won't race against the virqfd 88 * going away because we hold wqh->lock to get here. 89 */ 90 if (*(virqfd->pvirqfd) == virqfd) { 91 *(virqfd->pvirqfd) = NULL; 92 virqfd_deactivate(virqfd); 93 } 94 95 spin_unlock_irqrestore(&virqfd->vdev->irqlock, flags); 96 } 97 98 return 0; 99} 100 101static void virqfd_ptable_queue_proc(struct file *file, 102 wait_queue_head_t *wqh, poll_table *pt) 103{ 104 struct virqfd *virqfd = container_of(pt, struct virqfd, pt); 105 add_wait_queue(wqh, &virqfd->wait); 106} 107 108static void virqfd_shutdown(struct work_struct *work) 109{ 110 struct virqfd *virqfd = container_of(work, struct virqfd, shutdown); 111 u64 cnt; 112 113 eventfd_ctx_remove_wait_queue(virqfd->eventfd, &virqfd->wait, &cnt); 114 flush_work(&virqfd->inject); 115 eventfd_ctx_put(virqfd->eventfd); 116 117 kfree(virqfd); 118} 119 120static void virqfd_inject(struct work_struct *work) 121{ 122 struct virqfd *virqfd = container_of(work, struct virqfd, inject); 123 if (virqfd->thread) 124 virqfd->thread(virqfd->vdev, virqfd->data); 125} 126 127static int virqfd_enable(struct vfio_pci_device *vdev, 128 int (*handler)(struct vfio_pci_device *, void *), 129 void (*thread)(struct vfio_pci_device *, void *), 130 void *data, struct virqfd **pvirqfd, int fd) 131{ 132 struct file *file = NULL; 133 struct eventfd_ctx *ctx = NULL; 134 struct virqfd *virqfd; 135 int ret = 0; 136 unsigned int events; 137 138 virqfd = kzalloc(sizeof(*virqfd), GFP_KERNEL); 139 if (!virqfd) 140 return -ENOMEM; 141 142 virqfd->pvirqfd = pvirqfd; 143 virqfd->vdev = vdev; 144 virqfd->handler = handler; 145 virqfd->thread = thread; 146 virqfd->data = data; 147 148 INIT_WORK(&virqfd->shutdown, virqfd_shutdown); 149 INIT_WORK(&virqfd->inject, virqfd_inject); 150 151 file = eventfd_fget(fd); 152 if (IS_ERR(file)) { 153 ret = PTR_ERR(file); 154 goto fail; 155 } 156 157 ctx = eventfd_ctx_fileget(file); 158 if (IS_ERR(ctx)) { 159 ret = PTR_ERR(ctx); 160 goto fail; 161 } 162 163 virqfd->eventfd = ctx; 164 165 /* 166 * virqfds can be released by closing the eventfd or directly 167 * through ioctl. These are both done through a workqueue, so 168 * we update the pointer to the virqfd under lock to avoid 169 * pushing multiple jobs to release the same virqfd. 170 */ 171 spin_lock_irq(&vdev->irqlock); 172 173 if (*pvirqfd) { 174 spin_unlock_irq(&vdev->irqlock); 175 ret = -EBUSY; 176 goto fail; 177 } 178 *pvirqfd = virqfd; 179 180 spin_unlock_irq(&vdev->irqlock); 181 182 /* 183 * Install our own custom wake-up handling so we are notified via 184 * a callback whenever someone signals the underlying eventfd. 185 */ 186 init_waitqueue_func_entry(&virqfd->wait, virqfd_wakeup); 187 init_poll_funcptr(&virqfd->pt, virqfd_ptable_queue_proc); 188 189 events = file->f_op->poll(file, &virqfd->pt); 190 191 /* 192 * Check if there was an event already pending on the eventfd 193 * before we registered and trigger it as if we didn't miss it. 194 */ 195 if (events & POLLIN) { 196 if ((!handler || handler(vdev, data)) && thread) 197 schedule_work(&virqfd->inject); 198 } 199 200 /* 201 * Do not drop the file until the irqfd is fully initialized, 202 * otherwise we might race against the POLLHUP. 203 */ 204 fput(file); 205 206 return 0; 207 208fail: 209 if (ctx && !IS_ERR(ctx)) 210 eventfd_ctx_put(ctx); 211 212 if (file && !IS_ERR(file)) 213 fput(file); 214 215 kfree(virqfd); 216 217 return ret; 218} 219 220static void virqfd_disable(struct vfio_pci_device *vdev, 221 struct virqfd **pvirqfd) 222{ 223 unsigned long flags; 224 225 spin_lock_irqsave(&vdev->irqlock, flags); 226 227 if (*pvirqfd) { 228 virqfd_deactivate(*pvirqfd); 229 *pvirqfd = NULL; 230 } 231 232 spin_unlock_irqrestore(&vdev->irqlock, flags); 233 234 /* 235 * Block until we know all outstanding shutdown jobs have completed. 236 * Even if we don't queue the job, flush the wq to be sure it's 237 * been released. 238 */ 239 flush_workqueue(vfio_irqfd_cleanup_wq); 240} 241 242/* 243 * INTx 244 */ 245static void vfio_send_intx_eventfd(struct vfio_pci_device *vdev, void *unused) 246{ 247 if (likely(is_intx(vdev) && !vdev->virq_disabled)) 248 eventfd_signal(vdev->ctx[0].trigger, 1); 249} 250 251void vfio_pci_intx_mask(struct vfio_pci_device *vdev) 252{ 253 struct pci_dev *pdev = vdev->pdev; 254 unsigned long flags; 255 256 spin_lock_irqsave(&vdev->irqlock, flags); 257 258 /* 259 * Masking can come from interrupt, ioctl, or config space 260 * via INTx disable. The latter means this can get called 261 * even when not using intx delivery. In this case, just 262 * try to have the physical bit follow the virtual bit. 263 */ 264 if (unlikely(!is_intx(vdev))) { 265 if (vdev->pci_2_3) 266 pci_intx(pdev, 0); 267 } else if (!vdev->ctx[0].masked) { 268 /* 269 * Can't use check_and_mask here because we always want to 270 * mask, not just when something is pending. 271 */ 272 if (vdev->pci_2_3) 273 pci_intx(pdev, 0); 274 else 275 disable_irq_nosync(pdev->irq); 276 277 vdev->ctx[0].masked = true; 278 } 279 280 spin_unlock_irqrestore(&vdev->irqlock, flags); 281} 282 283/* 284 * If this is triggered by an eventfd, we can't call eventfd_signal 285 * or else we'll deadlock on the eventfd wait queue. Return >0 when 286 * a signal is necessary, which can then be handled via a work queue 287 * or directly depending on the caller. 288 */ 289int vfio_pci_intx_unmask_handler(struct vfio_pci_device *vdev, void *unused) 290{ 291 struct pci_dev *pdev = vdev->pdev; 292 unsigned long flags; 293 int ret = 0; 294 295 spin_lock_irqsave(&vdev->irqlock, flags); 296 297 /* 298 * Unmasking comes from ioctl or config, so again, have the 299 * physical bit follow the virtual even when not using INTx. 300 */ 301 if (unlikely(!is_intx(vdev))) { 302 if (vdev->pci_2_3) 303 pci_intx(pdev, 1); 304 } else if (vdev->ctx[0].masked && !vdev->virq_disabled) { 305 /* 306 * A pending interrupt here would immediately trigger, 307 * but we can avoid that overhead by just re-sending 308 * the interrupt to the user. 309 */ 310 if (vdev->pci_2_3) { 311 if (!pci_check_and_unmask_intx(pdev)) 312 ret = 1; 313 } else 314 enable_irq(pdev->irq); 315 316 vdev->ctx[0].masked = (ret > 0); 317 } 318 319 spin_unlock_irqrestore(&vdev->irqlock, flags); 320 321 return ret; 322} 323 324void vfio_pci_intx_unmask(struct vfio_pci_device *vdev) 325{ 326 if (vfio_pci_intx_unmask_handler(vdev, NULL) > 0) 327 vfio_send_intx_eventfd(vdev, NULL); 328} 329 330static irqreturn_t vfio_intx_handler(int irq, void *dev_id) 331{ 332 struct vfio_pci_device *vdev = dev_id; 333 unsigned long flags; 334 int ret = IRQ_NONE; 335 336 spin_lock_irqsave(&vdev->irqlock, flags); 337 338 if (!vdev->pci_2_3) { 339 disable_irq_nosync(vdev->pdev->irq); 340 vdev->ctx[0].masked = true; 341 ret = IRQ_HANDLED; 342 } else if (!vdev->ctx[0].masked && /* may be shared */ 343 pci_check_and_mask_intx(vdev->pdev)) { 344 vdev->ctx[0].masked = true; 345 ret = IRQ_HANDLED; 346 } 347 348 spin_unlock_irqrestore(&vdev->irqlock, flags); 349 350 if (ret == IRQ_HANDLED) 351 vfio_send_intx_eventfd(vdev, NULL); 352 353 return ret; 354} 355 356static int vfio_intx_enable(struct vfio_pci_device *vdev) 357{ 358 if (!is_irq_none(vdev)) 359 return -EINVAL; 360 361 if (!vdev->pdev->irq) 362 return -ENODEV; 363 364 vdev->ctx = kzalloc(sizeof(struct vfio_pci_irq_ctx), GFP_KERNEL); 365 if (!vdev->ctx) 366 return -ENOMEM; 367 368 vdev->num_ctx = 1; 369 vdev->irq_type = VFIO_PCI_INTX_IRQ_INDEX; 370 371 return 0; 372} 373 374static int vfio_intx_set_signal(struct vfio_pci_device *vdev, int fd) 375{ 376 struct pci_dev *pdev = vdev->pdev; 377 unsigned long irqflags = IRQF_SHARED; 378 struct eventfd_ctx *trigger; 379 unsigned long flags; 380 int ret; 381 382 if (vdev->ctx[0].trigger) { 383 free_irq(pdev->irq, vdev); 384 kfree(vdev->ctx[0].name); 385 eventfd_ctx_put(vdev->ctx[0].trigger); 386 vdev->ctx[0].trigger = NULL; 387 } 388 389 if (fd < 0) /* Disable only */ 390 return 0; 391 392 vdev->ctx[0].name = kasprintf(GFP_KERNEL, "vfio-intx(%s)", 393 pci_name(pdev)); 394 if (!vdev->ctx[0].name) 395 return -ENOMEM; 396 397 trigger = eventfd_ctx_fdget(fd); 398 if (IS_ERR(trigger)) { 399 kfree(vdev->ctx[0].name); 400 return PTR_ERR(trigger); 401 } 402 403 vdev->ctx[0].trigger = trigger; 404 405 if (!vdev->pci_2_3) 406 irqflags = 0; 407 408 ret = request_irq(pdev->irq, vfio_intx_handler, 409 irqflags, vdev->ctx[0].name, vdev); 410 if (ret) { 411 vdev->ctx[0].trigger = NULL; 412 kfree(vdev->ctx[0].name); 413 eventfd_ctx_put(trigger); 414 return ret; 415 } 416 417 /* 418 * INTx disable will stick across the new irq setup, 419 * disable_irq won't. 420 */ 421 spin_lock_irqsave(&vdev->irqlock, flags); 422 if (!vdev->pci_2_3 && (vdev->ctx[0].masked || vdev->virq_disabled)) 423 disable_irq_nosync(pdev->irq); 424 spin_unlock_irqrestore(&vdev->irqlock, flags); 425 426 return 0; 427} 428 429static void vfio_intx_disable(struct vfio_pci_device *vdev) 430{ 431 vfio_intx_set_signal(vdev, -1); 432 virqfd_disable(vdev, &vdev->ctx[0].unmask); 433 virqfd_disable(vdev, &vdev->ctx[0].mask); 434 vdev->irq_type = VFIO_PCI_NUM_IRQS; 435 vdev->num_ctx = 0; 436 kfree(vdev->ctx); 437} 438 439/* 440 * MSI/MSI-X 441 */ 442static irqreturn_t vfio_msihandler(int irq, void *arg) 443{ 444 struct eventfd_ctx *trigger = arg; 445 446 eventfd_signal(trigger, 1); 447 return IRQ_HANDLED; 448} 449 450static int vfio_msi_enable(struct vfio_pci_device *vdev, int nvec, bool msix) 451{ 452 struct pci_dev *pdev = vdev->pdev; 453 int ret; 454 455 if (!is_irq_none(vdev)) 456 return -EINVAL; 457 458 vdev->ctx = kzalloc(nvec * sizeof(struct vfio_pci_irq_ctx), GFP_KERNEL); 459 if (!vdev->ctx) 460 return -ENOMEM; 461 462 if (msix) { 463 int i; 464 465 vdev->msix = kzalloc(nvec * sizeof(struct msix_entry), 466 GFP_KERNEL); 467 if (!vdev->msix) { 468 kfree(vdev->ctx); 469 return -ENOMEM; 470 } 471 472 for (i = 0; i < nvec; i++) 473 vdev->msix[i].entry = i; 474 475 ret = pci_enable_msix(pdev, vdev->msix, nvec); 476 if (ret) { 477 kfree(vdev->msix); 478 kfree(vdev->ctx); 479 return ret; 480 } 481 } else { 482 ret = pci_enable_msi_block(pdev, nvec); 483 if (ret) { 484 kfree(vdev->ctx); 485 return ret; 486 } 487 } 488 489 vdev->num_ctx = nvec; 490 vdev->irq_type = msix ? VFIO_PCI_MSIX_IRQ_INDEX : 491 VFIO_PCI_MSI_IRQ_INDEX; 492 493 if (!msix) { 494 /* 495 * Compute the virtual hardware field for max msi vectors - 496 * it is the log base 2 of the number of vectors. 497 */ 498 vdev->msi_qmax = fls(nvec * 2 - 1) - 1; 499 } 500 501 return 0; 502} 503 504static int vfio_msi_set_vector_signal(struct vfio_pci_device *vdev, 505 int vector, int fd, bool msix) 506{ 507 struct pci_dev *pdev = vdev->pdev; 508 int irq = msix ? vdev->msix[vector].vector : pdev->irq + vector; 509 char *name = msix ? "vfio-msix" : "vfio-msi"; 510 struct eventfd_ctx *trigger; 511 int ret; 512 513 if (vector >= vdev->num_ctx) 514 return -EINVAL; 515 516 if (vdev->ctx[vector].trigger) { 517 free_irq(irq, vdev->ctx[vector].trigger); 518 kfree(vdev->ctx[vector].name); 519 eventfd_ctx_put(vdev->ctx[vector].trigger); 520 vdev->ctx[vector].trigger = NULL; 521 } 522 523 if (fd < 0) 524 return 0; 525 526 vdev->ctx[vector].name = kasprintf(GFP_KERNEL, "%s[%d](%s)", 527 name, vector, pci_name(pdev)); 528 if (!vdev->ctx[vector].name) 529 return -ENOMEM; 530 531 trigger = eventfd_ctx_fdget(fd); 532 if (IS_ERR(trigger)) { 533 kfree(vdev->ctx[vector].name); 534 return PTR_ERR(trigger); 535 } 536 537 ret = request_irq(irq, vfio_msihandler, 0, 538 vdev->ctx[vector].name, trigger); 539 if (ret) { 540 kfree(vdev->ctx[vector].name); 541 eventfd_ctx_put(trigger); 542 return ret; 543 } 544 545 vdev->ctx[vector].trigger = trigger; 546 547 return 0; 548} 549 550static int vfio_msi_set_block(struct vfio_pci_device *vdev, unsigned start, 551 unsigned count, int32_t *fds, bool msix) 552{ 553 int i, j, ret = 0; 554 555 if (start + count > vdev->num_ctx) 556 return -EINVAL; 557 558 for (i = 0, j = start; i < count && !ret; i++, j++) { 559 int fd = fds ? fds[i] : -1; 560 ret = vfio_msi_set_vector_signal(vdev, j, fd, msix); 561 } 562 563 if (ret) { 564 for (--j; j >= start; j--) 565 vfio_msi_set_vector_signal(vdev, j, -1, msix); 566 } 567 568 return ret; 569} 570 571static void vfio_msi_disable(struct vfio_pci_device *vdev, bool msix) 572{ 573 struct pci_dev *pdev = vdev->pdev; 574 int i; 575 576 vfio_msi_set_block(vdev, 0, vdev->num_ctx, NULL, msix); 577 578 for (i = 0; i < vdev->num_ctx; i++) { 579 virqfd_disable(vdev, &vdev->ctx[i].unmask); 580 virqfd_disable(vdev, &vdev->ctx[i].mask); 581 } 582 583 if (msix) { 584 pci_disable_msix(vdev->pdev); 585 kfree(vdev->msix); 586 } else 587 pci_disable_msi(pdev); 588 589 vdev->irq_type = VFIO_PCI_NUM_IRQS; 590 vdev->num_ctx = 0; 591 kfree(vdev->ctx); 592} 593 594/* 595 * IOCTL support 596 */ 597static int vfio_pci_set_intx_unmask(struct vfio_pci_device *vdev, 598 unsigned index, unsigned start, 599 unsigned count, uint32_t flags, void *data) 600{ 601 if (!is_intx(vdev) || start != 0 || count != 1) 602 return -EINVAL; 603 604 if (flags & VFIO_IRQ_SET_DATA_NONE) { 605 vfio_pci_intx_unmask(vdev); 606 } else if (flags & VFIO_IRQ_SET_DATA_BOOL) { 607 uint8_t unmask = *(uint8_t *)data; 608 if (unmask) 609 vfio_pci_intx_unmask(vdev); 610 } else if (flags & VFIO_IRQ_SET_DATA_EVENTFD) { 611 int32_t fd = *(int32_t *)data; 612 if (fd >= 0) 613 return virqfd_enable(vdev, vfio_pci_intx_unmask_handler, 614 vfio_send_intx_eventfd, NULL, 615 &vdev->ctx[0].unmask, fd); 616 617 virqfd_disable(vdev, &vdev->ctx[0].unmask); 618 } 619 620 return 0; 621} 622 623static int vfio_pci_set_intx_mask(struct vfio_pci_device *vdev, 624 unsigned index, unsigned start, 625 unsigned count, uint32_t flags, void *data) 626{ 627 if (!is_intx(vdev) || start != 0 || count != 1) 628 return -EINVAL; 629 630 if (flags & VFIO_IRQ_SET_DATA_NONE) { 631 vfio_pci_intx_mask(vdev); 632 } else if (flags & VFIO_IRQ_SET_DATA_BOOL) { 633 uint8_t mask = *(uint8_t *)data; 634 if (mask) 635 vfio_pci_intx_mask(vdev); 636 } else if (flags & VFIO_IRQ_SET_DATA_EVENTFD) { 637 return -ENOTTY; /* XXX implement me */ 638 } 639 640 return 0; 641} 642 643static int vfio_pci_set_intx_trigger(struct vfio_pci_device *vdev, 644 unsigned index, unsigned start, 645 unsigned count, uint32_t flags, void *data) 646{ 647 if (is_intx(vdev) && !count && (flags & VFIO_IRQ_SET_DATA_NONE)) { 648 vfio_intx_disable(vdev); 649 return 0; 650 } 651 652 if (!(is_intx(vdev) || is_irq_none(vdev)) || start != 0 || count != 1) 653 return -EINVAL; 654 655 if (flags & VFIO_IRQ_SET_DATA_EVENTFD) { 656 int32_t fd = *(int32_t *)data; 657 int ret; 658 659 if (is_intx(vdev)) 660 return vfio_intx_set_signal(vdev, fd); 661 662 ret = vfio_intx_enable(vdev); 663 if (ret) 664 return ret; 665 666 ret = vfio_intx_set_signal(vdev, fd); 667 if (ret) 668 vfio_intx_disable(vdev); 669 670 return ret; 671 } 672 673 if (!is_intx(vdev)) 674 return -EINVAL; 675 676 if (flags & VFIO_IRQ_SET_DATA_NONE) { 677 vfio_send_intx_eventfd(vdev, NULL); 678 } else if (flags & VFIO_IRQ_SET_DATA_BOOL) { 679 uint8_t trigger = *(uint8_t *)data; 680 if (trigger) 681 vfio_send_intx_eventfd(vdev, NULL); 682 } 683 return 0; 684} 685 686static int vfio_pci_set_msi_trigger(struct vfio_pci_device *vdev, 687 unsigned index, unsigned start, 688 unsigned count, uint32_t flags, void *data) 689{ 690 int i; 691 bool msix = (index == VFIO_PCI_MSIX_IRQ_INDEX) ? true : false; 692 693 if (irq_is(vdev, index) && !count && (flags & VFIO_IRQ_SET_DATA_NONE)) { 694 vfio_msi_disable(vdev, msix); 695 return 0; 696 } 697 698 if (!(irq_is(vdev, index) || is_irq_none(vdev))) 699 return -EINVAL; 700 701 if (flags & VFIO_IRQ_SET_DATA_EVENTFD) { 702 int32_t *fds = data; 703 int ret; 704 705 if (vdev->irq_type == index) 706 return vfio_msi_set_block(vdev, start, count, 707 fds, msix); 708 709 ret = vfio_msi_enable(vdev, start + count, msix); 710 if (ret) 711 return ret; 712 713 ret = vfio_msi_set_block(vdev, start, count, fds, msix); 714 if (ret) 715 vfio_msi_disable(vdev, msix); 716 717 return ret; 718 } 719 720 if (!irq_is(vdev, index) || start + count > vdev->num_ctx) 721 return -EINVAL; 722 723 for (i = start; i < start + count; i++) { 724 if (!vdev->ctx[i].trigger) 725 continue; 726 if (flags & VFIO_IRQ_SET_DATA_NONE) { 727 eventfd_signal(vdev->ctx[i].trigger, 1); 728 } else if (flags & VFIO_IRQ_SET_DATA_BOOL) { 729 uint8_t *bools = data; 730 if (bools[i - start]) 731 eventfd_signal(vdev->ctx[i].trigger, 1); 732 } 733 } 734 return 0; 735} 736 737int vfio_pci_set_irqs_ioctl(struct vfio_pci_device *vdev, uint32_t flags, 738 unsigned index, unsigned start, unsigned count, 739 void *data) 740{ 741 int (*func)(struct vfio_pci_device *vdev, unsigned index, 742 unsigned start, unsigned count, uint32_t flags, 743 void *data) = NULL; 744 745 switch (index) { 746 case VFIO_PCI_INTX_IRQ_INDEX: 747 switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) { 748 case VFIO_IRQ_SET_ACTION_MASK: 749 func = vfio_pci_set_intx_mask; 750 break; 751 case VFIO_IRQ_SET_ACTION_UNMASK: 752 func = vfio_pci_set_intx_unmask; 753 break; 754 case VFIO_IRQ_SET_ACTION_TRIGGER: 755 func = vfio_pci_set_intx_trigger; 756 break; 757 } 758 break; 759 case VFIO_PCI_MSI_IRQ_INDEX: 760 case VFIO_PCI_MSIX_IRQ_INDEX: 761 switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) { 762 case VFIO_IRQ_SET_ACTION_MASK: 763 case VFIO_IRQ_SET_ACTION_UNMASK: 764 /* XXX Need masking support exported */ 765 break; 766 case VFIO_IRQ_SET_ACTION_TRIGGER: 767 func = vfio_pci_set_msi_trigger; 768 break; 769 } 770 break; 771 } 772 773 if (!func) 774 return -ENOTTY; 775 776 return func(vdev, index, start, count, flags, data); 777} 778