Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1191622 > unrolled thread

[RFC 0/2] VFIO: Add virtual MSI doorbell support.

Back to article view | Back to linux.kernel

Contents

  [RFC 0/2] VFIO: Add virtual MSI doorbell support. Pranavkumar Sawargaonkar <pranavkumar@linaro.org> - 2015-07-24 11:10 +0200
    [RFC 1/2] drivers: vfio: iommu map and unmap device specific memory from kernel. Pranavkumar Sawargaonkar <pranavkumar@linaro.org> - 2015-07-24 11:10 +0200
    [RFC 2/2] drivers: vfio: pci: Add virtual MSI doorbell support. Pranavkumar Sawargaonkar <pranavkumar@linaro.org> - 2015-07-24 11:10 +0200
    Re: [RFC 0/2] VFIO: Add virtual MSI doorbell support. Pranavkumar Sawargaonkar <pranavkumar@linaro.org> - 2015-08-04 07:50 +0200
      RE: [RFC 0/2] VFIO: Add virtual MSI doorbell support. Bhushan Bharat <Bharat.Bhushan@freescale.com> - 2015-08-04 08:10 +0200

#1191622 — [RFC 0/2] VFIO: Add virtual MSI doorbell support.

In current VFIO MSI/MSI-X implementation, linux host kernel
allocates MSI/MSI-X vectors when userspace requests through vfio ioctls.
Vfio creates irqfd mappings to notify MSI/MSI-X interrupts
to the userspace when raised.
Guest OS will see emulated MSI/MSI-X controller and receives an interrupt
when kernel notifies the same via irqfd.

Host kernel allocates MSI/MSI-X using standard linux routines
like pci_enable_msix_range() and pci_enable_msi_range(). 
These routines along with requset_irq() in host kernel sets up 
MSI/MSI-X vectors with Physical MSI/MSI-X addresses provided by
interrupt controller driver in host kernel.

This means when a device is assigned with the guest OS, MSI/MSI-X addresses
present in PCIe EP are the PAs programmed by the host linux kernel.

In x86 MSI/MSI-X physical address range is reserved and iommu is aware
about these addreses and transalation is bypassed for these address range.

Unlike x86, ARM/ARM64 does not reserve MSI/MSI-X Physical address range and
all the transactions including MSI go through iommu/smmu without bypass.
This requires extending current vfio MSI layer with additional functionality
for ARM/ARM64 by
1. Programing IOVA (referred as a MSI virtual doorbell address)
   in device's MSI vector as a MSI address.
   This IOVA will be provided by the userspace based on the
   MSI/MSI-X addresses reserved for the guest.
2. Create an IOMMU mapping between this IOVA and
   Physical address (PA) assigned to the MSI vector.

This RFC is proposing a solution for MSI/MSI-X passthrough for ARM/ARM64.

Pranavkumar Sawargaonkar (2):
  drivers: vfio: iommu map and unmap device specific memory from
    kernel.
  drivers: vfio: pci: Add virtual MSI doorbell support.

 drivers/vfio/pci/vfio_pci.c         |   32 ++++++++++++++++++
 drivers/vfio/pci/vfio_pci_intrs.c   |   64 +++++++++++++++++++++++++++++++++++
 drivers/vfio/pci/vfio_pci_private.h |    3 ++
 drivers/vfio/vfio.c                 |   29 ++++++++++++++++
 drivers/vfio/vfio_iommu_type1.c     |   60 ++++++++++++++++++++++++++++++++
 include/linux/vfio.h                |   11 +++++-
 include/uapi/linux/vfio.h           |   19 +++++++++++
 7 files changed, 217 insertions(+), 1 deletion(-)

-- 
1.7.9.5

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [next] | [standalone]

#1191623 — [RFC 1/2] drivers: vfio: iommu map and unmap device specific memory from kernel.

In vfio we map and unmap various regions using "VFIO_IOMMU_MAP_DMA" and
"VFIO_IOMMU_UNMAP_DMA" ioctls from userspace.

Some device regions (like MSI in case of PCI), which we do not expose
to the userspace with mmap. These regions might require vfio driver
to create an iommu mapping, as their transactions goes through
an iommu like in case of ARM/ARM64.

