xref: /linux/drivers/vfio/pci/vfio_pci_intrs.c (revision e7d759f31ca295d589f7420719c311870bb3166f) 
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 
94 		ctx = vfio_irq_ctx_get(vdev, 0);
95 		if (WARN_ON_ONCE(!ctx))
96 			return;
97 		eventfd_signal(ctx->trigger);
98 	}
99 }
100 
101 /* Returns true if the INTx vfio_pci_irq_ctx.masked value is changed. */
102 bool vfio_pci_intx_mask(struct vfio_pci_core_device *vdev)
103 {
104 	struct pci_dev *pdev = vdev->pdev;
105 	struct vfio_pci_irq_ctx *ctx;
106 	unsigned long flags;
107 	bool masked_changed = false;
108 
109 	spin_lock_irqsave(&vdev->irqlock, flags);
110 
111 	/*
112 	 * Masking can come from interrupt, ioctl, or config space
113 	 * via INTx disable.  The latter means this can get called
114 	 * even when not using intx delivery.  In this case, just
115 	 * try to have the physical bit follow the virtual bit.
116 	 */
117 	if (unlikely(!is_intx(vdev))) {
118 		if (vdev->pci_2_3)
119 			pci_intx(pdev, 0);
120 		goto out_unlock;
121 	}
122 
123 	ctx = vfio_irq_ctx_get(vdev, 0);
124 	if (WARN_ON_ONCE(!ctx))
125 		goto out_unlock;
126 
127 	if (!ctx->masked) {
128 		/*
129 		 * Can't use check_and_mask here because we always want to
130 		 * mask, not just when something is pending.
131 		 */
132 		if (vdev->pci_2_3)
133 			pci_intx(pdev, 0);
134 		else
135 			disable_irq_nosync(pdev->irq);
136 
137 		ctx->masked = true;
138 		masked_changed = true;
139 	}
140 
141 out_unlock:
142 	spin_unlock_irqrestore(&vdev->irqlock, flags);
143 	return masked_changed;
144 }
145 
146 /*
147  * If this is triggered by an eventfd, we can't call eventfd_signal
148  * or else we'll deadlock on the eventfd wait queue.  Return >0 when
149  * a signal is necessary, which can then be handled via a work queue
150  * or directly depending on the caller.
151  */
152 static int vfio_pci_intx_unmask_handler(void *opaque, void *unused)
153 {
154 	struct vfio_pci_core_device *vdev = opaque;
155 	struct pci_dev *pdev = vdev->pdev;
156 	struct vfio_pci_irq_ctx *ctx;
157 	unsigned long flags;
158 	int ret = 0;
159 
160 	spin_lock_irqsave(&vdev->irqlock, flags);
161 
162 	/*
163 	 * Unmasking comes from ioctl or config, so again, have the
164 	 * physical bit follow the virtual even when not using INTx.
165 	 */
166 	if (unlikely(!is_intx(vdev))) {
167 		if (vdev->pci_2_3)
168 			pci_intx(pdev, 1);
169 		goto out_unlock;
170 	}
171 
172 	ctx = vfio_irq_ctx_get(vdev, 0);
173 	if (WARN_ON_ONCE(!ctx))
174 		goto out_unlock;
175 
176 	if (ctx->masked && !vdev->virq_disabled) {
177 		/*
178 		 * A pending interrupt here would immediately trigger,
179 		 * but we can avoid that overhead by just re-sending
180 		 * the interrupt to the user.
181 		 */
182 		if (vdev->pci_2_3) {
183 			if (!pci_check_and_unmask_intx(pdev))
184 				ret = 1;
185 		} else
186 			enable_irq(pdev->irq);
187 
188 		ctx->masked = (ret > 0);
189 	}
190 
191 out_unlock:
192 	spin_unlock_irqrestore(&vdev->irqlock, flags);
193 
194 	return ret;
195 }
196 
197 void vfio_pci_intx_unmask(struct vfio_pci_core_device *vdev)
198 {
199 	if (vfio_pci_intx_unmask_handler(vdev, NULL) > 0)
200 		vfio_send_intx_eventfd(vdev, NULL);
201 }
202 
203 static irqreturn_t vfio_intx_handler(int irq, void *dev_id)
204 {
205 	struct vfio_pci_core_device *vdev = dev_id;
206 	struct vfio_pci_irq_ctx *ctx;
207 	unsigned long flags;
208 	int ret = IRQ_NONE;
209 
210 	ctx = vfio_irq_ctx_get(vdev, 0);
211 	if (WARN_ON_ONCE(!ctx))
212 		return ret;
213 
214 	spin_lock_irqsave(&vdev->irqlock, flags);
215 
216 	if (!vdev->pci_2_3) {
217 		disable_irq_nosync(vdev->pdev->irq);
218 		ctx->masked = true;
219 		ret = IRQ_HANDLED;
220 	} else if (!ctx->masked &&  /* may be shared */
221 		   pci_check_and_mask_intx(vdev->pdev)) {
222 		ctx->masked = true;
223 		ret = IRQ_HANDLED;
224 	}
225 
226 	spin_unlock_irqrestore(&vdev->irqlock, flags);
227 
228 	if (ret == IRQ_HANDLED)
229 		vfio_send_intx_eventfd(vdev, NULL);
230 
231 	return ret;
232 }
233 
234 static int vfio_intx_enable(struct vfio_pci_core_device *vdev)
235 {
236 	struct vfio_pci_irq_ctx *ctx;
237 
238 	if (!is_irq_none(vdev))
239 		return -EINVAL;
240 
241 	if (!vdev->pdev->irq)
242 		return -ENODEV;
243 
244 	ctx = vfio_irq_ctx_alloc(vdev, 0);
245 	if (!ctx)
246 		return -ENOMEM;
247 
248 	/*
249 	 * If the virtual interrupt is masked, restore it.  Devices
250 	 * supporting DisINTx can be masked at the hardware level
251 	 * here, non-PCI-2.3 devices will have to wait until the
252 	 * interrupt is enabled.
253 	 */
254 	ctx->masked = vdev->virq_disabled;
255 	if (vdev->pci_2_3)
256 		pci_intx(vdev->pdev, !ctx->masked);
257 
258 	vdev->irq_type = VFIO_PCI_INTX_IRQ_INDEX;
259 
260 	return 0;
261 }
262 
263 static int vfio_intx_set_signal(struct vfio_pci_core_device *vdev, int fd)
264 {
265 	struct pci_dev *pdev = vdev->pdev;
266 	unsigned long irqflags = IRQF_SHARED;
267 	struct vfio_pci_irq_ctx *ctx;
268 	struct eventfd_ctx *trigger;
269 	unsigned long flags;
270 	int ret;
271 
272 	ctx = vfio_irq_ctx_get(vdev, 0);
273 	if (WARN_ON_ONCE(!ctx))
274 		return -EINVAL;
275 
276 	if (ctx->trigger) {
277 		free_irq(pdev->irq, vdev);
278 		kfree(ctx->name);
279 		eventfd_ctx_put(ctx->trigger);
280 		ctx->trigger = NULL;
281 	}
282 
283 	if (fd < 0) /* Disable only */
284 		return 0;
285 
286 	ctx->name = kasprintf(GFP_KERNEL_ACCOUNT, "vfio-intx(%s)",
287 			      pci_name(pdev));
288 	if (!ctx->name)
289 		return -ENOMEM;
290 
291 	trigger = eventfd_ctx_fdget(fd);
292 	if (IS_ERR(trigger)) {
293 		kfree(ctx->name);
294 		return PTR_ERR(trigger);
295 	}
296 
297 	ctx->trigger = trigger;
298 
299 	if (!vdev->pci_2_3)
300 		irqflags = 0;
301 
302 	ret = request_irq(pdev->irq, vfio_intx_handler,
303 			  irqflags, ctx->name, vdev);
304 	if (ret) {
305 		ctx->trigger = NULL;
306 		kfree(ctx->name);
307 		eventfd_ctx_put(trigger);
308 		return ret;
309 	}
310 
311 	/*
312 	 * INTx disable will stick across the new irq setup,
313 	 * disable_irq won't.
314 	 */
315 	spin_lock_irqsave(&vdev->irqlock, flags);
316 	if (!vdev->pci_2_3 && ctx->masked)
317 		disable_irq_nosync(pdev->irq);
318 	spin_unlock_irqrestore(&vdev->irqlock, flags);
319 
320 	return 0;
321 }
322 
323 static void vfio_intx_disable(struct vfio_pci_core_device *vdev)
324 {
325 	struct vfio_pci_irq_ctx *ctx;
326 
327 	ctx = vfio_irq_ctx_get(vdev, 0);
328 	WARN_ON_ONCE(!ctx);
329 	if (ctx) {
330 		vfio_virqfd_disable(&ctx->unmask);
331 		vfio_virqfd_disable(&ctx->mask);
332 	}
333 	vfio_intx_set_signal(vdev, -1);
334 	vdev->irq_type = VFIO_PCI_NUM_IRQS;
335 	vfio_irq_ctx_free(vdev, ctx, 0);
336 }
337 
338 /*
339  * MSI/MSI-X
340  */
341 static irqreturn_t vfio_msihandler(int irq, void *arg)
342 {
343 	struct eventfd_ctx *trigger = arg;
344 
345 	eventfd_signal(trigger);
346 	return IRQ_HANDLED;
347 }
348 
349 static int vfio_msi_enable(struct vfio_pci_core_device *vdev, int nvec, bool msix)
350 {
351 	struct pci_dev *pdev = vdev->pdev;
352 	unsigned int flag = msix ? PCI_IRQ_MSIX : PCI_IRQ_MSI;
353 	int ret;
354 	u16 cmd;
355 
356 	if (!is_irq_none(vdev))
357 		return -EINVAL;
358 
359 	/* return the number of supported vectors if we can't get all: */
360 	cmd = vfio_pci_memory_lock_and_enable(vdev);
361 	ret = pci_alloc_irq_vectors(pdev, 1, nvec, flag);
362 	if (ret < nvec) {
363 		if (ret > 0)
364 			pci_free_irq_vectors(pdev);
365 		vfio_pci_memory_unlock_and_restore(vdev, cmd);
366 		return ret;
367 	}
368 	vfio_pci_memory_unlock_and_restore(vdev, cmd);
369 
370 	vdev->irq_type = msix ? VFIO_PCI_MSIX_IRQ_INDEX :
371 				VFIO_PCI_MSI_IRQ_INDEX;
372 
373 	if (!msix) {
374 		/*
375 		 * Compute the virtual hardware field for max msi vectors -
376 		 * it is the log base 2 of the number of vectors.
377 		 */
378 		vdev->msi_qmax = fls(nvec * 2 - 1) - 1;
379 	}
380 
381 	return 0;
382 }
383 
384 /*
385  * vfio_msi_alloc_irq() returns the Linux IRQ number of an MSI or MSI-X device
386  * interrupt vector. If a Linux IRQ number is not available then a new
387  * interrupt is allocated if dynamic MSI-X is supported.
388  *
389  * Where is vfio_msi_free_irq()? Allocated interrupts are maintained,
390  * essentially forming a cache that subsequent allocations can draw from.
391  * Interrupts are freed using pci_free_irq_vectors() when MSI/MSI-X is
392  * disabled.
393  */
394 static int vfio_msi_alloc_irq(struct vfio_pci_core_device *vdev,
395 			      unsigned int vector, bool msix)
396 {
397 	struct pci_dev *pdev = vdev->pdev;
398 	struct msi_map map;
399 	int irq;
400 	u16 cmd;
401 
402 	irq = pci_irq_vector(pdev, vector);
403 	if (WARN_ON_ONCE(irq == 0))
404 		return -EINVAL;
405 	if (irq > 0 || !msix || !vdev->has_dyn_msix)
406 		return irq;
407 
408 	cmd = vfio_pci_memory_lock_and_enable(vdev);
409 	map = pci_msix_alloc_irq_at(pdev, vector, NULL);
410 	vfio_pci_memory_unlock_and_restore(vdev, cmd);
411 
412 	return map.index < 0 ? map.index : map.virq;
413 }
414 
415 static int vfio_msi_set_vector_signal(struct vfio_pci_core_device *vdev,
416 				      unsigned int vector, int fd, bool msix)
417 {
418 	struct pci_dev *pdev = vdev->pdev;
419 	struct vfio_pci_irq_ctx *ctx;
420 	struct eventfd_ctx *trigger;
421 	int irq = -EINVAL, ret;
422 	u16 cmd;
423 
424 	ctx = vfio_irq_ctx_get(vdev, vector);
425 
426 	if (ctx) {
427 		irq_bypass_unregister_producer(&ctx->producer);
428 		irq = pci_irq_vector(pdev, vector);
429 		cmd = vfio_pci_memory_lock_and_enable(vdev);
430 		free_irq(irq, ctx->trigger);
431 		vfio_pci_memory_unlock_and_restore(vdev, cmd);
432 		/* Interrupt stays allocated, will be freed at MSI-X disable. */
433 		kfree(ctx->name);
434 		eventfd_ctx_put(ctx->trigger);
435 		vfio_irq_ctx_free(vdev, ctx, vector);
436 	}
437 
438 	if (fd < 0)
439 		return 0;
440 
441 	if (irq == -EINVAL) {
442 		/* Interrupt stays allocated, will be freed at MSI-X disable. */
443 		irq = vfio_msi_alloc_irq(vdev, vector, msix);
444 		if (irq < 0)
445 			return irq;
446 	}
447 
448 	ctx = vfio_irq_ctx_alloc(vdev, vector);
449 	if (!ctx)
450 		return -ENOMEM;
451 
452 	ctx->name = kasprintf(GFP_KERNEL_ACCOUNT, "vfio-msi%s[%d](%s)",
453 			      msix ? "x" : "", vector, pci_name(pdev));
454 	if (!ctx->name) {
455 		ret = -ENOMEM;
456 		goto out_free_ctx;
457 	}
458 
459 	trigger = eventfd_ctx_fdget(fd);
460 	if (IS_ERR(trigger)) {
461 		ret = PTR_ERR(trigger);
462 		goto out_free_name;
463 	}
464 
465 	/*
466 	 * If the vector was previously allocated, refresh the on-device
467 	 * message data before enabling in case it had been cleared or
468 	 * corrupted (e.g. due to backdoor resets) since writing.
469 	 */
470 	cmd = vfio_pci_memory_lock_and_enable(vdev);
471 	if (msix) {
472 		struct msi_msg msg;
473 
474 		get_cached_msi_msg(irq, &msg);
475 		pci_write_msi_msg(irq, &msg);
476 	}
477 
478 	ret = request_irq(irq, vfio_msihandler, 0, ctx->name, trigger);
479 	vfio_pci_memory_unlock_and_restore(vdev, cmd);
480 	if (ret)
481 		goto out_put_eventfd_ctx;
482 
483 	ctx->producer.token = trigger;
484 	ctx->producer.irq = irq;
485 	ret = irq_bypass_register_producer(&ctx->producer);
486 	if (unlikely(ret)) {
487 		dev_info(&pdev->dev,
488 		"irq bypass producer (token %p) registration fails: %d\n",
489 		ctx->producer.token, ret);
490 
491 		ctx->producer.token = NULL;
492 	}
493 	ctx->trigger = trigger;
494 
495 	return 0;
496 
497 out_put_eventfd_ctx:
498 	eventfd_ctx_put(trigger);
499 out_free_name:
500 	kfree(ctx->name);
501 out_free_ctx:
502 	vfio_irq_ctx_free(vdev, ctx, vector);
503 	return ret;
504 }
505 
506 static int vfio_msi_set_block(struct vfio_pci_core_device *vdev, unsigned start,
507 			      unsigned count, int32_t *fds, bool msix)
508 {
509 	unsigned int i, j;
510 	int ret = 0;
511 
512 	for (i = 0, j = start; i < count && !ret; i++, j++) {
513 		int fd = fds ? fds[i] : -1;
514 		ret = vfio_msi_set_vector_signal(vdev, j, fd, msix);
515 	}
516 
517 	if (ret) {
518 		for (i = start; i < j; i++)
519 			vfio_msi_set_vector_signal(vdev, i, -1, msix);
520 	}
521 
522 	return ret;
523 }
524 
525 static void vfio_msi_disable(struct vfio_pci_core_device *vdev, bool msix)
526 {
527 	struct pci_dev *pdev = vdev->pdev;
528 	struct vfio_pci_irq_ctx *ctx;
529 	unsigned long i;
530 	u16 cmd;
531 
532 	xa_for_each(&vdev->ctx, i, ctx) {
533 		vfio_virqfd_disable(&ctx->unmask);
534 		vfio_virqfd_disable(&ctx->mask);
535 		vfio_msi_set_vector_signal(vdev, i, -1, msix);
536 	}
537 
538 	cmd = vfio_pci_memory_lock_and_enable(vdev);
539 	pci_free_irq_vectors(pdev);
540 	vfio_pci_memory_unlock_and_restore(vdev, cmd);
541 
542 	/*
543 	 * Both disable paths above use pci_intx_for_msi() to clear DisINTx
544 	 * via their shutdown paths.  Restore for NoINTx devices.
545 	 */
546 	if (vdev->nointx)
547 		pci_intx(pdev, 0);
548 
549 	vdev->irq_type = VFIO_PCI_NUM_IRQS;
550 }
551 
552 /*
553  * IOCTL support
554  */
555 static int vfio_pci_set_intx_unmask(struct vfio_pci_core_device *vdev,
556 				    unsigned index, unsigned start,
557 				    unsigned count, uint32_t flags, void *data)
558 {
559 	if (!is_intx(vdev) || start != 0 || count != 1)
560 		return -EINVAL;
561 
562 	if (flags & VFIO_IRQ_SET_DATA_NONE) {
563 		vfio_pci_intx_unmask(vdev);
564 	} else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
565 		uint8_t unmask = *(uint8_t *)data;
566 		if (unmask)
567 			vfio_pci_intx_unmask(vdev);
568 	} else if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
569 		struct vfio_pci_irq_ctx *ctx = vfio_irq_ctx_get(vdev, 0);
570 		int32_t fd = *(int32_t *)data;
571 
572 		if (WARN_ON_ONCE(!ctx))
573 			return -EINVAL;
574 		if (fd >= 0)
575 			return vfio_virqfd_enable((void *) vdev,
576 						  vfio_pci_intx_unmask_handler,
577 						  vfio_send_intx_eventfd, NULL,
578 						  &ctx->unmask, fd);
579 
580 		vfio_virqfd_disable(&ctx->unmask);
581 	}
582 
583 	return 0;
584 }
585 
586 static int vfio_pci_set_intx_mask(struct vfio_pci_core_device *vdev,
587 				  unsigned index, unsigned start,
588 				  unsigned count, uint32_t flags, void *data)
589 {
590 	if (!is_intx(vdev) || start != 0 || count != 1)
591 		return -EINVAL;
592 
593 	if (flags & VFIO_IRQ_SET_DATA_NONE) {
594 		vfio_pci_intx_mask(vdev);
595 	} else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
596 		uint8_t mask = *(uint8_t *)data;
597 		if (mask)
598 			vfio_pci_intx_mask(vdev);
599 	} else if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
600 		return -ENOTTY; /* XXX implement me */
601 	}
602 
603 	return 0;
604 }
605 
606 static int vfio_pci_set_intx_trigger(struct vfio_pci_core_device *vdev,
607 				     unsigned index, unsigned start,
608 				     unsigned count, uint32_t flags, void *data)
609 {
610 	if (is_intx(vdev) && !count && (flags & VFIO_IRQ_SET_DATA_NONE)) {
611 		vfio_intx_disable(vdev);
612 		return 0;
613 	}
614 
615 	if (!(is_intx(vdev) || is_irq_none(vdev)) || start != 0 || count != 1)
616 		return -EINVAL;
617 
618 	if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
619 		int32_t fd = *(int32_t *)data;
620 		int ret;
621 
622 		if (is_intx(vdev))
623 			return vfio_intx_set_signal(vdev, fd);
624 
625 		ret = vfio_intx_enable(vdev);
626 		if (ret)
627 			return ret;
628 
629 		ret = vfio_intx_set_signal(vdev, fd);
630 		if (ret)
631 			vfio_intx_disable(vdev);
632 
633 		return ret;
634 	}
635 
636 	if (!is_intx(vdev))
637 		return -EINVAL;
638 
639 	if (flags & VFIO_IRQ_SET_DATA_NONE) {
640 		vfio_send_intx_eventfd(vdev, NULL);
641 	} else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
642 		uint8_t trigger = *(uint8_t *)data;
643 		if (trigger)
644 			vfio_send_intx_eventfd(vdev, NULL);
645 	}
646 	return 0;
647 }
648 
649 static int vfio_pci_set_msi_trigger(struct vfio_pci_core_device *vdev,
650 				    unsigned index, unsigned start,
651 				    unsigned count, uint32_t flags, void *data)
652 {
653 	struct vfio_pci_irq_ctx *ctx;
654 	unsigned int i;
655 	bool msix = (index == VFIO_PCI_MSIX_IRQ_INDEX) ? true : false;
656 
657 	if (irq_is(vdev, index) && !count && (flags & VFIO_IRQ_SET_DATA_NONE)) {
658 		vfio_msi_disable(vdev, msix);
659 		return 0;
660 	}
661 
662 	if (!(irq_is(vdev, index) || is_irq_none(vdev)))
663 		return -EINVAL;
664 
665 	if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
666 		int32_t *fds = data;
667 		int ret;
668 
669 		if (vdev->irq_type == index)
670 			return vfio_msi_set_block(vdev, start, count,
671 						  fds, msix);
672 
673 		ret = vfio_msi_enable(vdev, start + count, msix);
674 		if (ret)
675 			return ret;
676 
677 		ret = vfio_msi_set_block(vdev, start, count, fds, msix);
678 		if (ret)
679 			vfio_msi_disable(vdev, msix);
680 
681 		return ret;
682 	}
683 
684 	if (!irq_is(vdev, index))
685 		return -EINVAL;
686 
687 	for (i = start; i < start + count; i++) {
688 		ctx = vfio_irq_ctx_get(vdev, i);
689 		if (!ctx)
690 			continue;
691 		if (flags & VFIO_IRQ_SET_DATA_NONE) {
692 			eventfd_signal(ctx->trigger);
693 		} else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
694 			uint8_t *bools = data;
695 			if (bools[i - start])
696 				eventfd_signal(ctx->trigger);
697 		}
698 	}
699 	return 0;
700 }
701 
702 static int vfio_pci_set_ctx_trigger_single(struct eventfd_ctx **ctx,
703 					   unsigned int count, uint32_t flags,
704 					   void *data)
705 {
706 	/* DATA_NONE/DATA_BOOL enables loopback testing */
707 	if (flags & VFIO_IRQ_SET_DATA_NONE) {
708 		if (*ctx) {
709 			if (count) {
710 				eventfd_signal(*ctx);
711 			} else {
712 				eventfd_ctx_put(*ctx);
713 				*ctx = NULL;
714 			}
715 			return 0;
716 		}
717 	} else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
718 		uint8_t trigger;
719 
720 		if (!count)
721 			return -EINVAL;
722 
723 		trigger = *(uint8_t *)data;
724 		if (trigger && *ctx)
725 			eventfd_signal(*ctx);
726 
727 		return 0;
728 	} else if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
729 		int32_t fd;
730 
731 		if (!count)
732 			return -EINVAL;
733 
734 		fd = *(int32_t *)data;
735 		if (fd == -1) {
736 			if (*ctx)
737 				eventfd_ctx_put(*ctx);
738 			*ctx = NULL;
739 		} else if (fd >= 0) {
740 			struct eventfd_ctx *efdctx;
741 
742 			efdctx = eventfd_ctx_fdget(fd);
743 			if (IS_ERR(efdctx))
744 				return PTR_ERR(efdctx);
745 
746 			if (*ctx)
747 				eventfd_ctx_put(*ctx);
748 
749 			*ctx = efdctx;
750 		}
751 		return 0;
752 	}
753 
754 	return -EINVAL;
755 }
756 
757 static int vfio_pci_set_err_trigger(struct vfio_pci_core_device *vdev,
758 				    unsigned index, unsigned start,
759 				    unsigned count, uint32_t flags, void *data)
760 {
761 	if (index != VFIO_PCI_ERR_IRQ_INDEX || start != 0 || count > 1)
762 		return -EINVAL;
763 
764 	return vfio_pci_set_ctx_trigger_single(&vdev->err_trigger,
765 					       count, flags, data);
766 }
767 
768 static int vfio_pci_set_req_trigger(struct vfio_pci_core_device *vdev,
769 				    unsigned index, unsigned start,
770 				    unsigned count, uint32_t flags, void *data)
771 {
772 	if (index != VFIO_PCI_REQ_IRQ_INDEX || start != 0 || count > 1)
773 		return -EINVAL;
774 
775 	return vfio_pci_set_ctx_trigger_single(&vdev->req_trigger,
776 					       count, flags, data);
777 }
778 
779 int vfio_pci_set_irqs_ioctl(struct vfio_pci_core_device *vdev, uint32_t flags,
780 			    unsigned index, unsigned start, unsigned count,
781 			    void *data)
782 {
783 	int (*func)(struct vfio_pci_core_device *vdev, unsigned index,
784 		    unsigned start, unsigned count, uint32_t flags,
785 		    void *data) = NULL;
786 
787 	switch (index) {
788 	case VFIO_PCI_INTX_IRQ_INDEX:
789 		switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
790 		case VFIO_IRQ_SET_ACTION_MASK:
791 			func = vfio_pci_set_intx_mask;
792 			break;
793 		case VFIO_IRQ_SET_ACTION_UNMASK:
794 			func = vfio_pci_set_intx_unmask;
795 			break;
796 		case VFIO_IRQ_SET_ACTION_TRIGGER:
797 			func = vfio_pci_set_intx_trigger;
798 			break;
799 		}
800 		break;
801 	case VFIO_PCI_MSI_IRQ_INDEX:
802 	case VFIO_PCI_MSIX_IRQ_INDEX:
803 		switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
804 		case VFIO_IRQ_SET_ACTION_MASK:
805 		case VFIO_IRQ_SET_ACTION_UNMASK:
806 			/* XXX Need masking support exported */
807 			break;
808 		case VFIO_IRQ_SET_ACTION_TRIGGER:
809 			func = vfio_pci_set_msi_trigger;
810 			break;
811 		}
812 		break;
813 	case VFIO_PCI_ERR_IRQ_INDEX:
814 		switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
815 		case VFIO_IRQ_SET_ACTION_TRIGGER:
816 			if (pci_is_pcie(vdev->pdev))
817 				func = vfio_pci_set_err_trigger;
818 			break;
819 		}
820 		break;
821 	case VFIO_PCI_REQ_IRQ_INDEX:
822 		switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
823 		case VFIO_IRQ_SET_ACTION_TRIGGER:
824 			func = vfio_pci_set_req_trigger;
825 			break;
826 		}
827 		break;
828 	}
829 
830 	if (!func)
831 		return -ENOTTY;
832 
833 	return func(vdev, index, start, count, flags, data);
834 }
835