VFIO support for platform devices
Subsystems (3)
v3 cover VFIO support for platform devices
This patch series aims to implement VFIO support for platform devices that reside behind an IOMMU. Examples of such devices are devices behind an ARM SMMU, or behind a Samsung Exynos System MMU.
The API used is based on the existing VFIO API that is also used with PCI devices. Only devices that include a basic set of IRQs and memory regions are targeted; devices with complex relationships with other devices on a device tree are not taken into account at this stage.
These patches apply on the latest version of Will Deacon's iommu/devel branch for the ARM SMMU driver, with also Kim Phillips' patches to allow platform drivers to bind to any device.
A copy with all the dependencies applied can be cloned from branch
vfio-platform-v3 at git-9UaJU3cA/F/[email protected]:virtualopensystems/linux-kvm-arm.git
The following IOCTLs have been found to be working on FastModels with an ARM SMMU (MMU400). Testing was based on the ARM PL330 DMA Controller featured on those models.
- VFIO_GET_API_VERSION
- VFIO_CHECK_EXTENSION
The TYPE1 fix proposed here enables the following IOCTLs:
- VFIO_GROUP_GET_STATUS
- VFIO_GROUP_SET_CONTAINER
- VFIO_SET_IOMMU
- VFIO_IOMMU_GET_INFO
- VFIO_IOMMU_MAP_DMA
For this ioctl specifically, a new flag has been added:
VFIO_DMA_MAP_FLAG_EXEC. This flag is taken into account on systems with an ARM SMMU.
The VFIO platform driver proposed here implements the following:
- VFIO_GROUP_GET_DEVICE_FD
- VFIO_DEVICE_GET_INFO
- VFIO_DEVICE_GET_REGION_INFO
- VFIO_DEVICE_GET_IRQ_INFO
- VFIO_DEVICE_SET_IRQS
IRQs are implemented partially using this ioctl. Handling incoming interrupts with an eventfd is supported, as is masking and unmasking. Level sensitive interrupts are automasked. What is not implemented is masking/unmasking via eventfd.
In addition, the VFIO platform driver implements the following through the VFIO device file descriptor:
- MMAPing memory regions to the virtual address space of the VFIO user.
- Read / write of memory regions directly through the file descriptor.
What still needs to be done, includes:
- Eventfd for masking/unmasking
- Extend the driver and API for device tree metadata
- QEMU / KVM integration
- Device specific functionality (e.g. VFIO_DEVICE_RESET)
- Improve VFIO_IOMMU_TYPE1 driver to support multiple buses at the same time
- Bind to ARM AMBA devices
- IOMMUs with nested page tables (Stage 1 & 2 translation on ARM SMMUs)
Changes since v2:
- Fixed Read/Write and MMAP on device regions
- Removed dependency on Device Tree
- Interrupts support
- Interrupt masking/unmasking
- Automask level sensitive interrupts
- Introduced VFIO_DMA_MAP_FLAG_EXEC
- Code clean ups
Antonios Motakis (9):
VFIO_IOMMU_TYPE1: Introduce the VFIO_DMA_MAP_FLAG_EXEC flag
VFIO_IOMMU_TYPE1: workaround to build for platform devices
VFIO_PLATFORM: Initial skeleton of VFIO support for platform devices
VFIO_PLATFORM: Return info for device and its memory mapped IO regions
VFIO_PLATFORM: Read and write support for the device fd
VFIO_PLATFORM: Support MMAP of MMIO regions
VFIO_PLATFORM: Return IRQ info
VFIO_PLATFORM: Initial interrupts support
VFIO_PLATFORM: Support for maskable and automasked interrupts
drivers/vfio/Kconfig | 3 +- drivers/vfio/Makefile | 1 + drivers/vfio/platform/Kconfig | 9 + drivers/vfio/platform/Makefile | 4 + drivers/vfio/platform/vfio_platform.c | 448 ++++++++++++++++++++++++++ drivers/vfio/platform/vfio_platform_irq.c | 289 +++++++++++++++++ drivers/vfio/platform/vfio_platform_private.h | 50 +++ drivers/vfio/vfio_iommu_type1.c | 27 +- include/uapi/linux/vfio.h | 2 + 9 files changed, 827 insertions(+), 6 deletions(-) create mode 100644 drivers/vfio/platform/Kconfig create mode 100644 drivers/vfio/platform/Makefile create mode 100644 drivers/vfio/platform/vfio_platform.c create mode 100644 drivers/vfio/platform/vfio_platform_irq.c create mode 100644 drivers/vfio/platform/vfio_platform_private.h
Signature · 1 line
1.8.3.2
PATCH 1/9 VFIO_IOMMU_TYPE1: Introduce the VFIO_DMA_MAP_FLAG_EXEC flag
The ARM SMMU driver expects the IOMMU_EXEC flag, otherwise it will set the page tables for a device as XN (execute never). This affects devices such as the ARM PL330 DMA Controller, which fails to operate if the XN flag is set on the memory it tries to fetch its instructions from.
We introduce the VFIO_DMA_MAP_FLAG_EXEC to VFIO, and use it in VFIO_IOMMU_TYPE1 to set the IOMMU_EXEC flag. This way the user can control whether the XN flag will be set on the requested mappings.
--- drivers/vfio/vfio_iommu_type1.c | 5 ++++- include/uapi/linux/vfio.h | 1 + 2 files changed, 5 insertions(+), 1 deletion(-)
drivers/vfio/vfio_iommu_type1.c +4 -1
@@ -557,6 +557,8 @@ static int vfio_dma_do_map(struct vfio_iommu *iommu, prot |=IOMMU_WRITE ;if (map->flags &VFIO_DMA_MAP_FLAG_READ ) prot |=IOMMU_READ ; +if (map->flags &VFIO_DMA_MAP_FLAG_EXEC ) + prot |=IOMMU_EXEC ;if (!prot)return -EINVAL ;/* No READ/WRITE? */
@@ -865,7 +867,8 @@ static long vfio_iommu_type1_ioctl(void *iommu_data, }else if (cmd ==VFIO_IOMMU_MAP_DMA ) {struct vfio_iommu_type1_dma_map map;uint32_t mask =VFIO_DMA_MAP_FLAG_READ | -VFIO_DMA_MAP_FLAG_WRITE ; +VFIO_DMA_MAP_FLAG_WRITE | +VFIO_DMA_MAP_FLAG_EXEC ; minsz = offsetofend(struct vfio_iommu_type1_dma_map, size);
include/uapi/linux/vfio.h +1 -0
@@ -392,6 +392,7 @@ struct vfio_iommu_type1_dma_map {__u32 flags;#define VFIO_DMA_MAP_FLAG_READ (1 << 0)/* readable from device */ #define VFIO_DMA_MAP_FLAG_WRITE (1 << 1)/* writable from device */ +#define VFIO_DMA_MAP_FLAG_EXEC (1 << 2)/* executable from device */ __u64 vaddr;/* Process virtual address */ __u64 iova;/* IO virtual address */ __u64 size;/* Size of mapping (bytes) */
Signature · 1 line
1.8.3.2
PATCH 2/9 VFIO_IOMMU_TYPE1: workaround to build for platform devices
In reply to Antonios MotakisThis is a workaround to make the VFIO_IOMMU_TYPE1 driver usable with platform devices instead of PCI. A future permanent fix should support both. This is required in order to use the Exynos SMMU, or ARM SMMU driver with VFIO.
--- drivers/vfio/Kconfig | 2 +- drivers/vfio/vfio_iommu_type1.c | 22 ++++++++++++++++++---- 2 files changed, 19 insertions(+), 5 deletions(-)
drivers/vfio/Kconfig +1 -1
@@ -11,7 +11,7 @@ config VFIO_IOMMU_SPAPR_TCE menuconfig VFIO tristate "VFIO Non-Privileged userspace driver framework" depends on IOMMU_API - select VFIO_IOMMU_TYPE1 if X86 + select VFIO_IOMMU_TYPE1 if X86 || ARM select VFIO_IOMMU_SPAPR_TCE if (PPC_POWERNV || PPC_PSERIES) help VFIO provides a framework for secure userspace device drivers.
drivers/vfio/vfio_iommu_type1.c +18 -4
@@ -30,7 +30,8 @@#include <linux/iommu.h> #include <linux/module.h> #include <linux/mm.h> -#include <linux/pci.h> /* pci_bus_type */ +#include <linux/pci.h> /* pci_bus_type */ +#include <linux/platform_device.h> /* platform_bus_type */ #include <linux/rbtree.h> #include <linux/sched.h> #include <linux/slab.h>
@@ -47,6 +48,8 @@ module_param_named(allow_unsafe_interrupts, allow_unsafe_interrupts, bool, S_IRUGO | S_IWUSR);MODULE_PARM_DESC (allow_unsafe_interrupts,"Enable VFIO IOMMU support for on platforms without interrupt remapping support." ); +static struct bus_type *iommu_bus_type =NULL ; +static bool require_cap_intr_remap = false;static bool disable_hugepages; module_param_named(disable_hugepages,
@@ -785,7 +788,8 @@ static void *vfio_iommu_type1_open(unsigned long arg)/* * Wish we didn't have to know about bus_type here. */ - iommu->domain =iommu_domain_alloc (&pci_bus_type); + iommu->domain =iommu_domain_alloc (iommu_bus_type); +if (!iommu->domain) {kfree (iommu);return ERR_PTR (-EIO );
@@ -797,7 +801,7 @@ static void *vfio_iommu_type1_open(unsigned long arg)* the way. Fortunately we know interrupt remapping is global for * our iommus. */ -if (!allow_unsafe_interrupts && +if (require_cap_intr_remap && !allow_unsafe_interrupts && !iommu_domain_has_cap (iommu->domain,IOMMU_CAP_INTR_REMAP )) {pr_warn ("%s: No interrupt remapping support. Use the module param \"allow_unsafe_interrupts\" to enable VFIO IOMMU support on this platform\n" , __func__);
@@ -914,7 +918,17 @@ static const struct vfio_iommu_driver_ops vfio_iommu_driver_ops_type1 = {static int __init vfio_iommu_type1_init (void ) { -if (!iommu_present (&pci_bus_type)) +#ifdef CONFIG_PCI +if (iommu_present (&pci_bus_type)) { + iommu_bus_type = &pci_bus_type; +/* For PCI targets, IOMMU_CAP_INTR_REMAP is required */ + require_cap_intr_remap = true; + } +#endif +if (!iommu_bus_type &&iommu_present (&platform_bus_type)) + iommu_bus_type = &platform_bus_type; + +if (!iommu_bus_type)return -ENODEV ;return vfio_register_iommu_driver (&vfio_iommu_driver_ops_type1);
Signature · 1 line
1.8.3.2
PATCH 3/9 VFIO_PLATFORM: Initial skeleton of VFIO support for platform devices
In reply to Antonios MotakisThis patch forms the skeleton for platform devices support with VFIO. To bind this driver with a platform device, the match_any_dev property is used as introduced by Kim Phillips' patch to allow platform drivers to bind to any device [1].
[1] https://lkml.org/lkml/2013/12/3/223
--- drivers/vfio/Kconfig | 1 + drivers/vfio/Makefile | 1 + drivers/vfio/platform/Kconfig | 9 ++ drivers/vfio/platform/Makefile | 4 + drivers/vfio/platform/vfio_platform.c | 174 ++++++++++++++++++++++++++ drivers/vfio/platform/vfio_platform_private.h | 22 ++++ include/uapi/linux/vfio.h | 1 + 7 files changed, 212 insertions(+) create mode 100644 drivers/vfio/platform/Kconfig create mode 100644 drivers/vfio/platform/Makefile create mode 100644 drivers/vfio/platform/vfio_platform.c create mode 100644 drivers/vfio/platform/vfio_platform_private.h
drivers/vfio/Kconfig +1 -0
@@ -20,3 +20,4 @@ menuconfig VFIO If you don't know what to do here, say N. source "drivers/vfio/pci/Kconfig" +source "drivers/vfio/platform/Kconfig"
drivers/vfio/Makefile +1 -0
@@ -2,3 +2,4 @@ obj-$(CONFIG_VFIO) += vfio.o obj-$(CONFIG_VFIO_IOMMU_TYPE1) += vfio_iommu_type1.o obj-$(CONFIG_VFIO_IOMMU_SPAPR_TCE) += vfio_iommu_spapr_tce.o obj-$(CONFIG_VFIO_PCI) += pci/ +obj-$(CONFIG_VFIO_PLATFORM) += platform/
drivers/vfio/platform/Kconfig new file +9 -0
@@ -0,0 +1,9 @@ +config VFIO_PLATFORM + tristate "VFIO support for platform devices" + depends on VFIO && EVENTFD + help + Support for platform devices with VFIO. This is required to make + use of platform devices present on the system using the VFIO + framework. + + If you don't know what to do here, say N.
drivers/vfio/platform/Makefile new file +4 -0
@@ -0,0 +1,4 @@ + +vfio-platform-y := vfio_platform.o + +obj-$(CONFIG_VFIO_PLATFORM) += vfio-platform.o
drivers/vfio/platform/vfio_platform.c new file +174 -0
174 lines not on this page · raw message
drivers/vfio/platform/vfio_platform_private.h new file +22 -0
@@ -0,0 +1,22 @@ +/* +* Copyright (C) 2013 - Virtual Open Systems +* Author: Antonios Motakis <a.motakis-lrHrjnjw1UfHK3s98zE1ajGjJy/[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License, version 2, as +* published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +*/ + +#ifndef VFIO_PLATFORM_PRIVATE_H +#define VFIO_PLATFORM_PRIVATE_H + +struct vfio_platform_device { +struct platform_device *pdev; +}; + +#endif /* VFIO_PCI_PRIVATE_H */
include/uapi/linux/vfio.h +1 -0
@@ -148,6 +148,7 @@ struct vfio_device_info {__u32 flags;#define VFIO_DEVICE_FLAGS_RESET (1 << 0)/* Device supports reset */ #define VFIO_DEVICE_FLAGS_PCI (1 << 1)/* vfio-pci device */ +#define VFIO_DEVICE_FLAGS_PLATFORM (1 << 2)/* vfio-platform device */ __u32 num_regions;/* Max region index + 1 */ __u32 num_irqs;/* Max IRQ index + 1 */ };
Signature · 1 line
1.8.3.2
PATCH 4/9 VFIO_PLATFORM: Return info for device and its memory mapped IO regions
In reply to Antonios MotakisA VFIO userspace driver will start by opening the VFIO device that corresponds to an IOMMU group, and will use the ioctl interface to get the basic device info, such as number of memory regions and interrupts, and their properties.
This patch enables the IOCTLs:
- VFIO_DEVICE_GET_INFO
- VFIO_DEVICE_GET_REGION_INFO
IRQ info is provided by one of the latter patches.
--- drivers/vfio/platform/vfio_platform.c | 74 ++++++++++++++++++++++++--- drivers/vfio/platform/vfio_platform_private.h | 8 +++ 2 files changed, 76 insertions(+), 6 deletions(-)
drivers/vfio/platform/vfio_platform.c +68 -6
@@ -34,15 +34,62 @@#define DRIVER_AUTHOR "Antonios Motakis <a.motakis-lrHrjnjw1UfHK3s98zE1ajGjJy/[email protected]>"#define DRIVER_DESC "VFIO for platform devices - User Level meta-driver" +static int vfio_platform_regions_init (struct vfio_platform_device *vdev) +{ +int cnt =0 , i; + +while (platform_get_resource (vdev->pdev,IORESOURCE_MEM , cnt)) + cnt++; + + vdev->num_regions = cnt; + + vdev->region =kzalloc (sizeof (struct vfio_platform_region ) * cnt, +GFP_KERNEL ); +if (!vdev->region) +return -ENOMEM ; + +for (i =0 ; i < cnt; i++) { +struct vfio_platform_region region; +struct resource *res = +platform_get_resource (vdev->pdev,IORESOURCE_MEM , i); + + region.addr = res->start; + region.size =resource_size (res); + region.flags =0 ; + + vdev->region[i] = region; + } + +return 0 ; +} + +static void vfio_platform_regions_cleanup (struct vfio_platform_device *vdev) +{ +kfree (vdev->region); +} +static void vfio_platform_release (void *device_data) { +struct vfio_platform_device *vdev = device_data; + +vfio_platform_regions_cleanup (vdev); +module_put (THIS_MODULE ); }static int vfio_platform_open (void *device_data) { -if (!try_module_get (THIS_MODULE )) +struct vfio_platform_device *vdev = device_data; +int ret; + + ret =vfio_platform_regions_init (vdev); +if (ret) +return ret; + +if (!try_module_get (THIS_MODULE )) { +vfio_platform_regions_cleanup (vdev);return -ENODEV ; + }return 0 ; }
@@ -65,18 +112,33 @@ static long vfio_platform_ioctl(void *device_data,return -EINVAL ; info.flags =VFIO_DEVICE_FLAGS_PLATFORM ; - info.num_regions =0 ; + info.num_regions = vdev->num_regions; info.num_irqs =0 ;return copy_to_user ((void __user *)arg, &info, minsz); - }else if (cmd ==VFIO_DEVICE_GET_REGION_INFO ) -return -EINVAL ; + }else if (cmd ==VFIO_DEVICE_GET_REGION_INFO ) { +struct vfio_region_info info; + + minsz = offsetofend(struct vfio_region_info, offset); + +if (copy_from_user (&info, (void __user *)arg, minsz)) +return -EFAULT ; + +if (info.argsz < minsz) +return -EINVAL ; + +/* map offset to the physical address */ + info.offset = vdev->region[info.index].addr; + info.size = vdev->region[info.index].size; + info.flags = vdev->region[info.index].flags; + +return copy_to_user ((void __user *)arg, &info, minsz); -else if (cmd ==VFIO_DEVICE_GET_IRQ_INFO ) + }else if (cmd ==VFIO_DEVICE_GET_IRQ_INFO ) {return -EINVAL ; -else if (cmd ==VFIO_DEVICE_SET_IRQS ) + }else if (cmd ==VFIO_DEVICE_SET_IRQS )return -EINVAL ;else if (cmd ==VFIO_DEVICE_RESET )
drivers/vfio/platform/vfio_platform_private.h +8 -0
@@ -15,8 +15,16 @@#ifndef VFIO_PLATFORM_PRIVATE_H #define VFIO_PLATFORM_PRIVATE_H +struct vfio_platform_region { +u64 addr; +resource_size_t size; +u32 flags; +}; +struct vfio_platform_device {struct platform_device *pdev; +struct vfio_platform_region *region; +u32 num_regions; };#endif /* VFIO_PCI_PRIVATE_H */
Signature · 1 line
1.8.3.2
PATCH 5/9 VFIO_PLATFORM: Read and write support for the device fd
In reply to Antonios MotakisVFIO returns a file descriptor which we can use to manipulate the memory regions of the device. Since some memory regions we cannot mmap due to security concerns, we also allow to read and write to this file descriptor directly.
--- drivers/vfio/platform/vfio_platform.c | 128 +++++++++++++++++++++++++++++++++- 1 file changed, 125 insertions(+), 3 deletions(-)
drivers/vfio/platform/vfio_platform.c +125 -3
@@ -55,7 +55,8 @@ static int vfio_platform_regions_init(struct vfio_platform_device *vdev) region.addr = res->start; region.size =resource_size (res); - region.flags =0 ; + region.flags =VFIO_REGION_INFO_FLAG_READ + |VFIO_REGION_INFO_FLAG_WRITE ; vdev->region[i] = region; }
@@ -150,13 +151,134 @@ static long vfio_platform_ioctl(void *device_data,static ssize_t vfio_platform_read (void *device_data,char __user *buf,size_t count,loff_t *ppos) { -return 0 ; +struct vfio_platform_device *vdev = device_data; +unsigned int *io; +int i; + +for (i =0 ; i < vdev->num_regions; i++) { +struct vfio_platform_region region = vdev->region[i]; +unsigned int done =0 ; +loff_t off; + +if ((*ppos < region.addr) + || (*ppos + count -1 ) >= (region.addr + region.size)) +continue ; + + io =ioremap_nocache (region.addr, region.size); + + off = *ppos - region.addr; + +while (count) { +size_t filled; + +if (count >=4 && !(off %4 )) { +u32 val; + + val =ioread32 (io + off); +if (copy_to_user (buf, &val,4 )) + goto err; + + filled =4 ; + }else if (count >=2 && !(off %2 )) { +u16 val; + + val =ioread16 (io + off); +if (copy_to_user (buf, &val,2 )) + goto err; + + filled =2 ; + }else { +u8 val; + + val =ioread8 (io + off); +if (copy_to_user (buf, &val,1 )) + goto err; + + filled =1 ; + } + + + count -= filled; + done += filled; + off += filled; + buf += filled; + } + +iounmap (io); +return done; + } + +return -EFAULT ; + +err: +iounmap (io); +return -EFAULT ; }static ssize_t vfio_platform_write (void *device_data,const char __user *buf,size_t count,loff_t *ppos) { -return 0 ; +struct vfio_platform_device *vdev = device_data; +unsigned int *io; +int i; + +for (i =0 ; i < vdev->num_regions; i++) { +struct vfio_platform_region region = vdev->region[i]; +unsigned int done =0 ; +loff_t off; + +if ((*ppos < region.addr) + || (*ppos + count -1 ) >= (region.addr + region.size)) +continue ; + + io =ioremap_nocache (region.addr, region.size); + + off = *ppos - region.addr; + +while (count) { +size_t filled; + +if (count >=4 && !(off %4 )) { +u32 val; + +if (copy_from_user (&val, buf,4 )) + goto err; +iowrite32 (val, io + off); + + filled =4 ; + }else if (count >=2 && !(off %2 )) { +u16 val; + +if (copy_from_user (&val, buf,2 )) + goto err; +iowrite16 (val, io + off); + + filled =2 ; + }else { +u8 val; + +if (copy_from_user (&val, buf,1 )) + goto err; +iowrite8 (val, io + off); + + filled =1 ; + } + + count -= filled; + done += filled; + off += filled; + buf += filled; + } + +iounmap (io); +return done; + } + +return -EINVAL ; + +err: +iounmap (io); +return -EFAULT ; }static int vfio_platform_mmap (void *device_data,struct vm_area_struct *vma)
Signature · 1 line
1.8.3.2
PATCH 6/9 VFIO_PLATFORM: Support MMAP of MMIO regions
In reply to Antonios MotakisAllow to memory map the MMIO regions of the device so userspace can directly access them.
--- drivers/vfio/platform/vfio_platform.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
drivers/vfio/platform/vfio_platform.c +33 -0
@@ -58,6 +58,11 @@ static int vfio_platform_regions_init(struct vfio_platform_device *vdev) region.flags =VFIO_REGION_INFO_FLAG_READ |VFIO_REGION_INFO_FLAG_WRITE ; +/* Only regions addressed with PAGE granularity can be MMAPed +* securely. */ +if (!(region.addr & ~PAGE_MASK ) && !(region.size & ~PAGE_MASK )) + region.flags |=VFIO_REGION_INFO_FLAG_MMAP ; + vdev->region[i] = region; }
@@ -283,6 +288,34 @@ err:static int vfio_platform_mmap (void *device_data,struct vm_area_struct *vma) { +struct vfio_platform_device *vdev = device_data; +u64 req_len = vma->vm_end - vma->vm_start; +u64 addr = vma->vm_pgoff <<PAGE_SHIFT ; +int i; + +if (vma->vm_end < vma->vm_start) +return -EINVAL ; +if (vma->vm_start & ~PAGE_MASK ) +return -EINVAL ; +if (vma->vm_end & ~PAGE_MASK ) +return -EINVAL ; +if ((vma->vm_flags &VM_SHARED ) ==0 ) +return -EINVAL ; + +for (i =0 ; i < vdev->num_regions; i++) { +struct vfio_platform_region region = vdev->region[i]; + +if ((addr < region.addr) + || (addr + req_len -1 ) >= (region.addr + region.size)) +continue ; + + vma->vm_private_data = vdev; + vma->vm_page_prot =pgprot_noncached (vma->vm_page_prot); + +return remap_pfn_range (vma, vma->vm_start, vma->vm_pgoff, + req_len, vma->vm_page_prot); + } +return -EINVAL ; }
Signature · 1 line
1.8.3.2
PATCH 7/9 VFIO_PLATFORM: Return IRQ info
In reply to Antonios MotakisReturn information for the interrupts exposed by the device. This patch extends VFIO_DEVICE_GET_INFO with the number of IRQs and enables VFIO_DEVICE_GET_IRQ_INFO
--- drivers/vfio/platform/Makefile | 2 +- drivers/vfio/platform/vfio_platform.c | 35 +++++++++++++-- drivers/vfio/platform/vfio_platform_irq.c | 63 +++++++++++++++++++++++++++ drivers/vfio/platform/vfio_platform_private.h | 11 +++++ 4 files changed, 106 insertions(+), 5 deletions(-) create mode 100644 drivers/vfio/platform/vfio_platform_irq.c
drivers/vfio/platform/Makefile +1 -1
@@ -1,4 +1,4 @@ -vfio-platform-y := vfio_platform.o +vfio-platform-y := vfio_platform.o vfio_platform_irq.o obj-$(CONFIG_VFIO_PLATFORM) += vfio-platform.o
drivers/vfio/platform/vfio_platform.c +31 -4
@@ -79,6 +79,7 @@ static void vfio_platform_release(void *device_data)struct vfio_platform_device *vdev = device_data;vfio_platform_regions_cleanup (vdev); +vfio_platform_irq_cleanup (vdev);module_put (THIS_MODULE ); }
@@ -92,12 +93,22 @@ static int vfio_platform_open(void *device_data)if (ret)return ret; + ret =vfio_platform_irq_init (vdev); +if (ret) + goto err_irq; +if (!try_module_get (THIS_MODULE )) { -vfio_platform_regions_cleanup (vdev); -return -ENODEV ; + ret = -ENODEV ; + goto err_mod; }return 0 ; + +err_mod: +vfio_platform_irq_cleanup (vdev); +err_irq: +vfio_platform_regions_cleanup (vdev); +return ret; } static long vfio_platform_ioctl(void *device_data,
@@ -119,7 +130,7 @@ static long vfio_platform_ioctl(void *device_data, info.flags =VFIO_DEVICE_FLAGS_PLATFORM ; info.num_regions = vdev->num_regions; - info.num_irqs =0 ; + info.num_irqs = vdev->num_irqs;return copy_to_user ((void __user *)arg, &info, minsz);
@@ -142,7 +153,23 @@ static long vfio_platform_ioctl(void *device_data,return copy_to_user ((void __user *)arg, &info, minsz); }else if (cmd ==VFIO_DEVICE_GET_IRQ_INFO ) { -return -EINVAL ; +struct vfio_irq_info info; + + minsz = offsetofend(struct vfio_irq_info, count); + +if (copy_from_user (&info, (void __user *)arg, minsz)) +return -EFAULT ; + +if (info.argsz < minsz) +return -EINVAL ; + +if (info.index >= vdev->num_irqs) +return -EINVAL ; + + info.flags = vdev->irq[info.index].flags; + info.count = vdev->irq[info.index].count; + +return copy_to_user ((void __user *)arg, &info, minsz); }else if (cmd ==VFIO_DEVICE_SET_IRQS )return -EINVAL ;
drivers/vfio/platform/vfio_platform_irq.c new file +63 -0
63 lines not on this page · raw message
drivers/vfio/platform/vfio_platform_private.h +11 -0
@@ -15,6 +15,11 @@ #ifndef VFIO_PLATFORM_PRIVATE_H #define VFIO_PLATFORM_PRIVATE_H +struct vfio_platform_irq { + u32 flags; + u32 count; +}; + struct vfio_platform_region { u64 addr; resource_size_t size;
@@ -25,6 +30,12 @@ struct vfio_platform_device {struct platform_device *pdev;struct vfio_platform_region *region;u32 num_regions; +struct vfio_platform_irq *irq; + u32 num_irqs; }; +extern int vfio_platform_irq_init (struct vfio_platform_device *vdev); + +extern void vfio_platform_irq_cleanup (struct vfio_platform_device *vdev); +#endif /* VFIO_PCI_PRIVATE_H */
Signature · 1 line
1.8.3.2
PATCH 8/9 VFIO_PLATFORM: Initial interrupts support
In reply to Antonios MotakisThis patch allows to set an eventfd for a patform device's interrupt, and also to trigger the interrupt eventfd from userspace for testing.
--- drivers/vfio/platform/vfio_platform.c | 36 +++++++- drivers/vfio/platform/vfio_platform_irq.c | 123 +++++++++++++++++++++++++- drivers/vfio/platform/vfio_platform_private.h | 7 ++ 3 files changed, 162 insertions(+), 4 deletions(-)
drivers/vfio/platform/vfio_platform.c +33 -3
@@ -171,10 +171,40 @@ static long vfio_platform_ioctl(void *device_data,return copy_to_user ((void __user *)arg, &info, minsz); - }else if (cmd ==VFIO_DEVICE_SET_IRQS ) -return -EINVAL ; + }else if (cmd ==VFIO_DEVICE_SET_IRQS ) { +struct vfio_irq_set hdr; +int ret =0 ; + + minsz = offsetofend(struct vfio_irq_set, count); + +if (copy_from_user (&hdr, (void __user *)arg, minsz)) +return -EFAULT ; + +if (hdr.argsz < minsz) +return -EINVAL ; + +if (hdr.index >= vdev->num_irqs) +return -EINVAL ; + +if (hdr.start !=0 || hdr.count >1 ) +return -EINVAL ; + +if (hdr.count ==0 && + (!(hdr.flags &VFIO_IRQ_SET_DATA_NONE ) || + !(hdr.flags &VFIO_IRQ_SET_ACTION_TRIGGER ))) +return -EINVAL ; + +if (hdr.flags & ~(VFIO_IRQ_SET_DATA_TYPE_MASK | +VFIO_IRQ_SET_ACTION_TYPE_MASK )) +return -EINVAL ; + + ret =vfio_platform_set_irqs_ioctl (vdev, hdr.flags, hdr.index, + hdr.start, hdr.count, + (void *)arg+minsz); + +return ret; -else if (cmd ==VFIO_DEVICE_RESET ) + }else if (cmd ==VFIO_DEVICE_RESET )return -EINVAL ;return -ENOTTY ;
drivers/vfio/platform/vfio_platform_irq.c +122 -1
142 lines not on this page · raw message
drivers/vfio/platform/vfio_platform_private.h +7 -0
@@ -16,8 +16,11 @@#define VFIO_PLATFORM_PRIVATE_H struct vfio_platform_irq { +struct eventfd_ctx *trigger;u32 flags;u32 count; +int hwirq; +char *name; };struct vfio_platform_region {
@@ -38,4 +41,8 @@ extern int vfio_platform_irq_init(struct vfio_platform_device *vdev);extern void vfio_platform_irq_cleanup (struct vfio_platform_device *vdev); +extern int vfio_platform_set_irqs_ioctl (struct vfio_platform_device *vdev, +uint32_t flags,unsigned index,unsigned start, +unsigned count,void *data); +#endif /* VFIO_PCI_PRIVATE_H */
Signature · 1 line
1.8.3.2
PATCH 9/9 VFIO_PLATFORM: Support for maskable and automasked interrupts
In reply to Antonios MotakisAdds support to mask interrupts, and also for automasked interrupts. Level sensitive interrupts are exposed as automasked interrupts and are masked and disabled automatically when they fire.
--- drivers/vfio/platform/vfio_platform_irq.c | 117 ++++++++++++++++++++++++-- drivers/vfio/platform/vfio_platform_private.h | 2 + 2 files changed, 113 insertions(+), 6 deletions(-)
drivers/vfio/platform/vfio_platform_irq.c +111 -6
@@ -52,9 +52,16 @@ int vfio_platform_irq_init(struct vfio_platform_device *vdev)struct vfio_platform_irq irq;int hwirq =platform_get_irq (vdev->pdev, i); - irq.flags =VFIO_IRQ_INFO_EVENTFD ; +spin_lock_init (&irq.lock); + + irq.flags =VFIO_IRQ_INFO_EVENTFD |VFIO_IRQ_INFO_MASKABLE ; + +if (irq_get_trigger_type (hwirq) &IRQ_TYPE_LEVEL_MASK ) + irq.flags |=VFIO_IRQ_INFO_AUTOMASKED ; + irq.count =1 ; irq.hwirq = hwirq; + irq.masked = false; vdev->irq[i] = irq; }
@@ -66,19 +73,39 @@ void vfio_platform_irq_cleanup(struct vfio_platform_device *vdev) {int i; -for (i =0 ; i < vdev->num_irqs; i++) +for (i =0 ; i < vdev->num_irqs; i++) {vfio_set_trigger (vdev, i,-1 ); +if (vdev->irq[i].masked) +enable_irq (vdev->irq[i].hwirq); + } +kfree (vdev->irq); }static irqreturn_t vfio_irq_handler (int irq,void *dev_id) { -struct eventfd_ctx *trigger = dev_id; +struct vfio_platform_irq *irq_ctx = dev_id; +unsigned long flags; +int ret =IRQ_NONE ; + +spin_lock_irqsave (&irq_ctx->lock, flags); + +if (!irq_ctx->masked) { + ret =IRQ_HANDLED ; + +if (irq_ctx->flags &VFIO_IRQ_INFO_AUTOMASKED ) { +disable_irq_nosync (irq_ctx->hwirq); + irq_ctx->masked = true; + } + } -eventfd_signal (trigger,1 ); +spin_unlock_irqrestore (&irq_ctx->lock, flags); -return IRQ_HANDLED ; +if (ret ==IRQ_HANDLED ) +eventfd_signal (irq_ctx->trigger,1 ); + +return ret; } static int vfio_set_trigger(struct vfio_platform_device *vdev,
@@ -159,6 +186,82 @@ static int vfio_platform_set_irq_trigger(struct vfio_platform_device *vdev,return -EFAULT ; } +static int vfio_platform_set_irq_unmask (struct vfio_platform_device *vdev, +unsigned index,unsigned start, +unsigned count,uint32_t flags,void *data) +{ +uint8_t arr; + +if (start !=0 || count !=1 ) +return -EINVAL ; + +switch (flags &VFIO_IRQ_SET_DATA_TYPE_MASK ) { +case VFIO_IRQ_SET_DATA_BOOL : +if (copy_from_user (&arr, data,sizeof (uint8_t ))) +return -EFAULT ; + +if (arr !=0x1 ) +return -EINVAL ; + +case VFIO_IRQ_SET_DATA_NONE : + +spin_lock_irq (&vdev->irq[index].lock); + +if (vdev->irq[index].masked) { +enable_irq (vdev->irq[index].hwirq); + vdev->irq[index].masked = false; + } + +spin_unlock_irq (&vdev->irq[index].lock); + +return 0 ; + +case VFIO_IRQ_SET_DATA_EVENTFD :/* XXX not implemented yet */ +default : +return -ENOTTY ; + } + +return 0 ; +} + +static int vfio_platform_set_irq_mask (struct vfio_platform_device *vdev, +unsigned index,unsigned start, +unsigned count,uint32_t flags,void *data) +{ +uint8_t arr; + +if (start !=0 || count !=1 ) +return -EINVAL ; + +switch (flags &VFIO_IRQ_SET_DATA_TYPE_MASK ) { +case VFIO_IRQ_SET_DATA_BOOL : +if (copy_from_user (&arr, data,sizeof (uint8_t ))) +return -EFAULT ; + +if (arr !=0x1 ) +return -EINVAL ; + +case VFIO_IRQ_SET_DATA_NONE : + +spin_lock_irq (&vdev->irq[index].lock); + +if (!vdev->irq[index].masked) { +disable_irq (vdev->irq[index].hwirq); + vdev->irq[index].masked = true; + } + +spin_unlock_irq (&vdev->irq[index].lock); + +return 0 ; + +case VFIO_IRQ_SET_DATA_EVENTFD :/* XXX not implemented yet */ +default : +return -ENOTTY ; + } + +return 0 ; +} +int vfio_platform_set_irqs_ioctl (struct vfio_platform_device *vdev,uint32_t flags,unsigned index,unsigned start,unsigned count,void *data)
@@ -169,8 +272,10 @@ int vfio_platform_set_irqs_ioctl(struct vfio_platform_device *vdev,switch (flags &VFIO_IRQ_SET_ACTION_TYPE_MASK ) {case VFIO_IRQ_SET_ACTION_MASK : + func = vfio_platform_set_irq_mask; +break ;case VFIO_IRQ_SET_ACTION_UNMASK : -/* XXX not implemented */ + func = vfio_platform_set_irq_unmask;break ;case VFIO_IRQ_SET_ACTION_TRIGGER : func = vfio_platform_set_irq_trigger;
drivers/vfio/platform/vfio_platform_private.h +2 -0
@@ -21,6 +21,8 @@ struct vfio_platform_irq {u32 count;int hwirq;char *name; +bool masked; +spinlock_t lock; };struct vfio_platform_region {
Signature · 1 line
1.8.3.2