As the memory is not mmaped in userspace and might needs to be mapped
with different memory attributes than user memory, we can not use
VFIO_IOMMU_MAP_DMA and VFIO_IOMMU_UNMAP_DMA ioctls.

This patch extends "vfio_iommu_driver_ops" to provide -
device_map() and device_unmap() methods by vfio iommu driver.
These methods can be used by other vfio device drivers like PCI,
to create and destroy simple iommu mappings for regions like MSI/MSI-X.

This patch also implements these methods for vfio iommu type1 driver.

Signed-off-by: Ankit Jindal <ajindal@apm.com>
Signed-off-by: Pranavkumar Sawargaonkar <pranavkumar@linaro.org>
Cc: Alex Williamson <alex.williamson@redhat.com>
Cc: Marc Zyngier <marc.zyngier@arm.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Christoffer Dall <christoffer.dall@linaro.org>
---
 drivers/vfio/vfio.c             |   29 +++++++++++++++++++
 drivers/vfio/vfio_iommu_type1.c |   60 +++++++++++++++++++++++++++++++++++++++
 include/linux/vfio.h            |   11 ++++++-
 3 files changed, 99 insertions(+), 1 deletion(-)

diff --git a/drivers/vfio/vfio.c b/drivers/vfio/vfio.c
index 2fb29df..7897c47 100644
--- a/drivers/vfio/vfio.c
+++ b/drivers/vfio/vfio.c
@@ -143,6 +143,35 @@ void vfio_unregister_iommu_driver(const struct vfio_iommu_driver_ops *ops)
 }
 EXPORT_SYMBOL_GPL(vfio_unregister_iommu_driver);
 
