* [PATCH 0/7] vfio-pci: add support for Freescale IOMMU (PAMU)
@ 2013-09-19 7:29 Bharat Bhushan
2013-09-19 7:29 ` [PATCH 1/7] powerpc: Add interface to get msi region information Bharat Bhushan
` (6 more replies)
0 siblings, 7 replies; 41+ messages in thread
From: Bharat Bhushan @ 2013-09-19 7:29 UTC (permalink / raw)
To: alex.williamson, joro, benh, galak, linux-kernel, linuxppc-dev,
linux-pci, agraf, scottwood, iommu
Cc: Bharat Bhushan
From: Bharat Bhushan <bharat.bhushan@freescale.com>
This patchset adds support for vfio-pci with Freescale
IOMMU (PAMU- Peripheral Access Management Unit)
The Freescale PAMU is an aperture-based IOMMU with the following
characteristics. Each device has an entry in a table in memory
describing the iova->phys mapping. The mapping has:
-an overall aperture that is power of 2 sized, and has a start iova that
is naturally aligned
-has 1 or more windows within the aperture
-number of windows must be power of 2, max is 256
-size of each window is determined by aperture size / # of windows
-iova of each window is determined by aperture start iova / # of windows
-the mapped region in each window can be different than
the window size...mapping must power of 2
-physical address of the mapping must be naturally aligned
with the mapping size
Because of some of above said limitations we need to set limited aperture
window which will have space for MSI address mapping. So we create space
for MSI windows just after the IOVA (guest memory).
First 4 patches in this patchset are for setting up MSI window and MSI address
at device accordingly.
Fifth patch resolves compilation error.
Sixth patch moves some common functions in a separate file so that they can be
used by FSL_PAMU implementation (next patch uses this). These will be used later for
iommu-none implementation. I believe we can do more of this but will take step by step.
Finally the seventh patch actually adds the support for FSL-PAMU :)
Bharat Bhushan (7):
powerpc: Add interface to get msi region information
iommu: add api to get iommu_domain of a device
fsl iommu: add get_dev_iommu_domain
powerpc: translate msi addr to iova if iommu is in use
iommu: supress loff_t compilation error on powerpc
vfio: moving some functions in common file
vfio pci: Add vfio iommu implementation for FSL_PAMU
arch/powerpc/include/asm/machdep.h | 8 +
arch/powerpc/include/asm/pci.h | 2 +
arch/powerpc/kernel/msi.c | 18 +
arch/powerpc/sysdev/fsl_msi.c | 95 ++++-
arch/powerpc/sysdev/fsl_msi.h | 11 +-
drivers/iommu/fsl_pamu_domain.c | 30 ++
drivers/iommu/iommu.c | 10 +
drivers/pci/msi.c | 26 +
drivers/vfio/Kconfig | 6 +
drivers/vfio/Makefile | 5 +-
drivers/vfio/pci/vfio_pci_rdwr.c | 3 +-
drivers/vfio/vfio_iommu_common.c | 235 +++++++++
drivers/vfio/vfio_iommu_common.h | 30 ++
drivers/vfio/vfio_iommu_fsl_pamu.c | 952 ++++++++++++++++++++++++++++++++++++
drivers/vfio/vfio_iommu_type1.c | 206 +--------
include/linux/iommu.h | 7 +
include/linux/msi.h | 8 +
include/linux/pci.h | 13 +
include/uapi/linux/vfio.h | 100 ++++
19 files changed, 1550 insertions(+), 215 deletions(-)
create mode 100644 drivers/vfio/vfio_iommu_common.c
create mode 100644 drivers/vfio/vfio_iommu_common.h
create mode 100644 drivers/vfio/vfio_iommu_fsl_pamu.c
^ permalink raw reply [flat|nested] 41+ messages in thread
* [PATCH 1/7] powerpc: Add interface to get msi region information
2013-09-19 7:29 [PATCH 0/7] vfio-pci: add support for Freescale IOMMU (PAMU) Bharat Bhushan
@ 2013-09-19 7:29 ` Bharat Bhushan
2013-09-24 23:58 ` Bjorn Helgaas
2013-10-08 22:57 ` Scott Wood
2013-09-19 7:29 ` [PATCH 2/7] iommu: add api to get iommu_domain of a device Bharat Bhushan
` (5 subsequent siblings)
6 siblings, 2 replies; 41+ messages in thread
From: Bharat Bhushan @ 2013-09-19 7:29 UTC (permalink / raw)
To: alex.williamson, joro, benh, galak, linux-kernel, linuxppc-dev,
linux-pci, agraf, scottwood, iommu
Cc: Bharat Bhushan
This patch adds interface to get following information
- Number of MSI regions (which is number of MSI banks for powerpc).
- Get the region address range: Physical page which have the
address/addresses used for generating MSI interrupt
and size of the page.
These are required to create IOMMU (Freescale PAMU) mapping for
devices which are directly assigned using VFIO.
Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
---
arch/powerpc/include/asm/machdep.h | 8 +++++++
arch/powerpc/include/asm/pci.h | 2 +
arch/powerpc/kernel/msi.c | 18 ++++++++++++++++
arch/powerpc/sysdev/fsl_msi.c | 39 +++++++++++++++++++++++++++++++++--
arch/powerpc/sysdev/fsl_msi.h | 11 ++++++++-
drivers/pci/msi.c | 26 ++++++++++++++++++++++++
include/linux/msi.h | 8 +++++++
include/linux/pci.h | 13 ++++++++++++
8 files changed, 120 insertions(+), 5 deletions(-)
diff --git a/arch/powerpc/include/asm/machdep.h b/arch/powerpc/include/asm/machdep.h
index 8b48090..8d1b787 100644
--- a/arch/powerpc/include/asm/machdep.h
+++ b/arch/powerpc/include/asm/machdep.h
@@ -30,6 +30,7 @@ struct file;
struct pci_controller;
struct kimage;
struct pci_host_bridge;
+struct msi_region;
struct machdep_calls {
char *name;
@@ -124,6 +125,13 @@ struct machdep_calls {
int (*setup_msi_irqs)(struct pci_dev *dev,
int nvec, int type);
void (*teardown_msi_irqs)(struct pci_dev *dev);
+
+ /* Returns the number of MSI regions (banks) */
+ int (*msi_get_region_count)(void);
+
+ /* Returns the requested region's address and size */
+ int (*msi_get_region)(int region_num,
+ struct msi_region *region);
#endif
void (*restart)(char *cmd);
diff --git a/arch/powerpc/include/asm/pci.h b/arch/powerpc/include/asm/pci.h
index 6653f27..e575349 100644
--- a/arch/powerpc/include/asm/pci.h
+++ b/arch/powerpc/include/asm/pci.h
@@ -117,6 +117,8 @@ extern int pci_proc_domain(struct pci_bus *bus);
#define arch_setup_msi_irqs arch_setup_msi_irqs
#define arch_teardown_msi_irqs arch_teardown_msi_irqs
#define arch_msi_check_device arch_msi_check_device
+#define arch_msi_get_region_count arch_msi_get_region_count
+#define arch_msi_get_region arch_msi_get_region
struct vm_area_struct;
/* Map a range of PCI memory or I/O space for a device into user space */
diff --git a/arch/powerpc/kernel/msi.c b/arch/powerpc/kernel/msi.c
index 8bbc12d..1a67787 100644
--- a/arch/powerpc/kernel/msi.c
+++ b/arch/powerpc/kernel/msi.c
@@ -13,6 +13,24 @@
#include <asm/machdep.h>
+int arch_msi_get_region_count(void)
+{
+ if (ppc_md.msi_get_region_count) {
+ pr_debug("msi: Using platform get_region_count routine.\n");
+ return ppc_md.msi_get_region_count();
+ }
+ return 0;
+}
+
+int arch_msi_get_region(int region_num, struct msi_region *region)
+{
+ if (ppc_md.msi_get_region) {
+ pr_debug("msi: Using platform get_region routine.\n");
+ return ppc_md.msi_get_region(region_num, region);
+ }
+ return 0;
+}
+
int arch_msi_check_device(struct pci_dev* dev, int nvec, int type)
{
if (!ppc_md.setup_msi_irqs || !ppc_md.teardown_msi_irqs) {
diff --git a/arch/powerpc/sysdev/fsl_msi.c b/arch/powerpc/sysdev/fsl_msi.c
index ab02db3..ed045cb 100644
--- a/arch/powerpc/sysdev/fsl_msi.c
+++ b/arch/powerpc/sysdev/fsl_msi.c
@@ -96,6 +96,34 @@ static int fsl_msi_init_allocator(struct fsl_msi *msi_data)
return 0;
}
+static int fsl_msi_get_region_count(void)
+{
+ int count = 0;
+ struct fsl_msi *msi_data;
+
+ list_for_each_entry(msi_data, &msi_head, list)
+ count++;
+
+ return count;
+}
+
+static int fsl_msi_get_region(int region_num, struct msi_region *region)
+{
+ struct fsl_msi *msi_data;
+
+ list_for_each_entry(msi_data, &msi_head, list) {
+ if (msi_data->bank_index == region_num) {
+ region->region_num = msi_data->bank_index;
+ /* Setting PAGE_SIZE as MSIIR is a 4 byte register */
+ region->size = PAGE_SIZE;
+ region->addr = msi_data->msiir & ~(region->size - 1);
+ return 0;
+ }
+ }
+
+ return -ENODEV;
+}
+
static int fsl_msi_check_device(struct pci_dev *pdev, int nvec, int type)
{
if (type == PCI_CAP_ID_MSIX)
@@ -137,7 +165,8 @@ static void fsl_compose_msi_msg(struct pci_dev *pdev, int hwirq,
if (reg && (len == sizeof(u64)))
address = be64_to_cpup(reg);
else
- address = fsl_pci_immrbar_base(hose) + msi_data->msiir_offset;
+ address = fsl_pci_immrbar_base(hose) +
+ (msi_data->msiir & 0xfffff);
msg->address_lo = lower_32_bits(address);
msg->address_hi = upper_32_bits(address);
@@ -376,6 +405,7 @@ static int fsl_of_msi_probe(struct platform_device *dev)
int len;
u32 offset;
static const u32 all_avail[] = { 0, NR_MSI_IRQS };
+ static int bank_index;
match = of_match_device(fsl_of_msi_ids, &dev->dev);
if (!match)
@@ -419,8 +449,8 @@ static int fsl_of_msi_probe(struct platform_device *dev)
dev->dev.of_node->full_name);
goto error_out;
}
- msi->msiir_offset =
- features->msiir_offset + (res.start & 0xfffff);
+ msi->msiir = res.start + features->msiir_offset;
+ printk("msi->msiir = %llx\n", msi->msiir);
}
msi->feature = features->fsl_pic_ip;
@@ -470,6 +500,7 @@ static int fsl_of_msi_probe(struct platform_device *dev)
}
}
+ msi->bank_index = bank_index++;
list_add_tail(&msi->list, &msi_head);
/* The multiple setting ppc_md.setup_msi_irqs will not harm things */
@@ -477,6 +508,8 @@ static int fsl_of_msi_probe(struct platform_device *dev)
ppc_md.setup_msi_irqs = fsl_setup_msi_irqs;
ppc_md.teardown_msi_irqs = fsl_teardown_msi_irqs;
ppc_md.msi_check_device = fsl_msi_check_device;
+ ppc_md.msi_get_region_count = fsl_msi_get_region_count;
+ ppc_md.msi_get_region = fsl_msi_get_region;
} else if (ppc_md.setup_msi_irqs != fsl_setup_msi_irqs) {
dev_err(&dev->dev, "Different MSI driver already installed!\n");
err = -ENODEV;
diff --git a/arch/powerpc/sysdev/fsl_msi.h b/arch/powerpc/sysdev/fsl_msi.h
index 8225f86..6bd5cfc 100644
--- a/arch/powerpc/sysdev/fsl_msi.h
+++ b/arch/powerpc/sysdev/fsl_msi.h
@@ -29,12 +29,19 @@ struct fsl_msi {
struct irq_domain *irqhost;
unsigned long cascade_irq;
-
- u32 msiir_offset; /* Offset of MSIIR, relative to start of CCSR */
+ dma_addr_t msiir; /* MSIIR Address in CCSR */
void __iomem *msi_regs;
u32 feature;
int msi_virqs[NR_MSI_REG];
+ /*
+ * During probe each bank is assigned a index number.
+ * index number ranges from 0 to 2^32.
+ * Example MSI bank 1 = 0
+ * MSI bank 2 = 1, and so on.
+ */
+ int bank_index;
+
struct msi_bitmap bitmap;
struct list_head list; /* support multiple MSI banks */
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index aca7578..6d85c15 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -30,6 +30,20 @@ static int pci_msi_enable = 1;
/* Arch hooks */
+#ifndef arch_msi_get_region_count
+int arch_msi_get_region_count(void)
+{
+ return 0;
+}
+#endif
+
+#ifndef arch_msi_get_region
+int arch_msi_get_region(int region_num, struct msi_region *region)
+{
+ return 0;
+}
+#endif
+
#ifndef arch_msi_check_device
int arch_msi_check_device(struct pci_dev *dev, int nvec, int type)
{
@@ -903,6 +917,18 @@ void pci_disable_msi(struct pci_dev *dev)
}
EXPORT_SYMBOL(pci_disable_msi);
+int msi_get_region_count(void)
+{
+ return arch_msi_get_region_count();
+}
+EXPORT_SYMBOL(msi_get_region_count);
+
+int msi_get_region(int region_num, struct msi_region *region)
+{
+ return arch_msi_get_region(region_num, region);
+}
+EXPORT_SYMBOL(msi_get_region);
+
/**
* pci_msix_table_size - return the number of device's MSI-X table entries
* @dev: pointer to the pci_dev data structure of MSI-X device function
diff --git a/include/linux/msi.h b/include/linux/msi.h
index ee66f3a..ae32601 100644
--- a/include/linux/msi.h
+++ b/include/linux/msi.h
@@ -50,6 +50,12 @@ struct msi_desc {
struct kobject kobj;
};
+struct msi_region {
+ int region_num;
+ dma_addr_t addr;
+ size_t size;
+};
+
/*
* The arch hook for setup up msi irqs
*/
@@ -58,5 +64,7 @@ void arch_teardown_msi_irq(unsigned int irq);
int arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type);
void arch_teardown_msi_irqs(struct pci_dev *dev);
int arch_msi_check_device(struct pci_dev* dev, int nvec, int type);
+int arch_msi_get_region_count(void);
+int arch_msi_get_region(int region_num, struct msi_region *region);
#endif /* LINUX_MSI_H */
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 186540d..2b26a59 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -1126,6 +1126,7 @@ struct msix_entry {
u16 entry; /* driver uses to specify entry, OS writes */
};
+struct msi_region;
#ifndef CONFIG_PCI_MSI
static inline int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec)
@@ -1168,6 +1169,16 @@ static inline int pci_msi_enabled(void)
{
return 0;
}
+
+static inline int msi_get_region_count(void)
+{
+ return 0;
+}
+
+static inline int msi_get_region(int region_num, struct msi_region *region)
+{
+ return 0;
+}
#else
int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec);
int pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec);
@@ -1180,6 +1191,8 @@ void pci_disable_msix(struct pci_dev *dev);
void msi_remove_pci_irq_vectors(struct pci_dev *dev);
void pci_restore_msi_state(struct pci_dev *dev);
int pci_msi_enabled(void);
+int msi_get_region_count(void);
+int msi_get_region(int region_num, struct msi_region *region);
#endif
#ifdef CONFIG_PCIEPORTBUS
--
1.7.0.4
^ permalink raw reply related [flat|nested] 41+ messages in thread
* [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-09-19 7:29 [PATCH 0/7] vfio-pci: add support for Freescale IOMMU (PAMU) Bharat Bhushan
2013-09-19 7:29 ` [PATCH 1/7] powerpc: Add interface to get msi region information Bharat Bhushan
@ 2013-09-19 7:29 ` Bharat Bhushan
2013-09-25 16:45 ` Alex Williamson
2013-09-19 7:29 ` [PATCH 3/7] fsl iommu: add get_dev_iommu_domain Bharat Bhushan
` (4 subsequent siblings)
6 siblings, 1 reply; 41+ messages in thread
From: Bharat Bhushan @ 2013-09-19 7:29 UTC (permalink / raw)
To: alex.williamson, joro, benh, galak, linux-kernel, linuxppc-dev,
linux-pci, agraf, scottwood, iommu
Cc: Bharat Bhushan
This api return the iommu domain to which the device is attached.
The iommu_domain is required for making API calls related to iommu.
Follow up patches which use this API to know iommu maping.
Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
---
drivers/iommu/iommu.c | 10 ++++++++++
include/linux/iommu.h | 7 +++++++
2 files changed, 17 insertions(+), 0 deletions(-)
diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
index fbe9ca7..6ac5f50 100644
--- a/drivers/iommu/iommu.c
+++ b/drivers/iommu/iommu.c
@@ -696,6 +696,16 @@ void iommu_detach_device(struct iommu_domain *domain, struct device *dev)
}
EXPORT_SYMBOL_GPL(iommu_detach_device);
+struct iommu_domain *iommu_get_dev_domain(struct device *dev)
+{
+ struct iommu_ops *ops = dev->bus->iommu_ops;
+
+ if (unlikely(ops == NULL || ops->get_dev_iommu_domain == NULL))
+ return NULL;
+
+ return ops->get_dev_iommu_domain(dev);
+}
+EXPORT_SYMBOL_GPL(iommu_get_dev_domain);
/*
* IOMMU groups are really the natrual working unit of the IOMMU, but
* the IOMMU API works on domains and devices. Bridge that gap by
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 7ea319e..fa046bd 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -127,6 +127,7 @@ struct iommu_ops {
int (*domain_set_windows)(struct iommu_domain *domain, u32 w_count);
/* Get the numer of window per domain */
u32 (*domain_get_windows)(struct iommu_domain *domain);
+ struct iommu_domain *(*get_dev_iommu_domain)(struct device *dev);
unsigned long pgsize_bitmap;
};
@@ -190,6 +191,7 @@ extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
phys_addr_t offset, u64 size,
int prot);
extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr);
+extern struct iommu_domain *iommu_get_dev_domain(struct device *dev);
/**
* report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
* @domain: the iommu domain where the fault has happened
@@ -284,6 +286,11 @@ static inline void iommu_domain_window_disable(struct iommu_domain *domain,
{
}
+static inline struct iommu_domain *iommu_get_dev_domain(struct device *dev)
+{
+ return NULL;
+}
+
static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
{
return 0;
--
1.7.0.4
^ permalink raw reply related [flat|nested] 41+ messages in thread
* [PATCH 3/7] fsl iommu: add get_dev_iommu_domain
2013-09-19 7:29 [PATCH 0/7] vfio-pci: add support for Freescale IOMMU (PAMU) Bharat Bhushan
2013-09-19 7:29 ` [PATCH 1/7] powerpc: Add interface to get msi region information Bharat Bhushan
2013-09-19 7:29 ` [PATCH 2/7] iommu: add api to get iommu_domain of a device Bharat Bhushan
@ 2013-09-19 7:29 ` Bharat Bhushan
2013-09-19 7:29 ` [PATCH 4/7] powerpc: translate msi addr to iova if iommu is in use Bharat Bhushan
` (3 subsequent siblings)
6 siblings, 0 replies; 41+ messages in thread
From: Bharat Bhushan @ 2013-09-19 7:29 UTC (permalink / raw)
To: alex.williamson, joro, benh, galak, linux-kernel, linuxppc-dev,
linux-pci, agraf, scottwood, iommu
Cc: Bharat Bhushan
From: Bharat Bhushan <bharat.bhushan@freescale.com>
returns the iommu_domain of the requested device for fsl pamu.
Use PCI controller dev struct for pci devices as current LIODN schema
assign LIODN to PCI controller not PCI device. This will be corrected
with proper LIODN schema.
Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
---
drivers/iommu/fsl_pamu_domain.c | 30 ++++++++++++++++++++++++++++++
1 files changed, 30 insertions(+), 0 deletions(-)
diff --git a/drivers/iommu/fsl_pamu_domain.c b/drivers/iommu/fsl_pamu_domain.c
index 14d803a..1d0dfe3 100644
--- a/drivers/iommu/fsl_pamu_domain.c
+++ b/drivers/iommu/fsl_pamu_domain.c
@@ -1140,6 +1140,35 @@ static u32 fsl_pamu_get_windows(struct iommu_domain *domain)
return dma_domain->win_cnt;
}
+static struct iommu_domain *fsl_get_dev_domain(struct device *dev)
+{
+ struct pci_controller *pci_ctl;
+ struct device_domain_info *info;
+ struct pci_dev *pdev;
+
+ /*
+ * Use PCI controller dev struct for pci devices as current
+ * LIODN schema assign LIODN to PCI controller not PCI device
+ * This should get corrected with proper LIODN schema.
+ */
+ if (dev->bus == &pci_bus_type) {
+ pdev = to_pci_dev(dev);
+ pci_ctl = pci_bus_to_host(pdev->bus);
+ /*
+ * make dev point to pci controller device
+ * so we can get the LIODN programmed by
+ * u-boot.
+ */
+ dev = pci_ctl->parent;
+ }
+
+ info = dev->archdata.iommu_domain;
+ if (info && info->domain)
+ return info->domain->iommu_domain;
+
+ return NULL;
+}
+
static struct iommu_ops fsl_pamu_ops = {
.domain_init = fsl_pamu_domain_init,
.domain_destroy = fsl_pamu_domain_destroy,
@@ -1155,6 +1184,7 @@ static struct iommu_ops fsl_pamu_ops = {
.domain_get_attr = fsl_pamu_get_domain_attr,
.add_device = fsl_pamu_add_device,
.remove_device = fsl_pamu_remove_device,
+ .get_dev_iommu_domain = fsl_get_dev_domain,
};
int pamu_domain_init()
--
1.7.0.4
^ permalink raw reply related [flat|nested] 41+ messages in thread
* [PATCH 4/7] powerpc: translate msi addr to iova if iommu is in use
2013-09-19 7:29 [PATCH 0/7] vfio-pci: add support for Freescale IOMMU (PAMU) Bharat Bhushan
` (2 preceding siblings ...)
2013-09-19 7:29 ` [PATCH 3/7] fsl iommu: add get_dev_iommu_domain Bharat Bhushan
@ 2013-09-19 7:29 ` Bharat Bhushan
2013-09-19 7:29 ` [PATCH 5/7] iommu: supress loff_t compilation error on powerpc Bharat Bhushan
` (2 subsequent siblings)
6 siblings, 0 replies; 41+ messages in thread
From: Bharat Bhushan @ 2013-09-19 7:29 UTC (permalink / raw)
To: alex.williamson, joro, benh, galak, linux-kernel, linuxppc-dev,
linux-pci, agraf, scottwood, iommu
Cc: Bharat Bhushan
If the device is attached with iommu domain then set MSI address
to the iova configured in PAMU.
Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
---
arch/powerpc/sysdev/fsl_msi.c | 56 +++++++++++++++++++++++++++++++++++++++-
1 files changed, 54 insertions(+), 2 deletions(-)
diff --git a/arch/powerpc/sysdev/fsl_msi.c b/arch/powerpc/sysdev/fsl_msi.c
index ed045cb..c7cf018 100644
--- a/arch/powerpc/sysdev/fsl_msi.c
+++ b/arch/powerpc/sysdev/fsl_msi.c
@@ -18,6 +18,7 @@
#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/of_platform.h>
+#include <linux/iommu.h>
#include <sysdev/fsl_soc.h>
#include <asm/prom.h>
#include <asm/hw_irq.h>
@@ -150,7 +151,40 @@ static void fsl_teardown_msi_irqs(struct pci_dev *pdev)
return;
}
-static void fsl_compose_msi_msg(struct pci_dev *pdev, int hwirq,
+static uint64_t fsl_iommu_get_iova(struct pci_dev *pdev, dma_addr_t msi_phys)
+{
+ struct iommu_domain *domain;
+ struct iommu_domain_geometry geometry;
+ u32 wins = 0;
+ uint64_t iova, size;
+ int ret, i;
+
+ domain = iommu_get_dev_domain(&pdev->dev);
+ if (!domain)
+ return 0;
+
+ ret = iommu_domain_get_attr(domain, DOMAIN_ATTR_WINDOWS, &wins);
+ if (ret)
+ return 0;
+
+ ret = iommu_domain_get_attr(domain, DOMAIN_ATTR_GEOMETRY, &geometry);
+ if (ret)
+ return 0;
+
+ iova = geometry.aperture_start;
+ size = geometry.aperture_end - geometry.aperture_start + 1;
+ do_div(size, wins);
+ for (i = 0; i < wins; i++) {
+ phys_addr_t phys;
+ phys = iommu_iova_to_phys(domain, iova);
+ if (phys == (msi_phys & ~(PAGE_SIZE - 1)))
+ return (iova + (msi_phys & (PAGE_SIZE - 1)));
+ iova += size;
+ }
+ return 0;
+}
+
+static int fsl_compose_msi_msg(struct pci_dev *pdev, int hwirq,
struct msi_msg *msg,
struct fsl_msi *fsl_msi_data)
{
@@ -168,6 +202,16 @@ static void fsl_compose_msi_msg(struct pci_dev *pdev, int hwirq,
address = fsl_pci_immrbar_base(hose) +
(msi_data->msiir & 0xfffff);
+ /*
+ * If the device is attached with iommu domain then set MSI address
+ * to the iova configured in PAMU.
+ */
+ if (iommu_get_dev_domain(&pdev->dev)) {
+ address = fsl_iommu_get_iova(pdev, msi_data->msiir);
+ if (!address)
+ return -ENODEV;
+ }
+
msg->address_lo = lower_32_bits(address);
msg->address_hi = upper_32_bits(address);
@@ -175,6 +219,8 @@ static void fsl_compose_msi_msg(struct pci_dev *pdev, int hwirq,
pr_debug("%s: allocated srs: %d, ibs: %d\n",
__func__, hwirq / IRQS_PER_MSI_REG, hwirq % IRQS_PER_MSI_REG);
+
+ return 0;
}
static int fsl_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)
@@ -244,7 +290,13 @@ static int fsl_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)
/* chip_data is msi_data via host->hostdata in host->map() */
irq_set_msi_desc(virq, entry);
- fsl_compose_msi_msg(pdev, hwirq, &msg, msi_data);
+ if (fsl_compose_msi_msg(pdev, hwirq, &msg, msi_data)) {
+ dev_err(&pdev->dev, "Fail to set MSI for hwirq %i\n",
+ hwirq);
+ msi_bitmap_free_hwirqs(&msi_data->bitmap, hwirq, 1);
+ rc = -ENODEV;
+ goto out_free;
+ }
write_msi_msg(virq, &msg);
}
return 0;
--
1.7.0.4
^ permalink raw reply related [flat|nested] 41+ messages in thread
* [PATCH 5/7] iommu: supress loff_t compilation error on powerpc
2013-09-19 7:29 [PATCH 0/7] vfio-pci: add support for Freescale IOMMU (PAMU) Bharat Bhushan
` (3 preceding siblings ...)
2013-09-19 7:29 ` [PATCH 4/7] powerpc: translate msi addr to iova if iommu is in use Bharat Bhushan
@ 2013-09-19 7:29 ` Bharat Bhushan
2013-09-25 16:40 ` Alex Williamson
2013-09-19 7:29 ` [PATCH 6/7] vfio: moving some functions in common file Bharat Bhushan
2013-09-19 7:29 ` [PATCH 7/7] vfio pci: Add vfio iommu implementation for FSL_PAMU Bharat Bhushan
6 siblings, 1 reply; 41+ messages in thread
From: Bharat Bhushan @ 2013-09-19 7:29 UTC (permalink / raw)
To: alex.williamson, joro, benh, galak, linux-kernel, linuxppc-dev,
linux-pci, agraf, scottwood, iommu
Cc: Bharat Bhushan
Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
---
drivers/vfio/pci/vfio_pci_rdwr.c | 3 ++-
1 files changed, 2 insertions(+), 1 deletions(-)
diff --git a/drivers/vfio/pci/vfio_pci_rdwr.c b/drivers/vfio/pci/vfio_pci_rdwr.c
index 210db24..8a8156a 100644
--- a/drivers/vfio/pci/vfio_pci_rdwr.c
+++ b/drivers/vfio/pci/vfio_pci_rdwr.c
@@ -181,7 +181,8 @@ ssize_t vfio_pci_vga_rw(struct vfio_pci_device *vdev, char __user *buf,
size_t count, loff_t *ppos, bool iswrite)
{
int ret;
- loff_t off, pos = *ppos & VFIO_PCI_OFFSET_MASK;
+ loff_t off;
+ u64 pos = (u64 )(*ppos & VFIO_PCI_OFFSET_MASK);
void __iomem *iomem = NULL;
unsigned int rsrc;
bool is_ioport;
--
1.7.0.4
^ permalink raw reply related [flat|nested] 41+ messages in thread
* [PATCH 6/7] vfio: moving some functions in common file
2013-09-19 7:29 [PATCH 0/7] vfio-pci: add support for Freescale IOMMU (PAMU) Bharat Bhushan
` (4 preceding siblings ...)
2013-09-19 7:29 ` [PATCH 5/7] iommu: supress loff_t compilation error on powerpc Bharat Bhushan
@ 2013-09-19 7:29 ` Bharat Bhushan
2013-09-25 17:02 ` Alex Williamson
2013-09-19 7:29 ` [PATCH 7/7] vfio pci: Add vfio iommu implementation for FSL_PAMU Bharat Bhushan
6 siblings, 1 reply; 41+ messages in thread
From: Bharat Bhushan @ 2013-09-19 7:29 UTC (permalink / raw)
To: alex.williamson, joro, benh, galak, linux-kernel, linuxppc-dev,
linux-pci, agraf, scottwood, iommu
Cc: Bharat Bhushan
Some function defined in vfio_iommu_type1.c were common and
we want to use these for FSL IOMMU (PAMU) and iommu-none driver.
So some of them are moved to vfio_iommu_common.c
I think we can do more of that but we will take this step by step.
Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
---
drivers/vfio/Makefile | 4 +-
drivers/vfio/vfio_iommu_common.c | 235 ++++++++++++++++++++++++++++++++++++++
drivers/vfio/vfio_iommu_common.h | 30 +++++
drivers/vfio/vfio_iommu_type1.c | 206 +---------------------------------
4 files changed, 268 insertions(+), 207 deletions(-)
create mode 100644 drivers/vfio/vfio_iommu_common.c
create mode 100644 drivers/vfio/vfio_iommu_common.h
diff --git a/drivers/vfio/Makefile b/drivers/vfio/Makefile
index 72bfabc..c5792ec 100644
--- a/drivers/vfio/Makefile
+++ b/drivers/vfio/Makefile
@@ -1,4 +1,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_IOMMU_TYPE1) += vfio_iommu_common.o vfio_iommu_type1.o
+obj-$(CONFIG_VFIO_IOMMU_SPAPR_TCE) += vfio_iommu_common.o vfio_iommu_spapr_tce.o
obj-$(CONFIG_VFIO_PCI) += pci/
diff --git a/drivers/vfio/vfio_iommu_common.c b/drivers/vfio/vfio_iommu_common.c
new file mode 100644
index 0000000..8bdc0ea
--- /dev/null
+++ b/drivers/vfio/vfio_iommu_common.c
@@ -0,0 +1,235 @@
+/*
+ * VFIO: Common code for vfio IOMMU support
+ *
+ * Copyright (C) 2012 Red Hat, Inc. All rights reserved.
+ * Author: Alex Williamson <alex.williamson@redhat.com>
+ * Author: Bharat Bhushan <bharat.bhushan@freescale.com>
+ *
+ * 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.
+ *
+ * Derived from original vfio:
+ * Copyright 2010 Cisco Systems, Inc. All rights reserved.
+ * Author: Tom Lyon, pugs@cisco.com
+ */
+
+#include <linux/compat.h>
+#include <linux/device.h>
+#include <linux/fs.h>
+#include <linux/iommu.h>
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/pci.h> /* pci_bus_type */
+#include <linux/rbtree.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/vfio.h>
+#include <linux/workqueue.h>
+
+static bool disable_hugepages;
+module_param_named(disable_hugepages,
+ disable_hugepages, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(disable_hugepages,
+ "Disable VFIO IOMMU support for IOMMU hugepages.");
+
+struct vwork {
+ struct mm_struct *mm;
+ long npage;
+ struct work_struct work;
+};
+
+/* delayed decrement/increment for locked_vm */
+void vfio_lock_acct_bg(struct work_struct *work)
+{
+ struct vwork *vwork = container_of(work, struct vwork, work);
+ struct mm_struct *mm;
+
+ mm = vwork->mm;
+ down_write(&mm->mmap_sem);
+ mm->locked_vm += vwork->npage;
+ up_write(&mm->mmap_sem);
+ mmput(mm);
+ kfree(vwork);
+}
+
+void vfio_lock_acct(long npage)
+{
+ struct vwork *vwork;
+ struct mm_struct *mm;
+
+ if (!current->mm || !npage)
+ return; /* process exited or nothing to do */
+
+ if (down_write_trylock(¤t->mm->mmap_sem)) {
+ current->mm->locked_vm += npage;
+ up_write(¤t->mm->mmap_sem);
+ return;
+ }
+
+ /*
+ * Couldn't get mmap_sem lock, so must setup to update
+ * mm->locked_vm later. If locked_vm were atomic, we
+ * wouldn't need this silliness
+ */
+ vwork = kmalloc(sizeof(struct vwork), GFP_KERNEL);
+ if (!vwork)
+ return;
+ mm = get_task_mm(current);
+ if (!mm) {
+ kfree(vwork);
+ return;
+ }
+ INIT_WORK(&vwork->work, vfio_lock_acct_bg);
+ vwork->mm = mm;
+ vwork->npage = npage;
+ schedule_work(&vwork->work);
+}
+
+/*
+ * Some mappings aren't backed by a struct page, for example an mmap'd
+ * MMIO range for our own or another device. These use a different
+ * pfn conversion and shouldn't be tracked as locked pages.
+ */
+bool is_invalid_reserved_pfn(unsigned long pfn)
+{
+ if (pfn_valid(pfn)) {
+ bool reserved;
+ struct page *tail = pfn_to_page(pfn);
+ struct page *head = compound_trans_head(tail);
+ reserved = !!(PageReserved(head));
+ if (head != tail) {
+ /*
+ * "head" is not a dangling pointer
+ * (compound_trans_head takes care of that)
+ * but the hugepage may have been split
+ * from under us (and we may not hold a
+ * reference count on the head page so it can
+ * be reused before we run PageReferenced), so
+ * we've to check PageTail before returning
+ * what we just read.
+ */
+ smp_rmb();
+ if (PageTail(tail))
+ return reserved;
+ }
+ return PageReserved(tail);
+ }
+
+ return true;
+}
+
+int put_pfn(unsigned long pfn, int prot)
+{
+ if (!is_invalid_reserved_pfn(pfn)) {
+ struct page *page = pfn_to_page(pfn);
+ if (prot & IOMMU_WRITE)
+ SetPageDirty(page);
+ put_page(page);
+ return 1;
+ }
+ return 0;
+}
+
+static int vaddr_get_pfn(unsigned long vaddr, int prot, unsigned long *pfn)
+{
+ struct page *page[1];
+ struct vm_area_struct *vma;
+ int ret = -EFAULT;
+
+ if (get_user_pages_fast(vaddr, 1, !!(prot & IOMMU_WRITE), page) == 1) {
+ *pfn = page_to_pfn(page[0]);
+ return 0;
+ }
+
+ printk("via vma\n");
+ down_read(¤t->mm->mmap_sem);
+
+ vma = find_vma_intersection(current->mm, vaddr, vaddr + 1);
+
+ if (vma && vma->vm_flags & VM_PFNMAP) {
+ *pfn = ((vaddr - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
+ if (is_invalid_reserved_pfn(*pfn))
+ ret = 0;
+ }
+
+ up_read(¤t->mm->mmap_sem);
+
+ return ret;
+}
+
+/*
+ * Attempt to pin pages. We really don't want to track all the pfns and
+ * the iommu can only map chunks of consecutive pfns anyway, so get the
+ * first page and all consecutive pages with the same locking.
+ */
+long vfio_pin_pages(unsigned long vaddr, long npage,
+ int prot, unsigned long *pfn_base)
+{
+ unsigned long limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
+ bool lock_cap = capable(CAP_IPC_LOCK);
+ long ret, i;
+
+ if (!current->mm)
+ return -ENODEV;
+
+ ret = vaddr_get_pfn(vaddr, prot, pfn_base);
+ if (ret)
+ return ret;
+
+ if (is_invalid_reserved_pfn(*pfn_base))
+ return 1;
+
+ if (!lock_cap && current->mm->locked_vm + 1 > limit) {
+ put_pfn(*pfn_base, prot);
+ pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n", __func__,
+ limit << PAGE_SHIFT);
+ return -ENOMEM;
+ }
+
+ if (unlikely(disable_hugepages)) {
+ vfio_lock_acct(1);
+ return 1;
+ }
+
+ /* Lock all the consecutive pages from pfn_base */
+ for (i = 1, vaddr += PAGE_SIZE; i < npage; i++, vaddr += PAGE_SIZE) {
+ unsigned long pfn = 0;
+
+ ret = vaddr_get_pfn(vaddr, prot, &pfn);
+ if (ret)
+ break;
+
+ if (pfn != *pfn_base + i || is_invalid_reserved_pfn(pfn)) {
+ put_pfn(pfn, prot);
+ break;
+ }
+
+ if (!lock_cap && current->mm->locked_vm + i + 1 > limit) {
+ put_pfn(pfn, prot);
+ pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n",
+ __func__, limit << PAGE_SHIFT);
+ break;
+ }
+ }
+
+ vfio_lock_acct(i);
+
+ return i;
+}
+
+long vfio_unpin_pages(unsigned long pfn, long npage,
+ int prot, bool do_accounting)
+{
+ unsigned long unlocked = 0;
+ long i;
+
+ for (i = 0; i < npage; i++)
+ unlocked += put_pfn(pfn++, prot);
+
+ if (do_accounting)
+ vfio_lock_acct(-unlocked);
+
+ return unlocked;
+}
diff --git a/drivers/vfio/vfio_iommu_common.h b/drivers/vfio/vfio_iommu_common.h
new file mode 100644
index 0000000..4738391
--- /dev/null
+++ b/drivers/vfio/vfio_iommu_common.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2012 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2013 Freescale Semiconductor, Inc.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef _VFIO_IOMMU_COMMON_H
+#define _VFIO_IOMMU_COMMON_H
+
+void vfio_lock_acct_bg(struct work_struct *work);
+void vfio_lock_acct(long npage);
+bool is_invalid_reserved_pfn(unsigned long pfn);
+int put_pfn(unsigned long pfn, int prot);
+long vfio_pin_pages(unsigned long vaddr, long npage, int prot,
+ unsigned long *pfn_base);
+long vfio_unpin_pages(unsigned long pfn, long npage,
+ int prot, bool do_accounting);
+#endif
diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c
index a9807de..e9a58fa 100644
--- a/drivers/vfio/vfio_iommu_type1.c
+++ b/drivers/vfio/vfio_iommu_type1.c
@@ -37,6 +37,7 @@
#include <linux/uaccess.h>
#include <linux/vfio.h>
#include <linux/workqueue.h>
+#include "vfio_iommu_common.h"
#define DRIVER_VERSION "0.2"
#define DRIVER_AUTHOR "Alex Williamson <alex.williamson@redhat.com>"
@@ -48,12 +49,6 @@ module_param_named(allow_unsafe_interrupts,
MODULE_PARM_DESC(allow_unsafe_interrupts,
"Enable VFIO IOMMU support for on platforms without interrupt remapping support.");
-static bool disable_hugepages;
-module_param_named(disable_hugepages,
- disable_hugepages, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(disable_hugepages,
- "Disable VFIO IOMMU support for IOMMU hugepages.");
-
struct vfio_iommu {
struct iommu_domain *domain;
struct mutex lock;
@@ -123,205 +118,6 @@ static void vfio_remove_dma(struct vfio_iommu *iommu, struct vfio_dma *old)
rb_erase(&old->node, &iommu->dma_list);
}
-struct vwork {
- struct mm_struct *mm;
- long npage;
- struct work_struct work;
-};
-
-/* delayed decrement/increment for locked_vm */
-static void vfio_lock_acct_bg(struct work_struct *work)
-{
- struct vwork *vwork = container_of(work, struct vwork, work);
- struct mm_struct *mm;
-
- mm = vwork->mm;
- down_write(&mm->mmap_sem);
- mm->locked_vm += vwork->npage;
- up_write(&mm->mmap_sem);
- mmput(mm);
- kfree(vwork);
-}
-
-static void vfio_lock_acct(long npage)
-{
- struct vwork *vwork;
- struct mm_struct *mm;
-
- if (!current->mm || !npage)
- return; /* process exited or nothing to do */
-
- if (down_write_trylock(¤t->mm->mmap_sem)) {
- current->mm->locked_vm += npage;
- up_write(¤t->mm->mmap_sem);
- return;
- }
-
- /*
- * Couldn't get mmap_sem lock, so must setup to update
- * mm->locked_vm later. If locked_vm were atomic, we
- * wouldn't need this silliness
- */
- vwork = kmalloc(sizeof(struct vwork), GFP_KERNEL);
- if (!vwork)
- return;
- mm = get_task_mm(current);
- if (!mm) {
- kfree(vwork);
- return;
- }
- INIT_WORK(&vwork->work, vfio_lock_acct_bg);
- vwork->mm = mm;
- vwork->npage = npage;
- schedule_work(&vwork->work);
-}
-
-/*
- * Some mappings aren't backed by a struct page, for example an mmap'd
- * MMIO range for our own or another device. These use a different
- * pfn conversion and shouldn't be tracked as locked pages.
- */
-static bool is_invalid_reserved_pfn(unsigned long pfn)
-{
- if (pfn_valid(pfn)) {
- bool reserved;
- struct page *tail = pfn_to_page(pfn);
- struct page *head = compound_trans_head(tail);
- reserved = !!(PageReserved(head));
- if (head != tail) {
- /*
- * "head" is not a dangling pointer
- * (compound_trans_head takes care of that)
- * but the hugepage may have been split
- * from under us (and we may not hold a
- * reference count on the head page so it can
- * be reused before we run PageReferenced), so
- * we've to check PageTail before returning
- * what we just read.
- */
- smp_rmb();
- if (PageTail(tail))
- return reserved;
- }
- return PageReserved(tail);
- }
-
- return true;
-}
-
-static int put_pfn(unsigned long pfn, int prot)
-{
- if (!is_invalid_reserved_pfn(pfn)) {
- struct page *page = pfn_to_page(pfn);
- if (prot & IOMMU_WRITE)
- SetPageDirty(page);
- put_page(page);
- return 1;
- }
- return 0;
-}
-
-static int vaddr_get_pfn(unsigned long vaddr, int prot, unsigned long *pfn)
-{
- struct page *page[1];
- struct vm_area_struct *vma;
- int ret = -EFAULT;
-
- if (get_user_pages_fast(vaddr, 1, !!(prot & IOMMU_WRITE), page) == 1) {
- *pfn = page_to_pfn(page[0]);
- return 0;
- }
-
- down_read(¤t->mm->mmap_sem);
-
- vma = find_vma_intersection(current->mm, vaddr, vaddr + 1);
-
- if (vma && vma->vm_flags & VM_PFNMAP) {
- *pfn = ((vaddr - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
- if (is_invalid_reserved_pfn(*pfn))
- ret = 0;
- }
-
- up_read(¤t->mm->mmap_sem);
-
- return ret;
-}
-
-/*
- * Attempt to pin pages. We really don't want to track all the pfns and
- * the iommu can only map chunks of consecutive pfns anyway, so get the
- * first page and all consecutive pages with the same locking.
- */
-static long vfio_pin_pages(unsigned long vaddr, long npage,
- int prot, unsigned long *pfn_base)
-{
- unsigned long limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
- bool lock_cap = capable(CAP_IPC_LOCK);
- long ret, i;
-
- if (!current->mm)
- return -ENODEV;
-
- ret = vaddr_get_pfn(vaddr, prot, pfn_base);
- if (ret)
- return ret;
-
- if (is_invalid_reserved_pfn(*pfn_base))
- return 1;
-
- if (!lock_cap && current->mm->locked_vm + 1 > limit) {
- put_pfn(*pfn_base, prot);
- pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n", __func__,
- limit << PAGE_SHIFT);
- return -ENOMEM;
- }
-
- if (unlikely(disable_hugepages)) {
- vfio_lock_acct(1);
- return 1;
- }
-
- /* Lock all the consecutive pages from pfn_base */
- for (i = 1, vaddr += PAGE_SIZE; i < npage; i++, vaddr += PAGE_SIZE) {
- unsigned long pfn = 0;
-
- ret = vaddr_get_pfn(vaddr, prot, &pfn);
- if (ret)
- break;
-
- if (pfn != *pfn_base + i || is_invalid_reserved_pfn(pfn)) {
- put_pfn(pfn, prot);
- break;
- }
-
- if (!lock_cap && current->mm->locked_vm + i + 1 > limit) {
- put_pfn(pfn, prot);
- pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n",
- __func__, limit << PAGE_SHIFT);
- break;
- }
- }
-
- vfio_lock_acct(i);
-
- return i;
-}
-
-static long vfio_unpin_pages(unsigned long pfn, long npage,
- int prot, bool do_accounting)
-{
- unsigned long unlocked = 0;
- long i;
-
- for (i = 0; i < npage; i++)
- unlocked += put_pfn(pfn++, prot);
-
- if (do_accounting)
- vfio_lock_acct(-unlocked);
-
- return unlocked;
-}
-
static int vfio_unmap_unpin(struct vfio_iommu *iommu, struct vfio_dma *dma,
dma_addr_t iova, size_t *size)
{
--
1.7.0.4
^ permalink raw reply related [flat|nested] 41+ messages in thread
* [PATCH 7/7] vfio pci: Add vfio iommu implementation for FSL_PAMU
2013-09-19 7:29 [PATCH 0/7] vfio-pci: add support for Freescale IOMMU (PAMU) Bharat Bhushan
` (5 preceding siblings ...)
2013-09-19 7:29 ` [PATCH 6/7] vfio: moving some functions in common file Bharat Bhushan
@ 2013-09-19 7:29 ` Bharat Bhushan
2013-09-25 19:06 ` Alex Williamson
6 siblings, 1 reply; 41+ messages in thread
From: Bharat Bhushan @ 2013-09-19 7:29 UTC (permalink / raw)
To: alex.williamson, joro, benh, galak, linux-kernel, linuxppc-dev,
linux-pci, agraf, scottwood, iommu
Cc: Bharat Bhushan
This patch adds vfio iommu support for Freescale IOMMU
(PAMU - Peripheral Access Management Unit).
The Freescale PAMU is an aperture-based IOMMU with the following
characteristics. Each device has an entry in a table in memory
describing the iova->phys mapping. The mapping has:
-an overall aperture that is power of 2 sized, and has a start iova that
is naturally aligned
-has 1 or more windows within the aperture
-number of windows must be power of 2, max is 256
-size of each window is determined by aperture size / # of windows
-iova of each window is determined by aperture start iova / # of windows
-the mapped region in each window can be different than
the window size...mapping must power of 2
-physical address of the mapping must be naturally aligned
with the mapping size
Some of the code is derived from TYPE1 iommu (driver/vfio/vfio_iommu_type1.c).
Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
---
drivers/vfio/Kconfig | 6 +
drivers/vfio/Makefile | 1 +
drivers/vfio/vfio_iommu_fsl_pamu.c | 952 ++++++++++++++++++++++++++++++++++++
include/uapi/linux/vfio.h | 100 ++++
4 files changed, 1059 insertions(+), 0 deletions(-)
create mode 100644 drivers/vfio/vfio_iommu_fsl_pamu.c
diff --git a/drivers/vfio/Kconfig b/drivers/vfio/Kconfig
index 26b3d9d..7d1da26 100644
--- a/drivers/vfio/Kconfig
+++ b/drivers/vfio/Kconfig
@@ -8,11 +8,17 @@ config VFIO_IOMMU_SPAPR_TCE
depends on VFIO && SPAPR_TCE_IOMMU
default n
+config VFIO_IOMMU_FSL_PAMU
+ tristate
+ depends on VFIO
+ default n
+
menuconfig VFIO
tristate "VFIO Non-Privileged userspace driver framework"
depends on IOMMU_API
select VFIO_IOMMU_TYPE1 if X86
select VFIO_IOMMU_SPAPR_TCE if (PPC_POWERNV || PPC_PSERIES)
+ select VFIO_IOMMU_FSL_PAMU if FSL_PAMU
help
VFIO provides a framework for secure userspace device drivers.
See Documentation/vfio.txt for more details.
diff --git a/drivers/vfio/Makefile b/drivers/vfio/Makefile
index c5792ec..7461350 100644
--- a/drivers/vfio/Makefile
+++ b/drivers/vfio/Makefile
@@ -1,4 +1,5 @@
obj-$(CONFIG_VFIO) += vfio.o
obj-$(CONFIG_VFIO_IOMMU_TYPE1) += vfio_iommu_common.o vfio_iommu_type1.o
obj-$(CONFIG_VFIO_IOMMU_SPAPR_TCE) += vfio_iommu_common.o vfio_iommu_spapr_tce.o
+obj-$(CONFIG_VFIO_IOMMU_FSL_PAMU) += vfio_iommu_common.o vfio_iommu_fsl_pamu.o
obj-$(CONFIG_VFIO_PCI) += pci/
diff --git a/drivers/vfio/vfio_iommu_fsl_pamu.c b/drivers/vfio/vfio_iommu_fsl_pamu.c
new file mode 100644
index 0000000..b29365f
--- /dev/null
+++ b/drivers/vfio/vfio_iommu_fsl_pamu.c
@@ -0,0 +1,952 @@
+/*
+ * VFIO: IOMMU DMA mapping support for FSL PAMU IOMMU
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Copyright (C) 2013 Freescale Semiconductor, Inc.
+ *
+ * Author: Bharat Bhushan <bharat.bhushan@freescale.com>
+ *
+ * This file is derived from driver/vfio/vfio_iommu_type1.c
+ *
+ * The Freescale PAMU is an aperture-based IOMMU with the following
+ * characteristics. Each device has an entry in a table in memory
+ * describing the iova->phys mapping. The mapping has:
+ * -an overall aperture that is power of 2 sized, and has a start iova that
+ * is naturally aligned
+ * -has 1 or more windows within the aperture
+ * -number of windows must be power of 2, max is 256
+ * -size of each window is determined by aperture size / # of windows
+ * -iova of each window is determined by aperture start iova / # of windows
+ * -the mapped region in each window can be different than
+ * the window size...mapping must power of 2
+ * -physical address of the mapping must be naturally aligned
+ * with the mapping size
+ */
+
+#include <linux/compat.h>
+#include <linux/device.h>
+#include <linux/fs.h>
+#include <linux/iommu.h>
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/pci.h> /* pci_bus_type */
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/vfio.h>
+#include <linux/workqueue.h>
+#include <linux/hugetlb.h>
+#include <linux/msi.h>
+#include <asm/fsl_pamu_stash.h>
+
+#include "vfio_iommu_common.h"
+
+#define DRIVER_VERSION "0.1"
+#define DRIVER_AUTHOR "Bharat Bhushan <bharat.bhushan@freescale.com>"
+#define DRIVER_DESC "FSL PAMU IOMMU driver for VFIO"
+
+struct vfio_iommu {
+ struct iommu_domain *domain;
+ struct mutex lock;
+ dma_addr_t aperture_start;
+ dma_addr_t aperture_end;
+ dma_addr_t page_size; /* Maximum mapped Page size */
+ int nsubwindows; /* Number of subwindows */
+ struct rb_root dma_list;
+ struct list_head msi_dma_list;
+ struct list_head group_list;
+};
+
+struct vfio_dma {
+ struct rb_node node;
+ dma_addr_t iova; /* Device address */
+ unsigned long vaddr; /* Process virtual addr */
+ size_t size; /* Number of pages */
+ int prot; /* IOMMU_READ/WRITE */
+};
+
+struct vfio_msi_dma {
+ struct list_head next;
+ dma_addr_t iova; /* Device address */
+ int bank_id;
+ int prot; /* IOMMU_READ/WRITE */
+};
+
+struct vfio_group {
+ struct iommu_group *iommu_group;
+ struct list_head next;
+};
+
+static struct vfio_dma *vfio_find_dma(struct vfio_iommu *iommu,
+ dma_addr_t start, size_t size)
+{
+ struct rb_node *node = iommu->dma_list.rb_node;
+
+ while (node) {
+ struct vfio_dma *dma = rb_entry(node, struct vfio_dma, node);
+
+ if (start + size <= dma->iova)
+ node = node->rb_left;
+ else if (start >= dma->iova + dma->size)
+ node = node->rb_right;
+ else
+ return dma;
+ }
+
+ return NULL;
+}
+
+static void vfio_insert_dma(struct vfio_iommu *iommu, struct vfio_dma *new)
+{
+ struct rb_node **link = &iommu->dma_list.rb_node, *parent = NULL;
+ struct vfio_dma *dma;
+
+ while (*link) {
+ parent = *link;
+ dma = rb_entry(parent, struct vfio_dma, node);
+
+ if (new->iova + new->size <= dma->iova)
+ link = &(*link)->rb_left;
+ else
+ link = &(*link)->rb_right;
+ }
+
+ rb_link_node(&new->node, parent, link);
+ rb_insert_color(&new->node, &iommu->dma_list);
+}
+
+static void vfio_remove_dma(struct vfio_iommu *iommu, struct vfio_dma *old)
+{
+ rb_erase(&old->node, &iommu->dma_list);
+}
+
+static int iova_to_win(struct vfio_iommu *iommu, dma_addr_t iova)
+{
+ u64 offset = iova - iommu->aperture_start;
+ do_div(offset, iommu->page_size);
+ return (int) offset;
+}
+
+static int vfio_disable_iommu_domain(struct vfio_iommu *iommu)
+{
+ int enable = 0;
+ return iommu_domain_set_attr(iommu->domain,
+ DOMAIN_ATTR_FSL_PAMU_ENABLE, &enable);
+}
+
+static int vfio_enable_iommu_domain(struct vfio_iommu *iommu)
+{
+ int enable = 1;
+ return iommu_domain_set_attr(iommu->domain,
+ DOMAIN_ATTR_FSL_PAMU_ENABLE, &enable);
+}
+
+/* Unmap DMA region */
+static int vfio_unmap_unpin(struct vfio_iommu *iommu, struct vfio_dma *dma,
+ dma_addr_t iova, size_t *size)
+{
+ dma_addr_t start = iova;
+ int win, win_start, win_end;
+ long unlocked = 0;
+ unsigned int nr_pages;
+
+ nr_pages = iommu->page_size / PAGE_SIZE;
+ win_start = iova_to_win(iommu, iova);
+ win_end = iova_to_win(iommu, iova + *size - 1);
+
+ /* Release the pinned pages */
+ for (win = win_start; win <= win_end; iova += iommu->page_size, win++) {
+ unsigned long pfn;
+
+ pfn = iommu_iova_to_phys(iommu->domain, iova) >> PAGE_SHIFT;
+ if (!pfn)
+ continue;
+
+ iommu_domain_window_disable(iommu->domain, win);
+
+ unlocked += vfio_unpin_pages(pfn, nr_pages, dma->prot, 1);
+ }
+
+ vfio_lock_acct(-unlocked);
+ *size = iova - start;
+ return 0;
+}
+
+static int vfio_remove_dma_overlap(struct vfio_iommu *iommu, dma_addr_t start,
+ size_t *size, struct vfio_dma *dma)
+{
+ size_t offset, overlap, tmp;
+ struct vfio_dma *split;
+ int ret;
+
+ if (!*size)
+ return 0;
+
+ /*
+ * Existing dma region is completely covered, unmap all. This is
+ * the likely case since userspace tends to map and unmap buffers
+ * in one shot rather than multiple mappings within a buffer.
+ */
+ if (likely(start <= dma->iova &&
+ start + *size >= dma->iova + dma->size)) {
+ *size = dma->size;
+ ret = vfio_unmap_unpin(iommu, dma, dma->iova, size);
+ if (ret)
+ return ret;
+
+ /*
+ * Did we remove more than we have? Should never happen
+ * since a vfio_dma is contiguous in iova and vaddr.
+ */
+ WARN_ON(*size != dma->size);
+
+ vfio_remove_dma(iommu, dma);
+ kfree(dma);
+ return 0;
+ }
+
+ /* Overlap low address of existing range */
+ if (start <= dma->iova) {
+ overlap = start + *size - dma->iova;
+ ret = vfio_unmap_unpin(iommu, dma, dma->iova, &overlap);
+ if (ret)
+ return ret;
+
+ vfio_remove_dma(iommu, dma);
+
+ /*
+ * Check, we may have removed to whole vfio_dma. If not
+ * fixup and re-insert.
+ */
+ if (overlap < dma->size) {
+ dma->iova += overlap;
+ dma->vaddr += overlap;
+ dma->size -= overlap;
+ vfio_insert_dma(iommu, dma);
+ } else
+ kfree(dma);
+
+ *size = overlap;
+ return 0;
+ }
+
+ /* Overlap high address of existing range */
+ if (start + *size >= dma->iova + dma->size) {
+ offset = start - dma->iova;
+ overlap = dma->size - offset;
+
+ ret = vfio_unmap_unpin(iommu, dma, start, &overlap);
+ if (ret)
+ return ret;
+
+ dma->size -= overlap;
+ *size = overlap;
+ return 0;
+ }
+
+ /* Split existing */
+
+ /*
+ * Allocate our tracking structure early even though it may not
+ * be used. An Allocation failure later loses track of pages and
+ * is more difficult to unwind.
+ */
+ split = kzalloc(sizeof(*split), GFP_KERNEL);
+ if (!split)
+ return -ENOMEM;
+
+ offset = start - dma->iova;
+
+ ret = vfio_unmap_unpin(iommu, dma, start, size);
+ if (ret || !*size) {
+ kfree(split);
+ return ret;
+ }
+
+ tmp = dma->size;
+
+ /* Resize the lower vfio_dma in place, before the below insert */
+ dma->size = offset;
+
+ /* Insert new for remainder, assuming it didn't all get unmapped */
+ if (likely(offset + *size < tmp)) {
+ split->size = tmp - offset - *size;
+ split->iova = dma->iova + offset + *size;
+ split->vaddr = dma->vaddr + offset + *size;
+ split->prot = dma->prot;
+ vfio_insert_dma(iommu, split);
+ } else
+ kfree(split);
+
+ return 0;
+}
+
+/* Map DMA region */
+static int vfio_dma_map(struct vfio_iommu *iommu, dma_addr_t iova,
+ unsigned long vaddr, long npage, int prot)
+{
+ int ret = 0, i;
+ size_t size;
+ unsigned int win, nr_subwindows;
+ dma_addr_t iovamap;
+
+ /* total size to be mapped */
+ size = npage << PAGE_SHIFT;
+ do_div(size, iommu->page_size);
+ nr_subwindows = size;
+ size = npage << PAGE_SHIFT;
+ iovamap = iova;
+ for (i = 0; i < nr_subwindows; i++) {
+ unsigned long pfn;
+ unsigned long nr_pages;
+ dma_addr_t mapsize;
+ struct vfio_dma *dma = NULL;
+
+ win = iova_to_win(iommu, iovamap);
+ if (iovamap != iommu->aperture_start + iommu->page_size * win) {
+ pr_err("%s iova(%llx) unalligned to window size %llx\n",
+ __func__, iovamap, iommu->page_size);
+ ret = -EINVAL;
+ break;
+ }
+
+ mapsize = min(iova + size - iovamap, iommu->page_size);
+ /*
+ * FIXME: Currently we only support mapping page-size
+ * of subwindow-size.
+ */
+ if (mapsize < iommu->page_size) {
+ pr_err("%s iova (%llx) not alligned to window size %llx\n",
+ __func__, iovamap, iommu->page_size);
+ ret = -EINVAL;
+ break;
+ }
+
+ nr_pages = mapsize >> PAGE_SHIFT;
+
+ /* Pin a contiguous chunk of memory */
+ ret = vfio_pin_pages(vaddr, nr_pages, prot, &pfn);
+ if (ret != nr_pages) {
+ pr_err("%s unable to pin pages = %lx, pinned(%lx/%lx)\n",
+ __func__, vaddr, npage, nr_pages);
+ ret = -EINVAL;
+ break;
+ }
+
+ ret = iommu_domain_window_enable(iommu->domain, win,
+ (phys_addr_t)pfn << PAGE_SHIFT,
+ mapsize, prot);
+ if (ret) {
+ pr_err("%s unable to iommu_map()\n", __func__);
+ ret = -EINVAL;
+ break;
+ }
+
+ /*
+ * Check if we abut a region below - nothing below 0.
+ * This is the most likely case when mapping chunks of
+ * physically contiguous regions within a virtual address
+ * range. Update the abutting entry in place since iova
+ * doesn't change.
+ */
+ if (likely(iovamap)) {
+ struct vfio_dma *tmp;
+ tmp = vfio_find_dma(iommu, iovamap - 1, 1);
+ if (tmp && tmp->prot == prot &&
+ tmp->vaddr + tmp->size == vaddr) {
+ tmp->size += mapsize;
+ dma = tmp;
+ }
+ }
+
+ /*
+ * Check if we abut a region above - nothing above ~0 + 1.
+ * If we abut above and below, remove and free. If only
+ * abut above, remove, modify, reinsert.
+ */
+ if (likely(iovamap + mapsize)) {
+ struct vfio_dma *tmp;
+ tmp = vfio_find_dma(iommu, iovamap + mapsize, 1);
+ if (tmp && tmp->prot == prot &&
+ tmp->vaddr == vaddr + mapsize) {
+ vfio_remove_dma(iommu, tmp);
+ if (dma) {
+ dma->size += tmp->size;
+ kfree(tmp);
+ } else {
+ tmp->size += mapsize;
+ tmp->iova = iovamap;
+ tmp->vaddr = vaddr;
+ vfio_insert_dma(iommu, tmp);
+ dma = tmp;
+ }
+ }
+ }
+
+ if (!dma) {
+ dma = kzalloc(sizeof(*dma), GFP_KERNEL);
+ if (!dma) {
+ iommu_unmap(iommu->domain, iovamap, mapsize);
+ vfio_unpin_pages(pfn, npage, prot, true);
+ ret = -ENOMEM;
+ break;
+ }
+
+ dma->size = mapsize;
+ dma->iova = iovamap;
+ dma->vaddr = vaddr;
+ dma->prot = prot;
+ vfio_insert_dma(iommu, dma);
+ }
+
+ iovamap += mapsize;
+ vaddr += mapsize;
+ }
+
+ if (ret) {
+ struct vfio_dma *tmp;
+ while ((tmp = vfio_find_dma(iommu, iova, size))) {
+ int r = vfio_remove_dma_overlap(iommu, iova,
+ &size, tmp);
+ if (WARN_ON(r || !size))
+ break;
+ }
+ }
+
+ vfio_enable_iommu_domain(iommu);
+ return 0;
+}
+
+static int vfio_dma_do_map(struct vfio_iommu *iommu,
+ struct vfio_iommu_type1_dma_map *map)
+{
+ dma_addr_t iova = map->iova;
+ size_t size = map->size;
+ unsigned long vaddr = map->vaddr;
+ int ret = 0, prot = 0;
+ long npage;
+
+ /* READ/WRITE from device perspective */
+ if (map->flags & VFIO_DMA_MAP_FLAG_WRITE)
+ prot |= IOMMU_WRITE;
+ if (map->flags & VFIO_DMA_MAP_FLAG_READ)
+ prot |= IOMMU_READ;
+
+ if (!prot)
+ return -EINVAL; /* No READ/WRITE? */
+
+ /* Don't allow IOVA wrap */
+ if (iova + size && iova + size < iova)
+ return -EINVAL;
+
+ /* Don't allow virtual address wrap */
+ if (vaddr + size && vaddr + size < vaddr)
+ return -EINVAL;
+
+ /*
+ * FIXME: Currently we only support mapping page-size
+ * of subwindow-size.
+ */
+ if (size < iommu->page_size)
+ return -EINVAL;
+
+ npage = size >> PAGE_SHIFT;
+ if (!npage)
+ return -EINVAL;
+
+ mutex_lock(&iommu->lock);
+
+ if (vfio_find_dma(iommu, iova, size)) {
+ ret = -EEXIST;
+ goto out_lock;
+ }
+
+ vfio_dma_map(iommu, iova, vaddr, npage, prot);
+
+out_lock:
+ mutex_unlock(&iommu->lock);
+ return ret;
+}
+
+static int vfio_dma_do_unmap(struct vfio_iommu *iommu,
+ struct vfio_iommu_type1_dma_unmap *unmap)
+{
+ struct vfio_dma *dma;
+ size_t unmapped = 0, size;
+ int ret = 0;
+
+ mutex_lock(&iommu->lock);
+
+ while ((dma = vfio_find_dma(iommu, unmap->iova, unmap->size))) {
+ size = unmap->size;
+ ret = vfio_remove_dma_overlap(iommu, unmap->iova, &size, dma);
+ if (ret || !size)
+ break;
+ unmapped += size;
+ }
+
+ mutex_unlock(&iommu->lock);
+
+ /*
+ * We may unmap more than requested, update the unmap struct so
+ * userspace can know.
+ */
+ unmap->size = unmapped;
+
+ return ret;
+}
+
+static int vfio_handle_get_attr(struct vfio_iommu *iommu,
+ struct vfio_pamu_attr *pamu_attr)
+{
+ switch (pamu_attr->attribute) {
+ case VFIO_ATTR_GEOMETRY: {
+ struct iommu_domain_geometry geom;
+ if (iommu_domain_get_attr(iommu->domain,
+ DOMAIN_ATTR_GEOMETRY, &geom)) {
+ pr_err("%s Error getting domain geometry\n",
+ __func__);
+ return -EFAULT;
+ }
+
+ pamu_attr->attr_info.attr.aperture_start = geom.aperture_start;
+ pamu_attr->attr_info.attr.aperture_end = geom.aperture_end;
+ break;
+ }
+ case VFIO_ATTR_WINDOWS: {
+ u32 count;
+ if (iommu_domain_get_attr(iommu->domain,
+ DOMAIN_ATTR_WINDOWS, &count)) {
+ pr_err("%s Error getting domain windows\n",
+ __func__);
+ return -EFAULT;
+ }
+
+ pamu_attr->attr_info.windows = count;
+ break;
+ }
+ case VFIO_ATTR_PAMU_STASH: {
+ struct pamu_stash_attribute stash;
+ if (iommu_domain_get_attr(iommu->domain,
+ DOMAIN_ATTR_FSL_PAMU_STASH, &stash)) {
+ pr_err("%s Error getting domain windows\n",
+ __func__);
+ return -EFAULT;
+ }
+
+ pamu_attr->attr_info.stash.cpu = stash.cpu;
+ pamu_attr->attr_info.stash.cache = stash.cache;
+ break;
+ }
+
+ default:
+ pr_err("%s Error: Invalid attribute (%d)\n",
+ __func__, pamu_attr->attribute);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int vfio_handle_set_attr(struct vfio_iommu *iommu,
+ struct vfio_pamu_attr *pamu_attr)
+{
+ switch (pamu_attr->attribute) {
+ case VFIO_ATTR_GEOMETRY: {
+ struct iommu_domain_geometry geom;
+
+ geom.aperture_start = pamu_attr->attr_info.attr.aperture_start;
+ geom.aperture_end = pamu_attr->attr_info.attr.aperture_end;
+ iommu->aperture_start = geom.aperture_start;
+ iommu->aperture_end = geom.aperture_end;
+ geom.force_aperture = 1;
+ if (iommu_domain_set_attr(iommu->domain,
+ DOMAIN_ATTR_GEOMETRY, &geom)) {
+ pr_err("%s Error setting domain geometry\n", __func__);
+ return -EFAULT;
+ }
+
+ break;
+ }
+ case VFIO_ATTR_WINDOWS: {
+ u32 count = pamu_attr->attr_info.windows;
+ u64 size;
+ if (count > 256) {
+ pr_err("Number of subwindows requested (%d) is 256\n",
+ count);
+ return -EINVAL;
+ }
+ iommu->nsubwindows = pamu_attr->attr_info.windows;
+ size = iommu->aperture_end - iommu->aperture_start + 1;
+ do_div(size, count);
+ iommu->page_size = size;
+ if (iommu_domain_set_attr(iommu->domain,
+ DOMAIN_ATTR_WINDOWS, &count)) {
+ pr_err("%s Error getting domain windows\n",
+ __func__);
+ return -EFAULT;
+ }
+
+ break;
+ }
+ case VFIO_ATTR_PAMU_STASH: {
+ struct pamu_stash_attribute stash;
+
+ stash.cpu = pamu_attr->attr_info.stash.cpu;
+ stash.cache = pamu_attr->attr_info.stash.cache;
+ if (iommu_domain_set_attr(iommu->domain,
+ DOMAIN_ATTR_FSL_PAMU_STASH, &stash)) {
+ pr_err("%s Error getting domain windows\n",
+ __func__);
+ return -EFAULT;
+ }
+ break;
+ }
+
+ default:
+ pr_err("%s Error: Invalid attribute (%d)\n",
+ __func__, pamu_attr->attribute);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int vfio_msi_map(struct vfio_iommu *iommu,
+ struct vfio_pamu_msi_bank_map *msi_map, int prot)
+{
+ struct msi_region region;
+ int window;
+ int ret;
+
+ ret = msi_get_region(msi_map->msi_bank_index, ®ion);
+ if (ret) {
+ pr_err("%s MSI region (%d) not found\n", __func__,
+ msi_map->msi_bank_index);
+ return ret;
+ }
+
+ window = iova_to_win(iommu, msi_map->iova);
+ ret = iommu_domain_window_enable(iommu->domain, window, region.addr,
+ region.size, prot);
+ if (ret) {
+ pr_err("%s Error: unable to map msi region\n", __func__);
+ return ret;
+ }
+
+ return 0;
+}
+
+static int vfio_do_msi_map(struct vfio_iommu *iommu,
+ struct vfio_pamu_msi_bank_map *msi_map)
+{
+ struct vfio_msi_dma *msi_dma;
+ int ret, prot = 0;
+
+ /* READ/WRITE from device perspective */
+ if (msi_map->flags & VFIO_DMA_MAP_FLAG_WRITE)
+ prot |= IOMMU_WRITE;
+ if (msi_map->flags & VFIO_DMA_MAP_FLAG_READ)
+ prot |= IOMMU_READ;
+
+ if (!prot)
+ return -EINVAL; /* No READ/WRITE? */
+
+ ret = vfio_msi_map(iommu, msi_map, prot);
+ if (ret)
+ return ret;
+
+ msi_dma = kzalloc(sizeof(*msi_dma), GFP_KERNEL);
+ if (!msi_dma)
+ return -ENOMEM;
+
+ msi_dma->iova = msi_map->iova;
+ msi_dma->bank_id = msi_map->msi_bank_index;
+ list_add(&msi_dma->next, &iommu->msi_dma_list);
+ return 0;
+}
+
+static void vfio_msi_unmap(struct vfio_iommu *iommu, dma_addr_t iova)
+{
+ int window;
+ window = iova_to_win(iommu, iova);
+ iommu_domain_window_disable(iommu->domain, window);
+}
+
+static int vfio_do_msi_unmap(struct vfio_iommu *iommu,
+ struct vfio_pamu_msi_bank_unmap *msi_unmap)
+{
+ struct vfio_msi_dma *mdma, *mdma_tmp;
+
+ list_for_each_entry_safe(mdma, mdma_tmp, &iommu->msi_dma_list, next) {
+ if (mdma->iova == msi_unmap->iova) {
+ vfio_msi_unmap(iommu, mdma->iova);
+ list_del(&mdma->next);
+ kfree(mdma);
+ return 0;
+ }
+ }
+
+ return -EINVAL;
+}
+static void *vfio_iommu_fsl_pamu_open(unsigned long arg)
+{
+ struct vfio_iommu *iommu;
+
+ if (arg != VFIO_FSL_PAMU_IOMMU)
+ return ERR_PTR(-EINVAL);
+
+ iommu = kzalloc(sizeof(*iommu), GFP_KERNEL);
+ if (!iommu)
+ return ERR_PTR(-ENOMEM);
+
+ INIT_LIST_HEAD(&iommu->group_list);
+ iommu->dma_list = RB_ROOT;
+ INIT_LIST_HEAD(&iommu->msi_dma_list);
+ mutex_init(&iommu->lock);
+
+ /*
+ * Wish we didn't have to know about bus_type here.
+ */
+ iommu->domain = iommu_domain_alloc(&pci_bus_type);
+ if (!iommu->domain) {
+ kfree(iommu);
+ return ERR_PTR(-EIO);
+ }
+
+ return iommu;
+}
+
+static void vfio_iommu_fsl_pamu_release(void *iommu_data)
+{
+ struct vfio_iommu *iommu = iommu_data;
+ struct vfio_group *group, *group_tmp;
+ struct vfio_msi_dma *mdma, *mdma_tmp;
+ struct rb_node *node;
+
+ list_for_each_entry_safe(group, group_tmp, &iommu->group_list, next) {
+ iommu_detach_group(iommu->domain, group->iommu_group);
+ list_del(&group->next);
+ kfree(group);
+ }
+
+ while ((node = rb_first(&iommu->dma_list))) {
+ struct vfio_dma *dma = rb_entry(node, struct vfio_dma, node);
+ size_t size = dma->size;
+ vfio_remove_dma_overlap(iommu, dma->iova, &size, dma);
+ if (WARN_ON(!size))
+ break;
+ }
+
+ list_for_each_entry_safe(mdma, mdma_tmp, &iommu->msi_dma_list, next) {
+ vfio_msi_unmap(iommu, mdma->iova);
+ list_del(&mdma->next);
+ kfree(mdma);
+ }
+
+ iommu_domain_free(iommu->domain);
+ iommu->domain = NULL;
+ kfree(iommu);
+}
+
+static long vfio_iommu_fsl_pamu_ioctl(void *iommu_data,
+ unsigned int cmd, unsigned long arg)
+{
+ struct vfio_iommu *iommu = iommu_data;
+ unsigned long minsz;
+
+ if (cmd == VFIO_CHECK_EXTENSION) {
+ switch (arg) {
+ case VFIO_FSL_PAMU_IOMMU:
+ return 1;
+ default:
+ return 0;
+ }
+ } 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;
+
+ minsz = offsetofend(struct vfio_iommu_type1_dma_map, size);
+
+ if (copy_from_user(&map, (void __user *)arg, minsz))
+ return -EFAULT;
+
+ if (map.argsz < minsz || map.flags & ~mask)
+ return -EINVAL;
+
+ return vfio_dma_do_map(iommu, &map);
+
+ } else if (cmd == VFIO_IOMMU_UNMAP_DMA) {
+ struct vfio_iommu_type1_dma_unmap unmap;
+ long ret;
+
+ minsz = offsetofend(struct vfio_iommu_type1_dma_unmap, size);
+
+ if (copy_from_user(&unmap, (void __user *)arg, minsz))
+ return -EFAULT;
+
+ if (unmap.argsz < minsz || unmap.flags)
+ return -EINVAL;
+
+ ret = vfio_dma_do_unmap(iommu, &unmap);
+ if (ret)
+ return ret;
+
+ return copy_to_user((void __user *)arg, &unmap, minsz);
+ } else if (cmd == VFIO_IOMMU_PAMU_GET_ATTR) {
+ struct vfio_pamu_attr pamu_attr;
+
+ minsz = offsetofend(struct vfio_pamu_attr, attr_info);
+ if (copy_from_user(&pamu_attr, (void __user *)arg, minsz))
+ return -EFAULT;
+
+ if (pamu_attr.argsz < minsz)
+ return -EINVAL;
+
+ vfio_handle_get_attr(iommu, &pamu_attr);
+
+ copy_to_user((void __user *)arg, &pamu_attr, minsz);
+ return 0;
+ } else if (cmd == VFIO_IOMMU_PAMU_SET_ATTR) {
+ struct vfio_pamu_attr pamu_attr;
+
+ minsz = offsetofend(struct vfio_pamu_attr, attr_info);
+ if (copy_from_user(&pamu_attr, (void __user *)arg, minsz))
+ return -EFAULT;
+
+ if (pamu_attr.argsz < minsz)
+ return -EINVAL;
+
+ vfio_handle_set_attr(iommu, &pamu_attr);
+ return 0;
+ } else if (cmd == VFIO_IOMMU_PAMU_GET_MSI_BANK_COUNT) {
+ return msi_get_region_count();
+ } else if (cmd == VFIO_IOMMU_PAMU_MAP_MSI_BANK) {
+ struct vfio_pamu_msi_bank_map msi_map;
+
+ minsz = offsetofend(struct vfio_pamu_msi_bank_map, iova);
+ if (copy_from_user(&msi_map, (void __user *)arg, minsz))
+ return -EFAULT;
+
+ if (msi_map.argsz < minsz)
+ return -EINVAL;
+
+ vfio_do_msi_map(iommu, &msi_map);
+ return 0;
+ } else if (cmd == VFIO_IOMMU_PAMU_UNMAP_MSI_BANK) {
+ struct vfio_pamu_msi_bank_unmap msi_unmap;
+
+ minsz = offsetofend(struct vfio_pamu_msi_bank_unmap, iova);
+ if (copy_from_user(&msi_unmap, (void __user *)arg, minsz))
+ return -EFAULT;
+
+ if (msi_unmap.argsz < minsz)
+ return -EINVAL;
+
+ vfio_do_msi_unmap(iommu, &msi_unmap);
+ return 0;
+
+ }
+
+ return -ENOTTY;
+}
+
+static int vfio_iommu_fsl_pamu_attach_group(void *iommu_data,
+ struct iommu_group *iommu_group)
+{
+ struct vfio_iommu *iommu = iommu_data;
+ struct vfio_group *group, *tmp;
+ int ret;
+
+ group = kzalloc(sizeof(*group), GFP_KERNEL);
+ if (!group)
+ return -ENOMEM;
+
+ mutex_lock(&iommu->lock);
+
+ list_for_each_entry(tmp, &iommu->group_list, next) {
+ if (tmp->iommu_group == iommu_group) {
+ mutex_unlock(&iommu->lock);
+ kfree(group);
+ return -EINVAL;
+ }
+ }
+
+ ret = iommu_attach_group(iommu->domain, iommu_group);
+ if (ret) {
+ mutex_unlock(&iommu->lock);
+ kfree(group);
+ return ret;
+ }
+
+ group->iommu_group = iommu_group;
+ list_add(&group->next, &iommu->group_list);
+
+ mutex_unlock(&iommu->lock);
+
+ return 0;
+}
+
+static void vfio_iommu_fsl_pamu_detach_group(void *iommu_data,
+ struct iommu_group *iommu_group)
+{
+ struct vfio_iommu *iommu = iommu_data;
+ struct vfio_group *group;
+
+ mutex_lock(&iommu->lock);
+
+ list_for_each_entry(group, &iommu->group_list, next) {
+ if (group->iommu_group == iommu_group) {
+ iommu_detach_group(iommu->domain, iommu_group);
+ list_del(&group->next);
+ kfree(group);
+ break;
+ }
+ }
+
+ mutex_unlock(&iommu->lock);
+}
+
+static const struct vfio_iommu_driver_ops vfio_iommu_driver_ops_fsl_pamu = {
+ .name = "vfio-iommu-fsl_pamu",
+ .owner = THIS_MODULE,
+ .open = vfio_iommu_fsl_pamu_open,
+ .release = vfio_iommu_fsl_pamu_release,
+ .ioctl = vfio_iommu_fsl_pamu_ioctl,
+ .attach_group = vfio_iommu_fsl_pamu_attach_group,
+ .detach_group = vfio_iommu_fsl_pamu_detach_group,
+};
+
+static int __init vfio_iommu_fsl_pamu_init(void)
+{
+ if (!iommu_present(&pci_bus_type))
+ return -ENODEV;
+
+ return vfio_register_iommu_driver(&vfio_iommu_driver_ops_fsl_pamu);
+}
+
+static void __exit vfio_iommu_fsl_pamu_cleanup(void)
+{
+ vfio_unregister_iommu_driver(&vfio_iommu_driver_ops_fsl_pamu);
+}
+
+module_init(vfio_iommu_fsl_pamu_init);
+module_exit(vfio_iommu_fsl_pamu_cleanup);
+
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
diff --git a/include/uapi/linux/vfio.h b/include/uapi/linux/vfio.h
index 0fd47f5..d359055 100644
--- a/include/uapi/linux/vfio.h
+++ b/include/uapi/linux/vfio.h
@@ -23,6 +23,7 @@
#define VFIO_TYPE1_IOMMU 1
#define VFIO_SPAPR_TCE_IOMMU 2
+#define VFIO_FSL_PAMU_IOMMU 3
/*
* The IOCTL interface is designed for extensibility by embedding the
@@ -451,4 +452,103 @@ struct vfio_iommu_spapr_tce_info {
/* ***************************************************************** */
+/*********** APIs for VFIO_PAMU type only ****************/
+/*
+ * VFIO_IOMMU_PAMU_GET_ATTR - _IO(VFIO_TYPE, VFIO_BASE + 17,
+ * struct vfio_pamu_attr)
+ *
+ * Gets the iommu attributes for the current vfio container.
+ * Caller sets argsz and attribute. The ioctl fills in
+ * the provided struct vfio_pamu_attr based on the attribute
+ * value that was set.
+ * Return: 0 on success, -errno on failure
+ */
+struct vfio_pamu_attr {
+ __u32 argsz;
+ __u32 flags; /* no flags currently */
+#define VFIO_ATTR_GEOMETRY 0
+#define VFIO_ATTR_WINDOWS 1
+#define VFIO_ATTR_PAMU_STASH 2
+ __u32 attribute;
+
+ union {
+ /* VFIO_ATTR_GEOMETRY */
+ struct {
+ /* first addr that can be mapped */
+ __u64 aperture_start;
+ /* last addr that can be mapped */
+ __u64 aperture_end;
+ } attr;
+
+ /* VFIO_ATTR_WINDOWS */
+ __u32 windows; /* number of windows in the aperture
+ * initially this will be the max number
+ * of windows that can be set
+ */
+ /* VFIO_ATTR_PAMU_STASH */
+ struct {
+ __u32 cpu; /* CPU number for stashing */
+ __u32 cache; /* cache ID for stashing */
+ } stash;
+ } attr_info;
+};
+#define VFIO_IOMMU_PAMU_GET_ATTR _IO(VFIO_TYPE, VFIO_BASE + 17)
+
+/*
+ * VFIO_IOMMU_PAMU_SET_ATTR - _IO(VFIO_TYPE, VFIO_BASE + 18,
+ * struct vfio_pamu_attr)
+ *
+ * Sets the iommu attributes for the current vfio container.
+ * Caller sets struct vfio_pamu attr, including argsz and attribute and
+ * setting any fields that are valid for the attribute.
+ * Return: 0 on success, -errno on failure
+ */
+#define VFIO_IOMMU_PAMU_SET_ATTR _IO(VFIO_TYPE, VFIO_BASE + 18)
+
+/*
+ * VFIO_IOMMU_PAMU_GET_MSI_BANK_COUNT - _IO(VFIO_TYPE, VFIO_BASE + 19, __u32)
+ *
+ * Returns the number of MSI banks for this platform. This tells user space
+ * how many aperture windows should be reserved for MSI banks when setting
+ * the PAMU geometry and window count.
+ * Return: __u32 bank count on success, -errno on failure
+ */
+#define VFIO_IOMMU_PAMU_GET_MSI_BANK_COUNT _IO(VFIO_TYPE, VFIO_BASE + 19)
+
+/*
+ * VFIO_IOMMU_PAMU_MAP_MSI_BANK - _IO(VFIO_TYPE, VFIO_BASE + 20,
+ * struct vfio_pamu_msi_bank_map)
+ *
+ * Maps the MSI bank at the specified index and iova. User space must
+ * call this ioctl once for each MSI bank (count of banks is returned by
+ * VFIO_IOMMU_PAMU_GET_MSI_BANK_COUNT).
+ * Caller provides struct vfio_pamu_msi_bank_map with all fields set.
+ * Return: 0 on success, -errno on failure
+ */
+
+struct vfio_pamu_msi_bank_map {
+ __u32 argsz;
+ __u32 flags; /* no flags currently */
+ __u32 msi_bank_index; /* the index of the MSI bank */
+ __u64 iova; /* the iova the bank is to be mapped to */
+};
+#define VFIO_IOMMU_PAMU_MAP_MSI_BANK _IO(VFIO_TYPE, VFIO_BASE + 20)
+
+/*
+ * VFIO_IOMMU_PAMU_UNMAP_MSI_BANK - _IO(VFIO_TYPE, VFIO_BASE + 21,
+ * struct vfio_pamu_msi_bank_unmap)
+ *
+ * Unmaps the MSI bank at the specified iova.
+ * Caller provides struct vfio_pamu_msi_bank_unmap with all fields set.
+ * Operates on VFIO file descriptor (/dev/vfio/vfio).
+ * Return: 0 on success, -errno on failure
+ */
+
+struct vfio_pamu_msi_bank_unmap {
+ __u32 argsz;
+ __u32 flags; /* no flags currently */
+ __u64 iova; /* the iova to be unmapped to */
+};
+#define VFIO_IOMMU_PAMU_UNMAP_MSI_BANK _IO(VFIO_TYPE, VFIO_BASE + 21)
+
#endif /* _UAPIVFIO_H */
--
1.7.0.4
^ permalink raw reply related [flat|nested] 41+ messages in thread
* Re: [PATCH 1/7] powerpc: Add interface to get msi region information
2013-09-19 7:29 ` [PATCH 1/7] powerpc: Add interface to get msi region information Bharat Bhushan
@ 2013-09-24 23:58 ` Bjorn Helgaas
2013-10-04 5:19 ` Bhushan Bharat-R65777
2013-10-08 22:57 ` Scott Wood
1 sibling, 1 reply; 41+ messages in thread
From: Bjorn Helgaas @ 2013-09-24 23:58 UTC (permalink / raw)
To: Bharat Bhushan
Cc: agraf, joro, linux-kernel, iommu, Bharat Bhushan,
alex.williamson, linux-pci, scottwood, linuxppc-dev
On Thu, Sep 19, 2013 at 12:59:17PM +0530, Bharat Bhushan wrote:
> This patch adds interface to get following information
> - Number of MSI regions (which is number of MSI banks for powerpc).
> - Get the region address range: Physical page which have the
> address/addresses used for generating MSI interrupt
> and size of the page.
>
> These are required to create IOMMU (Freescale PAMU) mapping for
> devices which are directly assigned using VFIO.
>
> Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
> ---
> arch/powerpc/include/asm/machdep.h | 8 +++++++
> arch/powerpc/include/asm/pci.h | 2 +
> arch/powerpc/kernel/msi.c | 18 ++++++++++++++++
> arch/powerpc/sysdev/fsl_msi.c | 39 +++++++++++++++++++++++++++++++++--
> arch/powerpc/sysdev/fsl_msi.h | 11 ++++++++-
> drivers/pci/msi.c | 26 ++++++++++++++++++++++++
> include/linux/msi.h | 8 +++++++
> include/linux/pci.h | 13 ++++++++++++
> 8 files changed, 120 insertions(+), 5 deletions(-)
>
> ...
> diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
> index aca7578..6d85c15 100644
> --- a/drivers/pci/msi.c
> +++ b/drivers/pci/msi.c
> @@ -30,6 +30,20 @@ static int pci_msi_enable = 1;
>
> /* Arch hooks */
>
> +#ifndef arch_msi_get_region_count
> +int arch_msi_get_region_count(void)
> +{
> + return 0;
> +}
> +#endif
> +
> +#ifndef arch_msi_get_region
> +int arch_msi_get_region(int region_num, struct msi_region *region)
> +{
> + return 0;
> +}
> +#endif
This #define strategy is gone; see 4287d824 ("PCI: use weak functions for
MSI arch-specific functions"). Please use the weak function strategy
for your new MSI region functions.
> +
> #ifndef arch_msi_check_device
> int arch_msi_check_device(struct pci_dev *dev, int nvec, int type)
> {
> @@ -903,6 +917,18 @@ void pci_disable_msi(struct pci_dev *dev)
> }
> EXPORT_SYMBOL(pci_disable_msi);
>
> +int msi_get_region_count(void)
> +{
> + return arch_msi_get_region_count();
> +}
> +EXPORT_SYMBOL(msi_get_region_count);
> +
> +int msi_get_region(int region_num, struct msi_region *region)
> +{
> + return arch_msi_get_region(region_num, region);
> +}
> +EXPORT_SYMBOL(msi_get_region);
Please split these interface additions, i.e., the drivers/pci/msi.c,
include/linux/msi.h, and include/linux/pci.h changes, into a separate
patch.
I don't know enough about VFIO to understand why these new interfaces
are needed. Is this the first VFIO IOMMU driver? I see
vfio_iommu_spapr_tce.c and vfio_iommu_type1.c but I don't know if
they're comparable to the Freescale PAMU. Do other VFIO IOMMU
implementations support MSI? If so, do they handle the problem of
mapping the MSI regions in a different way?
> /**
> * pci_msix_table_size - return the number of device's MSI-X table entries
> * @dev: pointer to the pci_dev data structure of MSI-X device function
> diff --git a/include/linux/msi.h b/include/linux/msi.h
> index ee66f3a..ae32601 100644
> --- a/include/linux/msi.h
> +++ b/include/linux/msi.h
> @@ -50,6 +50,12 @@ struct msi_desc {
> struct kobject kobj;
> };
>
> +struct msi_region {
> + int region_num;
> + dma_addr_t addr;
> + size_t size;
> +};
This needs some sort of explanatory comment.
> /*
> * The arch hook for setup up msi irqs
> */
> @@ -58,5 +64,7 @@ void arch_teardown_msi_irq(unsigned int irq);
> int arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type);
> void arch_teardown_msi_irqs(struct pci_dev *dev);
> int arch_msi_check_device(struct pci_dev* dev, int nvec, int type);
> +int arch_msi_get_region_count(void);
> +int arch_msi_get_region(int region_num, struct msi_region *region);
>
> #endif /* LINUX_MSI_H */
> diff --git a/include/linux/pci.h b/include/linux/pci.h
> index 186540d..2b26a59 100644
> --- a/include/linux/pci.h
> +++ b/include/linux/pci.h
> @@ -1126,6 +1126,7 @@ struct msix_entry {
> u16 entry; /* driver uses to specify entry, OS writes */
> };
>
> +struct msi_region;
>
> #ifndef CONFIG_PCI_MSI
> static inline int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec)
> @@ -1168,6 +1169,16 @@ static inline int pci_msi_enabled(void)
> {
> return 0;
> }
> +
> +static inline int msi_get_region_count(void)
> +{
> + return 0;
> +}
> +
> +static inline int msi_get_region(int region_num, struct msi_region *region)
> +{
> + return 0;
> +}
> #else
> int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec);
> int pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec);
> @@ -1180,6 +1191,8 @@ void pci_disable_msix(struct pci_dev *dev);
> void msi_remove_pci_irq_vectors(struct pci_dev *dev);
> void pci_restore_msi_state(struct pci_dev *dev);
> int pci_msi_enabled(void);
> +int msi_get_region_count(void);
> +int msi_get_region(int region_num, struct msi_region *region);
> #endif
>
> #ifdef CONFIG_PCIEPORTBUS
> --
> 1.7.0.4
>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-pci" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 5/7] iommu: supress loff_t compilation error on powerpc
2013-09-19 7:29 ` [PATCH 5/7] iommu: supress loff_t compilation error on powerpc Bharat Bhushan
@ 2013-09-25 16:40 ` Alex Williamson
2013-09-26 3:53 ` Bhushan Bharat-R65777
0 siblings, 1 reply; 41+ messages in thread
From: Alex Williamson @ 2013-09-25 16:40 UTC (permalink / raw)
To: Bharat Bhushan
Cc: agraf, linux-pci, joro, linux-kernel, Bharat Bhushan, iommu,
scottwood, linuxppc-dev
On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
> ---
> drivers/vfio/pci/vfio_pci_rdwr.c | 3 ++-
> 1 files changed, 2 insertions(+), 1 deletions(-)
>
> diff --git a/drivers/vfio/pci/vfio_pci_rdwr.c b/drivers/vfio/pci/vfio_pci_rdwr.c
> index 210db24..8a8156a 100644
> --- a/drivers/vfio/pci/vfio_pci_rdwr.c
> +++ b/drivers/vfio/pci/vfio_pci_rdwr.c
> @@ -181,7 +181,8 @@ ssize_t vfio_pci_vga_rw(struct vfio_pci_device *vdev, char __user *buf,
> size_t count, loff_t *ppos, bool iswrite)
> {
> int ret;
> - loff_t off, pos = *ppos & VFIO_PCI_OFFSET_MASK;
> + loff_t off;
> + u64 pos = (u64 )(*ppos & VFIO_PCI_OFFSET_MASK);
> void __iomem *iomem = NULL;
> unsigned int rsrc;
> bool is_ioport;
What's the compile error that this fixes?
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-09-19 7:29 ` [PATCH 2/7] iommu: add api to get iommu_domain of a device Bharat Bhushan
@ 2013-09-25 16:45 ` Alex Williamson
2013-10-04 9:54 ` Bhushan Bharat-R65777
2013-10-04 10:42 ` Bhushan Bharat-R65777
0 siblings, 2 replies; 41+ messages in thread
From: Alex Williamson @ 2013-09-25 16:45 UTC (permalink / raw)
To: Bharat Bhushan
Cc: agraf, linux-pci, joro, linux-kernel, Bharat Bhushan, iommu,
scottwood, linuxppc-dev
On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> This api return the iommu domain to which the device is attached.
> The iommu_domain is required for making API calls related to iommu.
> Follow up patches which use this API to know iommu maping.
>
> Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
> ---
> drivers/iommu/iommu.c | 10 ++++++++++
> include/linux/iommu.h | 7 +++++++
> 2 files changed, 17 insertions(+), 0 deletions(-)
>
> diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
> index fbe9ca7..6ac5f50 100644
> --- a/drivers/iommu/iommu.c
> +++ b/drivers/iommu/iommu.c
> @@ -696,6 +696,16 @@ void iommu_detach_device(struct iommu_domain *domain, struct device *dev)
> }
> EXPORT_SYMBOL_GPL(iommu_detach_device);
>
> +struct iommu_domain *iommu_get_dev_domain(struct device *dev)
> +{
> + struct iommu_ops *ops = dev->bus->iommu_ops;
> +
> + if (unlikely(ops == NULL || ops->get_dev_iommu_domain == NULL))
> + return NULL;
> +
> + return ops->get_dev_iommu_domain(dev);
> +}
> +EXPORT_SYMBOL_GPL(iommu_get_dev_domain);
What prevents this from racing iommu_domain_free()? There's no
references acquired, so there's no reason for the caller to assume the
pointer is valid.
> /*
> * IOMMU groups are really the natrual working unit of the IOMMU, but
> * the IOMMU API works on domains and devices. Bridge that gap by
> diff --git a/include/linux/iommu.h b/include/linux/iommu.h
> index 7ea319e..fa046bd 100644
> --- a/include/linux/iommu.h
> +++ b/include/linux/iommu.h
> @@ -127,6 +127,7 @@ struct iommu_ops {
> int (*domain_set_windows)(struct iommu_domain *domain, u32 w_count);
> /* Get the numer of window per domain */
> u32 (*domain_get_windows)(struct iommu_domain *domain);
> + struct iommu_domain *(*get_dev_iommu_domain)(struct device *dev);
>
> unsigned long pgsize_bitmap;
> };
> @@ -190,6 +191,7 @@ extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
> phys_addr_t offset, u64 size,
> int prot);
> extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr);
> +extern struct iommu_domain *iommu_get_dev_domain(struct device *dev);
> /**
> * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
> * @domain: the iommu domain where the fault has happened
> @@ -284,6 +286,11 @@ static inline void iommu_domain_window_disable(struct iommu_domain *domain,
> {
> }
>
> +static inline struct iommu_domain *iommu_get_dev_domain(struct device *dev)
> +{
> + return NULL;
> +}
> +
> static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
> {
> return 0;
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 6/7] vfio: moving some functions in common file
2013-09-19 7:29 ` [PATCH 6/7] vfio: moving some functions in common file Bharat Bhushan
@ 2013-09-25 17:02 ` Alex Williamson
2013-09-26 3:57 ` Bhushan Bharat-R65777
0 siblings, 1 reply; 41+ messages in thread
From: Alex Williamson @ 2013-09-25 17:02 UTC (permalink / raw)
To: Bharat Bhushan
Cc: agraf, linux-pci, joro, linux-kernel, Bharat Bhushan, iommu,
scottwood, linuxppc-dev
On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> Some function defined in vfio_iommu_type1.c were common and
> we want to use these for FSL IOMMU (PAMU) and iommu-none driver.
> So some of them are moved to vfio_iommu_common.c
>
> I think we can do more of that but we will take this step by step.
>
> Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
> ---
> drivers/vfio/Makefile | 4 +-
> drivers/vfio/vfio_iommu_common.c | 235 ++++++++++++++++++++++++++++++++++++++
> drivers/vfio/vfio_iommu_common.h | 30 +++++
> drivers/vfio/vfio_iommu_type1.c | 206 +---------------------------------
> 4 files changed, 268 insertions(+), 207 deletions(-)
> create mode 100644 drivers/vfio/vfio_iommu_common.c
> create mode 100644 drivers/vfio/vfio_iommu_common.h
>
> diff --git a/drivers/vfio/Makefile b/drivers/vfio/Makefile
> index 72bfabc..c5792ec 100644
> --- a/drivers/vfio/Makefile
> +++ b/drivers/vfio/Makefile
> @@ -1,4 +1,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_IOMMU_TYPE1) += vfio_iommu_common.o vfio_iommu_type1.o
> +obj-$(CONFIG_VFIO_IOMMU_SPAPR_TCE) += vfio_iommu_common.o vfio_iommu_spapr_tce.o
> obj-$(CONFIG_VFIO_PCI) += pci/
> diff --git a/drivers/vfio/vfio_iommu_common.c b/drivers/vfio/vfio_iommu_common.c
> new file mode 100644
> index 0000000..8bdc0ea
> --- /dev/null
> +++ b/drivers/vfio/vfio_iommu_common.c
> @@ -0,0 +1,235 @@
> +/*
> + * VFIO: Common code for vfio IOMMU support
> + *
> + * Copyright (C) 2012 Red Hat, Inc. All rights reserved.
> + * Author: Alex Williamson <alex.williamson@redhat.com>
> + * Author: Bharat Bhushan <bharat.bhushan@freescale.com>
> + *
> + * 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.
> + *
> + * Derived from original vfio:
> + * Copyright 2010 Cisco Systems, Inc. All rights reserved.
> + * Author: Tom Lyon, pugs@cisco.com
> + */
> +
> +#include <linux/compat.h>
> +#include <linux/device.h>
> +#include <linux/fs.h>
> +#include <linux/iommu.h>
> +#include <linux/module.h>
> +#include <linux/mm.h>
> +#include <linux/pci.h> /* pci_bus_type */
> +#include <linux/rbtree.h>
> +#include <linux/sched.h>
> +#include <linux/slab.h>
> +#include <linux/uaccess.h>
> +#include <linux/vfio.h>
> +#include <linux/workqueue.h>
Please cleanup includes on both the source and target files. You
obviously don't need linux/pci.h here for one.
> +
> +static bool disable_hugepages;
> +module_param_named(disable_hugepages,
> + disable_hugepages, bool, S_IRUGO | S_IWUSR);
> +MODULE_PARM_DESC(disable_hugepages,
> + "Disable VFIO IOMMU support for IOMMU hugepages.");
> +
> +struct vwork {
> + struct mm_struct *mm;
> + long npage;
> + struct work_struct work;
> +};
> +
> +/* delayed decrement/increment for locked_vm */
> +void vfio_lock_acct_bg(struct work_struct *work)
> +{
> + struct vwork *vwork = container_of(work, struct vwork, work);
> + struct mm_struct *mm;
> +
> + mm = vwork->mm;
> + down_write(&mm->mmap_sem);
> + mm->locked_vm += vwork->npage;
> + up_write(&mm->mmap_sem);
> + mmput(mm);
> + kfree(vwork);
> +}
> +
> +void vfio_lock_acct(long npage)
> +{
> + struct vwork *vwork;
> + struct mm_struct *mm;
> +
> + if (!current->mm || !npage)
> + return; /* process exited or nothing to do */
> +
> + if (down_write_trylock(¤t->mm->mmap_sem)) {
> + current->mm->locked_vm += npage;
> + up_write(¤t->mm->mmap_sem);
> + return;
> + }
> +
> + /*
> + * Couldn't get mmap_sem lock, so must setup to update
> + * mm->locked_vm later. If locked_vm were atomic, we
> + * wouldn't need this silliness
> + */
> + vwork = kmalloc(sizeof(struct vwork), GFP_KERNEL);
> + if (!vwork)
> + return;
> + mm = get_task_mm(current);
> + if (!mm) {
> + kfree(vwork);
> + return;
> + }
> + INIT_WORK(&vwork->work, vfio_lock_acct_bg);
> + vwork->mm = mm;
> + vwork->npage = npage;
> + schedule_work(&vwork->work);
> +}
> +
> +/*
> + * Some mappings aren't backed by a struct page, for example an mmap'd
> + * MMIO range for our own or another device. These use a different
> + * pfn conversion and shouldn't be tracked as locked pages.
> + */
> +bool is_invalid_reserved_pfn(unsigned long pfn)
> +{
> + if (pfn_valid(pfn)) {
> + bool reserved;
> + struct page *tail = pfn_to_page(pfn);
> + struct page *head = compound_trans_head(tail);
> + reserved = !!(PageReserved(head));
> + if (head != tail) {
> + /*
> + * "head" is not a dangling pointer
> + * (compound_trans_head takes care of that)
> + * but the hugepage may have been split
> + * from under us (and we may not hold a
> + * reference count on the head page so it can
> + * be reused before we run PageReferenced), so
> + * we've to check PageTail before returning
> + * what we just read.
> + */
> + smp_rmb();
> + if (PageTail(tail))
> + return reserved;
> + }
> + return PageReserved(tail);
> + }
> +
> + return true;
> +}
> +
> +int put_pfn(unsigned long pfn, int prot)
> +{
> + if (!is_invalid_reserved_pfn(pfn)) {
> + struct page *page = pfn_to_page(pfn);
> + if (prot & IOMMU_WRITE)
> + SetPageDirty(page);
> + put_page(page);
> + return 1;
> + }
> + return 0;
> +}
> +
> +static int vaddr_get_pfn(unsigned long vaddr, int prot, unsigned long *pfn)
> +{
> + struct page *page[1];
> + struct vm_area_struct *vma;
> + int ret = -EFAULT;
> +
> + if (get_user_pages_fast(vaddr, 1, !!(prot & IOMMU_WRITE), page) == 1) {
> + *pfn = page_to_pfn(page[0]);
> + return 0;
> + }
> +
> + printk("via vma\n");
> + down_read(¤t->mm->mmap_sem);
> +
> + vma = find_vma_intersection(current->mm, vaddr, vaddr + 1);
> +
> + if (vma && vma->vm_flags & VM_PFNMAP) {
> + *pfn = ((vaddr - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
> + if (is_invalid_reserved_pfn(*pfn))
> + ret = 0;
> + }
> +
> + up_read(¤t->mm->mmap_sem);
> +
> + return ret;
> +}
> +
> +/*
> + * Attempt to pin pages. We really don't want to track all the pfns and
> + * the iommu can only map chunks of consecutive pfns anyway, so get the
> + * first page and all consecutive pages with the same locking.
> + */
> +long vfio_pin_pages(unsigned long vaddr, long npage,
> + int prot, unsigned long *pfn_base)
> +{
> + unsigned long limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
> + bool lock_cap = capable(CAP_IPC_LOCK);
> + long ret, i;
> +
> + if (!current->mm)
> + return -ENODEV;
> +
> + ret = vaddr_get_pfn(vaddr, prot, pfn_base);
> + if (ret)
> + return ret;
> +
> + if (is_invalid_reserved_pfn(*pfn_base))
> + return 1;
> +
> + if (!lock_cap && current->mm->locked_vm + 1 > limit) {
> + put_pfn(*pfn_base, prot);
> + pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n", __func__,
> + limit << PAGE_SHIFT);
> + return -ENOMEM;
> + }
> +
> + if (unlikely(disable_hugepages)) {
> + vfio_lock_acct(1);
> + return 1;
> + }
> +
> + /* Lock all the consecutive pages from pfn_base */
> + for (i = 1, vaddr += PAGE_SIZE; i < npage; i++, vaddr += PAGE_SIZE) {
> + unsigned long pfn = 0;
> +
> + ret = vaddr_get_pfn(vaddr, prot, &pfn);
> + if (ret)
> + break;
> +
> + if (pfn != *pfn_base + i || is_invalid_reserved_pfn(pfn)) {
> + put_pfn(pfn, prot);
> + break;
> + }
> +
> + if (!lock_cap && current->mm->locked_vm + i + 1 > limit) {
> + put_pfn(pfn, prot);
> + pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n",
> + __func__, limit << PAGE_SHIFT);
> + break;
> + }
> + }
> +
> + vfio_lock_acct(i);
> +
> + return i;
> +}
> +
> +long vfio_unpin_pages(unsigned long pfn, long npage,
> + int prot, bool do_accounting)
> +{
> + unsigned long unlocked = 0;
> + long i;
> +
> + for (i = 0; i < npage; i++)
> + unlocked += put_pfn(pfn++, prot);
> +
> + if (do_accounting)
> + vfio_lock_acct(-unlocked);
> +
> + return unlocked;
> +}
> diff --git a/drivers/vfio/vfio_iommu_common.h b/drivers/vfio/vfio_iommu_common.h
> new file mode 100644
> index 0000000..4738391
> --- /dev/null
> +++ b/drivers/vfio/vfio_iommu_common.h
> @@ -0,0 +1,30 @@
> +/*
> + * Copyright (C) 2012 Red Hat, Inc. All rights reserved.
> + * Copyright (C) 2013 Freescale Semiconductor, Inc.
> + *
> + * 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.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
> + */
> +
> +#ifndef _VFIO_IOMMU_COMMON_H
> +#define _VFIO_IOMMU_COMMON_H
> +
> +void vfio_lock_acct_bg(struct work_struct *work);
Does this need to be exposed?
> +void vfio_lock_acct(long npage);
> +bool is_invalid_reserved_pfn(unsigned long pfn);
> +int put_pfn(unsigned long pfn, int prot);
Why are these exposed, they only seem to be used by functions in the new
common file.
> +long vfio_pin_pages(unsigned long vaddr, long npage, int prot,
> + unsigned long *pfn_base);
> +long vfio_unpin_pages(unsigned long pfn, long npage,
> + int prot, bool do_accounting);
Can we get by with just these two and vfio_lock_acct()?
> +#endif
> diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c
> index a9807de..e9a58fa 100644
> --- a/drivers/vfio/vfio_iommu_type1.c
> +++ b/drivers/vfio/vfio_iommu_type1.c
> @@ -37,6 +37,7 @@
> #include <linux/uaccess.h>
> #include <linux/vfio.h>
> #include <linux/workqueue.h>
> +#include "vfio_iommu_common.h"
>
> #define DRIVER_VERSION "0.2"
> #define DRIVER_AUTHOR "Alex Williamson <alex.williamson@redhat.com>"
> @@ -48,12 +49,6 @@ module_param_named(allow_unsafe_interrupts,
> MODULE_PARM_DESC(allow_unsafe_interrupts,
> "Enable VFIO IOMMU support for on platforms without interrupt remapping support.");
>
> -static bool disable_hugepages;
> -module_param_named(disable_hugepages,
> - disable_hugepages, bool, S_IRUGO | S_IWUSR);
> -MODULE_PARM_DESC(disable_hugepages,
> - "Disable VFIO IOMMU support for IOMMU hugepages.");
> -
> struct vfio_iommu {
> struct iommu_domain *domain;
> struct mutex lock;
> @@ -123,205 +118,6 @@ static void vfio_remove_dma(struct vfio_iommu *iommu, struct vfio_dma *old)
> rb_erase(&old->node, &iommu->dma_list);
> }
>
> -struct vwork {
> - struct mm_struct *mm;
> - long npage;
> - struct work_struct work;
> -};
> -
> -/* delayed decrement/increment for locked_vm */
> -static void vfio_lock_acct_bg(struct work_struct *work)
> -{
> - struct vwork *vwork = container_of(work, struct vwork, work);
> - struct mm_struct *mm;
> -
> - mm = vwork->mm;
> - down_write(&mm->mmap_sem);
> - mm->locked_vm += vwork->npage;
> - up_write(&mm->mmap_sem);
> - mmput(mm);
> - kfree(vwork);
> -}
> -
> -static void vfio_lock_acct(long npage)
> -{
> - struct vwork *vwork;
> - struct mm_struct *mm;
> -
> - if (!current->mm || !npage)
> - return; /* process exited or nothing to do */
> -
> - if (down_write_trylock(¤t->mm->mmap_sem)) {
> - current->mm->locked_vm += npage;
> - up_write(¤t->mm->mmap_sem);
> - return;
> - }
> -
> - /*
> - * Couldn't get mmap_sem lock, so must setup to update
> - * mm->locked_vm later. If locked_vm were atomic, we
> - * wouldn't need this silliness
> - */
> - vwork = kmalloc(sizeof(struct vwork), GFP_KERNEL);
> - if (!vwork)
> - return;
> - mm = get_task_mm(current);
> - if (!mm) {
> - kfree(vwork);
> - return;
> - }
> - INIT_WORK(&vwork->work, vfio_lock_acct_bg);
> - vwork->mm = mm;
> - vwork->npage = npage;
> - schedule_work(&vwork->work);
> -}
> -
> -/*
> - * Some mappings aren't backed by a struct page, for example an mmap'd
> - * MMIO range for our own or another device. These use a different
> - * pfn conversion and shouldn't be tracked as locked pages.
> - */
> -static bool is_invalid_reserved_pfn(unsigned long pfn)
> -{
> - if (pfn_valid(pfn)) {
> - bool reserved;
> - struct page *tail = pfn_to_page(pfn);
> - struct page *head = compound_trans_head(tail);
> - reserved = !!(PageReserved(head));
> - if (head != tail) {
> - /*
> - * "head" is not a dangling pointer
> - * (compound_trans_head takes care of that)
> - * but the hugepage may have been split
> - * from under us (and we may not hold a
> - * reference count on the head page so it can
> - * be reused before we run PageReferenced), so
> - * we've to check PageTail before returning
> - * what we just read.
> - */
> - smp_rmb();
> - if (PageTail(tail))
> - return reserved;
> - }
> - return PageReserved(tail);
> - }
> -
> - return true;
> -}
> -
> -static int put_pfn(unsigned long pfn, int prot)
> -{
> - if (!is_invalid_reserved_pfn(pfn)) {
> - struct page *page = pfn_to_page(pfn);
> - if (prot & IOMMU_WRITE)
> - SetPageDirty(page);
> - put_page(page);
> - return 1;
> - }
> - return 0;
> -}
> -
> -static int vaddr_get_pfn(unsigned long vaddr, int prot, unsigned long *pfn)
> -{
> - struct page *page[1];
> - struct vm_area_struct *vma;
> - int ret = -EFAULT;
> -
> - if (get_user_pages_fast(vaddr, 1, !!(prot & IOMMU_WRITE), page) == 1) {
> - *pfn = page_to_pfn(page[0]);
> - return 0;
> - }
> -
> - down_read(¤t->mm->mmap_sem);
> -
> - vma = find_vma_intersection(current->mm, vaddr, vaddr + 1);
> -
> - if (vma && vma->vm_flags & VM_PFNMAP) {
> - *pfn = ((vaddr - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
> - if (is_invalid_reserved_pfn(*pfn))
> - ret = 0;
> - }
> -
> - up_read(¤t->mm->mmap_sem);
> -
> - return ret;
> -}
> -
> -/*
> - * Attempt to pin pages. We really don't want to track all the pfns and
> - * the iommu can only map chunks of consecutive pfns anyway, so get the
> - * first page and all consecutive pages with the same locking.
> - */
> -static long vfio_pin_pages(unsigned long vaddr, long npage,
> - int prot, unsigned long *pfn_base)
> -{
> - unsigned long limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
> - bool lock_cap = capable(CAP_IPC_LOCK);
> - long ret, i;
> -
> - if (!current->mm)
> - return -ENODEV;
> -
> - ret = vaddr_get_pfn(vaddr, prot, pfn_base);
> - if (ret)
> - return ret;
> -
> - if (is_invalid_reserved_pfn(*pfn_base))
> - return 1;
> -
> - if (!lock_cap && current->mm->locked_vm + 1 > limit) {
> - put_pfn(*pfn_base, prot);
> - pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n", __func__,
> - limit << PAGE_SHIFT);
> - return -ENOMEM;
> - }
> -
> - if (unlikely(disable_hugepages)) {
> - vfio_lock_acct(1);
> - return 1;
> - }
> -
> - /* Lock all the consecutive pages from pfn_base */
> - for (i = 1, vaddr += PAGE_SIZE; i < npage; i++, vaddr += PAGE_SIZE) {
> - unsigned long pfn = 0;
> -
> - ret = vaddr_get_pfn(vaddr, prot, &pfn);
> - if (ret)
> - break;
> -
> - if (pfn != *pfn_base + i || is_invalid_reserved_pfn(pfn)) {
> - put_pfn(pfn, prot);
> - break;
> - }
> -
> - if (!lock_cap && current->mm->locked_vm + i + 1 > limit) {
> - put_pfn(pfn, prot);
> - pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n",
> - __func__, limit << PAGE_SHIFT);
> - break;
> - }
> - }
> -
> - vfio_lock_acct(i);
> -
> - return i;
> -}
> -
> -static long vfio_unpin_pages(unsigned long pfn, long npage,
> - int prot, bool do_accounting)
> -{
> - unsigned long unlocked = 0;
> - long i;
> -
> - for (i = 0; i < npage; i++)
> - unlocked += put_pfn(pfn++, prot);
> -
> - if (do_accounting)
> - vfio_lock_acct(-unlocked);
> -
> - return unlocked;
> -}
> -
> static int vfio_unmap_unpin(struct vfio_iommu *iommu, struct vfio_dma *dma,
> dma_addr_t iova, size_t *size)
> {
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 7/7] vfio pci: Add vfio iommu implementation for FSL_PAMU
2013-09-19 7:29 ` [PATCH 7/7] vfio pci: Add vfio iommu implementation for FSL_PAMU Bharat Bhushan
@ 2013-09-25 19:06 ` Alex Williamson
2013-09-26 5:27 ` Bhushan Bharat-R65777
0 siblings, 1 reply; 41+ messages in thread
From: Alex Williamson @ 2013-09-25 19:06 UTC (permalink / raw)
To: Bharat Bhushan
Cc: agraf, linux-pci, joro, linux-kernel, Bharat Bhushan, iommu,
scottwood, linuxppc-dev
On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> This patch adds vfio iommu support for Freescale IOMMU
> (PAMU - Peripheral Access Management Unit).
>
> The Freescale PAMU is an aperture-based IOMMU with the following
> characteristics. Each device has an entry in a table in memory
> describing the iova->phys mapping. The mapping has:
> -an overall aperture that is power of 2 sized, and has a start iova that
> is naturally aligned
> -has 1 or more windows within the aperture
> -number of windows must be power of 2, max is 256
> -size of each window is determined by aperture size / # of windows
> -iova of each window is determined by aperture start iova / # of windows
> -the mapped region in each window can be different than
> the window size...mapping must power of 2
> -physical address of the mapping must be naturally aligned
> with the mapping size
>
> Some of the code is derived from TYPE1 iommu (driver/vfio/vfio_iommu_type1.c).
>
> Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
> ---
> drivers/vfio/Kconfig | 6 +
> drivers/vfio/Makefile | 1 +
> drivers/vfio/vfio_iommu_fsl_pamu.c | 952 ++++++++++++++++++++++++++++++++++++
> include/uapi/linux/vfio.h | 100 ++++
> 4 files changed, 1059 insertions(+), 0 deletions(-)
> create mode 100644 drivers/vfio/vfio_iommu_fsl_pamu.c
>
> diff --git a/drivers/vfio/Kconfig b/drivers/vfio/Kconfig
> index 26b3d9d..7d1da26 100644
> --- a/drivers/vfio/Kconfig
> +++ b/drivers/vfio/Kconfig
> @@ -8,11 +8,17 @@ config VFIO_IOMMU_SPAPR_TCE
> depends on VFIO && SPAPR_TCE_IOMMU
> default n
>
> +config VFIO_IOMMU_FSL_PAMU
> + tristate
> + depends on VFIO
> + default n
> +
> menuconfig VFIO
> tristate "VFIO Non-Privileged userspace driver framework"
> depends on IOMMU_API
> select VFIO_IOMMU_TYPE1 if X86
> select VFIO_IOMMU_SPAPR_TCE if (PPC_POWERNV || PPC_PSERIES)
> + select VFIO_IOMMU_FSL_PAMU if FSL_PAMU
> help
> VFIO provides a framework for secure userspace device drivers.
> See Documentation/vfio.txt for more details.
> diff --git a/drivers/vfio/Makefile b/drivers/vfio/Makefile
> index c5792ec..7461350 100644
> --- a/drivers/vfio/Makefile
> +++ b/drivers/vfio/Makefile
> @@ -1,4 +1,5 @@
> obj-$(CONFIG_VFIO) += vfio.o
> obj-$(CONFIG_VFIO_IOMMU_TYPE1) += vfio_iommu_common.o vfio_iommu_type1.o
> obj-$(CONFIG_VFIO_IOMMU_SPAPR_TCE) += vfio_iommu_common.o vfio_iommu_spapr_tce.o
> +obj-$(CONFIG_VFIO_IOMMU_FSL_PAMU) += vfio_iommu_common.o vfio_iommu_fsl_pamu.o
> obj-$(CONFIG_VFIO_PCI) += pci/
> diff --git a/drivers/vfio/vfio_iommu_fsl_pamu.c b/drivers/vfio/vfio_iommu_fsl_pamu.c
> new file mode 100644
> index 0000000..b29365f
> --- /dev/null
> +++ b/drivers/vfio/vfio_iommu_fsl_pamu.c
> @@ -0,0 +1,952 @@
> +/*
> + * VFIO: IOMMU DMA mapping support for FSL PAMU IOMMU
> + *
> + * 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.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
> + *
> + * Copyright (C) 2013 Freescale Semiconductor, Inc.
> + *
> + * Author: Bharat Bhushan <bharat.bhushan@freescale.com>
> + *
> + * This file is derived from driver/vfio/vfio_iommu_type1.c
> + *
> + * The Freescale PAMU is an aperture-based IOMMU with the following
> + * characteristics. Each device has an entry in a table in memory
> + * describing the iova->phys mapping. The mapping has:
> + * -an overall aperture that is power of 2 sized, and has a start iova that
> + * is naturally aligned
> + * -has 1 or more windows within the aperture
> + * -number of windows must be power of 2, max is 256
> + * -size of each window is determined by aperture size / # of windows
> + * -iova of each window is determined by aperture start iova / # of windows
> + * -the mapped region in each window can be different than
> + * the window size...mapping must power of 2
> + * -physical address of the mapping must be naturally aligned
> + * with the mapping size
> + */
> +
> +#include <linux/compat.h>
> +#include <linux/device.h>
> +#include <linux/fs.h>
> +#include <linux/iommu.h>
> +#include <linux/module.h>
> +#include <linux/mm.h>
> +#include <linux/pci.h> /* pci_bus_type */
> +#include <linux/sched.h>
> +#include <linux/slab.h>
> +#include <linux/uaccess.h>
> +#include <linux/vfio.h>
> +#include <linux/workqueue.h>
> +#include <linux/hugetlb.h>
> +#include <linux/msi.h>
> +#include <asm/fsl_pamu_stash.h>
> +
> +#include "vfio_iommu_common.h"
> +
> +#define DRIVER_VERSION "0.1"
> +#define DRIVER_AUTHOR "Bharat Bhushan <bharat.bhushan@freescale.com>"
> +#define DRIVER_DESC "FSL PAMU IOMMU driver for VFIO"
> +
> +struct vfio_iommu {
> + struct iommu_domain *domain;
> + struct mutex lock;
> + dma_addr_t aperture_start;
> + dma_addr_t aperture_end;
> + dma_addr_t page_size; /* Maximum mapped Page size */
> + int nsubwindows; /* Number of subwindows */
> + struct rb_root dma_list;
> + struct list_head msi_dma_list;
> + struct list_head group_list;
> +};
> +
> +struct vfio_dma {
> + struct rb_node node;
> + dma_addr_t iova; /* Device address */
> + unsigned long vaddr; /* Process virtual addr */
> + size_t size; /* Number of pages */
Is this really pages?
> + int prot; /* IOMMU_READ/WRITE */
> +};
> +
> +struct vfio_msi_dma {
> + struct list_head next;
> + dma_addr_t iova; /* Device address */
> + int bank_id;
> + int prot; /* IOMMU_READ/WRITE */
> +};
> +
> +struct vfio_group {
> + struct iommu_group *iommu_group;
> + struct list_head next;
> +};
> +
> +static struct vfio_dma *vfio_find_dma(struct vfio_iommu *iommu,
> + dma_addr_t start, size_t size)
> +{
> + struct rb_node *node = iommu->dma_list.rb_node;
> +
> + while (node) {
> + struct vfio_dma *dma = rb_entry(node, struct vfio_dma, node);
> +
> + if (start + size <= dma->iova)
> + node = node->rb_left;
> + else if (start >= dma->iova + dma->size)
because this looks more like it's bytes...
> + node = node->rb_right;
> + else
> + return dma;
> + }
> +
> + return NULL;
> +}
> +
> +static void vfio_insert_dma(struct vfio_iommu *iommu, struct vfio_dma *new)
> +{
> + struct rb_node **link = &iommu->dma_list.rb_node, *parent = NULL;
> + struct vfio_dma *dma;
> +
> + while (*link) {
> + parent = *link;
> + dma = rb_entry(parent, struct vfio_dma, node);
> +
> + if (new->iova + new->size <= dma->iova)
so does this...
> + link = &(*link)->rb_left;
> + else
> + link = &(*link)->rb_right;
> + }
> +
> + rb_link_node(&new->node, parent, link);
> + rb_insert_color(&new->node, &iommu->dma_list);
> +}
> +
> +static void vfio_remove_dma(struct vfio_iommu *iommu, struct vfio_dma *old)
> +{
> + rb_erase(&old->node, &iommu->dma_list);
> +}
So if your vfio_dma.size is actually in bytes, why isn't all this code
in common?
> +
> +static int iova_to_win(struct vfio_iommu *iommu, dma_addr_t iova)
> +{
> + u64 offset = iova - iommu->aperture_start;
> + do_div(offset, iommu->page_size);
> + return (int) offset;
> +}
> +
> +static int vfio_disable_iommu_domain(struct vfio_iommu *iommu)
> +{
> + int enable = 0;
> + return iommu_domain_set_attr(iommu->domain,
> + DOMAIN_ATTR_FSL_PAMU_ENABLE, &enable);
> +}
This is never called?!
> +
> +static int vfio_enable_iommu_domain(struct vfio_iommu *iommu)
> +{
> + int enable = 1;
> + return iommu_domain_set_attr(iommu->domain,
> + DOMAIN_ATTR_FSL_PAMU_ENABLE, &enable);
> +}
> +
> +/* Unmap DMA region */
> +static int vfio_unmap_unpin(struct vfio_iommu *iommu, struct vfio_dma *dma,
> + dma_addr_t iova, size_t *size)
> +{
> + dma_addr_t start = iova;
> + int win, win_start, win_end;
> + long unlocked = 0;
> + unsigned int nr_pages;
> +
> + nr_pages = iommu->page_size / PAGE_SIZE;
> + win_start = iova_to_win(iommu, iova);
> + win_end = iova_to_win(iommu, iova + *size - 1);
> +
> + /* Release the pinned pages */
> + for (win = win_start; win <= win_end; iova += iommu->page_size, win++) {
> + unsigned long pfn;
> +
> + pfn = iommu_iova_to_phys(iommu->domain, iova) >> PAGE_SHIFT;
> + if (!pfn)
> + continue;
> +
> + iommu_domain_window_disable(iommu->domain, win);
> +
> + unlocked += vfio_unpin_pages(pfn, nr_pages, dma->prot, 1);
> + }
> +
> + vfio_lock_acct(-unlocked);
> + *size = iova - start;
> + return 0;
> +}
> +
> +static int vfio_remove_dma_overlap(struct vfio_iommu *iommu, dma_addr_t start,
> + size_t *size, struct vfio_dma *dma)
> +{
> + size_t offset, overlap, tmp;
> + struct vfio_dma *split;
> + int ret;
> +
> + if (!*size)
> + return 0;
> +
> + /*
> + * Existing dma region is completely covered, unmap all. This is
> + * the likely case since userspace tends to map and unmap buffers
> + * in one shot rather than multiple mappings within a buffer.
> + */
> + if (likely(start <= dma->iova &&
> + start + *size >= dma->iova + dma->size)) {
> + *size = dma->size;
> + ret = vfio_unmap_unpin(iommu, dma, dma->iova, size);
> + if (ret)
> + return ret;
> +
> + /*
> + * Did we remove more than we have? Should never happen
> + * since a vfio_dma is contiguous in iova and vaddr.
> + */
> + WARN_ON(*size != dma->size);
> +
> + vfio_remove_dma(iommu, dma);
> + kfree(dma);
> + return 0;
> + }
> +
> + /* Overlap low address of existing range */
> + if (start <= dma->iova) {
> + overlap = start + *size - dma->iova;
> + ret = vfio_unmap_unpin(iommu, dma, dma->iova, &overlap);
> + if (ret)
> + return ret;
> +
> + vfio_remove_dma(iommu, dma);
> +
> + /*
> + * Check, we may have removed to whole vfio_dma. If not
> + * fixup and re-insert.
> + */
> + if (overlap < dma->size) {
> + dma->iova += overlap;
> + dma->vaddr += overlap;
> + dma->size -= overlap;
> + vfio_insert_dma(iommu, dma);
> + } else
> + kfree(dma);
> +
> + *size = overlap;
> + return 0;
> + }
> +
> + /* Overlap high address of existing range */
> + if (start + *size >= dma->iova + dma->size) {
> + offset = start - dma->iova;
> + overlap = dma->size - offset;
> +
> + ret = vfio_unmap_unpin(iommu, dma, start, &overlap);
> + if (ret)
> + return ret;
> +
> + dma->size -= overlap;
> + *size = overlap;
> + return 0;
> + }
> +
> + /* Split existing */
> +
> + /*
> + * Allocate our tracking structure early even though it may not
> + * be used. An Allocation failure later loses track of pages and
> + * is more difficult to unwind.
> + */
> + split = kzalloc(sizeof(*split), GFP_KERNEL);
> + if (!split)
> + return -ENOMEM;
> +
> + offset = start - dma->iova;
> +
> + ret = vfio_unmap_unpin(iommu, dma, start, size);
> + if (ret || !*size) {
> + kfree(split);
> + return ret;
> + }
> +
> + tmp = dma->size;
> +
> + /* Resize the lower vfio_dma in place, before the below insert */
> + dma->size = offset;
> +
> + /* Insert new for remainder, assuming it didn't all get unmapped */
> + if (likely(offset + *size < tmp)) {
> + split->size = tmp - offset - *size;
> + split->iova = dma->iova + offset + *size;
> + split->vaddr = dma->vaddr + offset + *size;
> + split->prot = dma->prot;
> + vfio_insert_dma(iommu, split);
> + } else
> + kfree(split);
> +
> + return 0;
> +}
Hmm, this looks identical to type1, can we share more?
> +
> +/* Map DMA region */
> +static int vfio_dma_map(struct vfio_iommu *iommu, dma_addr_t iova,
> + unsigned long vaddr, long npage, int prot)
> +{
> + int ret = 0, i;
> + size_t size;
> + unsigned int win, nr_subwindows;
> + dma_addr_t iovamap;
> +
> + /* total size to be mapped */
> + size = npage << PAGE_SHIFT;
> + do_div(size, iommu->page_size);
> + nr_subwindows = size;
> + size = npage << PAGE_SHIFT;
Is all this do_div() stuff necessary? If page_size is a power of two,
just shift it.
> + iovamap = iova;
> + for (i = 0; i < nr_subwindows; i++) {
> + unsigned long pfn;
> + unsigned long nr_pages;
> + dma_addr_t mapsize;
> + struct vfio_dma *dma = NULL;
> +
> + win = iova_to_win(iommu, iovamap);
Aren't these consecutive, why can't we just increment?
> + if (iovamap != iommu->aperture_start + iommu->page_size * win) {
> + pr_err("%s iova(%llx) unalligned to window size %llx\n",
> + __func__, iovamap, iommu->page_size);
> + ret = -EINVAL;
> + break;
> + }
Can't this only happen on the first one? Seems like it should be
outside of the loop. What about alignment with the end of the window,
do you care? Check spelling in your warning, but better yet, get rid of
it, this doesn't seem like something we need to error on.
> +
> + mapsize = min(iova + size - iovamap, iommu->page_size);
> + /*
> + * FIXME: Currently we only support mapping page-size
> + * of subwindow-size.
> + */
> + if (mapsize < iommu->page_size) {
> + pr_err("%s iova (%llx) not alligned to window size %llx\n",
> + __func__, iovamap, iommu->page_size);
> + ret = -EINVAL;
> + break;
> + }
So you do care about the end alignment, but why can't we error for both
of these in advance?
> +
> + nr_pages = mapsize >> PAGE_SHIFT;
> +
> + /* Pin a contiguous chunk of memory */
> + ret = vfio_pin_pages(vaddr, nr_pages, prot, &pfn);
> + if (ret != nr_pages) {
> + pr_err("%s unable to pin pages = %lx, pinned(%lx/%lx)\n",
> + __func__, vaddr, npage, nr_pages);
> + ret = -EINVAL;
> + break;
> + }
How likely is this to succeed? It seems like we're relying on userspace
to use hugepages to make this work.
> +
> + ret = iommu_domain_window_enable(iommu->domain, win,
> + (phys_addr_t)pfn << PAGE_SHIFT,
> + mapsize, prot);
> + if (ret) {
> + pr_err("%s unable to iommu_map()\n", __func__);
> + ret = -EINVAL;
> + break;
> + }
You might consider how many cases you're returning EINVAL and think
about how difficult this will be to debug. I don't think we can leave
all these pr_err()s since it gives userspace a trivial way to spam log
files.
> +
> + /*
> + * Check if we abut a region below - nothing below 0.
> + * This is the most likely case when mapping chunks of
> + * physically contiguous regions within a virtual address
> + * range. Update the abutting entry in place since iova
> + * doesn't change.
> + */
> + if (likely(iovamap)) {
> + struct vfio_dma *tmp;
> + tmp = vfio_find_dma(iommu, iovamap - 1, 1);
> + if (tmp && tmp->prot == prot &&
> + tmp->vaddr + tmp->size == vaddr) {
> + tmp->size += mapsize;
> + dma = tmp;
> + }
> + }
> +
> + /*
> + * Check if we abut a region above - nothing above ~0 + 1.
> + * If we abut above and below, remove and free. If only
> + * abut above, remove, modify, reinsert.
> + */
> + if (likely(iovamap + mapsize)) {
> + struct vfio_dma *tmp;
> + tmp = vfio_find_dma(iommu, iovamap + mapsize, 1);
> + if (tmp && tmp->prot == prot &&
> + tmp->vaddr == vaddr + mapsize) {
> + vfio_remove_dma(iommu, tmp);
> + if (dma) {
> + dma->size += tmp->size;
> + kfree(tmp);
> + } else {
> + tmp->size += mapsize;
> + tmp->iova = iovamap;
> + tmp->vaddr = vaddr;
> + vfio_insert_dma(iommu, tmp);
> + dma = tmp;
> + }
> + }
> + }
> +
> + if (!dma) {
> + dma = kzalloc(sizeof(*dma), GFP_KERNEL);
> + if (!dma) {
> + iommu_unmap(iommu->domain, iovamap, mapsize);
> + vfio_unpin_pages(pfn, npage, prot, true);
> + ret = -ENOMEM;
> + break;
> + }
> +
> + dma->size = mapsize;
> + dma->iova = iovamap;
> + dma->vaddr = vaddr;
> + dma->prot = prot;
> + vfio_insert_dma(iommu, dma);
> + }
> +
> + iovamap += mapsize;
> + vaddr += mapsize;
Another chunk that looks like it's probably identical to type1. Can we
rip this out to another function and add it to common?
> + }
> +
> + if (ret) {
> + struct vfio_dma *tmp;
> + while ((tmp = vfio_find_dma(iommu, iova, size))) {
> + int r = vfio_remove_dma_overlap(iommu, iova,
> + &size, tmp);
> + if (WARN_ON(r || !size))
> + break;
> + }
> + }
Broken whitespace, please run scripts/checkpatch.pl before posting.
> +
> + vfio_enable_iommu_domain(iommu);
I don't quite understand your semantics here since you never use the
disable version, is this just redundant after the first mapping? When
dma_list is empty should it be disabled? Is there a bug here that an
error will enable the iommu domain even if there are no entries?
> + return 0;
> +}
> +
> +static int vfio_dma_do_map(struct vfio_iommu *iommu,
> + struct vfio_iommu_type1_dma_map *map)
> +{
> + dma_addr_t iova = map->iova;
> + size_t size = map->size;
> + unsigned long vaddr = map->vaddr;
> + int ret = 0, prot = 0;
> + long npage;
> +
> + /* READ/WRITE from device perspective */
> + if (map->flags & VFIO_DMA_MAP_FLAG_WRITE)
> + prot |= IOMMU_WRITE;
> + if (map->flags & VFIO_DMA_MAP_FLAG_READ)
> + prot |= IOMMU_READ;
> +
> + if (!prot)
> + return -EINVAL; /* No READ/WRITE? */
> +
> + /* Don't allow IOVA wrap */
> + if (iova + size && iova + size < iova)
> + return -EINVAL;
> +
> + /* Don't allow virtual address wrap */
> + if (vaddr + size && vaddr + size < vaddr)
> + return -EINVAL;
> +
> + /*
> + * FIXME: Currently we only support mapping page-size
> + * of subwindow-size.
> + */
> + if (size < iommu->page_size)
> + return -EINVAL;
> +
I'd think the start and end alignment could be tested here.
> + npage = size >> PAGE_SHIFT;
> + if (!npage)
> + return -EINVAL;
> +
> + mutex_lock(&iommu->lock);
> +
> + if (vfio_find_dma(iommu, iova, size)) {
> + ret = -EEXIST;
> + goto out_lock;
> + }
> +
> + vfio_dma_map(iommu, iova, vaddr, npage, prot);
> +
> +out_lock:
> + mutex_unlock(&iommu->lock);
> + return ret;
> +}
> +
> +static int vfio_dma_do_unmap(struct vfio_iommu *iommu,
> + struct vfio_iommu_type1_dma_unmap *unmap)
> +{
> + struct vfio_dma *dma;
> + size_t unmapped = 0, size;
> + int ret = 0;
> +
> + mutex_lock(&iommu->lock);
> +
> + while ((dma = vfio_find_dma(iommu, unmap->iova, unmap->size))) {
> + size = unmap->size;
> + ret = vfio_remove_dma_overlap(iommu, unmap->iova, &size, dma);
> + if (ret || !size)
> + break;
> + unmapped += size;
> + }
> +
> + mutex_unlock(&iommu->lock);
> +
> + /*
> + * We may unmap more than requested, update the unmap struct so
> + * userspace can know.
> + */
> + unmap->size = unmapped;
> +
> + return ret;
> +}
> +
> +static int vfio_handle_get_attr(struct vfio_iommu *iommu,
> + struct vfio_pamu_attr *pamu_attr)
> +{
> + switch (pamu_attr->attribute) {
> + case VFIO_ATTR_GEOMETRY: {
> + struct iommu_domain_geometry geom;
> + if (iommu_domain_get_attr(iommu->domain,
> + DOMAIN_ATTR_GEOMETRY, &geom)) {
> + pr_err("%s Error getting domain geometry\n",
> + __func__);
> + return -EFAULT;
> + }
> +
> + pamu_attr->attr_info.attr.aperture_start = geom.aperture_start;
> + pamu_attr->attr_info.attr.aperture_end = geom.aperture_end;
> + break;
> + }
> + case VFIO_ATTR_WINDOWS: {
> + u32 count;
> + if (iommu_domain_get_attr(iommu->domain,
> + DOMAIN_ATTR_WINDOWS, &count)) {
> + pr_err("%s Error getting domain windows\n",
> + __func__);
> + return -EFAULT;
> + }
> +
> + pamu_attr->attr_info.windows = count;
> + break;
> + }
> + case VFIO_ATTR_PAMU_STASH: {
> + struct pamu_stash_attribute stash;
> + if (iommu_domain_get_attr(iommu->domain,
> + DOMAIN_ATTR_FSL_PAMU_STASH, &stash)) {
> + pr_err("%s Error getting domain windows\n",
> + __func__);
> + return -EFAULT;
> + }
> +
> + pamu_attr->attr_info.stash.cpu = stash.cpu;
> + pamu_attr->attr_info.stash.cache = stash.cache;
> + break;
> + }
> +
> + default:
> + pr_err("%s Error: Invalid attribute (%d)\n",
> + __func__, pamu_attr->attribute);
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int vfio_handle_set_attr(struct vfio_iommu *iommu,
> + struct vfio_pamu_attr *pamu_attr)
> +{
> + switch (pamu_attr->attribute) {
> + case VFIO_ATTR_GEOMETRY: {
> + struct iommu_domain_geometry geom;
> +
> + geom.aperture_start = pamu_attr->attr_info.attr.aperture_start;
> + geom.aperture_end = pamu_attr->attr_info.attr.aperture_end;
> + iommu->aperture_start = geom.aperture_start;
> + iommu->aperture_end = geom.aperture_end;
> + geom.force_aperture = 1;
> + if (iommu_domain_set_attr(iommu->domain,
> + DOMAIN_ATTR_GEOMETRY, &geom)) {
> + pr_err("%s Error setting domain geometry\n", __func__);
> + return -EFAULT;
> + }
> +
> + break;
> + }
> + case VFIO_ATTR_WINDOWS: {
> + u32 count = pamu_attr->attr_info.windows;
> + u64 size;
> + if (count > 256) {
> + pr_err("Number of subwindows requested (%d) is 256\n",
> + count);
> + return -EINVAL;
> + }
> + iommu->nsubwindows = pamu_attr->attr_info.windows;
> + size = iommu->aperture_end - iommu->aperture_start + 1;
> + do_div(size, count);
> + iommu->page_size = size;
> + if (iommu_domain_set_attr(iommu->domain,
> + DOMAIN_ATTR_WINDOWS, &count)) {
> + pr_err("%s Error getting domain windows\n",
> + __func__);
> + return -EFAULT;
> + }
> +
> + break;
> + }
> + case VFIO_ATTR_PAMU_STASH: {
> + struct pamu_stash_attribute stash;
> +
> + stash.cpu = pamu_attr->attr_info.stash.cpu;
> + stash.cache = pamu_attr->attr_info.stash.cache;
> + if (iommu_domain_set_attr(iommu->domain,
> + DOMAIN_ATTR_FSL_PAMU_STASH, &stash)) {
> + pr_err("%s Error getting domain windows\n",
> + __func__);
> + return -EFAULT;
> + }
> + break;
Why do we throw away the return value of iommu_domain_set_attr and
replace it with EFAULT in all these cases? I assume all these pr_err()s
are leftover debug. Can the user do anything they shouldn't through
these? How do we guarantee that?
> + }
> +
> + default:
> + pr_err("%s Error: Invalid attribute (%d)\n",
> + __func__, pamu_attr->attribute);
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int vfio_msi_map(struct vfio_iommu *iommu,
> + struct vfio_pamu_msi_bank_map *msi_map, int prot)
> +{
> + struct msi_region region;
> + int window;
> + int ret;
> +
> + ret = msi_get_region(msi_map->msi_bank_index, ®ion);
> + if (ret) {
> + pr_err("%s MSI region (%d) not found\n", __func__,
> + msi_map->msi_bank_index);
> + return ret;
> + }
> +
> + window = iova_to_win(iommu, msi_map->iova);
> + ret = iommu_domain_window_enable(iommu->domain, window, region.addr,
> + region.size, prot);
> + if (ret) {
> + pr_err("%s Error: unable to map msi region\n", __func__);
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int vfio_do_msi_map(struct vfio_iommu *iommu,
> + struct vfio_pamu_msi_bank_map *msi_map)
> +{
> + struct vfio_msi_dma *msi_dma;
> + int ret, prot = 0;
> +
> + /* READ/WRITE from device perspective */
> + if (msi_map->flags & VFIO_DMA_MAP_FLAG_WRITE)
> + prot |= IOMMU_WRITE;
> + if (msi_map->flags & VFIO_DMA_MAP_FLAG_READ)
> + prot |= IOMMU_READ;
> +
> + if (!prot)
> + return -EINVAL; /* No READ/WRITE? */
> +
> + ret = vfio_msi_map(iommu, msi_map, prot);
> + if (ret)
> + return ret;
> +
> + msi_dma = kzalloc(sizeof(*msi_dma), GFP_KERNEL);
> + if (!msi_dma)
> + return -ENOMEM;
> +
> + msi_dma->iova = msi_map->iova;
> + msi_dma->bank_id = msi_map->msi_bank_index;
> + list_add(&msi_dma->next, &iommu->msi_dma_list);
> + return 0;
What happens when the user creates multiple MSI mappings at the same
iova? What happens when DMA mappings overlap MSI mappings? Shouldn't
there be some locking around list manipulation?
> +}
> +
> +static void vfio_msi_unmap(struct vfio_iommu *iommu, dma_addr_t iova)
> +{
> + int window;
> + window = iova_to_win(iommu, iova);
> + iommu_domain_window_disable(iommu->domain, window);
> +}
> +
> +static int vfio_do_msi_unmap(struct vfio_iommu *iommu,
> + struct vfio_pamu_msi_bank_unmap *msi_unmap)
> +{
> + struct vfio_msi_dma *mdma, *mdma_tmp;
> +
> + list_for_each_entry_safe(mdma, mdma_tmp, &iommu->msi_dma_list, next) {
> + if (mdma->iova == msi_unmap->iova) {
> + vfio_msi_unmap(iommu, mdma->iova);
> + list_del(&mdma->next);
> + kfree(mdma);
> + return 0;
> + }
> + }
> +
> + return -EINVAL;
> +}
> +static void *vfio_iommu_fsl_pamu_open(unsigned long arg)
> +{
> + struct vfio_iommu *iommu;
> +
> + if (arg != VFIO_FSL_PAMU_IOMMU)
> + return ERR_PTR(-EINVAL);
> +
> + iommu = kzalloc(sizeof(*iommu), GFP_KERNEL);
> + if (!iommu)
> + return ERR_PTR(-ENOMEM);
> +
> + INIT_LIST_HEAD(&iommu->group_list);
> + iommu->dma_list = RB_ROOT;
> + INIT_LIST_HEAD(&iommu->msi_dma_list);
> + mutex_init(&iommu->lock);
> +
> + /*
> + * Wish we didn't have to know about bus_type here.
> + */
> + iommu->domain = iommu_domain_alloc(&pci_bus_type);
> + if (!iommu->domain) {
> + kfree(iommu);
> + return ERR_PTR(-EIO);
> + }
> +
> + return iommu;
> +}
> +
> +static void vfio_iommu_fsl_pamu_release(void *iommu_data)
> +{
> + struct vfio_iommu *iommu = iommu_data;
> + struct vfio_group *group, *group_tmp;
> + struct vfio_msi_dma *mdma, *mdma_tmp;
> + struct rb_node *node;
> +
> + list_for_each_entry_safe(group, group_tmp, &iommu->group_list, next) {
> + iommu_detach_group(iommu->domain, group->iommu_group);
> + list_del(&group->next);
> + kfree(group);
> + }
> +
> + while ((node = rb_first(&iommu->dma_list))) {
> + struct vfio_dma *dma = rb_entry(node, struct vfio_dma, node);
> + size_t size = dma->size;
> + vfio_remove_dma_overlap(iommu, dma->iova, &size, dma);
> + if (WARN_ON(!size))
> + break;
> + }
> +
> + list_for_each_entry_safe(mdma, mdma_tmp, &iommu->msi_dma_list, next) {
> + vfio_msi_unmap(iommu, mdma->iova);
> + list_del(&mdma->next);
> + kfree(mdma);
> + }
> +
> + iommu_domain_free(iommu->domain);
> + iommu->domain = NULL;
> + kfree(iommu);
> +}
> +
> +static long vfio_iommu_fsl_pamu_ioctl(void *iommu_data,
> + unsigned int cmd, unsigned long arg)
> +{
> + struct vfio_iommu *iommu = iommu_data;
> + unsigned long minsz;
> +
> + if (cmd == VFIO_CHECK_EXTENSION) {
> + switch (arg) {
> + case VFIO_FSL_PAMU_IOMMU:
> + return 1;
> + default:
> + return 0;
> + }
> + } 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;
> +
> + minsz = offsetofend(struct vfio_iommu_type1_dma_map, size);
> +
> + if (copy_from_user(&map, (void __user *)arg, minsz))
> + return -EFAULT;
> +
> + if (map.argsz < minsz || map.flags & ~mask)
> + return -EINVAL;
> +
> + return vfio_dma_do_map(iommu, &map);
> +
> + } else if (cmd == VFIO_IOMMU_UNMAP_DMA) {
> + struct vfio_iommu_type1_dma_unmap unmap;
> + long ret;
> +
> + minsz = offsetofend(struct vfio_iommu_type1_dma_unmap, size);
> +
> + if (copy_from_user(&unmap, (void __user *)arg, minsz))
> + return -EFAULT;
> +
> + if (unmap.argsz < minsz || unmap.flags)
> + return -EINVAL;
> +
> + ret = vfio_dma_do_unmap(iommu, &unmap);
> + if (ret)
> + return ret;
> +
> + return copy_to_user((void __user *)arg, &unmap, minsz);
> + } else if (cmd == VFIO_IOMMU_PAMU_GET_ATTR) {
> + struct vfio_pamu_attr pamu_attr;
> +
> + minsz = offsetofend(struct vfio_pamu_attr, attr_info);
> + if (copy_from_user(&pamu_attr, (void __user *)arg, minsz))
> + return -EFAULT;
> +
> + if (pamu_attr.argsz < minsz)
> + return -EINVAL;
> +
> + vfio_handle_get_attr(iommu, &pamu_attr);
> +
> + copy_to_user((void __user *)arg, &pamu_attr, minsz);
> + return 0;
> + } else if (cmd == VFIO_IOMMU_PAMU_SET_ATTR) {
> + struct vfio_pamu_attr pamu_attr;
> +
> + minsz = offsetofend(struct vfio_pamu_attr, attr_info);
> + if (copy_from_user(&pamu_attr, (void __user *)arg, minsz))
> + return -EFAULT;
> +
> + if (pamu_attr.argsz < minsz)
> + return -EINVAL;
> +
> + vfio_handle_set_attr(iommu, &pamu_attr);
> + return 0;
> + } else if (cmd == VFIO_IOMMU_PAMU_GET_MSI_BANK_COUNT) {
> + return msi_get_region_count();
> + } else if (cmd == VFIO_IOMMU_PAMU_MAP_MSI_BANK) {
> + struct vfio_pamu_msi_bank_map msi_map;
> +
> + minsz = offsetofend(struct vfio_pamu_msi_bank_map, iova);
> + if (copy_from_user(&msi_map, (void __user *)arg, minsz))
> + return -EFAULT;
> +
> + if (msi_map.argsz < minsz)
> + return -EINVAL;
> +
> + vfio_do_msi_map(iommu, &msi_map);
> + return 0;
> + } else if (cmd == VFIO_IOMMU_PAMU_UNMAP_MSI_BANK) {
> + struct vfio_pamu_msi_bank_unmap msi_unmap;
> +
> + minsz = offsetofend(struct vfio_pamu_msi_bank_unmap, iova);
> + if (copy_from_user(&msi_unmap, (void __user *)arg, minsz))
> + return -EFAULT;
> +
> + if (msi_unmap.argsz < minsz)
> + return -EINVAL;
> +
> + vfio_do_msi_unmap(iommu, &msi_unmap);
> + return 0;
> +
> + }
> +
> + return -ENOTTY;
> +}
> +
> +static int vfio_iommu_fsl_pamu_attach_group(void *iommu_data,
> + struct iommu_group *iommu_group)
> +{
> + struct vfio_iommu *iommu = iommu_data;
> + struct vfio_group *group, *tmp;
> + int ret;
> +
> + group = kzalloc(sizeof(*group), GFP_KERNEL);
> + if (!group)
> + return -ENOMEM;
> +
> + mutex_lock(&iommu->lock);
> +
> + list_for_each_entry(tmp, &iommu->group_list, next) {
> + if (tmp->iommu_group == iommu_group) {
> + mutex_unlock(&iommu->lock);
> + kfree(group);
> + return -EINVAL;
> + }
> + }
> +
> + ret = iommu_attach_group(iommu->domain, iommu_group);
> + if (ret) {
> + mutex_unlock(&iommu->lock);
> + kfree(group);
> + return ret;
> + }
> +
> + group->iommu_group = iommu_group;
> + list_add(&group->next, &iommu->group_list);
> +
> + mutex_unlock(&iommu->lock);
> +
> + return 0;
> +}
> +
> +static void vfio_iommu_fsl_pamu_detach_group(void *iommu_data,
> + struct iommu_group *iommu_group)
> +{
> + struct vfio_iommu *iommu = iommu_data;
> + struct vfio_group *group;
> +
> + mutex_lock(&iommu->lock);
> +
> + list_for_each_entry(group, &iommu->group_list, next) {
> + if (group->iommu_group == iommu_group) {
> + iommu_detach_group(iommu->domain, iommu_group);
> + list_del(&group->next);
> + kfree(group);
> + break;
> + }
> + }
> +
> + mutex_unlock(&iommu->lock);
> +}
> +
> +static const struct vfio_iommu_driver_ops vfio_iommu_driver_ops_fsl_pamu = {
> + .name = "vfio-iommu-fsl_pamu",
> + .owner = THIS_MODULE,
> + .open = vfio_iommu_fsl_pamu_open,
> + .release = vfio_iommu_fsl_pamu_release,
> + .ioctl = vfio_iommu_fsl_pamu_ioctl,
> + .attach_group = vfio_iommu_fsl_pamu_attach_group,
> + .detach_group = vfio_iommu_fsl_pamu_detach_group,
> +};
> +
> +static int __init vfio_iommu_fsl_pamu_init(void)
> +{
> + if (!iommu_present(&pci_bus_type))
> + return -ENODEV;
> +
> + return vfio_register_iommu_driver(&vfio_iommu_driver_ops_fsl_pamu);
> +}
> +
> +static void __exit vfio_iommu_fsl_pamu_cleanup(void)
> +{
> + vfio_unregister_iommu_driver(&vfio_iommu_driver_ops_fsl_pamu);
> +}
> +
> +module_init(vfio_iommu_fsl_pamu_init);
> +module_exit(vfio_iommu_fsl_pamu_cleanup);
> +
> +MODULE_VERSION(DRIVER_VERSION);
> +MODULE_LICENSE("GPL v2");
> +MODULE_AUTHOR(DRIVER_AUTHOR);
> +MODULE_DESCRIPTION(DRIVER_DESC);
> diff --git a/include/uapi/linux/vfio.h b/include/uapi/linux/vfio.h
> index 0fd47f5..d359055 100644
> --- a/include/uapi/linux/vfio.h
> +++ b/include/uapi/linux/vfio.h
> @@ -23,6 +23,7 @@
>
> #define VFIO_TYPE1_IOMMU 1
> #define VFIO_SPAPR_TCE_IOMMU 2
> +#define VFIO_FSL_PAMU_IOMMU 3
>
> /*
> * The IOCTL interface is designed for extensibility by embedding the
> @@ -451,4 +452,103 @@ struct vfio_iommu_spapr_tce_info {
>
> /* ***************************************************************** */
>
> +/*********** APIs for VFIO_PAMU type only ****************/
> +/*
> + * VFIO_IOMMU_PAMU_GET_ATTR - _IO(VFIO_TYPE, VFIO_BASE + 17,
> + * struct vfio_pamu_attr)
> + *
> + * Gets the iommu attributes for the current vfio container.
> + * Caller sets argsz and attribute. The ioctl fills in
> + * the provided struct vfio_pamu_attr based on the attribute
> + * value that was set.
> + * Return: 0 on success, -errno on failure
> + */
> +struct vfio_pamu_attr {
> + __u32 argsz;
> + __u32 flags; /* no flags currently */
> +#define VFIO_ATTR_GEOMETRY 0
> +#define VFIO_ATTR_WINDOWS 1
> +#define VFIO_ATTR_PAMU_STASH 2
> + __u32 attribute;
> +
> + union {
> + /* VFIO_ATTR_GEOMETRY */
> + struct {
> + /* first addr that can be mapped */
> + __u64 aperture_start;
> + /* last addr that can be mapped */
> + __u64 aperture_end;
> + } attr;
> +
> + /* VFIO_ATTR_WINDOWS */
> + __u32 windows; /* number of windows in the aperture
> + * initially this will be the max number
> + * of windows that can be set
> + */
> + /* VFIO_ATTR_PAMU_STASH */
> + struct {
> + __u32 cpu; /* CPU number for stashing */
> + __u32 cache; /* cache ID for stashing */
> + } stash;
> + } attr_info;
> +};
> +#define VFIO_IOMMU_PAMU_GET_ATTR _IO(VFIO_TYPE, VFIO_BASE + 17)
> +
> +/*
> + * VFIO_IOMMU_PAMU_SET_ATTR - _IO(VFIO_TYPE, VFIO_BASE + 18,
> + * struct vfio_pamu_attr)
> + *
> + * Sets the iommu attributes for the current vfio container.
> + * Caller sets struct vfio_pamu attr, including argsz and attribute and
> + * setting any fields that are valid for the attribute.
> + * Return: 0 on success, -errno on failure
> + */
> +#define VFIO_IOMMU_PAMU_SET_ATTR _IO(VFIO_TYPE, VFIO_BASE + 18)
> +
> +/*
> + * VFIO_IOMMU_PAMU_GET_MSI_BANK_COUNT - _IO(VFIO_TYPE, VFIO_BASE + 19, __u32)
> + *
> + * Returns the number of MSI banks for this platform. This tells user space
> + * how many aperture windows should be reserved for MSI banks when setting
> + * the PAMU geometry and window count.
> + * Return: __u32 bank count on success, -errno on failure
> + */
> +#define VFIO_IOMMU_PAMU_GET_MSI_BANK_COUNT _IO(VFIO_TYPE, VFIO_BASE + 19)
> +
> +/*
> + * VFIO_IOMMU_PAMU_MAP_MSI_BANK - _IO(VFIO_TYPE, VFIO_BASE + 20,
> + * struct vfio_pamu_msi_bank_map)
> + *
> + * Maps the MSI bank at the specified index and iova. User space must
> + * call this ioctl once for each MSI bank (count of banks is returned by
> + * VFIO_IOMMU_PAMU_GET_MSI_BANK_COUNT).
> + * Caller provides struct vfio_pamu_msi_bank_map with all fields set.
> + * Return: 0 on success, -errno on failure
> + */
> +
> +struct vfio_pamu_msi_bank_map {
> + __u32 argsz;
> + __u32 flags; /* no flags currently */
> + __u32 msi_bank_index; /* the index of the MSI bank */
> + __u64 iova; /* the iova the bank is to be mapped to */
> +};
> +#define VFIO_IOMMU_PAMU_MAP_MSI_BANK _IO(VFIO_TYPE, VFIO_BASE + 20)
> +
> +/*
> + * VFIO_IOMMU_PAMU_UNMAP_MSI_BANK - _IO(VFIO_TYPE, VFIO_BASE + 21,
> + * struct vfio_pamu_msi_bank_unmap)
> + *
> + * Unmaps the MSI bank at the specified iova.
> + * Caller provides struct vfio_pamu_msi_bank_unmap with all fields set.
> + * Operates on VFIO file descriptor (/dev/vfio/vfio).
> + * Return: 0 on success, -errno on failure
> + */
> +
> +struct vfio_pamu_msi_bank_unmap {
> + __u32 argsz;
> + __u32 flags; /* no flags currently */
> + __u64 iova; /* the iova to be unmapped to */
> +};
> +#define VFIO_IOMMU_PAMU_UNMAP_MSI_BANK _IO(VFIO_TYPE, VFIO_BASE + 21)
> +
> #endif /* _UAPIVFIO_H */
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 5/7] iommu: supress loff_t compilation error on powerpc
2013-09-25 16:40 ` Alex Williamson
@ 2013-09-26 3:53 ` Bhushan Bharat-R65777
2013-09-26 22:20 ` Scott Wood
0 siblings, 1 reply; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-09-26 3:53 UTC (permalink / raw)
To: Alex Williamson
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev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^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 6/7] vfio: moving some functions in common file
2013-09-25 17:02 ` Alex Williamson
@ 2013-09-26 3:57 ` Bhushan Bharat-R65777
0 siblings, 0 replies; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-09-26 3:57 UTC (permalink / raw)
To: Alex Williamson
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev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^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 7/7] vfio pci: Add vfio iommu implementation for FSL_PAMU
2013-09-25 19:06 ` Alex Williamson
@ 2013-09-26 5:27 ` Bhushan Bharat-R65777
0 siblings, 0 replies; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-09-26 5:27 UTC (permalink / raw)
To: Alex Williamson
Cc: agraf, Wood Scott-B07421, linux-pci, joro, Bhushan Bharat-R65777,
linux-kernel, iommu, linuxppc-dev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==
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 5/7] iommu: supress loff_t compilation error on powerpc
2013-09-26 3:53 ` Bhushan Bharat-R65777
@ 2013-09-26 22:20 ` Scott Wood
0 siblings, 0 replies; 41+ messages in thread
From: Scott Wood @ 2013-09-26 22:20 UTC (permalink / raw)
To: Bhushan Bharat-R65777
Cc: agraf, Wood Scott-B07421, joro, linux-kernel, iommu,
Alex Williamson, linux-pci, linuxppc-dev
On Wed, 2013-09-25 at 22:53 -0500, Bhushan Bharat-R65777 wrote:
>
> > -----Original Message-----
> > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > Sent: Wednesday, September 25, 2013 10:10 PM
> > To: Bhushan Bharat-R65777
> > Cc: joro@8bytes.org; benh@kernel.crashing.org; galak@kernel.crashing.org; linux-
> > kernel@vger.kernel.org; linuxppc-dev@lists.ozlabs.org; linux-
> > pci@vger.kernel.org; agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > foundation.org; Bhushan Bharat-R65777
> > Subject: Re: [PATCH 5/7] iommu: supress loff_t compilation error on powerpc
> >
> > On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> > > Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
> > > ---
> > > drivers/vfio/pci/vfio_pci_rdwr.c | 3 ++-
> > > 1 files changed, 2 insertions(+), 1 deletions(-)
> > >
> > > diff --git a/drivers/vfio/pci/vfio_pci_rdwr.c
> > > b/drivers/vfio/pci/vfio_pci_rdwr.c
> > > index 210db24..8a8156a 100644
> > > --- a/drivers/vfio/pci/vfio_pci_rdwr.c
> > > +++ b/drivers/vfio/pci/vfio_pci_rdwr.c
> > > @@ -181,7 +181,8 @@ ssize_t vfio_pci_vga_rw(struct vfio_pci_device *vdev, char
> > __user *buf,
> > > size_t count, loff_t *ppos, bool iswrite) {
> > > int ret;
> > > - loff_t off, pos = *ppos & VFIO_PCI_OFFSET_MASK;
> > > + loff_t off;
> > > + u64 pos = (u64 )(*ppos & VFIO_PCI_OFFSET_MASK);
> > > void __iomem *iomem = NULL;
> > > unsigned int rsrc;
> > > bool is_ioport;
> >
> > What's the compile error that this fixes?
>
> I was getting below error; and after some googling I came to know that this is how it is fixed by other guys.
>
> /home/r65777/linux-vfio/drivers/vfio/pci/vfio_pci_rdwr.c:193: undefined reference to `__cmpdi2'
> /home/r65777/linux-vfio/drivers/vfio/pci/vfio_pci_rdwr.c:193: undefined reference to `__cmpdi2'
It looks like PPC Linux implements __ucmpdi2, but not the signed
version. That should be fixed, rather than hacking up random code to
avoid it.
-Scott
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 1/7] powerpc: Add interface to get msi region information
2013-09-24 23:58 ` Bjorn Helgaas
@ 2013-10-04 5:19 ` Bhushan Bharat-R65777
2013-10-08 16:47 ` Bjorn Helgaas
0 siblings, 1 reply; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-10-04 5:19 UTC (permalink / raw)
To: Bjorn Helgaas
Cc: agraf, Wood Scott-B07421, joro, linux-kernel, iommu,
alex.williamson, linux-pci, linuxppc-dev
> -----Original Message-----
> From: linux-pci-owner@vger.kernel.org [mailto:linux-pci-owner@vger.kernel=
.org]
> On Behalf Of Bjorn Helgaas
> Sent: Wednesday, September 25, 2013 5:28 AM
> To: Bhushan Bharat-R65777
> Cc: alex.williamson@redhat.com; joro@8bytes.org; benh@kernel.crashing.org=
;
> galak@kernel.crashing.org; linux-kernel@vger.kernel.org; linuxppc-
> dev@lists.ozlabs.org; linux-pci@vger.kernel.org; agraf@suse.de; Wood Scot=
t-
> B07421; iommu@lists.linux-foundation.org; Bhushan Bharat-R65777
> Subject: Re: [PATCH 1/7] powerpc: Add interface to get msi region informa=
tion
>=20
> On Thu, Sep 19, 2013 at 12:59:17PM +0530, Bharat Bhushan wrote:
> > This patch adds interface to get following information
> > - Number of MSI regions (which is number of MSI banks for powerpc).
> > - Get the region address range: Physical page which have the
> > address/addresses used for generating MSI interrupt
> > and size of the page.
> >
> > These are required to create IOMMU (Freescale PAMU) mapping for
> > devices which are directly assigned using VFIO.
> >
> > Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
> > ---
> > arch/powerpc/include/asm/machdep.h | 8 +++++++
> > arch/powerpc/include/asm/pci.h | 2 +
> > arch/powerpc/kernel/msi.c | 18 ++++++++++++++++
> > arch/powerpc/sysdev/fsl_msi.c | 39 ++++++++++++++++++++++++++++=
+++++--
> > arch/powerpc/sysdev/fsl_msi.h | 11 ++++++++-
> > drivers/pci/msi.c | 26 ++++++++++++++++++++++++
> > include/linux/msi.h | 8 +++++++
> > include/linux/pci.h | 13 ++++++++++++
> > 8 files changed, 120 insertions(+), 5 deletions(-)
> >
> > ...
>=20
> > diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c index
> > aca7578..6d85c15 100644
> > --- a/drivers/pci/msi.c
> > +++ b/drivers/pci/msi.c
> > @@ -30,6 +30,20 @@ static int pci_msi_enable =3D 1;
> >
> > /* Arch hooks */
> >
> > +#ifndef arch_msi_get_region_count
> > +int arch_msi_get_region_count(void)
> > +{
> > + return 0;
> > +}
> > +#endif
> > +
> > +#ifndef arch_msi_get_region
> > +int arch_msi_get_region(int region_num, struct msi_region *region) {
> > + return 0;
> > +}
> > +#endif
>=20
> This #define strategy is gone; see 4287d824 ("PCI: use weak functions for=
MSI
> arch-specific functions"). Please use the weak function strategy for you=
r new
> MSI region functions.
ok
>=20
> > +
> > #ifndef arch_msi_check_device
> > int arch_msi_check_device(struct pci_dev *dev, int nvec, int type) {
> > @@ -903,6 +917,18 @@ void pci_disable_msi(struct pci_dev *dev) }
> > EXPORT_SYMBOL(pci_disable_msi);
> >
> > +int msi_get_region_count(void)
> > +{
> > + return arch_msi_get_region_count();
> > +}
> > +EXPORT_SYMBOL(msi_get_region_count);
> > +
> > +int msi_get_region(int region_num, struct msi_region *region) {
> > + return arch_msi_get_region(region_num, region); }
> > +EXPORT_SYMBOL(msi_get_region);
>=20
> Please split these interface additions, i.e., the drivers/pci/msi.c,
> include/linux/msi.h, and include/linux/pci.h changes, into a separate pat=
ch.
ok
>=20
> I don't know enough about VFIO to understand why these new interfaces are
> needed. Is this the first VFIO IOMMU driver? I see vfio_iommu_spapr_tce=
.c and
> vfio_iommu_type1.c but I don't know if they're comparable to the Freescal=
e PAMU.
> Do other VFIO IOMMU implementations support MSI? If so, do they handle t=
he
> problem of mapping the MSI regions in a different way?
PAMU is an aperture type of IOMMU while other are paging type, So they are =
completely different from what PAMU is and handle that differently.
>=20
> > /**
> > * pci_msix_table_size - return the number of device's MSI-X table ent=
ries
> > * @dev: pointer to the pci_dev data structure of MSI-X device
> > function diff --git a/include/linux/msi.h b/include/linux/msi.h index
> > ee66f3a..ae32601 100644
> > --- a/include/linux/msi.h
> > +++ b/include/linux/msi.h
> > @@ -50,6 +50,12 @@ struct msi_desc {
> > struct kobject kobj;
> > };
> >
> > +struct msi_region {
> > + int region_num;
> > + dma_addr_t addr;
> > + size_t size;
> > +};
>=20
> This needs some sort of explanatory comment.
Ok
-Bharat
>=20
> > /*
> > * The arch hook for setup up msi irqs
> > */
> > @@ -58,5 +64,7 @@ void arch_teardown_msi_irq(unsigned int irq); int
> > arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type); void
> > arch_teardown_msi_irqs(struct pci_dev *dev); int
> > arch_msi_check_device(struct pci_dev* dev, int nvec, int type);
> > +int arch_msi_get_region_count(void);
> > +int arch_msi_get_region(int region_num, struct msi_region *region);
> >
> > #endif /* LINUX_MSI_H */
> > diff --git a/include/linux/pci.h b/include/linux/pci.h index
> > 186540d..2b26a59 100644
> > --- a/include/linux/pci.h
> > +++ b/include/linux/pci.h
> > @@ -1126,6 +1126,7 @@ struct msix_entry {
> > u16 entry; /* driver uses to specify entry, OS writes */
> > };
> >
> > +struct msi_region;
> >
> > #ifndef CONFIG_PCI_MSI
> > static inline int pci_enable_msi_block(struct pci_dev *dev, unsigned
> > int nvec) @@ -1168,6 +1169,16 @@ static inline int
> > pci_msi_enabled(void) {
> > return 0;
> > }
> > +
> > +static inline int msi_get_region_count(void) {
> > + return 0;
> > +}
> > +
> > +static inline int msi_get_region(int region_num, struct msi_region
> > +*region) {
> > + return 0;
> > +}
> > #else
> > int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec);
> > int pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int
> > *maxvec); @@ -1180,6 +1191,8 @@ void pci_disable_msix(struct pci_dev
> > *dev); void msi_remove_pci_irq_vectors(struct pci_dev *dev); void
> > pci_restore_msi_state(struct pci_dev *dev); int
> > pci_msi_enabled(void);
> > +int msi_get_region_count(void);
> > +int msi_get_region(int region_num, struct msi_region *region);
> > #endif
> >
> > #ifdef CONFIG_PCIEPORTBUS
> > --
> > 1.7.0.4
> >
> >
> > --
> > To unsubscribe from this list: send the line "unsubscribe linux-pci"
> > in the body of a message to majordomo@vger.kernel.org More majordomo
> > info at http://vger.kernel.org/majordomo-info.html
> --
> To unsubscribe from this list: send the line "unsubscribe linux-pci" in t=
he body
> of a message to majordomo@vger.kernel.org More majordomo info at
> http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-09-25 16:45 ` Alex Williamson
@ 2013-10-04 9:54 ` Bhushan Bharat-R65777
2013-10-04 15:45 ` Alex Williamson
2013-10-04 10:42 ` Bhushan Bharat-R65777
1 sibling, 1 reply; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-10-04 9:54 UTC (permalink / raw)
To: Alex Williamson
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev
DQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogbGludXgtcGNpLW93bmVy
QHZnZXIua2VybmVsLm9yZyBbbWFpbHRvOmxpbnV4LXBjaS1vd25lckB2Z2VyLmtlcm5lbC5vcmdd
DQo+IE9uIEJlaGFsZiBPZiBBbGV4IFdpbGxpYW1zb24NCj4gU2VudDogV2VkbmVzZGF5LCBTZXB0
ZW1iZXIgMjUsIDIwMTMgMTA6MTYgUE0NCj4gVG86IEJodXNoYW4gQmhhcmF0LVI2NTc3Nw0KPiBD
Yzogam9yb0A4Ynl0ZXMub3JnOyBiZW5oQGtlcm5lbC5jcmFzaGluZy5vcmc7IGdhbGFrQGtlcm5l
bC5jcmFzaGluZy5vcmc7IGxpbnV4LQ0KPiBrZXJuZWxAdmdlci5rZXJuZWwub3JnOyBsaW51eHBw
Yy1kZXZAbGlzdHMub3psYWJzLm9yZzsgbGludXgtDQo+IHBjaUB2Z2VyLmtlcm5lbC5vcmc7IGFn
cmFmQHN1c2UuZGU7IFdvb2QgU2NvdHQtQjA3NDIxOyBpb21tdUBsaXN0cy5saW51eC0NCj4gZm91
bmRhdGlvbi5vcmc7IEJodXNoYW4gQmhhcmF0LVI2NTc3Nw0KPiBTdWJqZWN0OiBSZTogW1BBVENI
IDIvN10gaW9tbXU6IGFkZCBhcGkgdG8gZ2V0IGlvbW11X2RvbWFpbiBvZiBhIGRldmljZQ0KPiAN
Cj4gT24gVGh1LCAyMDEzLTA5LTE5IGF0IDEyOjU5ICswNTMwLCBCaGFyYXQgQmh1c2hhbiB3cm90
ZToNCj4gPiBUaGlzIGFwaSByZXR1cm4gdGhlIGlvbW11IGRvbWFpbiB0byB3aGljaCB0aGUgZGV2
aWNlIGlzIGF0dGFjaGVkLg0KPiA+IFRoZSBpb21tdV9kb21haW4gaXMgcmVxdWlyZWQgZm9yIG1h
a2luZyBBUEkgY2FsbHMgcmVsYXRlZCB0byBpb21tdS4NCj4gPiBGb2xsb3cgdXAgcGF0Y2hlcyB3
aGljaCB1c2UgdGhpcyBBUEkgdG8ga25vdyBpb21tdSBtYXBpbmcuDQo+ID4NCj4gPiBTaWduZWQt
b2ZmLWJ5OiBCaGFyYXQgQmh1c2hhbiA8YmhhcmF0LmJodXNoYW5AZnJlZXNjYWxlLmNvbT4NCj4g
PiAtLS0NCj4gPiAgZHJpdmVycy9pb21tdS9pb21tdS5jIHwgICAxMCArKysrKysrKysrDQo+ID4g
IGluY2x1ZGUvbGludXgvaW9tbXUuaCB8ICAgIDcgKysrKysrKw0KPiA+ICAyIGZpbGVzIGNoYW5n
ZWQsIDE3IGluc2VydGlvbnMoKyksIDAgZGVsZXRpb25zKC0pDQo+ID4NCj4gPiBkaWZmIC0tZ2l0
IGEvZHJpdmVycy9pb21tdS9pb21tdS5jIGIvZHJpdmVycy9pb21tdS9pb21tdS5jIGluZGV4DQo+
ID4gZmJlOWNhNy4uNmFjNWY1MCAxMDA2NDQNCj4gPiAtLS0gYS9kcml2ZXJzL2lvbW11L2lvbW11
LmMNCj4gPiArKysgYi9kcml2ZXJzL2lvbW11L2lvbW11LmMNCj4gPiBAQCAtNjk2LDYgKzY5Niwx
NiBAQCB2b2lkIGlvbW11X2RldGFjaF9kZXZpY2Uoc3RydWN0IGlvbW11X2RvbWFpbg0KPiA+ICpk
b21haW4sIHN0cnVjdCBkZXZpY2UgKmRldikgIH0NCj4gPiBFWFBPUlRfU1lNQk9MX0dQTChpb21t
dV9kZXRhY2hfZGV2aWNlKTsNCj4gPg0KPiA+ICtzdHJ1Y3QgaW9tbXVfZG9tYWluICppb21tdV9n
ZXRfZGV2X2RvbWFpbihzdHJ1Y3QgZGV2aWNlICpkZXYpIHsNCj4gPiArCXN0cnVjdCBpb21tdV9v
cHMgKm9wcyA9IGRldi0+YnVzLT5pb21tdV9vcHM7DQo+ID4gKw0KPiA+ICsJaWYgKHVubGlrZWx5
KG9wcyA9PSBOVUxMIHx8IG9wcy0+Z2V0X2Rldl9pb21tdV9kb21haW4gPT0gTlVMTCkpDQo+ID4g
KwkJcmV0dXJuIE5VTEw7DQo+ID4gKw0KPiA+ICsJcmV0dXJuIG9wcy0+Z2V0X2Rldl9pb21tdV9k
b21haW4oZGV2KTsgfQ0KPiA+ICtFWFBPUlRfU1lNQk9MX0dQTChpb21tdV9nZXRfZGV2X2RvbWFp
bik7DQo+IA0KPiBXaGF0IHByZXZlbnRzIHRoaXMgZnJvbSByYWNpbmcgaW9tbXVfZG9tYWluX2Zy
ZWUoKT8gIFRoZXJlJ3Mgbm8gcmVmZXJlbmNlcw0KPiBhY3F1aXJlZCwgc28gdGhlcmUncyBubyBy
ZWFzb24gZm9yIHRoZSBjYWxsZXIgdG8gYXNzdW1lIHRoZSBwb2ludGVyIGlzIHZhbGlkLg0KDQpT
b3JyeSBmb3IgbGF0ZSBxdWVyeSwgc29tZWhvdyB0aGlzIGVtYWlsIHdlbnQgaW50byBhIGZvbGRl
ciBhbmQgZXNjYXBlZDsNCg0KSnVzdCB0byBiZSBzdXJlLCB0aGVyZSBpcyBub3QgbG9jayBhdCBn
ZW5lcmljICJzdHJ1Y3QgaW9tbXVfZG9tYWluIiwgYnV0IElQIHNwZWNpZmljIHN0cnVjdHVyZSAo
bGluayBGU0wgZG9tYWluKSBsaW5rZWQgaW4gaW9tbXVfZG9tYWluLT5wcml2IGhhdmUgYSBsb2Nr
LCBzbyB3ZSBuZWVkIHRvIGVuc3VyZSB0aGlzIHJhY2UgaW4gRlNMIGlvbW11IGNvZGUgKHNheSBk
cml2ZXJzL2lvbW11L2ZzbF9wYW11X2RvbWFpbi5jKSwgcmlnaHQ/DQoNClRoYW5rcw0KLUJoYXJh
dA0KDQo+IA0KPiA+ICAvKg0KPiA+ICAgKiBJT01NVSBncm91cHMgYXJlIHJlYWxseSB0aGUgbmF0
cnVhbCB3b3JraW5nIHVuaXQgb2YgdGhlIElPTU1VLCBidXQNCj4gPiAgICogdGhlIElPTU1VIEFQ
SSB3b3JrcyBvbiBkb21haW5zIGFuZCBkZXZpY2VzLiAgQnJpZGdlIHRoYXQgZ2FwIGJ5DQo+ID4g
ZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaW9tbXUuaCBiL2luY2x1ZGUvbGludXgvaW9tbXUu
aCBpbmRleA0KPiA+IDdlYTMxOWUuLmZhMDQ2YmQgMTAwNjQ0DQo+ID4gLS0tIGEvaW5jbHVkZS9s
aW51eC9pb21tdS5oDQo+ID4gKysrIGIvaW5jbHVkZS9saW51eC9pb21tdS5oDQo+ID4gQEAgLTEy
Nyw2ICsxMjcsNyBAQCBzdHJ1Y3QgaW9tbXVfb3BzIHsNCj4gPiAgCWludCAoKmRvbWFpbl9zZXRf
d2luZG93cykoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLCB1MzIgd19jb3VudCk7DQo+ID4g
IAkvKiBHZXQgdGhlIG51bWVyIG9mIHdpbmRvdyBwZXIgZG9tYWluICovDQo+ID4gIAl1MzIgKCpk
b21haW5fZ2V0X3dpbmRvd3MpKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbik7DQo+ID4gKwlz
dHJ1Y3QgaW9tbXVfZG9tYWluICooKmdldF9kZXZfaW9tbXVfZG9tYWluKShzdHJ1Y3QgZGV2aWNl
ICpkZXYpOw0KPiA+DQo+ID4gIAl1bnNpZ25lZCBsb25nIHBnc2l6ZV9iaXRtYXA7DQo+ID4gIH07
DQo+ID4gQEAgLTE5MCw2ICsxOTEsNyBAQCBleHRlcm4gaW50IGlvbW11X2RvbWFpbl93aW5kb3df
ZW5hYmxlKHN0cnVjdCBpb21tdV9kb21haW4NCj4gKmRvbWFpbiwgdTMyIHduZF9uciwNCj4gPiAg
CQkJCSAgICAgIHBoeXNfYWRkcl90IG9mZnNldCwgdTY0IHNpemUsDQo+ID4gIAkJCQkgICAgICBp
bnQgcHJvdCk7DQo+ID4gIGV4dGVybiB2b2lkIGlvbW11X2RvbWFpbl93aW5kb3dfZGlzYWJsZShz
dHJ1Y3QgaW9tbXVfZG9tYWluICpkb21haW4sDQo+ID4gdTMyIHduZF9ucik7DQo+ID4gK2V4dGVy
biBzdHJ1Y3QgaW9tbXVfZG9tYWluICppb21tdV9nZXRfZGV2X2RvbWFpbihzdHJ1Y3QgZGV2aWNl
ICpkZXYpOw0KPiA+ICAvKioNCj4gPiAgICogcmVwb3J0X2lvbW11X2ZhdWx0KCkgLSByZXBvcnQg
YWJvdXQgYW4gSU9NTVUgZmF1bHQgdG8gdGhlIElPTU1VIGZyYW1ld29yaw0KPiA+ICAgKiBAZG9t
YWluOiB0aGUgaW9tbXUgZG9tYWluIHdoZXJlIHRoZSBmYXVsdCBoYXMgaGFwcGVuZWQgQEAgLTI4
NCw2DQo+ID4gKzI4NiwxMSBAQCBzdGF0aWMgaW5saW5lIHZvaWQgaW9tbXVfZG9tYWluX3dpbmRv
d19kaXNhYmxlKHN0cnVjdA0KPiA+IGlvbW11X2RvbWFpbiAqZG9tYWluLCAgeyAgfQ0KPiA+DQo+
ID4gK3N0YXRpYyBpbmxpbmUgc3RydWN0IGlvbW11X2RvbWFpbiAqaW9tbXVfZ2V0X2Rldl9kb21h
aW4oc3RydWN0IGRldmljZQ0KPiA+ICsqZGV2KSB7DQo+ID4gKwlyZXR1cm4gTlVMTDsNCj4gPiAr
fQ0KPiA+ICsNCj4gPiAgc3RhdGljIGlubGluZSBwaHlzX2FkZHJfdCBpb21tdV9pb3ZhX3RvX3Bo
eXMoc3RydWN0IGlvbW11X2RvbWFpbg0KPiA+ICpkb21haW4sIGRtYV9hZGRyX3QgaW92YSkgIHsN
Cj4gPiAgCXJldHVybiAwOw0KPiANCj4gDQo+IA0KPiAtLQ0KPiBUbyB1bnN1YnNjcmliZSBmcm9t
IHRoaXMgbGlzdDogc2VuZCB0aGUgbGluZSAidW5zdWJzY3JpYmUgbGludXgtcGNpIiBpbiB0aGUg
Ym9keQ0KPiBvZiBhIG1lc3NhZ2UgdG8gbWFqb3Jkb21vQHZnZXIua2VybmVsLm9yZyBNb3JlIG1h
am9yZG9tbyBpbmZvIGF0DQo+IGh0dHA6Ly92Z2VyLmtlcm5lbC5vcmcvbWFqb3Jkb21vLWluZm8u
aHRtbA0KDQo=
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-09-25 16:45 ` Alex Williamson
2013-10-04 9:54 ` Bhushan Bharat-R65777
@ 2013-10-04 10:42 ` Bhushan Bharat-R65777
1 sibling, 0 replies; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-10-04 10:42 UTC (permalink / raw)
To: Bhushan Bharat-R65777, Alex Williamson
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev
DQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogQmh1c2hhbiBCaGFyYXQt
UjY1Nzc3DQo+IFNlbnQ6IEZyaWRheSwgT2N0b2JlciAwNCwgMjAxMyAzOjI0IFBNDQo+IFRvOiAn
QWxleCBXaWxsaWFtc29uJw0KPiBDYzogam9yb0A4Ynl0ZXMub3JnOyBiZW5oQGtlcm5lbC5jcmFz
aGluZy5vcmc7IGdhbGFrQGtlcm5lbC5jcmFzaGluZy5vcmc7IGxpbnV4LQ0KPiBrZXJuZWxAdmdl
ci5rZXJuZWwub3JnOyBsaW51eHBwYy1kZXZAbGlzdHMub3psYWJzLm9yZzsgbGludXgtDQo+IHBj
aUB2Z2VyLmtlcm5lbC5vcmc7IGFncmFmQHN1c2UuZGU7IFdvb2QgU2NvdHQtQjA3NDIxOyBpb21t
dUBsaXN0cy5saW51eC0NCj4gZm91bmRhdGlvbi5vcmcNCj4gU3ViamVjdDogUkU6IFtQQVRDSCAy
LzddIGlvbW11OiBhZGQgYXBpIHRvIGdldCBpb21tdV9kb21haW4gb2YgYSBkZXZpY2UNCj4gDQo+
IA0KPiANCj4gPiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiA+IEZyb206IGxpbnV4LXBj
aS1vd25lckB2Z2VyLmtlcm5lbC5vcmcNCj4gPiBbbWFpbHRvOmxpbnV4LXBjaS1vd25lckB2Z2Vy
Lmtlcm5lbC5vcmddDQo+ID4gT24gQmVoYWxmIE9mIEFsZXggV2lsbGlhbXNvbg0KPiA+IFNlbnQ6
IFdlZG5lc2RheSwgU2VwdGVtYmVyIDI1LCAyMDEzIDEwOjE2IFBNDQo+ID4gVG86IEJodXNoYW4g
QmhhcmF0LVI2NTc3Nw0KPiA+IENjOiBqb3JvQDhieXRlcy5vcmc7IGJlbmhAa2VybmVsLmNyYXNo
aW5nLm9yZzsNCj4gPiBnYWxha0BrZXJuZWwuY3Jhc2hpbmcub3JnOyBsaW51eC0ga2VybmVsQHZn
ZXIua2VybmVsLm9yZzsNCj4gPiBsaW51eHBwYy1kZXZAbGlzdHMub3psYWJzLm9yZzsgbGludXgt
IHBjaUB2Z2VyLmtlcm5lbC5vcmc7DQo+ID4gYWdyYWZAc3VzZS5kZTsgV29vZCBTY290dC1CMDc0
MjE7IGlvbW11QGxpc3RzLmxpbnV4LSBmb3VuZGF0aW9uLm9yZzsNCj4gPiBCaHVzaGFuIEJoYXJh
dC1SNjU3NzcNCj4gPiBTdWJqZWN0OiBSZTogW1BBVENIIDIvN10gaW9tbXU6IGFkZCBhcGkgdG8g
Z2V0IGlvbW11X2RvbWFpbiBvZiBhDQo+ID4gZGV2aWNlDQo+ID4NCj4gPiBPbiBUaHUsIDIwMTMt
MDktMTkgYXQgMTI6NTkgKzA1MzAsIEJoYXJhdCBCaHVzaGFuIHdyb3RlOg0KPiA+ID4gVGhpcyBh
cGkgcmV0dXJuIHRoZSBpb21tdSBkb21haW4gdG8gd2hpY2ggdGhlIGRldmljZSBpcyBhdHRhY2hl
ZC4NCj4gPiA+IFRoZSBpb21tdV9kb21haW4gaXMgcmVxdWlyZWQgZm9yIG1ha2luZyBBUEkgY2Fs
bHMgcmVsYXRlZCB0byBpb21tdS4NCj4gPiA+IEZvbGxvdyB1cCBwYXRjaGVzIHdoaWNoIHVzZSB0
aGlzIEFQSSB0byBrbm93IGlvbW11IG1hcGluZy4NCj4gPiA+DQo+ID4gPiBTaWduZWQtb2ZmLWJ5
OiBCaGFyYXQgQmh1c2hhbiA8YmhhcmF0LmJodXNoYW5AZnJlZXNjYWxlLmNvbT4NCj4gPiA+IC0t
LQ0KPiA+ID4gIGRyaXZlcnMvaW9tbXUvaW9tbXUuYyB8ICAgMTAgKysrKysrKysrKw0KPiA+ID4g
IGluY2x1ZGUvbGludXgvaW9tbXUuaCB8ICAgIDcgKysrKysrKw0KPiA+ID4gIDIgZmlsZXMgY2hh
bmdlZCwgMTcgaW5zZXJ0aW9ucygrKSwgMCBkZWxldGlvbnMoLSkNCj4gPiA+DQo+ID4gPiBkaWZm
IC0tZ2l0IGEvZHJpdmVycy9pb21tdS9pb21tdS5jIGIvZHJpdmVycy9pb21tdS9pb21tdS5jIGlu
ZGV4DQo+ID4gPiBmYmU5Y2E3Li42YWM1ZjUwIDEwMDY0NA0KPiA+ID4gLS0tIGEvZHJpdmVycy9p
b21tdS9pb21tdS5jDQo+ID4gPiArKysgYi9kcml2ZXJzL2lvbW11L2lvbW11LmMNCj4gPiA+IEBA
IC02OTYsNiArNjk2LDE2IEBAIHZvaWQgaW9tbXVfZGV0YWNoX2RldmljZShzdHJ1Y3QgaW9tbXVf
ZG9tYWluDQo+ID4gPiAqZG9tYWluLCBzdHJ1Y3QgZGV2aWNlICpkZXYpICB9DQo+ID4gPiBFWFBP
UlRfU1lNQk9MX0dQTChpb21tdV9kZXRhY2hfZGV2aWNlKTsNCj4gPiA+DQo+ID4gPiArc3RydWN0
IGlvbW11X2RvbWFpbiAqaW9tbXVfZ2V0X2Rldl9kb21haW4oc3RydWN0IGRldmljZSAqZGV2KSB7
DQo+ID4gPiArCXN0cnVjdCBpb21tdV9vcHMgKm9wcyA9IGRldi0+YnVzLT5pb21tdV9vcHM7DQo+
ID4gPiArDQo+ID4gPiArCWlmICh1bmxpa2VseShvcHMgPT0gTlVMTCB8fCBvcHMtPmdldF9kZXZf
aW9tbXVfZG9tYWluID09IE5VTEwpKQ0KPiA+ID4gKwkJcmV0dXJuIE5VTEw7DQo+ID4gPiArDQo+
ID4gPiArCXJldHVybiBvcHMtPmdldF9kZXZfaW9tbXVfZG9tYWluKGRldik7IH0NCj4gPiA+ICtF
WFBPUlRfU1lNQk9MX0dQTChpb21tdV9nZXRfZGV2X2RvbWFpbik7DQo+ID4NCj4gPiBXaGF0IHBy
ZXZlbnRzIHRoaXMgZnJvbSByYWNpbmcgaW9tbXVfZG9tYWluX2ZyZWUoKT8gIFRoZXJlJ3Mgbm8N
Cj4gPiByZWZlcmVuY2VzIGFjcXVpcmVkLCBzbyB0aGVyZSdzIG5vIHJlYXNvbiBmb3IgdGhlIGNh
bGxlciB0byBhc3N1bWUgdGhlIHBvaW50ZXINCj4gaXMgdmFsaWQuDQo+IA0KPiBTb3JyeSBmb3Ig
bGF0ZSBxdWVyeSwgc29tZWhvdyB0aGlzIGVtYWlsIHdlbnQgaW50byBhIGZvbGRlciBhbmQgZXNj
YXBlZDsNCj4gDQo+IEp1c3QgdG8gYmUgc3VyZSwgdGhlcmUgaXMgbm90IGxvY2sgYXQgZ2VuZXJp
YyAic3RydWN0IGlvbW11X2RvbWFpbiIsIGJ1dCBJUA0KPiBzcGVjaWZpYyBzdHJ1Y3R1cmUgKGxp
bmsgRlNMIGRvbWFpbikgbGlua2VkIGluIGlvbW11X2RvbWFpbi0+cHJpdiBoYXZlIGEgbG9jaywN
Cj4gc28gd2UgbmVlZCB0byBlbnN1cmUgdGhpcyByYWNlIGluIEZTTCBpb21tdSBjb2RlIChzYXkN
Cj4gZHJpdmVycy9pb21tdS9mc2xfcGFtdV9kb21haW4uYyksIHJpZ2h0Pw0KDQpGdXJ0aGVyIHRo
aW5raW5nIG9mIHRoaXMsIHRoZXJlIGFyZSBtb3JlIHByb2JsZW1zIGhlcmU6DQogLSBMaWtlIE1T
SSBzdWJzeXN0ZW0gd2lsbCBjYWxsIGlvbW11X2dldF9kZXZfZG9tYWluKCksIHdoaWNoIHdpbGwg
dGFrZSBhIGxvY2ssIGZpbmQgdGhlIGRvbWFpbiBwb2ludGVyLCByZWxlYXNlIHRoZSBsb2NrLCBh
bmQgcmV0dXJuIHRoZSBkb21haW4NCiAtIE5vdyBpZiBkb21haW4gaW4gZnJlZWQgdXANCiAtIFdo
aWxlIE1TSSBzdWJzeXN0ZW0gdHJpZXMgdG8gZG8gd29yayBvbiBkb21haW4gKGxpa2UgZ2V0X2F0
dHJpYnV0ZS9zZXRfYXR0cmlidXRlIGV0YykgPz8/DQoNClNvIGNhbiB3ZSBkbyBsaWtlIGlvbW11
X2dldF9kZXZfZG9tYWluKCkgd2lsbCByZXR1cm4gZG9tYWluIHdpdGggdGhlIGxvY2sgaGVsZCwg
YW5kIGlvbW11X3B1dF9kZXZfZG9tYWluKCkgd2lsbCByZWxlYXNlIHRoZSBsb2NrPyBBbmQgaW9t
bXVfZ2V0X2Rldl9kb21haW4oKSBtdXN0IGFsd2F5cyBiZSBmb2xsb3dlZCBieSBpb21tdV9nZXRf
ZGV2X2RvbWFpbigpDQoNClRoYW5rcw0KLUJoYXJhdA0KDQo+IA0KPiBUaGFua3MNCj4gLUJoYXJh
dA0KPiANCj4gPg0KPiA+ID4gIC8qDQo+ID4gPiAgICogSU9NTVUgZ3JvdXBzIGFyZSByZWFsbHkg
dGhlIG5hdHJ1YWwgd29ya2luZyB1bml0IG9mIHRoZSBJT01NVSwgYnV0DQo+ID4gPiAgICogdGhl
IElPTU1VIEFQSSB3b3JrcyBvbiBkb21haW5zIGFuZCBkZXZpY2VzLiAgQnJpZGdlIHRoYXQgZ2Fw
IGJ5DQo+ID4gPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9pb21tdS5oIGIvaW5jbHVkZS9s
aW51eC9pb21tdS5oIGluZGV4DQo+ID4gPiA3ZWEzMTllLi5mYTA0NmJkIDEwMDY0NA0KPiA+ID4g
LS0tIGEvaW5jbHVkZS9saW51eC9pb21tdS5oDQo+ID4gPiArKysgYi9pbmNsdWRlL2xpbnV4L2lv
bW11LmgNCj4gPiA+IEBAIC0xMjcsNiArMTI3LDcgQEAgc3RydWN0IGlvbW11X29wcyB7DQo+ID4g
PiAgCWludCAoKmRvbWFpbl9zZXRfd2luZG93cykoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWlu
LCB1MzIgd19jb3VudCk7DQo+ID4gPiAgCS8qIEdldCB0aGUgbnVtZXIgb2Ygd2luZG93IHBlciBk
b21haW4gKi8NCj4gPiA+ICAJdTMyICgqZG9tYWluX2dldF93aW5kb3dzKShzdHJ1Y3QgaW9tbXVf
ZG9tYWluICpkb21haW4pOw0KPiA+ID4gKwlzdHJ1Y3QgaW9tbXVfZG9tYWluICooKmdldF9kZXZf
aW9tbXVfZG9tYWluKShzdHJ1Y3QgZGV2aWNlICpkZXYpOw0KPiA+ID4NCj4gPiA+ICAJdW5zaWdu
ZWQgbG9uZyBwZ3NpemVfYml0bWFwOw0KPiA+ID4gIH07DQo+ID4gPiBAQCAtMTkwLDYgKzE5MSw3
IEBAIGV4dGVybiBpbnQgaW9tbXVfZG9tYWluX3dpbmRvd19lbmFibGUoc3RydWN0DQo+ID4gPiBp
b21tdV9kb21haW4NCj4gPiAqZG9tYWluLCB1MzIgd25kX25yLA0KPiA+ID4gIAkJCQkgICAgICBw
aHlzX2FkZHJfdCBvZmZzZXQsIHU2NCBzaXplLA0KPiA+ID4gIAkJCQkgICAgICBpbnQgcHJvdCk7
DQo+ID4gPiAgZXh0ZXJuIHZvaWQgaW9tbXVfZG9tYWluX3dpbmRvd19kaXNhYmxlKHN0cnVjdCBp
b21tdV9kb21haW4NCj4gPiA+ICpkb21haW4sDQo+ID4gPiB1MzIgd25kX25yKTsNCj4gPiA+ICtl
eHRlcm4gc3RydWN0IGlvbW11X2RvbWFpbiAqaW9tbXVfZ2V0X2Rldl9kb21haW4oc3RydWN0IGRl
dmljZQ0KPiA+ID4gKypkZXYpOw0KPiA+ID4gIC8qKg0KPiA+ID4gICAqIHJlcG9ydF9pb21tdV9m
YXVsdCgpIC0gcmVwb3J0IGFib3V0IGFuIElPTU1VIGZhdWx0IHRvIHRoZSBJT01NVQ0KPiBmcmFt
ZXdvcmsNCj4gPiA+ICAgKiBAZG9tYWluOiB0aGUgaW9tbXUgZG9tYWluIHdoZXJlIHRoZSBmYXVs
dCBoYXMgaGFwcGVuZWQgQEAgLTI4NCw2DQo+ID4gPiArMjg2LDExIEBAIHN0YXRpYyBpbmxpbmUg
dm9pZCBpb21tdV9kb21haW5fd2luZG93X2Rpc2FibGUoc3RydWN0DQo+ID4gPiBpb21tdV9kb21h
aW4gKmRvbWFpbiwgIHsgIH0NCj4gPiA+DQo+ID4gPiArc3RhdGljIGlubGluZSBzdHJ1Y3QgaW9t
bXVfZG9tYWluICppb21tdV9nZXRfZGV2X2RvbWFpbihzdHJ1Y3QNCj4gPiA+ICtkZXZpY2UNCj4g
PiA+ICsqZGV2KSB7DQo+ID4gPiArCXJldHVybiBOVUxMOw0KPiA+ID4gK30NCj4gPiA+ICsNCj4g
PiA+ICBzdGF0aWMgaW5saW5lIHBoeXNfYWRkcl90IGlvbW11X2lvdmFfdG9fcGh5cyhzdHJ1Y3Qg
aW9tbXVfZG9tYWluDQo+ID4gPiAqZG9tYWluLCBkbWFfYWRkcl90IGlvdmEpICB7DQo+ID4gPiAg
CXJldHVybiAwOw0KPiA+DQo+ID4NCj4gPg0KPiA+IC0tDQo+ID4gVG8gdW5zdWJzY3JpYmUgZnJv
bSB0aGlzIGxpc3Q6IHNlbmQgdGhlIGxpbmUgInVuc3Vic2NyaWJlIGxpbnV4LXBjaSINCj4gPiBp
biB0aGUgYm9keSBvZiBhIG1lc3NhZ2UgdG8gbWFqb3Jkb21vQHZnZXIua2VybmVsLm9yZyBNb3Jl
IG1ham9yZG9tbw0KPiA+IGluZm8gYXQgaHR0cDovL3ZnZXIua2VybmVsLm9yZy9tYWpvcmRvbW8t
aW5mby5odG1sDQoNCg==
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-04 9:54 ` Bhushan Bharat-R65777
@ 2013-10-04 15:45 ` Alex Williamson
2013-10-04 16:47 ` Bhushan Bharat-R65777
0 siblings, 1 reply; 41+ messages in thread
From: Alex Williamson @ 2013-10-04 15:45 UTC (permalink / raw)
To: Bhushan Bharat-R65777
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev
On Fri, 2013-10-04 at 09:54 +0000, Bhushan Bharat-R65777 wrote:
>
> > -----Original Message-----
> > From: linux-pci-owner@vger.kernel.org [mailto:linux-pci-owner@vger.kernel.org]
> > On Behalf Of Alex Williamson
> > Sent: Wednesday, September 25, 2013 10:16 PM
> > To: Bhushan Bharat-R65777
> > Cc: joro@8bytes.org; benh@kernel.crashing.org; galak@kernel.crashing.org; linux-
> > kernel@vger.kernel.org; linuxppc-dev@lists.ozlabs.org; linux-
> > pci@vger.kernel.org; agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > foundation.org; Bhushan Bharat-R65777
> > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
> >
> > On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> > > This api return the iommu domain to which the device is attached.
> > > The iommu_domain is required for making API calls related to iommu.
> > > Follow up patches which use this API to know iommu maping.
> > >
> > > Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
> > > ---
> > > drivers/iommu/iommu.c | 10 ++++++++++
> > > include/linux/iommu.h | 7 +++++++
> > > 2 files changed, 17 insertions(+), 0 deletions(-)
> > >
> > > diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c index
> > > fbe9ca7..6ac5f50 100644
> > > --- a/drivers/iommu/iommu.c
> > > +++ b/drivers/iommu/iommu.c
> > > @@ -696,6 +696,16 @@ void iommu_detach_device(struct iommu_domain
> > > *domain, struct device *dev) }
> > > EXPORT_SYMBOL_GPL(iommu_detach_device);
> > >
> > > +struct iommu_domain *iommu_get_dev_domain(struct device *dev) {
> > > + struct iommu_ops *ops = dev->bus->iommu_ops;
> > > +
> > > + if (unlikely(ops == NULL || ops->get_dev_iommu_domain == NULL))
> > > + return NULL;
> > > +
> > > + return ops->get_dev_iommu_domain(dev); }
> > > +EXPORT_SYMBOL_GPL(iommu_get_dev_domain);
> >
> > What prevents this from racing iommu_domain_free()? There's no references
> > acquired, so there's no reason for the caller to assume the pointer is valid.
>
> Sorry for late query, somehow this email went into a folder and escaped;
>
> Just to be sure, there is not lock at generic "struct iommu_domain", but IP specific structure (link FSL domain) linked in iommu_domain->priv have a lock, so we need to ensure this race in FSL iommu code (say drivers/iommu/fsl_pamu_domain.c), right?
No, it's not sufficient to make sure that your use of the interface is
race free. The interface itself needs to be designed so that it's
difficult to use incorrectly. That's not the case here. This is a
backdoor to get the iommu domain from the iommu driver regardless of who
is using it or how. The iommu domain is created and managed by vfio, so
shouldn't we be looking at how to do this through vfio? It seems like
you'd want to use your device to get a vfio group reference, from which
you could do something with the vfio external user interface and get the
iommu domain reference. Thanks,
Alex
> > > /*
> > > * IOMMU groups are really the natrual working unit of the IOMMU, but
> > > * the IOMMU API works on domains and devices. Bridge that gap by
> > > diff --git a/include/linux/iommu.h b/include/linux/iommu.h index
> > > 7ea319e..fa046bd 100644
> > > --- a/include/linux/iommu.h
> > > +++ b/include/linux/iommu.h
> > > @@ -127,6 +127,7 @@ struct iommu_ops {
> > > int (*domain_set_windows)(struct iommu_domain *domain, u32 w_count);
> > > /* Get the numer of window per domain */
> > > u32 (*domain_get_windows)(struct iommu_domain *domain);
> > > + struct iommu_domain *(*get_dev_iommu_domain)(struct device *dev);
> > >
> > > unsigned long pgsize_bitmap;
> > > };
> > > @@ -190,6 +191,7 @@ extern int iommu_domain_window_enable(struct iommu_domain
> > *domain, u32 wnd_nr,
> > > phys_addr_t offset, u64 size,
> > > int prot);
> > > extern void iommu_domain_window_disable(struct iommu_domain *domain,
> > > u32 wnd_nr);
> > > +extern struct iommu_domain *iommu_get_dev_domain(struct device *dev);
> > > /**
> > > * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
> > > * @domain: the iommu domain where the fault has happened @@ -284,6
> > > +286,11 @@ static inline void iommu_domain_window_disable(struct
> > > iommu_domain *domain, { }
> > >
> > > +static inline struct iommu_domain *iommu_get_dev_domain(struct device
> > > +*dev) {
> > > + return NULL;
> > > +}
> > > +
> > > static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain
> > > *domain, dma_addr_t iova) {
> > > return 0;
> >
> >
> >
> > --
> > To unsubscribe from this list: send the line "unsubscribe linux-pci" in the body
> > of a message to majordomo@vger.kernel.org More majordomo info at
> > http://vger.kernel.org/majordomo-info.html
>
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-04 15:45 ` Alex Williamson
@ 2013-10-04 16:47 ` Bhushan Bharat-R65777
2013-10-04 17:12 ` Alex Williamson
0 siblings, 1 reply; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-10-04 16:47 UTC (permalink / raw)
To: Alex Williamson
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev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==
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-04 16:47 ` Bhushan Bharat-R65777
@ 2013-10-04 17:12 ` Alex Williamson
2013-10-04 17:23 ` Bhushan Bharat-R65777
0 siblings, 1 reply; 41+ messages in thread
From: Alex Williamson @ 2013-10-04 17:12 UTC (permalink / raw)
To: Bhushan Bharat-R65777
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev
On Fri, 2013-10-04 at 16:47 +0000, Bhushan Bharat-R65777 wrote:
>
> > -----Original Message-----
> > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > Sent: Friday, October 04, 2013 9:15 PM
> > To: Bhushan Bharat-R65777
> > Cc: joro@8bytes.org; benh@kernel.crashing.org; galak@kernel.crashing.org; linux-
> > kernel@vger.kernel.org; linuxppc-dev@lists.ozlabs.org; linux-
> > pci@vger.kernel.org; agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > foundation.org
> > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
> >
> > On Fri, 2013-10-04 at 09:54 +0000, Bhushan Bharat-R65777 wrote:
> > >
> > > > -----Original Message-----
> > > > From: linux-pci-owner@vger.kernel.org
> > > > [mailto:linux-pci-owner@vger.kernel.org]
> > > > On Behalf Of Alex Williamson
> > > > Sent: Wednesday, September 25, 2013 10:16 PM
> > > > To: Bhushan Bharat-R65777
> > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux- foundation.org;
> > > > Bhushan Bharat-R65777
> > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a
> > > > device
> > > >
> > > > On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> > > > > This api return the iommu domain to which the device is attached.
> > > > > The iommu_domain is required for making API calls related to iommu.
> > > > > Follow up patches which use this API to know iommu maping.
> > > > >
> > > > > Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
> > > > > ---
> > > > > drivers/iommu/iommu.c | 10 ++++++++++
> > > > > include/linux/iommu.h | 7 +++++++
> > > > > 2 files changed, 17 insertions(+), 0 deletions(-)
> > > > >
> > > > > diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c index
> > > > > fbe9ca7..6ac5f50 100644
> > > > > --- a/drivers/iommu/iommu.c
> > > > > +++ b/drivers/iommu/iommu.c
> > > > > @@ -696,6 +696,16 @@ void iommu_detach_device(struct iommu_domain
> > > > > *domain, struct device *dev) }
> > > > > EXPORT_SYMBOL_GPL(iommu_detach_device);
> > > > >
> > > > > +struct iommu_domain *iommu_get_dev_domain(struct device *dev) {
> > > > > + struct iommu_ops *ops = dev->bus->iommu_ops;
> > > > > +
> > > > > + if (unlikely(ops == NULL || ops->get_dev_iommu_domain == NULL))
> > > > > + return NULL;
> > > > > +
> > > > > + return ops->get_dev_iommu_domain(dev); }
> > > > > +EXPORT_SYMBOL_GPL(iommu_get_dev_domain);
> > > >
> > > > What prevents this from racing iommu_domain_free()? There's no
> > > > references acquired, so there's no reason for the caller to assume the
> > pointer is valid.
> > >
> > > Sorry for late query, somehow this email went into a folder and
> > > escaped;
> > >
> > > Just to be sure, there is not lock at generic "struct iommu_domain", but IP
> > specific structure (link FSL domain) linked in iommu_domain->priv have a lock,
> > so we need to ensure this race in FSL iommu code (say
> > drivers/iommu/fsl_pamu_domain.c), right?
> >
> > No, it's not sufficient to make sure that your use of the interface is race
> > free. The interface itself needs to be designed so that it's difficult to use
> > incorrectly.
>
> So we can define iommu_get_dev_domain()/iommu_put_dev_domain();
> iommu_get_dev_domain() will return domain with the lock held, and
> iommu_put_dev_domain() will release the lock? And
> iommu_get_dev_domain() must always be followed by
> iommu_get_dev_domain().
What lock? get/put are generally used for reference counting, not
locking in the kernel.
> > That's not the case here. This is a backdoor to get the iommu
> > domain from the iommu driver regardless of who is using it or how. The iommu
> > domain is created and managed by vfio, so shouldn't we be looking at how to do
> > this through vfio?
>
> Let me first describe what we are doing here:
> During initialization:-
> - vfio talks to MSI system to know the MSI-page and size
> - vfio then interacts with iommu to map the MSI-page in iommu (IOVA is decided by userspace and physical address is the MSI-page)
> - So the IOVA subwindow mapping is created in iommu and yes VFIO know about this mapping.
>
> Now do SET_IRQ(MSI/MSIX) ioctl:
> - calls pci_enable_msix()/pci_enable_msi_block(): which is supposed to set MSI address/data in device.
> - So in current implementation (this patchset) msi-subsystem gets the IOVA from iommu via this defined interface.
> - Are you saying that rather than getting this from iommu, we should get this from vfio? What difference does this make?
Yes, you just said above that vfio knows the msi to iova mapping, so why
go outside of vfio to find it later? The difference is one case you can
have a proper reference to data structures to make sure the pointer you
get back actually has meaning at the time you're using it vs the code
here where you're defining an API that returns a meaningless value
because you can't check or enforce that an arbitrary caller is using it
correctly. It's not maintainable. Thanks,
Alex
> > It seems like you'd want to use your device to get a vfio
> > group reference, from which you could do something with the vfio external user
> > interface and get the iommu domain reference. Thanks,
> >
> > Alex
> >
> > > > > /*
> > > > > * IOMMU groups are really the natrual working unit of the IOMMU, but
> > > > > * the IOMMU API works on domains and devices. Bridge that gap
> > > > > by diff --git a/include/linux/iommu.h b/include/linux/iommu.h
> > > > > index 7ea319e..fa046bd 100644
> > > > > --- a/include/linux/iommu.h
> > > > > +++ b/include/linux/iommu.h
> > > > > @@ -127,6 +127,7 @@ struct iommu_ops {
> > > > > int (*domain_set_windows)(struct iommu_domain *domain, u32
> > w_count);
> > > > > /* Get the numer of window per domain */
> > > > > u32 (*domain_get_windows)(struct iommu_domain *domain);
> > > > > + struct iommu_domain *(*get_dev_iommu_domain)(struct device
> > > > > +*dev);
> > > > >
> > > > > unsigned long pgsize_bitmap;
> > > > > };
> > > > > @@ -190,6 +191,7 @@ extern int iommu_domain_window_enable(struct
> > > > > iommu_domain
> > > > *domain, u32 wnd_nr,
> > > > > phys_addr_t offset, u64 size,
> > > > > int prot);
> > > > > extern void iommu_domain_window_disable(struct iommu_domain
> > > > > *domain,
> > > > > u32 wnd_nr);
> > > > > +extern struct iommu_domain *iommu_get_dev_domain(struct device
> > > > > +*dev);
> > > > > /**
> > > > > * report_iommu_fault() - report about an IOMMU fault to the IOMMU
> > framework
> > > > > * @domain: the iommu domain where the fault has happened @@
> > > > > -284,6
> > > > > +286,11 @@ static inline void iommu_domain_window_disable(struct
> > > > > iommu_domain *domain, { }
> > > > >
> > > > > +static inline struct iommu_domain *iommu_get_dev_domain(struct
> > > > > +device
> > > > > +*dev) {
> > > > > + return NULL;
> > > > > +}
> > > > > +
> > > > > static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain
> > > > > *domain, dma_addr_t iova) {
> > > > > return 0;
> > > >
> > > >
> > > >
> > > > --
> > > > To unsubscribe from this list: send the line "unsubscribe linux-pci"
> > > > in the body of a message to majordomo@vger.kernel.org More majordomo
> > > > info at http://vger.kernel.org/majordomo-info.html
> > >
> >
> >
> >
>
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-04 17:12 ` Alex Williamson
@ 2013-10-04 17:23 ` Bhushan Bharat-R65777
2013-10-04 18:12 ` Alex Williamson
0 siblings, 1 reply; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-10-04 17:23 UTC (permalink / raw)
To: Alex Williamson
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev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^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-04 17:23 ` Bhushan Bharat-R65777
@ 2013-10-04 18:12 ` Alex Williamson
2013-10-07 5:46 ` Bhushan Bharat-R65777
0 siblings, 1 reply; 41+ messages in thread
From: Alex Williamson @ 2013-10-04 18:12 UTC (permalink / raw)
To: Bhushan Bharat-R65777
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev
On Fri, 2013-10-04 at 17:23 +0000, Bhushan Bharat-R65777 wrote:
>
> > -----Original Message-----
> > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > Sent: Friday, October 04, 2013 10:43 PM
> > To: Bhushan Bharat-R65777
> > Cc: joro@8bytes.org; benh@kernel.crashing.org; galak@kernel.crashing.org; linux-
> > kernel@vger.kernel.org; linuxppc-dev@lists.ozlabs.org; linux-
> > pci@vger.kernel.org; agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > foundation.org
> > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
> >
> > On Fri, 2013-10-04 at 16:47 +0000, Bhushan Bharat-R65777 wrote:
> > >
> > > > -----Original Message-----
> > > > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > > > Sent: Friday, October 04, 2013 9:15 PM
> > > > To: Bhushan Bharat-R65777
> > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux- foundation.org
> > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a
> > > > device
> > > >
> > > > On Fri, 2013-10-04 at 09:54 +0000, Bhushan Bharat-R65777 wrote:
> > > > >
> > > > > > -----Original Message-----
> > > > > > From: linux-pci-owner@vger.kernel.org
> > > > > > [mailto:linux-pci-owner@vger.kernel.org]
> > > > > > On Behalf Of Alex Williamson
> > > > > > Sent: Wednesday, September 25, 2013 10:16 PM
> > > > > > To: Bhushan Bharat-R65777
> > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > > > > > foundation.org; Bhushan Bharat-R65777
> > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a
> > > > > > device
> > > > > >
> > > > > > On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> > > > > > > This api return the iommu domain to which the device is attached.
> > > > > > > The iommu_domain is required for making API calls related to iommu.
> > > > > > > Follow up patches which use this API to know iommu maping.
> > > > > > >
> > > > > > > Signed-off-by: Bharat Bhushan <bharat.bhushan@freescale.com>
> > > > > > > ---
> > > > > > > drivers/iommu/iommu.c | 10 ++++++++++
> > > > > > > include/linux/iommu.h | 7 +++++++
> > > > > > > 2 files changed, 17 insertions(+), 0 deletions(-)
> > > > > > >
> > > > > > > diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
> > > > > > > index
> > > > > > > fbe9ca7..6ac5f50 100644
> > > > > > > --- a/drivers/iommu/iommu.c
> > > > > > > +++ b/drivers/iommu/iommu.c
> > > > > > > @@ -696,6 +696,16 @@ void iommu_detach_device(struct
> > > > > > > iommu_domain *domain, struct device *dev) }
> > > > > > > EXPORT_SYMBOL_GPL(iommu_detach_device);
> > > > > > >
> > > > > > > +struct iommu_domain *iommu_get_dev_domain(struct device *dev) {
> > > > > > > + struct iommu_ops *ops = dev->bus->iommu_ops;
> > > > > > > +
> > > > > > > + if (unlikely(ops == NULL || ops->get_dev_iommu_domain == NULL))
> > > > > > > + return NULL;
> > > > > > > +
> > > > > > > + return ops->get_dev_iommu_domain(dev); }
> > > > > > > +EXPORT_SYMBOL_GPL(iommu_get_dev_domain);
> > > > > >
> > > > > > What prevents this from racing iommu_domain_free()? There's no
> > > > > > references acquired, so there's no reason for the caller to
> > > > > > assume the
> > > > pointer is valid.
> > > > >
> > > > > Sorry for late query, somehow this email went into a folder and
> > > > > escaped;
> > > > >
> > > > > Just to be sure, there is not lock at generic "struct
> > > > > iommu_domain", but IP
> > > > specific structure (link FSL domain) linked in iommu_domain->priv
> > > > have a lock, so we need to ensure this race in FSL iommu code (say
> > > > drivers/iommu/fsl_pamu_domain.c), right?
> > > >
> > > > No, it's not sufficient to make sure that your use of the interface
> > > > is race free. The interface itself needs to be designed so that
> > > > it's difficult to use incorrectly.
> > >
> > > So we can define iommu_get_dev_domain()/iommu_put_dev_domain();
> > > iommu_get_dev_domain() will return domain with the lock held, and
> > > iommu_put_dev_domain() will release the lock? And
> > > iommu_get_dev_domain() must always be followed by
> > > iommu_get_dev_domain().
> >
> > What lock? get/put are generally used for reference counting, not locking in
> > the kernel.
> >
> > > > That's not the case here. This is a backdoor to get the iommu
> > > > domain from the iommu driver regardless of who is using it or how.
> > > > The iommu domain is created and managed by vfio, so shouldn't we be
> > > > looking at how to do this through vfio?
> > >
> > > Let me first describe what we are doing here:
> > > During initialization:-
> > > - vfio talks to MSI system to know the MSI-page and size
> > > - vfio then interacts with iommu to map the MSI-page in iommu (IOVA
> > > is decided by userspace and physical address is the MSI-page)
> > > - So the IOVA subwindow mapping is created in iommu and yes VFIO know about
> > this mapping.
> > >
> > > Now do SET_IRQ(MSI/MSIX) ioctl:
> > > - calls pci_enable_msix()/pci_enable_msi_block(): which is supposed to set
> > MSI address/data in device.
> > > - So in current implementation (this patchset) msi-subsystem gets the IOVA
> > from iommu via this defined interface.
> > > - Are you saying that rather than getting this from iommu, we should get this
> > from vfio? What difference does this make?
> >
> > Yes, you just said above that vfio knows the msi to iova mapping, so why go
> > outside of vfio to find it later? The difference is one case you can have a
> > proper reference to data structures to make sure the pointer you get back
> > actually has meaning at the time you're using it vs the code here where you're
> > defining an API that returns a meaningless value
>
> With FSL-PAMU we will always get consistant data from iommu or vfio-data structure.
Great, but you're trying to add a generic API to the IOMMU subsystem
that's difficult to use correctly. The fact that you use it correctly
does not justify the API.
> > because you can't check or
> > enforce that an arbitrary caller is using it correctly.
>
> I am not sure what is arbitrary caller? pdev is known to vfio, so vfio
> will only make pci_enable_msix()/pci_enable_msi_block() for this pdev.
> If anyother code makes then it is some other unexpectedly thing
> happening in system, no?
What's proposed here is a generic IOMMU API. Anybody can call this.
What if the host SCSI driver decides to go get the iommu domain for it's
device (or any other device)? Does that fit your usage model?
> > It's not maintainable.
> > Thanks,
>
> I do not have any issue with this as well, can you also describe the type of API you are envisioning;
> I can think of defining some function in vfio.c/vfio_iommu*.c, make them global and declare then in include/Linux/vfio.h
> And include <Linux/vfio.h> in caller file (arch/powerpc/kernel/msi.c)
Do you really want module dependencies between vfio and your core kernel
MSI setup? Look at the vfio external user interface that we've already
defined. That allows other components of the kernel to get a proper
reference to a vfio group. From there you can work out how to get what
you want. Another alternative is that vfio could register an MSI to
IOVA mapping with architecture code when the mapping is created. The
MSI setup path could then do a lookup in architecture code for the
mapping. You could even store the MSI to IOVA mapping in VFIO and
create an interface where SET_IRQ passes that mapping into setup code.
Thanks,
Alex
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-04 18:12 ` Alex Williamson
@ 2013-10-07 5:46 ` Bhushan Bharat-R65777
2013-10-08 3:13 ` Alex Williamson
0 siblings, 1 reply; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-10-07 5:46 UTC (permalink / raw)
To: Alex Williamson
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev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^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-07 5:46 ` Bhushan Bharat-R65777
@ 2013-10-08 3:13 ` Alex Williamson
2013-10-08 3:42 ` Bhushan Bharat-R65777
2013-10-10 20:09 ` Sethi Varun-B16395
0 siblings, 2 replies; 41+ messages in thread
From: Alex Williamson @ 2013-10-08 3:13 UTC (permalink / raw)
To: Bhushan Bharat-R65777
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev
On Mon, 2013-10-07 at 05:46 +0000, Bhushan Bharat-R65777 wrote:
>
> > -----Original Message-----
> > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > Sent: Friday, October 04, 2013 11:42 PM
> > To: Bhushan Bharat-R65777
> > Cc: joro@8bytes.org; benh@kernel.crashing.org; galak@kernel.crashing.org; linux-
> > kernel@vger.kernel.org; linuxppc-dev@lists.ozlabs.org; linux-
> > pci@vger.kernel.org; agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > foundation.org
> > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
> >
> > On Fri, 2013-10-04 at 17:23 +0000, Bhushan Bharat-R65777 wrote:
> > >
> > > > -----Original Message-----
> > > > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > > > Sent: Friday, October 04, 2013 10:43 PM
> > > > To: Bhushan Bharat-R65777
> > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux- foundation.org
> > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a
> > > > device
> > > >
> > > > On Fri, 2013-10-04 at 16:47 +0000, Bhushan Bharat-R65777 wrote:
> > > > >
> > > > > > -----Original Message-----
> > > > > > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > > > > > Sent: Friday, October 04, 2013 9:15 PM
> > > > > > To: Bhushan Bharat-R65777
> > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > > > > > foundation.org
> > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a
> > > > > > device
> > > > > >
> > > > > > On Fri, 2013-10-04 at 09:54 +0000, Bhushan Bharat-R65777 wrote:
> > > > > > >
> > > > > > > > -----Original Message-----
> > > > > > > > From: linux-pci-owner@vger.kernel.org
> > > > > > > > [mailto:linux-pci-owner@vger.kernel.org]
> > > > > > > > On Behalf Of Alex Williamson
> > > > > > > > Sent: Wednesday, September 25, 2013 10:16 PM
> > > > > > > > To: Bhushan Bharat-R65777
> > > > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > > > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > > > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > > > > > > > foundation.org; Bhushan Bharat-R65777
> > > > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain
> > > > > > > > of a device
> > > > > > > >
> > > > > > > > On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> > > > > > > > > This api return the iommu domain to which the device is attached.
> > > > > > > > > The iommu_domain is required for making API calls related to
> > iommu.
> > > > > > > > > Follow up patches which use this API to know iommu maping.
> > > > > > > > >
> > > > > > > > > Signed-off-by: Bharat Bhushan
> > > > > > > > > <bharat.bhushan@freescale.com>
> > > > > > > > > ---
> > > > > > > > > drivers/iommu/iommu.c | 10 ++++++++++
> > > > > > > > > include/linux/iommu.h | 7 +++++++
> > > > > > > > > 2 files changed, 17 insertions(+), 0 deletions(-)
> > > > > > > > >
> > > > > > > > > diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
> > > > > > > > > index
> > > > > > > > > fbe9ca7..6ac5f50 100644
> > > > > > > > > --- a/drivers/iommu/iommu.c
> > > > > > > > > +++ b/drivers/iommu/iommu.c
> > > > > > > > > @@ -696,6 +696,16 @@ void iommu_detach_device(struct
> > > > > > > > > iommu_domain *domain, struct device *dev) }
> > > > > > > > > EXPORT_SYMBOL_GPL(iommu_detach_device);
> > > > > > > > >
> > > > > > > > > +struct iommu_domain *iommu_get_dev_domain(struct device *dev) {
> > > > > > > > > + struct iommu_ops *ops = dev->bus->iommu_ops;
> > > > > > > > > +
> > > > > > > > > + if (unlikely(ops == NULL || ops->get_dev_iommu_domain ==
> > NULL))
> > > > > > > > > + return NULL;
> > > > > > > > > +
> > > > > > > > > + return ops->get_dev_iommu_domain(dev); }
> > > > > > > > > +EXPORT_SYMBOL_GPL(iommu_get_dev_domain);
> > > > > > > >
> > > > > > > > What prevents this from racing iommu_domain_free()? There's
> > > > > > > > no references acquired, so there's no reason for the caller
> > > > > > > > to assume the
> > > > > > pointer is valid.
> > > > > > >
> > > > > > > Sorry for late query, somehow this email went into a folder
> > > > > > > and escaped;
> > > > > > >
> > > > > > > Just to be sure, there is not lock at generic "struct
> > > > > > > iommu_domain", but IP
> > > > > > specific structure (link FSL domain) linked in
> > > > > > iommu_domain->priv have a lock, so we need to ensure this race
> > > > > > in FSL iommu code (say drivers/iommu/fsl_pamu_domain.c), right?
> > > > > >
> > > > > > No, it's not sufficient to make sure that your use of the
> > > > > > interface is race free. The interface itself needs to be
> > > > > > designed so that it's difficult to use incorrectly.
> > > > >
> > > > > So we can define iommu_get_dev_domain()/iommu_put_dev_domain();
> > > > > iommu_get_dev_domain() will return domain with the lock held, and
> > > > > iommu_put_dev_domain() will release the lock? And
> > > > > iommu_get_dev_domain() must always be followed by
> > > > > iommu_get_dev_domain().
> > > >
> > > > What lock? get/put are generally used for reference counting, not
> > > > locking in the kernel.
> > > >
> > > > > > That's not the case here. This is a backdoor to get the iommu
> > > > > > domain from the iommu driver regardless of who is using it or how.
> > > > > > The iommu domain is created and managed by vfio, so shouldn't we
> > > > > > be looking at how to do this through vfio?
> > > > >
> > > > > Let me first describe what we are doing here:
> > > > > During initialization:-
> > > > > - vfio talks to MSI system to know the MSI-page and size
> > > > > - vfio then interacts with iommu to map the MSI-page in iommu
> > > > > (IOVA is decided by userspace and physical address is the
> > > > > MSI-page)
> > > > > - So the IOVA subwindow mapping is created in iommu and yes VFIO
> > > > > know about
> > > > this mapping.
> > > > >
> > > > > Now do SET_IRQ(MSI/MSIX) ioctl:
> > > > > - calls pci_enable_msix()/pci_enable_msi_block(): which is
> > > > > supposed to set
> > > > MSI address/data in device.
> > > > > - So in current implementation (this patchset) msi-subsystem gets
> > > > > the IOVA
> > > > from iommu via this defined interface.
> > > > > - Are you saying that rather than getting this from iommu, we
> > > > > should get this
> > > > from vfio? What difference does this make?
> > > >
> > > > Yes, you just said above that vfio knows the msi to iova mapping, so
> > > > why go outside of vfio to find it later? The difference is one case
> > > > you can have a proper reference to data structures to make sure the
> > > > pointer you get back actually has meaning at the time you're using
> > > > it vs the code here where you're defining an API that returns a
> > > > meaningless value
> > >
> > > With FSL-PAMU we will always get consistant data from iommu or vfio-data
> > structure.
> >
> > Great, but you're trying to add a generic API to the IOMMU subsystem that's
> > difficult to use correctly. The fact that you use it correctly does not justify
> > the API.
> >
> > > > because you can't check or
> > > > enforce that an arbitrary caller is using it correctly.
> > >
> > > I am not sure what is arbitrary caller? pdev is known to vfio, so vfio
> > > will only make pci_enable_msix()/pci_enable_msi_block() for this pdev.
> > > If anyother code makes then it is some other unexpectedly thing
> > > happening in system, no?
> >
> > What's proposed here is a generic IOMMU API. Anybody can call this.
> > What if the host SCSI driver decides to go get the iommu domain for it's device
> > (or any other device)? Does that fit your usage model?
> >
> > > > It's not maintainable.
> > > > Thanks,
> > >
> > > I do not have any issue with this as well, can you also describe the
> > > type of API you are envisioning; I can think of defining some function
> > > in vfio.c/vfio_iommu*.c, make them global and declare then in
> > > include/Linux/vfio.h And include <Linux/vfio.h> in caller file
> > > (arch/powerpc/kernel/msi.c)
> >
> > Do you really want module dependencies between vfio and your core kernel MSI
> > setup? Look at the vfio external user interface that we've already defined.
> > That allows other components of the kernel to get a proper reference to a vfio
> > group. From there you can work out how to get what you want. Another
> > alternative is that vfio could register an MSI to IOVA mapping with architecture
> > code when the mapping is created. The MSI setup path could then do a lookup in
> > architecture code for the mapping. You could even store the MSI to IOVA mapping
> > in VFIO and create an interface where SET_IRQ passes that mapping into setup
> > code.
>
> Ok, What I want is to get IOVA associated with a physical address
> (physical address of MSI-bank).
> And currently I do not see a way to know IOVA of a physical address
> and doing all this domain get and then search through all of
> iommu-windows of that domain.
>
> What if we add an iommu-API which can return the IOVA mapping of a
> physical address. Current use case is setting up MSI's for aperture
> type of IOMMU also getting a phys_to_iova() mapping is independent of
> VFIO, your thought?
A physical address can be mapped to multiple IOVAs, so the interface
seems flawed by design. It also has the same problem as above, it's a
backdoor that can be called asynchronous to the owner of the domain, so
what reason is there to believe the result? It just replaces an
iommu_domain pointer with an IOVA. VFIO knows this mapping, so why are
we trying to go behind its back and ask the IOMMU? Thanks,
Alex
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-08 3:13 ` Alex Williamson
@ 2013-10-08 3:42 ` Bhushan Bharat-R65777
2013-10-10 20:09 ` Sethi Varun-B16395
1 sibling, 0 replies; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-10-08 3:42 UTC (permalink / raw)
To: Alex Williamson
Cc: agraf, Wood Scott-B07421, linux-pci, joro, linux-kernel, iommu,
linuxppc-dev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^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 1/7] powerpc: Add interface to get msi region information
2013-10-04 5:19 ` Bhushan Bharat-R65777
@ 2013-10-08 16:47 ` Bjorn Helgaas
2013-10-08 17:02 ` joro
2013-10-08 17:09 ` Scott Wood
0 siblings, 2 replies; 41+ messages in thread
From: Bjorn Helgaas @ 2013-10-08 16:47 UTC (permalink / raw)
To: Bhushan Bharat-R65777
Cc: agraf, Wood Scott-B07421, joro, linux-kernel, iommu,
alex.williamson, linux-pci, linuxppc-dev
On Thu, Oct 3, 2013 at 11:19 PM, Bhushan Bharat-R65777
<R65777@freescale.com> wrote:
>> I don't know enough about VFIO to understand why these new interfaces are
>> needed. Is this the first VFIO IOMMU driver? I see vfio_iommu_spapr_tce.c and
>> vfio_iommu_type1.c but I don't know if they're comparable to the Freescale PAMU.
>> Do other VFIO IOMMU implementations support MSI? If so, do they handle the
>> problem of mapping the MSI regions in a different way?
>
> PAMU is an aperture type of IOMMU while other are paging type, So they are completely different from what PAMU is and handle that differently.
This is not an explanation or a justification for adding new
interfaces. I still have no idea what an "aperture type IOMMU" is,
other than that it is "different." But I see that Alex is working on
this issue with you in a different thread, so I'm sure you guys will
sort it out.
Bjorn
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 1/7] powerpc: Add interface to get msi region information
2013-10-08 16:47 ` Bjorn Helgaas
@ 2013-10-08 17:02 ` joro
2013-10-08 17:09 ` Bhushan Bharat-R65777
2013-10-08 17:09 ` Scott Wood
1 sibling, 1 reply; 41+ messages in thread
From: joro @ 2013-10-08 17:02 UTC (permalink / raw)
To: Bjorn Helgaas
Cc: agraf, Wood Scott-B07421, linux-pci, iommu, linux-kernel,
alex.williamson, Bhushan Bharat-R65777, linuxppc-dev
On Tue, Oct 08, 2013 at 10:47:49AM -0600, Bjorn Helgaas wrote:
> I still have no idea what an "aperture type IOMMU" is,
> other than that it is "different."
An aperture based IOMMU is basically any GART-like IOMMU which can only
remap a small window (the aperture) of the DMA address space. DMA
outside of that window is either blocked completly or passed through
untranslated.
Joerg
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 1/7] powerpc: Add interface to get msi region information
2013-10-08 16:47 ` Bjorn Helgaas
2013-10-08 17:02 ` joro
@ 2013-10-08 17:09 ` Scott Wood
1 sibling, 0 replies; 41+ messages in thread
From: Scott Wood @ 2013-10-08 17:09 UTC (permalink / raw)
To: Bjorn Helgaas
Cc: agraf, Wood Scott-B07421, joro, linux-pci, linux-kernel, iommu,
alex.williamson, Bhushan Bharat-R65777, linuxppc-dev
On Tue, 2013-10-08 at 10:47 -0600, Bjorn Helgaas wrote:
> On Thu, Oct 3, 2013 at 11:19 PM, Bhushan Bharat-R65777
> <R65777@freescale.com> wrote:
>
> >> I don't know enough about VFIO to understand why these new interfaces are
> >> needed. Is this the first VFIO IOMMU driver? I see vfio_iommu_spapr_tce.c and
> >> vfio_iommu_type1.c but I don't know if they're comparable to the Freescale PAMU.
> >> Do other VFIO IOMMU implementations support MSI? If so, do they handle the
> >> problem of mapping the MSI regions in a different way?
> >
> > PAMU is an aperture type of IOMMU while other are paging type, So they are completely different from what PAMU is and handle that differently.
>
> This is not an explanation or a justification for adding new
> interfaces. I still have no idea what an "aperture type IOMMU" is,
> other than that it is "different." But I see that Alex is working on
> this issue with you in a different thread, so I'm sure you guys will
> sort it out.
PAMU is a very constrained IOMMU that cannot do arbitrary page mappings.
Due to these constraints, we cannot map the MSI I/O page at its normal
address while also mapping RAM at the address we want. The address we
can map it at depends on the addresses of other mappings, so it can't be
hidden in the IOMMU driver -- the user needs to be in control.
Another difference is that (if I understand correctly) PCs handle MSIs
specially, via interrupt remapping, rather than being translated as a
normal memory access through the IOMMU.
-Scott
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 1/7] powerpc: Add interface to get msi region information
2013-10-08 17:02 ` joro
@ 2013-10-08 17:09 ` Bhushan Bharat-R65777
2013-10-10 21:13 ` Sethi Varun-B16395
0 siblings, 1 reply; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-10-08 17:09 UTC (permalink / raw)
To: joro, Bjorn Helgaas
Cc: agraf, Wood Scott-B07421, linux-pci, iommu, linux-kernel,
alex.williamson, linuxppc-dev
> -----Original Message-----
> From: joro@8bytes.org [mailto:joro@8bytes.org]
> Sent: Tuesday, October 08, 2013 10:32 PM
> To: Bjorn Helgaas
> Cc: Bhushan Bharat-R65777; alex.williamson@redhat.com; benh@kernel.crashi=
ng.org;
> galak@kernel.crashing.org; linux-kernel@vger.kernel.org; linuxppc-
> dev@lists.ozlabs.org; linux-pci@vger.kernel.org; agraf@suse.de; Wood Scot=
t-
> B07421; iommu@lists.linux-foundation.org
> Subject: Re: [PATCH 1/7] powerpc: Add interface to get msi region informa=
tion
>=20
> On Tue, Oct 08, 2013 at 10:47:49AM -0600, Bjorn Helgaas wrote:
> > I still have no idea what an "aperture type IOMMU" is, other than that
> > it is "different."
>=20
> An aperture based IOMMU is basically any GART-like IOMMU which can only r=
emap a
> small window (the aperture) of the DMA address space. DMA outside of that=
window
> is either blocked completly or passed through untranslated.
It is completely blocked for Freescale PAMU.=20
So for this type of iommu what we have to do is to create a MSI mapping jus=
t after guest physical address, Example: guest have a 512M of memory then w=
e create window of 1G (because of power of 2 requirement), then we have to =
FIT MSI just after 512M of guest.
And for that we need
1) to know the physical address of MSI's in interrupt controller (for that=
this patch was all about of).
2) When guest enable MSI interrupt then we write MSI-address and MSI-DATA =
in device. The discussion with Alex Williamson is about that interface.
Thanks
-Bharat
>=20
>=20
> Joerg
>=20
>=20
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 1/7] powerpc: Add interface to get msi region information
2013-09-19 7:29 ` [PATCH 1/7] powerpc: Add interface to get msi region information Bharat Bhushan
2013-09-24 23:58 ` Bjorn Helgaas
@ 2013-10-08 22:57 ` Scott Wood
2013-10-08 23:25 ` Bjorn Helgaas
2013-10-09 4:47 ` Bhushan Bharat-R65777
1 sibling, 2 replies; 41+ messages in thread
From: Scott Wood @ 2013-10-08 22:57 UTC (permalink / raw)
To: Bharat Bhushan
Cc: agraf, joro, linux-kernel, iommu, Bharat Bhushan,
alex.williamson, linux-pci, linuxppc-dev
On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> @@ -376,6 +405,7 @@ static int fsl_of_msi_probe(struct platform_device *dev)
> int len;
> u32 offset;
> static const u32 all_avail[] = { 0, NR_MSI_IRQS };
> + static int bank_index;
>
> match = of_match_device(fsl_of_msi_ids, &dev->dev);
> if (!match)
> @@ -419,8 +449,8 @@ static int fsl_of_msi_probe(struct platform_device *dev)
> dev->dev.of_node->full_name);
> goto error_out;
> }
> - msi->msiir_offset =
> - features->msiir_offset + (res.start & 0xfffff);
> + msi->msiir = res.start + features->msiir_offset;
> + printk("msi->msiir = %llx\n", msi->msiir);
dev_dbg or remove
> }
>
> msi->feature = features->fsl_pic_ip;
> @@ -470,6 +500,7 @@ static int fsl_of_msi_probe(struct platform_device *dev)
> }
> }
>
> + msi->bank_index = bank_index++;
What if multiple MSIs are boing probed in parallel? bank_index is not
atomic.
> diff --git a/arch/powerpc/sysdev/fsl_msi.h b/arch/powerpc/sysdev/fsl_msi.h
> index 8225f86..6bd5cfc 100644
> --- a/arch/powerpc/sysdev/fsl_msi.h
> +++ b/arch/powerpc/sysdev/fsl_msi.h
> @@ -29,12 +29,19 @@ struct fsl_msi {
> struct irq_domain *irqhost;
>
> unsigned long cascade_irq;
> -
> - u32 msiir_offset; /* Offset of MSIIR, relative to start of CCSR */
> + dma_addr_t msiir; /* MSIIR Address in CCSR */
Are you sure dma_addr_t is right here, versus phys_addr_t? It implies
that it's the output of the DMA API, but I don't think the DMA API is
used in the MSI driver. Perhaps it should be, but we still want the raw
physical address to pass on to VFIO.
> void __iomem *msi_regs;
> u32 feature;
> int msi_virqs[NR_MSI_REG];
>
> + /*
> + * During probe each bank is assigned a index number.
> + * index number ranges from 0 to 2^32.
> + * Example MSI bank 1 = 0
> + * MSI bank 2 = 1, and so on.
> + */
> + int bank_index;
2^32 doesn't fit in "int" (nor does 2^32 - 1).
Just say that indices start at 0.
-Scott
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 1/7] powerpc: Add interface to get msi region information
2013-10-08 22:57 ` Scott Wood
@ 2013-10-08 23:25 ` Bjorn Helgaas
2013-10-08 23:35 ` Scott Wood
2013-10-09 4:47 ` Bhushan Bharat-R65777
1 sibling, 1 reply; 41+ messages in thread
From: Bjorn Helgaas @ 2013-10-08 23:25 UTC (permalink / raw)
To: Scott Wood
Cc: Alexander Graf, Joerg Roedel, linux-pci, linux-kernel,
open list:INTEL IOMMU (VT-d),
Bharat Bhushan, alex.williamson, Bharat Bhushan, linuxppc-dev
>> - u32 msiir_offset; /* Offset of MSIIR, relative to start of CCSR */
>> + dma_addr_t msiir; /* MSIIR Address in CCSR */
>
> Are you sure dma_addr_t is right here, versus phys_addr_t? It implies
> that it's the output of the DMA API, but I don't think the DMA API is
> used in the MSI driver. Perhaps it should be, but we still want the raw
> physical address to pass on to VFIO.
I don't know what "msiir" is used for, but if it's an address you
program into a PCI device, then it's a dma_addr_t even if you didn't
get it from the DMA API. Maybe "bus_addr_t" would have been a more
suggestive name than "dma_addr_t". That said, I have no idea how this
relates to VFIO.
Bjorn
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 1/7] powerpc: Add interface to get msi region information
2013-10-08 23:25 ` Bjorn Helgaas
@ 2013-10-08 23:35 ` Scott Wood
0 siblings, 0 replies; 41+ messages in thread
From: Scott Wood @ 2013-10-08 23:35 UTC (permalink / raw)
To: Bjorn Helgaas
Cc: Alexander Graf, Joerg Roedel, linux-pci, linux-kernel,
open list:INTEL IOMMU (VT-d),
Bharat Bhushan, alex.williamson, Bharat Bhushan, linuxppc-dev
On Tue, 2013-10-08 at 17:25 -0600, Bjorn Helgaas wrote:
> >> - u32 msiir_offset; /* Offset of MSIIR, relative to start of CCSR */
> >> + dma_addr_t msiir; /* MSIIR Address in CCSR */
> >
> > Are you sure dma_addr_t is right here, versus phys_addr_t? It implies
> > that it's the output of the DMA API, but I don't think the DMA API is
> > used in the MSI driver. Perhaps it should be, but we still want the raw
> > physical address to pass on to VFIO.
>
> I don't know what "msiir" is used for, but if it's an address you
> program into a PCI device, then it's a dma_addr_t even if you didn't
> get it from the DMA API. Maybe "bus_addr_t" would have been a more
> suggestive name than "dma_addr_t". That said, I have no idea how this
> relates to VFIO.
It's a bit awkward because it gets used both as something to program
into a PCI device (and it's probably a bug that the DMA API doesn't get
used), and also (if I understand the current plans correctly) as a
physical address to give to VFIO to be a destination address in an IOMMU
mapping. So I think the value we keep here should be a phys_addr_t (it
comes straight from the MMIO address in the device tree), which gets
trivially turned into a dma_addr_t by the non-VFIO code path because
there's currently no translation there.
-Scott
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 1/7] powerpc: Add interface to get msi region information
2013-10-08 22:57 ` Scott Wood
2013-10-08 23:25 ` Bjorn Helgaas
@ 2013-10-09 4:47 ` Bhushan Bharat-R65777
1 sibling, 0 replies; 41+ messages in thread
From: Bhushan Bharat-R65777 @ 2013-10-09 4:47 UTC (permalink / raw)
To: Wood Scott-B07421
Cc: agraf, joro, linux-kernel, iommu, alex.williamson, linux-pci,
linuxppc-dev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^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-08 3:13 ` Alex Williamson
2013-10-08 3:42 ` Bhushan Bharat-R65777
@ 2013-10-10 20:09 ` Sethi Varun-B16395
2013-10-10 20:41 ` Alex Williamson
1 sibling, 1 reply; 41+ messages in thread
From: Sethi Varun-B16395 @ 2013-10-10 20:09 UTC (permalink / raw)
To: Alex Williamson, Bhushan Bharat-R65777
Cc: Wood Scott-B07421, linux-pci, linux-kernel, agraf, iommu, linuxppc-dev
> -----Original Message-----
> From: iommu-bounces@lists.linux-foundation.org [mailto:iommu-
> bounces@lists.linux-foundation.org] On Behalf Of Alex Williamson
> Sent: Tuesday, October 08, 2013 8:43 AM
> To: Bhushan Bharat-R65777
> Cc: agraf@suse.de; Wood Scott-B07421; linux-pci@vger.kernel.org;
> galak@kernel.crashing.org; linux-kernel@vger.kernel.org;
> iommu@lists.linux-foundation.org; benh@kernel.crashing.org; linuxppc-
> dev@lists.ozlabs.org
> Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
>=20
> On Mon, 2013-10-07 at 05:46 +0000, Bhushan Bharat-R65777 wrote:
> >
> > > -----Original Message-----
> > > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > > Sent: Friday, October 04, 2013 11:42 PM
> > > To: Bhushan Bharat-R65777
> > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux- foundation.org
> > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a
> > > device
> > >
> > > On Fri, 2013-10-04 at 17:23 +0000, Bhushan Bharat-R65777 wrote:
> > > >
> > > > > -----Original Message-----
> > > > > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > > > > Sent: Friday, October 04, 2013 10:43 PM
> > > > > To: Bhushan Bharat-R65777
> > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > > > > foundation.org
> > > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a
> > > > > device
> > > > >
> > > > > On Fri, 2013-10-04 at 16:47 +0000, Bhushan Bharat-R65777 wrote:
> > > > > >
> > > > > > > -----Original Message-----
> > > > > > > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > > > > > > Sent: Friday, October 04, 2013 9:15 PM
> > > > > > > To: Bhushan Bharat-R65777
> > > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > > > > > > foundation.org
> > > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain
> > > > > > > of a device
> > > > > > >
> > > > > > > On Fri, 2013-10-04 at 09:54 +0000, Bhushan Bharat-R65777
> wrote:
> > > > > > > >
> > > > > > > > > -----Original Message-----
> > > > > > > > > From: linux-pci-owner@vger.kernel.org
> > > > > > > > > [mailto:linux-pci-owner@vger.kernel.org]
> > > > > > > > > On Behalf Of Alex Williamson
> > > > > > > > > Sent: Wednesday, September 25, 2013 10:16 PM
> > > > > > > > > To: Bhushan Bharat-R65777
> > > > > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > > > > galak@kernel.crashing.org; linux-
> > > > > > > > > kernel@vger.kernel.org; linuxppc-dev@lists.ozlabs.org;
> > > > > > > > > linux- pci@vger.kernel.org; agraf@suse.de; Wood
> > > > > > > > > Scott-B07421; iommu@lists.linux- foundation.org; Bhushan
> > > > > > > > > Bharat-R65777
> > > > > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get
> > > > > > > > > iommu_domain of a device
> > > > > > > > >
> > > > > > > > > On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> > > > > > > > > > This api return the iommu domain to which the device is
> attached.
> > > > > > > > > > The iommu_domain is required for making API calls
> > > > > > > > > > related to
> > > iommu.
> > > > > > > > > > Follow up patches which use this API to know iommu
> maping.
> > > > > > > > > >
> > > > > > > > > > Signed-off-by: Bharat Bhushan
> > > > > > > > > > <bharat.bhushan@freescale.com>
> > > > > > > > > > ---
> > > > > > > > > > drivers/iommu/iommu.c | 10 ++++++++++
> > > > > > > > > > include/linux/iommu.h | 7 +++++++
> > > > > > > > > > 2 files changed, 17 insertions(+), 0 deletions(-)
> > > > > > > > > >
> > > > > > > > > > diff --git a/drivers/iommu/iommu.c
> > > > > > > > > > b/drivers/iommu/iommu.c index
> > > > > > > > > > fbe9ca7..6ac5f50 100644
> > > > > > > > > > --- a/drivers/iommu/iommu.c
> > > > > > > > > > +++ b/drivers/iommu/iommu.c
> > > > > > > > > > @@ -696,6 +696,16 @@ void iommu_detach_device(struct
> > > > > > > > > > iommu_domain *domain, struct device *dev) }
> > > > > > > > > > EXPORT_SYMBOL_GPL(iommu_detach_device);
> > > > > > > > > >
> > > > > > > > > > +struct iommu_domain *iommu_get_dev_domain(struct
> device *dev) {
> > > > > > > > > > + struct iommu_ops *ops =3D dev->bus->iommu_ops;
> > > > > > > > > > +
> > > > > > > > > > + if (unlikely(ops =3D=3D NULL ||
> > > > > > > > > > +ops->get_dev_iommu_domain =3D=3D
> > > NULL))
> > > > > > > > > > + return NULL;
> > > > > > > > > > +
> > > > > > > > > > + return ops->get_dev_iommu_domain(dev); }
> > > > > > > > > > +EXPORT_SYMBOL_GPL(iommu_get_dev_domain);
> > > > > > > > >
> > > > > > > > > What prevents this from racing iommu_domain_free()?
> > > > > > > > > There's no references acquired, so there's no reason for
> > > > > > > > > the caller to assume the
> > > > > > > pointer is valid.
> > > > > > > >
> > > > > > > > Sorry for late query, somehow this email went into a
> > > > > > > > folder and escaped;
> > > > > > > >
> > > > > > > > Just to be sure, there is not lock at generic "struct
> > > > > > > > iommu_domain", but IP
> > > > > > > specific structure (link FSL domain) linked in
> > > > > > > iommu_domain->priv have a lock, so we need to ensure this
> > > > > > > race in FSL iommu code (say drivers/iommu/fsl_pamu_domain.c),
> right?
> > > > > > >
> > > > > > > No, it's not sufficient to make sure that your use of the
> > > > > > > interface is race free. The interface itself needs to be
> > > > > > > designed so that it's difficult to use incorrectly.
> > > > > >
> > > > > > So we can define
> > > > > > iommu_get_dev_domain()/iommu_put_dev_domain();
> > > > > > iommu_get_dev_domain() will return domain with the lock held,
> > > > > > and
> > > > > > iommu_put_dev_domain() will release the lock? And
> > > > > > iommu_get_dev_domain() must always be followed by
> > > > > > iommu_get_dev_domain().
> > > > >
> > > > > What lock? get/put are generally used for reference counting,
> > > > > not locking in the kernel.
> > > > >
> > > > > > > That's not the case here. This is a backdoor to get the
> > > > > > > iommu domain from the iommu driver regardless of who is using
> it or how.
> > > > > > > The iommu domain is created and managed by vfio, so
> > > > > > > shouldn't we be looking at how to do this through vfio?
> > > > > >
> > > > > > Let me first describe what we are doing here:
> > > > > > During initialization:-
> > > > > > - vfio talks to MSI system to know the MSI-page and size
> > > > > > - vfio then interacts with iommu to map the MSI-page in iommu
> > > > > > (IOVA is decided by userspace and physical address is the
> > > > > > MSI-page)
> > > > > > - So the IOVA subwindow mapping is created in iommu and yes
> > > > > > VFIO know about
> > > > > this mapping.
> > > > > >
> > > > > > Now do SET_IRQ(MSI/MSIX) ioctl:
> > > > > > - calls pci_enable_msix()/pci_enable_msi_block(): which is
> > > > > > supposed to set
> > > > > MSI address/data in device.
> > > > > > - So in current implementation (this patchset) msi-subsystem
> > > > > > gets the IOVA
> > > > > from iommu via this defined interface.
> > > > > > - Are you saying that rather than getting this from iommu, we
> > > > > > should get this
> > > > > from vfio? What difference does this make?
> > > > >
> > > > > Yes, you just said above that vfio knows the msi to iova
> > > > > mapping, so why go outside of vfio to find it later? The
> > > > > difference is one case you can have a proper reference to data
> > > > > structures to make sure the pointer you get back actually has
> > > > > meaning at the time you're using it vs the code here where
> > > > > you're defining an API that returns a meaningless value
> > > >
> > > > With FSL-PAMU we will always get consistant data from iommu or
> > > > vfio-data
> > > structure.
> > >
> > > Great, but you're trying to add a generic API to the IOMMU subsystem
> > > that's difficult to use correctly. The fact that you use it
> > > correctly does not justify the API.
> > >
> > > > > because you can't check or
> > > > > enforce that an arbitrary caller is using it correctly.
> > > >
> > > > I am not sure what is arbitrary caller? pdev is known to vfio, so
> > > > vfio will only make pci_enable_msix()/pci_enable_msi_block() for
> this pdev.
> > > > If anyother code makes then it is some other unexpectedly thing
> > > > happening in system, no?
> > >
> > > What's proposed here is a generic IOMMU API. Anybody can call this.
> > > What if the host SCSI driver decides to go get the iommu domain for
> > > it's device (or any other device)? Does that fit your usage model?
> > >
> > > > > It's not maintainable.
> > > > > Thanks,
> > > >
> > > > I do not have any issue with this as well, can you also describe
> > > > the type of API you are envisioning; I can think of defining some
> > > > function in vfio.c/vfio_iommu*.c, make them global and declare
> > > > then in include/Linux/vfio.h And include <Linux/vfio.h> in caller
> > > > file
> > > > (arch/powerpc/kernel/msi.c)
> > >
> > > Do you really want module dependencies between vfio and your core
> > > kernel MSI setup? Look at the vfio external user interface that
> we've already defined.
> > > That allows other components of the kernel to get a proper reference
> > > to a vfio group. From there you can work out how to get what you
> > > want. Another alternative is that vfio could register an MSI to
> > > IOVA mapping with architecture code when the mapping is created.
> > > The MSI setup path could then do a lookup in architecture code for
> > > the mapping. You could even store the MSI to IOVA mapping in VFIO
> > > and create an interface where SET_IRQ passes that mapping into setup
> code.
[Sethi Varun-B16395] What you are suggesting is that the MSI setup path que=
ries the vfio subsystem for the mapping, rather than directly querying the =
iommu subsystem. So, say if we add an interface for getting MSI to IOVA map=
ping in the msi setup path, wouldn't this again be specific to vfio? I reck=
on that this interface would again ppc machine specific interface.
-Varun
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-10 20:09 ` Sethi Varun-B16395
@ 2013-10-10 20:41 ` Alex Williamson
2013-10-14 12:58 ` Sethi Varun-B16395
0 siblings, 1 reply; 41+ messages in thread
From: Alex Williamson @ 2013-10-10 20:41 UTC (permalink / raw)
To: Sethi Varun-B16395
Cc: Wood Scott-B07421, linux-pci, linux-kernel, agraf, iommu,
Bhushan Bharat-R65777, linuxppc-dev
On Thu, 2013-10-10 at 20:09 +0000, Sethi Varun-B16395 wrote:
>
> > -----Original Message-----
> > From: iommu-bounces@lists.linux-foundation.org [mailto:iommu-
> > bounces@lists.linux-foundation.org] On Behalf Of Alex Williamson
> > Sent: Tuesday, October 08, 2013 8:43 AM
> > To: Bhushan Bharat-R65777
> > Cc: agraf@suse.de; Wood Scott-B07421; linux-pci@vger.kernel.org;
> > galak@kernel.crashing.org; linux-kernel@vger.kernel.org;
> > iommu@lists.linux-foundation.org; benh@kernel.crashing.org; linuxppc-
> > dev@lists.ozlabs.org
> > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
> >
> > On Mon, 2013-10-07 at 05:46 +0000, Bhushan Bharat-R65777 wrote:
> > >
> > > > -----Original Message-----
> > > > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > > > Sent: Friday, October 04, 2013 11:42 PM
> > > > To: Bhushan Bharat-R65777
> > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux- foundation.org
> > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a
> > > > device
> > > >
> > > > On Fri, 2013-10-04 at 17:23 +0000, Bhushan Bharat-R65777 wrote:
> > > > >
> > > > > > -----Original Message-----
> > > > > > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > > > > > Sent: Friday, October 04, 2013 10:43 PM
> > > > > > To: Bhushan Bharat-R65777
> > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > > > > > foundation.org
> > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a
> > > > > > device
> > > > > >
> > > > > > On Fri, 2013-10-04 at 16:47 +0000, Bhushan Bharat-R65777 wrote:
> > > > > > >
> > > > > > > > -----Original Message-----
> > > > > > > > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > > > > > > > Sent: Friday, October 04, 2013 9:15 PM
> > > > > > > > To: Bhushan Bharat-R65777
> > > > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > > > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > > > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > > > > > > > foundation.org
> > > > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain
> > > > > > > > of a device
> > > > > > > >
> > > > > > > > On Fri, 2013-10-04 at 09:54 +0000, Bhushan Bharat-R65777
> > wrote:
> > > > > > > > >
> > > > > > > > > > -----Original Message-----
> > > > > > > > > > From: linux-pci-owner@vger.kernel.org
> > > > > > > > > > [mailto:linux-pci-owner@vger.kernel.org]
> > > > > > > > > > On Behalf Of Alex Williamson
> > > > > > > > > > Sent: Wednesday, September 25, 2013 10:16 PM
> > > > > > > > > > To: Bhushan Bharat-R65777
> > > > > > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > > > > > galak@kernel.crashing.org; linux-
> > > > > > > > > > kernel@vger.kernel.org; linuxppc-dev@lists.ozlabs.org;
> > > > > > > > > > linux- pci@vger.kernel.org; agraf@suse.de; Wood
> > > > > > > > > > Scott-B07421; iommu@lists.linux- foundation.org; Bhushan
> > > > > > > > > > Bharat-R65777
> > > > > > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get
> > > > > > > > > > iommu_domain of a device
> > > > > > > > > >
> > > > > > > > > > On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan wrote:
> > > > > > > > > > > This api return the iommu domain to which the device is
> > attached.
> > > > > > > > > > > The iommu_domain is required for making API calls
> > > > > > > > > > > related to
> > > > iommu.
> > > > > > > > > > > Follow up patches which use this API to know iommu
> > maping.
> > > > > > > > > > >
> > > > > > > > > > > Signed-off-by: Bharat Bhushan
> > > > > > > > > > > <bharat.bhushan@freescale.com>
> > > > > > > > > > > ---
> > > > > > > > > > > drivers/iommu/iommu.c | 10 ++++++++++
> > > > > > > > > > > include/linux/iommu.h | 7 +++++++
> > > > > > > > > > > 2 files changed, 17 insertions(+), 0 deletions(-)
> > > > > > > > > > >
> > > > > > > > > > > diff --git a/drivers/iommu/iommu.c
> > > > > > > > > > > b/drivers/iommu/iommu.c index
> > > > > > > > > > > fbe9ca7..6ac5f50 100644
> > > > > > > > > > > --- a/drivers/iommu/iommu.c
> > > > > > > > > > > +++ b/drivers/iommu/iommu.c
> > > > > > > > > > > @@ -696,6 +696,16 @@ void iommu_detach_device(struct
> > > > > > > > > > > iommu_domain *domain, struct device *dev) }
> > > > > > > > > > > EXPORT_SYMBOL_GPL(iommu_detach_device);
> > > > > > > > > > >
> > > > > > > > > > > +struct iommu_domain *iommu_get_dev_domain(struct
> > device *dev) {
> > > > > > > > > > > + struct iommu_ops *ops = dev->bus->iommu_ops;
> > > > > > > > > > > +
> > > > > > > > > > > + if (unlikely(ops == NULL ||
> > > > > > > > > > > +ops->get_dev_iommu_domain ==
> > > > NULL))
> > > > > > > > > > > + return NULL;
> > > > > > > > > > > +
> > > > > > > > > > > + return ops->get_dev_iommu_domain(dev); }
> > > > > > > > > > > +EXPORT_SYMBOL_GPL(iommu_get_dev_domain);
> > > > > > > > > >
> > > > > > > > > > What prevents this from racing iommu_domain_free()?
> > > > > > > > > > There's no references acquired, so there's no reason for
> > > > > > > > > > the caller to assume the
> > > > > > > > pointer is valid.
> > > > > > > > >
> > > > > > > > > Sorry for late query, somehow this email went into a
> > > > > > > > > folder and escaped;
> > > > > > > > >
> > > > > > > > > Just to be sure, there is not lock at generic "struct
> > > > > > > > > iommu_domain", but IP
> > > > > > > > specific structure (link FSL domain) linked in
> > > > > > > > iommu_domain->priv have a lock, so we need to ensure this
> > > > > > > > race in FSL iommu code (say drivers/iommu/fsl_pamu_domain.c),
> > right?
> > > > > > > >
> > > > > > > > No, it's not sufficient to make sure that your use of the
> > > > > > > > interface is race free. The interface itself needs to be
> > > > > > > > designed so that it's difficult to use incorrectly.
> > > > > > >
> > > > > > > So we can define
> > > > > > > iommu_get_dev_domain()/iommu_put_dev_domain();
> > > > > > > iommu_get_dev_domain() will return domain with the lock held,
> > > > > > > and
> > > > > > > iommu_put_dev_domain() will release the lock? And
> > > > > > > iommu_get_dev_domain() must always be followed by
> > > > > > > iommu_get_dev_domain().
> > > > > >
> > > > > > What lock? get/put are generally used for reference counting,
> > > > > > not locking in the kernel.
> > > > > >
> > > > > > > > That's not the case here. This is a backdoor to get the
> > > > > > > > iommu domain from the iommu driver regardless of who is using
> > it or how.
> > > > > > > > The iommu domain is created and managed by vfio, so
> > > > > > > > shouldn't we be looking at how to do this through vfio?
> > > > > > >
> > > > > > > Let me first describe what we are doing here:
> > > > > > > During initialization:-
> > > > > > > - vfio talks to MSI system to know the MSI-page and size
> > > > > > > - vfio then interacts with iommu to map the MSI-page in iommu
> > > > > > > (IOVA is decided by userspace and physical address is the
> > > > > > > MSI-page)
> > > > > > > - So the IOVA subwindow mapping is created in iommu and yes
> > > > > > > VFIO know about
> > > > > > this mapping.
> > > > > > >
> > > > > > > Now do SET_IRQ(MSI/MSIX) ioctl:
> > > > > > > - calls pci_enable_msix()/pci_enable_msi_block(): which is
> > > > > > > supposed to set
> > > > > > MSI address/data in device.
> > > > > > > - So in current implementation (this patchset) msi-subsystem
> > > > > > > gets the IOVA
> > > > > > from iommu via this defined interface.
> > > > > > > - Are you saying that rather than getting this from iommu, we
> > > > > > > should get this
> > > > > > from vfio? What difference does this make?
> > > > > >
> > > > > > Yes, you just said above that vfio knows the msi to iova
> > > > > > mapping, so why go outside of vfio to find it later? The
> > > > > > difference is one case you can have a proper reference to data
> > > > > > structures to make sure the pointer you get back actually has
> > > > > > meaning at the time you're using it vs the code here where
> > > > > > you're defining an API that returns a meaningless value
> > > > >
> > > > > With FSL-PAMU we will always get consistant data from iommu or
> > > > > vfio-data
> > > > structure.
> > > >
> > > > Great, but you're trying to add a generic API to the IOMMU subsystem
> > > > that's difficult to use correctly. The fact that you use it
> > > > correctly does not justify the API.
> > > >
> > > > > > because you can't check or
> > > > > > enforce that an arbitrary caller is using it correctly.
> > > > >
> > > > > I am not sure what is arbitrary caller? pdev is known to vfio, so
> > > > > vfio will only make pci_enable_msix()/pci_enable_msi_block() for
> > this pdev.
> > > > > If anyother code makes then it is some other unexpectedly thing
> > > > > happening in system, no?
> > > >
> > > > What's proposed here is a generic IOMMU API. Anybody can call this.
> > > > What if the host SCSI driver decides to go get the iommu domain for
> > > > it's device (or any other device)? Does that fit your usage model?
> > > >
> > > > > > It's not maintainable.
> > > > > > Thanks,
> > > > >
> > > > > I do not have any issue with this as well, can you also describe
> > > > > the type of API you are envisioning; I can think of defining some
> > > > > function in vfio.c/vfio_iommu*.c, make them global and declare
> > > > > then in include/Linux/vfio.h And include <Linux/vfio.h> in caller
> > > > > file
> > > > > (arch/powerpc/kernel/msi.c)
> > > >
> > > > Do you really want module dependencies between vfio and your core
> > > > kernel MSI setup? Look at the vfio external user interface that
> > we've already defined.
> > > > That allows other components of the kernel to get a proper reference
> > > > to a vfio group. From there you can work out how to get what you
> > > > want. Another alternative is that vfio could register an MSI to
> > > > IOVA mapping with architecture code when the mapping is created.
> > > > The MSI setup path could then do a lookup in architecture code for
> > > > the mapping. You could even store the MSI to IOVA mapping in VFIO
> > > > and create an interface where SET_IRQ passes that mapping into setup
> > code.
> [Sethi Varun-B16395] What you are suggesting is that the MSI setup
> path queries the vfio subsystem for the mapping, rather than directly
> querying the iommu subsystem. So, say if we add an interface for
> getting MSI to IOVA mapping in the msi setup path, wouldn't this again
> be specific to vfio? I reckon that this interface would again ppc
> machine specific interface.
Sure, if this is a generic MSI setup path then clearly vfio should not
be involved. But by that same notion, if this is a generic MSI setup
path, how can the proposed solutions guarantee that the iommu_domain or
iova returned is still valid in all cases? It's racy. If the caller
trying to setup MSI has the information needed, why doesn't it pass it
in as part of the setup? Thanks,
Alex
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 1/7] powerpc: Add interface to get msi region information
2013-10-08 17:09 ` Bhushan Bharat-R65777
@ 2013-10-10 21:13 ` Sethi Varun-B16395
0 siblings, 0 replies; 41+ messages in thread
From: Sethi Varun-B16395 @ 2013-10-10 21:13 UTC (permalink / raw)
To: Bhushan Bharat-R65777, joro, Bjorn Helgaas
Cc: agraf, Wood Scott-B07421, linux-pci, iommu, linux-kernel,
alex.williamson, linuxppc-dev
> -----Original Message-----
> From: linux-kernel-owner@vger.kernel.org [mailto:linux-kernel-
> owner@vger.kernel.org] On Behalf Of Bhushan Bharat-R65777
> Sent: Tuesday, October 08, 2013 10:40 PM
> To: joro@8bytes.org; Bjorn Helgaas
> Cc: alex.williamson@redhat.com; benh@kernel.crashing.org;
> galak@kernel.crashing.org; linux-kernel@vger.kernel.org; linuxppc-
> dev@lists.ozlabs.org; linux-pci@vger.kernel.org; agraf@suse.de; Wood
> Scott-B07421; iommu@lists.linux-foundation.org
> Subject: RE: [PATCH 1/7] powerpc: Add interface to get msi region
> information
>=20
>=20
>=20
> > -----Original Message-----
> > From: joro@8bytes.org [mailto:joro@8bytes.org]
> > Sent: Tuesday, October 08, 2013 10:32 PM
> > To: Bjorn Helgaas
> > Cc: Bhushan Bharat-R65777; alex.williamson@redhat.com;
> > benh@kernel.crashing.org; galak@kernel.crashing.org;
> > linux-kernel@vger.kernel.org; linuxppc- dev@lists.ozlabs.org;
> > linux-pci@vger.kernel.org; agraf@suse.de; Wood Scott- B07421;
> > iommu@lists.linux-foundation.org
> > Subject: Re: [PATCH 1/7] powerpc: Add interface to get msi region
> > information
> >
> > On Tue, Oct 08, 2013 at 10:47:49AM -0600, Bjorn Helgaas wrote:
> > > I still have no idea what an "aperture type IOMMU" is, other than
> > > that it is "different."
> >
> > An aperture based IOMMU is basically any GART-like IOMMU which can
> > only remap a small window (the aperture) of the DMA address space. DMA
> > outside of that window is either blocked completly or passed through
> untranslated.
>=20
> It is completely blocked for Freescale PAMU.
> So for this type of iommu what we have to do is to create a MSI mapping
> just after guest physical address, Example: guest have a 512M of memory
> then we create window of 1G (because of power of 2 requirement), then we
> have to FIT MSI just after 512M of guest.
[Sethi Varun-B16395] PAMU (FSL IOMMU) has a concept of primary window and s=
ubwindows. Primary window corresponds to the complete guest iova address sp=
ace (including MSI space), with respect to IOMMU_API this is termed as geom=
etry . IOVA Base of subwindow is determined from the number of subwindows (=
configurable using iommu API). Subwindows allow for handling physically dis=
contiguous memory. PAMU translates device iova accesses to actual physical =
address. MSI mapping would be addressed by a subwindow, with iova base star=
ting at the end of the guest iova space.=20
VFIO code creates a PAMU window (also defines number of subwindow) to map =
the guest iova space + msi space. The interface defined by this patch queri=
es the PAMU driver to get the iova mapping for the msi region assigned to t=
he PCIe device (assigned to the guest).
-Varun
^ permalink raw reply [flat|nested] 41+ messages in thread
* RE: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-10 20:41 ` Alex Williamson
@ 2013-10-14 12:58 ` Sethi Varun-B16395
2013-10-14 14:20 ` Alex Williamson
0 siblings, 1 reply; 41+ messages in thread
From: Sethi Varun-B16395 @ 2013-10-14 12:58 UTC (permalink / raw)
To: Alex Williamson
Cc: Wood Scott-B07421, linux-pci, linux-kernel, agraf, iommu,
Bhushan Bharat-R65777, linuxppc-dev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^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
2013-10-14 12:58 ` Sethi Varun-B16395
@ 2013-10-14 14:20 ` Alex Williamson
0 siblings, 0 replies; 41+ messages in thread
From: Alex Williamson @ 2013-10-14 14:20 UTC (permalink / raw)
To: Sethi Varun-B16395
Cc: Wood Scott-B07421, linux-pci, linux-kernel, agraf, iommu,
Bhushan Bharat-R65777, linuxppc-dev
On Mon, 2013-10-14 at 12:58 +0000, Sethi Varun-B16395 wrote:
>
> > -----Original Message-----
> > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > Sent: Friday, October 11, 2013 2:12 AM
> > To: Sethi Varun-B16395
> > Cc: Bhushan Bharat-R65777; agraf@suse.de; Wood Scott-B07421; linux-
> > pci@vger.kernel.org; galak@kernel.crashing.org; linux-
> > kernel@vger.kernel.org; iommu@lists.linux-foundation.org;
> > benh@kernel.crashing.org; linuxppc-dev@lists.ozlabs.org
> > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a device
> >
> > On Thu, 2013-10-10 at 20:09 +0000, Sethi Varun-B16395 wrote:
> > >
> > > > -----Original Message-----
> > > > From: iommu-bounces@lists.linux-foundation.org [mailto:iommu-
> > > > bounces@lists.linux-foundation.org] On Behalf Of Alex Williamson
> > > > Sent: Tuesday, October 08, 2013 8:43 AM
> > > > To: Bhushan Bharat-R65777
> > > > Cc: agraf@suse.de; Wood Scott-B07421; linux-pci@vger.kernel.org;
> > > > galak@kernel.crashing.org; linux-kernel@vger.kernel.org;
> > > > iommu@lists.linux-foundation.org; benh@kernel.crashing.org;
> > > > linuxppc- dev@lists.ozlabs.org
> > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a
> > > > device
> > > >
> > > > On Mon, 2013-10-07 at 05:46 +0000, Bhushan Bharat-R65777 wrote:
> > > > >
> > > > > > -----Original Message-----
> > > > > > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > > > > > Sent: Friday, October 04, 2013 11:42 PM
> > > > > > To: Bhushan Bharat-R65777
> > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > > > > > foundation.org
> > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain of a
> > > > > > device
> > > > > >
> > > > > > On Fri, 2013-10-04 at 17:23 +0000, Bhushan Bharat-R65777 wrote:
> > > > > > >
> > > > > > > > -----Original Message-----
> > > > > > > > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > > > > > > > Sent: Friday, October 04, 2013 10:43 PM
> > > > > > > > To: Bhushan Bharat-R65777
> > > > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > > > galak@kernel.crashing.org; linux- kernel@vger.kernel.org;
> > > > > > > > linuxppc-dev@lists.ozlabs.org; linux- pci@vger.kernel.org;
> > > > > > > > agraf@suse.de; Wood Scott-B07421; iommu@lists.linux-
> > > > > > > > foundation.org
> > > > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get iommu_domain
> > > > > > > > of a device
> > > > > > > >
> > > > > > > > On Fri, 2013-10-04 at 16:47 +0000, Bhushan Bharat-R65777
> > wrote:
> > > > > > > > >
> > > > > > > > > > -----Original Message-----
> > > > > > > > > > From: Alex Williamson
> > > > > > > > > > [mailto:alex.williamson@redhat.com]
> > > > > > > > > > Sent: Friday, October 04, 2013 9:15 PM
> > > > > > > > > > To: Bhushan Bharat-R65777
> > > > > > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > > > > > galak@kernel.crashing.org; linux-
> > > > > > > > > > kernel@vger.kernel.org; linuxppc-dev@lists.ozlabs.org;
> > > > > > > > > > linux- pci@vger.kernel.org; agraf@suse.de; Wood
> > > > > > > > > > Scott-B07421; iommu@lists.linux- foundation.org
> > > > > > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get
> > > > > > > > > > iommu_domain of a device
> > > > > > > > > >
> > > > > > > > > > On Fri, 2013-10-04 at 09:54 +0000, Bhushan Bharat-R65777
> > > > wrote:
> > > > > > > > > > >
> > > > > > > > > > > > -----Original Message-----
> > > > > > > > > > > > From: linux-pci-owner@vger.kernel.org
> > > > > > > > > > > > [mailto:linux-pci-owner@vger.kernel.org]
> > > > > > > > > > > > On Behalf Of Alex Williamson
> > > > > > > > > > > > Sent: Wednesday, September 25, 2013 10:16 PM
> > > > > > > > > > > > To: Bhushan Bharat-R65777
> > > > > > > > > > > > Cc: joro@8bytes.org; benh@kernel.crashing.org;
> > > > > > > > > > > > galak@kernel.crashing.org; linux-
> > > > > > > > > > > > kernel@vger.kernel.org;
> > > > > > > > > > > > linuxppc-dev@lists.ozlabs.org;
> > > > > > > > > > > > linux- pci@vger.kernel.org; agraf@suse.de; Wood
> > > > > > > > > > > > Scott-B07421; iommu@lists.linux- foundation.org;
> > > > > > > > > > > > Bhushan
> > > > > > > > > > > > Bharat-R65777
> > > > > > > > > > > > Subject: Re: [PATCH 2/7] iommu: add api to get
> > > > > > > > > > > > iommu_domain of a device
> > > > > > > > > > > >
> > > > > > > > > > > > On Thu, 2013-09-19 at 12:59 +0530, Bharat Bhushan
> > wrote:
> > > > > > > > > > > > > This api return the iommu domain to which the
> > > > > > > > > > > > > device is
> > > > attached.
> > > > > > > > > > > > > The iommu_domain is required for making API calls
> > > > > > > > > > > > > related to
> > > > > > iommu.
> > > > > > > > > > > > > Follow up patches which use this API to know iommu
> > > > maping.
> > > > > > > > > > > > >
> > > > > > > > > > > > > Signed-off-by: Bharat Bhushan
> > > > > > > > > > > > > <bharat.bhushan@freescale.com>
> > > > > > > > > > > > > ---
> > > > > > > > > > > > > drivers/iommu/iommu.c | 10 ++++++++++
> > > > > > > > > > > > > include/linux/iommu.h | 7 +++++++
> > > > > > > > > > > > > 2 files changed, 17 insertions(+), 0 deletions(-)
> > > > > > > > > > > > >
> > > > > > > > > > > > > diff --git a/drivers/iommu/iommu.c
> > > > > > > > > > > > > b/drivers/iommu/iommu.c index
> > > > > > > > > > > > > fbe9ca7..6ac5f50 100644
> > > > > > > > > > > > > --- a/drivers/iommu/iommu.c
> > > > > > > > > > > > > +++ b/drivers/iommu/iommu.c
> > > > > > > > > > > > > @@ -696,6 +696,16 @@ void
> > > > > > > > > > > > > iommu_detach_device(struct iommu_domain *domain,
> > > > > > > > > > > > > struct device *dev) }
> > > > > > > > > > > > > EXPORT_SYMBOL_GPL(iommu_detach_device);
> > > > > > > > > > > > >
> > > > > > > > > > > > > +struct iommu_domain *iommu_get_dev_domain(struct
> > > > device *dev) {
> > > > > > > > > > > > > + struct iommu_ops *ops = dev->bus->iommu_ops;
> > > > > > > > > > > > > +
> > > > > > > > > > > > > + if (unlikely(ops == NULL ||
> > > > > > > > > > > > > +ops->get_dev_iommu_domain ==
> > > > > > NULL))
> > > > > > > > > > > > > + return NULL;
> > > > > > > > > > > > > +
> > > > > > > > > > > > > + return ops->get_dev_iommu_domain(dev); }
> > > > > > > > > > > > > +EXPORT_SYMBOL_GPL(iommu_get_dev_domain);
> > > > > > > > > > > >
> > > > > > > > > > > > What prevents this from racing iommu_domain_free()?
> > > > > > > > > > > > There's no references acquired, so there's no reason
> > > > > > > > > > > > for the caller to assume the
> > > > > > > > > > pointer is valid.
> > > > > > > > > > >
> > > > > > > > > > > Sorry for late query, somehow this email went into a
> > > > > > > > > > > folder and escaped;
> > > > > > > > > > >
> > > > > > > > > > > Just to be sure, there is not lock at generic "struct
> > > > > > > > > > > iommu_domain", but IP
> > > > > > > > > > specific structure (link FSL domain) linked in
> > > > > > > > > > iommu_domain->priv have a lock, so we need to ensure
> > > > > > > > > > this race in FSL iommu code (say
> > > > > > > > > > drivers/iommu/fsl_pamu_domain.c),
> > > > right?
> > > > > > > > > >
> > > > > > > > > > No, it's not sufficient to make sure that your use of
> > > > > > > > > > the interface is race free. The interface itself needs
> > > > > > > > > > to be designed so that it's difficult to use incorrectly.
> > > > > > > > >
> > > > > > > > > So we can define
> > > > > > > > > iommu_get_dev_domain()/iommu_put_dev_domain();
> > > > > > > > > iommu_get_dev_domain() will return domain with the lock
> > > > > > > > > held, and
> > > > > > > > > iommu_put_dev_domain() will release the lock? And
> > > > > > > > > iommu_get_dev_domain() must always be followed by
> > > > > > > > > iommu_get_dev_domain().
> > > > > > > >
> > > > > > > > What lock? get/put are generally used for reference
> > > > > > > > counting, not locking in the kernel.
> > > > > > > >
> > > > > > > > > > That's not the case here. This is a backdoor to get the
> > > > > > > > > > iommu domain from the iommu driver regardless of who is
> > > > > > > > > > using
> > > > it or how.
> > > > > > > > > > The iommu domain is created and managed by vfio, so
> > > > > > > > > > shouldn't we be looking at how to do this through vfio?
> > > > > > > > >
> > > > > > > > > Let me first describe what we are doing here:
> > > > > > > > > During initialization:-
> > > > > > > > > - vfio talks to MSI system to know the MSI-page and size
> > > > > > > > > - vfio then interacts with iommu to map the MSI-page in
> > > > > > > > > iommu (IOVA is decided by userspace and physical address
> > > > > > > > > is the
> > > > > > > > > MSI-page)
> > > > > > > > > - So the IOVA subwindow mapping is created in iommu and
> > > > > > > > > yes VFIO know about
> > > > > > > > this mapping.
> > > > > > > > >
> > > > > > > > > Now do SET_IRQ(MSI/MSIX) ioctl:
> > > > > > > > > - calls pci_enable_msix()/pci_enable_msi_block(): which
> > > > > > > > > is supposed to set
> > > > > > > > MSI address/data in device.
> > > > > > > > > - So in current implementation (this patchset)
> > > > > > > > > msi-subsystem gets the IOVA
> > > > > > > > from iommu via this defined interface.
> > > > > > > > > - Are you saying that rather than getting this from
> > > > > > > > > iommu, we should get this
> > > > > > > > from vfio? What difference does this make?
> > > > > > > >
> > > > > > > > Yes, you just said above that vfio knows the msi to iova
> > > > > > > > mapping, so why go outside of vfio to find it later? The
> > > > > > > > difference is one case you can have a proper reference to
> > > > > > > > data structures to make sure the pointer you get back
> > > > > > > > actually has meaning at the time you're using it vs the code
> > > > > > > > here where you're defining an API that returns a meaningless
> > > > > > > > value
> > > > > > >
> > > > > > > With FSL-PAMU we will always get consistant data from iommu or
> > > > > > > vfio-data
> > > > > > structure.
> > > > > >
> > > > > > Great, but you're trying to add a generic API to the IOMMU
> > > > > > subsystem that's difficult to use correctly. The fact that you
> > > > > > use it correctly does not justify the API.
> > > > > >
> > > > > > > > because you can't check or
> > > > > > > > enforce that an arbitrary caller is using it correctly.
> > > > > > >
> > > > > > > I am not sure what is arbitrary caller? pdev is known to vfio,
> > > > > > > so vfio will only make
> > > > > > > pci_enable_msix()/pci_enable_msi_block() for
> > > > this pdev.
> > > > > > > If anyother code makes then it is some other unexpectedly
> > > > > > > thing happening in system, no?
> > > > > >
> > > > > > What's proposed here is a generic IOMMU API. Anybody can call
> > this.
> > > > > > What if the host SCSI driver decides to go get the iommu domain
> > > > > > for it's device (or any other device)? Does that fit your usage
> > model?
> > > > > >
> > > > > > > > It's not maintainable.
> > > > > > > > Thanks,
> > > > > > >
> > > > > > > I do not have any issue with this as well, can you also
> > > > > > > describe the type of API you are envisioning; I can think of
> > > > > > > defining some function in vfio.c/vfio_iommu*.c, make them
> > > > > > > global and declare then in include/Linux/vfio.h And include
> > > > > > > <Linux/vfio.h> in caller file
> > > > > > > (arch/powerpc/kernel/msi.c)
> > > > > >
> > > > > > Do you really want module dependencies between vfio and your
> > > > > > core kernel MSI setup? Look at the vfio external user interface
> > > > > > that
> > > > we've already defined.
> > > > > > That allows other components of the kernel to get a proper
> > > > > > reference to a vfio group. From there you can work out how to
> > > > > > get what you want. Another alternative is that vfio could
> > > > > > register an MSI to IOVA mapping with architecture code when the
> > mapping is created.
> > > > > > The MSI setup path could then do a lookup in architecture code
> > > > > > for the mapping. You could even store the MSI to IOVA mapping
> > > > > > in VFIO and create an interface where SET_IRQ passes that
> > > > > > mapping into setup
> > > > code.
> > > [Sethi Varun-B16395] What you are suggesting is that the MSI setup
> > > path queries the vfio subsystem for the mapping, rather than directly
> > > querying the iommu subsystem. So, say if we add an interface for
> > > getting MSI to IOVA mapping in the msi setup path, wouldn't this again
> > > be specific to vfio? I reckon that this interface would again ppc
> > > machine specific interface.
> >
> > Sure, if this is a generic MSI setup path then clearly vfio should not be
> > involved. But by that same notion, if this is a generic MSI setup path,
> > how can the proposed solutions guarantee that the iommu_domain or iova
> > returned is still valid in all cases? It's racy. If the caller trying
> > to setup MSI has the information needed, why doesn't it pass it in as
> > part of the setup? Thanks,
> [Sethi Varun-B16395] Agreed, the proposed interface is not clean. But, we still need an interface through which MSI driver can call in to the vfio layer.
Or one that allows vfio to pass in the iova when the interrupt is being
setup. I'm afraid any kind of reverse interface where MSI calls back
into vfio is going to be racy. Thanks,
Alex
^ permalink raw reply [flat|nested] 41+ messages in thread
end of thread, other threads:[~2013-10-14 14:20 UTC | newest]
Thread overview: 41+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2013-09-19 7:29 [PATCH 0/7] vfio-pci: add support for Freescale IOMMU (PAMU) Bharat Bhushan
2013-09-19 7:29 ` [PATCH 1/7] powerpc: Add interface to get msi region information Bharat Bhushan
2013-09-24 23:58 ` Bjorn Helgaas
2013-10-04 5:19 ` Bhushan Bharat-R65777
2013-10-08 16:47 ` Bjorn Helgaas
2013-10-08 17:02 ` joro
2013-10-08 17:09 ` Bhushan Bharat-R65777
2013-10-10 21:13 ` Sethi Varun-B16395
2013-10-08 17:09 ` Scott Wood
2013-10-08 22:57 ` Scott Wood
2013-10-08 23:25 ` Bjorn Helgaas
2013-10-08 23:35 ` Scott Wood
2013-10-09 4:47 ` Bhushan Bharat-R65777
2013-09-19 7:29 ` [PATCH 2/7] iommu: add api to get iommu_domain of a device Bharat Bhushan
2013-09-25 16:45 ` Alex Williamson
2013-10-04 9:54 ` Bhushan Bharat-R65777
2013-10-04 15:45 ` Alex Williamson
2013-10-04 16:47 ` Bhushan Bharat-R65777
2013-10-04 17:12 ` Alex Williamson
2013-10-04 17:23 ` Bhushan Bharat-R65777
2013-10-04 18:12 ` Alex Williamson
2013-10-07 5:46 ` Bhushan Bharat-R65777
2013-10-08 3:13 ` Alex Williamson
2013-10-08 3:42 ` Bhushan Bharat-R65777
2013-10-10 20:09 ` Sethi Varun-B16395
2013-10-10 20:41 ` Alex Williamson
2013-10-14 12:58 ` Sethi Varun-B16395
2013-10-14 14:20 ` Alex Williamson
2013-10-04 10:42 ` Bhushan Bharat-R65777
2013-09-19 7:29 ` [PATCH 3/7] fsl iommu: add get_dev_iommu_domain Bharat Bhushan
2013-09-19 7:29 ` [PATCH 4/7] powerpc: translate msi addr to iova if iommu is in use Bharat Bhushan
2013-09-19 7:29 ` [PATCH 5/7] iommu: supress loff_t compilation error on powerpc Bharat Bhushan
2013-09-25 16:40 ` Alex Williamson
2013-09-26 3:53 ` Bhushan Bharat-R65777
2013-09-26 22:20 ` Scott Wood
2013-09-19 7:29 ` [PATCH 6/7] vfio: moving some functions in common file Bharat Bhushan
2013-09-25 17:02 ` Alex Williamson
2013-09-26 3:57 ` Bhushan Bharat-R65777
2013-09-19 7:29 ` [PATCH 7/7] vfio pci: Add vfio iommu implementation for FSL_PAMU Bharat Bhushan
2013-09-25 19:06 ` Alex Williamson
2013-09-26 5:27 ` Bhushan Bharat-R65777
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).