drivers/vfio/pci/vfio_pci_intrs.c

   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/msi.h>
  20 #include <linux/pci.h>
  21 #include <linux/file.h>
  22 #include <linux/vfio.h>
  23 #include <linux/wait.h>
  24 #include <linux/slab.h>
  25
  26 #include "vfio_pci_private.h"
  27
  28 /*
  29  * INTx
  30  */
  31 static void vfio_send_intx_eventfd(void *opaque, void *unused)
  32 {
  33         struct vfio_pci_device *vdev = opaque;
  34
  35         if (likely(is_intx(vdev) && !vdev->virq_disabled))
  36                 eventfd_signal(vdev->ctx[0].trigger, 1);
  37 }
  38
  39 void vfio_pci_intx_mask(struct vfio_pci_device *vdev)
  40 {
  41         struct pci_dev *pdev = vdev->pdev;
  42         unsigned long flags;
  43
  44         spin_lock_irqsave(&vdev->irqlock, flags);
  45
  46         /*
  47          * Masking can come from interrupt, ioctl, or config space
  48          * via INTx disable.  The latter means this can get called
  49          * even when not using intx delivery.  In this case, just
  50          * try to have the physical bit follow the virtual bit.
  51          */
  52         if (unlikely(!is_intx(vdev))) {
  53                 if (vdev->pci_2_3)
  54                         pci_intx(pdev, 0);
  55         } else if (!vdev->ctx[0].masked) {
  56                 /*
  57                  * Can't use check_and_mask here because we always want to
  58                  * mask, not just when something is pending.
  59                  */
  60                 if (vdev->pci_2_3)
  61                         pci_intx(pdev, 0);
  62                 else
  63                         disable_irq_nosync(pdev->irq);
  64
  65                 vdev->ctx[0].masked = true;
  66         }
  67
  68         spin_unlock_irqrestore(&vdev->irqlock, flags);
  69 }
  70
  71 /*
  72  * If this is triggered by an eventfd, we can't call eventfd_signal
  73  * or else we'll deadlock on the eventfd wait queue.  Return >0 when
  74  * a signal is necessary, which can then be handled via a work queue
  75  * or directly depending on the caller.
  76  */
  77 static int vfio_pci_intx_unmask_handler(void *opaque, void *unused)
  78 {
  79         struct vfio_pci_device *vdev = opaque;
  80         struct pci_dev *pdev = vdev->pdev;
  81         unsigned long flags;
  82         int ret = 0;
  83
  84         spin_lock_irqsave(&vdev->irqlock, flags);
  85
  86         /*
  87          * Unmasking comes from ioctl or config, so again, have the
  88          * physical bit follow the virtual even when not using INTx.
  89          */
  90         if (unlikely(!is_intx(vdev))) {
  91                 if (vdev->pci_2_3)
  92                         pci_intx(pdev, 1);
  93         } else if (vdev->ctx[0].masked && !vdev->virq_disabled) {
  94                 /*
  95                  * A pending interrupt here would immediately trigger,
  96                  * but we can avoid that overhead by just re-sending
  97                  * the interrupt to the user.
  98                  */
  99                 if (vdev->pci_2_3) {
 100                         if (!pci_check_and_unmask_intx(pdev))
 101                                 ret = 1;
 102                 } else
 103                         enable_irq(pdev->irq);
 104
 105                 vdev->ctx[0].masked = (ret > 0);
 106         }
 107
 108         spin_unlock_irqrestore(&vdev->irqlock, flags);
 109
 110         return ret;
 111 }
 112
 113 void vfio_pci_intx_unmask(struct vfio_pci_device *vdev)
 114 {
 115         if (vfio_pci_intx_unmask_handler(vdev, NULL) > 0)
 116                 vfio_send_intx_eventfd(vdev, NULL);
 117 }
 118
 119 static irqreturn_t vfio_intx_handler(int irq, void *dev_id)
 120 {
 121         struct vfio_pci_device *vdev = dev_id;
 122         unsigned long flags;
 123         int ret = IRQ_NONE;
 124
 125         spin_lock_irqsave(&vdev->irqlock, flags);
 126
 127         if (!vdev->pci_2_3) {
 128                 disable_irq_nosync(vdev->pdev->irq);
 129                 vdev->ctx[0].masked = true;
 130                 ret = IRQ_HANDLED;
 131         } else if (!vdev->ctx[0].masked &&  /* may be shared */
 132                    pci_check_and_mask_intx(vdev->pdev)) {
 133                 vdev->ctx[0].masked = true;
 134                 ret = IRQ_HANDLED;
 135         }
 136
 137         spin_unlock_irqrestore(&vdev->irqlock, flags);
 138
 139         if (ret == IRQ_HANDLED)
 140                 vfio_send_intx_eventfd(vdev, NULL);
 141
 142         return ret;
 143 }
 144
 145 static int vfio_intx_enable(struct vfio_pci_device *vdev)
 146 {
 147         if (!is_irq_none(vdev))
 148                 return -EINVAL;
 149
 150         if (!vdev->pdev->irq)
 151                 return -ENODEV;
 152
 153         vdev->ctx = kzalloc(sizeof(struct vfio_pci_irq_ctx), GFP_KERNEL);
 154         if (!vdev->ctx)
 155                 return -ENOMEM;
 156
 157         vdev->num_ctx = 1;
 158
 159         /*
 160          * If the virtual interrupt is masked, restore it.  Devices
 161          * supporting DisINTx can be masked at the hardware level
 162          * here, non-PCI-2.3 devices will have to wait until the
 163          * interrupt is enabled.
 164          */
 165         vdev->ctx[0].masked = vdev->virq_disabled;
 166         if (vdev->pci_2_3)
 167                 pci_intx(vdev->pdev, !vdev->ctx[0].masked);
 168
 169         vdev->irq_type = VFIO_PCI_INTX_IRQ_INDEX;
 170
 171         return 0;
 172 }
 173
 174 static int vfio_intx_set_signal(struct vfio_pci_device *vdev, int fd)
 175 {
 176         struct pci_dev *pdev = vdev->pdev;
 177         unsigned long irqflags = IRQF_SHARED;
 178         struct eventfd_ctx *trigger;
 179         unsigned long flags;
 180         int ret;
 181
 182         if (vdev->ctx[0].trigger) {
 183                 free_irq(pdev->irq, vdev);
 184                 kfree(vdev->ctx[0].name);
 185                 eventfd_ctx_put(vdev->ctx[0].trigger);
 186                 vdev->ctx[0].trigger = NULL;
 187         }
 188
 189         if (fd < 0) /* Disable only */
 190                 return 0;
 191
 192         vdev->ctx[0].name = kasprintf(GFP_KERNEL, "vfio-intx(%s)",
 193                                       pci_name(pdev));
 194         if (!vdev->ctx[0].name)
 195                 return -ENOMEM;
 196
 197         trigger = eventfd_ctx_fdget(fd);
 198         if (IS_ERR(trigger)) {
 199                 kfree(vdev->ctx[0].name);
 200                 return PTR_ERR(trigger);
 201         }
 202
 203         vdev->ctx[0].trigger = trigger;
 204
 205         if (!vdev->pci_2_3)
 206                 irqflags = 0;
 207
 208         ret = request_irq(pdev->irq, vfio_intx_handler,
 209                           irqflags, vdev->ctx[0].name, vdev);
 210         if (ret) {
 211                 vdev->ctx[0].trigger = NULL;
 212                 kfree(vdev->ctx[0].name);
 213                 eventfd_ctx_put(trigger);
 214                 return ret;
 215         }
 216
 217         /*
 218          * INTx disable will stick across the new irq setup,
 219          * disable_irq won't.
 220          */
 221         spin_lock_irqsave(&vdev->irqlock, flags);
 222         if (!vdev->pci_2_3 && vdev->ctx[0].masked)
 223                 disable_irq_nosync(pdev->irq);
 224         spin_unlock_irqrestore(&vdev->irqlock, flags);
 225
 226         return 0;
 227 }
 228
 229 static void vfio_intx_disable(struct vfio_pci_device *vdev)
 230 {
 231         vfio_virqfd_disable(&vdev->ctx[0].unmask);
 232         vfio_virqfd_disable(&vdev->ctx[0].mask);
 233         vfio_intx_set_signal(vdev, -1);
 234         vdev->irq_type = VFIO_PCI_NUM_IRQS;
 235         vdev->num_ctx = 0;
 236         kfree(vdev->ctx);
 237 }
 238
 239 /*
 240  * MSI/MSI-X
 241  */
 242 static irqreturn_t vfio_msihandler(int irq, void *arg)
 243 {
 244         struct eventfd_ctx *trigger = arg;
 245
 246         eventfd_signal(trigger, 1);
 247         return IRQ_HANDLED;
 248 }
 249
 250 static int vfio_msi_enable(struct vfio_pci_device *vdev, int nvec, bool msix)
 251 {
 252         struct pci_dev *pdev = vdev->pdev;
 253         unsigned int flag = msix ? PCI_IRQ_MSIX : PCI_IRQ_MSI;
 254         int ret;
 255         u16 cmd;
 256
 257         if (!is_irq_none(vdev))
 258                 return -EINVAL;
 259
 260         vdev->ctx = kcalloc(nvec, sizeof(struct vfio_pci_irq_ctx), GFP_KERNEL);
 261         if (!vdev->ctx)
 262                 return -ENOMEM;
 263
 264         /* return the number of supported vectors if we can't get all: */
 265         cmd = vfio_pci_memory_lock_and_enable(vdev);
 266         ret = pci_alloc_irq_vectors(pdev, 1, nvec, flag);
 267         if (ret < nvec) {
 268                 if (ret > 0)
 269                         pci_free_irq_vectors(pdev);
 270                 vfio_pci_memory_unlock_and_restore(vdev, cmd);
 271                 kfree(vdev->ctx);
 272                 return ret;
 273         }
 274         vfio_pci_memory_unlock_and_restore(vdev, cmd);
 275
 276         vdev->num_ctx = nvec;
 277         vdev->irq_type = msix ? VFIO_PCI_MSIX_IRQ_INDEX :
 278                                 VFIO_PCI_MSI_IRQ_INDEX;
 279
 280         if (!msix) {
 281                 /*
 282                  * Compute the virtual hardware field for max msi vectors -
 283                  * it is the log base 2 of the number of vectors.
 284                  */
 285                 vdev->msi_qmax = fls(nvec * 2 - 1) - 1;
 286         }
 287
 288         return 0;
 289 }
 290
 291 static int vfio_msi_set_vector_signal(struct vfio_pci_device *vdev,
 292                                       int vector, int fd, bool msix)
 293 {
 294         struct pci_dev *pdev = vdev->pdev;
 295         struct eventfd_ctx *trigger;
 296         int irq, ret;
 297         u16 cmd;
 298
 299         if (vector < 0 || vector >= vdev->num_ctx)
 300                 return -EINVAL;
 301
 302         irq = pci_irq_vector(pdev, vector);
 303
 304         if (vdev->ctx[vector].trigger) {
 305                 irq_bypass_unregister_producer(&vdev->ctx[vector].producer);
 306
 307                 cmd = vfio_pci_memory_lock_and_enable(vdev);
 308                 free_irq(irq, vdev->ctx[vector].trigger);
 309                 vfio_pci_memory_unlock_and_restore(vdev, cmd);
 310
 311                 kfree(vdev->ctx[vector].name);
 312                 eventfd_ctx_put(vdev->ctx[vector].trigger);
 313                 vdev->ctx[vector].trigger = NULL;
 314         }
 315
 316         if (fd < 0)
 317                 return 0;
 318
 319         vdev->ctx[vector].name = kasprintf(GFP_KERNEL, "vfio-msi%s[%d](%s)",
 320                                            msix ? "x" : "", vector,
 321                                            pci_name(pdev));
 322         if (!vdev->ctx[vector].name)
 323                 return -ENOMEM;
 324
 325         trigger = eventfd_ctx_fdget(fd);
 326         if (IS_ERR(trigger)) {
 327                 kfree(vdev->ctx[vector].name);
 328                 return PTR_ERR(trigger);
 329         }
 330
 331         /*
 332          * The MSIx vector table resides in device memory which may be cleared
 333          * via backdoor resets. We don't allow direct access to the vector
 334          * table so even if a userspace driver attempts to save/restore around
 335          * such a reset it would be unsuccessful. To avoid this, restore the
 336          * cached value of the message prior to enabling.
 337          */
 338         cmd = vfio_pci_memory_lock_and_enable(vdev);
 339         if (msix) {
 340                 struct msi_msg msg;
 341
 342                 get_cached_msi_msg(irq, &msg);
 343                 pci_write_msi_msg(irq, &msg);
 344         }
 345
 346         ret = request_irq(irq, vfio_msihandler, 0,
 347                           vdev->ctx[vector].name, trigger);
 348         vfio_pci_memory_unlock_and_restore(vdev, cmd);
 349         if (ret) {
 350                 kfree(vdev->ctx[vector].name);
 351                 eventfd_ctx_put(trigger);
 352                 return ret;
 353         }
 354
 355         vdev->ctx[vector].producer.token = trigger;
 356         vdev->ctx[vector].producer.irq = irq;
 357         ret = irq_bypass_register_producer(&vdev->ctx[vector].producer);
 358         if (unlikely(ret)) {
 359                 dev_info(&pdev->dev,
 360                 "irq bypass producer (token %p) registration fails: %d\n",
 361                 vdev->ctx[vector].producer.token, ret);
 362
 363                 vdev->ctx[vector].producer.token = NULL;
 364         }
 365         vdev->ctx[vector].trigger = trigger;
 366
 367         return 0;
 368 }
 369
 370 static int vfio_msi_set_block(struct vfio_pci_device *vdev, unsigned start,
 371                               unsigned count, int32_t *fds, bool msix)
 372 {
 373         int i, j, ret = 0;
 374
 375         if (start >= vdev->num_ctx || start + count > vdev->num_ctx)
 376                 return -EINVAL;
 377
 378         for (i = 0, j = start; i < count && !ret; i++, j++) {
 379                 int fd = fds ? fds[i] : -1;
 380                 ret = vfio_msi_set_vector_signal(vdev, j, fd, msix);
 381         }
 382
 383         if (ret) {
 384                 for (--j; j >= (int)start; j--)
 385                         vfio_msi_set_vector_signal(vdev, j, -1, msix);
 386         }
 387
 388         return ret;
 389 }
 390
 391 static void vfio_msi_disable(struct vfio_pci_device *vdev, bool msix)
 392 {
 393         struct pci_dev *pdev = vdev->pdev;
 394         int i;
 395         u16 cmd;
 396
 397         for (i = 0; i < vdev->num_ctx; i++) {
 398                 vfio_virqfd_disable(&vdev->ctx[i].unmask);
 399                 vfio_virqfd_disable(&vdev->ctx[i].mask);
 400         }
 401
 402         vfio_msi_set_block(vdev, 0, vdev->num_ctx, NULL, msix);
 403
 404         cmd = vfio_pci_memory_lock_and_enable(vdev);
 405         pci_free_irq_vectors(pdev);
 406         vfio_pci_memory_unlock_and_restore(vdev, cmd);
 407
 408         /*
 409          * Both disable paths above use pci_intx_for_msi() to clear DisINTx
 410          * via their shutdown paths.  Restore for NoINTx devices.
 411          */
 412         if (vdev->nointx)
 413                 pci_intx(pdev, 0);
 414
 415         vdev->irq_type = VFIO_PCI_NUM_IRQS;
 416         vdev->num_ctx = 0;
 417         kfree(vdev->ctx);
 418 }
 419
 420 /*
 421  * IOCTL support
 422  */
 423 static int vfio_pci_set_intx_unmask(struct vfio_pci_device *vdev,
 424                                     unsigned index, unsigned start,
 425                                     unsigned count, uint32_t flags, void *data)
 426 {
 427         if (!is_intx(vdev) || start != 0 || count != 1)
 428                 return -EINVAL;
 429
 430         if (flags & VFIO_IRQ_SET_DATA_NONE) {
 431                 vfio_pci_intx_unmask(vdev);
 432         } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
 433                 uint8_t unmask = *(uint8_t *)data;
 434                 if (unmask)
 435                         vfio_pci_intx_unmask(vdev);
 436         } else if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
 437                 int32_t fd = *(int32_t *)data;
 438                 if (fd >= 0)
 439                         return vfio_virqfd_enable((void *) vdev,
 440                                                   vfio_pci_intx_unmask_handler,
 441                                                   vfio_send_intx_eventfd, NULL,
 442                                                   &vdev->ctx[0].unmask, fd);
 443
 444                 vfio_virqfd_disable(&vdev->ctx[0].unmask);
 445         }
 446
 447         return 0;
 448 }
 449
 450 static int vfio_pci_set_intx_mask(struct vfio_pci_device *vdev,
 451                                   unsigned index, unsigned start,
 452                                   unsigned count, uint32_t flags, void *data)
 453 {
 454         if (!is_intx(vdev) || start != 0 || count != 1)
 455                 return -EINVAL;
 456
 457         if (flags & VFIO_IRQ_SET_DATA_NONE) {
 458                 vfio_pci_intx_mask(vdev);
 459         } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
 460                 uint8_t mask = *(uint8_t *)data;
 461                 if (mask)
 462                         vfio_pci_intx_mask(vdev);
 463         } else if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
 464                 return -ENOTTY; /* XXX implement me */
 465         }
 466
 467         return 0;
 468 }
 469
 470 static int vfio_pci_set_intx_trigger(struct vfio_pci_device *vdev,
 471                                      unsigned index, unsigned start,
 472                                      unsigned count, uint32_t flags, void *data)
 473 {
 474         if (is_intx(vdev) && !count && (flags & VFIO_IRQ_SET_DATA_NONE)) {
 475                 vfio_intx_disable(vdev);
 476                 return 0;
 477         }
 478
 479         if (!(is_intx(vdev) || is_irq_none(vdev)) || start != 0 || count != 1)
 480                 return -EINVAL;
 481
 482         if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
 483                 int32_t fd = *(int32_t *)data;
 484                 int ret;
 485
 486                 if (is_intx(vdev))
 487                         return vfio_intx_set_signal(vdev, fd);
 488
 489                 ret = vfio_intx_enable(vdev);
 490                 if (ret)
 491                         return ret;
 492
 493                 ret = vfio_intx_set_signal(vdev, fd);
 494                 if (ret)
 495                         vfio_intx_disable(vdev);
 496
 497                 return ret;
 498         }
 499
 500         if (!is_intx(vdev))
 501                 return -EINVAL;
 502
 503         if (flags & VFIO_IRQ_SET_DATA_NONE) {
 504                 vfio_send_intx_eventfd(vdev, NULL);
 505         } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
 506                 uint8_t trigger = *(uint8_t *)data;
 507                 if (trigger)
 508                         vfio_send_intx_eventfd(vdev, NULL);
 509         }
 510         return 0;
 511 }
 512
 513 static int vfio_pci_set_msi_trigger(struct vfio_pci_device *vdev,
 514                                     unsigned index, unsigned start,
 515                                     unsigned count, uint32_t flags, void *data)
 516 {
 517         int i;
 518         bool msix = (index == VFIO_PCI_MSIX_IRQ_INDEX) ? true : false;
 519
 520         if (irq_is(vdev, index) && !count && (flags & VFIO_IRQ_SET_DATA_NONE)) {
 521                 vfio_msi_disable(vdev, msix);
 522                 return 0;
 523         }
 524
 525         if (!(irq_is(vdev, index) || is_irq_none(vdev)))
 526                 return -EINVAL;
 527
 528         if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
 529                 int32_t *fds = data;
 530                 int ret;
 531
 532                 if (vdev->irq_type == index)
 533                         return vfio_msi_set_block(vdev, start, count,
 534                                                   fds, msix);
 535
 536                 ret = vfio_msi_enable(vdev, start + count, msix);
 537                 if (ret)
 538                         return ret;
 539
 540                 ret = vfio_msi_set_block(vdev, start, count, fds, msix);
 541                 if (ret)
 542                         vfio_msi_disable(vdev, msix);
 543
 544                 return ret;
 545         }
 546
 547         if (!irq_is(vdev, index) || start + count > vdev->num_ctx)
 548                 return -EINVAL;
 549
 550         for (i = start; i < start + count; i++) {
 551                 if (!vdev->ctx[i].trigger)
 552                         continue;
 553                 if (flags & VFIO_IRQ_SET_DATA_NONE) {
 554                         eventfd_signal(vdev->ctx[i].trigger, 1);
 555                 } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
 556                         uint8_t *bools = data;
 557                         if (bools[i - start])
 558                                 eventfd_signal(vdev->ctx[i].trigger, 1);
 559                 }
 560         }
 561         return 0;
 562 }
 563
 564 static int vfio_pci_set_ctx_trigger_single(struct eventfd_ctx **ctx,
 565                                            unsigned int count, uint32_t flags,
 566                                            void *data)
 567 {
 568         /* DATA_NONE/DATA_BOOL enables loopback testing */
 569         if (flags & VFIO_IRQ_SET_DATA_NONE) {
 570                 if (*ctx) {
 571                         if (count) {
 572                                 eventfd_signal(*ctx, 1);
 573                         } else {
 574                                 eventfd_ctx_put(*ctx);
 575                                 *ctx = NULL;
 576                         }
 577                         return 0;
 578                 }
 579         } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
 580                 uint8_t trigger;
 581
 582                 if (!count)
 583                         return -EINVAL;
 584
 585                 trigger = *(uint8_t *)data;
 586                 if (trigger && *ctx)
 587                         eventfd_signal(*ctx, 1);
 588
 589                 return 0;
 590         } else if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
 591                 int32_t fd;
 592
 593                 if (!count)
 594                         return -EINVAL;
 595
 596                 fd = *(int32_t *)data;
 597                 if (fd == -1) {
 598                         if (*ctx)
 599                                 eventfd_ctx_put(*ctx);
 600                         *ctx = NULL;
 601                 } else if (fd >= 0) {
 602                         struct eventfd_ctx *efdctx;
 603
 604                         efdctx = eventfd_ctx_fdget(fd);
 605                         if (IS_ERR(efdctx))
 606                                 return PTR_ERR(efdctx);
 607
 608                         if (*ctx)
 609                                 eventfd_ctx_put(*ctx);
 610
 611                         *ctx = efdctx;
 612                 }
 613                 return 0;
 614         }
 615
 616         return -EINVAL;
 617 }
 618
 619 static int vfio_pci_set_err_trigger(struct vfio_pci_device *vdev,
 620                                     unsigned index, unsigned start,
 621                                     unsigned count, uint32_t flags, void *data)
 622 {
 623         if (index != VFIO_PCI_ERR_IRQ_INDEX || start != 0 || count > 1)
 624                 return -EINVAL;
 625
 626         return vfio_pci_set_ctx_trigger_single(&vdev->err_trigger,
 627                                                count, flags, data);
 628 }
 629
 630 static int vfio_pci_set_req_trigger(struct vfio_pci_device *vdev,
 631                                     unsigned index, unsigned start,
 632                                     unsigned count, uint32_t flags, void *data)
 633 {
 634         if (index != VFIO_PCI_REQ_IRQ_INDEX || start != 0 || count > 1)
 635                 return -EINVAL;
 636
 637         return vfio_pci_set_ctx_trigger_single(&vdev->req_trigger,
 638                                                count, flags, data);
 639 }
 640
 641 int vfio_pci_set_irqs_ioctl(struct vfio_pci_device *vdev, uint32_t flags,
 642                             unsigned index, unsigned start, unsigned count,
 643                             void *data)
 644 {
 645         int (*func)(struct vfio_pci_device *vdev, unsigned index,
 646                     unsigned start, unsigned count, uint32_t flags,
 647                     void *data) = NULL;
 648
 649         switch (index) {
 650         case VFIO_PCI_INTX_IRQ_INDEX:
 651                 switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
 652                 case VFIO_IRQ_SET_ACTION_MASK:
 653                         func = vfio_pci_set_intx_mask;
 654                         break;
 655                 case VFIO_IRQ_SET_ACTION_UNMASK:
 656                         func = vfio_pci_set_intx_unmask;
 657                         break;
 658                 case VFIO_IRQ_SET_ACTION_TRIGGER:
 659                         func = vfio_pci_set_intx_trigger;
 660                         break;
 661                 }
 662                 break;
 663         case VFIO_PCI_MSI_IRQ_INDEX:
 664         case VFIO_PCI_MSIX_IRQ_INDEX:
 665                 switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
 666                 case VFIO_IRQ_SET_ACTION_MASK:
 667                 case VFIO_IRQ_SET_ACTION_UNMASK:
 668                         /* XXX Need masking support exported */
 669                         break;
 670                 case VFIO_IRQ_SET_ACTION_TRIGGER:
 671                         func = vfio_pci_set_msi_trigger;
 672                         break;
 673                 }
 674                 break;
 675         case VFIO_PCI_ERR_IRQ_INDEX:
 676                 switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
 677                 case VFIO_IRQ_SET_ACTION_TRIGGER:
 678                         if (pci_is_pcie(vdev->pdev))
 679                                 func = vfio_pci_set_err_trigger;
 680                         break;
 681                 }
 682                 break;
 683         case VFIO_PCI_REQ_IRQ_INDEX:
 684                 switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
 685                 case VFIO_IRQ_SET_ACTION_TRIGGER:
 686                         func = vfio_pci_set_req_trigger;
 687                         break;
 688                 }
 689                 break;
 690         }
 691
 692         if (!func)
 693                 return -ENOTTY;
 694
 695         return func(vdev, index, start, count, flags, data);
 696 }