diff options
Diffstat (limited to 'qemu/hw/vfio')
| -rw-r--r-- | qemu/hw/vfio/Makefile.objs | 7 | ||||
| -rw-r--r-- | qemu/hw/vfio/amd-xgbe.c | 56 | ||||
| -rw-r--r-- | qemu/hw/vfio/calxeda-xgmac.c | 56 | ||||
| -rw-r--r-- | qemu/hw/vfio/common.c | 1192 | ||||
| -rw-r--r-- | qemu/hw/vfio/pci-quirks.c | 1205 | ||||
| -rw-r--r-- | qemu/hw/vfio/pci.c | 2734 | ||||
| -rw-r--r-- | qemu/hw/vfio/pci.h | 162 | ||||
| -rw-r--r-- | qemu/hw/vfio/platform.c | 705 |
8 files changed, 0 insertions, 6117 deletions
diff --git a/qemu/hw/vfio/Makefile.objs b/qemu/hw/vfio/Makefile.objs deleted file mode 100644 index ceddbb8f9..000000000 --- a/qemu/hw/vfio/Makefile.objs +++ /dev/null @@ -1,7 +0,0 @@ -ifeq ($(CONFIG_LINUX), y) -obj-$(CONFIG_SOFTMMU) += common.o -obj-$(CONFIG_PCI) += pci.o pci-quirks.o -obj-$(CONFIG_SOFTMMU) += platform.o -obj-$(CONFIG_SOFTMMU) += calxeda-xgmac.o -obj-$(CONFIG_SOFTMMU) += amd-xgbe.o -endif diff --git a/qemu/hw/vfio/amd-xgbe.c b/qemu/hw/vfio/amd-xgbe.c deleted file mode 100644 index 2c60310cf..000000000 --- a/qemu/hw/vfio/amd-xgbe.c +++ /dev/null @@ -1,56 +0,0 @@ -/* - * AMD XGBE VFIO device - * - * Copyright Linaro Limited, 2015 - * - * Authors: - * Eric Auger <eric.auger@linaro.org> - * - * This work is licensed under the terms of the GNU GPL, version 2. See - * the COPYING file in the top-level directory. - * - */ - -#include "qemu/osdep.h" -#include "hw/vfio/vfio-amd-xgbe.h" - -static void amd_xgbe_realize(DeviceState *dev, Error **errp) -{ - VFIOPlatformDevice *vdev = VFIO_PLATFORM_DEVICE(dev); - VFIOAmdXgbeDeviceClass *k = VFIO_AMD_XGBE_DEVICE_GET_CLASS(dev); - - vdev->compat = g_strdup("amd,xgbe-seattle-v1a"); - - k->parent_realize(dev, errp); -} - -static const VMStateDescription vfio_platform_amd_xgbe_vmstate = { - .name = TYPE_VFIO_AMD_XGBE, - .unmigratable = 1, -}; - -static void vfio_amd_xgbe_class_init(ObjectClass *klass, void *data) -{ - DeviceClass *dc = DEVICE_CLASS(klass); - VFIOAmdXgbeDeviceClass *vcxc = - VFIO_AMD_XGBE_DEVICE_CLASS(klass); - vcxc->parent_realize = dc->realize; - dc->realize = amd_xgbe_realize; - dc->desc = "VFIO AMD XGBE"; - dc->vmsd = &vfio_platform_amd_xgbe_vmstate; -} - -static const TypeInfo vfio_amd_xgbe_dev_info = { - .name = TYPE_VFIO_AMD_XGBE, - .parent = TYPE_VFIO_PLATFORM, - .instance_size = sizeof(VFIOAmdXgbeDevice), - .class_init = vfio_amd_xgbe_class_init, - .class_size = sizeof(VFIOAmdXgbeDeviceClass), -}; - -static void register_amd_xgbe_dev_type(void) -{ - type_register_static(&vfio_amd_xgbe_dev_info); -} - -type_init(register_amd_xgbe_dev_type) diff --git a/qemu/hw/vfio/calxeda-xgmac.c b/qemu/hw/vfio/calxeda-xgmac.c deleted file mode 100644 index bb15d588e..000000000 --- a/qemu/hw/vfio/calxeda-xgmac.c +++ /dev/null @@ -1,56 +0,0 @@ -/* - * calxeda xgmac VFIO device - * - * Copyright Linaro Limited, 2014 - * - * Authors: - * Eric Auger <eric.auger@linaro.org> - * - * This work is licensed under the terms of the GNU GPL, version 2. See - * the COPYING file in the top-level directory. - * - */ - -#include "qemu/osdep.h" -#include "hw/vfio/vfio-calxeda-xgmac.h" - -static void calxeda_xgmac_realize(DeviceState *dev, Error **errp) -{ - VFIOPlatformDevice *vdev = VFIO_PLATFORM_DEVICE(dev); - VFIOCalxedaXgmacDeviceClass *k = VFIO_CALXEDA_XGMAC_DEVICE_GET_CLASS(dev); - - vdev->compat = g_strdup("calxeda,hb-xgmac"); - - k->parent_realize(dev, errp); -} - -static const VMStateDescription vfio_platform_calxeda_xgmac_vmstate = { - .name = TYPE_VFIO_CALXEDA_XGMAC, - .unmigratable = 1, -}; - -static void vfio_calxeda_xgmac_class_init(ObjectClass *klass, void *data) -{ - DeviceClass *dc = DEVICE_CLASS(klass); - VFIOCalxedaXgmacDeviceClass *vcxc = - VFIO_CALXEDA_XGMAC_DEVICE_CLASS(klass); - vcxc->parent_realize = dc->realize; - dc->realize = calxeda_xgmac_realize; - dc->desc = "VFIO Calxeda XGMAC"; - dc->vmsd = &vfio_platform_calxeda_xgmac_vmstate; -} - -static const TypeInfo vfio_calxeda_xgmac_dev_info = { - .name = TYPE_VFIO_CALXEDA_XGMAC, - .parent = TYPE_VFIO_PLATFORM, - .instance_size = sizeof(VFIOCalxedaXgmacDevice), - .class_init = vfio_calxeda_xgmac_class_init, - .class_size = sizeof(VFIOCalxedaXgmacDeviceClass), -}; - -static void register_calxeda_xgmac_dev_type(void) -{ - type_register_static(&vfio_calxeda_xgmac_dev_info); -} - -type_init(register_calxeda_xgmac_dev_type) diff --git a/qemu/hw/vfio/common.c b/qemu/hw/vfio/common.c deleted file mode 100644 index f27db36fb..000000000 --- a/qemu/hw/vfio/common.c +++ /dev/null @@ -1,1192 +0,0 @@ -/* - * generic functions used by VFIO devices - * - * Copyright Red Hat, Inc. 2012 - * - * Authors: - * Alex Williamson <alex.williamson@redhat.com> - * - * This work is licensed under the terms of the GNU GPL, version 2. See - * the COPYING file in the top-level directory. - * - * Based on qemu-kvm device-assignment: - * Adapted for KVM by Qumranet. - * Copyright (c) 2007, Neocleus, Alex Novik (alex@neocleus.com) - * Copyright (c) 2007, Neocleus, Guy Zana (guy@neocleus.com) - * Copyright (C) 2008, Qumranet, Amit Shah (amit.shah@qumranet.com) - * Copyright (C) 2008, Red Hat, Amit Shah (amit.shah@redhat.com) - * Copyright (C) 2008, IBM, Muli Ben-Yehuda (muli@il.ibm.com) - */ - -#include "qemu/osdep.h" -#include <sys/ioctl.h> -#include <sys/mman.h> -#include <linux/vfio.h> - -#include "hw/vfio/vfio-common.h" -#include "hw/vfio/vfio.h" -#include "exec/address-spaces.h" -#include "exec/memory.h" -#include "hw/hw.h" -#include "qemu/error-report.h" -#include "sysemu/kvm.h" -#include "trace.h" - -struct vfio_group_head vfio_group_list = - QLIST_HEAD_INITIALIZER(vfio_group_list); -struct vfio_as_head vfio_address_spaces = - QLIST_HEAD_INITIALIZER(vfio_address_spaces); - -#ifdef CONFIG_KVM -/* - * We have a single VFIO pseudo device per KVM VM. Once created it lives - * for the life of the VM. Closing the file descriptor only drops our - * reference to it and the device's reference to kvm. Therefore once - * initialized, this file descriptor is only released on QEMU exit and - * we'll re-use it should another vfio device be attached before then. - */ -static int vfio_kvm_device_fd = -1; -#endif - -/* - * Common VFIO interrupt disable - */ -void vfio_disable_irqindex(VFIODevice *vbasedev, int index) -{ - struct vfio_irq_set irq_set = { - .argsz = sizeof(irq_set), - .flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_TRIGGER, - .index = index, - .start = 0, - .count = 0, - }; - - ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set); -} - -void vfio_unmask_single_irqindex(VFIODevice *vbasedev, int index) -{ - struct vfio_irq_set irq_set = { - .argsz = sizeof(irq_set), - .flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_UNMASK, - .index = index, - .start = 0, - .count = 1, - }; - - ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set); -} - -void vfio_mask_single_irqindex(VFIODevice *vbasedev, int index) -{ - struct vfio_irq_set irq_set = { - .argsz = sizeof(irq_set), - .flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_MASK, - .index = index, - .start = 0, - .count = 1, - }; - - ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set); -} - -/* - * IO Port/MMIO - Beware of the endians, VFIO is always little endian - */ -void vfio_region_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ - VFIORegion *region = opaque; - VFIODevice *vbasedev = region->vbasedev; - union { - uint8_t byte; - uint16_t word; - uint32_t dword; - uint64_t qword; - } buf; - - switch (size) { - case 1: - buf.byte = data; - break; - case 2: - buf.word = cpu_to_le16(data); - break; - case 4: - buf.dword = cpu_to_le32(data); - break; - default: - hw_error("vfio: unsupported write size, %d bytes", size); - break; - } - - if (pwrite(vbasedev->fd, &buf, size, region->fd_offset + addr) != size) { - error_report("%s(%s:region%d+0x%"HWADDR_PRIx", 0x%"PRIx64 - ",%d) failed: %m", - __func__, vbasedev->name, region->nr, - addr, data, size); - } - - trace_vfio_region_write(vbasedev->name, region->nr, addr, data, size); - - /* - * A read or write to a BAR always signals an INTx EOI. This will - * do nothing if not pending (including not in INTx mode). We assume - * that a BAR access is in response to an interrupt and that BAR - * accesses will service the interrupt. Unfortunately, we don't know - * which access will service the interrupt, so we're potentially - * getting quite a few host interrupts per guest interrupt. - */ - vbasedev->ops->vfio_eoi(vbasedev); -} - -uint64_t vfio_region_read(void *opaque, - hwaddr addr, unsigned size) -{ - VFIORegion *region = opaque; - VFIODevice *vbasedev = region->vbasedev; - union { - uint8_t byte; - uint16_t word; - uint32_t dword; - uint64_t qword; - } buf; - uint64_t data = 0; - - if (pread(vbasedev->fd, &buf, size, region->fd_offset + addr) != size) { - error_report("%s(%s:region%d+0x%"HWADDR_PRIx", %d) failed: %m", - __func__, vbasedev->name, region->nr, - addr, size); - return (uint64_t)-1; - } - switch (size) { - case 1: - data = buf.byte; - break; - case 2: - data = le16_to_cpu(buf.word); - break; - case 4: - data = le32_to_cpu(buf.dword); - break; - default: - hw_error("vfio: unsupported read size, %d bytes", size); - break; - } - - trace_vfio_region_read(vbasedev->name, region->nr, addr, size, data); - - /* Same as write above */ - vbasedev->ops->vfio_eoi(vbasedev); - - return data; -} - -const MemoryRegionOps vfio_region_ops = { - .read = vfio_region_read, - .write = vfio_region_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -/* - * DMA - Mapping and unmapping for the "type1" IOMMU interface used on x86 - */ -static int vfio_dma_unmap(VFIOContainer *container, - hwaddr iova, ram_addr_t size) -{ - struct vfio_iommu_type1_dma_unmap unmap = { - .argsz = sizeof(unmap), - .flags = 0, - .iova = iova, - .size = size, - }; - - if (ioctl(container->fd, VFIO_IOMMU_UNMAP_DMA, &unmap)) { - error_report("VFIO_UNMAP_DMA: %d", -errno); - return -errno; - } - - return 0; -} - -static int vfio_dma_map(VFIOContainer *container, hwaddr iova, - ram_addr_t size, void *vaddr, bool readonly) -{ - struct vfio_iommu_type1_dma_map map = { - .argsz = sizeof(map), - .flags = VFIO_DMA_MAP_FLAG_READ, - .vaddr = (__u64)(uintptr_t)vaddr, - .iova = iova, - .size = size, - }; - - if (!readonly) { - map.flags |= VFIO_DMA_MAP_FLAG_WRITE; - } - - /* - * Try the mapping, if it fails with EBUSY, unmap the region and try - * again. This shouldn't be necessary, but we sometimes see it in - * the VGA ROM space. - */ - if (ioctl(container->fd, VFIO_IOMMU_MAP_DMA, &map) == 0 || - (errno == EBUSY && vfio_dma_unmap(container, iova, size) == 0 && - ioctl(container->fd, VFIO_IOMMU_MAP_DMA, &map) == 0)) { - return 0; - } - - error_report("VFIO_MAP_DMA: %d", -errno); - return -errno; -} - -static bool vfio_listener_skipped_section(MemoryRegionSection *section) -{ - return (!memory_region_is_ram(section->mr) && - !memory_region_is_iommu(section->mr)) || - /* - * Sizing an enabled 64-bit BAR can cause spurious mappings to - * addresses in the upper part of the 64-bit address space. These - * are never accessed by the CPU and beyond the address width of - * some IOMMU hardware. TODO: VFIO should tell us the IOMMU width. - */ - section->offset_within_address_space & (1ULL << 63); -} - -static void vfio_iommu_map_notify(Notifier *n, void *data) -{ - VFIOGuestIOMMU *giommu = container_of(n, VFIOGuestIOMMU, n); - VFIOContainer *container = giommu->container; - IOMMUTLBEntry *iotlb = data; - MemoryRegion *mr; - hwaddr xlat; - hwaddr len = iotlb->addr_mask + 1; - void *vaddr; - int ret; - - trace_vfio_iommu_map_notify(iotlb->iova, - iotlb->iova + iotlb->addr_mask); - - /* - * The IOMMU TLB entry we have just covers translation through - * this IOMMU to its immediate target. We need to translate - * it the rest of the way through to memory. - */ - rcu_read_lock(); - mr = address_space_translate(&address_space_memory, - iotlb->translated_addr, - &xlat, &len, iotlb->perm & IOMMU_WO); - if (!memory_region_is_ram(mr)) { - error_report("iommu map to non memory area %"HWADDR_PRIx"", - xlat); - goto out; - } - /* - * Translation truncates length to the IOMMU page size, - * check that it did not truncate too much. - */ - if (len & iotlb->addr_mask) { - error_report("iommu has granularity incompatible with target AS"); - goto out; - } - - if ((iotlb->perm & IOMMU_RW) != IOMMU_NONE) { - vaddr = memory_region_get_ram_ptr(mr) + xlat; - ret = vfio_dma_map(container, iotlb->iova, - iotlb->addr_mask + 1, vaddr, - !(iotlb->perm & IOMMU_WO) || mr->readonly); - if (ret) { - error_report("vfio_dma_map(%p, 0x%"HWADDR_PRIx", " - "0x%"HWADDR_PRIx", %p) = %d (%m)", - container, iotlb->iova, - iotlb->addr_mask + 1, vaddr, ret); - } - } else { - ret = vfio_dma_unmap(container, iotlb->iova, iotlb->addr_mask + 1); - if (ret) { - error_report("vfio_dma_unmap(%p, 0x%"HWADDR_PRIx", " - "0x%"HWADDR_PRIx") = %d (%m)", - container, iotlb->iova, - iotlb->addr_mask + 1, ret); - } - } -out: - rcu_read_unlock(); -} - -static hwaddr vfio_container_granularity(VFIOContainer *container) -{ - return (hwaddr)1 << ctz64(container->iova_pgsizes); -} - -static void vfio_listener_region_add(MemoryListener *listener, - MemoryRegionSection *section) -{ - VFIOContainer *container = container_of(listener, VFIOContainer, listener); - hwaddr iova, end; - Int128 llend, llsize; - void *vaddr; - int ret; - - if (vfio_listener_skipped_section(section)) { - trace_vfio_listener_region_add_skip( - section->offset_within_address_space, - section->offset_within_address_space + - int128_get64(int128_sub(section->size, int128_one()))); - return; - } - - if (unlikely((section->offset_within_address_space & ~TARGET_PAGE_MASK) != - (section->offset_within_region & ~TARGET_PAGE_MASK))) { - error_report("%s received unaligned region", __func__); - return; - } - - iova = TARGET_PAGE_ALIGN(section->offset_within_address_space); - llend = int128_make64(section->offset_within_address_space); - llend = int128_add(llend, section->size); - llend = int128_and(llend, int128_exts64(TARGET_PAGE_MASK)); - - if (int128_ge(int128_make64(iova), llend)) { - return; - } - end = int128_get64(int128_sub(llend, int128_one())); - - if ((iova < container->min_iova) || (end > container->max_iova)) { - error_report("vfio: IOMMU container %p can't map guest IOVA region" - " 0x%"HWADDR_PRIx"..0x%"HWADDR_PRIx, - container, iova, end); - ret = -EFAULT; - goto fail; - } - - memory_region_ref(section->mr); - - if (memory_region_is_iommu(section->mr)) { - VFIOGuestIOMMU *giommu; - - trace_vfio_listener_region_add_iommu(iova, end); - /* - * FIXME: We should do some checking to see if the - * capabilities of the host VFIO IOMMU are adequate to model - * the guest IOMMU - * - * FIXME: For VFIO iommu types which have KVM acceleration to - * avoid bouncing all map/unmaps through qemu this way, this - * would be the right place to wire that up (tell the KVM - * device emulation the VFIO iommu handles to use). - */ - giommu = g_malloc0(sizeof(*giommu)); - giommu->iommu = section->mr; - giommu->container = container; - giommu->n.notify = vfio_iommu_map_notify; - QLIST_INSERT_HEAD(&container->giommu_list, giommu, giommu_next); - - memory_region_register_iommu_notifier(giommu->iommu, &giommu->n); - memory_region_iommu_replay(giommu->iommu, &giommu->n, - vfio_container_granularity(container), - false); - - return; - } - - /* Here we assume that memory_region_is_ram(section->mr)==true */ - - vaddr = memory_region_get_ram_ptr(section->mr) + - section->offset_within_region + - (iova - section->offset_within_address_space); - - trace_vfio_listener_region_add_ram(iova, end, vaddr); - - llsize = int128_sub(llend, int128_make64(iova)); - - ret = vfio_dma_map(container, iova, int128_get64(llsize), - vaddr, section->readonly); - if (ret) { - error_report("vfio_dma_map(%p, 0x%"HWADDR_PRIx", " - "0x%"HWADDR_PRIx", %p) = %d (%m)", - container, iova, int128_get64(llsize), vaddr, ret); - goto fail; - } - - return; - -fail: - /* - * On the initfn path, store the first error in the container so we - * can gracefully fail. Runtime, there's not much we can do other - * than throw a hardware error. - */ - if (!container->initialized) { - if (!container->error) { - container->error = ret; - } - } else { - hw_error("vfio: DMA mapping failed, unable to continue"); - } -} - -static void vfio_listener_region_del(MemoryListener *listener, - MemoryRegionSection *section) -{ - VFIOContainer *container = container_of(listener, VFIOContainer, listener); - hwaddr iova, end; - int ret; - - if (vfio_listener_skipped_section(section)) { - trace_vfio_listener_region_del_skip( - section->offset_within_address_space, - section->offset_within_address_space + - int128_get64(int128_sub(section->size, int128_one()))); - return; - } - - if (unlikely((section->offset_within_address_space & ~TARGET_PAGE_MASK) != - (section->offset_within_region & ~TARGET_PAGE_MASK))) { - error_report("%s received unaligned region", __func__); - return; - } - - if (memory_region_is_iommu(section->mr)) { - VFIOGuestIOMMU *giommu; - - QLIST_FOREACH(giommu, &container->giommu_list, giommu_next) { - if (giommu->iommu == section->mr) { - memory_region_unregister_iommu_notifier(&giommu->n); - QLIST_REMOVE(giommu, giommu_next); - g_free(giommu); - break; - } - } - - /* - * FIXME: We assume the one big unmap below is adequate to - * remove any individual page mappings in the IOMMU which - * might have been copied into VFIO. This works for a page table - * based IOMMU where a big unmap flattens a large range of IO-PTEs. - * That may not be true for all IOMMU types. - */ - } - - iova = TARGET_PAGE_ALIGN(section->offset_within_address_space); - end = (section->offset_within_address_space + int128_get64(section->size)) & - TARGET_PAGE_MASK; - - if (iova >= end) { - return; - } - - trace_vfio_listener_region_del(iova, end - 1); - - ret = vfio_dma_unmap(container, iova, end - iova); - memory_region_unref(section->mr); - if (ret) { - error_report("vfio_dma_unmap(%p, 0x%"HWADDR_PRIx", " - "0x%"HWADDR_PRIx") = %d (%m)", - container, iova, end - iova, ret); - } -} - -static const MemoryListener vfio_memory_listener = { - .region_add = vfio_listener_region_add, - .region_del = vfio_listener_region_del, -}; - -static void vfio_listener_release(VFIOContainer *container) -{ - memory_listener_unregister(&container->listener); -} - -int vfio_region_setup(Object *obj, VFIODevice *vbasedev, VFIORegion *region, - int index, const char *name) -{ - struct vfio_region_info *info; - int ret; - - ret = vfio_get_region_info(vbasedev, index, &info); - if (ret) { - return ret; - } - - region->vbasedev = vbasedev; - region->flags = info->flags; - region->size = info->size; - region->fd_offset = info->offset; - region->nr = index; - - if (region->size) { - region->mem = g_new0(MemoryRegion, 1); - memory_region_init_io(region->mem, obj, &vfio_region_ops, - region, name, region->size); - - if (!vbasedev->no_mmap && - region->flags & VFIO_REGION_INFO_FLAG_MMAP && - !(region->size & ~qemu_real_host_page_mask)) { - - region->nr_mmaps = 1; - region->mmaps = g_new0(VFIOMmap, region->nr_mmaps); - - region->mmaps[0].offset = 0; - region->mmaps[0].size = region->size; - } - } - - g_free(info); - - trace_vfio_region_setup(vbasedev->name, index, name, - region->flags, region->fd_offset, region->size); - return 0; -} - -int vfio_region_mmap(VFIORegion *region) -{ - int i, prot = 0; - char *name; - - if (!region->mem) { - return 0; - } - - prot |= region->flags & VFIO_REGION_INFO_FLAG_READ ? PROT_READ : 0; - prot |= region->flags & VFIO_REGION_INFO_FLAG_WRITE ? PROT_WRITE : 0; - - for (i = 0; i < region->nr_mmaps; i++) { - region->mmaps[i].mmap = mmap(NULL, region->mmaps[i].size, prot, - MAP_SHARED, region->vbasedev->fd, - region->fd_offset + - region->mmaps[i].offset); - if (region->mmaps[i].mmap == MAP_FAILED) { - int ret = -errno; - - trace_vfio_region_mmap_fault(memory_region_name(region->mem), i, - region->fd_offset + - region->mmaps[i].offset, - region->fd_offset + - region->mmaps[i].offset + - region->mmaps[i].size - 1, ret); - - region->mmaps[i].mmap = NULL; - - for (i--; i >= 0; i--) { - memory_region_del_subregion(region->mem, ®ion->mmaps[i].mem); - munmap(region->mmaps[i].mmap, region->mmaps[i].size); - object_unparent(OBJECT(®ion->mmaps[i].mem)); - region->mmaps[i].mmap = NULL; - } - - return ret; - } - - name = g_strdup_printf("%s mmaps[%d]", - memory_region_name(region->mem), i); - memory_region_init_ram_ptr(®ion->mmaps[i].mem, - memory_region_owner(region->mem), - name, region->mmaps[i].size, - region->mmaps[i].mmap); - g_free(name); - memory_region_set_skip_dump(®ion->mmaps[i].mem); - memory_region_add_subregion(region->mem, region->mmaps[i].offset, - ®ion->mmaps[i].mem); - - trace_vfio_region_mmap(memory_region_name(®ion->mmaps[i].mem), - region->mmaps[i].offset, - region->mmaps[i].offset + - region->mmaps[i].size - 1); - } - - return 0; -} - -void vfio_region_exit(VFIORegion *region) -{ - int i; - - if (!region->mem) { - return; - } - - for (i = 0; i < region->nr_mmaps; i++) { - if (region->mmaps[i].mmap) { - memory_region_del_subregion(region->mem, ®ion->mmaps[i].mem); - } - } - - trace_vfio_region_exit(region->vbasedev->name, region->nr); -} - -void vfio_region_finalize(VFIORegion *region) -{ - int i; - - if (!region->mem) { - return; - } - - for (i = 0; i < region->nr_mmaps; i++) { - if (region->mmaps[i].mmap) { - munmap(region->mmaps[i].mmap, region->mmaps[i].size); - object_unparent(OBJECT(®ion->mmaps[i].mem)); - } - } - - object_unparent(OBJECT(region->mem)); - - g_free(region->mem); - g_free(region->mmaps); - - trace_vfio_region_finalize(region->vbasedev->name, region->nr); -} - -void vfio_region_mmaps_set_enabled(VFIORegion *region, bool enabled) -{ - int i; - - if (!region->mem) { - return; - } - - for (i = 0; i < region->nr_mmaps; i++) { - if (region->mmaps[i].mmap) { - memory_region_set_enabled(®ion->mmaps[i].mem, enabled); - } - } - - trace_vfio_region_mmaps_set_enabled(memory_region_name(region->mem), - enabled); -} - -void vfio_reset_handler(void *opaque) -{ - VFIOGroup *group; - VFIODevice *vbasedev; - - QLIST_FOREACH(group, &vfio_group_list, next) { - QLIST_FOREACH(vbasedev, &group->device_list, next) { - vbasedev->ops->vfio_compute_needs_reset(vbasedev); - } - } - - QLIST_FOREACH(group, &vfio_group_list, next) { - QLIST_FOREACH(vbasedev, &group->device_list, next) { - if (vbasedev->needs_reset) { - vbasedev->ops->vfio_hot_reset_multi(vbasedev); - } - } - } -} - -static void vfio_kvm_device_add_group(VFIOGroup *group) -{ -#ifdef CONFIG_KVM - struct kvm_device_attr attr = { - .group = KVM_DEV_VFIO_GROUP, - .attr = KVM_DEV_VFIO_GROUP_ADD, - .addr = (uint64_t)(unsigned long)&group->fd, - }; - - if (!kvm_enabled()) { - return; - } - - if (vfio_kvm_device_fd < 0) { - struct kvm_create_device cd = { - .type = KVM_DEV_TYPE_VFIO, - }; - - if (kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &cd)) { - error_report("Failed to create KVM VFIO device: %m"); - return; - } - - vfio_kvm_device_fd = cd.fd; - } - - if (ioctl(vfio_kvm_device_fd, KVM_SET_DEVICE_ATTR, &attr)) { - error_report("Failed to add group %d to KVM VFIO device: %m", - group->groupid); - } -#endif -} - -static void vfio_kvm_device_del_group(VFIOGroup *group) -{ -#ifdef CONFIG_KVM - struct kvm_device_attr attr = { - .group = KVM_DEV_VFIO_GROUP, - .attr = KVM_DEV_VFIO_GROUP_DEL, - .addr = (uint64_t)(unsigned long)&group->fd, - }; - - if (vfio_kvm_device_fd < 0) { - return; - } - - if (ioctl(vfio_kvm_device_fd, KVM_SET_DEVICE_ATTR, &attr)) { - error_report("Failed to remove group %d from KVM VFIO device: %m", - group->groupid); - } -#endif -} - -static VFIOAddressSpace *vfio_get_address_space(AddressSpace *as) -{ - VFIOAddressSpace *space; - - QLIST_FOREACH(space, &vfio_address_spaces, list) { - if (space->as == as) { - return space; - } - } - - /* No suitable VFIOAddressSpace, create a new one */ - space = g_malloc0(sizeof(*space)); - space->as = as; - QLIST_INIT(&space->containers); - - QLIST_INSERT_HEAD(&vfio_address_spaces, space, list); - - return space; -} - -static void vfio_put_address_space(VFIOAddressSpace *space) -{ - if (QLIST_EMPTY(&space->containers)) { - QLIST_REMOVE(space, list); - g_free(space); - } -} - -static int vfio_connect_container(VFIOGroup *group, AddressSpace *as) -{ - VFIOContainer *container; - int ret, fd; - VFIOAddressSpace *space; - - space = vfio_get_address_space(as); - - QLIST_FOREACH(container, &space->containers, next) { - if (!ioctl(group->fd, VFIO_GROUP_SET_CONTAINER, &container->fd)) { - group->container = container; - QLIST_INSERT_HEAD(&container->group_list, group, container_next); - return 0; - } - } - - fd = qemu_open("/dev/vfio/vfio", O_RDWR); - if (fd < 0) { - error_report("vfio: failed to open /dev/vfio/vfio: %m"); - ret = -errno; - goto put_space_exit; - } - - ret = ioctl(fd, VFIO_GET_API_VERSION); - if (ret != VFIO_API_VERSION) { - error_report("vfio: supported vfio version: %d, " - "reported version: %d", VFIO_API_VERSION, ret); - ret = -EINVAL; - goto close_fd_exit; - } - - container = g_malloc0(sizeof(*container)); - container->space = space; - container->fd = fd; - if (ioctl(fd, VFIO_CHECK_EXTENSION, VFIO_TYPE1_IOMMU) || - ioctl(fd, VFIO_CHECK_EXTENSION, VFIO_TYPE1v2_IOMMU)) { - bool v2 = !!ioctl(fd, VFIO_CHECK_EXTENSION, VFIO_TYPE1v2_IOMMU); - struct vfio_iommu_type1_info info; - - ret = ioctl(group->fd, VFIO_GROUP_SET_CONTAINER, &fd); - if (ret) { - error_report("vfio: failed to set group container: %m"); - ret = -errno; - goto free_container_exit; - } - - ret = ioctl(fd, VFIO_SET_IOMMU, - v2 ? VFIO_TYPE1v2_IOMMU : VFIO_TYPE1_IOMMU); - if (ret) { - error_report("vfio: failed to set iommu for container: %m"); - ret = -errno; - goto free_container_exit; - } - - /* - * FIXME: This assumes that a Type1 IOMMU can map any 64-bit - * IOVA whatsoever. That's not actually true, but the current - * kernel interface doesn't tell us what it can map, and the - * existing Type1 IOMMUs generally support any IOVA we're - * going to actually try in practice. - */ - container->min_iova = 0; - container->max_iova = (hwaddr)-1; - - /* Assume just 4K IOVA page size */ - container->iova_pgsizes = 0x1000; - info.argsz = sizeof(info); - ret = ioctl(fd, VFIO_IOMMU_GET_INFO, &info); - /* Ignore errors */ - if ((ret == 0) && (info.flags & VFIO_IOMMU_INFO_PGSIZES)) { - container->iova_pgsizes = info.iova_pgsizes; - } - } else if (ioctl(fd, VFIO_CHECK_EXTENSION, VFIO_SPAPR_TCE_IOMMU)) { - struct vfio_iommu_spapr_tce_info info; - - ret = ioctl(group->fd, VFIO_GROUP_SET_CONTAINER, &fd); - if (ret) { - error_report("vfio: failed to set group container: %m"); - ret = -errno; - goto free_container_exit; - } - ret = ioctl(fd, VFIO_SET_IOMMU, VFIO_SPAPR_TCE_IOMMU); - if (ret) { - error_report("vfio: failed to set iommu for container: %m"); - ret = -errno; - goto free_container_exit; - } - - /* - * The host kernel code implementing VFIO_IOMMU_DISABLE is called - * when container fd is closed so we do not call it explicitly - * in this file. - */ - ret = ioctl(fd, VFIO_IOMMU_ENABLE); - if (ret) { - error_report("vfio: failed to enable container: %m"); - ret = -errno; - goto free_container_exit; - } - - /* - * This only considers the host IOMMU's 32-bit window. At - * some point we need to add support for the optional 64-bit - * window and dynamic windows - */ - info.argsz = sizeof(info); - ret = ioctl(fd, VFIO_IOMMU_SPAPR_TCE_GET_INFO, &info); - if (ret) { - error_report("vfio: VFIO_IOMMU_SPAPR_TCE_GET_INFO failed: %m"); - ret = -errno; - goto free_container_exit; - } - container->min_iova = info.dma32_window_start; - container->max_iova = container->min_iova + info.dma32_window_size - 1; - - /* Assume just 4K IOVA pages for now */ - container->iova_pgsizes = 0x1000; - } else { - error_report("vfio: No available IOMMU models"); - ret = -EINVAL; - goto free_container_exit; - } - - container->listener = vfio_memory_listener; - - memory_listener_register(&container->listener, container->space->as); - - if (container->error) { - ret = container->error; - error_report("vfio: memory listener initialization failed for container"); - goto listener_release_exit; - } - - container->initialized = true; - - QLIST_INIT(&container->group_list); - QLIST_INSERT_HEAD(&space->containers, container, next); - - group->container = container; - QLIST_INSERT_HEAD(&container->group_list, group, container_next); - - return 0; -listener_release_exit: - vfio_listener_release(container); - -free_container_exit: - g_free(container); - -close_fd_exit: - close(fd); - -put_space_exit: - vfio_put_address_space(space); - - return ret; -} - -static void vfio_disconnect_container(VFIOGroup *group) -{ - VFIOContainer *container = group->container; - - if (ioctl(group->fd, VFIO_GROUP_UNSET_CONTAINER, &container->fd)) { - error_report("vfio: error disconnecting group %d from container", - group->groupid); - } - - QLIST_REMOVE(group, container_next); - group->container = NULL; - - if (QLIST_EMPTY(&container->group_list)) { - VFIOAddressSpace *space = container->space; - VFIOGuestIOMMU *giommu, *tmp; - - vfio_listener_release(container); - QLIST_REMOVE(container, next); - - QLIST_FOREACH_SAFE(giommu, &container->giommu_list, giommu_next, tmp) { - memory_region_unregister_iommu_notifier(&giommu->n); - QLIST_REMOVE(giommu, giommu_next); - g_free(giommu); - } - - trace_vfio_disconnect_container(container->fd); - close(container->fd); - g_free(container); - - vfio_put_address_space(space); - } -} - -VFIOGroup *vfio_get_group(int groupid, AddressSpace *as) -{ - VFIOGroup *group; - char path[32]; - struct vfio_group_status status = { .argsz = sizeof(status) }; - - QLIST_FOREACH(group, &vfio_group_list, next) { - if (group->groupid == groupid) { - /* Found it. Now is it already in the right context? */ - if (group->container->space->as == as) { - return group; - } else { - error_report("vfio: group %d used in multiple address spaces", - group->groupid); - return NULL; - } - } - } - - group = g_malloc0(sizeof(*group)); - - snprintf(path, sizeof(path), "/dev/vfio/%d", groupid); - group->fd = qemu_open(path, O_RDWR); - if (group->fd < 0) { - error_report("vfio: error opening %s: %m", path); - goto free_group_exit; - } - - if (ioctl(group->fd, VFIO_GROUP_GET_STATUS, &status)) { - error_report("vfio: error getting group status: %m"); - goto close_fd_exit; - } - - if (!(status.flags & VFIO_GROUP_FLAGS_VIABLE)) { - error_report("vfio: error, group %d is not viable, please ensure " - "all devices within the iommu_group are bound to their " - "vfio bus driver.", groupid); - goto close_fd_exit; - } - - group->groupid = groupid; - QLIST_INIT(&group->device_list); - - if (vfio_connect_container(group, as)) { - error_report("vfio: failed to setup container for group %d", groupid); - goto close_fd_exit; - } - - if (QLIST_EMPTY(&vfio_group_list)) { - qemu_register_reset(vfio_reset_handler, NULL); - } - - QLIST_INSERT_HEAD(&vfio_group_list, group, next); - - vfio_kvm_device_add_group(group); - - return group; - -close_fd_exit: - close(group->fd); - -free_group_exit: - g_free(group); - - return NULL; -} - -void vfio_put_group(VFIOGroup *group) -{ - if (!group || !QLIST_EMPTY(&group->device_list)) { - return; - } - - vfio_kvm_device_del_group(group); - vfio_disconnect_container(group); - QLIST_REMOVE(group, next); - trace_vfio_put_group(group->fd); - close(group->fd); - g_free(group); - - if (QLIST_EMPTY(&vfio_group_list)) { - qemu_unregister_reset(vfio_reset_handler, NULL); - } -} - -int vfio_get_device(VFIOGroup *group, const char *name, - VFIODevice *vbasedev) -{ - struct vfio_device_info dev_info = { .argsz = sizeof(dev_info) }; - int ret, fd; - - fd = ioctl(group->fd, VFIO_GROUP_GET_DEVICE_FD, name); - if (fd < 0) { - error_report("vfio: error getting device %s from group %d: %m", - name, group->groupid); - error_printf("Verify all devices in group %d are bound to vfio-<bus> " - "or pci-stub and not already in use\n", group->groupid); - return fd; - } - - ret = ioctl(fd, VFIO_DEVICE_GET_INFO, &dev_info); - if (ret) { - error_report("vfio: error getting device info: %m"); - close(fd); - return ret; - } - - vbasedev->fd = fd; - vbasedev->group = group; - QLIST_INSERT_HEAD(&group->device_list, vbasedev, next); - - vbasedev->num_irqs = dev_info.num_irqs; - vbasedev->num_regions = dev_info.num_regions; - vbasedev->flags = dev_info.flags; - - trace_vfio_get_device(name, dev_info.flags, dev_info.num_regions, - dev_info.num_irqs); - - vbasedev->reset_works = !!(dev_info.flags & VFIO_DEVICE_FLAGS_RESET); - return 0; -} - -void vfio_put_base_device(VFIODevice *vbasedev) -{ - if (!vbasedev->group) { - return; - } - QLIST_REMOVE(vbasedev, next); - vbasedev->group = NULL; - trace_vfio_put_base_device(vbasedev->fd); - close(vbasedev->fd); -} - -int vfio_get_region_info(VFIODevice *vbasedev, int index, - struct vfio_region_info **info) -{ - size_t argsz = sizeof(struct vfio_region_info); - - *info = g_malloc0(argsz); - - (*info)->index = index; - (*info)->argsz = argsz; - - if (ioctl(vbasedev->fd, VFIO_DEVICE_GET_REGION_INFO, *info)) { - g_free(*info); - return -errno; - } - - return 0; -} - -/* - * Interfaces for IBM EEH (Enhanced Error Handling) - */ -static bool vfio_eeh_container_ok(VFIOContainer *container) -{ - /* - * As of 2016-03-04 (linux-4.5) the host kernel EEH/VFIO - * implementation is broken if there are multiple groups in a - * container. The hardware works in units of Partitionable - * Endpoints (== IOMMU groups) and the EEH operations naively - * iterate across all groups in the container, without any logic - * to make sure the groups have their state synchronized. For - * certain operations (ENABLE) that might be ok, until an error - * occurs, but for others (GET_STATE) it's clearly broken. - */ - - /* - * XXX Once fixed kernels exist, test for them here - */ - - if (QLIST_EMPTY(&container->group_list)) { - return false; - } - - if (QLIST_NEXT(QLIST_FIRST(&container->group_list), container_next)) { - return false; - } - - return true; -} - -static int vfio_eeh_container_op(VFIOContainer *container, uint32_t op) -{ - struct vfio_eeh_pe_op pe_op = { - .argsz = sizeof(pe_op), - .op = op, - }; - int ret; - - if (!vfio_eeh_container_ok(container)) { - error_report("vfio/eeh: EEH_PE_OP 0x%x: " - "kernel requires a container with exactly one group", op); - return -EPERM; - } - - ret = ioctl(container->fd, VFIO_EEH_PE_OP, &pe_op); - if (ret < 0) { - error_report("vfio/eeh: EEH_PE_OP 0x%x failed: %m", op); - return -errno; - } - - return 0; -} - -static VFIOContainer *vfio_eeh_as_container(AddressSpace *as) -{ - VFIOAddressSpace *space = vfio_get_address_space(as); - VFIOContainer *container = NULL; - - if (QLIST_EMPTY(&space->containers)) { - /* No containers to act on */ - goto out; - } - - container = QLIST_FIRST(&space->containers); - - if (QLIST_NEXT(container, next)) { - /* We don't yet have logic to synchronize EEH state across - * multiple containers */ - container = NULL; - goto out; - } - -out: - vfio_put_address_space(space); - return container; -} - -bool vfio_eeh_as_ok(AddressSpace *as) -{ - VFIOContainer *container = vfio_eeh_as_container(as); - - return (container != NULL) && vfio_eeh_container_ok(container); -} - -int vfio_eeh_as_op(AddressSpace *as, uint32_t op) -{ - VFIOContainer *container = vfio_eeh_as_container(as); - - if (!container) { - return -ENODEV; - } - return vfio_eeh_container_op(container, op); -} diff --git a/qemu/hw/vfio/pci-quirks.c b/qemu/hw/vfio/pci-quirks.c deleted file mode 100644 index 49ecf1172..000000000 --- a/qemu/hw/vfio/pci-quirks.c +++ /dev/null @@ -1,1205 +0,0 @@ -/* - * device quirks for PCI devices - * - * Copyright Red Hat, Inc. 2012-2015 - * - * Authors: - * Alex Williamson <alex.williamson@redhat.com> - * - * This work is licensed under the terms of the GNU GPL, version 2. See - * the COPYING file in the top-level directory. - */ - -#include "qemu/osdep.h" -#include "pci.h" -#include "trace.h" -#include "qemu/range.h" - -/* Use uin32_t for vendor & device so PCI_ANY_ID expands and cannot match hw */ -static bool vfio_pci_is(VFIOPCIDevice *vdev, uint32_t vendor, uint32_t device) -{ - return (vendor == PCI_ANY_ID || vendor == vdev->vendor_id) && - (device == PCI_ANY_ID || device == vdev->device_id); -} - -static bool vfio_is_vga(VFIOPCIDevice *vdev) -{ - PCIDevice *pdev = &vdev->pdev; - uint16_t class = pci_get_word(pdev->config + PCI_CLASS_DEVICE); - - return class == PCI_CLASS_DISPLAY_VGA; -} - -/* - * List of device ids/vendor ids for which to disable - * option rom loading. This avoids the guest hangs during rom - * execution as noticed with the BCM 57810 card for lack of a - * more better way to handle such issues. - * The user can still override by specifying a romfile or - * rombar=1. - * Please see https://bugs.launchpad.net/qemu/+bug/1284874 - * for an analysis of the 57810 card hang. When adding - * a new vendor id/device id combination below, please also add - * your card/environment details and information that could - * help in debugging to the bug tracking this issue - */ -static const struct { - uint32_t vendor; - uint32_t device; -} romblacklist[] = { - { 0x14e4, 0x168e }, /* Broadcom BCM 57810 */ -}; - -bool vfio_blacklist_opt_rom(VFIOPCIDevice *vdev) -{ - int i; - - for (i = 0 ; i < ARRAY_SIZE(romblacklist); i++) { - if (vfio_pci_is(vdev, romblacklist[i].vendor, romblacklist[i].device)) { - trace_vfio_quirk_rom_blacklisted(vdev->vbasedev.name, - romblacklist[i].vendor, - romblacklist[i].device); - return true; - } - } - return false; -} - -/* - * Device specific region quirks (mostly backdoors to PCI config space) - */ - -/* - * The generic window quirks operate on an address and data register, - * vfio_generic_window_address_quirk handles the address register and - * vfio_generic_window_data_quirk handles the data register. These ops - * pass reads and writes through to hardware until a value matching the - * stored address match/mask is written. When this occurs, the data - * register access emulated PCI config space for the device rather than - * passing through accesses. This enables devices where PCI config space - * is accessible behind a window register to maintain the virtualization - * provided through vfio. - */ -typedef struct VFIOConfigWindowMatch { - uint32_t match; - uint32_t mask; -} VFIOConfigWindowMatch; - -typedef struct VFIOConfigWindowQuirk { - struct VFIOPCIDevice *vdev; - - uint32_t address_val; - - uint32_t address_offset; - uint32_t data_offset; - - bool window_enabled; - uint8_t bar; - - MemoryRegion *addr_mem; - MemoryRegion *data_mem; - - uint32_t nr_matches; - VFIOConfigWindowMatch matches[]; -} VFIOConfigWindowQuirk; - -static uint64_t vfio_generic_window_quirk_address_read(void *opaque, - hwaddr addr, - unsigned size) -{ - VFIOConfigWindowQuirk *window = opaque; - VFIOPCIDevice *vdev = window->vdev; - - return vfio_region_read(&vdev->bars[window->bar].region, - addr + window->address_offset, size); -} - -static void vfio_generic_window_quirk_address_write(void *opaque, hwaddr addr, - uint64_t data, - unsigned size) -{ - VFIOConfigWindowQuirk *window = opaque; - VFIOPCIDevice *vdev = window->vdev; - int i; - - window->window_enabled = false; - - vfio_region_write(&vdev->bars[window->bar].region, - addr + window->address_offset, data, size); - - for (i = 0; i < window->nr_matches; i++) { - if ((data & ~window->matches[i].mask) == window->matches[i].match) { - window->window_enabled = true; - window->address_val = data & window->matches[i].mask; - trace_vfio_quirk_generic_window_address_write(vdev->vbasedev.name, - memory_region_name(window->addr_mem), data); - break; - } - } -} - -static const MemoryRegionOps vfio_generic_window_address_quirk = { - .read = vfio_generic_window_quirk_address_read, - .write = vfio_generic_window_quirk_address_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -static uint64_t vfio_generic_window_quirk_data_read(void *opaque, - hwaddr addr, unsigned size) -{ - VFIOConfigWindowQuirk *window = opaque; - VFIOPCIDevice *vdev = window->vdev; - uint64_t data; - - /* Always read data reg, discard if window enabled */ - data = vfio_region_read(&vdev->bars[window->bar].region, - addr + window->data_offset, size); - - if (window->window_enabled) { - data = vfio_pci_read_config(&vdev->pdev, window->address_val, size); - trace_vfio_quirk_generic_window_data_read(vdev->vbasedev.name, - memory_region_name(window->data_mem), data); - } - - return data; -} - -static void vfio_generic_window_quirk_data_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ - VFIOConfigWindowQuirk *window = opaque; - VFIOPCIDevice *vdev = window->vdev; - - if (window->window_enabled) { - vfio_pci_write_config(&vdev->pdev, window->address_val, data, size); - trace_vfio_quirk_generic_window_data_write(vdev->vbasedev.name, - memory_region_name(window->data_mem), data); - return; - } - - vfio_region_write(&vdev->bars[window->bar].region, - addr + window->data_offset, data, size); -} - -static const MemoryRegionOps vfio_generic_window_data_quirk = { - .read = vfio_generic_window_quirk_data_read, - .write = vfio_generic_window_quirk_data_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -/* - * The generic mirror quirk handles devices which expose PCI config space - * through a region within a BAR. When enabled, reads and writes are - * redirected through to emulated PCI config space. XXX if PCI config space - * used memory regions, this could just be an alias. - */ -typedef struct VFIOConfigMirrorQuirk { - struct VFIOPCIDevice *vdev; - uint32_t offset; - uint8_t bar; - MemoryRegion *mem; -} VFIOConfigMirrorQuirk; - -static uint64_t vfio_generic_quirk_mirror_read(void *opaque, - hwaddr addr, unsigned size) -{ - VFIOConfigMirrorQuirk *mirror = opaque; - VFIOPCIDevice *vdev = mirror->vdev; - uint64_t data; - - /* Read and discard in case the hardware cares */ - (void)vfio_region_read(&vdev->bars[mirror->bar].region, - addr + mirror->offset, size); - - data = vfio_pci_read_config(&vdev->pdev, addr, size); - trace_vfio_quirk_generic_mirror_read(vdev->vbasedev.name, - memory_region_name(mirror->mem), - addr, data); - return data; -} - -static void vfio_generic_quirk_mirror_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ - VFIOConfigMirrorQuirk *mirror = opaque; - VFIOPCIDevice *vdev = mirror->vdev; - - vfio_pci_write_config(&vdev->pdev, addr, data, size); - trace_vfio_quirk_generic_mirror_write(vdev->vbasedev.name, - memory_region_name(mirror->mem), - addr, data); -} - -static const MemoryRegionOps vfio_generic_mirror_quirk = { - .read = vfio_generic_quirk_mirror_read, - .write = vfio_generic_quirk_mirror_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -/* Is range1 fully contained within range2? */ -static bool vfio_range_contained(uint64_t first1, uint64_t len1, - uint64_t first2, uint64_t len2) { - return (first1 >= first2 && first1 + len1 <= first2 + len2); -} - -#define PCI_VENDOR_ID_ATI 0x1002 - -/* - * Radeon HD cards (HD5450 & HD7850) report the upper byte of the I/O port BAR - * through VGA register 0x3c3. On newer cards, the I/O port BAR is always - * BAR4 (older cards like the X550 used BAR1, but we don't care to support - * those). Note that on bare metal, a read of 0x3c3 doesn't always return the - * I/O port BAR address. Originally this was coded to return the virtual BAR - * address only if the physical register read returns the actual BAR address, - * but users have reported greater success if we return the virtual address - * unconditionally. - */ -static uint64_t vfio_ati_3c3_quirk_read(void *opaque, - hwaddr addr, unsigned size) -{ - VFIOPCIDevice *vdev = opaque; - uint64_t data = vfio_pci_read_config(&vdev->pdev, - PCI_BASE_ADDRESS_4 + 1, size); - - trace_vfio_quirk_ati_3c3_read(vdev->vbasedev.name, data); - - return data; -} - -static const MemoryRegionOps vfio_ati_3c3_quirk = { - .read = vfio_ati_3c3_quirk_read, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -static void vfio_vga_probe_ati_3c3_quirk(VFIOPCIDevice *vdev) -{ - VFIOQuirk *quirk; - - /* - * As long as the BAR is >= 256 bytes it will be aligned such that the - * lower byte is always zero. Filter out anything else, if it exists. - */ - if (!vfio_pci_is(vdev, PCI_VENDOR_ID_ATI, PCI_ANY_ID) || - !vdev->bars[4].ioport || vdev->bars[4].region.size < 256) { - return; - } - - quirk = g_malloc0(sizeof(*quirk)); - quirk->mem = g_new0(MemoryRegion, 1); - quirk->nr_mem = 1; - - memory_region_init_io(quirk->mem, OBJECT(vdev), &vfio_ati_3c3_quirk, vdev, - "vfio-ati-3c3-quirk", 1); - memory_region_add_subregion(&vdev->vga->region[QEMU_PCI_VGA_IO_HI].mem, - 3 /* offset 3 bytes from 0x3c0 */, quirk->mem); - - QLIST_INSERT_HEAD(&vdev->vga->region[QEMU_PCI_VGA_IO_HI].quirks, - quirk, next); - - trace_vfio_quirk_ati_3c3_probe(vdev->vbasedev.name); -} - -/* - * Newer ATI/AMD devices, including HD5450 and HD7850, have a mirror to PCI - * config space through MMIO BAR2 at offset 0x4000. Nothing seems to access - * the MMIO space directly, but a window to this space is provided through - * I/O port BAR4. Offset 0x0 is the address register and offset 0x4 is the - * data register. When the address is programmed to a range of 0x4000-0x4fff - * PCI configuration space is available. Experimentation seems to indicate - * that read-only may be provided by hardware. - */ -static void vfio_probe_ati_bar4_quirk(VFIOPCIDevice *vdev, int nr) -{ - VFIOQuirk *quirk; - VFIOConfigWindowQuirk *window; - - /* This windows doesn't seem to be used except by legacy VGA code */ - if (!vfio_pci_is(vdev, PCI_VENDOR_ID_ATI, PCI_ANY_ID) || - !vdev->has_vga || nr != 4) { - return; - } - - quirk = g_malloc0(sizeof(*quirk)); - quirk->mem = g_new0(MemoryRegion, 2); - quirk->nr_mem = 2; - window = quirk->data = g_malloc0(sizeof(*window) + - sizeof(VFIOConfigWindowMatch)); - window->vdev = vdev; - window->address_offset = 0; - window->data_offset = 4; - window->nr_matches = 1; - window->matches[0].match = 0x4000; - window->matches[0].mask = vdev->config_size - 1; - window->bar = nr; - window->addr_mem = &quirk->mem[0]; - window->data_mem = &quirk->mem[1]; - - memory_region_init_io(window->addr_mem, OBJECT(vdev), - &vfio_generic_window_address_quirk, window, - "vfio-ati-bar4-window-address-quirk", 4); - memory_region_add_subregion_overlap(vdev->bars[nr].region.mem, - window->address_offset, - window->addr_mem, 1); - - memory_region_init_io(window->data_mem, OBJECT(vdev), - &vfio_generic_window_data_quirk, window, - "vfio-ati-bar4-window-data-quirk", 4); - memory_region_add_subregion_overlap(vdev->bars[nr].region.mem, - window->data_offset, - window->data_mem, 1); - - QLIST_INSERT_HEAD(&vdev->bars[nr].quirks, quirk, next); - - trace_vfio_quirk_ati_bar4_probe(vdev->vbasedev.name); -} - -/* - * Trap the BAR2 MMIO mirror to config space as well. - */ -static void vfio_probe_ati_bar2_quirk(VFIOPCIDevice *vdev, int nr) -{ - VFIOQuirk *quirk; - VFIOConfigMirrorQuirk *mirror; - - /* Only enable on newer devices where BAR2 is 64bit */ - if (!vfio_pci_is(vdev, PCI_VENDOR_ID_ATI, PCI_ANY_ID) || - !vdev->has_vga || nr != 2 || !vdev->bars[2].mem64) { - return; - } - - quirk = g_malloc0(sizeof(*quirk)); - mirror = quirk->data = g_malloc0(sizeof(*mirror)); - mirror->mem = quirk->mem = g_new0(MemoryRegion, 1); - quirk->nr_mem = 1; - mirror->vdev = vdev; - mirror->offset = 0x4000; - mirror->bar = nr; - - memory_region_init_io(mirror->mem, OBJECT(vdev), - &vfio_generic_mirror_quirk, mirror, - "vfio-ati-bar2-4000-quirk", PCI_CONFIG_SPACE_SIZE); - memory_region_add_subregion_overlap(vdev->bars[nr].region.mem, - mirror->offset, mirror->mem, 1); - - QLIST_INSERT_HEAD(&vdev->bars[nr].quirks, quirk, next); - - trace_vfio_quirk_ati_bar2_probe(vdev->vbasedev.name); -} - -/* - * Older ATI/AMD cards like the X550 have a similar window to that above. - * I/O port BAR1 provides a window to a mirror of PCI config space located - * in BAR2 at offset 0xf00. We don't care to support such older cards, but - * note it for future reference. - */ - -#define PCI_VENDOR_ID_NVIDIA 0x10de - -/* - * Nvidia has several different methods to get to config space, the - * nouveu project has several of these documented here: - * https://github.com/pathscale/envytools/tree/master/hwdocs - * - * The first quirk is actually not documented in envytools and is found - * on 10de:01d1 (NVIDIA Corporation G72 [GeForce 7300 LE]). This is an - * NV46 chipset. The backdoor uses the legacy VGA I/O ports to access - * the mirror of PCI config space found at BAR0 offset 0x1800. The access - * sequence first writes 0x338 to I/O port 0x3d4. The target offset is - * then written to 0x3d0. Finally 0x538 is written for a read and 0x738 - * is written for a write to 0x3d4. The BAR0 offset is then accessible - * through 0x3d0. This quirk doesn't seem to be necessary on newer cards - * that use the I/O port BAR5 window but it doesn't hurt to leave it. - */ -typedef enum {NONE = 0, SELECT, WINDOW, READ, WRITE} VFIONvidia3d0State; -static const char *nv3d0_states[] = { "NONE", "SELECT", - "WINDOW", "READ", "WRITE" }; - -typedef struct VFIONvidia3d0Quirk { - VFIOPCIDevice *vdev; - VFIONvidia3d0State state; - uint32_t offset; -} VFIONvidia3d0Quirk; - -static uint64_t vfio_nvidia_3d4_quirk_read(void *opaque, - hwaddr addr, unsigned size) -{ - VFIONvidia3d0Quirk *quirk = opaque; - VFIOPCIDevice *vdev = quirk->vdev; - - quirk->state = NONE; - - return vfio_vga_read(&vdev->vga->region[QEMU_PCI_VGA_IO_HI], - addr + 0x14, size); -} - -static void vfio_nvidia_3d4_quirk_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ - VFIONvidia3d0Quirk *quirk = opaque; - VFIOPCIDevice *vdev = quirk->vdev; - VFIONvidia3d0State old_state = quirk->state; - - quirk->state = NONE; - - switch (data) { - case 0x338: - if (old_state == NONE) { - quirk->state = SELECT; - trace_vfio_quirk_nvidia_3d0_state(vdev->vbasedev.name, - nv3d0_states[quirk->state]); - } - break; - case 0x538: - if (old_state == WINDOW) { - quirk->state = READ; - trace_vfio_quirk_nvidia_3d0_state(vdev->vbasedev.name, - nv3d0_states[quirk->state]); - } - break; - case 0x738: - if (old_state == WINDOW) { - quirk->state = WRITE; - trace_vfio_quirk_nvidia_3d0_state(vdev->vbasedev.name, - nv3d0_states[quirk->state]); - } - break; - } - - vfio_vga_write(&vdev->vga->region[QEMU_PCI_VGA_IO_HI], - addr + 0x14, data, size); -} - -static const MemoryRegionOps vfio_nvidia_3d4_quirk = { - .read = vfio_nvidia_3d4_quirk_read, - .write = vfio_nvidia_3d4_quirk_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -static uint64_t vfio_nvidia_3d0_quirk_read(void *opaque, - hwaddr addr, unsigned size) -{ - VFIONvidia3d0Quirk *quirk = opaque; - VFIOPCIDevice *vdev = quirk->vdev; - VFIONvidia3d0State old_state = quirk->state; - uint64_t data = vfio_vga_read(&vdev->vga->region[QEMU_PCI_VGA_IO_HI], - addr + 0x10, size); - - quirk->state = NONE; - - if (old_state == READ && - (quirk->offset & ~(PCI_CONFIG_SPACE_SIZE - 1)) == 0x1800) { - uint8_t offset = quirk->offset & (PCI_CONFIG_SPACE_SIZE - 1); - - data = vfio_pci_read_config(&vdev->pdev, offset, size); - trace_vfio_quirk_nvidia_3d0_read(vdev->vbasedev.name, - offset, size, data); - } - - return data; -} - -static void vfio_nvidia_3d0_quirk_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ - VFIONvidia3d0Quirk *quirk = opaque; - VFIOPCIDevice *vdev = quirk->vdev; - VFIONvidia3d0State old_state = quirk->state; - - quirk->state = NONE; - - if (old_state == SELECT) { - quirk->offset = (uint32_t)data; - quirk->state = WINDOW; - trace_vfio_quirk_nvidia_3d0_state(vdev->vbasedev.name, - nv3d0_states[quirk->state]); - } else if (old_state == WRITE) { - if ((quirk->offset & ~(PCI_CONFIG_SPACE_SIZE - 1)) == 0x1800) { - uint8_t offset = quirk->offset & (PCI_CONFIG_SPACE_SIZE - 1); - - vfio_pci_write_config(&vdev->pdev, offset, data, size); - trace_vfio_quirk_nvidia_3d0_write(vdev->vbasedev.name, - offset, data, size); - return; - } - } - - vfio_vga_write(&vdev->vga->region[QEMU_PCI_VGA_IO_HI], - addr + 0x10, data, size); -} - -static const MemoryRegionOps vfio_nvidia_3d0_quirk = { - .read = vfio_nvidia_3d0_quirk_read, - .write = vfio_nvidia_3d0_quirk_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -static void vfio_vga_probe_nvidia_3d0_quirk(VFIOPCIDevice *vdev) -{ - VFIOQuirk *quirk; - VFIONvidia3d0Quirk *data; - - if (!vfio_pci_is(vdev, PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID) || - !vdev->bars[1].region.size) { - return; - } - - quirk = g_malloc0(sizeof(*quirk)); - quirk->data = data = g_malloc0(sizeof(*data)); - quirk->mem = g_new0(MemoryRegion, 2); - quirk->nr_mem = 2; - data->vdev = vdev; - - memory_region_init_io(&quirk->mem[0], OBJECT(vdev), &vfio_nvidia_3d4_quirk, - data, "vfio-nvidia-3d4-quirk", 2); - memory_region_add_subregion(&vdev->vga->region[QEMU_PCI_VGA_IO_HI].mem, - 0x14 /* 0x3c0 + 0x14 */, &quirk->mem[0]); - - memory_region_init_io(&quirk->mem[1], OBJECT(vdev), &vfio_nvidia_3d0_quirk, - data, "vfio-nvidia-3d0-quirk", 2); - memory_region_add_subregion(&vdev->vga->region[QEMU_PCI_VGA_IO_HI].mem, - 0x10 /* 0x3c0 + 0x10 */, &quirk->mem[1]); - - QLIST_INSERT_HEAD(&vdev->vga->region[QEMU_PCI_VGA_IO_HI].quirks, - quirk, next); - - trace_vfio_quirk_nvidia_3d0_probe(vdev->vbasedev.name); -} - -/* - * The second quirk is documented in envytools. The I/O port BAR5 is just - * a set of address/data ports to the MMIO BARs. The BAR we care about is - * again BAR0. This backdoor is apparently a bit newer than the one above - * so we need to not only trap 256 bytes @0x1800, but all of PCI config - * space, including extended space is available at the 4k @0x88000. - */ -typedef struct VFIONvidiaBAR5Quirk { - uint32_t master; - uint32_t enable; - MemoryRegion *addr_mem; - MemoryRegion *data_mem; - bool enabled; - VFIOConfigWindowQuirk window; /* last for match data */ -} VFIONvidiaBAR5Quirk; - -static void vfio_nvidia_bar5_enable(VFIONvidiaBAR5Quirk *bar5) -{ - VFIOPCIDevice *vdev = bar5->window.vdev; - - if (((bar5->master & bar5->enable) & 0x1) == bar5->enabled) { - return; - } - - bar5->enabled = !bar5->enabled; - trace_vfio_quirk_nvidia_bar5_state(vdev->vbasedev.name, - bar5->enabled ? "Enable" : "Disable"); - memory_region_set_enabled(bar5->addr_mem, bar5->enabled); - memory_region_set_enabled(bar5->data_mem, bar5->enabled); -} - -static uint64_t vfio_nvidia_bar5_quirk_master_read(void *opaque, - hwaddr addr, unsigned size) -{ - VFIONvidiaBAR5Quirk *bar5 = opaque; - VFIOPCIDevice *vdev = bar5->window.vdev; - - return vfio_region_read(&vdev->bars[5].region, addr, size); -} - -static void vfio_nvidia_bar5_quirk_master_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ - VFIONvidiaBAR5Quirk *bar5 = opaque; - VFIOPCIDevice *vdev = bar5->window.vdev; - - vfio_region_write(&vdev->bars[5].region, addr, data, size); - - bar5->master = data; - vfio_nvidia_bar5_enable(bar5); -} - -static const MemoryRegionOps vfio_nvidia_bar5_quirk_master = { - .read = vfio_nvidia_bar5_quirk_master_read, - .write = vfio_nvidia_bar5_quirk_master_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -static uint64_t vfio_nvidia_bar5_quirk_enable_read(void *opaque, - hwaddr addr, unsigned size) -{ - VFIONvidiaBAR5Quirk *bar5 = opaque; - VFIOPCIDevice *vdev = bar5->window.vdev; - - return vfio_region_read(&vdev->bars[5].region, addr + 4, size); -} - -static void vfio_nvidia_bar5_quirk_enable_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ - VFIONvidiaBAR5Quirk *bar5 = opaque; - VFIOPCIDevice *vdev = bar5->window.vdev; - - vfio_region_write(&vdev->bars[5].region, addr + 4, data, size); - - bar5->enable = data; - vfio_nvidia_bar5_enable(bar5); -} - -static const MemoryRegionOps vfio_nvidia_bar5_quirk_enable = { - .read = vfio_nvidia_bar5_quirk_enable_read, - .write = vfio_nvidia_bar5_quirk_enable_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -static void vfio_probe_nvidia_bar5_quirk(VFIOPCIDevice *vdev, int nr) -{ - VFIOQuirk *quirk; - VFIONvidiaBAR5Quirk *bar5; - VFIOConfigWindowQuirk *window; - - if (!vfio_pci_is(vdev, PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID) || - !vdev->has_vga || nr != 5) { - return; - } - - quirk = g_malloc0(sizeof(*quirk)); - quirk->mem = g_new0(MemoryRegion, 4); - quirk->nr_mem = 4; - bar5 = quirk->data = g_malloc0(sizeof(*bar5) + - (sizeof(VFIOConfigWindowMatch) * 2)); - window = &bar5->window; - - window->vdev = vdev; - window->address_offset = 0x8; - window->data_offset = 0xc; - window->nr_matches = 2; - window->matches[0].match = 0x1800; - window->matches[0].mask = PCI_CONFIG_SPACE_SIZE - 1; - window->matches[1].match = 0x88000; - window->matches[1].mask = vdev->config_size - 1; - window->bar = nr; - window->addr_mem = bar5->addr_mem = &quirk->mem[0]; - window->data_mem = bar5->data_mem = &quirk->mem[1]; - - memory_region_init_io(window->addr_mem, OBJECT(vdev), - &vfio_generic_window_address_quirk, window, - "vfio-nvidia-bar5-window-address-quirk", 4); - memory_region_add_subregion_overlap(vdev->bars[nr].region.mem, - window->address_offset, - window->addr_mem, 1); - memory_region_set_enabled(window->addr_mem, false); - - memory_region_init_io(window->data_mem, OBJECT(vdev), - &vfio_generic_window_data_quirk, window, - "vfio-nvidia-bar5-window-data-quirk", 4); - memory_region_add_subregion_overlap(vdev->bars[nr].region.mem, - window->data_offset, - window->data_mem, 1); - memory_region_set_enabled(window->data_mem, false); - - memory_region_init_io(&quirk->mem[2], OBJECT(vdev), - &vfio_nvidia_bar5_quirk_master, bar5, - "vfio-nvidia-bar5-master-quirk", 4); - memory_region_add_subregion_overlap(vdev->bars[nr].region.mem, - 0, &quirk->mem[2], 1); - - memory_region_init_io(&quirk->mem[3], OBJECT(vdev), - &vfio_nvidia_bar5_quirk_enable, bar5, - "vfio-nvidia-bar5-enable-quirk", 4); - memory_region_add_subregion_overlap(vdev->bars[nr].region.mem, - 4, &quirk->mem[3], 1); - - QLIST_INSERT_HEAD(&vdev->bars[nr].quirks, quirk, next); - - trace_vfio_quirk_nvidia_bar5_probe(vdev->vbasedev.name); -} - -/* - * Finally, BAR0 itself. We want to redirect any accesses to either - * 0x1800 or 0x88000 through the PCI config space access functions. - */ -static void vfio_nvidia_quirk_mirror_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ - VFIOConfigMirrorQuirk *mirror = opaque; - VFIOPCIDevice *vdev = mirror->vdev; - PCIDevice *pdev = &vdev->pdev; - - vfio_generic_quirk_mirror_write(opaque, addr, data, size); - - /* - * Nvidia seems to acknowledge MSI interrupts by writing 0xff to the - * MSI capability ID register. Both the ID and next register are - * read-only, so we allow writes covering either of those to real hw. - */ - if ((pdev->cap_present & QEMU_PCI_CAP_MSI) && - vfio_range_contained(addr, size, pdev->msi_cap, PCI_MSI_FLAGS)) { - vfio_region_write(&vdev->bars[mirror->bar].region, - addr + mirror->offset, data, size); - trace_vfio_quirk_nvidia_bar0_msi_ack(vdev->vbasedev.name); - } -} - -static const MemoryRegionOps vfio_nvidia_mirror_quirk = { - .read = vfio_generic_quirk_mirror_read, - .write = vfio_nvidia_quirk_mirror_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -static void vfio_probe_nvidia_bar0_quirk(VFIOPCIDevice *vdev, int nr) -{ - VFIOQuirk *quirk; - VFIOConfigMirrorQuirk *mirror; - - if (!vfio_pci_is(vdev, PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID) || - !vfio_is_vga(vdev) || nr != 0) { - return; - } - - quirk = g_malloc0(sizeof(*quirk)); - mirror = quirk->data = g_malloc0(sizeof(*mirror)); - mirror->mem = quirk->mem = g_new0(MemoryRegion, 1); - quirk->nr_mem = 1; - mirror->vdev = vdev; - mirror->offset = 0x88000; - mirror->bar = nr; - - memory_region_init_io(mirror->mem, OBJECT(vdev), - &vfio_nvidia_mirror_quirk, mirror, - "vfio-nvidia-bar0-88000-mirror-quirk", - vdev->config_size); - memory_region_add_subregion_overlap(vdev->bars[nr].region.mem, - mirror->offset, mirror->mem, 1); - - QLIST_INSERT_HEAD(&vdev->bars[nr].quirks, quirk, next); - - /* The 0x1800 offset mirror only seems to get used by legacy VGA */ - if (vdev->has_vga) { - quirk = g_malloc0(sizeof(*quirk)); - mirror = quirk->data = g_malloc0(sizeof(*mirror)); - mirror->mem = quirk->mem = g_new0(MemoryRegion, 1); - quirk->nr_mem = 1; - mirror->vdev = vdev; - mirror->offset = 0x1800; - mirror->bar = nr; - - memory_region_init_io(mirror->mem, OBJECT(vdev), - &vfio_nvidia_mirror_quirk, mirror, - "vfio-nvidia-bar0-1800-mirror-quirk", - PCI_CONFIG_SPACE_SIZE); - memory_region_add_subregion_overlap(vdev->bars[nr].region.mem, - mirror->offset, mirror->mem, 1); - - QLIST_INSERT_HEAD(&vdev->bars[nr].quirks, quirk, next); - } - - trace_vfio_quirk_nvidia_bar0_probe(vdev->vbasedev.name); -} - -/* - * TODO - Some Nvidia devices provide config access to their companion HDA - * device and even to their parent bridge via these config space mirrors. - * Add quirks for those regions. - */ - -#define PCI_VENDOR_ID_REALTEK 0x10ec - -/* - * RTL8168 devices have a backdoor that can access the MSI-X table. At BAR2 - * offset 0x70 there is a dword data register, offset 0x74 is a dword address - * register. According to the Linux r8169 driver, the MSI-X table is addressed - * when the "type" portion of the address register is set to 0x1. This appears - * to be bits 16:30. Bit 31 is both a write indicator and some sort of - * "address latched" indicator. Bits 12:15 are a mask field, which we can - * ignore because the MSI-X table should always be accessed as a dword (full - * mask). Bits 0:11 is offset within the type. - * - * Example trace: - * - * Read from MSI-X table offset 0 - * vfio: vfio_bar_write(0000:05:00.0:BAR2+0x74, 0x1f000, 4) // store read addr - * vfio: vfio_bar_read(0000:05:00.0:BAR2+0x74, 4) = 0x8001f000 // latch - * vfio: vfio_bar_read(0000:05:00.0:BAR2+0x70, 4) = 0xfee00398 // read data - * - * Write 0xfee00000 to MSI-X table offset 0 - * vfio: vfio_bar_write(0000:05:00.0:BAR2+0x70, 0xfee00000, 4) // write data - * vfio: vfio_bar_write(0000:05:00.0:BAR2+0x74, 0x8001f000, 4) // do write - * vfio: vfio_bar_read(0000:05:00.0:BAR2+0x74, 4) = 0x1f000 // complete - */ -typedef struct VFIOrtl8168Quirk { - VFIOPCIDevice *vdev; - uint32_t addr; - uint32_t data; - bool enabled; -} VFIOrtl8168Quirk; - -static uint64_t vfio_rtl8168_quirk_address_read(void *opaque, - hwaddr addr, unsigned size) -{ - VFIOrtl8168Quirk *rtl = opaque; - VFIOPCIDevice *vdev = rtl->vdev; - uint64_t data = vfio_region_read(&vdev->bars[2].region, addr + 0x74, size); - - if (rtl->enabled) { - data = rtl->addr ^ 0x80000000U; /* latch/complete */ - trace_vfio_quirk_rtl8168_fake_latch(vdev->vbasedev.name, data); - } - - return data; -} - -static void vfio_rtl8168_quirk_address_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ - VFIOrtl8168Quirk *rtl = opaque; - VFIOPCIDevice *vdev = rtl->vdev; - - rtl->enabled = false; - - if ((data & 0x7fff0000) == 0x10000) { /* MSI-X table */ - rtl->enabled = true; - rtl->addr = (uint32_t)data; - - if (data & 0x80000000U) { /* Do write */ - if (vdev->pdev.cap_present & QEMU_PCI_CAP_MSIX) { - hwaddr offset = data & 0xfff; - uint64_t val = rtl->data; - - trace_vfio_quirk_rtl8168_msix_write(vdev->vbasedev.name, - (uint16_t)offset, val); - - /* Write to the proper guest MSI-X table instead */ - memory_region_dispatch_write(&vdev->pdev.msix_table_mmio, - offset, val, size, - MEMTXATTRS_UNSPECIFIED); - } - return; /* Do not write guest MSI-X data to hardware */ - } - } - - vfio_region_write(&vdev->bars[2].region, addr + 0x74, data, size); -} - -static const MemoryRegionOps vfio_rtl_address_quirk = { - .read = vfio_rtl8168_quirk_address_read, - .write = vfio_rtl8168_quirk_address_write, - .valid = { - .min_access_size = 4, - .max_access_size = 4, - .unaligned = false, - }, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -static uint64_t vfio_rtl8168_quirk_data_read(void *opaque, - hwaddr addr, unsigned size) -{ - VFIOrtl8168Quirk *rtl = opaque; - VFIOPCIDevice *vdev = rtl->vdev; - uint64_t data = vfio_region_read(&vdev->bars[2].region, addr + 0x74, size); - - if (rtl->enabled && (vdev->pdev.cap_present & QEMU_PCI_CAP_MSIX)) { - hwaddr offset = rtl->addr & 0xfff; - memory_region_dispatch_read(&vdev->pdev.msix_table_mmio, offset, - &data, size, MEMTXATTRS_UNSPECIFIED); - trace_vfio_quirk_rtl8168_msix_read(vdev->vbasedev.name, offset, data); - } - - return data; -} - -static void vfio_rtl8168_quirk_data_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ - VFIOrtl8168Quirk *rtl = opaque; - VFIOPCIDevice *vdev = rtl->vdev; - - rtl->data = (uint32_t)data; - - vfio_region_write(&vdev->bars[2].region, addr + 0x70, data, size); -} - -static const MemoryRegionOps vfio_rtl_data_quirk = { - .read = vfio_rtl8168_quirk_data_read, - .write = vfio_rtl8168_quirk_data_write, - .valid = { - .min_access_size = 4, - .max_access_size = 4, - .unaligned = false, - }, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -static void vfio_probe_rtl8168_bar2_quirk(VFIOPCIDevice *vdev, int nr) -{ - VFIOQuirk *quirk; - VFIOrtl8168Quirk *rtl; - - if (!vfio_pci_is(vdev, PCI_VENDOR_ID_REALTEK, 0x8168) || nr != 2) { - return; - } - - quirk = g_malloc0(sizeof(*quirk)); - quirk->mem = g_new0(MemoryRegion, 2); - quirk->nr_mem = 2; - quirk->data = rtl = g_malloc0(sizeof(*rtl)); - rtl->vdev = vdev; - - memory_region_init_io(&quirk->mem[0], OBJECT(vdev), - &vfio_rtl_address_quirk, rtl, - "vfio-rtl8168-window-address-quirk", 4); - memory_region_add_subregion_overlap(vdev->bars[nr].region.mem, - 0x74, &quirk->mem[0], 1); - - memory_region_init_io(&quirk->mem[1], OBJECT(vdev), - &vfio_rtl_data_quirk, rtl, - "vfio-rtl8168-window-data-quirk", 4); - memory_region_add_subregion_overlap(vdev->bars[nr].region.mem, - 0x70, &quirk->mem[1], 1); - - QLIST_INSERT_HEAD(&vdev->bars[nr].quirks, quirk, next); - - trace_vfio_quirk_rtl8168_probe(vdev->vbasedev.name); -} - -/* - * Common quirk probe entry points. - */ -void vfio_vga_quirk_setup(VFIOPCIDevice *vdev) -{ - vfio_vga_probe_ati_3c3_quirk(vdev); - vfio_vga_probe_nvidia_3d0_quirk(vdev); -} - -void vfio_vga_quirk_exit(VFIOPCIDevice *vdev) -{ - VFIOQuirk *quirk; - int i, j; - - for (i = 0; i < ARRAY_SIZE(vdev->vga->region); i++) { - QLIST_FOREACH(quirk, &vdev->vga->region[i].quirks, next) { - for (j = 0; j < quirk->nr_mem; j++) { - memory_region_del_subregion(&vdev->vga->region[i].mem, - &quirk->mem[j]); - } - } - } -} - -void vfio_vga_quirk_finalize(VFIOPCIDevice *vdev) -{ - int i, j; - - for (i = 0; i < ARRAY_SIZE(vdev->vga->region); i++) { - while (!QLIST_EMPTY(&vdev->vga->region[i].quirks)) { - VFIOQuirk *quirk = QLIST_FIRST(&vdev->vga->region[i].quirks); - QLIST_REMOVE(quirk, next); - for (j = 0; j < quirk->nr_mem; j++) { - object_unparent(OBJECT(&quirk->mem[j])); - } - g_free(quirk->mem); - g_free(quirk->data); - g_free(quirk); - } - } -} - -void vfio_bar_quirk_setup(VFIOPCIDevice *vdev, int nr) -{ - vfio_probe_ati_bar4_quirk(vdev, nr); - vfio_probe_ati_bar2_quirk(vdev, nr); - vfio_probe_nvidia_bar5_quirk(vdev, nr); - vfio_probe_nvidia_bar0_quirk(vdev, nr); - vfio_probe_rtl8168_bar2_quirk(vdev, nr); -} - -void vfio_bar_quirk_exit(VFIOPCIDevice *vdev, int nr) -{ - VFIOBAR *bar = &vdev->bars[nr]; - VFIOQuirk *quirk; - int i; - - QLIST_FOREACH(quirk, &bar->quirks, next) { - for (i = 0; i < quirk->nr_mem; i++) { - memory_region_del_subregion(bar->region.mem, &quirk->mem[i]); - } - } -} - -void vfio_bar_quirk_finalize(VFIOPCIDevice *vdev, int nr) -{ - VFIOBAR *bar = &vdev->bars[nr]; - int i; - - while (!QLIST_EMPTY(&bar->quirks)) { - VFIOQuirk *quirk = QLIST_FIRST(&bar->quirks); - QLIST_REMOVE(quirk, next); - for (i = 0; i < quirk->nr_mem; i++) { - object_unparent(OBJECT(&quirk->mem[i])); - } - g_free(quirk->mem); - g_free(quirk->data); - g_free(quirk); - } -} - -/* - * Reset quirks - */ - -/* - * AMD Radeon PCI config reset, based on Linux: - * drivers/gpu/drm/radeon/ci_smc.c:ci_is_smc_running() - * drivers/gpu/drm/radeon/radeon_device.c:radeon_pci_config_reset - * drivers/gpu/drm/radeon/ci_smc.c:ci_reset_smc() - * drivers/gpu/drm/radeon/ci_smc.c:ci_stop_smc_clock() - * IDs: include/drm/drm_pciids.h - * Registers: http://cgit.freedesktop.org/~agd5f/linux/commit/?id=4e2aa447f6f0 - * - * Bonaire and Hawaii GPUs do not respond to a bus reset. This is a bug in the - * hardware that should be fixed on future ASICs. The symptom of this is that - * once the accerlated driver loads, Windows guests will bsod on subsequent - * attmpts to load the driver, such as after VM reset or shutdown/restart. To - * work around this, we do an AMD specific PCI config reset, followed by an SMC - * reset. The PCI config reset only works if SMC firmware is running, so we - * have a dependency on the state of the device as to whether this reset will - * be effective. There are still cases where we won't be able to kick the - * device into working, but this greatly improves the usability overall. The - * config reset magic is relatively common on AMD GPUs, but the setup and SMC - * poking is largely ASIC specific. - */ -static bool vfio_radeon_smc_is_running(VFIOPCIDevice *vdev) -{ - uint32_t clk, pc_c; - - /* - * Registers 200h and 204h are index and data registers for accessing - * indirect configuration registers within the device. - */ - vfio_region_write(&vdev->bars[5].region, 0x200, 0x80000004, 4); - clk = vfio_region_read(&vdev->bars[5].region, 0x204, 4); - vfio_region_write(&vdev->bars[5].region, 0x200, 0x80000370, 4); - pc_c = vfio_region_read(&vdev->bars[5].region, 0x204, 4); - - return (!(clk & 1) && (0x20100 <= pc_c)); -} - -/* - * The scope of a config reset is controlled by a mode bit in the misc register - * and a fuse, exposed as a bit in another register. The fuse is the default - * (0 = GFX, 1 = whole GPU), the misc bit is a toggle, with the forumula - * scope = !(misc ^ fuse), where the resulting scope is defined the same as - * the fuse. A truth table therefore tells us that if misc == fuse, we need - * to flip the value of the bit in the misc register. - */ -static void vfio_radeon_set_gfx_only_reset(VFIOPCIDevice *vdev) -{ - uint32_t misc, fuse; - bool a, b; - - vfio_region_write(&vdev->bars[5].region, 0x200, 0xc00c0000, 4); - fuse = vfio_region_read(&vdev->bars[5].region, 0x204, 4); - b = fuse & 64; - - vfio_region_write(&vdev->bars[5].region, 0x200, 0xc0000010, 4); - misc = vfio_region_read(&vdev->bars[5].region, 0x204, 4); - a = misc & 2; - - if (a == b) { - vfio_region_write(&vdev->bars[5].region, 0x204, misc ^ 2, 4); - vfio_region_read(&vdev->bars[5].region, 0x204, 4); /* flush */ - } -} - -static int vfio_radeon_reset(VFIOPCIDevice *vdev) -{ - PCIDevice *pdev = &vdev->pdev; - int i, ret = 0; - uint32_t data; - - /* Defer to a kernel implemented reset */ - if (vdev->vbasedev.reset_works) { - trace_vfio_quirk_ati_bonaire_reset_skipped(vdev->vbasedev.name); - return -ENODEV; - } - - /* Enable only memory BAR access */ - vfio_pci_write_config(pdev, PCI_COMMAND, PCI_COMMAND_MEMORY, 2); - - /* Reset only works if SMC firmware is loaded and running */ - if (!vfio_radeon_smc_is_running(vdev)) { - ret = -EINVAL; - trace_vfio_quirk_ati_bonaire_reset_no_smc(vdev->vbasedev.name); - goto out; - } - - /* Make sure only the GFX function is reset */ - vfio_radeon_set_gfx_only_reset(vdev); - - /* AMD PCI config reset */ - vfio_pci_write_config(pdev, 0x7c, 0x39d5e86b, 4); - usleep(100); - - /* Read back the memory size to make sure we're out of reset */ - for (i = 0; i < 100000; i++) { - if (vfio_region_read(&vdev->bars[5].region, 0x5428, 4) != 0xffffffff) { - goto reset_smc; - } - usleep(1); - } - - trace_vfio_quirk_ati_bonaire_reset_timeout(vdev->vbasedev.name); - -reset_smc: - /* Reset SMC */ - vfio_region_write(&vdev->bars[5].region, 0x200, 0x80000000, 4); - data = vfio_region_read(&vdev->bars[5].region, 0x204, 4); - data |= 1; - vfio_region_write(&vdev->bars[5].region, 0x204, data, 4); - - /* Disable SMC clock */ - vfio_region_write(&vdev->bars[5].region, 0x200, 0x80000004, 4); - data = vfio_region_read(&vdev->bars[5].region, 0x204, 4); - data |= 1; - vfio_region_write(&vdev->bars[5].region, 0x204, data, 4); - - trace_vfio_quirk_ati_bonaire_reset_done(vdev->vbasedev.name); - -out: - /* Restore PCI command register */ - vfio_pci_write_config(pdev, PCI_COMMAND, 0, 2); - - return ret; -} - -void vfio_setup_resetfn_quirk(VFIOPCIDevice *vdev) -{ - switch (vdev->vendor_id) { - case 0x1002: - switch (vdev->device_id) { - /* Bonaire */ - case 0x6649: /* Bonaire [FirePro W5100] */ - case 0x6650: - case 0x6651: - case 0x6658: /* Bonaire XTX [Radeon R7 260X] */ - case 0x665c: /* Bonaire XT [Radeon HD 7790/8770 / R9 260 OEM] */ - case 0x665d: /* Bonaire [Radeon R7 200 Series] */ - /* Hawaii */ - case 0x67A0: /* Hawaii XT GL [FirePro W9100] */ - case 0x67A1: /* Hawaii PRO GL [FirePro W8100] */ - case 0x67A2: - case 0x67A8: - case 0x67A9: - case 0x67AA: - case 0x67B0: /* Hawaii XT [Radeon R9 290X] */ - case 0x67B1: /* Hawaii PRO [Radeon R9 290] */ - case 0x67B8: - case 0x67B9: - case 0x67BA: - case 0x67BE: - vdev->resetfn = vfio_radeon_reset; - trace_vfio_quirk_ati_bonaire_reset(vdev->vbasedev.name); - break; - } - break; - } -} diff --git a/qemu/hw/vfio/pci.c b/qemu/hw/vfio/pci.c deleted file mode 100644 index d091d8cf0..000000000 --- a/qemu/hw/vfio/pci.c +++ /dev/null @@ -1,2734 +0,0 @@ -/* - * vfio based device assignment support - * - * Copyright Red Hat, Inc. 2012 - * - * Authors: - * Alex Williamson <alex.williamson@redhat.com> - * - * This work is licensed under the terms of the GNU GPL, version 2. See - * the COPYING file in the top-level directory. - * - * Based on qemu-kvm device-assignment: - * Adapted for KVM by Qumranet. - * Copyright (c) 2007, Neocleus, Alex Novik (alex@neocleus.com) - * Copyright (c) 2007, Neocleus, Guy Zana (guy@neocleus.com) - * Copyright (C) 2008, Qumranet, Amit Shah (amit.shah@qumranet.com) - * Copyright (C) 2008, Red Hat, Amit Shah (amit.shah@redhat.com) - * Copyright (C) 2008, IBM, Muli Ben-Yehuda (muli@il.ibm.com) - */ - -#include "qemu/osdep.h" -#include <linux/vfio.h> -#include <sys/ioctl.h> -#include <sys/mman.h> - -#include "hw/pci/msi.h" -#include "hw/pci/msix.h" -#include "hw/pci/pci_bridge.h" -#include "qemu/error-report.h" -#include "qemu/range.h" -#include "sysemu/kvm.h" -#include "sysemu/sysemu.h" -#include "pci.h" -#include "trace.h" - -#define MSIX_CAP_LENGTH 12 - -static void vfio_disable_interrupts(VFIOPCIDevice *vdev); -static void vfio_mmap_set_enabled(VFIOPCIDevice *vdev, bool enabled); - -/* - * Disabling BAR mmaping can be slow, but toggling it around INTx can - * also be a huge overhead. We try to get the best of both worlds by - * waiting until an interrupt to disable mmaps (subsequent transitions - * to the same state are effectively no overhead). If the interrupt has - * been serviced and the time gap is long enough, we re-enable mmaps for - * performance. This works well for things like graphics cards, which - * may not use their interrupt at all and are penalized to an unusable - * level by read/write BAR traps. Other devices, like NICs, have more - * regular interrupts and see much better latency by staying in non-mmap - * mode. We therefore set the default mmap_timeout such that a ping - * is just enough to keep the mmap disabled. Users can experiment with - * other options with the x-intx-mmap-timeout-ms parameter (a value of - * zero disables the timer). - */ -static void vfio_intx_mmap_enable(void *opaque) -{ - VFIOPCIDevice *vdev = opaque; - - if (vdev->intx.pending) { - timer_mod(vdev->intx.mmap_timer, - qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + vdev->intx.mmap_timeout); - return; - } - - vfio_mmap_set_enabled(vdev, true); -} - -static void vfio_intx_interrupt(void *opaque) -{ - VFIOPCIDevice *vdev = opaque; - - if (!event_notifier_test_and_clear(&vdev->intx.interrupt)) { - return; - } - - trace_vfio_intx_interrupt(vdev->vbasedev.name, 'A' + vdev->intx.pin); - - vdev->intx.pending = true; - pci_irq_assert(&vdev->pdev); - vfio_mmap_set_enabled(vdev, false); - if (vdev->intx.mmap_timeout) { - timer_mod(vdev->intx.mmap_timer, - qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + vdev->intx.mmap_timeout); - } -} - -static void vfio_intx_eoi(VFIODevice *vbasedev) -{ - VFIOPCIDevice *vdev = container_of(vbasedev, VFIOPCIDevice, vbasedev); - - if (!vdev->intx.pending) { - return; - } - - trace_vfio_intx_eoi(vbasedev->name); - - vdev->intx.pending = false; - pci_irq_deassert(&vdev->pdev); - vfio_unmask_single_irqindex(vbasedev, VFIO_PCI_INTX_IRQ_INDEX); -} - -static void vfio_intx_enable_kvm(VFIOPCIDevice *vdev) -{ -#ifdef CONFIG_KVM - struct kvm_irqfd irqfd = { - .fd = event_notifier_get_fd(&vdev->intx.interrupt), - .gsi = vdev->intx.route.irq, - .flags = KVM_IRQFD_FLAG_RESAMPLE, - }; - struct vfio_irq_set *irq_set; - int ret, argsz; - int32_t *pfd; - - if (vdev->no_kvm_intx || !kvm_irqfds_enabled() || - vdev->intx.route.mode != PCI_INTX_ENABLED || - !kvm_resamplefds_enabled()) { - return; - } - - /* Get to a known interrupt state */ - qemu_set_fd_handler(irqfd.fd, NULL, NULL, vdev); - vfio_mask_single_irqindex(&vdev->vbasedev, VFIO_PCI_INTX_IRQ_INDEX); - vdev->intx.pending = false; - pci_irq_deassert(&vdev->pdev); - - /* Get an eventfd for resample/unmask */ - if (event_notifier_init(&vdev->intx.unmask, 0)) { - error_report("vfio: Error: event_notifier_init failed eoi"); - goto fail; - } - - /* KVM triggers it, VFIO listens for it */ - irqfd.resamplefd = event_notifier_get_fd(&vdev->intx.unmask); - - if (kvm_vm_ioctl(kvm_state, KVM_IRQFD, &irqfd)) { - error_report("vfio: Error: Failed to setup resample irqfd: %m"); - goto fail_irqfd; - } - - argsz = sizeof(*irq_set) + sizeof(*pfd); - - irq_set = g_malloc0(argsz); - irq_set->argsz = argsz; - irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | VFIO_IRQ_SET_ACTION_UNMASK; - irq_set->index = VFIO_PCI_INTX_IRQ_INDEX; - irq_set->start = 0; - irq_set->count = 1; - pfd = (int32_t *)&irq_set->data; - - *pfd = irqfd.resamplefd; - - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_SET_IRQS, irq_set); - g_free(irq_set); - if (ret) { - error_report("vfio: Error: Failed to setup INTx unmask fd: %m"); - goto fail_vfio; - } - - /* Let'em rip */ - vfio_unmask_single_irqindex(&vdev->vbasedev, VFIO_PCI_INTX_IRQ_INDEX); - - vdev->intx.kvm_accel = true; - - trace_vfio_intx_enable_kvm(vdev->vbasedev.name); - - return; - -fail_vfio: - irqfd.flags = KVM_IRQFD_FLAG_DEASSIGN; - kvm_vm_ioctl(kvm_state, KVM_IRQFD, &irqfd); -fail_irqfd: - event_notifier_cleanup(&vdev->intx.unmask); -fail: - qemu_set_fd_handler(irqfd.fd, vfio_intx_interrupt, NULL, vdev); - vfio_unmask_single_irqindex(&vdev->vbasedev, VFIO_PCI_INTX_IRQ_INDEX); -#endif -} - -static void vfio_intx_disable_kvm(VFIOPCIDevice *vdev) -{ -#ifdef CONFIG_KVM - struct kvm_irqfd irqfd = { - .fd = event_notifier_get_fd(&vdev->intx.interrupt), - .gsi = vdev->intx.route.irq, - .flags = KVM_IRQFD_FLAG_DEASSIGN, - }; - - if (!vdev->intx.kvm_accel) { - return; - } - - /* - * Get to a known state, hardware masked, QEMU ready to accept new - * interrupts, QEMU IRQ de-asserted. - */ - vfio_mask_single_irqindex(&vdev->vbasedev, VFIO_PCI_INTX_IRQ_INDEX); - vdev->intx.pending = false; - pci_irq_deassert(&vdev->pdev); - - /* Tell KVM to stop listening for an INTx irqfd */ - if (kvm_vm_ioctl(kvm_state, KVM_IRQFD, &irqfd)) { - error_report("vfio: Error: Failed to disable INTx irqfd: %m"); - } - - /* We only need to close the eventfd for VFIO to cleanup the kernel side */ - event_notifier_cleanup(&vdev->intx.unmask); - - /* QEMU starts listening for interrupt events. */ - qemu_set_fd_handler(irqfd.fd, vfio_intx_interrupt, NULL, vdev); - - vdev->intx.kvm_accel = false; - - /* If we've missed an event, let it re-fire through QEMU */ - vfio_unmask_single_irqindex(&vdev->vbasedev, VFIO_PCI_INTX_IRQ_INDEX); - - trace_vfio_intx_disable_kvm(vdev->vbasedev.name); -#endif -} - -static void vfio_intx_update(PCIDevice *pdev) -{ - VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev); - PCIINTxRoute route; - - if (vdev->interrupt != VFIO_INT_INTx) { - return; - } - - route = pci_device_route_intx_to_irq(&vdev->pdev, vdev->intx.pin); - - if (!pci_intx_route_changed(&vdev->intx.route, &route)) { - return; /* Nothing changed */ - } - - trace_vfio_intx_update(vdev->vbasedev.name, - vdev->intx.route.irq, route.irq); - - vfio_intx_disable_kvm(vdev); - - vdev->intx.route = route; - - if (route.mode != PCI_INTX_ENABLED) { - return; - } - - vfio_intx_enable_kvm(vdev); - - /* Re-enable the interrupt in cased we missed an EOI */ - vfio_intx_eoi(&vdev->vbasedev); -} - -static int vfio_intx_enable(VFIOPCIDevice *vdev) -{ - uint8_t pin = vfio_pci_read_config(&vdev->pdev, PCI_INTERRUPT_PIN, 1); - int ret, argsz; - struct vfio_irq_set *irq_set; - int32_t *pfd; - - if (!pin) { - return 0; - } - - vfio_disable_interrupts(vdev); - - vdev->intx.pin = pin - 1; /* Pin A (1) -> irq[0] */ - pci_config_set_interrupt_pin(vdev->pdev.config, pin); - -#ifdef CONFIG_KVM - /* - * Only conditional to avoid generating error messages on platforms - * where we won't actually use the result anyway. - */ - if (kvm_irqfds_enabled() && kvm_resamplefds_enabled()) { - vdev->intx.route = pci_device_route_intx_to_irq(&vdev->pdev, - vdev->intx.pin); - } -#endif - - ret = event_notifier_init(&vdev->intx.interrupt, 0); - if (ret) { - error_report("vfio: Error: event_notifier_init failed"); - return ret; - } - - argsz = sizeof(*irq_set) + sizeof(*pfd); - - irq_set = g_malloc0(argsz); - irq_set->argsz = argsz; - irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | VFIO_IRQ_SET_ACTION_TRIGGER; - irq_set->index = VFIO_PCI_INTX_IRQ_INDEX; - irq_set->start = 0; - irq_set->count = 1; - pfd = (int32_t *)&irq_set->data; - - *pfd = event_notifier_get_fd(&vdev->intx.interrupt); - qemu_set_fd_handler(*pfd, vfio_intx_interrupt, NULL, vdev); - - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_SET_IRQS, irq_set); - g_free(irq_set); - if (ret) { - error_report("vfio: Error: Failed to setup INTx fd: %m"); - qemu_set_fd_handler(*pfd, NULL, NULL, vdev); - event_notifier_cleanup(&vdev->intx.interrupt); - return -errno; - } - - vfio_intx_enable_kvm(vdev); - - vdev->interrupt = VFIO_INT_INTx; - - trace_vfio_intx_enable(vdev->vbasedev.name); - - return 0; -} - -static void vfio_intx_disable(VFIOPCIDevice *vdev) -{ - int fd; - - timer_del(vdev->intx.mmap_timer); - vfio_intx_disable_kvm(vdev); - vfio_disable_irqindex(&vdev->vbasedev, VFIO_PCI_INTX_IRQ_INDEX); - vdev->intx.pending = false; - pci_irq_deassert(&vdev->pdev); - vfio_mmap_set_enabled(vdev, true); - - fd = event_notifier_get_fd(&vdev->intx.interrupt); - qemu_set_fd_handler(fd, NULL, NULL, vdev); - event_notifier_cleanup(&vdev->intx.interrupt); - - vdev->interrupt = VFIO_INT_NONE; - - trace_vfio_intx_disable(vdev->vbasedev.name); -} - -/* - * MSI/X - */ -static void vfio_msi_interrupt(void *opaque) -{ - VFIOMSIVector *vector = opaque; - VFIOPCIDevice *vdev = vector->vdev; - MSIMessage (*get_msg)(PCIDevice *dev, unsigned vector); - void (*notify)(PCIDevice *dev, unsigned vector); - MSIMessage msg; - int nr = vector - vdev->msi_vectors; - - if (!event_notifier_test_and_clear(&vector->interrupt)) { - return; - } - - if (vdev->interrupt == VFIO_INT_MSIX) { - get_msg = msix_get_message; - notify = msix_notify; - - /* A masked vector firing needs to use the PBA, enable it */ - if (msix_is_masked(&vdev->pdev, nr)) { - set_bit(nr, vdev->msix->pending); - memory_region_set_enabled(&vdev->pdev.msix_pba_mmio, true); - trace_vfio_msix_pba_enable(vdev->vbasedev.name); - } - } else if (vdev->interrupt == VFIO_INT_MSI) { - get_msg = msi_get_message; - notify = msi_notify; - } else { - abort(); - } - - msg = get_msg(&vdev->pdev, nr); - trace_vfio_msi_interrupt(vdev->vbasedev.name, nr, msg.address, msg.data); - notify(&vdev->pdev, nr); -} - -static int vfio_enable_vectors(VFIOPCIDevice *vdev, bool msix) -{ - struct vfio_irq_set *irq_set; - int ret = 0, i, argsz; - int32_t *fds; - - argsz = sizeof(*irq_set) + (vdev->nr_vectors * sizeof(*fds)); - - irq_set = g_malloc0(argsz); - irq_set->argsz = argsz; - irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | VFIO_IRQ_SET_ACTION_TRIGGER; - irq_set->index = msix ? VFIO_PCI_MSIX_IRQ_INDEX : VFIO_PCI_MSI_IRQ_INDEX; - irq_set->start = 0; - irq_set->count = vdev->nr_vectors; - fds = (int32_t *)&irq_set->data; - - for (i = 0; i < vdev->nr_vectors; i++) { - int fd = -1; - - /* - * MSI vs MSI-X - The guest has direct access to MSI mask and pending - * bits, therefore we always use the KVM signaling path when setup. - * MSI-X mask and pending bits are emulated, so we want to use the - * KVM signaling path only when configured and unmasked. - */ - if (vdev->msi_vectors[i].use) { - if (vdev->msi_vectors[i].virq < 0 || - (msix && msix_is_masked(&vdev->pdev, i))) { - fd = event_notifier_get_fd(&vdev->msi_vectors[i].interrupt); - } else { - fd = event_notifier_get_fd(&vdev->msi_vectors[i].kvm_interrupt); - } - } - - fds[i] = fd; - } - - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_SET_IRQS, irq_set); - - g_free(irq_set); - - return ret; -} - -static void vfio_add_kvm_msi_virq(VFIOPCIDevice *vdev, VFIOMSIVector *vector, - MSIMessage *msg, bool msix) -{ - int virq; - - if ((msix && vdev->no_kvm_msix) || (!msix && vdev->no_kvm_msi) || !msg) { - return; - } - - if (event_notifier_init(&vector->kvm_interrupt, 0)) { - return; - } - - virq = kvm_irqchip_add_msi_route(kvm_state, *msg, &vdev->pdev); - if (virq < 0) { - event_notifier_cleanup(&vector->kvm_interrupt); - return; - } - - if (kvm_irqchip_add_irqfd_notifier_gsi(kvm_state, &vector->kvm_interrupt, - NULL, virq) < 0) { - kvm_irqchip_release_virq(kvm_state, virq); - event_notifier_cleanup(&vector->kvm_interrupt); - return; - } - - vector->virq = virq; -} - -static void vfio_remove_kvm_msi_virq(VFIOMSIVector *vector) -{ - kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state, &vector->kvm_interrupt, - vector->virq); - kvm_irqchip_release_virq(kvm_state, vector->virq); - vector->virq = -1; - event_notifier_cleanup(&vector->kvm_interrupt); -} - -static void vfio_update_kvm_msi_virq(VFIOMSIVector *vector, MSIMessage msg, - PCIDevice *pdev) -{ - kvm_irqchip_update_msi_route(kvm_state, vector->virq, msg, pdev); -} - -static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr, - MSIMessage *msg, IOHandler *handler) -{ - VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev); - VFIOMSIVector *vector; - int ret; - - trace_vfio_msix_vector_do_use(vdev->vbasedev.name, nr); - - vector = &vdev->msi_vectors[nr]; - - if (!vector->use) { - vector->vdev = vdev; - vector->virq = -1; - if (event_notifier_init(&vector->interrupt, 0)) { - error_report("vfio: Error: event_notifier_init failed"); - } - vector->use = true; - msix_vector_use(pdev, nr); - } - - qemu_set_fd_handler(event_notifier_get_fd(&vector->interrupt), - handler, NULL, vector); - - /* - * Attempt to enable route through KVM irqchip, - * default to userspace handling if unavailable. - */ - if (vector->virq >= 0) { - if (!msg) { - vfio_remove_kvm_msi_virq(vector); - } else { - vfio_update_kvm_msi_virq(vector, *msg, pdev); - } - } else { - vfio_add_kvm_msi_virq(vdev, vector, msg, true); - } - - /* - * We don't want to have the host allocate all possible MSI vectors - * for a device if they're not in use, so we shutdown and incrementally - * increase them as needed. - */ - if (vdev->nr_vectors < nr + 1) { - vfio_disable_irqindex(&vdev->vbasedev, VFIO_PCI_MSIX_IRQ_INDEX); - vdev->nr_vectors = nr + 1; - ret = vfio_enable_vectors(vdev, true); - if (ret) { - error_report("vfio: failed to enable vectors, %d", ret); - } - } else { - int argsz; - struct vfio_irq_set *irq_set; - int32_t *pfd; - - argsz = sizeof(*irq_set) + sizeof(*pfd); - - irq_set = g_malloc0(argsz); - irq_set->argsz = argsz; - irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | - VFIO_IRQ_SET_ACTION_TRIGGER; - irq_set->index = VFIO_PCI_MSIX_IRQ_INDEX; - irq_set->start = nr; - irq_set->count = 1; - pfd = (int32_t *)&irq_set->data; - - if (vector->virq >= 0) { - *pfd = event_notifier_get_fd(&vector->kvm_interrupt); - } else { - *pfd = event_notifier_get_fd(&vector->interrupt); - } - - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_SET_IRQS, irq_set); - g_free(irq_set); - if (ret) { - error_report("vfio: failed to modify vector, %d", ret); - } - } - - /* Disable PBA emulation when nothing more is pending. */ - clear_bit(nr, vdev->msix->pending); - if (find_first_bit(vdev->msix->pending, - vdev->nr_vectors) == vdev->nr_vectors) { - memory_region_set_enabled(&vdev->pdev.msix_pba_mmio, false); - trace_vfio_msix_pba_disable(vdev->vbasedev.name); - } - - return 0; -} - -static int vfio_msix_vector_use(PCIDevice *pdev, - unsigned int nr, MSIMessage msg) -{ - return vfio_msix_vector_do_use(pdev, nr, &msg, vfio_msi_interrupt); -} - -static void vfio_msix_vector_release(PCIDevice *pdev, unsigned int nr) -{ - VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev); - VFIOMSIVector *vector = &vdev->msi_vectors[nr]; - - trace_vfio_msix_vector_release(vdev->vbasedev.name, nr); - - /* - * There are still old guests that mask and unmask vectors on every - * interrupt. If we're using QEMU bypass with a KVM irqfd, leave all of - * the KVM setup in place, simply switch VFIO to use the non-bypass - * eventfd. We'll then fire the interrupt through QEMU and the MSI-X - * core will mask the interrupt and set pending bits, allowing it to - * be re-asserted on unmask. Nothing to do if already using QEMU mode. - */ - if (vector->virq >= 0) { - int argsz; - struct vfio_irq_set *irq_set; - int32_t *pfd; - - argsz = sizeof(*irq_set) + sizeof(*pfd); - - irq_set = g_malloc0(argsz); - irq_set->argsz = argsz; - irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | - VFIO_IRQ_SET_ACTION_TRIGGER; - irq_set->index = VFIO_PCI_MSIX_IRQ_INDEX; - irq_set->start = nr; - irq_set->count = 1; - pfd = (int32_t *)&irq_set->data; - - *pfd = event_notifier_get_fd(&vector->interrupt); - - ioctl(vdev->vbasedev.fd, VFIO_DEVICE_SET_IRQS, irq_set); - - g_free(irq_set); - } -} - -static void vfio_msix_enable(VFIOPCIDevice *vdev) -{ - vfio_disable_interrupts(vdev); - - vdev->msi_vectors = g_new0(VFIOMSIVector, vdev->msix->entries); - - vdev->interrupt = VFIO_INT_MSIX; - - /* - * Some communication channels between VF & PF or PF & fw rely on the - * physical state of the device and expect that enabling MSI-X from the - * guest enables the same on the host. When our guest is Linux, the - * guest driver call to pci_enable_msix() sets the enabling bit in the - * MSI-X capability, but leaves the vector table masked. We therefore - * can't rely on a vector_use callback (from request_irq() in the guest) - * to switch the physical device into MSI-X mode because that may come a - * long time after pci_enable_msix(). This code enables vector 0 with - * triggering to userspace, then immediately release the vector, leaving - * the physical device with no vectors enabled, but MSI-X enabled, just - * like the guest view. - */ - vfio_msix_vector_do_use(&vdev->pdev, 0, NULL, NULL); - vfio_msix_vector_release(&vdev->pdev, 0); - - if (msix_set_vector_notifiers(&vdev->pdev, vfio_msix_vector_use, - vfio_msix_vector_release, NULL)) { - error_report("vfio: msix_set_vector_notifiers failed"); - } - - trace_vfio_msix_enable(vdev->vbasedev.name); -} - -static void vfio_msi_enable(VFIOPCIDevice *vdev) -{ - int ret, i; - - vfio_disable_interrupts(vdev); - - vdev->nr_vectors = msi_nr_vectors_allocated(&vdev->pdev); -retry: - vdev->msi_vectors = g_new0(VFIOMSIVector, vdev->nr_vectors); - - for (i = 0; i < vdev->nr_vectors; i++) { - VFIOMSIVector *vector = &vdev->msi_vectors[i]; - MSIMessage msg = msi_get_message(&vdev->pdev, i); - - vector->vdev = vdev; - vector->virq = -1; - vector->use = true; - - if (event_notifier_init(&vector->interrupt, 0)) { - error_report("vfio: Error: event_notifier_init failed"); - } - - qemu_set_fd_handler(event_notifier_get_fd(&vector->interrupt), - vfio_msi_interrupt, NULL, vector); - - /* - * Attempt to enable route through KVM irqchip, - * default to userspace handling if unavailable. - */ - vfio_add_kvm_msi_virq(vdev, vector, &msg, false); - } - - /* Set interrupt type prior to possible interrupts */ - vdev->interrupt = VFIO_INT_MSI; - - ret = vfio_enable_vectors(vdev, false); - if (ret) { - if (ret < 0) { - error_report("vfio: Error: Failed to setup MSI fds: %m"); - } else if (ret != vdev->nr_vectors) { - error_report("vfio: Error: Failed to enable %d " - "MSI vectors, retry with %d", vdev->nr_vectors, ret); - } - - for (i = 0; i < vdev->nr_vectors; i++) { - VFIOMSIVector *vector = &vdev->msi_vectors[i]; - if (vector->virq >= 0) { - vfio_remove_kvm_msi_virq(vector); - } - qemu_set_fd_handler(event_notifier_get_fd(&vector->interrupt), - NULL, NULL, NULL); - event_notifier_cleanup(&vector->interrupt); - } - - g_free(vdev->msi_vectors); - - if (ret > 0 && ret != vdev->nr_vectors) { - vdev->nr_vectors = ret; - goto retry; - } - vdev->nr_vectors = 0; - - /* - * Failing to setup MSI doesn't really fall within any specification. - * Let's try leaving interrupts disabled and hope the guest figures - * out to fall back to INTx for this device. - */ - error_report("vfio: Error: Failed to enable MSI"); - vdev->interrupt = VFIO_INT_NONE; - - return; - } - - trace_vfio_msi_enable(vdev->vbasedev.name, vdev->nr_vectors); -} - -static void vfio_msi_disable_common(VFIOPCIDevice *vdev) -{ - int i; - - for (i = 0; i < vdev->nr_vectors; i++) { - VFIOMSIVector *vector = &vdev->msi_vectors[i]; - if (vdev->msi_vectors[i].use) { - if (vector->virq >= 0) { - vfio_remove_kvm_msi_virq(vector); - } - qemu_set_fd_handler(event_notifier_get_fd(&vector->interrupt), - NULL, NULL, NULL); - event_notifier_cleanup(&vector->interrupt); - } - } - - g_free(vdev->msi_vectors); - vdev->msi_vectors = NULL; - vdev->nr_vectors = 0; - vdev->interrupt = VFIO_INT_NONE; - - vfio_intx_enable(vdev); -} - -static void vfio_msix_disable(VFIOPCIDevice *vdev) -{ - int i; - - msix_unset_vector_notifiers(&vdev->pdev); - - /* - * MSI-X will only release vectors if MSI-X is still enabled on the - * device, check through the rest and release it ourselves if necessary. - */ - for (i = 0; i < vdev->nr_vectors; i++) { - if (vdev->msi_vectors[i].use) { - vfio_msix_vector_release(&vdev->pdev, i); - msix_vector_unuse(&vdev->pdev, i); - } - } - - if (vdev->nr_vectors) { - vfio_disable_irqindex(&vdev->vbasedev, VFIO_PCI_MSIX_IRQ_INDEX); - } - - vfio_msi_disable_common(vdev); - - memset(vdev->msix->pending, 0, - BITS_TO_LONGS(vdev->msix->entries) * sizeof(unsigned long)); - - trace_vfio_msix_disable(vdev->vbasedev.name); -} - -static void vfio_msi_disable(VFIOPCIDevice *vdev) -{ - vfio_disable_irqindex(&vdev->vbasedev, VFIO_PCI_MSI_IRQ_INDEX); - vfio_msi_disable_common(vdev); - - trace_vfio_msi_disable(vdev->vbasedev.name); -} - -static void vfio_update_msi(VFIOPCIDevice *vdev) -{ - int i; - - for (i = 0; i < vdev->nr_vectors; i++) { - VFIOMSIVector *vector = &vdev->msi_vectors[i]; - MSIMessage msg; - - if (!vector->use || vector->virq < 0) { - continue; - } - - msg = msi_get_message(&vdev->pdev, i); - vfio_update_kvm_msi_virq(vector, msg, &vdev->pdev); - } -} - -static void vfio_pci_load_rom(VFIOPCIDevice *vdev) -{ - struct vfio_region_info *reg_info; - uint64_t size; - off_t off = 0; - ssize_t bytes; - - if (vfio_get_region_info(&vdev->vbasedev, - VFIO_PCI_ROM_REGION_INDEX, ®_info)) { - error_report("vfio: Error getting ROM info: %m"); - return; - } - - trace_vfio_pci_load_rom(vdev->vbasedev.name, (unsigned long)reg_info->size, - (unsigned long)reg_info->offset, - (unsigned long)reg_info->flags); - - vdev->rom_size = size = reg_info->size; - vdev->rom_offset = reg_info->offset; - - g_free(reg_info); - - if (!vdev->rom_size) { - vdev->rom_read_failed = true; - error_report("vfio-pci: Cannot read device rom at " - "%s", vdev->vbasedev.name); - error_printf("Device option ROM contents are probably invalid " - "(check dmesg).\nSkip option ROM probe with rombar=0, " - "or load from file with romfile=\n"); - return; - } - - vdev->rom = g_malloc(size); - memset(vdev->rom, 0xff, size); - - while (size) { - bytes = pread(vdev->vbasedev.fd, vdev->rom + off, - size, vdev->rom_offset + off); - if (bytes == 0) { - break; - } else if (bytes > 0) { - off += bytes; - size -= bytes; - } else { - if (errno == EINTR || errno == EAGAIN) { - continue; - } - error_report("vfio: Error reading device ROM: %m"); - break; - } - } - - /* - * Test the ROM signature against our device, if the vendor is correct - * but the device ID doesn't match, store the correct device ID and - * recompute the checksum. Intel IGD devices need this and are known - * to have bogus checksums so we can't simply adjust the checksum. - */ - if (pci_get_word(vdev->rom) == 0xaa55 && - pci_get_word(vdev->rom + 0x18) + 8 < vdev->rom_size && - !memcmp(vdev->rom + pci_get_word(vdev->rom + 0x18), "PCIR", 4)) { - uint16_t vid, did; - - vid = pci_get_word(vdev->rom + pci_get_word(vdev->rom + 0x18) + 4); - did = pci_get_word(vdev->rom + pci_get_word(vdev->rom + 0x18) + 6); - - if (vid == vdev->vendor_id && did != vdev->device_id) { - int i; - uint8_t csum, *data = vdev->rom; - - pci_set_word(vdev->rom + pci_get_word(vdev->rom + 0x18) + 6, - vdev->device_id); - data[6] = 0; - - for (csum = 0, i = 0; i < vdev->rom_size; i++) { - csum += data[i]; - } - - data[6] = -csum; - } - } -} - -static uint64_t vfio_rom_read(void *opaque, hwaddr addr, unsigned size) -{ - VFIOPCIDevice *vdev = opaque; - union { - uint8_t byte; - uint16_t word; - uint32_t dword; - uint64_t qword; - } val; - uint64_t data = 0; - - /* Load the ROM lazily when the guest tries to read it */ - if (unlikely(!vdev->rom && !vdev->rom_read_failed)) { - vfio_pci_load_rom(vdev); - } - - memcpy(&val, vdev->rom + addr, - (addr < vdev->rom_size) ? MIN(size, vdev->rom_size - addr) : 0); - - switch (size) { - case 1: - data = val.byte; - break; - case 2: - data = le16_to_cpu(val.word); - break; - case 4: - data = le32_to_cpu(val.dword); - break; - default: - hw_error("vfio: unsupported read size, %d bytes\n", size); - break; - } - - trace_vfio_rom_read(vdev->vbasedev.name, addr, size, data); - - return data; -} - -static void vfio_rom_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ -} - -static const MemoryRegionOps vfio_rom_ops = { - .read = vfio_rom_read, - .write = vfio_rom_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -static void vfio_pci_size_rom(VFIOPCIDevice *vdev) -{ - uint32_t orig, size = cpu_to_le32((uint32_t)PCI_ROM_ADDRESS_MASK); - off_t offset = vdev->config_offset + PCI_ROM_ADDRESS; - DeviceState *dev = DEVICE(vdev); - char *name; - int fd = vdev->vbasedev.fd; - - if (vdev->pdev.romfile || !vdev->pdev.rom_bar) { - /* Since pci handles romfile, just print a message and return */ - if (vfio_blacklist_opt_rom(vdev) && vdev->pdev.romfile) { - error_printf("Warning : Device at %s is known to cause system instability issues during option rom execution. Proceeding anyway since user specified romfile\n", - vdev->vbasedev.name); - } - return; - } - - /* - * Use the same size ROM BAR as the physical device. The contents - * will get filled in later when the guest tries to read it. - */ - if (pread(fd, &orig, 4, offset) != 4 || - pwrite(fd, &size, 4, offset) != 4 || - pread(fd, &size, 4, offset) != 4 || - pwrite(fd, &orig, 4, offset) != 4) { - error_report("%s(%s) failed: %m", __func__, vdev->vbasedev.name); - return; - } - - size = ~(le32_to_cpu(size) & PCI_ROM_ADDRESS_MASK) + 1; - - if (!size) { - return; - } - - if (vfio_blacklist_opt_rom(vdev)) { - if (dev->opts && qemu_opt_get(dev->opts, "rombar")) { - error_printf("Warning : Device at %s is known to cause system instability issues during option rom execution. Proceeding anyway since user specified non zero value for rombar\n", - vdev->vbasedev.name); - } else { - error_printf("Warning : Rom loading for device at %s has been disabled due to system instability issues. Specify rombar=1 or romfile to force\n", - vdev->vbasedev.name); - return; - } - } - - trace_vfio_pci_size_rom(vdev->vbasedev.name, size); - - name = g_strdup_printf("vfio[%s].rom", vdev->vbasedev.name); - - memory_region_init_io(&vdev->pdev.rom, OBJECT(vdev), - &vfio_rom_ops, vdev, name, size); - g_free(name); - - pci_register_bar(&vdev->pdev, PCI_ROM_SLOT, - PCI_BASE_ADDRESS_SPACE_MEMORY, &vdev->pdev.rom); - - vdev->pdev.has_rom = true; - vdev->rom_read_failed = false; -} - -void vfio_vga_write(void *opaque, hwaddr addr, - uint64_t data, unsigned size) -{ - VFIOVGARegion *region = opaque; - VFIOVGA *vga = container_of(region, VFIOVGA, region[region->nr]); - union { - uint8_t byte; - uint16_t word; - uint32_t dword; - uint64_t qword; - } buf; - off_t offset = vga->fd_offset + region->offset + addr; - - switch (size) { - case 1: - buf.byte = data; - break; - case 2: - buf.word = cpu_to_le16(data); - break; - case 4: - buf.dword = cpu_to_le32(data); - break; - default: - hw_error("vfio: unsupported write size, %d bytes", size); - break; - } - - if (pwrite(vga->fd, &buf, size, offset) != size) { - error_report("%s(,0x%"HWADDR_PRIx", 0x%"PRIx64", %d) failed: %m", - __func__, region->offset + addr, data, size); - } - - trace_vfio_vga_write(region->offset + addr, data, size); -} - -uint64_t vfio_vga_read(void *opaque, hwaddr addr, unsigned size) -{ - VFIOVGARegion *region = opaque; - VFIOVGA *vga = container_of(region, VFIOVGA, region[region->nr]); - union { - uint8_t byte; - uint16_t word; - uint32_t dword; - uint64_t qword; - } buf; - uint64_t data = 0; - off_t offset = vga->fd_offset + region->offset + addr; - - if (pread(vga->fd, &buf, size, offset) != size) { - error_report("%s(,0x%"HWADDR_PRIx", %d) failed: %m", - __func__, region->offset + addr, size); - return (uint64_t)-1; - } - - switch (size) { - case 1: - data = buf.byte; - break; - case 2: - data = le16_to_cpu(buf.word); - break; - case 4: - data = le32_to_cpu(buf.dword); - break; - default: - hw_error("vfio: unsupported read size, %d bytes", size); - break; - } - - trace_vfio_vga_read(region->offset + addr, size, data); - - return data; -} - -static const MemoryRegionOps vfio_vga_ops = { - .read = vfio_vga_read, - .write = vfio_vga_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -/* - * PCI config space - */ -uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len) -{ - VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev); - uint32_t emu_bits = 0, emu_val = 0, phys_val = 0, val; - - memcpy(&emu_bits, vdev->emulated_config_bits + addr, len); - emu_bits = le32_to_cpu(emu_bits); - - if (emu_bits) { - emu_val = pci_default_read_config(pdev, addr, len); - } - - if (~emu_bits & (0xffffffffU >> (32 - len * 8))) { - ssize_t ret; - - ret = pread(vdev->vbasedev.fd, &phys_val, len, - vdev->config_offset + addr); - if (ret != len) { - error_report("%s(%s, 0x%x, 0x%x) failed: %m", - __func__, vdev->vbasedev.name, addr, len); - return -errno; - } - phys_val = le32_to_cpu(phys_val); - } - - val = (emu_val & emu_bits) | (phys_val & ~emu_bits); - - trace_vfio_pci_read_config(vdev->vbasedev.name, addr, len, val); - - return val; -} - -void vfio_pci_write_config(PCIDevice *pdev, - uint32_t addr, uint32_t val, int len) -{ - VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev); - uint32_t val_le = cpu_to_le32(val); - - trace_vfio_pci_write_config(vdev->vbasedev.name, addr, val, len); - - /* Write everything to VFIO, let it filter out what we can't write */ - if (pwrite(vdev->vbasedev.fd, &val_le, len, vdev->config_offset + addr) - != len) { - error_report("%s(%s, 0x%x, 0x%x, 0x%x) failed: %m", - __func__, vdev->vbasedev.name, addr, val, len); - } - - /* MSI/MSI-X Enabling/Disabling */ - if (pdev->cap_present & QEMU_PCI_CAP_MSI && - ranges_overlap(addr, len, pdev->msi_cap, vdev->msi_cap_size)) { - int is_enabled, was_enabled = msi_enabled(pdev); - - pci_default_write_config(pdev, addr, val, len); - - is_enabled = msi_enabled(pdev); - - if (!was_enabled) { - if (is_enabled) { - vfio_msi_enable(vdev); - } - } else { - if (!is_enabled) { - vfio_msi_disable(vdev); - } else { - vfio_update_msi(vdev); - } - } - } else if (pdev->cap_present & QEMU_PCI_CAP_MSIX && - ranges_overlap(addr, len, pdev->msix_cap, MSIX_CAP_LENGTH)) { - int is_enabled, was_enabled = msix_enabled(pdev); - - pci_default_write_config(pdev, addr, val, len); - - is_enabled = msix_enabled(pdev); - - if (!was_enabled && is_enabled) { - vfio_msix_enable(vdev); - } else if (was_enabled && !is_enabled) { - vfio_msix_disable(vdev); - } - } else { - /* Write everything to QEMU to keep emulated bits correct */ - pci_default_write_config(pdev, addr, val, len); - } -} - -/* - * Interrupt setup - */ -static void vfio_disable_interrupts(VFIOPCIDevice *vdev) -{ - /* - * More complicated than it looks. Disabling MSI/X transitions the - * device to INTx mode (if supported). Therefore we need to first - * disable MSI/X and then cleanup by disabling INTx. - */ - if (vdev->interrupt == VFIO_INT_MSIX) { - vfio_msix_disable(vdev); - } else if (vdev->interrupt == VFIO_INT_MSI) { - vfio_msi_disable(vdev); - } - - if (vdev->interrupt == VFIO_INT_INTx) { - vfio_intx_disable(vdev); - } -} - -static int vfio_msi_setup(VFIOPCIDevice *vdev, int pos) -{ - uint16_t ctrl; - bool msi_64bit, msi_maskbit; - int ret, entries; - - if (pread(vdev->vbasedev.fd, &ctrl, sizeof(ctrl), - vdev->config_offset + pos + PCI_CAP_FLAGS) != sizeof(ctrl)) { - return -errno; - } - ctrl = le16_to_cpu(ctrl); - - msi_64bit = !!(ctrl & PCI_MSI_FLAGS_64BIT); - msi_maskbit = !!(ctrl & PCI_MSI_FLAGS_MASKBIT); - entries = 1 << ((ctrl & PCI_MSI_FLAGS_QMASK) >> 1); - - trace_vfio_msi_setup(vdev->vbasedev.name, pos); - - ret = msi_init(&vdev->pdev, pos, entries, msi_64bit, msi_maskbit); - if (ret < 0) { - if (ret == -ENOTSUP) { - return 0; - } - error_report("vfio: msi_init failed"); - return ret; - } - vdev->msi_cap_size = 0xa + (msi_maskbit ? 0xa : 0) + (msi_64bit ? 0x4 : 0); - - return 0; -} - -static void vfio_pci_fixup_msix_region(VFIOPCIDevice *vdev) -{ - off_t start, end; - VFIORegion *region = &vdev->bars[vdev->msix->table_bar].region; - - /* - * We expect to find a single mmap covering the whole BAR, anything else - * means it's either unsupported or already setup. - */ - if (region->nr_mmaps != 1 || region->mmaps[0].offset || - region->size != region->mmaps[0].size) { - return; - } - - /* MSI-X table start and end aligned to host page size */ - start = vdev->msix->table_offset & qemu_real_host_page_mask; - end = REAL_HOST_PAGE_ALIGN((uint64_t)vdev->msix->table_offset + - (vdev->msix->entries * PCI_MSIX_ENTRY_SIZE)); - - /* - * Does the MSI-X table cover the beginning of the BAR? The whole BAR? - * NB - Host page size is necessarily a power of two and so is the PCI - * BAR (not counting EA yet), therefore if we have host page aligned - * @start and @end, then any remainder of the BAR before or after those - * must be at least host page sized and therefore mmap'able. - */ - if (!start) { - if (end >= region->size) { - region->nr_mmaps = 0; - g_free(region->mmaps); - region->mmaps = NULL; - trace_vfio_msix_fixup(vdev->vbasedev.name, - vdev->msix->table_bar, 0, 0); - } else { - region->mmaps[0].offset = end; - region->mmaps[0].size = region->size - end; - trace_vfio_msix_fixup(vdev->vbasedev.name, - vdev->msix->table_bar, region->mmaps[0].offset, - region->mmaps[0].offset + region->mmaps[0].size); - } - - /* Maybe it's aligned at the end of the BAR */ - } else if (end >= region->size) { - region->mmaps[0].size = start; - trace_vfio_msix_fixup(vdev->vbasedev.name, - vdev->msix->table_bar, region->mmaps[0].offset, - region->mmaps[0].offset + region->mmaps[0].size); - - /* Otherwise it must split the BAR */ - } else { - region->nr_mmaps = 2; - region->mmaps = g_renew(VFIOMmap, region->mmaps, 2); - - memcpy(®ion->mmaps[1], ®ion->mmaps[0], sizeof(VFIOMmap)); - - region->mmaps[0].size = start; - trace_vfio_msix_fixup(vdev->vbasedev.name, - vdev->msix->table_bar, region->mmaps[0].offset, - region->mmaps[0].offset + region->mmaps[0].size); - - region->mmaps[1].offset = end; - region->mmaps[1].size = region->size - end; - trace_vfio_msix_fixup(vdev->vbasedev.name, - vdev->msix->table_bar, region->mmaps[1].offset, - region->mmaps[1].offset + region->mmaps[1].size); - } -} - -/* - * We don't have any control over how pci_add_capability() inserts - * capabilities into the chain. In order to setup MSI-X we need a - * MemoryRegion for the BAR. In order to setup the BAR and not - * attempt to mmap the MSI-X table area, which VFIO won't allow, we - * need to first look for where the MSI-X table lives. So we - * unfortunately split MSI-X setup across two functions. - */ -static int vfio_msix_early_setup(VFIOPCIDevice *vdev) -{ - uint8_t pos; - uint16_t ctrl; - uint32_t table, pba; - int fd = vdev->vbasedev.fd; - VFIOMSIXInfo *msix; - - pos = pci_find_capability(&vdev->pdev, PCI_CAP_ID_MSIX); - if (!pos) { - return 0; - } - - if (pread(fd, &ctrl, sizeof(ctrl), - vdev->config_offset + pos + PCI_MSIX_FLAGS) != sizeof(ctrl)) { - return -errno; - } - - if (pread(fd, &table, sizeof(table), - vdev->config_offset + pos + PCI_MSIX_TABLE) != sizeof(table)) { - return -errno; - } - - if (pread(fd, &pba, sizeof(pba), - vdev->config_offset + pos + PCI_MSIX_PBA) != sizeof(pba)) { - return -errno; - } - - ctrl = le16_to_cpu(ctrl); - table = le32_to_cpu(table); - pba = le32_to_cpu(pba); - - msix = g_malloc0(sizeof(*msix)); - msix->table_bar = table & PCI_MSIX_FLAGS_BIRMASK; - msix->table_offset = table & ~PCI_MSIX_FLAGS_BIRMASK; - msix->pba_bar = pba & PCI_MSIX_FLAGS_BIRMASK; - msix->pba_offset = pba & ~PCI_MSIX_FLAGS_BIRMASK; - msix->entries = (ctrl & PCI_MSIX_FLAGS_QSIZE) + 1; - - /* - * Test the size of the pba_offset variable and catch if it extends outside - * of the specified BAR. If it is the case, we need to apply a hardware - * specific quirk if the device is known or we have a broken configuration. - */ - if (msix->pba_offset >= vdev->bars[msix->pba_bar].region.size) { - /* - * Chelsio T5 Virtual Function devices are encoded as 0x58xx for T5 - * adapters. The T5 hardware returns an incorrect value of 0x8000 for - * the VF PBA offset while the BAR itself is only 8k. The correct value - * is 0x1000, so we hard code that here. - */ - if (vdev->vendor_id == PCI_VENDOR_ID_CHELSIO && - (vdev->device_id & 0xff00) == 0x5800) { - msix->pba_offset = 0x1000; - } else { - error_report("vfio: Hardware reports invalid configuration, " - "MSIX PBA outside of specified BAR"); - g_free(msix); - return -EINVAL; - } - } - - trace_vfio_msix_early_setup(vdev->vbasedev.name, pos, msix->table_bar, - msix->table_offset, msix->entries); - vdev->msix = msix; - - vfio_pci_fixup_msix_region(vdev); - - return 0; -} - -static int vfio_msix_setup(VFIOPCIDevice *vdev, int pos) -{ - int ret; - - vdev->msix->pending = g_malloc0(BITS_TO_LONGS(vdev->msix->entries) * - sizeof(unsigned long)); - ret = msix_init(&vdev->pdev, vdev->msix->entries, - vdev->bars[vdev->msix->table_bar].region.mem, - vdev->msix->table_bar, vdev->msix->table_offset, - vdev->bars[vdev->msix->pba_bar].region.mem, - vdev->msix->pba_bar, vdev->msix->pba_offset, pos); - if (ret < 0) { - if (ret == -ENOTSUP) { - return 0; - } - error_report("vfio: msix_init failed"); - return ret; - } - - /* - * The PCI spec suggests that devices provide additional alignment for - * MSI-X structures and avoid overlapping non-MSI-X related registers. - * For an assigned device, this hopefully means that emulation of MSI-X - * structures does not affect the performance of the device. If devices - * fail to provide that alignment, a significant performance penalty may - * result, for instance Mellanox MT27500 VFs: - * http://www.spinics.net/lists/kvm/msg125881.html - * - * The PBA is simply not that important for such a serious regression and - * most drivers do not appear to look at it. The solution for this is to - * disable the PBA MemoryRegion unless it's being used. We disable it - * here and only enable it if a masked vector fires through QEMU. As the - * vector-use notifier is called, which occurs on unmask, we test whether - * PBA emulation is needed and again disable if not. - */ - memory_region_set_enabled(&vdev->pdev.msix_pba_mmio, false); - - return 0; -} - -static void vfio_teardown_msi(VFIOPCIDevice *vdev) -{ - msi_uninit(&vdev->pdev); - - if (vdev->msix) { - msix_uninit(&vdev->pdev, - vdev->bars[vdev->msix->table_bar].region.mem, - vdev->bars[vdev->msix->pba_bar].region.mem); - g_free(vdev->msix->pending); - } -} - -/* - * Resource setup - */ -static void vfio_mmap_set_enabled(VFIOPCIDevice *vdev, bool enabled) -{ - int i; - - for (i = 0; i < PCI_ROM_SLOT; i++) { - vfio_region_mmaps_set_enabled(&vdev->bars[i].region, enabled); - } -} - -static void vfio_bar_setup(VFIOPCIDevice *vdev, int nr) -{ - VFIOBAR *bar = &vdev->bars[nr]; - - uint32_t pci_bar; - uint8_t type; - int ret; - - /* Skip both unimplemented BARs and the upper half of 64bit BARS. */ - if (!bar->region.size) { - return; - } - - /* Determine what type of BAR this is for registration */ - ret = pread(vdev->vbasedev.fd, &pci_bar, sizeof(pci_bar), - vdev->config_offset + PCI_BASE_ADDRESS_0 + (4 * nr)); - if (ret != sizeof(pci_bar)) { - error_report("vfio: Failed to read BAR %d (%m)", nr); - return; - } - - pci_bar = le32_to_cpu(pci_bar); - bar->ioport = (pci_bar & PCI_BASE_ADDRESS_SPACE_IO); - bar->mem64 = bar->ioport ? 0 : (pci_bar & PCI_BASE_ADDRESS_MEM_TYPE_64); - type = pci_bar & (bar->ioport ? ~PCI_BASE_ADDRESS_IO_MASK : - ~PCI_BASE_ADDRESS_MEM_MASK); - - if (vfio_region_mmap(&bar->region)) { - error_report("Failed to mmap %s BAR %d. Performance may be slow", - vdev->vbasedev.name, nr); - } - - vfio_bar_quirk_setup(vdev, nr); - - pci_register_bar(&vdev->pdev, nr, type, bar->region.mem); -} - -static void vfio_bars_setup(VFIOPCIDevice *vdev) -{ - int i; - - for (i = 0; i < PCI_ROM_SLOT; i++) { - vfio_bar_setup(vdev, i); - } - - if (vdev->vga) { - memory_region_init_io(&vdev->vga->region[QEMU_PCI_VGA_MEM].mem, - OBJECT(vdev), &vfio_vga_ops, - &vdev->vga->region[QEMU_PCI_VGA_MEM], - "vfio-vga-mmio@0xa0000", - QEMU_PCI_VGA_MEM_SIZE); - memory_region_init_io(&vdev->vga->region[QEMU_PCI_VGA_IO_LO].mem, - OBJECT(vdev), &vfio_vga_ops, - &vdev->vga->region[QEMU_PCI_VGA_IO_LO], - "vfio-vga-io@0x3b0", - QEMU_PCI_VGA_IO_LO_SIZE); - memory_region_init_io(&vdev->vga->region[QEMU_PCI_VGA_IO_HI].mem, - OBJECT(vdev), &vfio_vga_ops, - &vdev->vga->region[QEMU_PCI_VGA_IO_HI], - "vfio-vga-io@0x3c0", - QEMU_PCI_VGA_IO_HI_SIZE); - - pci_register_vga(&vdev->pdev, &vdev->vga->region[QEMU_PCI_VGA_MEM].mem, - &vdev->vga->region[QEMU_PCI_VGA_IO_LO].mem, - &vdev->vga->region[QEMU_PCI_VGA_IO_HI].mem); - vfio_vga_quirk_setup(vdev); - } -} - -static void vfio_bars_exit(VFIOPCIDevice *vdev) -{ - int i; - - for (i = 0; i < PCI_ROM_SLOT; i++) { - vfio_bar_quirk_exit(vdev, i); - vfio_region_exit(&vdev->bars[i].region); - } - - if (vdev->vga) { - pci_unregister_vga(&vdev->pdev); - vfio_vga_quirk_exit(vdev); - } -} - -static void vfio_bars_finalize(VFIOPCIDevice *vdev) -{ - int i; - - for (i = 0; i < PCI_ROM_SLOT; i++) { - vfio_bar_quirk_finalize(vdev, i); - vfio_region_finalize(&vdev->bars[i].region); - } - - if (vdev->vga) { - vfio_vga_quirk_finalize(vdev); - for (i = 0; i < ARRAY_SIZE(vdev->vga->region); i++) { - object_unparent(OBJECT(&vdev->vga->region[i].mem)); - } - g_free(vdev->vga); - } -} - -/* - * General setup - */ -static uint8_t vfio_std_cap_max_size(PCIDevice *pdev, uint8_t pos) -{ - uint8_t tmp; - uint16_t next = PCI_CONFIG_SPACE_SIZE; - - for (tmp = pdev->config[PCI_CAPABILITY_LIST]; tmp; - tmp = pdev->config[tmp + PCI_CAP_LIST_NEXT]) { - if (tmp > pos && tmp < next) { - next = tmp; - } - } - - return next - pos; -} - -static void vfio_set_word_bits(uint8_t *buf, uint16_t val, uint16_t mask) -{ - pci_set_word(buf, (pci_get_word(buf) & ~mask) | val); -} - -static void vfio_add_emulated_word(VFIOPCIDevice *vdev, int pos, - uint16_t val, uint16_t mask) -{ - vfio_set_word_bits(vdev->pdev.config + pos, val, mask); - vfio_set_word_bits(vdev->pdev.wmask + pos, ~mask, mask); - vfio_set_word_bits(vdev->emulated_config_bits + pos, mask, mask); -} - -static void vfio_set_long_bits(uint8_t *buf, uint32_t val, uint32_t mask) -{ - pci_set_long(buf, (pci_get_long(buf) & ~mask) | val); -} - -static void vfio_add_emulated_long(VFIOPCIDevice *vdev, int pos, - uint32_t val, uint32_t mask) -{ - vfio_set_long_bits(vdev->pdev.config + pos, val, mask); - vfio_set_long_bits(vdev->pdev.wmask + pos, ~mask, mask); - vfio_set_long_bits(vdev->emulated_config_bits + pos, mask, mask); -} - -static int vfio_setup_pcie_cap(VFIOPCIDevice *vdev, int pos, uint8_t size) -{ - uint16_t flags; - uint8_t type; - - flags = pci_get_word(vdev->pdev.config + pos + PCI_CAP_FLAGS); - type = (flags & PCI_EXP_FLAGS_TYPE) >> 4; - - if (type != PCI_EXP_TYPE_ENDPOINT && - type != PCI_EXP_TYPE_LEG_END && - type != PCI_EXP_TYPE_RC_END) { - - error_report("vfio: Assignment of PCIe type 0x%x " - "devices is not currently supported", type); - return -EINVAL; - } - - if (!pci_bus_is_express(vdev->pdev.bus)) { - PCIBus *bus = vdev->pdev.bus; - PCIDevice *bridge; - - /* - * Traditionally PCI device assignment exposes the PCIe capability - * as-is on non-express buses. The reason being that some drivers - * simply assume that it's there, for example tg3. However when - * we're running on a native PCIe machine type, like Q35, we need - * to hide the PCIe capability. The reason for this is twofold; - * first Windows guests get a Code 10 error when the PCIe capability - * is exposed in this configuration. Therefore express devices won't - * work at all unless they're attached to express buses in the VM. - * Second, a native PCIe machine introduces the possibility of fine - * granularity IOMMUs supporting both translation and isolation. - * Guest code to discover the IOMMU visibility of a device, such as - * IOMMU grouping code on Linux, is very aware of device types and - * valid transitions between bus types. An express device on a non- - * express bus is not a valid combination on bare metal systems. - * - * Drivers that require a PCIe capability to make the device - * functional are simply going to need to have their devices placed - * on a PCIe bus in the VM. - */ - while (!pci_bus_is_root(bus)) { - bridge = pci_bridge_get_device(bus); - bus = bridge->bus; - } - - if (pci_bus_is_express(bus)) { - return 0; - } - - } else if (pci_bus_is_root(vdev->pdev.bus)) { - /* - * On a Root Complex bus Endpoints become Root Complex Integrated - * Endpoints, which changes the type and clears the LNK & LNK2 fields. - */ - if (type == PCI_EXP_TYPE_ENDPOINT) { - vfio_add_emulated_word(vdev, pos + PCI_CAP_FLAGS, - PCI_EXP_TYPE_RC_END << 4, - PCI_EXP_FLAGS_TYPE); - - /* Link Capabilities, Status, and Control goes away */ - if (size > PCI_EXP_LNKCTL) { - vfio_add_emulated_long(vdev, pos + PCI_EXP_LNKCAP, 0, ~0); - vfio_add_emulated_word(vdev, pos + PCI_EXP_LNKCTL, 0, ~0); - vfio_add_emulated_word(vdev, pos + PCI_EXP_LNKSTA, 0, ~0); - -#ifndef PCI_EXP_LNKCAP2 -#define PCI_EXP_LNKCAP2 44 -#endif -#ifndef PCI_EXP_LNKSTA2 -#define PCI_EXP_LNKSTA2 50 -#endif - /* Link 2 Capabilities, Status, and Control goes away */ - if (size > PCI_EXP_LNKCAP2) { - vfio_add_emulated_long(vdev, pos + PCI_EXP_LNKCAP2, 0, ~0); - vfio_add_emulated_word(vdev, pos + PCI_EXP_LNKCTL2, 0, ~0); - vfio_add_emulated_word(vdev, pos + PCI_EXP_LNKSTA2, 0, ~0); - } - } - - } else if (type == PCI_EXP_TYPE_LEG_END) { - /* - * Legacy endpoints don't belong on the root complex. Windows - * seems to be happier with devices if we skip the capability. - */ - return 0; - } - - } else { - /* - * Convert Root Complex Integrated Endpoints to regular endpoints. - * These devices don't support LNK/LNK2 capabilities, so make them up. - */ - if (type == PCI_EXP_TYPE_RC_END) { - vfio_add_emulated_word(vdev, pos + PCI_CAP_FLAGS, - PCI_EXP_TYPE_ENDPOINT << 4, - PCI_EXP_FLAGS_TYPE); - vfio_add_emulated_long(vdev, pos + PCI_EXP_LNKCAP, - PCI_EXP_LNK_MLW_1 | PCI_EXP_LNK_LS_25, ~0); - vfio_add_emulated_word(vdev, pos + PCI_EXP_LNKCTL, 0, ~0); - } - - /* Mark the Link Status bits as emulated to allow virtual negotiation */ - vfio_add_emulated_word(vdev, pos + PCI_EXP_LNKSTA, - pci_get_word(vdev->pdev.config + pos + - PCI_EXP_LNKSTA), - PCI_EXP_LNKCAP_MLW | PCI_EXP_LNKCAP_SLS); - } - - pos = pci_add_capability(&vdev->pdev, PCI_CAP_ID_EXP, pos, size); - if (pos >= 0) { - vdev->pdev.exp.exp_cap = pos; - } - - return pos; -} - -static void vfio_check_pcie_flr(VFIOPCIDevice *vdev, uint8_t pos) -{ - uint32_t cap = pci_get_long(vdev->pdev.config + pos + PCI_EXP_DEVCAP); - - if (cap & PCI_EXP_DEVCAP_FLR) { - trace_vfio_check_pcie_flr(vdev->vbasedev.name); - vdev->has_flr = true; - } -} - -static void vfio_check_pm_reset(VFIOPCIDevice *vdev, uint8_t pos) -{ - uint16_t csr = pci_get_word(vdev->pdev.config + pos + PCI_PM_CTRL); - - if (!(csr & PCI_PM_CTRL_NO_SOFT_RESET)) { - trace_vfio_check_pm_reset(vdev->vbasedev.name); - vdev->has_pm_reset = true; - } -} - -static void vfio_check_af_flr(VFIOPCIDevice *vdev, uint8_t pos) -{ - uint8_t cap = pci_get_byte(vdev->pdev.config + pos + PCI_AF_CAP); - - if ((cap & PCI_AF_CAP_TP) && (cap & PCI_AF_CAP_FLR)) { - trace_vfio_check_af_flr(vdev->vbasedev.name); - vdev->has_flr = true; - } -} - -static int vfio_add_std_cap(VFIOPCIDevice *vdev, uint8_t pos) -{ - PCIDevice *pdev = &vdev->pdev; - uint8_t cap_id, next, size; - int ret; - - cap_id = pdev->config[pos]; - next = pdev->config[pos + PCI_CAP_LIST_NEXT]; - - /* - * If it becomes important to configure capabilities to their actual - * size, use this as the default when it's something we don't recognize. - * Since QEMU doesn't actually handle many of the config accesses, - * exact size doesn't seem worthwhile. - */ - size = vfio_std_cap_max_size(pdev, pos); - - /* - * pci_add_capability always inserts the new capability at the head - * of the chain. Therefore to end up with a chain that matches the - * physical device, we insert from the end by making this recursive. - * This is also why we pre-calculate size above as cached config space - * will be changed as we unwind the stack. - */ - if (next) { - ret = vfio_add_std_cap(vdev, next); - if (ret) { - return ret; - } - } else { - /* Begin the rebuild, use QEMU emulated list bits */ - pdev->config[PCI_CAPABILITY_LIST] = 0; - vdev->emulated_config_bits[PCI_CAPABILITY_LIST] = 0xff; - vdev->emulated_config_bits[PCI_STATUS] |= PCI_STATUS_CAP_LIST; - } - - /* Use emulated next pointer to allow dropping caps */ - pci_set_byte(vdev->emulated_config_bits + pos + PCI_CAP_LIST_NEXT, 0xff); - - switch (cap_id) { - case PCI_CAP_ID_MSI: - ret = vfio_msi_setup(vdev, pos); - break; - case PCI_CAP_ID_EXP: - vfio_check_pcie_flr(vdev, pos); - ret = vfio_setup_pcie_cap(vdev, pos, size); - break; - case PCI_CAP_ID_MSIX: - ret = vfio_msix_setup(vdev, pos); - break; - case PCI_CAP_ID_PM: - vfio_check_pm_reset(vdev, pos); - vdev->pm_cap = pos; - ret = pci_add_capability(pdev, cap_id, pos, size); - break; - case PCI_CAP_ID_AF: - vfio_check_af_flr(vdev, pos); - ret = pci_add_capability(pdev, cap_id, pos, size); - break; - default: - ret = pci_add_capability(pdev, cap_id, pos, size); - break; - } - - if (ret < 0) { - error_report("vfio: %s Error adding PCI capability " - "0x%x[0x%x]@0x%x: %d", vdev->vbasedev.name, - cap_id, size, pos, ret); - return ret; - } - - return 0; -} - -static int vfio_add_capabilities(VFIOPCIDevice *vdev) -{ - PCIDevice *pdev = &vdev->pdev; - - if (!(pdev->config[PCI_STATUS] & PCI_STATUS_CAP_LIST) || - !pdev->config[PCI_CAPABILITY_LIST]) { - return 0; /* Nothing to add */ - } - - return vfio_add_std_cap(vdev, pdev->config[PCI_CAPABILITY_LIST]); -} - -static void vfio_pci_pre_reset(VFIOPCIDevice *vdev) -{ - PCIDevice *pdev = &vdev->pdev; - uint16_t cmd; - - vfio_disable_interrupts(vdev); - - /* Make sure the device is in D0 */ - if (vdev->pm_cap) { - uint16_t pmcsr; - uint8_t state; - - pmcsr = vfio_pci_read_config(pdev, vdev->pm_cap + PCI_PM_CTRL, 2); - state = pmcsr & PCI_PM_CTRL_STATE_MASK; - if (state) { - pmcsr &= ~PCI_PM_CTRL_STATE_MASK; - vfio_pci_write_config(pdev, vdev->pm_cap + PCI_PM_CTRL, pmcsr, 2); - /* vfio handles the necessary delay here */ - pmcsr = vfio_pci_read_config(pdev, vdev->pm_cap + PCI_PM_CTRL, 2); - state = pmcsr & PCI_PM_CTRL_STATE_MASK; - if (state) { - error_report("vfio: Unable to power on device, stuck in D%d", - state); - } - } - } - - /* - * Stop any ongoing DMA by disconecting I/O, MMIO, and bus master. - * Also put INTx Disable in known state. - */ - cmd = vfio_pci_read_config(pdev, PCI_COMMAND, 2); - cmd &= ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER | - PCI_COMMAND_INTX_DISABLE); - vfio_pci_write_config(pdev, PCI_COMMAND, cmd, 2); -} - -static void vfio_pci_post_reset(VFIOPCIDevice *vdev) -{ - vfio_intx_enable(vdev); -} - -static bool vfio_pci_host_match(PCIHostDeviceAddress *addr, const char *name) -{ - char tmp[13]; - - sprintf(tmp, "%04x:%02x:%02x.%1x", addr->domain, - addr->bus, addr->slot, addr->function); - - return (strcmp(tmp, name) == 0); -} - -static int vfio_pci_hot_reset(VFIOPCIDevice *vdev, bool single) -{ - VFIOGroup *group; - struct vfio_pci_hot_reset_info *info; - struct vfio_pci_dependent_device *devices; - struct vfio_pci_hot_reset *reset; - int32_t *fds; - int ret, i, count; - bool multi = false; - - trace_vfio_pci_hot_reset(vdev->vbasedev.name, single ? "one" : "multi"); - - vfio_pci_pre_reset(vdev); - vdev->vbasedev.needs_reset = false; - - info = g_malloc0(sizeof(*info)); - info->argsz = sizeof(*info); - - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_GET_PCI_HOT_RESET_INFO, info); - if (ret && errno != ENOSPC) { - ret = -errno; - if (!vdev->has_pm_reset) { - error_report("vfio: Cannot reset device %s, " - "no available reset mechanism.", vdev->vbasedev.name); - } - goto out_single; - } - - count = info->count; - info = g_realloc(info, sizeof(*info) + (count * sizeof(*devices))); - info->argsz = sizeof(*info) + (count * sizeof(*devices)); - devices = &info->devices[0]; - - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_GET_PCI_HOT_RESET_INFO, info); - if (ret) { - ret = -errno; - error_report("vfio: hot reset info failed: %m"); - goto out_single; - } - - trace_vfio_pci_hot_reset_has_dep_devices(vdev->vbasedev.name); - - /* Verify that we have all the groups required */ - for (i = 0; i < info->count; i++) { - PCIHostDeviceAddress host; - VFIOPCIDevice *tmp; - VFIODevice *vbasedev_iter; - - host.domain = devices[i].segment; - host.bus = devices[i].bus; - host.slot = PCI_SLOT(devices[i].devfn); - host.function = PCI_FUNC(devices[i].devfn); - - trace_vfio_pci_hot_reset_dep_devices(host.domain, - host.bus, host.slot, host.function, devices[i].group_id); - - if (vfio_pci_host_match(&host, vdev->vbasedev.name)) { - continue; - } - - QLIST_FOREACH(group, &vfio_group_list, next) { - if (group->groupid == devices[i].group_id) { - break; - } - } - - if (!group) { - if (!vdev->has_pm_reset) { - error_report("vfio: Cannot reset device %s, " - "depends on group %d which is not owned.", - vdev->vbasedev.name, devices[i].group_id); - } - ret = -EPERM; - goto out; - } - - /* Prep dependent devices for reset and clear our marker. */ - QLIST_FOREACH(vbasedev_iter, &group->device_list, next) { - if (vbasedev_iter->type != VFIO_DEVICE_TYPE_PCI) { - continue; - } - tmp = container_of(vbasedev_iter, VFIOPCIDevice, vbasedev); - if (vfio_pci_host_match(&host, tmp->vbasedev.name)) { - if (single) { - ret = -EINVAL; - goto out_single; - } - vfio_pci_pre_reset(tmp); - tmp->vbasedev.needs_reset = false; - multi = true; - break; - } - } - } - - if (!single && !multi) { - ret = -EINVAL; - goto out_single; - } - - /* Determine how many group fds need to be passed */ - count = 0; - QLIST_FOREACH(group, &vfio_group_list, next) { - for (i = 0; i < info->count; i++) { - if (group->groupid == devices[i].group_id) { - count++; - break; - } - } - } - - reset = g_malloc0(sizeof(*reset) + (count * sizeof(*fds))); - reset->argsz = sizeof(*reset) + (count * sizeof(*fds)); - fds = &reset->group_fds[0]; - - /* Fill in group fds */ - QLIST_FOREACH(group, &vfio_group_list, next) { - for (i = 0; i < info->count; i++) { - if (group->groupid == devices[i].group_id) { - fds[reset->count++] = group->fd; - break; - } - } - } - - /* Bus reset! */ - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_PCI_HOT_RESET, reset); - g_free(reset); - - trace_vfio_pci_hot_reset_result(vdev->vbasedev.name, - ret ? "%m" : "Success"); - -out: - /* Re-enable INTx on affected devices */ - for (i = 0; i < info->count; i++) { - PCIHostDeviceAddress host; - VFIOPCIDevice *tmp; - VFIODevice *vbasedev_iter; - - host.domain = devices[i].segment; - host.bus = devices[i].bus; - host.slot = PCI_SLOT(devices[i].devfn); - host.function = PCI_FUNC(devices[i].devfn); - - if (vfio_pci_host_match(&host, vdev->vbasedev.name)) { - continue; - } - - QLIST_FOREACH(group, &vfio_group_list, next) { - if (group->groupid == devices[i].group_id) { - break; - } - } - - if (!group) { - break; - } - - QLIST_FOREACH(vbasedev_iter, &group->device_list, next) { - if (vbasedev_iter->type != VFIO_DEVICE_TYPE_PCI) { - continue; - } - tmp = container_of(vbasedev_iter, VFIOPCIDevice, vbasedev); - if (vfio_pci_host_match(&host, tmp->vbasedev.name)) { - vfio_pci_post_reset(tmp); - break; - } - } - } -out_single: - vfio_pci_post_reset(vdev); - g_free(info); - - return ret; -} - -/* - * We want to differentiate hot reset of mulitple in-use devices vs hot reset - * of a single in-use device. VFIO_DEVICE_RESET will already handle the case - * of doing hot resets when there is only a single device per bus. The in-use - * here refers to how many VFIODevices are affected. A hot reset that affects - * multiple devices, but only a single in-use device, means that we can call - * it from our bus ->reset() callback since the extent is effectively a single - * device. This allows us to make use of it in the hotplug path. When there - * are multiple in-use devices, we can only trigger the hot reset during a - * system reset and thus from our reset handler. We separate _one vs _multi - * here so that we don't overlap and do a double reset on the system reset - * path where both our reset handler and ->reset() callback are used. Calling - * _one() will only do a hot reset for the one in-use devices case, calling - * _multi() will do nothing if a _one() would have been sufficient. - */ -static int vfio_pci_hot_reset_one(VFIOPCIDevice *vdev) -{ - return vfio_pci_hot_reset(vdev, true); -} - -static int vfio_pci_hot_reset_multi(VFIODevice *vbasedev) -{ - VFIOPCIDevice *vdev = container_of(vbasedev, VFIOPCIDevice, vbasedev); - return vfio_pci_hot_reset(vdev, false); -} - -static void vfio_pci_compute_needs_reset(VFIODevice *vbasedev) -{ - VFIOPCIDevice *vdev = container_of(vbasedev, VFIOPCIDevice, vbasedev); - if (!vbasedev->reset_works || (!vdev->has_flr && vdev->has_pm_reset)) { - vbasedev->needs_reset = true; - } -} - -static VFIODeviceOps vfio_pci_ops = { - .vfio_compute_needs_reset = vfio_pci_compute_needs_reset, - .vfio_hot_reset_multi = vfio_pci_hot_reset_multi, - .vfio_eoi = vfio_intx_eoi, -}; - -int vfio_populate_vga(VFIOPCIDevice *vdev) -{ - VFIODevice *vbasedev = &vdev->vbasedev; - struct vfio_region_info *reg_info; - int ret; - - if (vbasedev->num_regions > VFIO_PCI_VGA_REGION_INDEX) { - ret = vfio_get_region_info(vbasedev, - VFIO_PCI_VGA_REGION_INDEX, ®_info); - if (ret) { - return ret; - } - - if (!(reg_info->flags & VFIO_REGION_INFO_FLAG_READ) || - !(reg_info->flags & VFIO_REGION_INFO_FLAG_WRITE) || - reg_info->size < 0xbffff + 1) { - error_report("vfio: Unexpected VGA info, flags 0x%lx, size 0x%lx", - (unsigned long)reg_info->flags, - (unsigned long)reg_info->size); - g_free(reg_info); - return -EINVAL; - } - - vdev->vga = g_new0(VFIOVGA, 1); - - vdev->vga->fd_offset = reg_info->offset; - vdev->vga->fd = vdev->vbasedev.fd; - - g_free(reg_info); - - vdev->vga->region[QEMU_PCI_VGA_MEM].offset = QEMU_PCI_VGA_MEM_BASE; - vdev->vga->region[QEMU_PCI_VGA_MEM].nr = QEMU_PCI_VGA_MEM; - QLIST_INIT(&vdev->vga->region[QEMU_PCI_VGA_MEM].quirks); - - vdev->vga->region[QEMU_PCI_VGA_IO_LO].offset = QEMU_PCI_VGA_IO_LO_BASE; - vdev->vga->region[QEMU_PCI_VGA_IO_LO].nr = QEMU_PCI_VGA_IO_LO; - QLIST_INIT(&vdev->vga->region[QEMU_PCI_VGA_IO_LO].quirks); - - vdev->vga->region[QEMU_PCI_VGA_IO_HI].offset = QEMU_PCI_VGA_IO_HI_BASE; - vdev->vga->region[QEMU_PCI_VGA_IO_HI].nr = QEMU_PCI_VGA_IO_HI; - QLIST_INIT(&vdev->vga->region[QEMU_PCI_VGA_IO_HI].quirks); - } - - return 0; -} - -static int vfio_populate_device(VFIOPCIDevice *vdev) -{ - VFIODevice *vbasedev = &vdev->vbasedev; - struct vfio_region_info *reg_info; - struct vfio_irq_info irq_info = { .argsz = sizeof(irq_info) }; - int i, ret = -1; - - /* Sanity check device */ - if (!(vbasedev->flags & VFIO_DEVICE_FLAGS_PCI)) { - error_report("vfio: Um, this isn't a PCI device"); - goto error; - } - - if (vbasedev->num_regions < VFIO_PCI_CONFIG_REGION_INDEX + 1) { - error_report("vfio: unexpected number of io regions %u", - vbasedev->num_regions); - goto error; - } - - if (vbasedev->num_irqs < VFIO_PCI_MSIX_IRQ_INDEX + 1) { - error_report("vfio: unexpected number of irqs %u", vbasedev->num_irqs); - goto error; - } - - for (i = VFIO_PCI_BAR0_REGION_INDEX; i < VFIO_PCI_ROM_REGION_INDEX; i++) { - char *name = g_strdup_printf("%s BAR %d", vbasedev->name, i); - - ret = vfio_region_setup(OBJECT(vdev), vbasedev, - &vdev->bars[i].region, i, name); - g_free(name); - - if (ret) { - error_report("vfio: Error getting region %d info: %m", i); - goto error; - } - - QLIST_INIT(&vdev->bars[i].quirks); - } - - ret = vfio_get_region_info(vbasedev, - VFIO_PCI_CONFIG_REGION_INDEX, ®_info); - if (ret) { - error_report("vfio: Error getting config info: %m"); - goto error; - } - - trace_vfio_populate_device_config(vdev->vbasedev.name, - (unsigned long)reg_info->size, - (unsigned long)reg_info->offset, - (unsigned long)reg_info->flags); - - vdev->config_size = reg_info->size; - if (vdev->config_size == PCI_CONFIG_SPACE_SIZE) { - vdev->pdev.cap_present &= ~QEMU_PCI_CAP_EXPRESS; - } - vdev->config_offset = reg_info->offset; - - g_free(reg_info); - - if (vdev->features & VFIO_FEATURE_ENABLE_VGA) { - ret = vfio_populate_vga(vdev); - if (ret) { - error_report( - "vfio: Device does not support requested feature x-vga"); - goto error; - } - } - - irq_info.index = VFIO_PCI_ERR_IRQ_INDEX; - - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_GET_IRQ_INFO, &irq_info); - if (ret) { - /* This can fail for an old kernel or legacy PCI dev */ - trace_vfio_populate_device_get_irq_info_failure(); - ret = 0; - } else if (irq_info.count == 1) { - vdev->pci_aer = true; - } else { - error_report("vfio: %s " - "Could not enable error recovery for the device", - vbasedev->name); - } - -error: - return ret; -} - -static void vfio_put_device(VFIOPCIDevice *vdev) -{ - g_free(vdev->vbasedev.name); - g_free(vdev->msix); - - vfio_put_base_device(&vdev->vbasedev); -} - -static void vfio_err_notifier_handler(void *opaque) -{ - VFIOPCIDevice *vdev = opaque; - - if (!event_notifier_test_and_clear(&vdev->err_notifier)) { - return; - } - - /* - * TBD. Retrieve the error details and decide what action - * needs to be taken. One of the actions could be to pass - * the error to the guest and have the guest driver recover - * from the error. This requires that PCIe capabilities be - * exposed to the guest. For now, we just terminate the - * guest to contain the error. - */ - - error_report("%s(%s) Unrecoverable error detected. Please collect any data possible and then kill the guest", __func__, vdev->vbasedev.name); - - vm_stop(RUN_STATE_INTERNAL_ERROR); -} - -/* - * Registers error notifier for devices supporting error recovery. - * If we encounter a failure in this function, we report an error - * and continue after disabling error recovery support for the - * device. - */ -static void vfio_register_err_notifier(VFIOPCIDevice *vdev) -{ - int ret; - int argsz; - struct vfio_irq_set *irq_set; - int32_t *pfd; - - if (!vdev->pci_aer) { - return; - } - - if (event_notifier_init(&vdev->err_notifier, 0)) { - error_report("vfio: Unable to init event notifier for error detection"); - vdev->pci_aer = false; - return; - } - - argsz = sizeof(*irq_set) + sizeof(*pfd); - - irq_set = g_malloc0(argsz); - irq_set->argsz = argsz; - irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | - VFIO_IRQ_SET_ACTION_TRIGGER; - irq_set->index = VFIO_PCI_ERR_IRQ_INDEX; - irq_set->start = 0; - irq_set->count = 1; - pfd = (int32_t *)&irq_set->data; - - *pfd = event_notifier_get_fd(&vdev->err_notifier); - qemu_set_fd_handler(*pfd, vfio_err_notifier_handler, NULL, vdev); - - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_SET_IRQS, irq_set); - if (ret) { - error_report("vfio: Failed to set up error notification"); - qemu_set_fd_handler(*pfd, NULL, NULL, vdev); - event_notifier_cleanup(&vdev->err_notifier); - vdev->pci_aer = false; - } - g_free(irq_set); -} - -static void vfio_unregister_err_notifier(VFIOPCIDevice *vdev) -{ - int argsz; - struct vfio_irq_set *irq_set; - int32_t *pfd; - int ret; - - if (!vdev->pci_aer) { - return; - } - - argsz = sizeof(*irq_set) + sizeof(*pfd); - - irq_set = g_malloc0(argsz); - irq_set->argsz = argsz; - irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | - VFIO_IRQ_SET_ACTION_TRIGGER; - irq_set->index = VFIO_PCI_ERR_IRQ_INDEX; - irq_set->start = 0; - irq_set->count = 1; - pfd = (int32_t *)&irq_set->data; - *pfd = -1; - - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_SET_IRQS, irq_set); - if (ret) { - error_report("vfio: Failed to de-assign error fd: %m"); - } - g_free(irq_set); - qemu_set_fd_handler(event_notifier_get_fd(&vdev->err_notifier), - NULL, NULL, vdev); - event_notifier_cleanup(&vdev->err_notifier); -} - -static void vfio_req_notifier_handler(void *opaque) -{ - VFIOPCIDevice *vdev = opaque; - - if (!event_notifier_test_and_clear(&vdev->req_notifier)) { - return; - } - - qdev_unplug(&vdev->pdev.qdev, NULL); -} - -static void vfio_register_req_notifier(VFIOPCIDevice *vdev) -{ - struct vfio_irq_info irq_info = { .argsz = sizeof(irq_info), - .index = VFIO_PCI_REQ_IRQ_INDEX }; - int argsz; - struct vfio_irq_set *irq_set; - int32_t *pfd; - - if (!(vdev->features & VFIO_FEATURE_ENABLE_REQ)) { - return; - } - - if (ioctl(vdev->vbasedev.fd, - VFIO_DEVICE_GET_IRQ_INFO, &irq_info) < 0 || irq_info.count < 1) { - return; - } - - if (event_notifier_init(&vdev->req_notifier, 0)) { - error_report("vfio: Unable to init event notifier for device request"); - return; - } - - argsz = sizeof(*irq_set) + sizeof(*pfd); - - irq_set = g_malloc0(argsz); - irq_set->argsz = argsz; - irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | - VFIO_IRQ_SET_ACTION_TRIGGER; - irq_set->index = VFIO_PCI_REQ_IRQ_INDEX; - irq_set->start = 0; - irq_set->count = 1; - pfd = (int32_t *)&irq_set->data; - - *pfd = event_notifier_get_fd(&vdev->req_notifier); - qemu_set_fd_handler(*pfd, vfio_req_notifier_handler, NULL, vdev); - - if (ioctl(vdev->vbasedev.fd, VFIO_DEVICE_SET_IRQS, irq_set)) { - error_report("vfio: Failed to set up device request notification"); - qemu_set_fd_handler(*pfd, NULL, NULL, vdev); - event_notifier_cleanup(&vdev->req_notifier); - } else { - vdev->req_enabled = true; - } - - g_free(irq_set); -} - -static void vfio_unregister_req_notifier(VFIOPCIDevice *vdev) -{ - int argsz; - struct vfio_irq_set *irq_set; - int32_t *pfd; - - if (!vdev->req_enabled) { - return; - } - - argsz = sizeof(*irq_set) + sizeof(*pfd); - - irq_set = g_malloc0(argsz); - irq_set->argsz = argsz; - irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | - VFIO_IRQ_SET_ACTION_TRIGGER; - irq_set->index = VFIO_PCI_REQ_IRQ_INDEX; - irq_set->start = 0; - irq_set->count = 1; - pfd = (int32_t *)&irq_set->data; - *pfd = -1; - - if (ioctl(vdev->vbasedev.fd, VFIO_DEVICE_SET_IRQS, irq_set)) { - error_report("vfio: Failed to de-assign device request fd: %m"); - } - g_free(irq_set); - qemu_set_fd_handler(event_notifier_get_fd(&vdev->req_notifier), - NULL, NULL, vdev); - event_notifier_cleanup(&vdev->req_notifier); - - vdev->req_enabled = false; -} - -static int vfio_initfn(PCIDevice *pdev) -{ - VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev); - VFIODevice *vbasedev_iter; - VFIOGroup *group; - char *tmp, group_path[PATH_MAX], *group_name; - ssize_t len; - struct stat st; - int groupid; - int ret; - - if (!vdev->vbasedev.sysfsdev) { - vdev->vbasedev.sysfsdev = - g_strdup_printf("/sys/bus/pci/devices/%04x:%02x:%02x.%01x", - vdev->host.domain, vdev->host.bus, - vdev->host.slot, vdev->host.function); - } - - if (stat(vdev->vbasedev.sysfsdev, &st) < 0) { - error_report("vfio: error: no such host device: %s", - vdev->vbasedev.sysfsdev); - return -errno; - } - - vdev->vbasedev.name = g_strdup(basename(vdev->vbasedev.sysfsdev)); - vdev->vbasedev.ops = &vfio_pci_ops; - vdev->vbasedev.type = VFIO_DEVICE_TYPE_PCI; - - tmp = g_strdup_printf("%s/iommu_group", vdev->vbasedev.sysfsdev); - len = readlink(tmp, group_path, sizeof(group_path)); - g_free(tmp); - - if (len <= 0 || len >= sizeof(group_path)) { - error_report("vfio: error no iommu_group for device"); - return len < 0 ? -errno : -ENAMETOOLONG; - } - - group_path[len] = 0; - - group_name = basename(group_path); - if (sscanf(group_name, "%d", &groupid) != 1) { - error_report("vfio: error reading %s: %m", group_path); - return -errno; - } - - trace_vfio_initfn(vdev->vbasedev.name, groupid); - - group = vfio_get_group(groupid, pci_device_iommu_address_space(pdev)); - if (!group) { - error_report("vfio: failed to get group %d", groupid); - return -ENOENT; - } - - QLIST_FOREACH(vbasedev_iter, &group->device_list, next) { - if (strcmp(vbasedev_iter->name, vdev->vbasedev.name) == 0) { - error_report("vfio: error: device %s is already attached", - vdev->vbasedev.name); - vfio_put_group(group); - return -EBUSY; - } - } - - ret = vfio_get_device(group, vdev->vbasedev.name, &vdev->vbasedev); - if (ret) { - error_report("vfio: failed to get device %s", vdev->vbasedev.name); - vfio_put_group(group); - return ret; - } - - ret = vfio_populate_device(vdev); - if (ret) { - return ret; - } - - /* Get a copy of config space */ - ret = pread(vdev->vbasedev.fd, vdev->pdev.config, - MIN(pci_config_size(&vdev->pdev), vdev->config_size), - vdev->config_offset); - if (ret < (int)MIN(pci_config_size(&vdev->pdev), vdev->config_size)) { - ret = ret < 0 ? -errno : -EFAULT; - error_report("vfio: Failed to read device config space"); - return ret; - } - - /* vfio emulates a lot for us, but some bits need extra love */ - vdev->emulated_config_bits = g_malloc0(vdev->config_size); - - /* QEMU can choose to expose the ROM or not */ - memset(vdev->emulated_config_bits + PCI_ROM_ADDRESS, 0xff, 4); - - /* - * The PCI spec reserves vendor ID 0xffff as an invalid value. The - * device ID is managed by the vendor and need only be a 16-bit value. - * Allow any 16-bit value for subsystem so they can be hidden or changed. - */ - if (vdev->vendor_id != PCI_ANY_ID) { - if (vdev->vendor_id >= 0xffff) { - error_report("vfio: Invalid PCI vendor ID provided"); - return -EINVAL; - } - vfio_add_emulated_word(vdev, PCI_VENDOR_ID, vdev->vendor_id, ~0); - trace_vfio_pci_emulated_vendor_id(vdev->vbasedev.name, vdev->vendor_id); - } else { - vdev->vendor_id = pci_get_word(pdev->config + PCI_VENDOR_ID); - } - - if (vdev->device_id != PCI_ANY_ID) { - if (vdev->device_id > 0xffff) { - error_report("vfio: Invalid PCI device ID provided"); - return -EINVAL; - } - vfio_add_emulated_word(vdev, PCI_DEVICE_ID, vdev->device_id, ~0); - trace_vfio_pci_emulated_device_id(vdev->vbasedev.name, vdev->device_id); - } else { - vdev->device_id = pci_get_word(pdev->config + PCI_DEVICE_ID); - } - - if (vdev->sub_vendor_id != PCI_ANY_ID) { - if (vdev->sub_vendor_id > 0xffff) { - error_report("vfio: Invalid PCI subsystem vendor ID provided"); - return -EINVAL; - } - vfio_add_emulated_word(vdev, PCI_SUBSYSTEM_VENDOR_ID, - vdev->sub_vendor_id, ~0); - trace_vfio_pci_emulated_sub_vendor_id(vdev->vbasedev.name, - vdev->sub_vendor_id); - } - - if (vdev->sub_device_id != PCI_ANY_ID) { - if (vdev->sub_device_id > 0xffff) { - error_report("vfio: Invalid PCI subsystem device ID provided"); - return -EINVAL; - } - vfio_add_emulated_word(vdev, PCI_SUBSYSTEM_ID, vdev->sub_device_id, ~0); - trace_vfio_pci_emulated_sub_device_id(vdev->vbasedev.name, - vdev->sub_device_id); - } - - /* QEMU can change multi-function devices to single function, or reverse */ - vdev->emulated_config_bits[PCI_HEADER_TYPE] = - PCI_HEADER_TYPE_MULTI_FUNCTION; - - /* Restore or clear multifunction, this is always controlled by QEMU */ - if (vdev->pdev.cap_present & QEMU_PCI_CAP_MULTIFUNCTION) { - vdev->pdev.config[PCI_HEADER_TYPE] |= PCI_HEADER_TYPE_MULTI_FUNCTION; - } else { - vdev->pdev.config[PCI_HEADER_TYPE] &= ~PCI_HEADER_TYPE_MULTI_FUNCTION; - } - - /* - * Clear host resource mapping info. If we choose not to register a - * BAR, such as might be the case with the option ROM, we can get - * confusing, unwritable, residual addresses from the host here. - */ - memset(&vdev->pdev.config[PCI_BASE_ADDRESS_0], 0, 24); - memset(&vdev->pdev.config[PCI_ROM_ADDRESS], 0, 4); - - vfio_pci_size_rom(vdev); - - ret = vfio_msix_early_setup(vdev); - if (ret) { - return ret; - } - - vfio_bars_setup(vdev); - - ret = vfio_add_capabilities(vdev); - if (ret) { - goto out_teardown; - } - - /* QEMU emulates all of MSI & MSIX */ - if (pdev->cap_present & QEMU_PCI_CAP_MSIX) { - memset(vdev->emulated_config_bits + pdev->msix_cap, 0xff, - MSIX_CAP_LENGTH); - } - - if (pdev->cap_present & QEMU_PCI_CAP_MSI) { - memset(vdev->emulated_config_bits + pdev->msi_cap, 0xff, - vdev->msi_cap_size); - } - - if (vfio_pci_read_config(&vdev->pdev, PCI_INTERRUPT_PIN, 1)) { - vdev->intx.mmap_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, - vfio_intx_mmap_enable, vdev); - pci_device_set_intx_routing_notifier(&vdev->pdev, vfio_intx_update); - ret = vfio_intx_enable(vdev); - if (ret) { - goto out_teardown; - } - } - - vfio_register_err_notifier(vdev); - vfio_register_req_notifier(vdev); - vfio_setup_resetfn_quirk(vdev); - - return 0; - -out_teardown: - pci_device_set_intx_routing_notifier(&vdev->pdev, NULL); - vfio_teardown_msi(vdev); - vfio_bars_exit(vdev); - return ret; -} - -static void vfio_instance_finalize(Object *obj) -{ - PCIDevice *pci_dev = PCI_DEVICE(obj); - VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pci_dev); - VFIOGroup *group = vdev->vbasedev.group; - - vfio_bars_finalize(vdev); - g_free(vdev->emulated_config_bits); - g_free(vdev->rom); - vfio_put_device(vdev); - vfio_put_group(group); -} - -static void vfio_exitfn(PCIDevice *pdev) -{ - VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev); - - vfio_unregister_req_notifier(vdev); - vfio_unregister_err_notifier(vdev); - pci_device_set_intx_routing_notifier(&vdev->pdev, NULL); - vfio_disable_interrupts(vdev); - if (vdev->intx.mmap_timer) { - timer_free(vdev->intx.mmap_timer); - } - vfio_teardown_msi(vdev); - vfio_bars_exit(vdev); -} - -static void vfio_pci_reset(DeviceState *dev) -{ - PCIDevice *pdev = DO_UPCAST(PCIDevice, qdev, dev); - VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev); - - trace_vfio_pci_reset(vdev->vbasedev.name); - - vfio_pci_pre_reset(vdev); - - if (vdev->resetfn && !vdev->resetfn(vdev)) { - goto post_reset; - } - - if (vdev->vbasedev.reset_works && - (vdev->has_flr || !vdev->has_pm_reset) && - !ioctl(vdev->vbasedev.fd, VFIO_DEVICE_RESET)) { - trace_vfio_pci_reset_flr(vdev->vbasedev.name); - goto post_reset; - } - - /* See if we can do our own bus reset */ - if (!vfio_pci_hot_reset_one(vdev)) { - goto post_reset; - } - - /* If nothing else works and the device supports PM reset, use it */ - if (vdev->vbasedev.reset_works && vdev->has_pm_reset && - !ioctl(vdev->vbasedev.fd, VFIO_DEVICE_RESET)) { - trace_vfio_pci_reset_pm(vdev->vbasedev.name); - goto post_reset; - } - -post_reset: - vfio_pci_post_reset(vdev); -} - -static void vfio_instance_init(Object *obj) -{ - PCIDevice *pci_dev = PCI_DEVICE(obj); - VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, PCI_DEVICE(obj)); - - device_add_bootindex_property(obj, &vdev->bootindex, - "bootindex", NULL, - &pci_dev->qdev, NULL); -} - -static Property vfio_pci_dev_properties[] = { - DEFINE_PROP_PCI_HOST_DEVADDR("host", VFIOPCIDevice, host), - DEFINE_PROP_STRING("sysfsdev", VFIOPCIDevice, vbasedev.sysfsdev), - DEFINE_PROP_UINT32("x-intx-mmap-timeout-ms", VFIOPCIDevice, - intx.mmap_timeout, 1100), - DEFINE_PROP_BIT("x-vga", VFIOPCIDevice, features, - VFIO_FEATURE_ENABLE_VGA_BIT, false), - DEFINE_PROP_BIT("x-req", VFIOPCIDevice, features, - VFIO_FEATURE_ENABLE_REQ_BIT, true), - DEFINE_PROP_BOOL("x-no-mmap", VFIOPCIDevice, vbasedev.no_mmap, false), - DEFINE_PROP_BOOL("x-no-kvm-intx", VFIOPCIDevice, no_kvm_intx, false), - DEFINE_PROP_BOOL("x-no-kvm-msi", VFIOPCIDevice, no_kvm_msi, false), - DEFINE_PROP_BOOL("x-no-kvm-msix", VFIOPCIDevice, no_kvm_msix, false), - DEFINE_PROP_UINT32("x-pci-vendor-id", VFIOPCIDevice, vendor_id, PCI_ANY_ID), - DEFINE_PROP_UINT32("x-pci-device-id", VFIOPCIDevice, device_id, PCI_ANY_ID), - DEFINE_PROP_UINT32("x-pci-sub-vendor-id", VFIOPCIDevice, - sub_vendor_id, PCI_ANY_ID), - DEFINE_PROP_UINT32("x-pci-sub-device-id", VFIOPCIDevice, - sub_device_id, PCI_ANY_ID), - /* - * TODO - support passed fds... is this necessary? - * DEFINE_PROP_STRING("vfiofd", VFIOPCIDevice, vfiofd_name), - * DEFINE_PROP_STRING("vfiogroupfd, VFIOPCIDevice, vfiogroupfd_name), - */ - DEFINE_PROP_END_OF_LIST(), -}; - -static const VMStateDescription vfio_pci_vmstate = { - .name = "vfio-pci", - .unmigratable = 1, -}; - -static void vfio_pci_dev_class_init(ObjectClass *klass, void *data) -{ - DeviceClass *dc = DEVICE_CLASS(klass); - PCIDeviceClass *pdc = PCI_DEVICE_CLASS(klass); - - dc->reset = vfio_pci_reset; - dc->props = vfio_pci_dev_properties; - dc->vmsd = &vfio_pci_vmstate; - dc->desc = "VFIO-based PCI device assignment"; - set_bit(DEVICE_CATEGORY_MISC, dc->categories); - pdc->init = vfio_initfn; - pdc->exit = vfio_exitfn; - pdc->config_read = vfio_pci_read_config; - pdc->config_write = vfio_pci_write_config; - pdc->is_express = 1; /* We might be */ -} - -static const TypeInfo vfio_pci_dev_info = { - .name = "vfio-pci", - .parent = TYPE_PCI_DEVICE, - .instance_size = sizeof(VFIOPCIDevice), - .class_init = vfio_pci_dev_class_init, - .instance_init = vfio_instance_init, - .instance_finalize = vfio_instance_finalize, -}; - -static void register_vfio_pci_dev_type(void) -{ - type_register_static(&vfio_pci_dev_info); -} - -type_init(register_vfio_pci_dev_type) diff --git a/qemu/hw/vfio/pci.h b/qemu/hw/vfio/pci.h deleted file mode 100644 index 3976f6854..000000000 --- a/qemu/hw/vfio/pci.h +++ /dev/null @@ -1,162 +0,0 @@ -/* - * vfio based device assignment support - PCI devices - * - * Copyright Red Hat, Inc. 2012-2015 - * - * Authors: - * Alex Williamson <alex.williamson@redhat.com> - * - * This work is licensed under the terms of the GNU GPL, version 2. See - * the COPYING file in the top-level directory. - */ -#ifndef HW_VFIO_VFIO_PCI_H -#define HW_VFIO_VFIO_PCI_H - -#include "qemu-common.h" -#include "exec/memory.h" -#include "hw/pci/pci.h" -#include "hw/vfio/vfio-common.h" -#include "qemu/event_notifier.h" -#include "qemu/queue.h" -#include "qemu/timer.h" - -#define PCI_ANY_ID (~0) - -struct VFIOPCIDevice; - -typedef struct VFIOQuirk { - QLIST_ENTRY(VFIOQuirk) next; - void *data; - int nr_mem; - MemoryRegion *mem; -} VFIOQuirk; - -typedef struct VFIOBAR { - VFIORegion region; - bool ioport; - bool mem64; - QLIST_HEAD(, VFIOQuirk) quirks; -} VFIOBAR; - -typedef struct VFIOVGARegion { - MemoryRegion mem; - off_t offset; - int nr; - QLIST_HEAD(, VFIOQuirk) quirks; -} VFIOVGARegion; - -typedef struct VFIOVGA { - off_t fd_offset; - int fd; - VFIOVGARegion region[QEMU_PCI_VGA_NUM_REGIONS]; -} VFIOVGA; - -typedef struct VFIOINTx { - bool pending; /* interrupt pending */ - bool kvm_accel; /* set when QEMU bypass through KVM enabled */ - uint8_t pin; /* which pin to pull for qemu_set_irq */ - EventNotifier interrupt; /* eventfd triggered on interrupt */ - EventNotifier unmask; /* eventfd for unmask on QEMU bypass */ - PCIINTxRoute route; /* routing info for QEMU bypass */ - uint32_t mmap_timeout; /* delay to re-enable mmaps after interrupt */ - QEMUTimer *mmap_timer; /* enable mmaps after periods w/o interrupts */ -} VFIOINTx; - -typedef struct VFIOMSIVector { - /* - * Two interrupt paths are configured per vector. The first, is only used - * for interrupts injected via QEMU. This is typically the non-accel path, - * but may also be used when we want QEMU to handle masking and pending - * bits. The KVM path bypasses QEMU and is therefore higher performance, - * but requires masking at the device. virq is used to track the MSI route - * through KVM, thus kvm_interrupt is only available when virq is set to a - * valid (>= 0) value. - */ - EventNotifier interrupt; - EventNotifier kvm_interrupt; - struct VFIOPCIDevice *vdev; /* back pointer to device */ - int virq; - bool use; -} VFIOMSIVector; - -enum { - VFIO_INT_NONE = 0, - VFIO_INT_INTx = 1, - VFIO_INT_MSI = 2, - VFIO_INT_MSIX = 3, -}; - -/* Cache of MSI-X setup plus extra mmap and memory region for split BAR map */ -typedef struct VFIOMSIXInfo { - uint8_t table_bar; - uint8_t pba_bar; - uint16_t entries; - uint32_t table_offset; - uint32_t pba_offset; - MemoryRegion mmap_mem; - void *mmap; - unsigned long *pending; -} VFIOMSIXInfo; - -typedef struct VFIOPCIDevice { - PCIDevice pdev; - VFIODevice vbasedev; - VFIOINTx intx; - unsigned int config_size; - uint8_t *emulated_config_bits; /* QEMU emulated bits, little-endian */ - off_t config_offset; /* Offset of config space region within device fd */ - unsigned int rom_size; - off_t rom_offset; /* Offset of ROM region within device fd */ - void *rom; - int msi_cap_size; - VFIOMSIVector *msi_vectors; - VFIOMSIXInfo *msix; - int nr_vectors; /* Number of MSI/MSIX vectors currently in use */ - int interrupt; /* Current interrupt type */ - VFIOBAR bars[PCI_NUM_REGIONS - 1]; /* No ROM */ - VFIOVGA *vga; /* 0xa0000, 0x3b0, 0x3c0 */ - PCIHostDeviceAddress host; - EventNotifier err_notifier; - EventNotifier req_notifier; - int (*resetfn)(struct VFIOPCIDevice *); - uint32_t vendor_id; - uint32_t device_id; - uint32_t sub_vendor_id; - uint32_t sub_device_id; - uint32_t features; -#define VFIO_FEATURE_ENABLE_VGA_BIT 0 -#define VFIO_FEATURE_ENABLE_VGA (1 << VFIO_FEATURE_ENABLE_VGA_BIT) -#define VFIO_FEATURE_ENABLE_REQ_BIT 1 -#define VFIO_FEATURE_ENABLE_REQ (1 << VFIO_FEATURE_ENABLE_REQ_BIT) - int32_t bootindex; - uint8_t pm_cap; - bool has_vga; - bool pci_aer; - bool req_enabled; - bool has_flr; - bool has_pm_reset; - bool rom_read_failed; - bool no_kvm_intx; - bool no_kvm_msi; - bool no_kvm_msix; -} VFIOPCIDevice; - -uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len); -void vfio_pci_write_config(PCIDevice *pdev, - uint32_t addr, uint32_t val, int len); - -uint64_t vfio_vga_read(void *opaque, hwaddr addr, unsigned size); -void vfio_vga_write(void *opaque, hwaddr addr, uint64_t data, unsigned size); - -bool vfio_blacklist_opt_rom(VFIOPCIDevice *vdev); -void vfio_vga_quirk_setup(VFIOPCIDevice *vdev); -void vfio_vga_quirk_exit(VFIOPCIDevice *vdev); -void vfio_vga_quirk_finalize(VFIOPCIDevice *vdev); -void vfio_bar_quirk_setup(VFIOPCIDevice *vdev, int nr); -void vfio_bar_quirk_exit(VFIOPCIDevice *vdev, int nr); -void vfio_bar_quirk_finalize(VFIOPCIDevice *vdev, int nr); -void vfio_setup_resetfn_quirk(VFIOPCIDevice *vdev); - -int vfio_populate_vga(VFIOPCIDevice *vdev); - -#endif /* HW_VFIO_VFIO_PCI_H */ diff --git a/qemu/hw/vfio/platform.c b/qemu/hw/vfio/platform.c deleted file mode 100644 index 1798a00a3..000000000 --- a/qemu/hw/vfio/platform.c +++ /dev/null @@ -1,705 +0,0 @@ -/* - * vfio based device assignment support - platform devices - * - * Copyright Linaro Limited, 2014 - * - * Authors: - * Kim Phillips <kim.phillips@linaro.org> - * Eric Auger <eric.auger@linaro.org> - * - * This work is licensed under the terms of the GNU GPL, version 2. See - * the COPYING file in the top-level directory. - * - * Based on vfio based PCI device assignment support: - * Copyright Red Hat, Inc. 2012 - */ - -#include "qemu/osdep.h" -#include "qapi/error.h" -#include <sys/ioctl.h> -#include <linux/vfio.h> - -#include "hw/vfio/vfio-platform.h" -#include "qemu/error-report.h" -#include "qemu/range.h" -#include "sysemu/sysemu.h" -#include "exec/memory.h" -#include "qemu/queue.h" -#include "hw/sysbus.h" -#include "trace.h" -#include "hw/platform-bus.h" -#include "sysemu/kvm.h" - -/* - * Functions used whatever the injection method - */ - -static inline bool vfio_irq_is_automasked(VFIOINTp *intp) -{ - return intp->flags & VFIO_IRQ_INFO_AUTOMASKED; -} - -/** - * vfio_init_intp - allocate, initialize the IRQ struct pointer - * and add it into the list of IRQs - * @vbasedev: the VFIO device handle - * @info: irq info struct retrieved from VFIO driver - */ -static VFIOINTp *vfio_init_intp(VFIODevice *vbasedev, - struct vfio_irq_info info) -{ - int ret; - VFIOPlatformDevice *vdev = - container_of(vbasedev, VFIOPlatformDevice, vbasedev); - SysBusDevice *sbdev = SYS_BUS_DEVICE(vdev); - VFIOINTp *intp; - - intp = g_malloc0(sizeof(*intp)); - intp->vdev = vdev; - intp->pin = info.index; - intp->flags = info.flags; - intp->state = VFIO_IRQ_INACTIVE; - intp->kvm_accel = false; - - sysbus_init_irq(sbdev, &intp->qemuirq); - - /* Get an eventfd for trigger */ - intp->interrupt = g_malloc0(sizeof(EventNotifier)); - ret = event_notifier_init(intp->interrupt, 0); - if (ret) { - g_free(intp->interrupt); - g_free(intp); - error_report("vfio: Error: trigger event_notifier_init failed "); - return NULL; - } - if (vfio_irq_is_automasked(intp)) { - /* Get an eventfd for resample/unmask */ - intp->unmask = g_malloc0(sizeof(EventNotifier)); - ret = event_notifier_init(intp->unmask, 0); - if (ret) { - g_free(intp->interrupt); - g_free(intp->unmask); - g_free(intp); - error_report("vfio: Error: resamplefd event_notifier_init failed"); - return NULL; - } - } - - QLIST_INSERT_HEAD(&vdev->intp_list, intp, next); - return intp; -} - -/** - * vfio_set_trigger_eventfd - set VFIO eventfd handling - * - * @intp: IRQ struct handle - * @handler: handler to be called on eventfd signaling - * - * Setup VFIO signaling and attach an optional user-side handler - * to the eventfd - */ -static int vfio_set_trigger_eventfd(VFIOINTp *intp, - eventfd_user_side_handler_t handler) -{ - VFIODevice *vbasedev = &intp->vdev->vbasedev; - struct vfio_irq_set *irq_set; - int argsz, ret; - int32_t *pfd; - - argsz = sizeof(*irq_set) + sizeof(*pfd); - irq_set = g_malloc0(argsz); - irq_set->argsz = argsz; - irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | VFIO_IRQ_SET_ACTION_TRIGGER; - irq_set->index = intp->pin; - irq_set->start = 0; - irq_set->count = 1; - pfd = (int32_t *)&irq_set->data; - *pfd = event_notifier_get_fd(intp->interrupt); - qemu_set_fd_handler(*pfd, (IOHandler *)handler, NULL, intp); - ret = ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, irq_set); - g_free(irq_set); - if (ret < 0) { - error_report("vfio: Failed to set trigger eventfd: %m"); - qemu_set_fd_handler(*pfd, NULL, NULL, NULL); - } - return ret; -} - -/* - * Functions only used when eventfds are handled on user-side - * ie. without irqfd - */ - -/** - * vfio_mmap_set_enabled - enable/disable the fast path mode - * @vdev: the VFIO platform device - * @enabled: the target mmap state - * - * enabled = true ~ fast path = MMIO region is mmaped (no KVM TRAP); - * enabled = false ~ slow path = MMIO region is trapped and region callbacks - * are called; slow path enables to trap the device IRQ status register reset -*/ - -static void vfio_mmap_set_enabled(VFIOPlatformDevice *vdev, bool enabled) -{ - int i; - - for (i = 0; i < vdev->vbasedev.num_regions; i++) { - vfio_region_mmaps_set_enabled(vdev->regions[i], enabled); - } -} - -/** - * vfio_intp_mmap_enable - timer function, restores the fast path - * if there is no more active IRQ - * @opaque: actually points to the VFIO platform device - * - * Called on mmap timer timout, this function checks whether the - * IRQ is still active and if not, restores the fast path. - * by construction a single eventfd is handled at a time. - * if the IRQ is still active, the timer is re-programmed. - */ -static void vfio_intp_mmap_enable(void *opaque) -{ - VFIOINTp *tmp; - VFIOPlatformDevice *vdev = (VFIOPlatformDevice *)opaque; - - qemu_mutex_lock(&vdev->intp_mutex); - QLIST_FOREACH(tmp, &vdev->intp_list, next) { - if (tmp->state == VFIO_IRQ_ACTIVE) { - trace_vfio_platform_intp_mmap_enable(tmp->pin); - /* re-program the timer to check active status later */ - timer_mod(vdev->mmap_timer, - qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + - vdev->mmap_timeout); - qemu_mutex_unlock(&vdev->intp_mutex); - return; - } - } - vfio_mmap_set_enabled(vdev, true); - qemu_mutex_unlock(&vdev->intp_mutex); -} - -/** - * vfio_intp_inject_pending_lockheld - Injects a pending IRQ - * @opaque: opaque pointer, in practice the VFIOINTp handle - * - * The function is called on a previous IRQ completion, from - * vfio_platform_eoi, while the intp_mutex is locked. - * Also in such situation, the slow path already is set and - * the mmap timer was already programmed. - */ -static void vfio_intp_inject_pending_lockheld(VFIOINTp *intp) -{ - trace_vfio_platform_intp_inject_pending_lockheld(intp->pin, - event_notifier_get_fd(intp->interrupt)); - - intp->state = VFIO_IRQ_ACTIVE; - - /* trigger the virtual IRQ */ - qemu_set_irq(intp->qemuirq, 1); -} - -/** - * vfio_intp_interrupt - The user-side eventfd handler - * @opaque: opaque pointer which in practice is the VFIOINTp handle - * - * the function is entered in event handler context: - * the vIRQ is injected into the guest if there is no other active - * or pending IRQ. - */ -static void vfio_intp_interrupt(VFIOINTp *intp) -{ - int ret; - VFIOINTp *tmp; - VFIOPlatformDevice *vdev = intp->vdev; - bool delay_handling = false; - - qemu_mutex_lock(&vdev->intp_mutex); - if (intp->state == VFIO_IRQ_INACTIVE) { - QLIST_FOREACH(tmp, &vdev->intp_list, next) { - if (tmp->state == VFIO_IRQ_ACTIVE || - tmp->state == VFIO_IRQ_PENDING) { - delay_handling = true; - break; - } - } - } - if (delay_handling) { - /* - * the new IRQ gets a pending status and is pushed in - * the pending queue - */ - intp->state = VFIO_IRQ_PENDING; - trace_vfio_intp_interrupt_set_pending(intp->pin); - QSIMPLEQ_INSERT_TAIL(&vdev->pending_intp_queue, - intp, pqnext); - ret = event_notifier_test_and_clear(intp->interrupt); - qemu_mutex_unlock(&vdev->intp_mutex); - return; - } - - trace_vfio_platform_intp_interrupt(intp->pin, - event_notifier_get_fd(intp->interrupt)); - - ret = event_notifier_test_and_clear(intp->interrupt); - if (!ret) { - error_report("Error when clearing fd=%d (ret = %d)", - event_notifier_get_fd(intp->interrupt), ret); - } - - intp->state = VFIO_IRQ_ACTIVE; - - /* sets slow path */ - vfio_mmap_set_enabled(vdev, false); - - /* trigger the virtual IRQ */ - qemu_set_irq(intp->qemuirq, 1); - - /* - * Schedule the mmap timer which will restore fastpath when no IRQ - * is active anymore - */ - if (vdev->mmap_timeout) { - timer_mod(vdev->mmap_timer, - qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + - vdev->mmap_timeout); - } - qemu_mutex_unlock(&vdev->intp_mutex); -} - -/** - * vfio_platform_eoi - IRQ completion routine - * @vbasedev: the VFIO device handle - * - * De-asserts the active virtual IRQ and unmasks the physical IRQ - * (effective for level sensitive IRQ auto-masked by the VFIO driver). - * Then it handles next pending IRQ if any. - * eoi function is called on the first access to any MMIO region - * after an IRQ was triggered, trapped since slow path was set. - * It is assumed this access corresponds to the IRQ status - * register reset. With such a mechanism, a single IRQ can be - * handled at a time since there is no way to know which IRQ - * was completed by the guest (we would need additional details - * about the IRQ status register mask). - */ -static void vfio_platform_eoi(VFIODevice *vbasedev) -{ - VFIOINTp *intp; - VFIOPlatformDevice *vdev = - container_of(vbasedev, VFIOPlatformDevice, vbasedev); - - qemu_mutex_lock(&vdev->intp_mutex); - QLIST_FOREACH(intp, &vdev->intp_list, next) { - if (intp->state == VFIO_IRQ_ACTIVE) { - trace_vfio_platform_eoi(intp->pin, - event_notifier_get_fd(intp->interrupt)); - intp->state = VFIO_IRQ_INACTIVE; - - /* deassert the virtual IRQ */ - qemu_set_irq(intp->qemuirq, 0); - - if (vfio_irq_is_automasked(intp)) { - /* unmasks the physical level-sensitive IRQ */ - vfio_unmask_single_irqindex(vbasedev, intp->pin); - } - - /* a single IRQ can be active at a time */ - break; - } - } - /* in case there are pending IRQs, handle the first one */ - if (!QSIMPLEQ_EMPTY(&vdev->pending_intp_queue)) { - intp = QSIMPLEQ_FIRST(&vdev->pending_intp_queue); - vfio_intp_inject_pending_lockheld(intp); - QSIMPLEQ_REMOVE_HEAD(&vdev->pending_intp_queue, pqnext); - } - qemu_mutex_unlock(&vdev->intp_mutex); -} - -/** - * vfio_start_eventfd_injection - starts the virtual IRQ injection using - * user-side handled eventfds - * @sbdev: the sysbus device handle - * @irq: the qemu irq handle - */ - -static void vfio_start_eventfd_injection(SysBusDevice *sbdev, qemu_irq irq) -{ - int ret; - VFIOPlatformDevice *vdev = VFIO_PLATFORM_DEVICE(sbdev); - VFIOINTp *intp; - - QLIST_FOREACH(intp, &vdev->intp_list, next) { - if (intp->qemuirq == irq) { - break; - } - } - assert(intp); - - ret = vfio_set_trigger_eventfd(intp, vfio_intp_interrupt); - if (ret) { - error_report("vfio: failed to start eventfd signaling for IRQ %d: %m", - intp->pin); - abort(); - } -} - -/* - * Functions used for irqfd - */ - -/** - * vfio_set_resample_eventfd - sets the resamplefd for an IRQ - * @intp: the IRQ struct handle - * programs the VFIO driver to unmask this IRQ when the - * intp->unmask eventfd is triggered - */ -static int vfio_set_resample_eventfd(VFIOINTp *intp) -{ - VFIODevice *vbasedev = &intp->vdev->vbasedev; - struct vfio_irq_set *irq_set; - int argsz, ret; - int32_t *pfd; - - argsz = sizeof(*irq_set) + sizeof(*pfd); - irq_set = g_malloc0(argsz); - irq_set->argsz = argsz; - irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | VFIO_IRQ_SET_ACTION_UNMASK; - irq_set->index = intp->pin; - irq_set->start = 0; - irq_set->count = 1; - pfd = (int32_t *)&irq_set->data; - *pfd = event_notifier_get_fd(intp->unmask); - qemu_set_fd_handler(*pfd, NULL, NULL, NULL); - ret = ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, irq_set); - g_free(irq_set); - if (ret < 0) { - error_report("vfio: Failed to set resample eventfd: %m"); - } - return ret; -} - -/** - * vfio_start_irqfd_injection - starts the virtual IRQ injection using - * irqfd - * - * @sbdev: the sysbus device handle - * @irq: the qemu irq handle - * - * In case the irqfd setup fails, we fallback to userspace handled eventfd - */ -static void vfio_start_irqfd_injection(SysBusDevice *sbdev, qemu_irq irq) -{ - VFIOPlatformDevice *vdev = VFIO_PLATFORM_DEVICE(sbdev); - VFIOINTp *intp; - - if (!kvm_irqfds_enabled() || !kvm_resamplefds_enabled() || - !vdev->irqfd_allowed) { - goto fail_irqfd; - } - - QLIST_FOREACH(intp, &vdev->intp_list, next) { - if (intp->qemuirq == irq) { - break; - } - } - assert(intp); - - if (kvm_irqchip_add_irqfd_notifier(kvm_state, intp->interrupt, - intp->unmask, irq) < 0) { - goto fail_irqfd; - } - - if (vfio_set_trigger_eventfd(intp, NULL) < 0) { - goto fail_vfio; - } - if (vfio_irq_is_automasked(intp)) { - if (vfio_set_resample_eventfd(intp) < 0) { - goto fail_vfio; - } - trace_vfio_platform_start_level_irqfd_injection(intp->pin, - event_notifier_get_fd(intp->interrupt), - event_notifier_get_fd(intp->unmask)); - } else { - trace_vfio_platform_start_edge_irqfd_injection(intp->pin, - event_notifier_get_fd(intp->interrupt)); - } - - intp->kvm_accel = true; - - return; -fail_vfio: - kvm_irqchip_remove_irqfd_notifier(kvm_state, intp->interrupt, irq); - error_report("vfio: failed to start eventfd signaling for IRQ %d: %m", - intp->pin); - abort(); -fail_irqfd: - vfio_start_eventfd_injection(sbdev, irq); - return; -} - -/* VFIO skeleton */ - -static void vfio_platform_compute_needs_reset(VFIODevice *vbasedev) -{ - vbasedev->needs_reset = true; -} - -/* not implemented yet */ -static int vfio_platform_hot_reset_multi(VFIODevice *vbasedev) -{ - return -1; -} - -/** - * vfio_populate_device - Allocate and populate MMIO region - * and IRQ structs according to driver returned information - * @vbasedev: the VFIO device handle - * - */ -static int vfio_populate_device(VFIODevice *vbasedev) -{ - VFIOINTp *intp, *tmp; - int i, ret = -1; - VFIOPlatformDevice *vdev = - container_of(vbasedev, VFIOPlatformDevice, vbasedev); - - if (!(vbasedev->flags & VFIO_DEVICE_FLAGS_PLATFORM)) { - error_report("vfio: Um, this isn't a platform device"); - return ret; - } - - vdev->regions = g_new0(VFIORegion *, vbasedev->num_regions); - - for (i = 0; i < vbasedev->num_regions; i++) { - char *name = g_strdup_printf("VFIO %s region %d\n", vbasedev->name, i); - - vdev->regions[i] = g_new0(VFIORegion, 1); - ret = vfio_region_setup(OBJECT(vdev), vbasedev, - vdev->regions[i], i, name); - g_free(name); - if (ret) { - error_report("vfio: Error getting region %d info: %m", i); - goto reg_error; - } - } - - vdev->mmap_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, - vfio_intp_mmap_enable, vdev); - - QSIMPLEQ_INIT(&vdev->pending_intp_queue); - - for (i = 0; i < vbasedev->num_irqs; i++) { - struct vfio_irq_info irq = { .argsz = sizeof(irq) }; - - irq.index = i; - ret = ioctl(vbasedev->fd, VFIO_DEVICE_GET_IRQ_INFO, &irq); - if (ret) { - error_printf("vfio: error getting device %s irq info", - vbasedev->name); - goto irq_err; - } else { - trace_vfio_platform_populate_interrupts(irq.index, - irq.count, - irq.flags); - intp = vfio_init_intp(vbasedev, irq); - if (!intp) { - error_report("vfio: Error installing IRQ %d up", i); - goto irq_err; - } - } - } - return 0; -irq_err: - timer_del(vdev->mmap_timer); - QLIST_FOREACH_SAFE(intp, &vdev->intp_list, next, tmp) { - QLIST_REMOVE(intp, next); - g_free(intp); - } -reg_error: - for (i = 0; i < vbasedev->num_regions; i++) { - if (vdev->regions[i]) { - vfio_region_finalize(vdev->regions[i]); - } - g_free(vdev->regions[i]); - } - g_free(vdev->regions); - return ret; -} - -/* specialized functions for VFIO Platform devices */ -static VFIODeviceOps vfio_platform_ops = { - .vfio_compute_needs_reset = vfio_platform_compute_needs_reset, - .vfio_hot_reset_multi = vfio_platform_hot_reset_multi, - .vfio_eoi = vfio_platform_eoi, -}; - -/** - * vfio_base_device_init - perform preliminary VFIO setup - * @vbasedev: the VFIO device handle - * - * Implement the VFIO command sequence that allows to discover - * assigned device resources: group extraction, device - * fd retrieval, resource query. - * Precondition: the device name must be initialized - */ -static int vfio_base_device_init(VFIODevice *vbasedev) -{ - VFIOGroup *group; - VFIODevice *vbasedev_iter; - char *tmp, group_path[PATH_MAX], *group_name; - ssize_t len; - struct stat st; - int groupid; - int ret; - - /* @sysfsdev takes precedence over @host */ - if (vbasedev->sysfsdev) { - g_free(vbasedev->name); - vbasedev->name = g_strdup(basename(vbasedev->sysfsdev)); - } else { - if (!vbasedev->name || strchr(vbasedev->name, '/')) { - return -EINVAL; - } - - vbasedev->sysfsdev = g_strdup_printf("/sys/bus/platform/devices/%s", - vbasedev->name); - } - - if (stat(vbasedev->sysfsdev, &st) < 0) { - error_report("vfio: error: no such host device: %s", - vbasedev->sysfsdev); - return -errno; - } - - tmp = g_strdup_printf("%s/iommu_group", vbasedev->sysfsdev); - len = readlink(tmp, group_path, sizeof(group_path)); - g_free(tmp); - - if (len < 0 || len >= sizeof(group_path)) { - error_report("vfio: error no iommu_group for device"); - return len < 0 ? -errno : -ENAMETOOLONG; - } - - group_path[len] = 0; - - group_name = basename(group_path); - if (sscanf(group_name, "%d", &groupid) != 1) { - error_report("vfio: error reading %s: %m", group_path); - return -errno; - } - - trace_vfio_platform_base_device_init(vbasedev->name, groupid); - - group = vfio_get_group(groupid, &address_space_memory); - if (!group) { - error_report("vfio: failed to get group %d", groupid); - return -ENOENT; - } - - QLIST_FOREACH(vbasedev_iter, &group->device_list, next) { - if (strcmp(vbasedev_iter->name, vbasedev->name) == 0) { - error_report("vfio: error: device %s is already attached", - vbasedev->name); - vfio_put_group(group); - return -EBUSY; - } - } - ret = vfio_get_device(group, vbasedev->name, vbasedev); - if (ret) { - error_report("vfio: failed to get device %s", vbasedev->name); - vfio_put_group(group); - return ret; - } - - ret = vfio_populate_device(vbasedev); - if (ret) { - error_report("vfio: failed to populate device %s", vbasedev->name); - vfio_put_group(group); - } - - return ret; -} - -/** - * vfio_platform_realize - the device realize function - * @dev: device state pointer - * @errp: error - * - * initialize the device, its memory regions and IRQ structures - * IRQ are started separately - */ -static void vfio_platform_realize(DeviceState *dev, Error **errp) -{ - VFIOPlatformDevice *vdev = VFIO_PLATFORM_DEVICE(dev); - SysBusDevice *sbdev = SYS_BUS_DEVICE(dev); - VFIODevice *vbasedev = &vdev->vbasedev; - int i, ret; - - vbasedev->type = VFIO_DEVICE_TYPE_PLATFORM; - vbasedev->ops = &vfio_platform_ops; - - trace_vfio_platform_realize(vbasedev->sysfsdev ? - vbasedev->sysfsdev : vbasedev->name, - vdev->compat); - - ret = vfio_base_device_init(vbasedev); - if (ret) { - error_setg(errp, "vfio: vfio_base_device_init failed for %s", - vbasedev->name); - return; - } - - for (i = 0; i < vbasedev->num_regions; i++) { - if (vfio_region_mmap(vdev->regions[i])) { - error_report("%s mmap unsupported. Performance may be slow", - memory_region_name(vdev->regions[i]->mem)); - } - sysbus_init_mmio(sbdev, vdev->regions[i]->mem); - } -} - -static const VMStateDescription vfio_platform_vmstate = { - .name = TYPE_VFIO_PLATFORM, - .unmigratable = 1, -}; - -static Property vfio_platform_dev_properties[] = { - DEFINE_PROP_STRING("host", VFIOPlatformDevice, vbasedev.name), - DEFINE_PROP_STRING("sysfsdev", VFIOPlatformDevice, vbasedev.sysfsdev), - DEFINE_PROP_BOOL("x-no-mmap", VFIOPlatformDevice, vbasedev.no_mmap, false), - DEFINE_PROP_UINT32("mmap-timeout-ms", VFIOPlatformDevice, - mmap_timeout, 1100), - DEFINE_PROP_BOOL("x-irqfd", VFIOPlatformDevice, irqfd_allowed, true), - DEFINE_PROP_END_OF_LIST(), -}; - -static void vfio_platform_class_init(ObjectClass *klass, void *data) -{ - DeviceClass *dc = DEVICE_CLASS(klass); - SysBusDeviceClass *sbc = SYS_BUS_DEVICE_CLASS(klass); - - dc->realize = vfio_platform_realize; - dc->props = vfio_platform_dev_properties; - dc->vmsd = &vfio_platform_vmstate; - dc->desc = "VFIO-based platform device assignment"; - sbc->connect_irq_notifier = vfio_start_irqfd_injection; - set_bit(DEVICE_CATEGORY_MISC, dc->categories); -} - -static const TypeInfo vfio_platform_dev_info = { - .name = TYPE_VFIO_PLATFORM, - .parent = TYPE_SYS_BUS_DEVICE, - .instance_size = sizeof(VFIOPlatformDevice), - .class_init = vfio_platform_class_init, - .class_size = sizeof(VFIOPlatformDeviceClass), - .abstract = true, -}; - -static void register_vfio_platform_dev_type(void) -{ - type_register_static(&vfio_platform_dev_info); -} - -type_init(register_vfio_platform_dev_type) |