2 * Kernel-based Virtual Machine - device assignment support
4 * Copyright (C) 2010 Red Hat, Inc. and/or its affiliates.
6 * This work is licensed under the terms of the GNU GPL, version 2. See
7 * the COPYING file in the top-level directory.
11 #include <linux/kvm_host.h>
12 #include <linux/kvm.h>
13 #include <linux/uaccess.h>
14 #include <linux/vmalloc.h>
15 #include <linux/errno.h>
16 #include <linux/spinlock.h>
17 #include <linux/pci.h>
18 #include <linux/interrupt.h>
19 #include <linux/slab.h>
20 #include <linux/namei.h>
24 static struct kvm_assigned_dev_kernel
*kvm_find_assigned_dev(struct list_head
*head
,
27 struct list_head
*ptr
;
28 struct kvm_assigned_dev_kernel
*match
;
30 list_for_each(ptr
, head
) {
31 match
= list_entry(ptr
, struct kvm_assigned_dev_kernel
, list
);
32 if (match
->assigned_dev_id
== assigned_dev_id
)
38 static int find_index_from_host_irq(struct kvm_assigned_dev_kernel
39 *assigned_dev
, int irq
)
42 struct msix_entry
*host_msix_entries
;
44 host_msix_entries
= assigned_dev
->host_msix_entries
;
47 for (i
= 0; i
< assigned_dev
->entries_nr
; i
++)
48 if (irq
== host_msix_entries
[i
].vector
) {
53 printk(KERN_WARNING
"Fail to find correlated MSI-X entry!\n");
58 static irqreturn_t
kvm_assigned_dev_intx(int irq
, void *dev_id
)
60 struct kvm_assigned_dev_kernel
*assigned_dev
= dev_id
;
63 spin_lock(&assigned_dev
->intx_lock
);
64 if (pci_check_and_mask_intx(assigned_dev
->dev
)) {
65 assigned_dev
->host_irq_disabled
= true;
66 ret
= IRQ_WAKE_THREAD
;
69 spin_unlock(&assigned_dev
->intx_lock
);
75 kvm_assigned_dev_raise_guest_irq(struct kvm_assigned_dev_kernel
*assigned_dev
,
78 if (unlikely(assigned_dev
->irq_requested_type
&
79 KVM_DEV_IRQ_GUEST_INTX
)) {
80 spin_lock(&assigned_dev
->intx_mask_lock
);
81 if (!(assigned_dev
->flags
& KVM_DEV_ASSIGN_MASK_INTX
))
82 kvm_set_irq(assigned_dev
->kvm
,
83 assigned_dev
->irq_source_id
, vector
, 1);
84 spin_unlock(&assigned_dev
->intx_mask_lock
);
86 kvm_set_irq(assigned_dev
->kvm
, assigned_dev
->irq_source_id
,
90 static irqreturn_t
kvm_assigned_dev_thread_intx(int irq
, void *dev_id
)
92 struct kvm_assigned_dev_kernel
*assigned_dev
= dev_id
;
94 if (!(assigned_dev
->flags
& KVM_DEV_ASSIGN_PCI_2_3
)) {
95 spin_lock_irq(&assigned_dev
->intx_lock
);
96 disable_irq_nosync(irq
);
97 assigned_dev
->host_irq_disabled
= true;
98 spin_unlock_irq(&assigned_dev
->intx_lock
);
101 kvm_assigned_dev_raise_guest_irq(assigned_dev
,
102 assigned_dev
->guest_irq
);
107 #ifdef __KVM_HAVE_MSI
108 static irqreturn_t
kvm_assigned_dev_thread_msi(int irq
, void *dev_id
)
110 struct kvm_assigned_dev_kernel
*assigned_dev
= dev_id
;
112 kvm_assigned_dev_raise_guest_irq(assigned_dev
,
113 assigned_dev
->guest_irq
);
119 #ifdef __KVM_HAVE_MSIX
120 static irqreturn_t
kvm_assigned_dev_thread_msix(int irq
, void *dev_id
)
122 struct kvm_assigned_dev_kernel
*assigned_dev
= dev_id
;
123 int index
= find_index_from_host_irq(assigned_dev
, irq
);
127 vector
= assigned_dev
->guest_msix_entries
[index
].vector
;
128 kvm_assigned_dev_raise_guest_irq(assigned_dev
, vector
);
135 /* Ack the irq line for an assigned device */
136 static void kvm_assigned_dev_ack_irq(struct kvm_irq_ack_notifier
*kian
)
138 struct kvm_assigned_dev_kernel
*dev
=
139 container_of(kian
, struct kvm_assigned_dev_kernel
,
142 kvm_set_irq(dev
->kvm
, dev
->irq_source_id
, dev
->guest_irq
, 0);
144 spin_lock(&dev
->intx_mask_lock
);
146 if (!(dev
->flags
& KVM_DEV_ASSIGN_MASK_INTX
)) {
147 bool reassert
= false;
149 spin_lock_irq(&dev
->intx_lock
);
151 * The guest IRQ may be shared so this ack can come from an
152 * IRQ for another guest device.
154 if (dev
->host_irq_disabled
) {
155 if (!(dev
->flags
& KVM_DEV_ASSIGN_PCI_2_3
))
156 enable_irq(dev
->host_irq
);
157 else if (!pci_check_and_unmask_intx(dev
->dev
))
159 dev
->host_irq_disabled
= reassert
;
161 spin_unlock_irq(&dev
->intx_lock
);
164 kvm_set_irq(dev
->kvm
, dev
->irq_source_id
,
168 spin_unlock(&dev
->intx_mask_lock
);
171 static void deassign_guest_irq(struct kvm
*kvm
,
172 struct kvm_assigned_dev_kernel
*assigned_dev
)
174 if (assigned_dev
->ack_notifier
.gsi
!= -1)
175 kvm_unregister_irq_ack_notifier(kvm
,
176 &assigned_dev
->ack_notifier
);
178 kvm_set_irq(assigned_dev
->kvm
, assigned_dev
->irq_source_id
,
179 assigned_dev
->guest_irq
, 0);
181 if (assigned_dev
->irq_source_id
!= -1)
182 kvm_free_irq_source_id(kvm
, assigned_dev
->irq_source_id
);
183 assigned_dev
->irq_source_id
= -1;
184 assigned_dev
->irq_requested_type
&= ~(KVM_DEV_IRQ_GUEST_MASK
);
187 /* The function implicit hold kvm->lock mutex due to cancel_work_sync() */
188 static void deassign_host_irq(struct kvm
*kvm
,
189 struct kvm_assigned_dev_kernel
*assigned_dev
)
192 * We disable irq here to prevent further events.
194 * Notice this maybe result in nested disable if the interrupt type is
195 * INTx, but it's OK for we are going to free it.
197 * If this function is a part of VM destroy, please ensure that till
198 * now, the kvm state is still legal for probably we also have to wait
199 * on a currently running IRQ handler.
201 if (assigned_dev
->irq_requested_type
& KVM_DEV_IRQ_HOST_MSIX
) {
203 for (i
= 0; i
< assigned_dev
->entries_nr
; i
++)
204 disable_irq(assigned_dev
->host_msix_entries
[i
].vector
);
206 for (i
= 0; i
< assigned_dev
->entries_nr
; i
++)
207 free_irq(assigned_dev
->host_msix_entries
[i
].vector
,
210 assigned_dev
->entries_nr
= 0;
211 kfree(assigned_dev
->host_msix_entries
);
212 kfree(assigned_dev
->guest_msix_entries
);
213 pci_disable_msix(assigned_dev
->dev
);
215 /* Deal with MSI and INTx */
216 if ((assigned_dev
->irq_requested_type
&
217 KVM_DEV_IRQ_HOST_INTX
) &&
218 (assigned_dev
->flags
& KVM_DEV_ASSIGN_PCI_2_3
)) {
219 spin_lock_irq(&assigned_dev
->intx_lock
);
220 pci_intx(assigned_dev
->dev
, false);
221 spin_unlock_irq(&assigned_dev
->intx_lock
);
222 synchronize_irq(assigned_dev
->host_irq
);
224 disable_irq(assigned_dev
->host_irq
);
226 free_irq(assigned_dev
->host_irq
, assigned_dev
);
228 if (assigned_dev
->irq_requested_type
& KVM_DEV_IRQ_HOST_MSI
)
229 pci_disable_msi(assigned_dev
->dev
);
232 assigned_dev
->irq_requested_type
&= ~(KVM_DEV_IRQ_HOST_MASK
);
235 static int kvm_deassign_irq(struct kvm
*kvm
,
236 struct kvm_assigned_dev_kernel
*assigned_dev
,
237 unsigned long irq_requested_type
)
239 unsigned long guest_irq_type
, host_irq_type
;
241 if (!irqchip_in_kernel(kvm
))
243 /* no irq assignment to deassign */
244 if (!assigned_dev
->irq_requested_type
)
247 host_irq_type
= irq_requested_type
& KVM_DEV_IRQ_HOST_MASK
;
248 guest_irq_type
= irq_requested_type
& KVM_DEV_IRQ_GUEST_MASK
;
251 deassign_host_irq(kvm
, assigned_dev
);
253 deassign_guest_irq(kvm
, assigned_dev
);
258 static void kvm_free_assigned_irq(struct kvm
*kvm
,
259 struct kvm_assigned_dev_kernel
*assigned_dev
)
261 kvm_deassign_irq(kvm
, assigned_dev
, assigned_dev
->irq_requested_type
);
264 static void kvm_free_assigned_device(struct kvm
*kvm
,
265 struct kvm_assigned_dev_kernel
268 kvm_free_assigned_irq(kvm
, assigned_dev
);
270 pci_reset_function(assigned_dev
->dev
);
271 if (pci_load_and_free_saved_state(assigned_dev
->dev
,
272 &assigned_dev
->pci_saved_state
))
273 printk(KERN_INFO
"%s: Couldn't reload %s saved state\n",
274 __func__
, dev_name(&assigned_dev
->dev
->dev
));
276 pci_restore_state(assigned_dev
->dev
);
278 assigned_dev
->dev
->dev_flags
&= ~PCI_DEV_FLAGS_ASSIGNED
;
280 pci_release_regions(assigned_dev
->dev
);
281 pci_disable_device(assigned_dev
->dev
);
282 pci_dev_put(assigned_dev
->dev
);
284 list_del(&assigned_dev
->list
);
288 void kvm_free_all_assigned_devices(struct kvm
*kvm
)
290 struct list_head
*ptr
, *ptr2
;
291 struct kvm_assigned_dev_kernel
*assigned_dev
;
293 list_for_each_safe(ptr
, ptr2
, &kvm
->arch
.assigned_dev_head
) {
294 assigned_dev
= list_entry(ptr
,
295 struct kvm_assigned_dev_kernel
,
298 kvm_free_assigned_device(kvm
, assigned_dev
);
302 static int assigned_device_enable_host_intx(struct kvm
*kvm
,
303 struct kvm_assigned_dev_kernel
*dev
)
305 irq_handler_t irq_handler
;
308 dev
->host_irq
= dev
->dev
->irq
;
311 * We can only share the IRQ line with other host devices if we are
312 * able to disable the IRQ source at device-level - independently of
313 * the guest driver. Otherwise host devices may suffer from unbounded
314 * IRQ latencies when the guest keeps the line asserted.
316 if (dev
->flags
& KVM_DEV_ASSIGN_PCI_2_3
) {
317 irq_handler
= kvm_assigned_dev_intx
;
321 flags
= IRQF_ONESHOT
;
323 if (request_threaded_irq(dev
->host_irq
, irq_handler
,
324 kvm_assigned_dev_thread_intx
, flags
,
328 if (dev
->flags
& KVM_DEV_ASSIGN_PCI_2_3
) {
329 spin_lock_irq(&dev
->intx_lock
);
330 pci_intx(dev
->dev
, true);
331 spin_unlock_irq(&dev
->intx_lock
);
336 #ifdef __KVM_HAVE_MSI
337 static int assigned_device_enable_host_msi(struct kvm
*kvm
,
338 struct kvm_assigned_dev_kernel
*dev
)
342 if (!dev
->dev
->msi_enabled
) {
343 r
= pci_enable_msi(dev
->dev
);
348 dev
->host_irq
= dev
->dev
->irq
;
349 if (request_threaded_irq(dev
->host_irq
, NULL
,
350 kvm_assigned_dev_thread_msi
, 0,
351 dev
->irq_name
, dev
)) {
352 pci_disable_msi(dev
->dev
);
360 #ifdef __KVM_HAVE_MSIX
361 static int assigned_device_enable_host_msix(struct kvm
*kvm
,
362 struct kvm_assigned_dev_kernel
*dev
)
366 /* host_msix_entries and guest_msix_entries should have been
368 if (dev
->entries_nr
== 0)
371 r
= pci_enable_msix(dev
->dev
, dev
->host_msix_entries
, dev
->entries_nr
);
375 for (i
= 0; i
< dev
->entries_nr
; i
++) {
376 r
= request_threaded_irq(dev
->host_msix_entries
[i
].vector
,
377 NULL
, kvm_assigned_dev_thread_msix
,
378 0, dev
->irq_name
, dev
);
385 for (i
-= 1; i
>= 0; i
--)
386 free_irq(dev
->host_msix_entries
[i
].vector
, dev
);
387 pci_disable_msix(dev
->dev
);
393 static int assigned_device_enable_guest_intx(struct kvm
*kvm
,
394 struct kvm_assigned_dev_kernel
*dev
,
395 struct kvm_assigned_irq
*irq
)
397 dev
->guest_irq
= irq
->guest_irq
;
398 dev
->ack_notifier
.gsi
= irq
->guest_irq
;
402 #ifdef __KVM_HAVE_MSI
403 static int assigned_device_enable_guest_msi(struct kvm
*kvm
,
404 struct kvm_assigned_dev_kernel
*dev
,
405 struct kvm_assigned_irq
*irq
)
407 dev
->guest_irq
= irq
->guest_irq
;
408 dev
->ack_notifier
.gsi
= -1;
413 #ifdef __KVM_HAVE_MSIX
414 static int assigned_device_enable_guest_msix(struct kvm
*kvm
,
415 struct kvm_assigned_dev_kernel
*dev
,
416 struct kvm_assigned_irq
*irq
)
418 dev
->guest_irq
= irq
->guest_irq
;
419 dev
->ack_notifier
.gsi
= -1;
424 static int assign_host_irq(struct kvm
*kvm
,
425 struct kvm_assigned_dev_kernel
*dev
,
430 if (dev
->irq_requested_type
& KVM_DEV_IRQ_HOST_MASK
)
433 snprintf(dev
->irq_name
, sizeof(dev
->irq_name
), "kvm:%s",
436 switch (host_irq_type
) {
437 case KVM_DEV_IRQ_HOST_INTX
:
438 r
= assigned_device_enable_host_intx(kvm
, dev
);
440 #ifdef __KVM_HAVE_MSI
441 case KVM_DEV_IRQ_HOST_MSI
:
442 r
= assigned_device_enable_host_msi(kvm
, dev
);
445 #ifdef __KVM_HAVE_MSIX
446 case KVM_DEV_IRQ_HOST_MSIX
:
447 r
= assigned_device_enable_host_msix(kvm
, dev
);
453 dev
->host_irq_disabled
= false;
456 dev
->irq_requested_type
|= host_irq_type
;
461 static int assign_guest_irq(struct kvm
*kvm
,
462 struct kvm_assigned_dev_kernel
*dev
,
463 struct kvm_assigned_irq
*irq
,
464 unsigned long guest_irq_type
)
469 if (dev
->irq_requested_type
& KVM_DEV_IRQ_GUEST_MASK
)
472 id
= kvm_request_irq_source_id(kvm
);
476 dev
->irq_source_id
= id
;
478 switch (guest_irq_type
) {
479 case KVM_DEV_IRQ_GUEST_INTX
:
480 r
= assigned_device_enable_guest_intx(kvm
, dev
, irq
);
482 #ifdef __KVM_HAVE_MSI
483 case KVM_DEV_IRQ_GUEST_MSI
:
484 r
= assigned_device_enable_guest_msi(kvm
, dev
, irq
);
487 #ifdef __KVM_HAVE_MSIX
488 case KVM_DEV_IRQ_GUEST_MSIX
:
489 r
= assigned_device_enable_guest_msix(kvm
, dev
, irq
);
497 dev
->irq_requested_type
|= guest_irq_type
;
498 if (dev
->ack_notifier
.gsi
!= -1)
499 kvm_register_irq_ack_notifier(kvm
, &dev
->ack_notifier
);
501 kvm_free_irq_source_id(kvm
, dev
->irq_source_id
);
506 /* TODO Deal with KVM_DEV_IRQ_ASSIGNED_MASK_MSIX */
507 static int kvm_vm_ioctl_assign_irq(struct kvm
*kvm
,
508 struct kvm_assigned_irq
*assigned_irq
)
511 struct kvm_assigned_dev_kernel
*match
;
512 unsigned long host_irq_type
, guest_irq_type
;
514 if (!irqchip_in_kernel(kvm
))
517 mutex_lock(&kvm
->lock
);
519 match
= kvm_find_assigned_dev(&kvm
->arch
.assigned_dev_head
,
520 assigned_irq
->assigned_dev_id
);
524 host_irq_type
= (assigned_irq
->flags
& KVM_DEV_IRQ_HOST_MASK
);
525 guest_irq_type
= (assigned_irq
->flags
& KVM_DEV_IRQ_GUEST_MASK
);
528 /* can only assign one type at a time */
529 if (hweight_long(host_irq_type
) > 1)
531 if (hweight_long(guest_irq_type
) > 1)
533 if (host_irq_type
== 0 && guest_irq_type
== 0)
538 r
= assign_host_irq(kvm
, match
, host_irq_type
);
543 r
= assign_guest_irq(kvm
, match
, assigned_irq
, guest_irq_type
);
545 mutex_unlock(&kvm
->lock
);
549 static int kvm_vm_ioctl_deassign_dev_irq(struct kvm
*kvm
,
550 struct kvm_assigned_irq
554 struct kvm_assigned_dev_kernel
*match
;
555 unsigned long irq_type
;
557 mutex_lock(&kvm
->lock
);
559 match
= kvm_find_assigned_dev(&kvm
->arch
.assigned_dev_head
,
560 assigned_irq
->assigned_dev_id
);
564 irq_type
= assigned_irq
->flags
& (KVM_DEV_IRQ_HOST_MASK
|
565 KVM_DEV_IRQ_GUEST_MASK
);
566 r
= kvm_deassign_irq(kvm
, match
, irq_type
);
568 mutex_unlock(&kvm
->lock
);
573 * We want to test whether the caller has been granted permissions to
574 * use this device. To be able to configure and control the device,
575 * the user needs access to PCI configuration space and BAR resources.
576 * These are accessed through PCI sysfs. PCI config space is often
577 * passed to the process calling this ioctl via file descriptor, so we
578 * can't rely on access to that file. We can check for permissions
579 * on each of the BAR resource files, which is a pretty clear
580 * indicator that the user has been granted access to the device.
582 static int probe_sysfs_permissions(struct pci_dev
*dev
)
586 bool bar_found
= false;
588 for (i
= PCI_STD_RESOURCES
; i
<= PCI_STD_RESOURCE_END
; i
++) {
589 char *kpath
, *syspath
;
594 if (!pci_resource_len(dev
, i
))
597 kpath
= kobject_get_path(&dev
->dev
.kobj
, GFP_KERNEL
);
601 /* Per sysfs-rules, sysfs is always at /sys */
602 syspath
= kasprintf(GFP_KERNEL
, "/sys%s/resource%d", kpath
, i
);
607 r
= kern_path(syspath
, LOOKUP_FOLLOW
, &path
);
612 inode
= path
.dentry
->d_inode
;
614 r
= inode_permission(inode
, MAY_READ
| MAY_WRITE
| MAY_ACCESS
);
622 /* If no resources, probably something special */
628 return -EINVAL
; /* No way to control the device without sysfs */
632 static int kvm_vm_ioctl_assign_device(struct kvm
*kvm
,
633 struct kvm_assigned_pci_dev
*assigned_dev
)
636 struct kvm_assigned_dev_kernel
*match
;
640 if (!(assigned_dev
->flags
& KVM_DEV_ASSIGN_ENABLE_IOMMU
))
643 mutex_lock(&kvm
->lock
);
644 idx
= srcu_read_lock(&kvm
->srcu
);
646 match
= kvm_find_assigned_dev(&kvm
->arch
.assigned_dev_head
,
647 assigned_dev
->assigned_dev_id
);
649 /* device already assigned */
654 match
= kzalloc(sizeof(struct kvm_assigned_dev_kernel
), GFP_KERNEL
);
656 printk(KERN_INFO
"%s: Couldn't allocate memory\n",
661 dev
= pci_get_domain_bus_and_slot(assigned_dev
->segnr
,
663 assigned_dev
->devfn
);
665 printk(KERN_INFO
"%s: host device not found\n", __func__
);
670 /* Don't allow bridges to be assigned */
671 pci_read_config_byte(dev
, PCI_HEADER_TYPE
, &header_type
);
672 if ((header_type
& PCI_HEADER_TYPE
) != PCI_HEADER_TYPE_NORMAL
) {
677 r
= probe_sysfs_permissions(dev
);
681 if (pci_enable_device(dev
)) {
682 printk(KERN_INFO
"%s: Could not enable PCI device\n", __func__
);
686 r
= pci_request_regions(dev
, "kvm_assigned_device");
688 printk(KERN_INFO
"%s: Could not get access to device regions\n",
693 pci_reset_function(dev
);
695 match
->pci_saved_state
= pci_store_saved_state(dev
);
696 if (!match
->pci_saved_state
)
697 printk(KERN_DEBUG
"%s: Couldn't store %s saved state\n",
698 __func__
, dev_name(&dev
->dev
));
700 if (!pci_intx_mask_supported(dev
))
701 assigned_dev
->flags
&= ~KVM_DEV_ASSIGN_PCI_2_3
;
703 match
->assigned_dev_id
= assigned_dev
->assigned_dev_id
;
704 match
->host_segnr
= assigned_dev
->segnr
;
705 match
->host_busnr
= assigned_dev
->busnr
;
706 match
->host_devfn
= assigned_dev
->devfn
;
707 match
->flags
= assigned_dev
->flags
;
709 spin_lock_init(&match
->intx_lock
);
710 spin_lock_init(&match
->intx_mask_lock
);
711 match
->irq_source_id
= -1;
713 match
->ack_notifier
.irq_acked
= kvm_assigned_dev_ack_irq
;
715 list_add(&match
->list
, &kvm
->arch
.assigned_dev_head
);
717 if (!kvm
->arch
.iommu_domain
) {
718 r
= kvm_iommu_map_guest(kvm
);
722 r
= kvm_assign_device(kvm
, match
);
727 srcu_read_unlock(&kvm
->srcu
, idx
);
728 mutex_unlock(&kvm
->lock
);
731 if (pci_load_and_free_saved_state(dev
, &match
->pci_saved_state
))
732 printk(KERN_INFO
"%s: Couldn't reload %s saved state\n",
733 __func__
, dev_name(&dev
->dev
));
734 list_del(&match
->list
);
735 pci_release_regions(dev
);
737 pci_disable_device(dev
);
742 srcu_read_unlock(&kvm
->srcu
, idx
);
743 mutex_unlock(&kvm
->lock
);
747 static int kvm_vm_ioctl_deassign_device(struct kvm
*kvm
,
748 struct kvm_assigned_pci_dev
*assigned_dev
)
751 struct kvm_assigned_dev_kernel
*match
;
753 mutex_lock(&kvm
->lock
);
755 match
= kvm_find_assigned_dev(&kvm
->arch
.assigned_dev_head
,
756 assigned_dev
->assigned_dev_id
);
758 printk(KERN_INFO
"%s: device hasn't been assigned before, "
759 "so cannot be deassigned\n", __func__
);
764 kvm_deassign_device(kvm
, match
);
766 kvm_free_assigned_device(kvm
, match
);
769 mutex_unlock(&kvm
->lock
);
774 #ifdef __KVM_HAVE_MSIX
775 static int kvm_vm_ioctl_set_msix_nr(struct kvm
*kvm
,
776 struct kvm_assigned_msix_nr
*entry_nr
)
779 struct kvm_assigned_dev_kernel
*adev
;
781 mutex_lock(&kvm
->lock
);
783 adev
= kvm_find_assigned_dev(&kvm
->arch
.assigned_dev_head
,
784 entry_nr
->assigned_dev_id
);
790 if (adev
->entries_nr
== 0) {
791 adev
->entries_nr
= entry_nr
->entry_nr
;
792 if (adev
->entries_nr
== 0 ||
793 adev
->entries_nr
> KVM_MAX_MSIX_PER_DEV
) {
798 adev
->host_msix_entries
= kzalloc(sizeof(struct msix_entry
) *
801 if (!adev
->host_msix_entries
) {
805 adev
->guest_msix_entries
=
806 kzalloc(sizeof(struct msix_entry
) * entry_nr
->entry_nr
,
808 if (!adev
->guest_msix_entries
) {
809 kfree(adev
->host_msix_entries
);
813 } else /* Not allowed set MSI-X number twice */
816 mutex_unlock(&kvm
->lock
);
820 static int kvm_vm_ioctl_set_msix_entry(struct kvm
*kvm
,
821 struct kvm_assigned_msix_entry
*entry
)
824 struct kvm_assigned_dev_kernel
*adev
;
826 mutex_lock(&kvm
->lock
);
828 adev
= kvm_find_assigned_dev(&kvm
->arch
.assigned_dev_head
,
829 entry
->assigned_dev_id
);
836 for (i
= 0; i
< adev
->entries_nr
; i
++)
837 if (adev
->guest_msix_entries
[i
].vector
== 0 ||
838 adev
->guest_msix_entries
[i
].entry
== entry
->entry
) {
839 adev
->guest_msix_entries
[i
].entry
= entry
->entry
;
840 adev
->guest_msix_entries
[i
].vector
= entry
->gsi
;
841 adev
->host_msix_entries
[i
].entry
= entry
->entry
;
844 if (i
== adev
->entries_nr
) {
850 mutex_unlock(&kvm
->lock
);
856 static int kvm_vm_ioctl_set_pci_irq_mask(struct kvm
*kvm
,
857 struct kvm_assigned_pci_dev
*assigned_dev
)
860 struct kvm_assigned_dev_kernel
*match
;
862 mutex_lock(&kvm
->lock
);
864 match
= kvm_find_assigned_dev(&kvm
->arch
.assigned_dev_head
,
865 assigned_dev
->assigned_dev_id
);
871 spin_lock(&match
->intx_mask_lock
);
873 match
->flags
&= ~KVM_DEV_ASSIGN_MASK_INTX
;
874 match
->flags
|= assigned_dev
->flags
& KVM_DEV_ASSIGN_MASK_INTX
;
876 if (match
->irq_requested_type
& KVM_DEV_IRQ_GUEST_INTX
) {
877 if (assigned_dev
->flags
& KVM_DEV_ASSIGN_MASK_INTX
) {
878 kvm_set_irq(match
->kvm
, match
->irq_source_id
,
879 match
->guest_irq
, 0);
881 * Masking at hardware-level is performed on demand,
882 * i.e. when an IRQ actually arrives at the host.
884 } else if (!(assigned_dev
->flags
& KVM_DEV_ASSIGN_PCI_2_3
)) {
886 * Unmask the IRQ line if required. Unmasking at
887 * device level will be performed by user space.
889 spin_lock_irq(&match
->intx_lock
);
890 if (match
->host_irq_disabled
) {
891 enable_irq(match
->host_irq
);
892 match
->host_irq_disabled
= false;
894 spin_unlock_irq(&match
->intx_lock
);
898 spin_unlock(&match
->intx_mask_lock
);
901 mutex_unlock(&kvm
->lock
);
905 long kvm_vm_ioctl_assigned_device(struct kvm
*kvm
, unsigned ioctl
,
908 void __user
*argp
= (void __user
*)arg
;
912 case KVM_ASSIGN_PCI_DEVICE
: {
913 struct kvm_assigned_pci_dev assigned_dev
;
916 if (copy_from_user(&assigned_dev
, argp
, sizeof assigned_dev
))
918 r
= kvm_vm_ioctl_assign_device(kvm
, &assigned_dev
);
923 case KVM_ASSIGN_IRQ
: {
927 case KVM_ASSIGN_DEV_IRQ
: {
928 struct kvm_assigned_irq assigned_irq
;
931 if (copy_from_user(&assigned_irq
, argp
, sizeof assigned_irq
))
933 r
= kvm_vm_ioctl_assign_irq(kvm
, &assigned_irq
);
938 case KVM_DEASSIGN_DEV_IRQ
: {
939 struct kvm_assigned_irq assigned_irq
;
942 if (copy_from_user(&assigned_irq
, argp
, sizeof assigned_irq
))
944 r
= kvm_vm_ioctl_deassign_dev_irq(kvm
, &assigned_irq
);
949 case KVM_DEASSIGN_PCI_DEVICE
: {
950 struct kvm_assigned_pci_dev assigned_dev
;
953 if (copy_from_user(&assigned_dev
, argp
, sizeof assigned_dev
))
955 r
= kvm_vm_ioctl_deassign_device(kvm
, &assigned_dev
);
960 #ifdef KVM_CAP_IRQ_ROUTING
961 case KVM_SET_GSI_ROUTING
: {
962 struct kvm_irq_routing routing
;
963 struct kvm_irq_routing __user
*urouting
;
964 struct kvm_irq_routing_entry
*entries
;
967 if (copy_from_user(&routing
, argp
, sizeof(routing
)))
970 if (routing
.nr
>= KVM_MAX_IRQ_ROUTES
)
975 entries
= vmalloc(routing
.nr
* sizeof(*entries
));
980 if (copy_from_user(entries
, urouting
->entries
,
981 routing
.nr
* sizeof(*entries
)))
982 goto out_free_irq_routing
;
983 r
= kvm_set_irq_routing(kvm
, entries
, routing
.nr
,
985 out_free_irq_routing
:
989 #endif /* KVM_CAP_IRQ_ROUTING */
990 #ifdef __KVM_HAVE_MSIX
991 case KVM_ASSIGN_SET_MSIX_NR
: {
992 struct kvm_assigned_msix_nr entry_nr
;
994 if (copy_from_user(&entry_nr
, argp
, sizeof entry_nr
))
996 r
= kvm_vm_ioctl_set_msix_nr(kvm
, &entry_nr
);
1001 case KVM_ASSIGN_SET_MSIX_ENTRY
: {
1002 struct kvm_assigned_msix_entry entry
;
1004 if (copy_from_user(&entry
, argp
, sizeof entry
))
1006 r
= kvm_vm_ioctl_set_msix_entry(kvm
, &entry
);
1012 case KVM_ASSIGN_SET_INTX_MASK
: {
1013 struct kvm_assigned_pci_dev assigned_dev
;
1016 if (copy_from_user(&assigned_dev
, argp
, sizeof assigned_dev
))
1018 r
= kvm_vm_ioctl_set_pci_irq_mask(kvm
, &assigned_dev
);