+int vfio_device_iommu_map(struct vfio_device *device, unsigned long iova,
+			  phys_addr_t paddr, size_t size, int prot)
+{
+	struct vfio_container *container = device->group->container;
+	const struct vfio_iommu_driver_ops *ops = container->iommu_driver->ops;
+	int ret;
+
+	if (!ops->device_map)
+		return -EINVAL;
+
+	ret = ops->device_map(container->iommu_data, iova, paddr, size, prot);
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(vfio_device_iommu_map);
+
+void vfio_device_iommu_unmap(struct vfio_device *device, unsigned long iova,
+			    size_t size)
+{
+	struct vfio_container *container = device->group->container;
+	const struct vfio_iommu_driver_ops *ops = container->iommu_driver->ops;
+
+	if (!ops->device_unmap)
+		return;
+
+	ops->device_unmap(container->iommu_data, iova, size);
+}
+EXPORT_SYMBOL_GPL(vfio_device_iommu_unmap);
+
 /**
  * Group minor allocation/free - both called with vfio.group_lock held
  */
diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c
index 57d8c37..e41995d 100644
--- a/drivers/vfio/vfio_iommu_type1.c
+++ b/drivers/vfio/vfio_iommu_type1.c
@@ -1025,6 +1025,64 @@ static long vfio_iommu_type1_ioctl(void *iommu_data,
 	return -ENOTTY;
 }
 
+static int vfio_iommu_type1_device_map(void *iommu_data, unsigned long iova,
+		phys_addr_t paddr, size_t size,
+		int prot)
+{
+	struct vfio_iommu *iommu = iommu_data;
+	struct vfio_domain *d;
+	int ret;
+
+	mutex_lock(&iommu->lock);
+
+	list_for_each_entry(d, &iommu->domain_list, next) {
+
+		if (iommu_iova_to_phys(d->domain, iova))
+			continue;
+
+		ret = iommu_map(d->domain, iova, paddr,
+				size, prot | d->prot);
+
+		if (ret) {
+			if (ret != -EBUSY)
+				goto unwind;
+		}
+
+		cond_resched();
+	}
+
+	mutex_unlock(&iommu->lock);
+
+	return 0;
+
+unwind:
+	list_for_each_entry_continue_reverse(d, &iommu->domain_list, next)
+		iommu_unmap(d->domain, iova, size);
+
+	mutex_unlock(&iommu->lock);
+	return ret;
+}
+
+static void vfio_iommu_type1_device_unmap(void *iommu_data, unsigned long iova,
+					 size_t size)
+{
+	struct vfio_iommu *iommu = iommu_data;
+	struct vfio_domain *d;
+
+	mutex_lock(&iommu->lock);
+
+	list_for_each_entry(d, &iommu->domain_list, next) {
+
+		if (!iommu_iova_to_phys(d->domain, iova))
+			continue;
+
+		iommu_unmap(d->domain, iova, size);
+		cond_resched();
+	}
+
+	mutex_unlock(&iommu->lock);
+}
+
 static const struct vfio_iommu_driver_ops vfio_iommu_driver_ops_type1 = {
 	.name		= "vfio-iommu-type1",
 	.owner		= THIS_MODULE,
@@ -1033,6 +1091,8 @@ static const struct vfio_iommu_driver_ops vfio_iommu_driver_ops_type1 = {
 	.ioctl		= vfio_iommu_type1_ioctl,
 	.attach_group	= vfio_iommu_type1_attach_group,
 	.detach_group	= vfio_iommu_type1_detach_group,
+	.device_map	= vfio_iommu_type1_device_map,
+	.device_unmap	= vfio_iommu_type1_device_unmap,
 };
 
 static int __init vfio_iommu_type1_init(void)
diff --git a/include/linux/vfio.h b/include/linux/vfio.h
index ddb4409..ef0d974 100644
--- a/include/linux/vfio.h
+++ b/include/linux/vfio.h
@@ -52,6 +52,12 @@ extern void *vfio_del_group_dev(struct device *dev);
 extern struct vfio_device *vfio_device_get_from_dev(struct device *dev);
 extern void vfio_device_put(struct vfio_device *device);
 extern void *vfio_device_data(struct vfio_device *device);
+extern int vfio_device_iommu_map(struct vfio_device *device,
+					unsigned long iova,
+					phys_addr_t paddr,
+					size_t size, int prot);
+extern void vfio_device_iommu_unmap(struct vfio_device *device,
+				    unsigned long iova, size_t size);
 
 /**
  * struct vfio_iommu_driver_ops - VFIO IOMMU driver callbacks
@@ -72,7 +78,10 @@ struct vfio_iommu_driver_ops {
 					struct iommu_group *group);
 	void		(*detach_group)(void *iommu_data,
 					struct iommu_group *group);
-
+	int		(*device_map)(void *iommu_data, unsigned long iova,
+				      phys_addr_t paddr, size_t size, int prot);
+	void		(*device_unmap)(void *iommu_data, unsigned long iova,
+					size_t size);
 };
 
 extern int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops);
-- 
1.7.9.5

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1191624 — [RFC 2/2] drivers: vfio: pci: Add virtual MSI doorbell support.

In ARM/ARM64 MSI transactions goes through iommu/smmu.
This means there has to be an iommu mapping created for MSI addresses.

This patch adds a new ioctl "VFIO_DEVICE_PCI_MSI_VIRT_DOORBELL".

Userspace can call this ioctl to do following things:
1. Create a virtual doorbell mapping between
MSI IOVA term as a "virtual msi doorbell" (known by the userspace) and
MSI PA (known by the kernel).
2. Set MSI/MSI-X vetcor with a virtual doorbell address instead of PA.

Signed-off-by: Ankit Jindal <ajindal@apm.com>
Signed-off-by: Pranavkumar Sawargaonkar <pranavkumar@linaro.org>
Cc: Alex Williamson <alex.williamson@redhat.com>
Cc: Marc Zyngier <marc.zyngier@arm.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Christoffer Dall <christoffer.dall@linaro.org>
---
 drivers/vfio/pci/vfio_pci.c         |   32 ++++++++++++++++++
 drivers/vfio/pci/vfio_pci_intrs.c   |   64 +++++++++++++++++++++++++++++++++++
 drivers/vfio/pci/vfio_pci_private.h |    3 ++
 include/uapi/linux/vfio.h           |   19 +++++++++++
 4 files changed, 118 insertions(+)

diff --git a/drivers/vfio/pci/vfio_pci.c b/drivers/vfio/pci/vfio_pci.c
index 964ad57..9c92707 100644
--- a/drivers/vfio/pci/vfio_pci.c
+++ b/drivers/vfio/pci/vfio_pci.c
@@ -784,6 +784,38 @@ hot_reset_release:
 
 		kfree(groups);
 		return ret;
+	} else if (cmd == VFIO_DEVICE_PCI_MSI_VIRT_DOORBELL) {
+		struct vfio_pci_msi_virt_doorbell hdr;
+		u64 *data = NULL;
+		int ret = 0;
+		size_t size = sizeof(uint64_t);
+
+		minsz = offsetofend(struct vfio_pci_msi_virt_doorbell, count);
+
+		if (copy_from_user(&hdr, (void __user *)arg, minsz))
+			return -EFAULT;
+
+		if (hdr.argsz < minsz)
+			return -EINVAL;
+
+		if (hdr.argsz - minsz < hdr.count * size)
+			return -EINVAL;
+
+		data = memdup_user((void __user *)(arg + minsz),
+				hdr.count * size);
+		if (IS_ERR(data))
+			return PTR_ERR(data);
+
+		mutex_lock(&vdev->igate);
+
+		ret = vfio_pci_msi_virt_doorbell(vdev, hdr.flags,
+				hdr.start, hdr.count, data);
+
+		mutex_unlock(&vdev->igate);
+
+		kfree(data);
+
+		return ret;
 	}
 
 	return -ENOTTY;
diff --git a/drivers/vfio/pci/vfio_pci_intrs.c b/drivers/vfio/pci/vfio_pci_intrs.c
index 1f577b4..22a25b8 100644
--- a/drivers/vfio/pci/vfio_pci_intrs.c
+++ b/drivers/vfio/pci/vfio_pci_intrs.c
@@ -16,6 +16,7 @@
 #include <linux/device.h>
 #include <linux/interrupt.h>
 #include <linux/eventfd.h>
+#include <linux/irq.h>
 #include <linux/msi.h>
 #include <linux/pci.h>
 #include <linux/file.h>
@@ -352,8 +353,10 @@ static int vfio_msi_set_vector_signal(struct vfio_pci_device *vdev,
 		pci_write_msi_msg(irq, &msg);
 	}
 
+
 	ret = request_irq(irq, vfio_msihandler, 0,
 			  vdev->ctx[vector].name, trigger);
+
 	if (ret) {
 		kfree(vdev->ctx[vector].name);
 		eventfd_ctx_put(trigger);
@@ -673,3 +676,64 @@ int vfio_pci_set_irqs_ioctl(struct vfio_pci_device *vdev, uint32_t flags,
 
 	return func(vdev, index, start, count, flags, data);
 }
+
+int vfio_pci_msi_virt_doorbell(struct vfio_pci_device *vdev, uint32_t flags,
+			    unsigned start, unsigned count,
+			    void *data)
+{
+	struct pci_dev *pdev = vdev->pdev;
+	int irq;
+	bool msix = flags & VFIO_PCI_IS_MSIX;
+	struct msi_msg msg;
+	struct irq_data *d;
+	unsigned long msi_paddr, msi_iova;
+	struct vfio_device *device;
+	int ret;
+	int i, j;
+
+	for (i = 0, j = start; i < count && !ret; i++, j++) {
+
+		device = vfio_device_get_from_dev(&pdev->dev);
+		irq = msix ? vdev->msix[j].vector :
+					pdev->irq + j;
+
+		if (flags & VFIO_PCI_MSI_SET_DOORBELL) {
+			/* Get the MSI message to extract Physical Address */
+			d = irq_get_irq_data(irq);
+			irq_chip_compose_msi_msg(d, &msg);
+			msi_paddr = (msg.address_hi << 31) | msg.address_lo;
+		} else {
+			/*
+			 * Restore the cached value of the message prior
+			 * to the virtual doorbell setting.
+			 */
+			get_cached_msi_msg(irq, &msg);
+		}
+
+		/* MSI IPA/GPA i.e. virtual doorbell address */
+		msi_iova = (unsigned long) ((unsigned long *) data)[i];
+
+		if (flags & VFIO_PCI_MSI_SET_DOORBELL) {
+			ret = vfio_device_iommu_map(device,
+						    (msi_iova & PAGE_MASK),
+						    (msi_paddr & PAGE_MASK),
+						    PAGE_SIZE,
+						    IOMMU_READ | IOMMU_WRITE |
+						    IOMMU_CACHE);
+
+			/* Fill MSI GPA/IPA as a new MSI doorbell address. */
+			msg.address_hi = msi_iova << 31;
+			msg.address_lo = msi_iova & 0xFFFFFFFF;
+		} else if (flags & VFIO_PCI_MSI_CLEAR_DOORBELL) {
+			vfio_device_iommu_unmap(device, (msi_iova & PAGE_MASK),
+						PAGE_SIZE);
+		} else {
+			return -EINVAL;
+		}
+
+		pci_write_msi_msg(irq, &msg);
+	}
+
+	return 0;
+}
+
diff --git a/drivers/vfio/pci/vfio_pci_private.h b/drivers/vfio/pci/vfio_pci_private.h
index ae0e1b4..ec76e45 100644
--- a/drivers/vfio/pci/vfio_pci_private.h
+++ b/drivers/vfio/pci/vfio_pci_private.h
@@ -73,6 +73,9 @@ extern void vfio_pci_intx_unmask(struct vfio_pci_device *vdev);
 extern int vfio_pci_set_irqs_ioctl(struct vfio_pci_device *vdev,
 				   uint32_t flags, unsigned index,
 				   unsigned start, unsigned count, void *data);
