drivers/vfio/pci/vfio_pci_intrs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * VFIO PCI interrupt handling
   4  *
   5  * Copyright (C) 2012 Red Hat, Inc.  All rights reserved.
   6  *     Author: Alex Williamson <alex.williamson@redhat.com>
   7  *
   8  * Derived from original vfio:
   9  * Copyright 2010 Cisco Systems, Inc.  All rights reserved.
  10  * Author: Tom Lyon, pugs@cisco.com
  11  */
  12
  13 #include <linux/device.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/eventfd.h>
  16 #include <linux/msi.h>
  17 #include <linux/pci.h>
  18 #include <linux/file.h>
  19 #include <linux/vfio.h>
  20 #include <linux/wait.h>
  21 #include <linux/slab.h>
  22
  23 #include "vfio_pci_priv.h"
  24
  25 struct vfio_pci_irq_ctx {
  26         struct eventfd_ctx      *trigger;
  27         struct virqfd           *unmask;
  28         struct virqfd           *mask;
  29         char                    *name;
  30         bool                    masked;
  31         struct irq_bypass_producer      producer;
  32 };
  33
  34 static bool irq_is(struct vfio_pci_core_device *vdev, int type)
  35 {
  36         return vdev->irq_type == type;
  37 }
  38
  39 static bool is_intx(struct vfio_pci_core_device *vdev)
  40 {
  41         return vdev->irq_type == VFIO_PCI_INTX_IRQ_INDEX;
  42 }
  43
  44 static bool is_irq_none(struct vfio_pci_core_device *vdev)
  45 {
  46         return !(vdev->irq_type == VFIO_PCI_INTX_IRQ_INDEX ||
  47                  vdev->irq_type == VFIO_PCI_MSI_IRQ_INDEX ||
  48                  vdev->irq_type == VFIO_PCI_MSIX_IRQ_INDEX);
  49 }
  50
  51 static
  52 struct vfio_pci_irq_ctx *vfio_irq_ctx_get(struct vfio_pci_core_device *vdev,
  53                                           unsigned long index)
  54 {
  55         return xa_load(&vdev->ctx, index);
  56 }
  57
  58 static void vfio_irq_ctx_free(struct vfio_pci_core_device *vdev,
  59                               struct vfio_pci_irq_ctx *ctx, unsigned long index)
  60 {
  61         xa_erase(&vdev->ctx, index);
  62         kfree(ctx);
  63 }
  64
  65 static struct vfio_pci_irq_ctx *
  66 vfio_irq_ctx_alloc(struct vfio_pci_core_device *vdev, unsigned long index)
  67 {
  68         struct vfio_pci_irq_ctx *ctx;
  69         int ret;
  70
  71         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL_ACCOUNT);
  72         if (!ctx)
  73                 return NULL;
  74
  75         ret = xa_insert(&vdev->ctx, index, ctx, GFP_KERNEL_ACCOUNT);
  76         if (ret) {
  77                 kfree(ctx);
  78                 return NULL;
  79         }
  80
  81         return ctx;
  82 }
  83
  84 /*
  85  * INTx
  86  */
  87 static void vfio_send_intx_eventfd(void *opaque, void *unused)
  88 {
  89         struct vfio_pci_core_device *vdev = opaque;
  90
  91         if (likely(is_intx(vdev) && !vdev->virq_disabled)) {
  92                 struct vfio_pci_irq_ctx *ctx;
  93                 struct eventfd_ctx *trigger;
  94
  95                 ctx = vfio_irq_ctx_get(vdev, 0);
  96                 if (WARN_ON_ONCE(!ctx))
  97                         return;
  98
  99                 trigger = READ_ONCE(ctx->trigger);
 100                 if (likely(trigger))
 101                         eventfd_signal(trigger);
 102         }
 103 }
 104
 105 /* Returns true if the INTx vfio_pci_irq_ctx.masked value is changed. */
 106 static bool __vfio_pci_intx_mask(struct vfio_pci_core_device *vdev)
 107 {
 108         struct pci_dev *pdev = vdev->pdev;
 109         struct vfio_pci_irq_ctx *ctx;
 110         unsigned long flags;
 111         bool masked_changed = false;
 112
 113         lockdep_assert_held(&vdev->igate);
 114
 115         spin_lock_irqsave(&vdev->irqlock, flags);
 116
 117         /*
 118          * Masking can come from interrupt, ioctl, or config space
 119          * via INTx disable.  The latter means this can get called
 120          * even when not using intx delivery.  In this case, just
 121          * try to have the physical bit follow the virtual bit.
 122          */
 123         if (unlikely(!is_intx(vdev))) {
 124                 if (vdev->pci_2_3)
 125                         pci_intx(pdev, 0);
 126                 goto out_unlock;
 127         }
 128
 129         ctx = vfio_irq_ctx_get(vdev, 0);
 130         if (WARN_ON_ONCE(!ctx))
 131                 goto out_unlock;
 132
 133         if (!ctx->masked) {
 134                 /*
 135                  * Can't use check_and_mask here because we always want to
 136                  * mask, not just when something is pending.
 137                  */
 138                 if (vdev->pci_2_3)
 139                         pci_intx(pdev, 0);
 140                 else
 141                         disable_irq_nosync(pdev->irq);
 142
 143                 ctx->masked = true;
 144                 masked_changed = true;
 145         }
 146
 147 out_unlock:
 148         spin_unlock_irqrestore(&vdev->irqlock, flags);
 149         return masked_changed;
 150 }
 151
 152 bool vfio_pci_intx_mask(struct vfio_pci_core_device *vdev)
 153 {
 154         bool mask_changed;
 155
 156         mutex_lock(&vdev->igate);
 157         mask_changed = __vfio_pci_intx_mask(vdev);
 158         mutex_unlock(&vdev->igate);
 159
 160         return mask_changed;
 161 }
 162
 163 /*
 164  * If this is triggered by an eventfd, we can't call eventfd_signal
 165  * or else we'll deadlock on the eventfd wait queue.  Return >0 when
 166  * a signal is necessary, which can then be handled via a work queue
 167  * or directly depending on the caller.
 168  */
 169 static int vfio_pci_intx_unmask_handler(void *opaque, void *unused)
 170 {
 171         struct vfio_pci_core_device *vdev = opaque;
 172         struct pci_dev *pdev = vdev->pdev;
 173         struct vfio_pci_irq_ctx *ctx;
 174         unsigned long flags;
 175         int ret = 0;
 176
 177         spin_lock_irqsave(&vdev->irqlock, flags);
 178
 179         /*
 180          * Unmasking comes from ioctl or config, so again, have the
 181          * physical bit follow the virtual even when not using INTx.
 182          */
 183         if (unlikely(!is_intx(vdev))) {
 184                 if (vdev->pci_2_3)
 185                         pci_intx(pdev, 1);
 186                 goto out_unlock;
 187         }
 188
 189         ctx = vfio_irq_ctx_get(vdev, 0);
 190         if (WARN_ON_ONCE(!ctx))
 191                 goto out_unlock;
 192
 193         if (ctx->masked && !vdev->virq_disabled) {
 194                 /*
 195                  * A pending interrupt here would immediately trigger,
 196                  * but we can avoid that overhead by just re-sending
 197                  * the interrupt to the user.
 198                  */
 199                 if (vdev->pci_2_3) {
 200                         if (!pci_check_and_unmask_intx(pdev))
 201                                 ret = 1;
 202                 } else
 203                         enable_irq(pdev->irq);
 204
 205                 ctx->masked = (ret > 0);
 206         }
 207
 208 out_unlock:
 209         spin_unlock_irqrestore(&vdev->irqlock, flags);
 210
 211         return ret;
 212 }
 213
 214 static void __vfio_pci_intx_unmask(struct vfio_pci_core_device *vdev)
 215 {
 216         lockdep_assert_held(&vdev->igate);
 217
 218         if (vfio_pci_intx_unmask_handler(vdev, NULL) > 0)
 219                 vfio_send_intx_eventfd(vdev, NULL);
 220 }
 221
 222 void vfio_pci_intx_unmask(struct vfio_pci_core_device *vdev)
 223 {
 224         mutex_lock(&vdev->igate);
 225         __vfio_pci_intx_unmask(vdev);
 226         mutex_unlock(&vdev->igate);
 227 }
 228
 229 static irqreturn_t vfio_intx_handler(int irq, void *dev_id)
 230 {
 231         struct vfio_pci_core_device *vdev = dev_id;
 232         struct vfio_pci_irq_ctx *ctx;
 233         unsigned long flags;
 234         int ret = IRQ_NONE;
 235
 236         ctx = vfio_irq_ctx_get(vdev, 0);
 237         if (WARN_ON_ONCE(!ctx))
 238                 return ret;
 239
 240         spin_lock_irqsave(&vdev->irqlock, flags);
 241
 242         if (!vdev->pci_2_3) {
 243                 disable_irq_nosync(vdev->pdev->irq);
 244                 ctx->masked = true;
 245                 ret = IRQ_HANDLED;
 246         } else if (!ctx->masked &&  /* may be shared */
 247                    pci_check_and_mask_intx(vdev->pdev)) {
 248                 ctx->masked = true;
 249                 ret = IRQ_HANDLED;
 250         }
 251
 252         spin_unlock_irqrestore(&vdev->irqlock, flags);
 253
 254         if (ret == IRQ_HANDLED)
 255                 vfio_send_intx_eventfd(vdev, NULL);
 256
 257         return ret;
 258 }
 259
 260 static int vfio_intx_enable(struct vfio_pci_core_device *vdev,
 261                             struct eventfd_ctx *trigger)
 262 {
 263         struct pci_dev *pdev = vdev->pdev;
 264         struct vfio_pci_irq_ctx *ctx;
 265         unsigned long irqflags;
 266         char *name;
 267         int ret;
 268
 269         if (!is_irq_none(vdev))
 270                 return -EINVAL;
 271
 272         if (!pdev->irq)
 273                 return -ENODEV;
 274
 275         name = kasprintf(GFP_KERNEL_ACCOUNT, "vfio-intx(%s)", pci_name(pdev));
 276         if (!name)
 277                 return -ENOMEM;
 278
 279         ctx = vfio_irq_ctx_alloc(vdev, 0);
 280         if (!ctx)
 281                 return -ENOMEM;
 282
 283         ctx->name = name;
 284         ctx->trigger = trigger;
 285
 286         /*
 287          * Fill the initial masked state based on virq_disabled.  After
 288          * enable, changing the DisINTx bit in vconfig directly changes INTx
 289          * masking.  igate prevents races during setup, once running masked
 290          * is protected via irqlock.
 291          *
 292          * Devices supporting DisINTx also reflect the current mask state in
 293          * the physical DisINTx bit, which is not affected during IRQ setup.
 294          *
 295          * Devices without DisINTx support require an exclusive interrupt.
 296          * IRQ masking is performed at the IRQ chip.  Again, igate protects
 297          * against races during setup and IRQ handlers and irqfds are not
 298          * yet active, therefore masked is stable and can be used to
 299          * conditionally auto-enable the IRQ.
 300          *
 301          * irq_type must be stable while the IRQ handler is registered,
 302          * therefore it must be set before request_irq().
 303          */
 304         ctx->masked = vdev->virq_disabled;
 305         if (vdev->pci_2_3) {
 306                 pci_intx(pdev, !ctx->masked);
 307                 irqflags = IRQF_SHARED;
 308         } else {
 309                 irqflags = ctx->masked ? IRQF_NO_AUTOEN : 0;
 310         }
 311
 312         vdev->irq_type = VFIO_PCI_INTX_IRQ_INDEX;
 313
 314         ret = request_irq(pdev->irq, vfio_intx_handler,
 315                           irqflags, ctx->name, vdev);
 316         if (ret) {
 317                 vdev->irq_type = VFIO_PCI_NUM_IRQS;
 318                 kfree(name);
 319                 vfio_irq_ctx_free(vdev, ctx, 0);
 320                 return ret;
 321         }
 322
 323         return 0;
 324 }
 325
 326 static int vfio_intx_set_signal(struct vfio_pci_core_device *vdev,
 327                                 struct eventfd_ctx *trigger)
 328 {
 329         struct pci_dev *pdev = vdev->pdev;
 330         struct vfio_pci_irq_ctx *ctx;
 331         struct eventfd_ctx *old;
 332
 333         ctx = vfio_irq_ctx_get(vdev, 0);
 334         if (WARN_ON_ONCE(!ctx))
 335                 return -EINVAL;
 336
 337         old = ctx->trigger;
 338
 339         WRITE_ONCE(ctx->trigger, trigger);
 340
 341         /* Releasing an old ctx requires synchronizing in-flight users */
 342         if (old) {
 343                 synchronize_irq(pdev->irq);
 344                 vfio_virqfd_flush_thread(&ctx->unmask);
 345                 eventfd_ctx_put(old);
 346         }
 347
 348         return 0;
 349 }
 350
 351 static void vfio_intx_disable(struct vfio_pci_core_device *vdev)
 352 {
 353         struct pci_dev *pdev = vdev->pdev;
 354         struct vfio_pci_irq_ctx *ctx;
 355
 356         ctx = vfio_irq_ctx_get(vdev, 0);
 357         WARN_ON_ONCE(!ctx);
 358         if (ctx) {
 359                 vfio_virqfd_disable(&ctx->unmask);
 360                 vfio_virqfd_disable(&ctx->mask);
 361                 free_irq(pdev->irq, vdev);
 362                 if (ctx->trigger)
 363                         eventfd_ctx_put(ctx->trigger);
 364                 kfree(ctx->name);
 365                 vfio_irq_ctx_free(vdev, ctx, 0);
 366         }
 367         vdev->irq_type = VFIO_PCI_NUM_IRQS;
 368 }
 369
 370 /*
 371  * MSI/MSI-X
 372  */
 373 static irqreturn_t vfio_msihandler(int irq, void *arg)
 374 {
 375         struct eventfd_ctx *trigger = arg;
 376
 377         eventfd_signal(trigger);
 378         return IRQ_HANDLED;
 379 }
 380
 381 static int vfio_msi_enable(struct vfio_pci_core_device *vdev, int nvec, bool msix)
 382 {
 383         struct pci_dev *pdev = vdev->pdev;
 384         unsigned int flag = msix ? PCI_IRQ_MSIX : PCI_IRQ_MSI;
 385         int ret;
 386         u16 cmd;
 387
 388         if (!is_irq_none(vdev))
 389                 return -EINVAL;
 390
 391         /* return the number of supported vectors if we can't get all: */
 392         cmd = vfio_pci_memory_lock_and_enable(vdev);
 393         ret = pci_alloc_irq_vectors(pdev, 1, nvec, flag);
 394         if (ret < nvec) {
 395                 if (ret > 0)
 396                         pci_free_irq_vectors(pdev);
 397                 vfio_pci_memory_unlock_and_restore(vdev, cmd);
 398                 return ret;
 399         }
 400         vfio_pci_memory_unlock_and_restore(vdev, cmd);
 401
 402         vdev->irq_type = msix ? VFIO_PCI_MSIX_IRQ_INDEX :
 403                                 VFIO_PCI_MSI_IRQ_INDEX;
 404
 405         if (!msix) {
 406                 /*
 407                  * Compute the virtual hardware field for max msi vectors -
 408                  * it is the log base 2 of the number of vectors.
 409                  */
 410                 vdev->msi_qmax = fls(nvec * 2 - 1) - 1;
 411         }
 412
 413         return 0;
 414 }
 415
 416 /*
 417  * vfio_msi_alloc_irq() returns the Linux IRQ number of an MSI or MSI-X device
 418  * interrupt vector. If a Linux IRQ number is not available then a new
 419  * interrupt is allocated if dynamic MSI-X is supported.
 420  *
 421  * Where is vfio_msi_free_irq()? Allocated interrupts are maintained,
 422  * essentially forming a cache that subsequent allocations can draw from.
 423  * Interrupts are freed using pci_free_irq_vectors() when MSI/MSI-X is
 424  * disabled.
 425  */
 426 static int vfio_msi_alloc_irq(struct vfio_pci_core_device *vdev,
 427                               unsigned int vector, bool msix)
 428 {
 429         struct pci_dev *pdev = vdev->pdev;
 430         struct msi_map map;
 431         int irq;
 432         u16 cmd;
 433
 434         irq = pci_irq_vector(pdev, vector);
 435         if (WARN_ON_ONCE(irq == 0))
 436                 return -EINVAL;
 437         if (irq > 0 || !msix || !vdev->has_dyn_msix)
 438                 return irq;
 439
 440         cmd = vfio_pci_memory_lock_and_enable(vdev);
 441         map = pci_msix_alloc_irq_at(pdev, vector, NULL);
 442         vfio_pci_memory_unlock_and_restore(vdev, cmd);
 443
 444         return map.index < 0 ? map.index : map.virq;
 445 }
 446
 447 static int vfio_msi_set_vector_signal(struct vfio_pci_core_device *vdev,
 448                                       unsigned int vector, int fd, bool msix)
 449 {
 450         struct pci_dev *pdev = vdev->pdev;
 451         struct vfio_pci_irq_ctx *ctx;
 452         struct eventfd_ctx *trigger;
 453         int irq = -EINVAL, ret;
 454         u16 cmd;
 455
 456         ctx = vfio_irq_ctx_get(vdev, vector);
 457
 458         if (ctx) {
 459                 irq_bypass_unregister_producer(&ctx->producer);
 460                 irq = pci_irq_vector(pdev, vector);
 461                 cmd = vfio_pci_memory_lock_and_enable(vdev);
 462                 free_irq(irq, ctx->trigger);
 463                 vfio_pci_memory_unlock_and_restore(vdev, cmd);
 464                 /* Interrupt stays allocated, will be freed at MSI-X disable. */
 465                 kfree(ctx->name);
 466                 eventfd_ctx_put(ctx->trigger);
 467                 vfio_irq_ctx_free(vdev, ctx, vector);
 468         }
 469
 470         if (fd < 0)
 471                 return 0;
 472
 473         if (irq == -EINVAL) {
 474                 /* Interrupt stays allocated, will be freed at MSI-X disable. */
 475                 irq = vfio_msi_alloc_irq(vdev, vector, msix);
 476                 if (irq < 0)
 477                         return irq;
 478         }
 479
 480         ctx = vfio_irq_ctx_alloc(vdev, vector);
 481         if (!ctx)
 482                 return -ENOMEM;
 483
 484         ctx->name = kasprintf(GFP_KERNEL_ACCOUNT, "vfio-msi%s[%d](%s)",
 485                               msix ? "x" : "", vector, pci_name(pdev));
 486         if (!ctx->name) {
 487                 ret = -ENOMEM;
 488                 goto out_free_ctx;
 489         }
 490
 491         trigger = eventfd_ctx_fdget(fd);
 492         if (IS_ERR(trigger)) {
 493                 ret = PTR_ERR(trigger);
 494                 goto out_free_name;
 495         }
 496
 497         /*
 498          * If the vector was previously allocated, refresh the on-device
 499          * message data before enabling in case it had been cleared or
 500          * corrupted (e.g. due to backdoor resets) since writing.
 501          */
 502         cmd = vfio_pci_memory_lock_and_enable(vdev);
 503         if (msix) {
 504                 struct msi_msg msg;
 505
 506                 get_cached_msi_msg(irq, &msg);
 507                 pci_write_msi_msg(irq, &msg);
 508         }
 509
 510         ret = request_irq(irq, vfio_msihandler, 0, ctx->name, trigger);
 511         vfio_pci_memory_unlock_and_restore(vdev, cmd);
 512         if (ret)
 513                 goto out_put_eventfd_ctx;
 514
 515         ctx->producer.token = trigger;
 516         ctx->producer.irq = irq;
 517         ret = irq_bypass_register_producer(&ctx->producer);
 518         if (unlikely(ret)) {
 519                 dev_info(&pdev->dev,
 520                 "irq bypass producer (token %p) registration fails: %d\n",
 521                 ctx->producer.token, ret);
 522
 523                 ctx->producer.token = NULL;
 524         }
 525         ctx->trigger = trigger;
 526
 527         return 0;
 528
 529 out_put_eventfd_ctx:
 530         eventfd_ctx_put(trigger);
 531 out_free_name:
 532         kfree(ctx->name);
 533 out_free_ctx:
 534         vfio_irq_ctx_free(vdev, ctx, vector);
 535         return ret;
 536 }
 537
 538 static int vfio_msi_set_block(struct vfio_pci_core_device *vdev, unsigned start,
 539                               unsigned count, int32_t *fds, bool msix)
 540 {
 541         unsigned int i, j;
 542         int ret = 0;
 543
 544         for (i = 0, j = start; i < count && !ret; i++, j++) {
 545                 int fd = fds ? fds[i] : -1;
 546                 ret = vfio_msi_set_vector_signal(vdev, j, fd, msix);
 547         }
 548
 549         if (ret) {
 550                 for (i = start; i < j; i++)
 551                         vfio_msi_set_vector_signal(vdev, i, -1, msix);
 552         }
 553
 554         return ret;
 555 }
 556
 557 static void vfio_msi_disable(struct vfio_pci_core_device *vdev, bool msix)
 558 {
 559         struct pci_dev *pdev = vdev->pdev;
 560         struct vfio_pci_irq_ctx *ctx;
 561         unsigned long i;
 562         u16 cmd;
 563
 564         xa_for_each(&vdev->ctx, i, ctx) {
 565                 vfio_virqfd_disable(&ctx->unmask);
 566                 vfio_virqfd_disable(&ctx->mask);
 567                 vfio_msi_set_vector_signal(vdev, i, -1, msix);
 568         }
 569
 570         cmd = vfio_pci_memory_lock_and_enable(vdev);
 571         pci_free_irq_vectors(pdev);
 572         vfio_pci_memory_unlock_and_restore(vdev, cmd);
 573
 574         /*
 575          * Both disable paths above use pci_intx_for_msi() to clear DisINTx
 576          * via their shutdown paths.  Restore for NoINTx devices.
 577          */
 578         if (vdev->nointx)
 579                 pci_intx(pdev, 0);
 580
 581         vdev->irq_type = VFIO_PCI_NUM_IRQS;
 582 }
 583
 584 /*
 585  * IOCTL support
 586  */
 587 static int vfio_pci_set_intx_unmask(struct vfio_pci_core_device *vdev,
 588                                     unsigned index, unsigned start,
 589                                     unsigned count, uint32_t flags, void *data)
 590 {
 591         if (!is_intx(vdev) || start != 0 || count != 1)
 592                 return -EINVAL;
 593
 594         if (flags & VFIO_IRQ_SET_DATA_NONE) {
 595                 __vfio_pci_intx_unmask(vdev);
 596         } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
 597                 uint8_t unmask = *(uint8_t *)data;
 598                 if (unmask)
 599                         __vfio_pci_intx_unmask(vdev);
 600         } else if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
 601                 struct vfio_pci_irq_ctx *ctx = vfio_irq_ctx_get(vdev, 0);
 602                 int32_t fd = *(int32_t *)data;
 603
 604                 if (WARN_ON_ONCE(!ctx))
 605                         return -EINVAL;
 606                 if (fd >= 0)
 607                         return vfio_virqfd_enable((void *) vdev,
 608                                                   vfio_pci_intx_unmask_handler,
 609                                                   vfio_send_intx_eventfd, NULL,
 610                                                   &ctx->unmask, fd);
 611
 612                 vfio_virqfd_disable(&ctx->unmask);
 613         }
 614
 615         return 0;
 616 }
 617
 618 static int vfio_pci_set_intx_mask(struct vfio_pci_core_device *vdev,
 619                                   unsigned index, unsigned start,
 620                                   unsigned count, uint32_t flags, void *data)
 621 {
 622         if (!is_intx(vdev) || start != 0 || count != 1)
 623                 return -EINVAL;
 624
 625         if (flags & VFIO_IRQ_SET_DATA_NONE) {
 626                 __vfio_pci_intx_mask(vdev);
 627         } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
 628                 uint8_t mask = *(uint8_t *)data;
 629                 if (mask)
 630                         __vfio_pci_intx_mask(vdev);
 631         } else if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
 632                 return -ENOTTY; /* XXX implement me */
 633         }
 634
 635         return 0;
 636 }
 637
 638 static int vfio_pci_set_intx_trigger(struct vfio_pci_core_device *vdev,
 639                                      unsigned index, unsigned start,
 640                                      unsigned count, uint32_t flags, void *data)
 641 {
 642         if (is_intx(vdev) && !count && (flags & VFIO_IRQ_SET_DATA_NONE)) {
 643                 vfio_intx_disable(vdev);
 644                 return 0;
 645         }
 646
 647         if (!(is_intx(vdev) || is_irq_none(vdev)) || start != 0 || count != 1)
 648                 return -EINVAL;
 649
 650         if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
 651                 struct eventfd_ctx *trigger = NULL;
 652                 int32_t fd = *(int32_t *)data;
 653                 int ret;
 654
 655                 if (fd >= 0) {
 656                         trigger = eventfd_ctx_fdget(fd);
 657                         if (IS_ERR(trigger))
 658                                 return PTR_ERR(trigger);
 659                 }
 660
 661                 if (is_intx(vdev))
 662                         ret = vfio_intx_set_signal(vdev, trigger);
 663                 else
 664                         ret = vfio_intx_enable(vdev, trigger);
 665
 666                 if (ret && trigger)
 667                         eventfd_ctx_put(trigger);
 668
 669                 return ret;
 670         }
 671
 672         if (!is_intx(vdev))
 673                 return -EINVAL;
 674
 675         if (flags & VFIO_IRQ_SET_DATA_NONE) {
 676                 vfio_send_intx_eventfd(vdev, NULL);
 677         } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
 678                 uint8_t trigger = *(uint8_t *)data;
 679                 if (trigger)
 680                         vfio_send_intx_eventfd(vdev, NULL);
 681         }
 682         return 0;
 683 }
 684
 685 static int vfio_pci_set_msi_trigger(struct vfio_pci_core_device *vdev,
 686                                     unsigned index, unsigned start,
 687                                     unsigned count, uint32_t flags, void *data)
 688 {
 689         struct vfio_pci_irq_ctx *ctx;
 690         unsigned 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))
 721                 return -EINVAL;
 722
 723         for (i = start; i < start + count; i++) {
 724                 ctx = vfio_irq_ctx_get(vdev, i);
 725                 if (!ctx)
 726                         continue;
 727                 if (flags & VFIO_IRQ_SET_DATA_NONE) {
 728                         eventfd_signal(ctx->trigger);
 729                 } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
 730                         uint8_t *bools = data;
 731                         if (bools[i - start])
 732                                 eventfd_signal(ctx->trigger);
 733                 }
 734         }
 735         return 0;
 736 }
 737
 738 static int vfio_pci_set_ctx_trigger_single(struct eventfd_ctx **ctx,
 739                                            unsigned int count, uint32_t flags,
 740                                            void *data)
 741 {
 742         /* DATA_NONE/DATA_BOOL enables loopback testing */
 743         if (flags & VFIO_IRQ_SET_DATA_NONE) {
 744                 if (*ctx) {
 745                         if (count) {
 746                                 eventfd_signal(*ctx);
 747                         } else {
 748                                 eventfd_ctx_put(*ctx);
 749                                 *ctx = NULL;
 750                         }
 751                         return 0;
 752                 }
 753         } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
 754                 uint8_t trigger;
 755
 756                 if (!count)
 757                         return -EINVAL;
 758
 759                 trigger = *(uint8_t *)data;
 760                 if (trigger && *ctx)
 761                         eventfd_signal(*ctx);
 762
 763                 return 0;
 764         } else if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
 765                 int32_t fd;
 766
 767                 if (!count)
 768                         return -EINVAL;
 769
 770                 fd = *(int32_t *)data;
 771                 if (fd == -1) {
 772                         if (*ctx)
 773                                 eventfd_ctx_put(*ctx);
 774                         *ctx = NULL;
 775                 } else if (fd >= 0) {
 776                         struct eventfd_ctx *efdctx;
 777
 778                         efdctx = eventfd_ctx_fdget(fd);
 779                         if (IS_ERR(efdctx))
 780                                 return PTR_ERR(efdctx);
 781
 782                         if (*ctx)
 783                                 eventfd_ctx_put(*ctx);
 784
 785                         *ctx = efdctx;
 786                 }
 787                 return 0;
 788         }
 789
 790         return -EINVAL;
 791 }
 792
 793 static int vfio_pci_set_err_trigger(struct vfio_pci_core_device *vdev,
 794                                     unsigned index, unsigned start,
 795                                     unsigned count, uint32_t flags, void *data)
 796 {
 797         if (index != VFIO_PCI_ERR_IRQ_INDEX || start != 0 || count > 1)
 798                 return -EINVAL;
 799
 800         return vfio_pci_set_ctx_trigger_single(&vdev->err_trigger,
 801                                                count, flags, data);
 802 }
 803
 804 static int vfio_pci_set_req_trigger(struct vfio_pci_core_device *vdev,
 805                                     unsigned index, unsigned start,
 806                                     unsigned count, uint32_t flags, void *data)
 807 {
 808         if (index != VFIO_PCI_REQ_IRQ_INDEX || start != 0 || count > 1)
 809                 return -EINVAL;
 810
 811         return vfio_pci_set_ctx_trigger_single(&vdev->req_trigger,
 812                                                count, flags, data);
 813 }
 814
 815 int vfio_pci_set_irqs_ioctl(struct vfio_pci_core_device *vdev, uint32_t flags,
 816                             unsigned index, unsigned start, unsigned count,
 817                             void *data)
 818 {
 819         int (*func)(struct vfio_pci_core_device *vdev, unsigned index,
 820                     unsigned start, unsigned count, uint32_t flags,
 821                     void *data) = NULL;
 822
 823         switch (index) {
 824         case VFIO_PCI_INTX_IRQ_INDEX:
 825                 switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
 826                 case VFIO_IRQ_SET_ACTION_MASK:
 827                         func = vfio_pci_set_intx_mask;
 828                         break;
 829                 case VFIO_IRQ_SET_ACTION_UNMASK:
 830                         func = vfio_pci_set_intx_unmask;
 831                         break;
 832                 case VFIO_IRQ_SET_ACTION_TRIGGER:
 833                         func = vfio_pci_set_intx_trigger;
 834                         break;
 835                 }
 836                 break;
 837         case VFIO_PCI_MSI_IRQ_INDEX:
 838         case VFIO_PCI_MSIX_IRQ_INDEX:
 839                 switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
 840                 case VFIO_IRQ_SET_ACTION_MASK:
 841                 case VFIO_IRQ_SET_ACTION_UNMASK:
 842                         /* XXX Need masking support exported */
 843                         break;
 844                 case VFIO_IRQ_SET_ACTION_TRIGGER:
 845                         func = vfio_pci_set_msi_trigger;
 846                         break;
 847                 }
 848                 break;
 849         case VFIO_PCI_ERR_IRQ_INDEX:
 850                 switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
 851                 case VFIO_IRQ_SET_ACTION_TRIGGER:
 852                         if (pci_is_pcie(vdev->pdev))
 853                                 func = vfio_pci_set_err_trigger;
 854                         break;
 855                 }
 856                 break;
 857         case VFIO_PCI_REQ_IRQ_INDEX:
 858                 switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
 859                 case VFIO_IRQ_SET_ACTION_TRIGGER:
 860                         func = vfio_pci_set_req_trigger;
 861                         break;
 862                 }
 863                 break;
 864         }
 865
 866         if (!func)
 867                 return -ENOTTY;
 868
 869         return func(vdev, index, start, count, flags, data);
 870 }