+extern int vfio_pci_msi_virt_doorbell(struct vfio_pci_device *vdev,
+				   uint32_t flags, unsigned start,
+				   unsigned count, void *data);
 
 extern ssize_t vfio_pci_config_rw(struct vfio_pci_device *vdev,
 				  char __user *buf, size_t count,
diff --git a/include/uapi/linux/vfio.h b/include/uapi/linux/vfio.h
index 9fd7b5d..12384f5 100644
--- a/include/uapi/linux/vfio.h
+++ b/include/uapi/linux/vfio.h
@@ -379,6 +379,25 @@ struct vfio_pci_hot_reset {
 
 #define VFIO_DEVICE_PCI_HOT_RESET	_IO(VFIO_TYPE, VFIO_BASE + 13)
 
+/**
+ * VFIO_DEVICE_PCI_MSI_VIRT_DOORBELL - _IOW(VFIO_TYPE, VFIO_BASE + 14,
+ *					   struct vfio_pci_msi_virt_doorbell)
+ *
+ * Return: 0 on success, -errno on failure.
+ */
+struct vfio_pci_msi_virt_doorbell {
+	__u32   argsz;
+	__u32   flags;
+#define VFIO_PCI_MSI_CLEAR_DOORBELL	(1 << 0) /* Remove virtual doorbell */
+#define VFIO_PCI_MSI_SET_DOORBELL	(1 << 1) /* Set virtual doorbell */
+#define VFIO_PCI_IS_MSIX		(1 << 2) /* Is MSI-X ? */
+	__u32	start;
+	__u32	count;
+	__u64	data[];
+};
+
+#define VFIO_DEVICE_PCI_MSI_VIRT_DOORBELL       _IO(VFIO_TYPE, VFIO_BASE + 14)
+
 /* -------- API for Type1 VFIO IOMMU -------- */
 
 /**
-- 
1.7.9.5

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1199422

Hi Bharat,

On 28 July 2015 at 23:28, Alex Williamson <alex.williamson@redhat.com> wrote:
> On Tue, 2015-07-28 at 17:23 +0000, Bhushan Bharat wrote:
>> Hi Alex,
>>
>> > -----Original Message-----
>> > From: Alex Williamson [mailto:alex.williamson@redhat.com]
>> > Sent: Tuesday, July 28, 2015 9:52 PM
>> > To: Pranavkumar Sawargaonkar
>> > Cc: kvm@vger.kernel.org; kvmarm@lists.cs.columbia.edu; linux-arm-
>> > kernel@lists.infradead.org; linux-kernel@vger.kernel.org;
>> > christoffer.dall@linaro.org; marc.zyngier@arm.com; will.deacon@arm.com;
>> > bhelgaas@google.com; arnd@arndb.de; rob.herring@linaro.org;
>> > eric.auger@linaro.org; patches@apm.com; Bhushan Bharat-R65777; Yoder
>> > Stuart-B08248
>> > Subject: Re: [RFC 0/2] VFIO: Add virtual MSI doorbell support.
>> >
>> > On Fri, 2015-07-24 at 14:33 +0530, Pranavkumar Sawargaonkar wrote:
>> > > In current VFIO MSI/MSI-X implementation, linux host kernel allocates
>> > > MSI/MSI-X vectors when userspace requests through vfio ioctls.
>> > > Vfio creates irqfd mappings to notify MSI/MSI-X interrupts to the
>> > > userspace when raised.
>> > > Guest OS will see emulated MSI/MSI-X controller and receives an
>> > > interrupt when kernel notifies the same via irqfd.
>> > >
>> > > Host kernel allocates MSI/MSI-X using standard linux routines like
>> > > pci_enable_msix_range() and pci_enable_msi_range().
>> > > These routines along with requset_irq() in host kernel sets up
>> > > MSI/MSI-X vectors with Physical MSI/MSI-X addresses provided by
>> > > interrupt controller driver in host kernel.
>> > >
>> > > This means when a device is assigned with the guest OS, MSI/MSI-X
>> > > addresses present in PCIe EP are the PAs programmed by the host linux
>> > kernel.
>> > >
>> > > In x86 MSI/MSI-X physical address range is reserved and iommu is aware
>> > > about these addreses and transalation is bypassed for these address range.
>> > >
>> > > Unlike x86, ARM/ARM64 does not reserve MSI/MSI-X Physical address
>> > > range and all the transactions including MSI go through iommu/smmu
>> > without bypass.
>> > > This requires extending current vfio MSI layer with additional
>> > > functionality for ARM/ARM64 by 1. Programing IOVA (referred as a MSI
>> > > virtual doorbell address)
>> > >    in device's MSI vector as a MSI address.
>> > >    This IOVA will be provided by the userspace based on the
>> > >    MSI/MSI-X addresses reserved for the guest.
>> > > 2. Create an IOMMU mapping between this IOVA and
>> > >    Physical address (PA) assigned to the MSI vector.
>> > >
>> > > This RFC is proposing a solution for MSI/MSI-X passthrough for
>> > ARM/ARM64.
>> >
>> >
>> > Hi Pranavkumar,
>> >
>> > Freescale has the same, or very similar, need, so any solution in this space
>> > will need to work for both ARM and powerpc.  I'm not a big fan of this
>> > approach as it seems to require the user to configure MSI/X via ioctl and then
>> > call a separate ioctl mapping the doorbells.  That's more code for the user,
>> > more code to get wrong and potentially a gap between configuring MSI/X
>> > and enabling mappings where we could see IOMMU faults.
>> >
>> > If we know that doorbell mappings are required, why can't we set aside a
>> > bank of IOVA space and have them mapped automatically as MSI/X is being
>> > configured?  Then the user's need for special knowledge and handling of this
>> > case is limited to setup.  The IOVA space will be mapped and used as needed,
>> > we only need the user to specify the IOVA space reserved for this.  Thanks,
>>
>> We probably need a mix of both to support Freescale PowerPC and ARM
>> based machines.
>> In this mix mode kernel vfio driver will reserve some IOVA for mapping
>> MSI page/s.
>
> If vfio is reserving pages independently from the user, this becomes
> what Marc called "shaping" the VM and what x86 effectively does.  An
> interface extension should expose these implicit regions so the user can
> avoid them for DMA memory mapping.
>
>>  If any other iova mapping will overlap with this then it will return
>> error and user-space. Ideally this should be choosen in such a way
>> that it never overlap, which is easy on some systems but can be tricky
>> on some other system like Freescale PowerPC. This is not sufficient
>> for at-least Freescale PowerPC based SOC. This is because of hardware
>> limitation, where we need to fit this reserved iova address within
>> aperture decided by user-space. So if we allow user-space to change
>> this reserved iova address to a value decided by user-spece itself
>> then we can support both ARM/PowerPC based solutions.
>
> Yes, that's my intention, to allow userspace to specify the reserved
> region.  I believe you have some additional restrictions on the number
> of MSI banks available and whether MSI banks can be shared, but I would
> hope that doesn't preclude a shared interface with ARM.
>
>> I have some implementation ready/tested with this approach and if this
>> approach looks good then I can submit a RFC patch.
>
> Yes, please post.  Thanks,

Could you please share a tentative timeline by which you will be
posting your patches ?
Also are you planning to post counterpart patches for qemu or kvmtool ?

Thanks,
Pranav
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1199433
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--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web