Xen-Devel Archive on lore.kernel.org
 help / color / Atom feed
* [Xen-devel] [PATCH V3 0/8] iommu/arm: Add Renesas IPMMU-VMSA support + Linux's iommu_fwspec
@ 2019-08-20 18:09 Oleksandr Tyshchenko
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 1/8] iommu/arm: Add iommu_helpers.c file to keep common for IOMMUs stuff Oleksandr Tyshchenko
                   ` (7 more replies)
  0 siblings, 8 replies; 41+ messages in thread
From: Oleksandr Tyshchenko @ 2019-08-20 18:09 UTC (permalink / raw)
  To: xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini,
	Volodymyr_Babchuk, Yoshihiro Shimoda

From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>

The purpose of this patch series is to add IPMMU-VMSA support to Xen on ARM.

Besides new IOMMU driver, this series contains "iommu_fwspec" support
and new API iommu_add_dt_device() for adding DT device to IOMMU and many other 
things.

The IPMMU-VMSA is VMSA-compatible I/O Memory Management Unit (IOMMU)
which provides address translation and access protection functionalities
to processing units and interconnect networks.

Please note, this driver is supposed to work only with newest
Gen3 SoCs revisions which IPMMU hardware supports stage 2 translation
table format and is able to use CPU's P2M table as is if one is
3-level page table (up to 40 bit IPA).

----------
This driver is based on Linux's IPMMU-VMSA driver from Renesas BSP:
https://git.kernel.org/pub/scm/linux/kernel/git/horms/renesas-bsp.git/tree/drivers/iommu/ipmmu-vmsa.c?h=v4.14.75-ltsi/rcar-3.9.6
and Xen's SMMU driver:
xen/drivers/passthrough/arm/smmu.c

Although Xen driver has a lot in common with Linux driver, it is not
a "direct ported" copy and should be treated as such.

The major differences compare to the Linux driver are:

1. Stage 1/Stage 2 translation. Linux driver supports Stage 1
translation only (with Stage 1 translation table format). It manages
page table by itself. But Xen driver supports Stage 2 translation
(with Stage 2 translation table format) to be able to share the P2M
with the CPU. Stage 1 translation is always bypassed in Xen driver.

So, Xen driver is supposed to be used with newest Gen3 SoC revisions only
(H3 ES3.0, M3-W+, etc.) which IPMMU H/W supports stage 2 translation
table format.

2. AArch64 support. Linux driver uses VMSAv8-32 mode, while Xen driver
enables Armv8 VMSAv8-64 mode to cover up to 40 bit input address.

3. Context bank (sets of page table) usage. In Xen, each context bank is
mapped to one Xen domain. So, all devices being pass throughed to the
same Xen domain share the same context bank.

4. IPMMU device tracking. In Xen, all IOMMU devices are managed
by single driver instance. So, driver uses global list to keep track
of registered IPMMU devices.

----------
Series was tested on Gen3 H3 ES3.0 based boards using current staging
(248faa6 xen/arm: add reserved-memory regions to the dom0 memory node)
in a system with several DMA masters being assigned to different guest domains.
Guest domain reboot, destroy/create are functional.  

Please note, the series depends on Julien's patch (on review):
https://lists.xenproject.org/archives/html/xen-devel/2019-08/msg01924.html

You can find the whole series (+ Julien's patch) here:
repo: https://github.com/otyshchenko1/xen.git branch: ipmmu_upstream3

You can find previous discussions here:
[V1] https://lists.xenproject.org/archives/html/xen-devel/2019-06/msg01755.html
[V2] https://lists.xenproject.org/archives/html/xen-devel/2019-08/msg00253.html

Oleksandr Tyshchenko (8):
  iommu/arm: Add iommu_helpers.c file to keep common for IOMMUs stuff
  iommu/arm: Add ability to handle deferred probing request
  xen/common: Introduce _xrealloc function
  xen/common: Introduce xrealloc_flex_struct() helper macros
  iommu/arm: Add lightweight iommu_fwspec support
  iommu: Add of_xlate callback
  iommu/arm: Introduce iommu_add_dt_device API
  iommu/arm: Add Renesas IPMMU-VMSA support

 xen/arch/arm/domain_build.c                 |   11 +
 xen/arch/arm/platforms/Kconfig              |    1 +
 xen/common/xmalloc_tlsf.c                   |   45 +
 xen/drivers/passthrough/Kconfig             |   13 +
 xen/drivers/passthrough/arm/Makefile        |    3 +-
 xen/drivers/passthrough/arm/iommu.c         |  114 ++-
 xen/drivers/passthrough/arm/iommu_fwspec.c  |   94 ++
 xen/drivers/passthrough/arm/iommu_helpers.c |   84 ++
 xen/drivers/passthrough/arm/ipmmu-vmsa.c    | 1359 +++++++++++++++++++++++++++
 xen/drivers/passthrough/arm/smmu.c          |   48 +-
 xen/include/asm-arm/device.h                |    7 +-
 xen/include/asm-arm/iommu.h                 |   18 +
 xen/include/asm-arm/iommu_fwspec.h          |   68 ++
 xen/include/xen/device_tree.h               |    7 +
 xen/include/xen/iommu.h                     |   10 +
 xen/include/xen/xmalloc.h                   |   13 +
 16 files changed, 1843 insertions(+), 52 deletions(-)
 create mode 100644 xen/drivers/passthrough/arm/iommu_fwspec.c
 create mode 100644 xen/drivers/passthrough/arm/iommu_helpers.c
 create mode 100644 xen/drivers/passthrough/arm/ipmmu-vmsa.c
 create mode 100644 xen/include/asm-arm/iommu_fwspec.h

-- 
2.7.4


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* [Xen-devel] [PATCH V3 1/8] iommu/arm: Add iommu_helpers.c file to keep common for IOMMUs stuff
  2019-08-20 18:09 [Xen-devel] [PATCH V3 0/8] iommu/arm: Add Renesas IPMMU-VMSA support + Linux's iommu_fwspec Oleksandr Tyshchenko
@ 2019-08-20 18:09 ` Oleksandr Tyshchenko
  2019-09-09 11:45   ` Julien Grall
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 2/8] iommu/arm: Add ability to handle deferred probing request Oleksandr Tyshchenko
                   ` (6 subsequent siblings)
  7 siblings, 1 reply; 41+ messages in thread
From: Oleksandr Tyshchenko @ 2019-08-20 18:09 UTC (permalink / raw)
  To: xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini, Volodymyr_Babchuk

From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>

Introduce a separate file to keep various helpers which could be used
by more than one IOMMU driver in order not to duplicate code.

The first candidates to be moved to the new file are SMMU driver's
"map_page/unmap_page" callbacks. There callbacks neither contain any
SMMU specific info nor perform any SMMU specific actions and are going
to be the same across all IOMMU drivers which H/W IP shares P2M
with the CPU like SMMU does.

So, move callbacks to iommu_helpers.c for the upcoming IPMMU driver
to be able to re-use them.

Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
CC: Julien Grall <julien.grall@arm.com>

---
Changes V2 -> V3:
    - put headers in alphabetical order
    - retained Copyright from the SMMU code
---
 xen/drivers/passthrough/arm/Makefile        |  2 +-
 xen/drivers/passthrough/arm/iommu_helpers.c | 84 +++++++++++++++++++++++++++++
 xen/drivers/passthrough/arm/smmu.c          | 48 +----------------
 xen/include/asm-arm/iommu.h                 |  7 +++
 4 files changed, 94 insertions(+), 47 deletions(-)
 create mode 100644 xen/drivers/passthrough/arm/iommu_helpers.c

diff --git a/xen/drivers/passthrough/arm/Makefile b/xen/drivers/passthrough/arm/Makefile
index b3efcfd..4abb87a 100644
--- a/xen/drivers/passthrough/arm/Makefile
+++ b/xen/drivers/passthrough/arm/Makefile
@@ -1,2 +1,2 @@
-obj-y += iommu.o
+obj-y += iommu.o iommu_helpers.o
 obj-$(CONFIG_ARM_SMMU) += smmu.o
diff --git a/xen/drivers/passthrough/arm/iommu_helpers.c b/xen/drivers/passthrough/arm/iommu_helpers.c
new file mode 100644
index 0000000..a36e2b8
--- /dev/null
+++ b/xen/drivers/passthrough/arm/iommu_helpers.c
@@ -0,0 +1,84 @@
+/*
+ * xen/drivers/passthrough/arm/iommu_helpers.c
+ *
+ * Contains various helpers to be used by IOMMU drivers.
+ *
+ * Based on Xen's SMMU driver:
+ *    xen/drivers/passthrough/arm/smmu.c
+ *
+ * Copyright (C) 2014 Linaro Limited.
+ *
+ * Copyright (C) 2019 EPAM Systems Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms and conditions 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <xen/iommu.h>
+#include <xen/lib.h>
+#include <xen/sched.h>
+
+#include <asm/device.h>
+
+/* Should only be used if P2M Table is shared between the CPU and the IOMMU. */
+int __must_check arm_iommu_map_page(struct domain *d, dfn_t dfn, mfn_t mfn,
+                                    unsigned int flags,
+                                    unsigned int *flush_flags)
+{
+    p2m_type_t t;
+
+    /*
+     * Grant mappings can be used for DMA requests. The dev_bus_addr
+     * returned by the hypercall is the MFN (not the IPA). For device
+     * protected by an IOMMU, Xen needs to add a 1:1 mapping in the domain
+     * p2m to allow DMA request to work.
+     * This is only valid when the domain is directed mapped. Hence this
+     * function should only be used by gnttab code with gfn == mfn == dfn.
+     */
+    BUG_ON(!is_domain_direct_mapped(d));
+    BUG_ON(mfn_x(mfn) != dfn_x(dfn));
+
+    /* We only support readable and writable flags */
+    if ( !(flags & (IOMMUF_readable | IOMMUF_writable)) )
+        return -EINVAL;
+
+    t = (flags & IOMMUF_writable) ? p2m_iommu_map_rw : p2m_iommu_map_ro;
+
+    /*
+     * The function guest_physmap_add_entry replaces the current mapping
+     * if there is already one...
+     */
+    return guest_physmap_add_entry(d, _gfn(dfn_x(dfn)), _mfn(dfn_x(dfn)), 0, t);
+}
+
+/* Should only be used if P2M Table is shared between the CPU and the IOMMU. */
+int __must_check arm_iommu_unmap_page(struct domain *d, dfn_t dfn,
+                                      unsigned int *flush_flags)
+{
+    /*
+     * This function should only be used by gnttab code when the domain
+     * is direct mapped (i.e. gfn == mfn == dfn).
+     */
+    if ( !is_domain_direct_mapped(d) )
+        return -EINVAL;
+
+    return guest_physmap_remove_page(d, _gfn(dfn_x(dfn)), _mfn(dfn_x(dfn)), 0);
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "BSD"
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
diff --git a/xen/drivers/passthrough/arm/smmu.c b/xen/drivers/passthrough/arm/smmu.c
index f151b9f..8ae986a 100644
--- a/xen/drivers/passthrough/arm/smmu.c
+++ b/xen/drivers/passthrough/arm/smmu.c
@@ -2734,50 +2734,6 @@ static void arm_smmu_iommu_domain_teardown(struct domain *d)
 	xfree(xen_domain);
 }
 
-static int __must_check arm_smmu_map_page(struct domain *d, dfn_t dfn,
-					  mfn_t mfn, unsigned int flags,
-					  unsigned int *flush_flags)
-{
-	p2m_type_t t;
-
-	/*
-	 * Grant mappings can be used for DMA requests. The dev_bus_addr
-	 * returned by the hypercall is the MFN (not the IPA). For device
-	 * protected by an IOMMU, Xen needs to add a 1:1 mapping in the domain
-	 * p2m to allow DMA request to work.
-	 * This is only valid when the domain is directed mapped. Hence this
-	 * function should only be used by gnttab code with gfn == mfn == dfn.
-	 */
-	BUG_ON(!is_domain_direct_mapped(d));
-	BUG_ON(mfn_x(mfn) != dfn_x(dfn));
-
-	/* We only support readable and writable flags */
-	if (!(flags & (IOMMUF_readable | IOMMUF_writable)))
-		return -EINVAL;
-
-	t = (flags & IOMMUF_writable) ? p2m_iommu_map_rw : p2m_iommu_map_ro;
-
-	/*
-	 * The function guest_physmap_add_entry replaces the current mapping
-	 * if there is already one...
-	 */
-	return guest_physmap_add_entry(d, _gfn(dfn_x(dfn)), _mfn(dfn_x(dfn)),
-				       0, t);
-}
-
-static int __must_check arm_smmu_unmap_page(struct domain *d, dfn_t dfn,
-                                            unsigned int *flush_flags)
-{
-	/*
-	 * This function should only be used by gnttab code when the domain
-	 * is direct mapped (i.e. gfn == mfn == dfn).
-	 */
-	if ( !is_domain_direct_mapped(d) )
-		return -EINVAL;
-
-	return guest_physmap_remove_page(d, _gfn(dfn_x(dfn)), _mfn(dfn_x(dfn)), 0);
-}
-
 static const struct iommu_ops arm_smmu_iommu_ops = {
     .init = arm_smmu_iommu_domain_init,
     .hwdom_init = arm_smmu_iommu_hwdom_init,
@@ -2786,8 +2742,8 @@ static const struct iommu_ops arm_smmu_iommu_ops = {
     .iotlb_flush_all = arm_smmu_iotlb_flush_all,
     .assign_device = arm_smmu_assign_dev,
     .reassign_device = arm_smmu_reassign_dev,
-    .map_page = arm_smmu_map_page,
-    .unmap_page = arm_smmu_unmap_page,
+    .map_page = arm_iommu_map_page,
+    .unmap_page = arm_iommu_unmap_page,
 };
 
 static __init const struct arm_smmu_device *find_smmu(const struct device *dev)
diff --git a/xen/include/asm-arm/iommu.h b/xen/include/asm-arm/iommu.h
index 904c9ae..20d865e 100644
--- a/xen/include/asm-arm/iommu.h
+++ b/xen/include/asm-arm/iommu.h
@@ -26,6 +26,13 @@ struct arch_iommu
 const struct iommu_ops *iommu_get_ops(void);
 void iommu_set_ops(const struct iommu_ops *ops);
 
+/* mapping helpers */
+int __must_check arm_iommu_map_page(struct domain *d, dfn_t dfn, mfn_t mfn,
+                                    unsigned int flags,
+                                    unsigned int *flush_flags);
+int __must_check arm_iommu_unmap_page(struct domain *d, dfn_t dfn,
+                                      unsigned int *flush_flags);
+
 #endif /* __ARCH_ARM_IOMMU_H__ */
 
 /*
-- 
2.7.4


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* [Xen-devel] [PATCH V3 2/8] iommu/arm: Add ability to handle deferred probing request
  2019-08-20 18:09 [Xen-devel] [PATCH V3 0/8] iommu/arm: Add Renesas IPMMU-VMSA support + Linux's iommu_fwspec Oleksandr Tyshchenko
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 1/8] iommu/arm: Add iommu_helpers.c file to keep common for IOMMUs stuff Oleksandr Tyshchenko
@ 2019-08-20 18:09 ` Oleksandr Tyshchenko
  2019-09-09 12:24   ` Julien Grall
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 3/8] xen/common: Introduce _xrealloc function Oleksandr Tyshchenko
                   ` (5 subsequent siblings)
  7 siblings, 1 reply; 41+ messages in thread
From: Oleksandr Tyshchenko @ 2019-08-20 18:09 UTC (permalink / raw)
  To: xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini, Volodymyr_Babchuk

From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>

This patch adds minimal required support to General IOMMU framework
to be able to handle a case when IOMMU driver requesting deferred
probing for a device.

In order not to pull Linux's error code (-EPROBE_DEFER) to Xen
we have chosen -EAGAIN to be used for indicating that device
probing is deferred.

This is needed for the upcoming IPMMU driver which may request
deferred probing depending on what device will be probed the first
(there is some dependency between these devices, Root device must be
registered before Cache devices. If not the case, driver will deny
further Cache device probes until Root device is registered).
As we can't guarantee a fixed pre-defined order for the device nodes
in DT, we need to be ready for the situation where devices being
probed in "any" order.

While here, order the headers alphabetically.

Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
CC: Julien Grall <julien.grall@arm.com>

---
Changes V2 -> V3:
    - removed deferred_probe field from struct dt_device_node,
      re-used domain_list instead
    - documented domain_list usage
    - added ASSERT to check that np->domain_list is empty
      before re-using it
    - put deferred_probe_list to init section
    - used more strict logic regarding processing devices in
      the deferred list
    - added more comments to code
    - put headers in alphabetical order
---
 xen/drivers/passthrough/arm/iommu.c | 59 ++++++++++++++++++++++++++++++++++---
 xen/include/asm-arm/device.h        |  6 +++-
 xen/include/xen/device_tree.h       |  7 +++++
 3 files changed, 67 insertions(+), 5 deletions(-)

diff --git a/xen/drivers/passthrough/arm/iommu.c b/xen/drivers/passthrough/arm/iommu.c
index f219de9..72a30e0 100644
--- a/xen/drivers/passthrough/arm/iommu.c
+++ b/xen/drivers/passthrough/arm/iommu.c
@@ -15,11 +15,20 @@
  * GNU General Public License for more details.
  */
 
-#include <xen/lib.h>
-#include <xen/iommu.h>
 #include <xen/device_tree.h>
+#include <xen/iommu.h>
+#include <xen/lib.h>
+
 #include <asm/device.h>
 
+/*
+ * Deferred probe list is used to keep track of devices for which driver
+ * requested deferred probing (returned -EAGAIN).
+ *
+ * We re-use device's domain_list to link the device in the deferred list.
+ */
+static __initdata LIST_HEAD(deferred_probe_list);
+
 static const struct iommu_ops *iommu_ops;
 
 const struct iommu_ops *iommu_get_ops(void)
@@ -42,7 +51,7 @@ void __init iommu_set_ops(const struct iommu_ops *ops)
 
 int __init iommu_hardware_setup(void)
 {
-    struct dt_device_node *np;
+    struct dt_device_node *np, *tmp;
     int rc;
     unsigned int num_iommus = 0;
 
@@ -51,6 +60,17 @@ int __init iommu_hardware_setup(void)
         rc = device_init(np, DEVICE_IOMMU, NULL);
         if ( !rc )
             num_iommus++;
+        else if ( rc == -EAGAIN )
+        {
+            /* We expect nobody uses domain_list at such early stage. */
+            ASSERT(list_empty(&np->domain_list));
+
+            /*
+             * Driver requested deferred probing, so add this device to
+             * the deferred list for further processing.
+             */
+            list_add(&np->domain_list, &deferred_probe_list);
+        }
         /*
          * Ignore the following error codes:
          *   - EBADF: Indicate the current not is not an IOMMU
@@ -61,7 +81,38 @@ int __init iommu_hardware_setup(void)
             return rc;
     }
 
-    return ( num_iommus > 0 ) ? 0 : -ENODEV;
+    /* Return immediately if there are no initialized devices. */
+    if ( !num_iommus )
+        return ( list_empty(&deferred_probe_list) ) ? -ENODEV : -EAGAIN;
+
+    rc = 0;
+
+    /*
+     * Process devices in the deferred list if it is not empty.
+     * Check that at least one device is initialized at each loop, otherwise
+     * we may get an infinite loop. Also stop processing if we got an error
+     * other than -EAGAIN.
+     */
+    while ( !list_empty(&deferred_probe_list) && num_iommus )
+    {
+        num_iommus = 0;
+
+        list_for_each_entry_safe ( np, tmp, &deferred_probe_list, domain_list )
+        {
+            rc = device_init(np, DEVICE_IOMMU, NULL);
+            if ( !rc )
+            {
+                num_iommus++;
+
+                /* Remove initialized device from the deferred list. */
+                list_del_init(&np->domain_list);
+            }
+            else if ( rc != -EAGAIN )
+                return rc;
+        }
+    }
+
+    return rc;
 }
 
 void __hwdom_init arch_iommu_check_autotranslated_hwdom(struct domain *d)
diff --git a/xen/include/asm-arm/device.h b/xen/include/asm-arm/device.h
index 63a0f36..ee1c3bc 100644
--- a/xen/include/asm-arm/device.h
+++ b/xen/include/asm-arm/device.h
@@ -44,7 +44,11 @@ struct device_desc {
     enum device_class class;
     /* List of devices supported by this driver */
     const struct dt_device_match *dt_match;
-    /* Device initialization */
+    /*
+     * Device initialization.
+     *
+     * -EAGAIN is used to indicate that device probing is deferred.
+     */
     int (*init)(struct dt_device_node *dev, const void *data);
 };
 
diff --git a/xen/include/xen/device_tree.h b/xen/include/xen/device_tree.h
index 9a7a8f2..3702e9b 100644
--- a/xen/include/xen/device_tree.h
+++ b/xen/include/xen/device_tree.h
@@ -92,6 +92,13 @@ struct dt_device_node {
 
     /* IOMMU specific fields */
     bool is_protected;
+    /*
+     * The main purpose of this list node is to link the structure in the list
+     * of devices assigned to domain.
+     *
+     * Boot code (iommu_hardware_setup) re-uses this list to link the structure
+     * in the list of devices for which driver requested deferred probing.
+     */
     struct list_head domain_list;
 
     struct device dev;
-- 
2.7.4


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* [Xen-devel] [PATCH V3 3/8] xen/common: Introduce _xrealloc function
  2019-08-20 18:09 [Xen-devel] [PATCH V3 0/8] iommu/arm: Add Renesas IPMMU-VMSA support + Linux's iommu_fwspec Oleksandr Tyshchenko
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 1/8] iommu/arm: Add iommu_helpers.c file to keep common for IOMMUs stuff Oleksandr Tyshchenko
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 2/8] iommu/arm: Add ability to handle deferred probing request Oleksandr Tyshchenko
@ 2019-08-20 18:09 ` Oleksandr Tyshchenko
  2019-08-21  8:09   ` Paul Durrant
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 4/8] xen/common: Introduce xrealloc_flex_struct() helper macros Oleksandr Tyshchenko
                   ` (4 subsequent siblings)
  7 siblings, 1 reply; 41+ messages in thread
From: Oleksandr Tyshchenko @ 2019-08-20 18:09 UTC (permalink / raw)
  To: xen-devel
  Cc: sstabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap,
	Andrew Cooper, Ian Jackson, Tim Deegan, Oleksandr Tyshchenko,
	julien.grall, Jan Beulich, Volodymyr_Babchuk

From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>

This patch introduces type-unsafe function which besides
re-allocation handles the following corner cases:
1. if requested size is zero, it will behave like xfree
2. if incoming pointer is not valid (NULL or ZERO_BLOCK_PTR),
   it will behave like xmalloc

If both pointer and size are valid the function will re-allocate and
copy only if requested size doesn't fit in already allocated space.

Subsequent patch will add type-safe helper macros.

Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
CC: Andrew Cooper <andrew.cooper3@citrix.com>
CC: George Dunlap <George.Dunlap@eu.citrix.com>
CC: Ian Jackson <ian.jackson@eu.citrix.com>
CC: Jan Beulich <jbeulich@suse.com>
CC: Julien Grall <julien.grall@arm.com>
CC: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
CC: Stefano Stabellini <sstabellini@kernel.org>
CC: Tim Deegan <tim@xen.org>
CC: Wei Liu <wl@xen.org>

---
Changes since RFC:
   - behave like xmalloc if incoming pointer is ZERO_BLOCK_PTR or NULL
   - return ZERO_BLOCK_PTR after xfree if requested size is zero
   - add patch description
   - use allocator internals to recognize current size of
     the incoming pointer
   - do not re-allocate and copy if requested size fits in already
     allocated space

   ...

   Original patch was initially posted by Sameer Goel:
   https://lists.xen.org/archives/html/xen-devel/2017-06/msg00858.html

   This could be considered as another attempt to add it:
   https://www.mail-archive.com/kexec@lists.infradead.org/msg21335.html

   [As it was previously discussed with Julien in IRC]

   The reason for this patch to be an RFC is that patch itself is not
   completely correct and I don't fully understand what/how should
   be done for this patch to be accepted. Or whether community even
   wants this to go in. So, to avoid bike shedding, the first target is
   to collect feedback.

   For everyone who wants more details why this is needed and
   where used, please see next patch of this thread:
   "iommu/arm: Add lightweight iommu_fwspec support"

   In a nutshell, the upcoming "iommu_fwspec" support on ARM
   is going to use xrealloc to expand an array for device IDs.
   We really want to have "iommu_fwspec" support which will give us
   a generic abstract way to add new device to the IOMMU based on
   the generic IOMMU DT binding.
---
 xen/common/xmalloc_tlsf.c | 45 +++++++++++++++++++++++++++++++++++++++++++++
 xen/include/xen/xmalloc.h |  1 +
 2 files changed, 46 insertions(+)

diff --git a/xen/common/xmalloc_tlsf.c b/xen/common/xmalloc_tlsf.c
index e98ad65..eecae2e 100644
--- a/xen/common/xmalloc_tlsf.c
+++ b/xen/common/xmalloc_tlsf.c
@@ -598,6 +598,51 @@ void *_xzalloc(unsigned long size, unsigned long align)
     return p ? memset(p, 0, size) : p;
 }
 
+void *_xrealloc(void *ptr, unsigned long size, unsigned long align)
+{
+    unsigned long curr_size, tmp_size;
+    void *p;
+
+    if ( !size )
+    {
+        xfree(ptr);
+        return ZERO_BLOCK_PTR;
+    }
+
+    if ( ptr == NULL || ptr == ZERO_BLOCK_PTR )
+        return _xmalloc(size, align);
+
+    if ( !((unsigned long)ptr & (PAGE_SIZE - 1)) )
+        curr_size = PFN_ORDER(virt_to_page(ptr)) << PAGE_SHIFT;
+    else
+    {
+        struct bhdr *b;
+        b = (struct bhdr *)((char *)ptr - BHDR_OVERHEAD);
+        curr_size = b->size & BLOCK_SIZE_MASK;
+    }
+
+    ASSERT((align & (align - 1)) == 0);
+    if ( align < MEM_ALIGN )
+        align = MEM_ALIGN;
+    tmp_size = size + align - MEM_ALIGN;
+
+    if ( tmp_size < PAGE_SIZE )
+        tmp_size = ( tmp_size < MIN_BLOCK_SIZE ) ? MIN_BLOCK_SIZE :
+            ROUNDUP_SIZE(tmp_size);
+
+    if ( tmp_size <= curr_size ) /* fits in current block */
+        return ptr;
+
+    p = _xmalloc(size, align);
+    if ( p )
+    {
+        memcpy(p, ptr, min(curr_size, size));
+        xfree(ptr);
+    }
+
+    return p;
+}
+
 void xfree(void *p)
 {
     struct bhdr *b;
diff --git a/xen/include/xen/xmalloc.h b/xen/include/xen/xmalloc.h
index f075d2d..831152f 100644
--- a/xen/include/xen/xmalloc.h
+++ b/xen/include/xen/xmalloc.h
@@ -51,6 +51,7 @@ extern void xfree(void *);
 /* Underlying functions */
 extern void *_xmalloc(unsigned long size, unsigned long align);
 extern void *_xzalloc(unsigned long size, unsigned long align);
+extern void *_xrealloc(void *ptr, unsigned long size, unsigned long align);
 
 static inline void *_xmalloc_array(
     unsigned long size, unsigned long align, unsigned long num)
-- 
2.7.4


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* [Xen-devel] [PATCH V3 4/8] xen/common: Introduce xrealloc_flex_struct() helper macros
  2019-08-20 18:09 [Xen-devel] [PATCH V3 0/8] iommu/arm: Add Renesas IPMMU-VMSA support + Linux's iommu_fwspec Oleksandr Tyshchenko
                   ` (2 preceding siblings ...)
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 3/8] xen/common: Introduce _xrealloc function Oleksandr Tyshchenko
@ 2019-08-20 18:09 ` Oleksandr Tyshchenko
  2019-08-27 13:28   ` Jan Beulich
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 5/8] iommu/arm: Add lightweight iommu_fwspec support Oleksandr Tyshchenko
                   ` (3 subsequent siblings)
  7 siblings, 1 reply; 41+ messages in thread
From: Oleksandr Tyshchenko @ 2019-08-20 18:09 UTC (permalink / raw)
  To: xen-devel
  Cc: sstabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap,
	Andrew Cooper, Ian Jackson, Tim Deegan, Oleksandr Tyshchenko,
	julien.grall, Jan Beulich, Volodymyr_Babchuk

From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>

This patch introduces type-safe helper macros to re-allocate space
for a structure with a flexible array of typed objects.

For example, if we need to re-size an array with a single element:

   struct arrlen
   {
      size_t len;
      int data[1];
   };

We can use the proposed macros in the following way:

   new_ptr = realloc_flex_struct(old_ptr, struct arrlen, data, num_elem);

Subsequent patch will use this macros.

Also, while here, introduce xmalloc_flex_struct() to allocate space
for a structure with a flexible array of typed objects.

Suggested-by: Volodymyr Babchuk <Volodymyr_Babchuk@epam.com>
Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
CC: Andrew Cooper <andrew.cooper3@citrix.com>
CC: George Dunlap <George.Dunlap@eu.citrix.com>
CC: Ian Jackson <ian.jackson@eu.citrix.com>
CC: Jan Beulich <jbeulich@suse.com>
CC: Julien Grall <julien.grall@arm.com>
CC: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
CC: Stefano Stabellini <sstabellini@kernel.org>
CC: Tim Deegan <tim@xen.org>
CC: Wei Liu <wl@xen.org>
---
 xen/include/xen/xmalloc.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/xen/include/xen/xmalloc.h b/xen/include/xen/xmalloc.h
index 831152f..2eb88a8 100644
--- a/xen/include/xen/xmalloc.h
+++ b/xen/include/xen/xmalloc.h
@@ -35,6 +35,18 @@
 #define xzalloc_array(_type, _num) \
     ((_type *)_xzalloc_array(sizeof(_type), __alignof__(_type), _num))
 
+/* Re-allocate space for a structure with a flexible array of typed objects. */
+#define xrealloc_flex_struct(_ptr, _type, _field, _len) ({                   \
+    /* type checking: make sure that incoming pointer is of correct type */  \
+    (void)((typeof(_ptr)) 0 == (_type *) 0);                                 \
+    ((_type *)_xrealloc(_ptr, offsetof(_type, _field[_len]),                 \
+                        __alignof__(_type)));                                \
+})
+
+/* Allocate space for a structure with a flexible array of typed objects. */
+#define xmalloc_flex_struct(_type, _field, _len) \
+    ((_type *)_xmalloc(offsetof(_type, _field[_len]), __alignof__(_type)))
+
 /* Allocate untyped storage. */
 #define xmalloc_bytes(_bytes) _xmalloc(_bytes, SMP_CACHE_BYTES)
 #define xzalloc_bytes(_bytes) _xzalloc(_bytes, SMP_CACHE_BYTES)
-- 
2.7.4


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* [Xen-devel] [PATCH V3 5/8] iommu/arm: Add lightweight iommu_fwspec support
  2019-08-20 18:09 [Xen-devel] [PATCH V3 0/8] iommu/arm: Add Renesas IPMMU-VMSA support + Linux's iommu_fwspec Oleksandr Tyshchenko
                   ` (3 preceding siblings ...)
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 4/8] xen/common: Introduce xrealloc_flex_struct() helper macros Oleksandr Tyshchenko
@ 2019-08-20 18:09 ` Oleksandr Tyshchenko
  2019-09-09 14:36   ` Julien Grall
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 6/8] iommu: Add of_xlate callback Oleksandr Tyshchenko
                   ` (2 subsequent siblings)
  7 siblings, 1 reply; 41+ messages in thread
From: Oleksandr Tyshchenko @ 2019-08-20 18:09 UTC (permalink / raw)
  To: xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini, Volodymyr_Babchuk

From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>

We need to have some abstract way to add new device to the IOMMU
based on the generic IOMMU DT bindings [1] which can be used for
both DT (right now) and ACPI (in future).

For that reason we can borrow the idea used in Linux these days
called "iommu_fwspec". Having this in, it will be possible
to configure IOMMU master interfaces of the device (device IDs)
from a single common place and avoid keeping almost identical look-up
implementations in each IOMMU driver.

There is no need to port the whole implementation of "iommu_fwspec"
to Xen, we could, probably, end up with a much simpler solution,
some "stripped down" version which fits our requirements.

So, this patch adds the following:
1. A common structure "iommu_fwspec" to hold the the per-device
   firmware data
2. New member "iommu_fwspec" of struct device
3. Functions/helpers to deal with "dev->iommu_fwspec"

It should be noted that in comparing with original "iommu_fwspec"
Xen's variant doesn't contain some fields, which are not really
needed at the moment (ops, flag) and "iommu_fwnode" field was replaced
by "iommu_dev" to avoid porting a lot of code (to support "fwnode_handle")
with little benefit.

Subsequent patches will use of that support.

[1] https://www.kernel.org/doc/Documentation/devicetree/bindings/iommu/iommu.txt

Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
CC: Julien Grall <julien.grall@arm.com>

---
Changes V2 -> V3:
    - added Copyright from Linux
    - ordered the headers alphabetically
    - removed check for not a NULL before calling xfree()
    - used unsigned for variables which can't be negative
    - removed #include <asm/iommu_fwspec.h> from iommu.h
    - added check to iommu_fwspec_init() to not allow overriding
    - clarified comments in code
    - modified iommu_fwspec_add_ids() to use type-safe xrealloc_flex_struct()
---
 xen/drivers/passthrough/arm/Makefile       |  2 +-
 xen/drivers/passthrough/arm/iommu_fwspec.c | 94 ++++++++++++++++++++++++++++++
 xen/include/asm-arm/device.h               |  1 +
 xen/include/asm-arm/iommu_fwspec.h         | 68 +++++++++++++++++++++
 4 files changed, 164 insertions(+), 1 deletion(-)
 create mode 100644 xen/drivers/passthrough/arm/iommu_fwspec.c
 create mode 100644 xen/include/asm-arm/iommu_fwspec.h

diff --git a/xen/drivers/passthrough/arm/Makefile b/xen/drivers/passthrough/arm/Makefile
index 4abb87a..5fbad45 100644
--- a/xen/drivers/passthrough/arm/Makefile
+++ b/xen/drivers/passthrough/arm/Makefile
@@ -1,2 +1,2 @@
-obj-y += iommu.o iommu_helpers.o
+obj-y += iommu.o iommu_helpers.o iommu_fwspec.o
 obj-$(CONFIG_ARM_SMMU) += smmu.o
diff --git a/xen/drivers/passthrough/arm/iommu_fwspec.c b/xen/drivers/passthrough/arm/iommu_fwspec.c
new file mode 100644
index 0000000..12b8bae
--- /dev/null
+++ b/xen/drivers/passthrough/arm/iommu_fwspec.c
@@ -0,0 +1,94 @@
+/*
+ * xen/drivers/passthrough/arm/iommu_fwspec.c
+ *
+ * Contains functions to maintain per-device firmware data
+ *
+ * Based on Linux's iommu_fwspec support you can find at:
+ *    drivers/iommu/iommu.c
+ *
+ * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
+ *
+ * Copyright (C) 2019 EPAM Systems Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms and conditions 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <xen/iommu.h>
+#include <xen/lib.h>
+
+#include <asm/device.h>
+#include <asm/iommu_fwspec.h>
+
+int iommu_fwspec_init(struct device *dev, struct device *iommu_dev)
+{
+    struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
+
+    if ( fwspec )
+    {
+        /* We expect the device to be protected by only one IOMMU. */
+        if ( fwspec->iommu_dev != iommu_dev )
+            return -EINVAL;
+
+        return 0;
+    }
+
+    fwspec = xzalloc(struct iommu_fwspec);
+    if ( !fwspec )
+        return -ENOMEM;
+
+    fwspec->iommu_dev = iommu_dev;
+    dev_iommu_fwspec_set(dev, fwspec);
+
+    return 0;
+}
+
+void iommu_fwspec_free(struct device *dev)
+{
+    struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
+
+    xfree(fwspec);
+    dev_iommu_fwspec_set(dev, NULL);
+}
+
+int iommu_fwspec_add_ids(struct device *dev, uint32_t *ids,
+                         unsigned int num_ids)
+{
+    struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
+    unsigned int i;
+
+    if ( !fwspec )
+        return -EINVAL;
+
+    fwspec = xrealloc_flex_struct(fwspec, struct iommu_fwspec, ids,
+                                  fwspec->num_ids + num_ids);
+    if ( !fwspec )
+        return -ENOMEM;
+
+    dev_iommu_fwspec_set(dev, fwspec);
+
+    for ( i = 0; i < num_ids; i++ )
+        fwspec->ids[fwspec->num_ids + i] = ids[i];
+
+    fwspec->num_ids += num_ids;
+
+    return 0;
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "BSD"
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
diff --git a/xen/include/asm-arm/device.h b/xen/include/asm-arm/device.h
index ee1c3bc..ee7cff2 100644
--- a/xen/include/asm-arm/device.h
+++ b/xen/include/asm-arm/device.h
@@ -18,6 +18,7 @@ struct device
     struct dt_device_node *of_node; /* Used by drivers imported from Linux */
 #endif
     struct dev_archdata archdata;
+    struct iommu_fwspec *iommu_fwspec; /* per-device IOMMU instance data */
 };
 
 typedef struct device device_t;
diff --git a/xen/include/asm-arm/iommu_fwspec.h b/xen/include/asm-arm/iommu_fwspec.h
new file mode 100644
index 0000000..8ce4da1
--- /dev/null
+++ b/xen/include/asm-arm/iommu_fwspec.h
@@ -0,0 +1,68 @@
+/*
+ * xen/include/asm-arm/iommu_fwspec.h
+ *
+ * Contains a common structure to hold the per-device firmware data and
+ * declaration of functions used to maintain that data
+ *
+ * Based on Linux's iommu_fwspec support you can find at:
+ *    include/linux/iommu.h
+ *
+ * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
+ *
+ * Copyright (C) 2019 EPAM Systems Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms and conditions 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __ARCH_ARM_IOMMU_FWSPEC_H__
+#define __ARCH_ARM_IOMMU_FWSPEC_H__
+
+/* per-device IOMMU instance data */
+struct iommu_fwspec {
+    /* this device's IOMMU */
+    struct device *iommu_dev;
+    /* IOMMU driver private data for this device */
+    void *iommu_priv;
+    /* number of associated device IDs */
+    unsigned int num_ids;
+    /* IDs which this device may present to the IOMMU */
+    uint32_t ids[1];
+};
+
+int iommu_fwspec_init(struct device *dev, struct device *iommu_dev);
+void iommu_fwspec_free(struct device *dev);
+int iommu_fwspec_add_ids(struct device *dev, uint32_t *ids,
+                         unsigned int num_ids);
+
+static inline struct iommu_fwspec *dev_iommu_fwspec_get(struct device *dev)
+{
+    return dev->iommu_fwspec;
+}
+
+static inline void dev_iommu_fwspec_set(struct device *dev,
+                                        struct iommu_fwspec *fwspec)
+{
+    dev->iommu_fwspec = fwspec;
+}
+
+#endif /* __ARCH_ARM_IOMMU_FWSPEC_H__ */
+
+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "BSD"
+ * c-basic-offset: 4
+ * tab-width: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
-- 
2.7.4


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* [Xen-devel] [PATCH V3 6/8] iommu: Add of_xlate callback
  2019-08-20 18:09 [Xen-devel] [PATCH V3 0/8] iommu/arm: Add Renesas IPMMU-VMSA support + Linux's iommu_fwspec Oleksandr Tyshchenko
                   ` (4 preceding siblings ...)
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 5/8] iommu/arm: Add lightweight iommu_fwspec support Oleksandr Tyshchenko
@ 2019-08-20 18:09 ` Oleksandr Tyshchenko
  2019-08-27 13:30   ` Jan Beulich
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 7/8] iommu/arm: Introduce iommu_add_dt_device API Oleksandr Tyshchenko
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support Oleksandr Tyshchenko
  7 siblings, 1 reply; 41+ messages in thread
From: Oleksandr Tyshchenko @ 2019-08-20 18:09 UTC (permalink / raw)
  To: xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini,
	Volodymyr_Babchuk, Jan Beulich

From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>

According to the generic IOMMU DT bindings [1] the context of
required properties for IOMMU device/master node (#iommu-cells, iommus)
depends on many factors and is really driver depended thing.

We need some way to provide the driver with DT IOMMU specifier which
describes the IOMMU master interfaces of that device (device IDs, etc)
to let it decide how to interpret them. For that reason we can borrow
Linux's "of_xlate" callback.

All IOMMU drivers which support generic IOMMU DT bindings should use
this callback.

Subsequent patches will use of that support.

[1] https://www.kernel.org/doc/Documentation/devicetree/bindings/iommu/iommu.txt

Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
CC: Julien Grall <julien.grall@arm.com>
CC: Jan Beulich <jbeulich@suse.com>
---
 xen/include/xen/iommu.h | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/xen/include/xen/iommu.h b/xen/include/xen/iommu.h
index 48f8748..79b86ac 100644
--- a/xen/include/xen/iommu.h
+++ b/xen/include/xen/iommu.h
@@ -240,6 +240,16 @@ struct iommu_ops {
     int __must_check (*iotlb_flush_all)(struct domain *d);
     int (*get_reserved_device_memory)(iommu_grdm_t *, void *);
     void (*dump_p2m_table)(struct domain *d);
+
+#ifdef CONFIG_HAS_DEVICE_TREE
+    /*
+     * All IOMMU drivers which support generic IOMMU DT bindings should use
+     * this callback. This is a way for the framework to provide the driver
+     * with DT IOMMU specifier which describes the IOMMU master interfaces of
+     * that device (device IDs, etc).
+     */
+    int (*of_xlate)(device_t *dev, struct dt_phandle_args *args);
+#endif
 };
 
 #include <asm/iommu.h>
-- 
2.7.4


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* [Xen-devel] [PATCH V3 7/8] iommu/arm: Introduce iommu_add_dt_device API
  2019-08-20 18:09 [Xen-devel] [PATCH V3 0/8] iommu/arm: Add Renesas IPMMU-VMSA support + Linux's iommu_fwspec Oleksandr Tyshchenko
                   ` (5 preceding siblings ...)
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 6/8] iommu: Add of_xlate callback Oleksandr Tyshchenko
@ 2019-08-20 18:09 ` Oleksandr Tyshchenko
  2019-09-09 15:04   ` Julien Grall
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support Oleksandr Tyshchenko
  7 siblings, 1 reply; 41+ messages in thread
From: Oleksandr Tyshchenko @ 2019-08-20 18:09 UTC (permalink / raw)
  To: xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini, Volodymyr_Babchuk

From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>

This patch adds new iommu_add_dt_device API for adding DT device
to the IOMMU using generic IOMMU DT bindings [1] and previously
added "iommu_fwspec" support and "add_device/of_xlate" callbacks.

New function does the following:
- Parse the DT bindings according to the specification
- Provide DT IOMMU specifier which describes the IOMMU master
  interfaces of that device (device IDs, etc) to the driver
- Add master device to the IOMMU if latter is present and available

The additional benefit here is to avoid to go through the whole DT
multiple times in IOMMU driver trying to locate master devices which
belong to each IOMMU device being probed.

[1] https://www.kernel.org/doc/Documentation/devicetree/bindings/iommu/iommu.txt

Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
CC: Julien Grall <julien.grall@arm.com>

---
Changes V2 -> V3:
    - clarified patch description
    - clarified comments in code
    - modified to provide DT IOMMU specifier to the driver
      using "of_xlate" callback
    - documented function usage
    - modified to return an error if ops is not present/implemented,
    - added ability to return a possitive value to indicate
      that device doesn't need to be protected
    - removed check for the "iommu" property presence
      in the common code
    - included <asm/iommu_fwspec.h> directly
---
 xen/arch/arm/domain_build.c         | 11 ++++++++
 xen/drivers/passthrough/arm/iommu.c | 55 +++++++++++++++++++++++++++++++++++++
 xen/include/asm-arm/iommu.h         | 11 ++++++++
 3 files changed, 77 insertions(+)

diff --git a/xen/arch/arm/domain_build.c b/xen/arch/arm/domain_build.c
index e79d4e2..159ea6a 100644
--- a/xen/arch/arm/domain_build.c
+++ b/xen/arch/arm/domain_build.c
@@ -1240,6 +1240,7 @@ static int __init map_device_children(struct domain *d,
 
 /*
  * For a given device node:
+ *  - Try to call iommu_add_dt_device to protect the device by an IOMMU
  *  - Give permission to the guest to manage IRQ and MMIO range
  *  - Retrieve the IRQ configuration (i.e edge/level) from device tree
  * When the device is not marked for guest passthrough:
@@ -1257,6 +1258,16 @@ static int __init handle_device(struct domain *d, struct dt_device_node *dev,
     u64 addr, size;
     bool need_mapping = !dt_device_for_passthrough(dev);
 
+    dt_dprintk("%s add to iommu\n", dt_node_full_name(dev));
+
+    res = iommu_add_dt_device(dev);
+    if ( res < 0 )
+    {
+        printk(XENLOG_ERR "Failed to add %s to the IOMMU\n",
+               dt_node_full_name(dev));
+        return res;
+    }
+
     nirq = dt_number_of_irq(dev);
     naddr = dt_number_of_address(dev);
 
diff --git a/xen/drivers/passthrough/arm/iommu.c b/xen/drivers/passthrough/arm/iommu.c
index 72a30e0..47e4bc6 100644
--- a/xen/drivers/passthrough/arm/iommu.c
+++ b/xen/drivers/passthrough/arm/iommu.c
@@ -20,6 +20,7 @@
 #include <xen/lib.h>
 
 #include <asm/device.h>
+#include <asm/iommu_fwspec.h>
 
 /*
  * Deferred probe list is used to keep track of devices for which driver
@@ -139,3 +140,57 @@ int arch_iommu_populate_page_table(struct domain *d)
 void __hwdom_init arch_iommu_hwdom_init(struct domain *d)
 {
 }
+
+int __init iommu_add_dt_device(struct dt_device_node *np)
+{
+    const struct iommu_ops *ops = iommu_get_ops();
+    struct dt_phandle_args iommu_spec;
+    struct device *dev = dt_to_dev(np);
+    int rc = 1, index = 0;
+
+    if ( !iommu_enabled )
+        return 1;
+
+    if ( !ops || !ops->add_device || !ops->of_xlate )
+        return -EINVAL;
+
+    if ( dev_iommu_fwspec_get(dev) )
+        return -EEXIST;
+
+    /* According Documentation/devicetree/bindings/iommu/iommu.txt from Linux */
+    while ( !dt_parse_phandle_with_args(np, "iommus", "#iommu-cells",
+                                        index, &iommu_spec) )
+    {
+        if ( !dt_device_is_available(iommu_spec.np) )
+            break;
+
+        rc = iommu_fwspec_init(dev, &iommu_spec.np->dev);
+        if ( rc )
+            break;
+
+        /*
+         * Provide DT IOMMU specifier which describes the IOMMU master
+         * interfaces of that device (device IDs, etc) to the driver.
+         * The driver's responsibility is to decide how to interpret them.
+         * It should also initialize/verify that device.
+         */
+        rc = ops->of_xlate(dev, &iommu_spec);
+        if ( rc )
+            break;
+
+        index++;
+    }
+
+    /*
+     * Add master device to the IOMMU if latter is present and available.
+     * The driver's responsibility is to check whether that device
+     * was initialized/verified before and mark that device as protected.
+     */
+    if ( !rc )
+        rc = ops->add_device(0, dev);
+
+    if ( rc < 0 )
+        iommu_fwspec_free(dev);
+
+    return rc;
+}
diff --git a/xen/include/asm-arm/iommu.h b/xen/include/asm-arm/iommu.h
index 20d865e..e75359c 100644
--- a/xen/include/asm-arm/iommu.h
+++ b/xen/include/asm-arm/iommu.h
@@ -26,6 +26,17 @@ struct arch_iommu
 const struct iommu_ops *iommu_get_ops(void);
 void iommu_set_ops(const struct iommu_ops *ops);
 
+/*
+ * Helper to add master device to the IOMMU using generic IOMMU DT bindings.
+ *
+ * Return values:
+ *  0 : device is protected by an IOMMU
+ * <0 : device is not protected by an IOMMU, but must be (error condition)
+ * >0 : device doesn't need to be protected by an IOMMU
+ *      (IOMMU is not enabled/present or device is not connected to it).
+ */
+int iommu_add_dt_device(struct dt_device_node *np);
+
 /* mapping helpers */
 int __must_check arm_iommu_map_page(struct domain *d, dfn_t dfn, mfn_t mfn,
                                     unsigned int flags,
-- 
2.7.4


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support
  2019-08-20 18:09 [Xen-devel] [PATCH V3 0/8] iommu/arm: Add Renesas IPMMU-VMSA support + Linux's iommu_fwspec Oleksandr Tyshchenko
                   ` (6 preceding siblings ...)
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 7/8] iommu/arm: Introduce iommu_add_dt_device API Oleksandr Tyshchenko
@ 2019-08-20 18:09 ` Oleksandr Tyshchenko
  2019-08-29  8:37   ` Yoshihiro Shimoda
                     ` (2 more replies)
  7 siblings, 3 replies; 41+ messages in thread
From: Oleksandr Tyshchenko @ 2019-08-20 18:09 UTC (permalink / raw)
  To: xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini,
	Volodymyr_Babchuk, Yoshihiro Shimoda

From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>

The IPMMU-VMSA is VMSA-compatible I/O Memory Management Unit (IOMMU)
which provides address translation and access protection functionalities
to processing units and interconnect networks.

Please note, current driver is supposed to work only with newest
Gen3 SoCs revisions which IPMMU hardware supports stage 2 translation
table format and is able to use CPU's P2M table as is if one is
3-level page table (up to 40 bit IPA).

The major differences compare to the Linux driver are:

1. Stage 1/Stage 2 translation. Linux driver supports Stage 1
translation only (with Stage 1 translation table format). It manages
page table by itself. But Xen driver supports Stage 2 translation
(with Stage 2 translation table format) to be able to share the P2M
with the CPU. Stage 1 translation is always bypassed in Xen driver.

So, Xen driver is supposed to be used with newest R-Car Gen3 SoC revisions
only (H3 ES3.0, M3-W+, etc.) which IPMMU H/W supports stage 2 translation
table format.

2. AArch64 support. Linux driver uses VMSAv8-32 mode, while Xen driver
enables Armv8 VMSAv8-64 mode to cover up to 40 bit input address.

3. Context bank (sets of page table) usage. In Xen, each context bank is
mapped to one Xen domain. So, all devices being pass throughed to the
same Xen domain share the same context bank.

4. IPMMU device tracking. In Xen, all IOMMU devices are managed
by single driver instance. So, driver uses global list to keep track
of registered IPMMU devices.

Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
CC: Julien Grall <julien.grall@arm.com>
CC: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>

---
Changes V2 -> V3:
    - added Copyright from Linux
    - included <xen/iommu.h> and <asm/iommu_fwspec.h> directly
    - removed pointless spin_lock from ipmmu_iommu_domain_teardown()
    - changed "Gen3" to "R-Car Gen3", "M3 ES3.0" to "M3-W+"
    - changed RCAR_PRODUCT_M3 to RCAR_PRODUCT_M3W
    - clarified IMTTBCR_TSZ1_MASK
    - removed TLB flush from ipmmu_domain_irq() until clarified the purpose
    - returned -ENODEV in ipmmu_init() if P2M sharing or P2M IPA size
      is not supported to show that IOMMU device is not usable in Xen
    - implemented new callback "of_xlate" to parse DT IOMMU specifier
      and add device IDs to "iommu_fwspec"
    - reworked "add_device" callback
    - updated patch description

Changes V1 -> V2:
    - rewrited driver to use iommu_fwspec
    - removed DT parsing code for micro-TLBs
    - removed struct ipmmu_vmsa_master_cfg, dev_archdata macro
    - added ipmmu_find_mmu_by_dev(), various helpers to access
      fwspec->iommu_priv
    - implemented new callback "add_device" to add master device to IPMMU
    - removed ipmmu_protect_masters()
    - removed code to locate Root device in the first place,
      used EAGAIN to request deferred probing
    - used printk_once for the system wide error messages in ipmmu_init()
      which don't need to be shown for every device being probed
    - removed map_page/unmap_page implementation, reused them
      from iommu_helpers.c
    - used %pd for printing domaid id
    - performed various cosmetic fixes
    - changed u32 -> uint32_t, u64 -> uint64_t,
      unsigned int -> uint32_t where needed
    - clarified TODOs
    - clafiried supported SoC versions in config IPMMU_VMSA,
      set default to "n"
    - updated comments in code, provided more accurate description,
      added new comments where needed
    - updated patch description by providing differences between
      Linux/Xen implementations
    - removed fields for cache snoop transaction when configuring IMTTBCR
      (update from Renesas BSP)
---
 xen/arch/arm/platforms/Kconfig           |    1 +
 xen/drivers/passthrough/Kconfig          |   13 +
 xen/drivers/passthrough/arm/Makefile     |    1 +
 xen/drivers/passthrough/arm/ipmmu-vmsa.c | 1359 ++++++++++++++++++++++++++++++
 4 files changed, 1374 insertions(+)
 create mode 100644 xen/drivers/passthrough/arm/ipmmu-vmsa.c

diff --git a/xen/arch/arm/platforms/Kconfig b/xen/arch/arm/platforms/Kconfig
index bc0e9cd..c93a6b2 100644
--- a/xen/arch/arm/platforms/Kconfig
+++ b/xen/arch/arm/platforms/Kconfig
@@ -25,6 +25,7 @@ config RCAR3
 	bool "Renesas RCar3 support"
 	depends on ARM_64
 	select HAS_SCIF
+	select IPMMU_VMSA
 	---help---
 	Enable all the required drivers for Renesas RCar3
 
diff --git a/xen/drivers/passthrough/Kconfig b/xen/drivers/passthrough/Kconfig
index a3c0649..47eadb4 100644
--- a/xen/drivers/passthrough/Kconfig
+++ b/xen/drivers/passthrough/Kconfig
@@ -12,4 +12,17 @@ config ARM_SMMU
 
 	  Say Y here if your SoC includes an IOMMU device implementing the
 	  ARM SMMU architecture.
+
+config IPMMU_VMSA
+	bool "Renesas IPMMU-VMSA found in R-Car Gen3 SoCs"
+	default n
+	depends on ARM_64
+	---help---
+	  Support for implementations of the Renesas IPMMU-VMSA found
+	  in R-Car Gen3 SoCs.
+
+	  Say Y here if you are using newest R-Car Gen3 SoCs revisions
+	  (H3 ES3.0, M3-W+, etc) which IPMMU hardware supports stage 2
+	  translation table format and is able to use CPU's P2M table as is.
+
 endif
diff --git a/xen/drivers/passthrough/arm/Makefile b/xen/drivers/passthrough/arm/Makefile
index 5fbad45..fcd918e 100644
--- a/xen/drivers/passthrough/arm/Makefile
+++ b/xen/drivers/passthrough/arm/Makefile
@@ -1,2 +1,3 @@
 obj-y += iommu.o iommu_helpers.o iommu_fwspec.o
 obj-$(CONFIG_ARM_SMMU) += smmu.o
+obj-$(CONFIG_IPMMU_VMSA) += ipmmu-vmsa.o
diff --git a/xen/drivers/passthrough/arm/ipmmu-vmsa.c b/xen/drivers/passthrough/arm/ipmmu-vmsa.c
new file mode 100644
index 0000000..ec543c3
--- /dev/null
+++ b/xen/drivers/passthrough/arm/ipmmu-vmsa.c
@@ -0,0 +1,1359 @@
+/*
+ * xen/drivers/passthrough/arm/ipmmu-vmsa.c
+ *
+ * Driver for the Renesas IPMMU-VMSA found in R-Car Gen3 SoCs.
+ *
+ * The IPMMU-VMSA is VMSA-compatible I/O Memory Management Unit (IOMMU)
+ * which provides address translation and access protection functionalities
+ * to processing units and interconnect networks.
+ *
+ * Please note, current driver is supposed to work only with newest
+ * R-Car Gen3 SoCs revisions which IPMMU hardware supports stage 2 translation
+ * table format and is able to use CPU's P2M table as is.
+ *
+ * Based on Linux's IPMMU-VMSA driver from Renesas BSP:
+ *    drivers/iommu/ipmmu-vmsa.c
+ * you can found at:
+ *    url: git://git.kernel.org/pub/scm/linux/kernel/git/horms/renesas-bsp.git
+ *    branch: v4.14.75-ltsi/rcar-3.9.6
+ *    commit: e206eb5b81a60e64c35fbc3a999b1a0db2b98044
+ * and Xen's SMMU driver:
+ *    xen/drivers/passthrough/arm/smmu.c
+ *
+ * Copyright (C) 2014-2019 Renesas Electronics Corporation
+ *
+ * Copyright (C) 2016-2019 EPAM Systems Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms and conditions 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <xen/delay.h>
+#include <xen/err.h>
+#include <xen/iommu.h>
+#include <xen/irq.h>
+#include <xen/lib.h>
+#include <xen/list.h>
+#include <xen/mm.h>
+#include <xen/sched.h>
+#include <xen/vmap.h>
+
+#include <asm/atomic.h>
+#include <asm/device.h>
+#include <asm/io.h>
+#include <asm/iommu_fwspec.h>
+
+#define dev_name(dev) dt_node_full_name(dev_to_dt(dev))
+
+/* Device logger functions */
+#define dev_print(dev, lvl, fmt, ...)    \
+    printk(lvl "ipmmu: %s: " fmt, dev_name(dev), ## __VA_ARGS__)
+
+#define dev_info(dev, fmt, ...)    \
+    dev_print(dev, XENLOG_INFO, fmt, ## __VA_ARGS__)
+#define dev_warn(dev, fmt, ...)    \
+    dev_print(dev, XENLOG_WARNING, fmt, ## __VA_ARGS__)
+#define dev_err(dev, fmt, ...)     \
+    dev_print(dev, XENLOG_ERR, fmt, ## __VA_ARGS__)
+#define dev_err_ratelimited(dev, fmt, ...)    \
+    dev_print(dev, XENLOG_ERR, fmt, ## __VA_ARGS__)
+
+/*
+ * R-Car Gen3 SoCs make use of up to 8 IPMMU contexts (sets of page table) and
+ * these can be managed independently. Each context is mapped to one Xen domain.
+ */
+#define IPMMU_CTX_MAX     8
+/* R-Car Gen3 SoCs make use of up to 48 micro-TLBs per IPMMU device. */
+#define IPMMU_UTLB_MAX    48
+
+/* IPMMU context supports IPA size up to 40 bit. */
+#define IPMMU_MAX_P2M_IPA_BITS    40
+
+/*
+ * Xen's domain IPMMU information stored in dom_iommu(d)->arch.priv
+ *
+ * As each context (set of page table) is mapped to one Xen domain,
+ * all associated IPMMU domains use the same context mapped to this Xen domain.
+ * This makes all master devices being attached to the same Xen domain share
+ * the same context (P2M table).
+ */
+struct ipmmu_vmsa_xen_domain {
+    /*
+     * Used to protect everything which belongs to this Xen domain:
+     * device assignment, domain init/destroy, flush ops, etc
+     */
+    spinlock_t lock;
+    /* One or more Cache IPMMU domains associated with this Xen domain */
+    struct list_head cache_domains;
+    /* Root IPMMU domain associated with this Xen domain */
+    struct ipmmu_vmsa_domain *root_domain;
+};
+
+/* Xen master device's IPMMU information stored in fwspec->iommu_priv */
+struct ipmmu_vmsa_xen_device {
+    /* Cache IPMMU domain this master device is logically attached to */
+    struct ipmmu_vmsa_domain *domain;
+    /* Cache IPMMU this master device is physically connected to */
+    struct ipmmu_vmsa_device *mmu;
+};
+
+/* Root/Cache IPMMU device's information */
+struct ipmmu_vmsa_device {
+    struct device *dev;
+    void __iomem *base;
+    struct ipmmu_vmsa_device *root;
+    struct list_head list;
+    unsigned int num_utlbs;
+    unsigned int num_ctx;
+    spinlock_t lock;    /* Protects ctx and domains[] */
+    DECLARE_BITMAP(ctx, IPMMU_CTX_MAX);
+    struct ipmmu_vmsa_domain *domains[IPMMU_CTX_MAX];
+};
+
+/*
+ * Root/Cache IPMMU domain's information
+ *
+ * Root IPMMU device is assigned to Root IPMMU domain while Cache IPMMU device
+ * is assigned to Cache IPMMU domain. Master devices are connected to Cache
+ * IPMMU devices through specific ports called micro-TLBs.
+ * All Cache IPMMU devices, in turn, are connected to Root IPMMU device
+ * which manages IPMMU context.
+ */
+struct ipmmu_vmsa_domain {
+    /*
+     * IPMMU device assigned to this IPMMU domain.
+     * Either Root device which is located at the main memory bus domain or
+     * Cache device which is located at each hierarchy bus domain.
+     */
+    struct ipmmu_vmsa_device *mmu;
+
+    /* Context used for this IPMMU domain */
+    unsigned int context_id;
+
+    /* Xen domain associated with this IPMMU domain */
+    struct domain *d;
+
+    /* The fields below are used for Cache IPMMU domain only */
+
+    /*
+     * Used to keep track of the master devices which are attached to this
+     * IPMMU domain (domain users). Master devices behind the same IPMMU device
+     * are grouped together by putting into the same IPMMU domain.
+     * Only when the refcount reaches 0 this IPMMU domain can be destroyed.
+     */
+    unsigned int refcount;
+    /* Used to link this IPMMU domain for the same Xen domain */
+    struct list_head list;
+};
+
+/* Used to keep track of registered IPMMU devices */
+static LIST_HEAD(ipmmu_devices);
+static DEFINE_SPINLOCK(ipmmu_devices_lock);
+
+#define TLB_LOOP_TIMEOUT    100 /* 100us */
+
+/* Registers Definition */
+#define IM_CTX_SIZE    0x40
+
+#define IMCTR                0x0000
+/*
+ * These fields are implemented in IPMMU-MM only. So, can be set for
+ * Root IPMMU only.
+ */
+#define IMCTR_VA64           (1 << 29)
+#define IMCTR_TRE            (1 << 17)
+#define IMCTR_AFE            (1 << 16)
+#define IMCTR_RTSEL_MASK     (3 << 4)
+#define IMCTR_RTSEL_SHIFT    4
+#define IMCTR_TREN           (1 << 3)
+/*
+ * These fields are common for all IPMMU devices. So, can be set for
+ * Cache IPMMUs as well.
+ */
+#define IMCTR_INTEN          (1 << 2)
+#define IMCTR_FLUSH          (1 << 1)
+#define IMCTR_MMUEN          (1 << 0)
+#define IMCTR_COMMON_MASK    (7 << 0)
+
+#define IMCAAR               0x0004
+
+#define IMTTBCR                        0x0008
+#define IMTTBCR_EAE                    (1 << 31)
+#define IMTTBCR_PMB                    (1 << 30)
+#define IMTTBCR_SH1_NON_SHAREABLE      (0 << 28)
+#define IMTTBCR_SH1_OUTER_SHAREABLE    (2 << 28)
+#define IMTTBCR_SH1_INNER_SHAREABLE    (3 << 28)
+#define IMTTBCR_SH1_MASK               (3 << 28)
+#define IMTTBCR_ORGN1_NC               (0 << 26)
+#define IMTTBCR_ORGN1_WB_WA            (1 << 26)
+#define IMTTBCR_ORGN1_WT               (2 << 26)
+#define IMTTBCR_ORGN1_WB               (3 << 26)
+#define IMTTBCR_ORGN1_MASK             (3 << 26)
+#define IMTTBCR_IRGN1_NC               (0 << 24)
+#define IMTTBCR_IRGN1_WB_WA            (1 << 24)
+#define IMTTBCR_IRGN1_WT               (2 << 24)
+#define IMTTBCR_IRGN1_WB               (3 << 24)
+#define IMTTBCR_IRGN1_MASK             (3 << 24)
+#define IMTTBCR_TSZ1_MASK              (0x1f << 16)
+#define IMTTBCR_TSZ1_SHIFT             16
+#define IMTTBCR_SH0_NON_SHAREABLE      (0 << 12)
+#define IMTTBCR_SH0_OUTER_SHAREABLE    (2 << 12)
+#define IMTTBCR_SH0_INNER_SHAREABLE    (3 << 12)
+#define IMTTBCR_SH0_MASK               (3 << 12)
+#define IMTTBCR_ORGN0_NC               (0 << 10)
+#define IMTTBCR_ORGN0_WB_WA            (1 << 10)
+#define IMTTBCR_ORGN0_WT               (2 << 10)
+#define IMTTBCR_ORGN0_WB               (3 << 10)
+#define IMTTBCR_ORGN0_MASK             (3 << 10)
+#define IMTTBCR_IRGN0_NC               (0 << 8)
+#define IMTTBCR_IRGN0_WB_WA            (1 << 8)
+#define IMTTBCR_IRGN0_WT               (2 << 8)
+#define IMTTBCR_IRGN0_WB               (3 << 8)
+#define IMTTBCR_IRGN0_MASK             (3 << 8)
+#define IMTTBCR_SL0_LVL_2              (0 << 6)
+#define IMTTBCR_SL0_LVL_1              (1 << 6)
+#define IMTTBCR_TSZ0_MASK              (0x1f << 0)
+#define IMTTBCR_TSZ0_SHIFT             0
+
+#define IMTTLBR0              0x0010
+#define IMTTLBR0_TTBR_MASK    (0xfffff << 12)
+#define IMTTUBR0              0x0014
+#define IMTTUBR0_TTBR_MASK    (0xff << 0)
+#define IMTTLBR1              0x0018
+#define IMTTLBR1_TTBR_MASK    (0xfffff << 12)
+#define IMTTUBR1              0x001c
+#define IMTTUBR1_TTBR_MASK    (0xff << 0)
+
+#define IMSTR                          0x0020
+#define IMSTR_ERRLVL_MASK              (3 << 12)
+#define IMSTR_ERRLVL_SHIFT             12
+#define IMSTR_ERRCODE_TLB_FORMAT       (1 << 8)
+#define IMSTR_ERRCODE_ACCESS_PERM      (4 << 8)
+#define IMSTR_ERRCODE_SECURE_ACCESS    (5 << 8)
+#define IMSTR_ERRCODE_MASK             (7 << 8)
+#define IMSTR_MHIT                     (1 << 4)
+#define IMSTR_ABORT                    (1 << 2)
+#define IMSTR_PF                       (1 << 1)
+#define IMSTR_TF                       (1 << 0)
+
+#define IMELAR    0x0030
+#define IMEUAR    0x0034
+
+#define IMUCTR(n)              ((n) < 32 ? IMUCTR0(n) : IMUCTR32(n))
+#define IMUCTR0(n)             (0x0300 + ((n) * 16))
+#define IMUCTR32(n)            (0x0600 + (((n) - 32) * 16))
+#define IMUCTR_FIXADDEN        (1 << 31)
+#define IMUCTR_FIXADD_MASK     (0xff << 16)
+#define IMUCTR_FIXADD_SHIFT    16
+#define IMUCTR_TTSEL_MMU(n)    ((n) << 4)
+#define IMUCTR_TTSEL_PMB       (8 << 4)
+#define IMUCTR_TTSEL_MASK      (15 << 4)
+#define IMUCTR_FLUSH           (1 << 1)
+#define IMUCTR_MMUEN           (1 << 0)
+
+#define IMUASID(n)             ((n) < 32 ? IMUASID0(n) : IMUASID32(n))
+#define IMUASID0(n)            (0x0308 + ((n) * 16))
+#define IMUASID32(n)           (0x0608 + (((n) - 32) * 16))
+#define IMUASID_ASID8_MASK     (0xff << 8)
+#define IMUASID_ASID8_SHIFT    8
+#define IMUASID_ASID0_MASK     (0xff << 0)
+#define IMUASID_ASID0_SHIFT    0
+
+#define IMSAUXCTLR          0x0504
+#define IMSAUXCTLR_S2PTE    (1 << 3)
+
+static struct ipmmu_vmsa_device *to_ipmmu(struct device *dev)
+{
+    struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
+
+    return fwspec && fwspec->iommu_priv ?
+        ((struct ipmmu_vmsa_xen_device *)fwspec->iommu_priv)->mmu : NULL;
+}
+
+static void set_ipmmu(struct device *dev, struct ipmmu_vmsa_device *mmu)
+{
+    struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
+
+    ((struct ipmmu_vmsa_xen_device *)fwspec->iommu_priv)->mmu = mmu;
+}
+
+static struct ipmmu_vmsa_domain *to_domain(struct device *dev)
+{
+    struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
+
+    return fwspec && fwspec->iommu_priv ?
+        ((struct ipmmu_vmsa_xen_device *)fwspec->iommu_priv)->domain : NULL;
+}
+
+static void set_domain(struct device *dev, struct ipmmu_vmsa_domain *domain)
+{
+    struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
+
+    ((struct ipmmu_vmsa_xen_device *)fwspec->iommu_priv)->domain = domain;
+}
+
+static struct ipmmu_vmsa_device *ipmmu_find_mmu_by_dev(struct device *dev)
+{
+    struct ipmmu_vmsa_device *mmu = NULL;
+    bool found = false;
+
+    spin_lock(&ipmmu_devices_lock);
+
+    list_for_each_entry ( mmu, &ipmmu_devices, list )
+    {
+        if ( mmu->dev == dev )
+        {
+            found = true;
+            break;
+        }
+    }
+
+    spin_unlock(&ipmmu_devices_lock);
+
+    return found ? mmu : NULL;
+}
+
+/* Root device handling */
+static bool ipmmu_is_root(struct ipmmu_vmsa_device *mmu)
+{
+    return mmu->root == mmu;
+}
+
+static struct ipmmu_vmsa_device *ipmmu_find_root(void)
+{
+    struct ipmmu_vmsa_device *mmu = NULL;
+    bool found = false;
+
+    spin_lock(&ipmmu_devices_lock);
+
+    list_for_each_entry( mmu, &ipmmu_devices, list )
+    {
+        if ( ipmmu_is_root(mmu) )
+        {
+            found = true;
+            break;
+        }
+    }
+
+    spin_unlock(&ipmmu_devices_lock);
+
+    return found ? mmu : NULL;
+}
+
+/* Read/Write Access */
+static uint32_t ipmmu_read(struct ipmmu_vmsa_device *mmu, uint32_t offset)
+{
+    return readl(mmu->base + offset);
+}
+
+static void ipmmu_write(struct ipmmu_vmsa_device *mmu, uint32_t offset,
+                        uint32_t data)
+{
+    writel(data, mmu->base + offset);
+}
+
+static uint32_t ipmmu_ctx_read_root(struct ipmmu_vmsa_domain *domain,
+                                    uint32_t reg)
+{
+    return ipmmu_read(domain->mmu->root,
+                      domain->context_id * IM_CTX_SIZE + reg);
+}
+
+static void ipmmu_ctx_write_root(struct ipmmu_vmsa_domain *domain,
+                                 uint32_t reg, uint32_t data)
+{
+    ipmmu_write(domain->mmu->root,
+                domain->context_id * IM_CTX_SIZE + reg, data);
+}
+
+static void ipmmu_ctx_write_cache(struct ipmmu_vmsa_domain *domain,
+                                  uint32_t reg, uint32_t data)
+{
+    /* We expect only IMCTR value to be passed as a reg. */
+    ASSERT(reg == IMCTR);
+
+    /* Mask fields which are implemented in IPMMU-MM only. */
+    if ( !ipmmu_is_root(domain->mmu) )
+        ipmmu_write(domain->mmu, domain->context_id * IM_CTX_SIZE + reg,
+                    data & IMCTR_COMMON_MASK);
+}
+
+/*
+ * Write the context to both Root IPMMU and all Cache IPMMUs assigned
+ * to this Xen domain.
+ */
+static void ipmmu_ctx_write_all(struct ipmmu_vmsa_domain *domain,
+                                uint32_t reg, uint32_t data)
+{
+    struct ipmmu_vmsa_xen_domain *xen_domain = dom_iommu(domain->d)->arch.priv;
+    struct ipmmu_vmsa_domain *cache_domain;
+
+    list_for_each_entry( cache_domain, &xen_domain->cache_domains, list )
+        ipmmu_ctx_write_cache(cache_domain, reg, data);
+
+    ipmmu_ctx_write_root(domain, reg, data);
+}
+
+/* TLB and micro-TLB Management */
+
+/* Wait for any pending TLB invalidations to complete. */
+static void ipmmu_tlb_sync(struct ipmmu_vmsa_domain *domain)
+{
+    unsigned int count = 0;
+
+    while ( ipmmu_ctx_read_root(domain, IMCTR) & IMCTR_FLUSH )
+    {
+        cpu_relax();
+        if ( ++count == TLB_LOOP_TIMEOUT )
+        {
+            dev_err_ratelimited(domain->mmu->dev, "TLB sync timed out -- MMU may be deadlocked\n");
+            return;
+        }
+        udelay(1);
+    }
+}
+
+static void ipmmu_tlb_invalidate(struct ipmmu_vmsa_domain *domain)
+{
+    uint32_t data;
+
+    data = ipmmu_ctx_read_root(domain, IMCTR);
+    data |= IMCTR_FLUSH;
+    ipmmu_ctx_write_all(domain, IMCTR, data);
+
+    ipmmu_tlb_sync(domain);
+}
+
+/* Enable MMU translation for the micro-TLB. */
+static void ipmmu_utlb_enable(struct ipmmu_vmsa_domain *domain,
+                              unsigned int utlb)
+{
+    struct ipmmu_vmsa_device *mmu = domain->mmu;
+
+    /*
+     * TODO: Reference-count the micro-TLB as several bus masters can be
+     * connected to the same micro-TLB. Prevent the use cases where
+     * the same micro-TLB could be shared between multiple Xen domains.
+     */
+    ipmmu_write(mmu, IMUASID(utlb), 0);
+    ipmmu_write(mmu, IMUCTR(utlb), ipmmu_read(mmu, IMUCTR(utlb)) |
+                IMUCTR_TTSEL_MMU(domain->context_id) | IMUCTR_MMUEN);
+}
+
+/* Disable MMU translation for the micro-TLB. */
+static void ipmmu_utlb_disable(struct ipmmu_vmsa_domain *domain,
+                               unsigned int utlb)
+{
+    struct ipmmu_vmsa_device *mmu = domain->mmu;
+
+    ipmmu_write(mmu, IMUCTR(utlb), 0);
+}
+
+/* Domain/Context Management */
+static int ipmmu_domain_allocate_context(struct ipmmu_vmsa_device *mmu,
+                                         struct ipmmu_vmsa_domain *domain)
+{
+    unsigned long flags;
+    int ret;
+
+    spin_lock_irqsave(&mmu->lock, flags);
+
+    ret = find_first_zero_bit(mmu->ctx, mmu->num_ctx);
+    if ( ret != mmu->num_ctx )
+    {
+        mmu->domains[ret] = domain;
+        set_bit(ret, mmu->ctx);
+    }
+    else
+        ret = -EBUSY;
+
+    spin_unlock_irqrestore(&mmu->lock, flags);
+
+    return ret;
+}
+
+static void ipmmu_domain_free_context(struct ipmmu_vmsa_device *mmu,
+                                      unsigned int context_id)
+{
+    unsigned long flags;
+
+    spin_lock_irqsave(&mmu->lock, flags);
+
+    clear_bit(context_id, mmu->ctx);
+    mmu->domains[context_id] = NULL;
+
+    spin_unlock_irqrestore(&mmu->lock, flags);
+}
+
+static int ipmmu_domain_init_context(struct ipmmu_vmsa_domain *domain)
+{
+    uint64_t ttbr;
+    uint32_t tsz0;
+    int ret;
+
+    /* Find an unused context. */
+    ret = ipmmu_domain_allocate_context(domain->mmu->root, domain);
+    if ( ret < 0 )
+        return ret;
+
+    domain->context_id = ret;
+
+    /*
+     * TTBR0
+     * Use P2M table for this Xen domain.
+     */
+    ASSERT(domain->d != NULL);
+    ttbr = page_to_maddr(domain->d->arch.p2m.root);
+
+    dev_info(domain->mmu->root->dev, "%pd: Set IPMMU context %u (pgd 0x%"PRIx64")\n",
+             domain->d, domain->context_id, ttbr);
+
+    ipmmu_ctx_write_root(domain, IMTTLBR0, ttbr & IMTTLBR0_TTBR_MASK);
+    ipmmu_ctx_write_root(domain, IMTTUBR0, (ttbr >> 32) & IMTTUBR0_TTBR_MASK);
+
+    /*
+     * TTBCR
+     * We use long descriptors and allocate the whole "p2m_ipa_bits" IPA space
+     * to TTBR0. Use 4KB page granule. Start page table walks at first level.
+     * Always bypass stage 1 translation.
+     */
+    tsz0 = (64 - p2m_ipa_bits) << IMTTBCR_TSZ0_SHIFT;
+    ipmmu_ctx_write_root(domain, IMTTBCR, IMTTBCR_EAE | IMTTBCR_PMB |
+                         IMTTBCR_SL0_LVL_1 | tsz0);
+
+    /*
+     * IMSTR
+     * Clear all interrupt flags.
+     */
+    ipmmu_ctx_write_root(domain, IMSTR, ipmmu_ctx_read_root(domain, IMSTR));
+
+    /*
+     * IMCTR
+     * Enable the MMU and interrupt generation. The long-descriptor
+     * translation table format doesn't use TEX remapping. Don't enable AF
+     * software management as we have no use for it. Use VMSAv8-64 mode.
+     * Enable the context for Root IPMMU only. Flush the TLB as required
+     * when modifying the context registers.
+     */
+    ipmmu_ctx_write_root(domain, IMCTR,
+                         IMCTR_VA64 | IMCTR_INTEN | IMCTR_FLUSH | IMCTR_MMUEN);
+
+    return 0;
+}
+
+static void ipmmu_domain_destroy_context(struct ipmmu_vmsa_domain *domain)
+{
+    if ( !domain->mmu )
+        return;
+
+    /*
+     * Disable the context for Root IPMMU only. Flush the TLB as required
+     * when modifying the context registers.
+     */
+    ipmmu_ctx_write_root(domain, IMCTR, IMCTR_FLUSH);
+    ipmmu_tlb_sync(domain);
+
+    ipmmu_domain_free_context(domain->mmu->root, domain->context_id);
+}
+
+/* Fault Handling */
+static void ipmmu_domain_irq(struct ipmmu_vmsa_domain *domain)
+{
+    const uint32_t err_mask = IMSTR_MHIT | IMSTR_ABORT | IMSTR_PF | IMSTR_TF;
+    struct ipmmu_vmsa_device *mmu = domain->mmu;
+    uint32_t status;
+    uint64_t iova;
+
+    status = ipmmu_ctx_read_root(domain, IMSTR);
+    if ( !(status & err_mask) )
+        return;
+
+    iova = ipmmu_ctx_read_root(domain, IMELAR) |
+        ((uint64_t)ipmmu_ctx_read_root(domain, IMEUAR) << 32);
+
+    /*
+     * Clear the error status flags. Unlike traditional interrupt flag
+     * registers that must be cleared by writing 1, this status register
+     * seems to require 0. The error address register must be read before,
+     * otherwise its value will be 0.
+     */
+    ipmmu_ctx_write_root(domain, IMSTR, 0);
+
+    /* Log fatal errors. */
+    if ( status & IMSTR_MHIT )
+        dev_err_ratelimited(mmu->dev, "%pd: Multiple TLB hits @0x%"PRIx64"\n",
+                            domain->d, iova);
+    if ( status & IMSTR_ABORT )
+        dev_err_ratelimited(mmu->dev, "%pd: Page Table Walk Abort @0x%"PRIx64"\n",
+                            domain->d, iova);
+
+    /* Return if it is neither Permission Fault nor Translation Fault. */
+    if ( !(status & (IMSTR_PF | IMSTR_TF)) )
+        return;
+
+    dev_err_ratelimited(mmu->dev, "%pd: Unhandled fault: status 0x%08x iova 0x%"PRIx64"\n",
+                        domain->d, status, iova);
+}
+
+static void ipmmu_irq(int irq, void *dev, struct cpu_user_regs *regs)
+{
+    struct ipmmu_vmsa_device *mmu = dev;
+    unsigned int i;
+    unsigned long flags;
+
+    spin_lock_irqsave(&mmu->lock, flags);
+
+    /*
+     * When interrupt arrives, we don't know the context it is related to.
+     * So, check interrupts for all active contexts to locate a context
+     * with status bits set.
+    */
+    for ( i = 0; i < mmu->num_ctx; i++ )
+    {
+        if ( !mmu->domains[i] )
+            continue;
+        ipmmu_domain_irq(mmu->domains[i]);
+    }
+
+    spin_unlock_irqrestore(&mmu->lock, flags);
+}
+
+/* Master devices management */
+static int ipmmu_attach_device(struct ipmmu_vmsa_domain *domain,
+                               struct device *dev)
+{
+    struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
+    struct ipmmu_vmsa_device *mmu = to_ipmmu(dev);
+    unsigned int i;
+
+    if ( !mmu )
+    {
+        dev_err(dev, "Cannot attach to IPMMU\n");
+        return -ENXIO;
+    }
+
+    if ( !domain->mmu )
+    {
+        /* The domain hasn't been used yet, initialize it. */
+        domain->mmu = mmu;
+
+        /*
+         * We have already enabled context for Root IPMMU assigned to this
+         * Xen domain in ipmmu_domain_init_context().
+         * Enable the context for Cache IPMMU only. Flush the TLB as required
+         * when modifying the context registers.
+         */
+        ipmmu_ctx_write_cache(domain, IMCTR,
+                              ipmmu_ctx_read_root(domain, IMCTR) | IMCTR_FLUSH);
+
+        dev_info(dev, "Using IPMMU context %u\n", domain->context_id);
+    }
+    else if ( domain->mmu != mmu )
+    {
+        /*
+         * Something is wrong, we can't attach two master devices using
+         * different IOMMUs to the same IPMMU domain.
+         */
+        dev_err(dev, "Can't attach IPMMU %s to domain on IPMMU %s\n",
+                dev_name(mmu->dev), dev_name(domain->mmu->dev));
+        return -EINVAL;
+    }
+    else
+        dev_info(dev, "Reusing IPMMU context %u\n", domain->context_id);
+
+    for ( i = 0; i < fwspec->num_ids; ++i )
+        ipmmu_utlb_enable(domain, fwspec->ids[i]);
+
+    return 0;
+}
+
+static void ipmmu_detach_device(struct ipmmu_vmsa_domain *domain,
+                                struct device *dev)
+{
+    struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
+    unsigned int i;
+
+    for ( i = 0; i < fwspec->num_ids; ++i )
+        ipmmu_utlb_disable(domain, fwspec->ids[i]);
+}
+
+static int ipmmu_init_platform_device(struct device *dev,
+                                      struct dt_phandle_args *args)
+{
+    struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
+    struct ipmmu_vmsa_device *mmu;
+
+    mmu = ipmmu_find_mmu_by_dev(dt_to_dev(args->np));
+    if ( !mmu )
+        return -ENODEV;
+
+    fwspec->iommu_priv = xzalloc(struct ipmmu_vmsa_xen_device);
+    if ( !fwspec->iommu_priv )
+        return -ENOMEM;
+
+    set_ipmmu(dev, mmu);
+
+    return 0;
+}
+
+static void ipmmu_device_reset(struct ipmmu_vmsa_device *mmu)
+{
+    unsigned int i;
+
+    /* Disable all contexts. */
+    for ( i = 0; i < mmu->num_ctx; ++i )
+        ipmmu_write(mmu, i * IM_CTX_SIZE + IMCTR, 0);
+}
+
+/*
+ * This function relies on the fact that Root IPMMU device is being probed
+ * the first. If not the case, it denies further Cache IPMMU device probes
+ * (returns the -EAGAIN) until the Root IPMMU device has been registered
+ * for sure.
+ */
+static int ipmmu_probe(struct dt_device_node *node)
+{
+    struct ipmmu_vmsa_device *mmu;
+    uint64_t addr, size;
+    int irq, ret;
+
+    mmu = xzalloc(struct ipmmu_vmsa_device);
+    if ( !mmu )
+    {
+        dev_err(&node->dev, "Cannot allocate device data\n");
+        return -ENOMEM;
+    }
+
+    mmu->dev = &node->dev;
+    mmu->num_utlbs = IPMMU_UTLB_MAX;
+    mmu->num_ctx = IPMMU_CTX_MAX;
+    spin_lock_init(&mmu->lock);
+    bitmap_zero(mmu->ctx, IPMMU_CTX_MAX);
+
+    /* Map I/O memory and request IRQ. */
+    ret = dt_device_get_address(node, 0, &addr, &size);
+    if ( ret )
+    {
+        dev_err(&node->dev, "Failed to get MMIO\n");
+        goto out;
+    }
+
+    mmu->base = ioremap_nocache(addr, size);
+    if ( !mmu->base )
+    {
+        dev_err(&node->dev, "Failed to ioremap MMIO (addr 0x%"PRIx64" size 0x%"PRIx64")\n",
+                addr, size);
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    /*
+     * Determine if this IPMMU node is a Root device by checking for
+     * the lack of renesas,ipmmu-main property.
+     */
+    if ( !dt_find_property(node, "renesas,ipmmu-main", NULL) )
+        mmu->root = mmu;
+    else
+        mmu->root = ipmmu_find_root();
+
+    /* Wait until the Root device has been registered for sure. */
+    if ( !mmu->root )
+    {
+        dev_err(&node->dev, "Root IPMMU hasn't been registered yet\n");
+        ret = -EAGAIN;
+        goto out;
+    }
+
+    /* Root devices have mandatory IRQs. */
+    if ( ipmmu_is_root(mmu) )
+    {
+        irq = platform_get_irq(node, 0);
+        if ( irq < 0 )
+        {
+            dev_err(&node->dev, "No IRQ found\n");
+            ret = irq;
+            goto out;
+        }
+
+        ret = request_irq(irq, 0, ipmmu_irq, dev_name(&node->dev), mmu);
+        if ( ret < 0 )
+        {
+            dev_err(&node->dev, "Failed to request IRQ %d\n", irq);
+            goto out;
+        }
+
+        ipmmu_device_reset(mmu);
+
+        /*
+         * Use stage 2 translation table format when stage 2 translation
+         * enabled.
+         */
+        ipmmu_write(mmu, IMSAUXCTLR,
+                    ipmmu_read(mmu, IMSAUXCTLR) | IMSAUXCTLR_S2PTE);
+
+        dev_info(&node->dev, "IPMMU context 0 is reserved\n");
+        set_bit(0, mmu->ctx);
+    }
+
+    spin_lock(&ipmmu_devices_lock);
+    list_add(&mmu->list, &ipmmu_devices);
+    spin_unlock(&ipmmu_devices_lock);
+
+    dev_info(&node->dev, "Registered %s IPMMU\n",
+             ipmmu_is_root(mmu) ? "Root" : "Cache");
+
+    return 0;
+
+out:
+    if ( mmu->base )
+        iounmap(mmu->base);
+    xfree(mmu);
+
+    return ret;
+}
+
+/* Xen IOMMU ops */
+static int __must_check ipmmu_iotlb_flush_all(struct domain *d)
+{
+    struct ipmmu_vmsa_xen_domain *xen_domain = dom_iommu(d)->arch.priv;
+
+    if ( !xen_domain || !xen_domain->root_domain )
+        return 0;
+
+    spin_lock(&xen_domain->lock);
+    ipmmu_tlb_invalidate(xen_domain->root_domain);
+    spin_unlock(&xen_domain->lock);
+
+    return 0;
+}
+
+static int __must_check ipmmu_iotlb_flush(struct domain *d, dfn_t dfn,
+                                          unsigned int page_count,
+                                          unsigned int flush_flags)
+{
+    ASSERT(flush_flags);
+
+    /* The hardware doesn't support selective TLB flush. */
+    return ipmmu_iotlb_flush_all(d);
+}
+
+static struct ipmmu_vmsa_domain *ipmmu_get_cache_domain(struct domain *d,
+                                                        struct device *dev)
+{
+    struct ipmmu_vmsa_xen_domain *xen_domain = dom_iommu(d)->arch.priv;
+    struct ipmmu_vmsa_device *mmu = to_ipmmu(dev);
+    struct ipmmu_vmsa_domain *domain;
+
+    if ( !mmu )
+        return NULL;
+
+    /*
+     * Loop through all Cache IPMMU domains associated with this Xen domain
+     * to locate an IPMMU domain this IPMMU device is assigned to.
+     */
+    list_for_each_entry( domain, &xen_domain->cache_domains, list )
+    {
+        if ( domain->mmu == mmu )
+            return domain;
+    }
+
+    return NULL;
+}
+
+static struct ipmmu_vmsa_domain *ipmmu_alloc_cache_domain(struct domain *d)
+{
+    struct ipmmu_vmsa_xen_domain *xen_domain = dom_iommu(d)->arch.priv;
+    struct ipmmu_vmsa_domain *domain;
+
+    domain = xzalloc(struct ipmmu_vmsa_domain);
+    if ( !domain )
+        return ERR_PTR(-ENOMEM);
+
+    /*
+     * We don't assign the Cache IPMMU device here, it will be assigned when
+     * attaching master device to this domain in ipmmu_attach_device().
+     * domain->mmu = NULL;
+     */
+
+    domain->d = d;
+    /* Use the same context mapped to this Xen domain. */
+    domain->context_id = xen_domain->root_domain->context_id;
+
+    return domain;
+}
+
+static void ipmmu_free_cache_domain(struct ipmmu_vmsa_domain *domain)
+{
+    list_del(&domain->list);
+    /*
+     * Disable the context for Cache IPMMU only. Flush the TLB as required
+     * when modifying the context registers.
+     */
+    ipmmu_ctx_write_cache(domain, IMCTR, IMCTR_FLUSH);
+    xfree(domain);
+}
+
+static struct ipmmu_vmsa_domain *ipmmu_alloc_root_domain(struct domain *d)
+{
+    struct ipmmu_vmsa_domain *domain;
+    struct ipmmu_vmsa_device *root;
+    int ret;
+
+    /* If we are here then Root device must has been registered. */
+    root = ipmmu_find_root();
+    if ( !root )
+    {
+        printk(XENLOG_ERR "ipmmu: Unable to locate Root IPMMU\n");
+        return ERR_PTR(-ENODEV);
+    }
+
+    domain = xzalloc(struct ipmmu_vmsa_domain);
+    if ( !domain )
+        return ERR_PTR(-ENOMEM);
+
+    domain->mmu = root;
+    domain->d = d;
+
+    /* Initialize the context to be mapped to this Xen domain. */
+    ret = ipmmu_domain_init_context(domain);
+    if ( ret < 0 )
+    {
+        dev_err(root->dev, "%pd: Unable to initialize IPMMU context\n", d);
+        xfree(domain);
+        return ERR_PTR(ret);
+    }
+
+    return domain;
+}
+
+static void ipmmu_free_root_domain(struct ipmmu_vmsa_domain *domain)
+{
+    ipmmu_domain_destroy_context(domain);
+    xfree(domain);
+}
+
+static int ipmmu_assign_device(struct domain *d, u8 devfn, struct device *dev,
+                               uint32_t flag)
+{
+    struct ipmmu_vmsa_xen_domain *xen_domain = dom_iommu(d)->arch.priv;
+    struct ipmmu_vmsa_domain *domain;
+    int ret;
+
+    if ( !xen_domain )
+        return -EINVAL;
+
+    if ( !to_ipmmu(dev) )
+        return -ENODEV;
+
+    spin_lock(&xen_domain->lock);
+
+    /*
+     * The IPMMU context for the Xen domain is not allocated beforehand
+     * (at the Xen domain creation time), but on demand only, when the first
+     * master device being attached to it.
+     * Create Root IPMMU domain which context will be mapped to this Xen domain
+     * if not exits yet.
+     */
+    if ( !xen_domain->root_domain )
+    {
+        domain = ipmmu_alloc_root_domain(d);
+        if ( IS_ERR(domain) )
+        {
+            ret = PTR_ERR(domain);
+            goto out;
+        }
+
+        xen_domain->root_domain = domain;
+    }
+
+    if ( to_domain(dev) )
+    {
+        dev_err(dev, "Already attached to IPMMU domain\n");
+        ret = -EEXIST;
+        goto out;
+    }
+
+    /*
+     * Master devices behind the same Cache IPMMU can be attached to the same
+     * Cache IPMMU domain.
+     * Before creating new IPMMU domain check to see if the required one
+     * already exists for this Xen domain.
+     */
+    domain = ipmmu_get_cache_domain(d, dev);
+    if ( !domain )
+    {
+        /* Create new IPMMU domain this master device will be attached to. */
+        domain = ipmmu_alloc_cache_domain(d);
+        if ( IS_ERR(domain) )
+        {
+            ret = PTR_ERR(domain);
+            goto out;
+        }
+
+        /* Chain new IPMMU domain to the Xen domain. */
+        list_add(&domain->list, &xen_domain->cache_domains);
+    }
+
+    ret = ipmmu_attach_device(domain, dev);
+    if ( ret )
+    {
+        /*
+         * Destroy Cache IPMMU domain only if there are no master devices
+         * attached to it.
+         */
+        if ( !domain->refcount )
+            ipmmu_free_cache_domain(domain);
+    }
+    else
+    {
+        domain->refcount++;
+        set_domain(dev, domain);
+    }
+
+out:
+    spin_unlock(&xen_domain->lock);
+
+    return ret;
+}
+
+static int ipmmu_deassign_device(struct domain *d, struct device *dev)
+{
+    struct ipmmu_vmsa_xen_domain *xen_domain = dom_iommu(d)->arch.priv;
+    struct ipmmu_vmsa_domain *domain = to_domain(dev);
+
+    if ( !domain || domain->d != d )
+    {
+        dev_err(dev, "Not attached to %pd\n", d);
+        return -ESRCH;
+    }
+
+    spin_lock(&xen_domain->lock);
+
+    ipmmu_detach_device(domain, dev);
+    set_domain(dev, NULL);
+    domain->refcount--;
+
+    /*
+     * Destroy Cache IPMMU domain only if there are no master devices
+     * attached to it.
+     */
+    if ( !domain->refcount )
+        ipmmu_free_cache_domain(domain);
+
+    spin_unlock(&xen_domain->lock);
+
+    return 0;
+}
+
+static int ipmmu_reassign_device(struct domain *s, struct domain *t,
+                                 u8 devfn,  struct device *dev)
+{
+    int ret = 0;
+
+    /* Don't allow remapping on other domain than hwdom */
+    if ( t && t != hardware_domain )
+        return -EPERM;
+
+    if ( t == s )
+        return 0;
+
+    ret = ipmmu_deassign_device(s, dev);
+    if ( ret )
+        return ret;
+
+    if ( t )
+    {
+        /* No flags are defined for ARM. */
+        ret = ipmmu_assign_device(t, devfn, dev, 0);
+        if ( ret )
+            return ret;
+    }
+
+    return 0;
+}
+
+static int ipmmu_of_xlate(struct device *dev, struct dt_phandle_args *spec)
+{
+    int ret;
+
+    /*
+     * Perform sanity check of passed DT IOMMU specifier. Each master device
+     * gets micro-TLB (device ID) assignment via the "iommus" property
+     * in DT. We expect #iommu-cells to be 1 (Multiple-master IOMMU) and
+     * this cell for the micro-TLB (device ID).
+     */
+    if ( spec->args_count != 1 || spec->args[0] >= IPMMU_UTLB_MAX )
+        return -EINVAL;
+
+    ret = iommu_fwspec_add_ids(dev, spec->args, 1);
+    if ( ret )
+        return ret;
+
+    /* Initialize once - xlate() will call multiple times. */
+    if ( to_ipmmu(dev) )
+        return 0;
+
+    return ipmmu_init_platform_device(dev, spec);
+}
+
+static int ipmmu_add_device(u8 devfn, struct device *dev)
+{
+    struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
+
+    /* Only let through devices that have been verified in xlate(). */
+    if ( !to_ipmmu(dev) )
+        return -ENODEV;
+
+    if ( dt_device_is_protected(dev_to_dt(dev)) )
+    {
+        dev_err(dev, "Already added to IPMMU\n");
+        return -EEXIST;
+    }
+
+    /* Let Xen know that the master device is protected by an IOMMU. */
+    dt_device_set_protected(dev_to_dt(dev));
+
+    dev_info(dev, "Added master device (IPMMU %s micro-TLBs %u)\n",
+             dev_name(fwspec->iommu_dev), fwspec->num_ids);
+
+    return 0;
+}
+
+static int ipmmu_iommu_domain_init(struct domain *d)
+{
+    struct ipmmu_vmsa_xen_domain *xen_domain;
+
+    xen_domain = xzalloc(struct ipmmu_vmsa_xen_domain);
+    if ( !xen_domain )
+        return -ENOMEM;
+
+    spin_lock_init(&xen_domain->lock);
+    INIT_LIST_HEAD(&xen_domain->cache_domains);
+    /*
+     * We don't create Root IPMMU domain here, it will be created on demand
+     * only, when attaching the first master device to this Xen domain in
+     * ipmmu_assign_device().
+     * xen_domain->root_domain = NULL;
+    */
+
+    dom_iommu(d)->arch.priv = xen_domain;
+
+    return 0;
+}
+
+static void __hwdom_init ipmmu_iommu_hwdom_init(struct domain *d)
+{
+    /* Set to false options not supported on ARM. */
+    if ( iommu_hwdom_inclusive )
+        printk(XENLOG_WARNING "ipmmu: map-inclusive dom0-iommu option is not supported on ARM\n");
+    iommu_hwdom_inclusive = false;
+    if ( iommu_hwdom_reserved == 1 )
+        printk(XENLOG_WARNING "ipmmu: map-reserved dom0-iommu option is not supported on ARM\n");
+    iommu_hwdom_reserved = 0;
+
+    arch_iommu_hwdom_init(d);
+}
+
+static void ipmmu_iommu_domain_teardown(struct domain *d)
+{
+    struct ipmmu_vmsa_xen_domain *xen_domain = dom_iommu(d)->arch.priv;
+
+    if ( !xen_domain )
+        return;
+
+    /*
+     * Destroy Root IPMMU domain which context is mapped to this Xen domain
+     * if exits.
+     */
+    if ( xen_domain->root_domain )
+        ipmmu_free_root_domain(xen_domain->root_domain);
+
+    /*
+     * We assume that all master devices have already been detached from
+     * this Xen domain and there must be no associated Cache IPMMU domains
+     * in use.
+     */
+    ASSERT(list_empty(&xen_domain->cache_domains));
+    xfree(xen_domain);
+    dom_iommu(d)->arch.priv = NULL;
+}
+
+static const struct iommu_ops ipmmu_iommu_ops =
+{
+    .init            = ipmmu_iommu_domain_init,
+    .hwdom_init      = ipmmu_iommu_hwdom_init,
+    .teardown        = ipmmu_iommu_domain_teardown,
+    .iotlb_flush     = ipmmu_iotlb_flush,
+    .iotlb_flush_all = ipmmu_iotlb_flush_all,
+    .assign_device   = ipmmu_assign_device,
+    .reassign_device = ipmmu_reassign_device,
+    .map_page        = arm_iommu_map_page,
+    .unmap_page      = arm_iommu_unmap_page,
+    .of_xlate        = ipmmu_of_xlate,
+    .add_device      = ipmmu_add_device,
+};
+
+/* R-Car Gen3 SoCs product and cut information. */
+#define RCAR_PRODUCT_MASK    0x00007F00
+#define RCAR_PRODUCT_H3      0x00004F00
+#define RCAR_PRODUCT_M3W     0x00005200
+#define RCAR_PRODUCT_M3N     0x00005500
+#define RCAR_CUT_MASK        0x000000FF
+#define RCAR_CUT_VER30       0x00000020
+
+static __init bool ipmmu_stage2_supported(void)
+{
+    struct dt_device_node *np;
+    uint64_t addr, size;
+    void __iomem *base;
+    uint32_t product, cut;
+    static enum
+    {
+        UNKNOWN,
+        SUPPORTED,
+        NOTSUPPORTED
+    } stage2_supported = UNKNOWN;
+
+    /* Use the flag to avoid checking for the compatibility more then once. */
+    switch ( stage2_supported )
+    {
+    case SUPPORTED:
+        return true;
+
+    case NOTSUPPORTED:
+        return false;
+
+    case UNKNOWN:
+    default:
+        stage2_supported = NOTSUPPORTED;
+        break;
+    }
+
+    np = dt_find_compatible_node(NULL, NULL, "renesas,prr");
+    if ( !np )
+    {
+        printk(XENLOG_ERR "ipmmu: Failed to find PRR node\n");
+        return false;
+    }
+
+    if ( dt_device_get_address(np, 0, &addr, &size) )
+    {
+        printk(XENLOG_ERR "ipmmu: Failed to get PRR MMIO\n");
+        return false;
+    }
+
+    base = ioremap_nocache(addr, size);
+    if ( !base )
+    {
+        printk(XENLOG_ERR "ipmmu: Failed to ioremap PRR MMIO\n");
+        return false;
+    }
+
+    product = readl(base);
+    cut = product & RCAR_CUT_MASK;
+    product &= RCAR_PRODUCT_MASK;
+
+    switch ( product )
+    {
+    case RCAR_PRODUCT_H3:
+    case RCAR_PRODUCT_M3W:
+        if ( cut >= RCAR_CUT_VER30 )
+            stage2_supported = SUPPORTED;
+        break;
+
+    case RCAR_PRODUCT_M3N:
+        stage2_supported = SUPPORTED;
+        break;
+
+    default:
+        printk(XENLOG_ERR "ipmmu: Unsupported SoC version\n");
+        break;
+    }
+
+    iounmap(base);
+
+    return stage2_supported == SUPPORTED;
+}
+
+static const struct dt_device_match ipmmu_dt_match[] __initconst =
+{
+    DT_MATCH_COMPATIBLE("renesas,ipmmu-r8a7795"),
+    DT_MATCH_COMPATIBLE("renesas,ipmmu-r8a77965"),
+    DT_MATCH_COMPATIBLE("renesas,ipmmu-r8a7796"),
+    { /* sentinel */ },
+};
+
+static __init int ipmmu_init(struct dt_device_node *node, const void *data)
+{
+    int ret;
+
+    /*
+     * Even if the device can't be initialized, we don't want to give
+     * the IPMMU device to dom0.
+     */
+    dt_device_set_used_by(node, DOMID_XEN);
+
+    if ( !iommu_hap_pt_share )
+    {
+        printk_once(XENLOG_ERR "ipmmu: P2M table must always be shared between the CPU and the IPMMU\n");
+        return -EINVAL;
+    }
+
+    if ( !ipmmu_stage2_supported() )
+    {
+        printk_once(XENLOG_ERR "ipmmu: P2M sharing is not supported in current SoC revision\n");
+        return -ENODEV;
+    }
+    else
+    {
+        /*
+         * As 4-level translation table is not supported in IPMMU, we need
+         * to check IPA size used for P2M table beforehand to be sure it is
+         * 3-level and the IPMMU will be able to use it.
+         *
+         * TODO: First initialize the IOMMU and gather the requirements and
+         * then initialize the P2M. In the P2M code, take into the account
+         * the IOMMU requirements and restrict "pa_range" if necessary.
+         */
+        if ( IPMMU_MAX_P2M_IPA_BITS < p2m_ipa_bits )
+        {
+            printk_once(XENLOG_ERR "ipmmu: P2M IPA size is not supported (P2M=%u IPMMU=%u)!\n",
+                        p2m_ipa_bits, IPMMU_MAX_P2M_IPA_BITS);
+            return -ENODEV;
+        }
+    }
+
+    ret = ipmmu_probe(node);
+    if ( ret )
+    {
+        dev_err(&node->dev, "Failed to init IPMMU (%d)\n", ret);
+        return ret;
+    }
+
+    iommu_set_ops(&ipmmu_iommu_ops);
+
+    return 0;
+}
+
+DT_DEVICE_START(ipmmu, "Renesas IPMMU-VMSA", DEVICE_IOMMU)
+    .dt_match = ipmmu_dt_match,
+    .init = ipmmu_init,
+DT_DEVICE_END
+
+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "BSD"
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
-- 
2.7.4


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 3/8] xen/common: Introduce _xrealloc function
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 3/8] xen/common: Introduce _xrealloc function Oleksandr Tyshchenko
@ 2019-08-21  8:09   ` Paul Durrant
  2019-08-21 14:36     ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Paul Durrant @ 2019-08-21  8:09 UTC (permalink / raw)
  To: Oleksandr Tyshchenko, xen-devel
  Cc: sstabellini, Wei Liu, Konrad Rzeszutek Wilk, Andrew Cooper,
	Tim \(Xen.org\),
	George Dunlap, Oleksandr Tyshchenko, julien.grall, Jan Beulich,
	Ian Jackson, Volodymyr_Babchuk

> -----Original Message-----
> From: Xen-devel <xen-devel-bounces@lists.xenproject.org> On Behalf Of Oleksandr Tyshchenko
> Sent: 20 August 2019 19:10
> To: xen-devel@lists.xenproject.org
> Cc: sstabellini@kernel.org; Wei Liu <wl@xen.org>; Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>;
> George Dunlap <George.Dunlap@citrix.com>; Andrew Cooper <Andrew.Cooper3@citrix.com>; Ian Jackson
> <Ian.Jackson@citrix.com>; Tim (Xen.org) <tim@xen.org>; Oleksandr Tyshchenko
> <oleksandr_tyshchenko@epam.com>; julien.grall@arm.com; Jan Beulich <jbeulich@suse.com>;
> Volodymyr_Babchuk@epam.com
> Subject: [Xen-devel] [PATCH V3 3/8] xen/common: Introduce _xrealloc function
> 
> From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
> 
> This patch introduces type-unsafe function which besides
> re-allocation handles the following corner cases:
> 1. if requested size is zero, it will behave like xfree
> 2. if incoming pointer is not valid (NULL or ZERO_BLOCK_PTR),
>    it will behave like xmalloc
> 
> If both pointer and size are valid the function will re-allocate and
> copy only if requested size doesn't fit in already allocated space.
> 
> Subsequent patch will add type-safe helper macros.
> 
> Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
> CC: Andrew Cooper <andrew.cooper3@citrix.com>
> CC: George Dunlap <George.Dunlap@eu.citrix.com>
> CC: Ian Jackson <ian.jackson@eu.citrix.com>
> CC: Jan Beulich <jbeulich@suse.com>
> CC: Julien Grall <julien.grall@arm.com>
> CC: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
> CC: Stefano Stabellini <sstabellini@kernel.org>
> CC: Tim Deegan <tim@xen.org>
> CC: Wei Liu <wl@xen.org>
> 
> ---
> Changes since RFC:
>    - behave like xmalloc if incoming pointer is ZERO_BLOCK_PTR or NULL
>    - return ZERO_BLOCK_PTR after xfree if requested size is zero
>    - add patch description
>    - use allocator internals to recognize current size of
>      the incoming pointer
>    - do not re-allocate and copy if requested size fits in already
>      allocated space
> 
>    ...
> 
>    Original patch was initially posted by Sameer Goel:
>    https://lists.xen.org/archives/html/xen-devel/2017-06/msg00858.html
> 
>    This could be considered as another attempt to add it:
>    https://www.mail-archive.com/kexec@lists.infradead.org/msg21335.html
> 
>    [As it was previously discussed with Julien in IRC]
> 
>    The reason for this patch to be an RFC is that patch itself is not
>    completely correct and I don't fully understand what/how should
>    be done for this patch to be accepted. Or whether community even
>    wants this to go in. So, to avoid bike shedding, the first target is
>    to collect feedback.
> 
>    For everyone who wants more details why this is needed and
>    where used, please see next patch of this thread:
>    "iommu/arm: Add lightweight iommu_fwspec support"
> 
>    In a nutshell, the upcoming "iommu_fwspec" support on ARM
>    is going to use xrealloc to expand an array for device IDs.
>    We really want to have "iommu_fwspec" support which will give us
>    a generic abstract way to add new device to the IOMMU based on
>    the generic IOMMU DT binding.
> ---
>  xen/common/xmalloc_tlsf.c | 45 +++++++++++++++++++++++++++++++++++++++++++++
>  xen/include/xen/xmalloc.h |  1 +
>  2 files changed, 46 insertions(+)
> 
> diff --git a/xen/common/xmalloc_tlsf.c b/xen/common/xmalloc_tlsf.c
> index e98ad65..eecae2e 100644
> --- a/xen/common/xmalloc_tlsf.c
> +++ b/xen/common/xmalloc_tlsf.c
> @@ -598,6 +598,51 @@ void *_xzalloc(unsigned long size, unsigned long align)
>      return p ? memset(p, 0, size) : p;
>  }
> 
> +void *_xrealloc(void *ptr, unsigned long size, unsigned long align)
> +{
> +    unsigned long curr_size, tmp_size;
> +    void *p;
> +
> +    if ( !size )
> +    {
> +        xfree(ptr);
> +        return ZERO_BLOCK_PTR;
> +    }
> +
> +    if ( ptr == NULL || ptr == ZERO_BLOCK_PTR )
> +        return _xmalloc(size, align);
> +
> +    if ( !((unsigned long)ptr & (PAGE_SIZE - 1)) )
> +        curr_size = PFN_ORDER(virt_to_page(ptr)) << PAGE_SHIFT;
> +    else
> +    {
> +        struct bhdr *b;
> +        b = (struct bhdr *)((char *)ptr - BHDR_OVERHEAD);
> +        curr_size = b->size & BLOCK_SIZE_MASK;
> +    }

That seconds clause is not going to give you the block size if the previous allocation had alignment padding. You'll need to check the FREE_BLOCK bit to tell whether it's a real block header or the 'fake' alignment header and then maybe walk backwards onto the real header. See the code in xfree(). You should also check whether the new requested alignment is compatible with the existing block alignment

  Paul

> +
> +    ASSERT((align & (align - 1)) == 0);
> +    if ( align < MEM_ALIGN )
> +        align = MEM_ALIGN;
> +    tmp_size = size + align - MEM_ALIGN;
> +
> +    if ( tmp_size < PAGE_SIZE )
> +        tmp_size = ( tmp_size < MIN_BLOCK_SIZE ) ? MIN_BLOCK_SIZE :
> +            ROUNDUP_SIZE(tmp_size);
> +
> +    if ( tmp_size <= curr_size ) /* fits in current block */
> +        return ptr;
> +
> +    p = _xmalloc(size, align);
> +    if ( p )
> +    {
> +        memcpy(p, ptr, min(curr_size, size));
> +        xfree(ptr);
> +    }
> +
> +    return p;
> +}
> +
>  void xfree(void *p)
>  {
>      struct bhdr *b;
> diff --git a/xen/include/xen/xmalloc.h b/xen/include/xen/xmalloc.h
> index f075d2d..831152f 100644
> --- a/xen/include/xen/xmalloc.h
> +++ b/xen/include/xen/xmalloc.h
> @@ -51,6 +51,7 @@ extern void xfree(void *);
>  /* Underlying functions */
>  extern void *_xmalloc(unsigned long size, unsigned long align);
>  extern void *_xzalloc(unsigned long size, unsigned long align);
> +extern void *_xrealloc(void *ptr, unsigned long size, unsigned long align);
> 
>  static inline void *_xmalloc_array(
>      unsigned long size, unsigned long align, unsigned long num)
> --
> 2.7.4
> 
> 
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@lists.xenproject.org
> https://lists.xenproject.org/mailman/listinfo/xen-devel
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 3/8] xen/common: Introduce _xrealloc function
  2019-08-21  8:09   ` Paul Durrant
@ 2019-08-21 14:36     ` Oleksandr
  2019-08-21 15:47       ` Paul Durrant
  0 siblings, 1 reply; 41+ messages in thread
From: Oleksandr @ 2019-08-21 14:36 UTC (permalink / raw)
  To: Paul Durrant, xen-devel
  Cc: sstabellini, Wei Liu, Konrad Rzeszutek Wilk, Andrew Cooper,
	Tim \(Xen.org\),
	George Dunlap, Oleksandr Tyshchenko, julien.grall, Jan Beulich,
	Ian Jackson, Volodymyr_Babchuk


On 21.08.19 11:09, Paul Durrant wrote:

Hi, Paul

>>   }
>>
>> +void *_xrealloc(void *ptr, unsigned long size, unsigned long align)
>> +{
>> +    unsigned long curr_size, tmp_size;
>> +    void *p;
>> +
>> +    if ( !size )
>> +    {
>> +        xfree(ptr);
>> +        return ZERO_BLOCK_PTR;
>> +    }
>> +
>> +    if ( ptr == NULL || ptr == ZERO_BLOCK_PTR )
>> +        return _xmalloc(size, align);
>> +
>> +    if ( !((unsigned long)ptr & (PAGE_SIZE - 1)) )
>> +        curr_size = PFN_ORDER(virt_to_page(ptr)) << PAGE_SHIFT;
>> +    else
>> +    {
>> +        struct bhdr *b;
>> +        b = (struct bhdr *)((char *)ptr - BHDR_OVERHEAD);
>> +        curr_size = b->size & BLOCK_SIZE_MASK;
>> +    }
> That seconds clause is not going to give you the block size if the previous allocation had alignment padding. You'll need to check the FREE_BLOCK bit to tell whether it's a real block header or the 'fake' alignment header and then maybe walk backwards onto the real header. See the code in xfree().

Indeed. Thank you for the pointer.


> You should also check whether the new requested alignment is compatible with the existing block alignment


I am wondering:

In case when we use only type-safe construction for the basic allocation 
(xmalloc) and type-safe construction for the re-allocation 
(xrealloc_flex_struct) over the same pointer of the correct type, will 
we get a possible alignment incompatibility?


This is how I see it:

diff --git a/xen/common/xmalloc_tlsf.c b/xen/common/xmalloc_tlsf.c
index eecae2e..f90f453 100644
--- a/xen/common/xmalloc_tlsf.c
+++ b/xen/common/xmalloc_tlsf.c
@@ -616,8 +616,15 @@ void *_xrealloc(void *ptr, unsigned long size, 
unsigned long align)
          curr_size = PFN_ORDER(virt_to_page(ptr)) << PAGE_SHIFT;
      else
      {
-        struct bhdr *b;
-        b = (struct bhdr *)((char *)ptr - BHDR_OVERHEAD);
+        struct bhdr *b = (struct bhdr *)((char *)ptr - BHDR_OVERHEAD);
+
+        if ( b->size & FREE_BLOCK )
+        {
+            p = (char *)ptr - (b->size & ~FREE_BLOCK);
+            b = (struct bhdr *)((char *)p - BHDR_OVERHEAD);
+            ASSERT(!(b->size & FREE_BLOCK));
+        }
+
          curr_size = b->size & BLOCK_SIZE_MASK;
      }

@@ -630,8 +637,8 @@ void *_xrealloc(void *ptr, unsigned long size, 
unsigned long align)
          tmp_size = ( tmp_size < MIN_BLOCK_SIZE ) ? MIN_BLOCK_SIZE :
              ROUNDUP_SIZE(tmp_size);

-    if ( tmp_size <= curr_size ) /* fits in current block */
-        return ptr;
+    if ( tmp_size <= curr_size && ((unsigned long)ptr & (align - 1)) == 0 )
+        return ptr; /* fits in current block */

      p = _xmalloc(size, align);
      if ( p )

(END)


Did I get your point correct?


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 3/8] xen/common: Introduce _xrealloc function
  2019-08-21 14:36     ` Oleksandr
@ 2019-08-21 15:47       ` Paul Durrant
  2019-08-21 17:04         ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Paul Durrant @ 2019-08-21 15:47 UTC (permalink / raw)
  To: Oleksandr, xen-devel
  Cc: sstabellini, Wei Liu, Konrad Rzeszutek Wilk, Andrew Cooper,
	Tim \(Xen.org\),
	George Dunlap, Oleksandr Tyshchenko, julien.grall, Jan Beulich,
	Ian Jackson, Volodymyr_Babchuk

> -----Original Message-----
> From: Oleksandr <olekstysh@gmail.com>
> Sent: 21 August 2019 15:36
> To: Paul Durrant <Paul.Durrant@citrix.com>; xen-devel@lists.xenproject.org
> Cc: sstabellini@kernel.org; Wei Liu <wl@xen.org>; Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>;
> George Dunlap <George.Dunlap@citrix.com>; Andrew Cooper <Andrew.Cooper3@citrix.com>; Ian Jackson
> <Ian.Jackson@citrix.com>; Tim (Xen.org) <tim@xen.org>; Oleksandr Tyshchenko
> <oleksandr_tyshchenko@epam.com>; julien.grall@arm.com; Jan Beulich <jbeulich@suse.com>;
> Volodymyr_Babchuk@epam.com
> Subject: Re: [Xen-devel] [PATCH V3 3/8] xen/common: Introduce _xrealloc function
> 
> 
> On 21.08.19 11:09, Paul Durrant wrote:
> 
> Hi, Paul
> 
> >>   }
> >>
> >> +void *_xrealloc(void *ptr, unsigned long size, unsigned long align)
> >> +{
> >> +    unsigned long curr_size, tmp_size;
> >> +    void *p;
> >> +
> >> +    if ( !size )
> >> +    {
> >> +        xfree(ptr);
> >> +        return ZERO_BLOCK_PTR;
> >> +    }
> >> +
> >> +    if ( ptr == NULL || ptr == ZERO_BLOCK_PTR )
> >> +        return _xmalloc(size, align);
> >> +
> >> +    if ( !((unsigned long)ptr & (PAGE_SIZE - 1)) )
> >> +        curr_size = PFN_ORDER(virt_to_page(ptr)) << PAGE_SHIFT;
> >> +    else
> >> +    {
> >> +        struct bhdr *b;
> >> +        b = (struct bhdr *)((char *)ptr - BHDR_OVERHEAD);
> >> +        curr_size = b->size & BLOCK_SIZE_MASK;
> >> +    }
> > That seconds clause is not going to give you the block size if the previous allocation had alignment
> padding. You'll need to check the FREE_BLOCK bit to tell whether it's a real block header or the
> 'fake' alignment header and then maybe walk backwards onto the real header. See the code in xfree().
> 
> Indeed. Thank you for the pointer.
> 
> 
> > You should also check whether the new requested alignment is compatible with the existing block
> alignment
> 
> 
> I am wondering:
> 
> In case when we use only type-safe construction for the basic allocation
> (xmalloc) and type-safe construction for the re-allocation
> (xrealloc_flex_struct) over the same pointer of the correct type, will
> we get a possible alignment incompatibility?

You shouldn't but you're trusting that no-one will want to call the function directly with a higher alignment.
 
> 
> 
> This is how I see it:
> 
> diff --git a/xen/common/xmalloc_tlsf.c b/xen/common/xmalloc_tlsf.c
> index eecae2e..f90f453 100644
> --- a/xen/common/xmalloc_tlsf.c
> +++ b/xen/common/xmalloc_tlsf.c
> @@ -616,8 +616,15 @@ void *_xrealloc(void *ptr, unsigned long size,
> unsigned long align)
>           curr_size = PFN_ORDER(virt_to_page(ptr)) << PAGE_SHIFT;
>       else
>       {
> -        struct bhdr *b;
> -        b = (struct bhdr *)((char *)ptr - BHDR_OVERHEAD);
> +        struct bhdr *b = (struct bhdr *)((char *)ptr - BHDR_OVERHEAD);
> +
> +        if ( b->size & FREE_BLOCK )
> +        {
> +            p = (char *)ptr - (b->size & ~FREE_BLOCK);
> +            b = (struct bhdr *)((char *)p - BHDR_OVERHEAD);
> +            ASSERT(!(b->size & FREE_BLOCK));
> +        }
> +
>           curr_size = b->size & BLOCK_SIZE_MASK;

Yes, that looks ok for getting the size right...

>       }
> 
> @@ -630,8 +637,8 @@ void *_xrealloc(void *ptr, unsigned long size,
> unsigned long align)
>           tmp_size = ( tmp_size < MIN_BLOCK_SIZE ) ? MIN_BLOCK_SIZE :
>               ROUNDUP_SIZE(tmp_size);
> 
> -    if ( tmp_size <= curr_size ) /* fits in current block */
> -        return ptr;
> +    if ( tmp_size <= curr_size && ((unsigned long)ptr & (align - 1)) == 0 )
> +        return ptr; /* fits in current block */

...and that should deal with the alignment too (although you may want to mention the alignment part in the comment too)

> 
>       p = _xmalloc(size, align);
>       if ( p )
> 
> (END)
> 
> 
> Did I get your point correct?
> 

Yes, with those changes I think it will look ok.

  Paul

> 
> --
> Regards,
> 
> Oleksandr Tyshchenko

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 3/8] xen/common: Introduce _xrealloc function
  2019-08-21 15:47       ` Paul Durrant
@ 2019-08-21 17:04         ` Oleksandr
  0 siblings, 0 replies; 41+ messages in thread
From: Oleksandr @ 2019-08-21 17:04 UTC (permalink / raw)
  To: Paul Durrant, xen-devel
  Cc: sstabellini, Wei Liu, Konrad Rzeszutek Wilk, Andrew Cooper,
	Tim \(Xen.org\),
	George Dunlap, Oleksandr Tyshchenko, julien.grall, Jan Beulich,
	Ian Jackson, Volodymyr_Babchuk


On 21.08.19 18:47, Paul Durrant wrote:

Hi

>>
>> You should also check whether the new requested alignment is compatible with the existing block
>> alignment
>>
>>
>> I am wondering:
>>
>> In case when we use only type-safe construction for the basic allocation
>> (xmalloc) and type-safe construction for the re-allocation
>> (xrealloc_flex_struct) over the same pointer of the correct type, will
>> we get a possible alignment incompatibility?
> You shouldn't but you're trusting that no-one will want to call the function directly with a higher alignment.

Yes, it is best to be on the safe side.


>   
>>
>> This is how I see it:
>>
>> diff --git a/xen/common/xmalloc_tlsf.c b/xen/common/xmalloc_tlsf.c
>> index eecae2e..f90f453 100644
>> --- a/xen/common/xmalloc_tlsf.c
>> +++ b/xen/common/xmalloc_tlsf.c
>> @@ -616,8 +616,15 @@ void *_xrealloc(void *ptr, unsigned long size,
>> unsigned long align)
>>            curr_size = PFN_ORDER(virt_to_page(ptr)) << PAGE_SHIFT;
>>        else
>>        {
>> -        struct bhdr *b;
>> -        b = (struct bhdr *)((char *)ptr - BHDR_OVERHEAD);
>> +        struct bhdr *b = (struct bhdr *)((char *)ptr - BHDR_OVERHEAD);
>> +
>> +        if ( b->size & FREE_BLOCK )
>> +        {
>> +            p = (char *)ptr - (b->size & ~FREE_BLOCK);
>> +            b = (struct bhdr *)((char *)p - BHDR_OVERHEAD);
>> +            ASSERT(!(b->size & FREE_BLOCK));
>> +        }
>> +
>>            curr_size = b->size & BLOCK_SIZE_MASK;
> Yes, that looks ok for getting the size right...
>
>>        }
>>
>> @@ -630,8 +637,8 @@ void *_xrealloc(void *ptr, unsigned long size,
>> unsigned long align)
>>            tmp_size = ( tmp_size < MIN_BLOCK_SIZE ) ? MIN_BLOCK_SIZE :
>>                ROUNDUP_SIZE(tmp_size);
>>
>> -    if ( tmp_size <= curr_size ) /* fits in current block */
>> -        return ptr;
>> +    if ( tmp_size <= curr_size && ((unsigned long)ptr & (align - 1)) == 0 )
>> +        return ptr; /* fits in current block */
> ...and that should deal with the alignment too (although you may want to mention the alignment part in the comment too)
>
>>        p = _xmalloc(size, align);
>>        if ( p )
>>
>> (END)
>>
>>
>> Did I get your point correct?
>>
> Yes, with those changes I think it will look ok.

Thank you.


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 4/8] xen/common: Introduce xrealloc_flex_struct() helper macros
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 4/8] xen/common: Introduce xrealloc_flex_struct() helper macros Oleksandr Tyshchenko
@ 2019-08-27 13:28   ` Jan Beulich
  2019-08-28 18:23     ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Jan Beulich @ 2019-08-27 13:28 UTC (permalink / raw)
  To: Oleksandr Tyshchenko
  Cc: sstabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap,
	Andrew Cooper, Ian Jackson, Tim Deegan, Oleksandr Tyshchenko,
	julien.grall, xen-devel, Volodymyr_Babchuk

On 20.08.2019 20:09, Oleksandr Tyshchenko wrote:
> --- a/xen/include/xen/xmalloc.h
> +++ b/xen/include/xen/xmalloc.h
> @@ -35,6 +35,18 @@
>   #define xzalloc_array(_type, _num) \
>       ((_type *)_xzalloc_array(sizeof(_type), __alignof__(_type), _num))
>   
> +/* Re-allocate space for a structure with a flexible array of typed objects. */
> +#define xrealloc_flex_struct(_ptr, _type, _field, _len) ({                   \

May I ask that you don't extend the bad use of leading underscores here?

> +    /* type checking: make sure that incoming pointer is of correct type */  \

Comment style (should start with upper case char)

> +    (void)((typeof(_ptr)) 0 == (_type *) 0);                                 \

Stray blanks before 0. And why not simply "(void)((ptr) == (type *)0)"?
(You'd need to avoid the double evaluation of ptr, yes.)

> +    ((_type *)_xrealloc(_ptr, offsetof(_type, _field[_len]),                 \
> +                        __alignof__(_type)));                                \

Unnecessary pair of outermost parentheses.

> +})
> +
> +/* Allocate space for a structure with a flexible array of typed objects. */
> +#define xmalloc_flex_struct(_type, _field, _len) \
> +    ((_type *)_xmalloc(offsetof(_type, _field[_len]), __alignof__(_type)))

I think this wants to go ahead of its re-alloc counterpart.

In both cases I'd also like to suggest using "nr" instead of "len",
as something called "length" can be mistaken to represent the
overall length of the resulting object, rather than the number of
array elements.

Jan

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 6/8] iommu: Add of_xlate callback
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 6/8] iommu: Add of_xlate callback Oleksandr Tyshchenko
@ 2019-08-27 13:30   ` Jan Beulich
  2019-08-27 14:59     ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Jan Beulich @ 2019-08-27 13:30 UTC (permalink / raw)
  To: Oleksandr Tyshchenko
  Cc: xen-devel, julien.grall, sstabellini, Volodymyr_Babchuk,
	Oleksandr Tyshchenko

On 20.08.2019 20:09, Oleksandr Tyshchenko wrote:
> --- a/xen/include/xen/iommu.h
> +++ b/xen/include/xen/iommu.h
> @@ -240,6 +240,16 @@ struct iommu_ops {
>       int __must_check (*iotlb_flush_all)(struct domain *d);
>       int (*get_reserved_device_memory)(iommu_grdm_t *, void *);
>       void (*dump_p2m_table)(struct domain *d);
> +
> +#ifdef CONFIG_HAS_DEVICE_TREE
> +    /*
> +     * All IOMMU drivers which support generic IOMMU DT bindings should use
> +     * this callback. This is a way for the framework to provide the driver
> +     * with DT IOMMU specifier which describes the IOMMU master interfaces of
> +     * that device (device IDs, etc).
> +     */
> +    int (*of_xlate)(device_t *dev, struct dt_phandle_args *args);
> +#endif
>   };

I think this should be folded into the first patch using it. Doing
so may also answer my question of what "of" here stands for.

Jan

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 6/8] iommu: Add of_xlate callback
  2019-08-27 13:30   ` Jan Beulich
@ 2019-08-27 14:59     ` Oleksandr
  2019-08-27 15:11       ` Jan Beulich
  0 siblings, 1 reply; 41+ messages in thread
From: Oleksandr @ 2019-08-27 14:59 UTC (permalink / raw)
  To: Jan Beulich
  Cc: xen-devel, julien.grall, sstabellini, Volodymyr_Babchuk,
	Oleksandr Tyshchenko


Hi Jan

> On 20.08.2019 20:09, Oleksandr Tyshchenko wrote:
>> --- a/xen/include/xen/iommu.h
>> +++ b/xen/include/xen/iommu.h
>> @@ -240,6 +240,16 @@ struct iommu_ops {
>>       int __must_check (*iotlb_flush_all)(struct domain *d);
>>       int (*get_reserved_device_memory)(iommu_grdm_t *, void *);
>>       void (*dump_p2m_table)(struct domain *d);
>> +
>> +#ifdef CONFIG_HAS_DEVICE_TREE
>> +    /*
>> +     * All IOMMU drivers which support generic IOMMU DT bindings 
>> should use
>> +     * this callback. This is a way for the framework to provide the 
>> driver
>> +     * with DT IOMMU specifier which describes the IOMMU master 
>> interfaces of
>> +     * that device (device IDs, etc).
>> +     */
>> +    int (*of_xlate)(device_t *dev, struct dt_phandle_args *args);
>> +#endif
>>   };
>
> I think this should be folded into the first patch using it. Doing
> so may also answer my question of what "of" here stands for.

In Linux, code related to the device-tree is prefixed with "of_". But, 
in Xen, code related to the device-tree is prefixed with "dt_" [1]. 
Looks like, I should have named it "dt_xlate" to be consistent.
There was a preference to introduce callback in a separate patch [2]. 
Anyway, shall I fold it?


[1] 
https://github.com/xen-project/xen/blob/master/xen/include/xen/device_tree.h
[2] 
https://lists.xenproject.org/archives/html/xen-devel/2019-08/msg01393.html


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 6/8] iommu: Add of_xlate callback
  2019-08-27 14:59     ` Oleksandr
@ 2019-08-27 15:11       ` Jan Beulich
  2019-09-09 12:37         ` Julien Grall
  0 siblings, 1 reply; 41+ messages in thread
From: Jan Beulich @ 2019-08-27 15:11 UTC (permalink / raw)
  To: Oleksandr
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini,
	Volodymyr_Babchuk, xen-devel

On 27.08.2019 16:59, Oleksandr wrote:
> There was a preference to introduce callback in a separate patch [2]. Anyway, shall I fold it?

Hmm, I disagree with Julien here. I don't think we should have unused
hooks in the tree, not even intermediately.

Jan

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 4/8] xen/common: Introduce xrealloc_flex_struct() helper macros
  2019-08-27 13:28   ` Jan Beulich
@ 2019-08-28 18:23     ` Oleksandr
  2019-08-29  7:21       ` Jan Beulich
  0 siblings, 1 reply; 41+ messages in thread
From: Oleksandr @ 2019-08-28 18:23 UTC (permalink / raw)
  To: Jan Beulich
  Cc: sstabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap,
	Andrew Cooper, Ian Jackson, Tim Deegan, Oleksandr Tyshchenko,
	julien.grall, xen-devel, Volodymyr_Babchuk


On 27.08.19 16:28, Jan Beulich wrote:

Hi Jan

> On 20.08.2019 20:09, Oleksandr Tyshchenko wrote:
>> --- a/xen/include/xen/xmalloc.h
>> +++ b/xen/include/xen/xmalloc.h
>> @@ -35,6 +35,18 @@
>>   #define xzalloc_array(_type, _num) \
>>       ((_type *)_xzalloc_array(sizeof(_type), __alignof__(_type), _num))
>>   +/* Re-allocate space for a structure with a flexible array of 
>> typed objects. */
>> +#define xrealloc_flex_struct(_ptr, _type, _field, _len) 
>> ({                   \
>
> May I ask that you don't extend the bad use of leading underscores here?

Yes, sure.


>
>> +    /* type checking: make sure that incoming pointer is of correct 
>> type */  \
>
> Comment style (should start with upper case char)

ok


>
>> +    (void)((typeof(_ptr)) 0 == (_type *) 
>> 0);                                 \
>
> Stray blanks before 0. And why not simply "(void)((ptr) == (type *)0)"?
> (You'd need to avoid the double evaluation of ptr, yes.)

ok


>
>> +    ((_type *)_xrealloc(_ptr, offsetof(_type, 
>> _field[_len]),                 \
>> + __alignof__(_type)));                                \
>
> Unnecessary pair of outermost parentheses.

ok


>
>> +})
>> +
>> +/* Allocate space for a structure with a flexible array of typed 
>> objects. */
>> +#define xmalloc_flex_struct(_type, _field, _len) \
>> +    ((_type *)_xmalloc(offsetof(_type, _field[_len]), 
>> __alignof__(_type)))
>
> I think this wants to go ahead of its re-alloc counterpart.

ok


>
> In both cases I'd also like to suggest using "nr" instead of "len",
> as something called "length" can be mistaken to represent the
> overall length of the resulting object, rather than the number of
> array elements.

sounds reasonable

Thank you.


diff --git a/xen/include/xen/xmalloc.h b/xen/include/xen/xmalloc.h
index 831152f..3eec10b 100644
--- a/xen/include/xen/xmalloc.h
+++ b/xen/include/xen/xmalloc.h
@@ -35,6 +35,18 @@
  #define xzalloc_array(_type, _num) \
      ((_type *)_xzalloc_array(sizeof(_type), __alignof__(_type), _num))

+/* Allocate space for a structure with a flexible array of typed 
objects. */
+#define xmalloc_flex_struct(type, field, nr) \
+    ((type *)_xmalloc(offsetof(type, field[nr]), __alignof__(type)))
+
+/* Re-allocate space for a structure with a flexible array of typed 
objects. */
+#define xrealloc_flex_struct(ptr, type, field, nr) 
({                        \
+    typeof(*(ptr)) *ptr_ = 
(ptr);                                            \
+    /* Type checking: make sure that incoming pointer is of correct 
type */  \
+    (void)((ptr) == (type 
*)0);                                              \
+    (type *)_xrealloc(ptr_, offsetof(type, field[nr]), 
__alignof__(type));   \
+})
+
  /* Allocate untyped storage. */
  #define xmalloc_bytes(_bytes) _xmalloc(_bytes, SMP_CACHE_BYTES)
  #define xzalloc_bytes(_bytes) _xzalloc(_bytes, SMP_CACHE_BYTES)
(END)

-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 4/8] xen/common: Introduce xrealloc_flex_struct() helper macros
  2019-08-28 18:23     ` Oleksandr
@ 2019-08-29  7:21       ` Jan Beulich
  2019-08-29 19:04         ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Jan Beulich @ 2019-08-29  7:21 UTC (permalink / raw)
  To: Oleksandr
  Cc: sstabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap,
	Andrew Cooper, Ian Jackson, Tim Deegan, Oleksandr Tyshchenko,
	julien.grall, xen-devel, Volodymyr_Babchuk

On 28.08.2019 20:23, Oleksandr wrote:
> --- a/xen/include/xen/xmalloc.h
> +++ b/xen/include/xen/xmalloc.h
> @@ -35,6 +35,18 @@
>   #define xzalloc_array(_type, _num) \
>       ((_type *)_xzalloc_array(sizeof(_type), __alignof__(_type), _num))
> 
> +/* Allocate space for a structure with a flexible array of typed 
> objects. */
> +#define xmalloc_flex_struct(type, field, nr) \
> +    ((type *)_xmalloc(offsetof(type, field[nr]), __alignof__(type)))
> +
> +/* Re-allocate space for a structure with a flexible array of typed 
> objects. */
> +#define xrealloc_flex_struct(ptr, type, field, nr) 
> ({                        \
> +    typeof(*(ptr)) *ptr_ = 
> (ptr);                                            \
> +    /* Type checking: make sure that incoming pointer is of correct 
> type */  \
> +    (void)((ptr) == (type 
> *)0);                                              \
> +    (type *)_xrealloc(ptr_, offsetof(type, field[nr]), 
> __alignof__(type));   \
> +})
> +

What about

#define xrealloc_flex_struct(ptr, field, nr)                         \
    (typeof(ptr))_xrealloc(ptr, offsetof(typeof(*(ptr)), field[nr]), \
                           __alignof__(typeof(*(ptr))))

?

Jan

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support Oleksandr Tyshchenko
@ 2019-08-29  8:37   ` Yoshihiro Shimoda
  2019-08-29 10:56     ` Oleksandr
  2019-08-29 11:19   ` Oleksandr
  2019-09-09 21:24   ` Julien Grall
  2 siblings, 1 reply; 41+ messages in thread
From: Yoshihiro Shimoda @ 2019-08-29  8:37 UTC (permalink / raw)
  To: Oleksandr Tyshchenko, xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini, Volodymyr_Babchuk

Hi Oleksandr-san,

> From: Oleksandr Tyshchenko, Sent: Wednesday, August 21, 2019 3:10 AM
> 
> From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
> 
> The IPMMU-VMSA is VMSA-compatible I/O Memory Management Unit (IOMMU)
> which provides address translation and access protection functionalities
> to processing units and interconnect networks.
> 
> Please note, current driver is supposed to work only with newest
> Gen3 SoCs revisions which IPMMU hardware supports stage 2 translation

This is still "Gen3", so that please replace it with "R-Car Gen3"...

> table format and is able to use CPU's P2M table as is if one is
> 3-level page table (up to 40 bit IPA).
> 
> The major differences compare to the Linux driver are:
> 
> 1. Stage 1/Stage 2 translation. Linux driver supports Stage 1
> translation only (with Stage 1 translation table format). It manages
> page table by itself. But Xen driver supports Stage 2 translation
> (with Stage 2 translation table format) to be able to share the P2M
> with the CPU. Stage 1 translation is always bypassed in Xen driver.
> 
> So, Xen driver is supposed to be used with newest R-Car Gen3 SoC revisions
> only (H3 ES3.0, M3-W+, etc.) which IPMMU H/W supports stage 2 translation
> table format.
> 
> 2. AArch64 support. Linux driver uses VMSAv8-32 mode, while Xen driver
> enables Armv8 VMSAv8-64 mode to cover up to 40 bit input address.
> 
> 3. Context bank (sets of page table) usage. In Xen, each context bank is
> mapped to one Xen domain. So, all devices being pass throughed to the
> same Xen domain share the same context bank.
> 
> 4. IPMMU device tracking. In Xen, all IOMMU devices are managed
> by single driver instance. So, driver uses global list to keep track
> of registered IPMMU devices.
> 
> Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
> CC: Julien Grall <julien.grall@arm.com>
> CC: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>

About this hardware handling, this patch seems good to me. But, since
I'm not familiar about Xen passthrough framework, I think I cannot
add my Reviewed-by tag into this patch. What do you think?

Best regards,
Yoshihiro Shimoda


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support
  2019-08-29  8:37   ` Yoshihiro Shimoda
@ 2019-08-29 10:56     ` Oleksandr
  2019-09-02  7:04       ` Yoshihiro Shimoda
  0 siblings, 1 reply; 41+ messages in thread
From: Oleksandr @ 2019-08-29 10:56 UTC (permalink / raw)
  To: Yoshihiro Shimoda, xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini, Volodymyr_Babchuk


On 29.08.19 11:37, Yoshihiro Shimoda wrote:
> Hi Oleksandr-san,

Hi Shimoda-san.


>
>> From: Oleksandr Tyshchenko, Sent: Wednesday, August 21, 2019 3:10 AM
>>
>> From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
>>
>> The IPMMU-VMSA is VMSA-compatible I/O Memory Management Unit (IOMMU)
>> which provides address translation and access protection functionalities
>> to processing units and interconnect networks.
>>
>> Please note, current driver is supposed to work only with newest
>> Gen3 SoCs revisions which IPMMU hardware supports stage 2 translation
> This is still "Gen3", so that please replace it with "R-Car Gen3"...

Will do.


>
>> table format and is able to use CPU's P2M table as is if one is
>> 3-level page table (up to 40 bit IPA).
>>
>> The major differences compare to the Linux driver are:
>>
>> 1. Stage 1/Stage 2 translation. Linux driver supports Stage 1
>> translation only (with Stage 1 translation table format). It manages
>> page table by itself. But Xen driver supports Stage 2 translation
>> (with Stage 2 translation table format) to be able to share the P2M
>> with the CPU. Stage 1 translation is always bypassed in Xen driver.
>>
>> So, Xen driver is supposed to be used with newest R-Car Gen3 SoC revisions
>> only (H3 ES3.0, M3-W+, etc.) which IPMMU H/W supports stage 2 translation
>> table format.
>>
>> 2. AArch64 support. Linux driver uses VMSAv8-32 mode, while Xen driver
>> enables Armv8 VMSAv8-64 mode to cover up to 40 bit input address.
>>
>> 3. Context bank (sets of page table) usage. In Xen, each context bank is
>> mapped to one Xen domain. So, all devices being pass throughed to the
>> same Xen domain share the same context bank.
>>
>> 4. IPMMU device tracking. In Xen, all IOMMU devices are managed
>> by single driver instance. So, driver uses global list to keep track
>> of registered IPMMU devices.
>>
>> Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
>> CC: Julien Grall <julien.grall@arm.com>
>> CC: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
> About this hardware handling, this patch seems good to me. But, since
> I'm not familiar about Xen passthrough framework, I think I cannot
> add my Reviewed-by tag into this patch. What do you think?

I am not completely sure regarding that, but I have seen cases when the 
people give their R-b not for the entire patch, but for a part of it.

Especially, when patch touches many sub-systems/archs. Would you mind if 
I specify what your R-b covers? -> [for the IPMMU H/W bits]


Thank you for the review.

>
> Best regards,
> Yoshihiro Shimoda
>
-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support Oleksandr Tyshchenko
  2019-08-29  8:37   ` Yoshihiro Shimoda
@ 2019-08-29 11:19   ` Oleksandr
  2019-09-09 21:24   ` Julien Grall
  2 siblings, 0 replies; 41+ messages in thread
From: Oleksandr @ 2019-08-29 11:19 UTC (permalink / raw)
  To: xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini,
	Volodymyr_Babchuk, Yoshihiro Shimoda

Hi, all


> +
> +static __init int ipmmu_init(struct dt_device_node *node, const void *data)
> +{
> +    int ret;
> +
> +    /*
> +     * Even if the device can't be initialized, we don't want to give
> +     * the IPMMU device to dom0.
> +     */
> +    dt_device_set_used_by(node, DOMID_XEN);
> +
> +    if ( !iommu_hap_pt_share )
> +    {
> +        printk_once(XENLOG_ERR "ipmmu: P2M table must always be shared between the CPU and the IPMMU\n");
> +        return -EINVAL;
> +    }
> +
> +    if ( !ipmmu_stage2_supported() )
> +    {
> +        printk_once(XENLOG_ERR "ipmmu: P2M sharing is not supported in current SoC revision\n");
> +        return -ENODEV;
> +    }
> +    else
> +    {
> +        /*
> +         * As 4-level translation table is not supported in IPMMU, we need
> +         * to check IPA size used for P2M table beforehand to be sure it is
> +         * 3-level and the IPMMU will be able to use it.
> +         *
> +         * TODO: First initialize the IOMMU and gather the requirements and
> +         * then initialize the P2M. In the P2M code, take into the account
> +         * the IOMMU requirements and restrict "pa_range" if necessary.
> +         */
> +        if ( IPMMU_MAX_P2M_IPA_BITS < p2m_ipa_bits )
> +        {
> +            printk_once(XENLOG_ERR "ipmmu: P2M IPA size is not supported (P2M=%u IPMMU=%u)!\n",
> +                        p2m_ipa_bits, IPMMU_MAX_P2M_IPA_BITS);
> +            return -ENODEV;
> +        }


There is a patch in ML which is intended to address this TODO:

https://lists.xenproject.org/archives/html/xen-devel/2019-08/msg02237.html


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 4/8] xen/common: Introduce xrealloc_flex_struct() helper macros
  2019-08-29  7:21       ` Jan Beulich
@ 2019-08-29 19:04         ` Oleksandr
  0 siblings, 0 replies; 41+ messages in thread
From: Oleksandr @ 2019-08-29 19:04 UTC (permalink / raw)
  To: Jan Beulich
  Cc: sstabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap,
	Andrew Cooper, Ian Jackson, Tim Deegan, Oleksandr Tyshchenko,
	julien.grall, xen-devel, Volodymyr_Babchuk


On 29.08.19 10:21, Jan Beulich wrote:

Hi Jan

> On 28.08.2019 20:23, Oleksandr wrote:
>> --- a/xen/include/xen/xmalloc.h
>> +++ b/xen/include/xen/xmalloc.h
>> @@ -35,6 +35,18 @@
>>    #define xzalloc_array(_type, _num) \
>>        ((_type *)_xzalloc_array(sizeof(_type), __alignof__(_type), _num))
>>
>> +/* Allocate space for a structure with a flexible array of typed
>> objects. */
>> +#define xmalloc_flex_struct(type, field, nr) \
>> +    ((type *)_xmalloc(offsetof(type, field[nr]), __alignof__(type)))
>> +
>> +/* Re-allocate space for a structure with a flexible array of typed
>> objects. */
>> +#define xrealloc_flex_struct(ptr, type, field, nr)
>> ({                        \
>> +    typeof(*(ptr)) *ptr_ =
>> (ptr);                                            \
>> +    /* Type checking: make sure that incoming pointer is of correct
>> type */  \
>> +    (void)((ptr) == (type
>> *)0);                                              \
>> +    (type *)_xrealloc(ptr_, offsetof(type, field[nr]),
>> __alignof__(type));   \
>> +})
>> +
> What about
>
> #define xrealloc_flex_struct(ptr, field, nr)                         \
>      (typeof(ptr))_xrealloc(ptr, offsetof(typeof(*(ptr)), field[nr]), \
>                             __alignof__(typeof(*(ptr))))
>
> ?

Even better. And works...

Thank you.


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support
  2019-08-29 10:56     ` Oleksandr
@ 2019-09-02  7:04       ` Yoshihiro Shimoda
  2019-09-09 14:33         ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Yoshihiro Shimoda @ 2019-09-02  7:04 UTC (permalink / raw)
  To: Oleksandr, xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini, Volodymyr_Babchuk

Hi Oleksandr-san,

> From: Oleksandr, Sent: Thursday, August 29, 2019 7:56 PM
<snip>
> > About this hardware handling, this patch seems good to me. But, since
> > I'm not familiar about Xen passthrough framework, I think I cannot
> > add my Reviewed-by tag into this patch. What do you think?
> 
> I am not completely sure regarding that, but I have seen cases when the
> people give their R-b not for the entire patch, but for a part of it.
> 
> Especially, when patch touches many sub-systems/archs. Would you mind if
> I specify what your R-b covers? -> [for the IPMMU H/W bits]

I got it. When you submit v4 patch, I'll review and send such a tag.

Best regards,
Yoshihiro Shimoda

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 1/8] iommu/arm: Add iommu_helpers.c file to keep common for IOMMUs stuff
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 1/8] iommu/arm: Add iommu_helpers.c file to keep common for IOMMUs stuff Oleksandr Tyshchenko
@ 2019-09-09 11:45   ` Julien Grall
  2019-09-09 14:12     ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Julien Grall @ 2019-09-09 11:45 UTC (permalink / raw)
  To: Oleksandr Tyshchenko, xen-devel
  Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk

Hi Oleksandr,

On 8/20/19 7:09 PM, Oleksandr Tyshchenko wrote:
> From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
> 
> Introduce a separate file to keep various helpers which could be used
> by more than one IOMMU driver in order not to duplicate code.
> 
> The first candidates to be moved to the new file are SMMU driver's
> "map_page/unmap_page" callbacks. There callbacks neither contain any

s/There/These/ I think.

> SMMU specific info nor perform any SMMU specific actions and are going
> to be the same across all IOMMU drivers which H/W IP shares P2M
> with the CPU like SMMU does.
> 
> So, move callbacks to iommu_helpers.c for the upcoming IPMMU driver
> to be able to re-use them.
> 
> Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
> CC: Julien Grall <julien.grall@arm.com>

[...]

>   static __init const struct arm_smmu_device *find_smmu(const struct device *dev)
> diff --git a/xen/include/asm-arm/iommu.h b/xen/include/asm-arm/iommu.h
> index 904c9ae..20d865e 100644
> --- a/xen/include/asm-arm/iommu.h
> +++ b/xen/include/asm-arm/iommu.h
> @@ -26,6 +26,13 @@ struct arch_iommu
>   const struct iommu_ops *iommu_get_ops(void);
>   void iommu_set_ops(const struct iommu_ops *ops);
>   
> +/* mapping helpers */

I would specify this only works when the PT is shared between the IOMMU 
and CPU.

With the two requests addressed:

Acked-by: Julien Grall <julien.grall@arm.com>

> +int __must_check arm_iommu_map_page(struct domain *d, dfn_t dfn, mfn_t mfn,
> +                                    unsigned int flags,
> +                                    unsigned int *flush_flags);
> +int __must_check arm_iommu_unmap_page(struct domain *d, dfn_t dfn,
> +                                      unsigned int *flush_flags);
> +
>   #endif /* __ARCH_ARM_IOMMU_H__ */
>   
>   /*
> 

Cheers,

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 2/8] iommu/arm: Add ability to handle deferred probing request
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 2/8] iommu/arm: Add ability to handle deferred probing request Oleksandr Tyshchenko
@ 2019-09-09 12:24   ` Julien Grall
  2019-09-09 14:19     ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Julien Grall @ 2019-09-09 12:24 UTC (permalink / raw)
  To: Oleksandr Tyshchenko, xen-devel
  Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk

Hi Oleksandr,

The code looks code, few comments below.

On 8/20/19 7:09 PM, Oleksandr Tyshchenko wrote:
> From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
> 
> This patch adds minimal required support to General IOMMU framework
> to be able to handle a case when IOMMU driver requesting deferred
> probing for a device.
> 
> In order not to pull Linux's error code (-EPROBE_DEFER) to Xen
> we have chosen -EAGAIN to be used for indicating that device
> probing is deferred.
> 
> This is needed for the upcoming IPMMU driver which may request
> deferred probing depending on what device will be probed the first
> (there is some dependency between these devices, Root device must be
> registered before Cache devices. If not the case, driver will deny
> further Cache device probes until Root device is registered).
> As we can't guarantee a fixed pre-defined order for the device nodes
> in DT, we need to be ready for the situation where devices being
> probed in "any" order.
> 
> While here, order the headers alphabetically.

It is common to clean code you modify in the same patch if they are not 
complex, but this is not the case here... Indeed, the headers are not 
touched. So I would prefer this to be in a separate patch unless it 
breaks the compilation without it.

> 
> Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
> CC: Julien Grall <julien.grall@arm.com>
> 
> ---
> Changes V2 -> V3:
>      - removed deferred_probe field from struct dt_device_node,
>        re-used domain_list instead
>      - documented domain_list usage
>      - added ASSERT to check that np->domain_list is empty
>        before re-using it
>      - put deferred_probe_list to init section
>      - used more strict logic regarding processing devices in
>        the deferred list
>      - added more comments to code
>      - put headers in alphabetical order
> ---
>   xen/drivers/passthrough/arm/iommu.c | 59 ++++++++++++++++++++++++++++++++++---
>   xen/include/asm-arm/device.h        |  6 +++-
>   xen/include/xen/device_tree.h       |  7 +++++
>   3 files changed, 67 insertions(+), 5 deletions(-)
> 
> diff --git a/xen/drivers/passthrough/arm/iommu.c b/xen/drivers/passthrough/arm/iommu.c
> index f219de9..72a30e0 100644
> --- a/xen/drivers/passthrough/arm/iommu.c
> +++ b/xen/drivers/passthrough/arm/iommu.c
> @@ -15,11 +15,20 @@
>    * GNU General Public License for more details.
>    */
>   
> -#include <xen/lib.h>
> -#include <xen/iommu.h>
>   #include <xen/device_tree.h>
> +#include <xen/iommu.h>
> +#include <xen/lib.h>
> +
>   #include <asm/device.h>
>   
> +/*
> + * Deferred probe list is used to keep track of devices for which driver
> + * requested deferred probing (returned -EAGAIN).
> + *
> + * We re-use device's domain_list to link the device in the deferred list.
> + */
> +static __initdata LIST_HEAD(deferred_probe_list);
> +
>   static const struct iommu_ops *iommu_ops;
>   
>   const struct iommu_ops *iommu_get_ops(void)
> @@ -42,7 +51,7 @@ void __init iommu_set_ops(const struct iommu_ops *ops)
>   
>   int __init iommu_hardware_setup(void)
>   {
> -    struct dt_device_node *np;
> +    struct dt_device_node *np, *tmp;
>       int rc;
>       unsigned int num_iommus = 0;
>   
> @@ -51,6 +60,17 @@ int __init iommu_hardware_setup(void)
>           rc = device_init(np, DEVICE_IOMMU, NULL);
>           if ( !rc )
>               num_iommus++;
> +        else if ( rc == -EAGAIN )
> +        {
> +            /* We expect nobody uses domain_list at such early stage. */

AFAICT, this comment is only an English version of the next line. It 
would be best if you explain why domain_list is re-used here.

> +            ASSERT(list_empty(&np->domain_list));
> +
> +            /*
> +             * Driver requested deferred probing, so add this device to
> +             * the deferred list for further processing.
> +             */
> +            list_add(&np->domain_list, &deferred_probe_list);
> +        }
>           /*
>            * Ignore the following error codes:
>            *   - EBADF: Indicate the current not is not an IOMMU
> @@ -61,7 +81,38 @@ int __init iommu_hardware_setup(void)
>               return rc;
>       }
>   
> -    return ( num_iommus > 0 ) ? 0 : -ENODEV;
> +    /* Return immediately if there are no initialized devices. */
> +    if ( !num_iommus )
> +        return ( list_empty(&deferred_probe_list) ) ? -ENODEV : -EAGAIN;

NIT: Do you need the outer ()?

> +
> +    rc = 0;
> +
> +    /*
> +     * Process devices in the deferred list if it is not empty.
> +     * Check that at least one device is initialized at each loop, otherwise
> +     * we may get an infinite loop. Also stop processing if we got an error
> +     * other than -EAGAIN.
> +     */
> +    while ( !list_empty(&deferred_probe_list) && num_iommus )
> +    {
> +        num_iommus = 0;
> +
> +        list_for_each_entry_safe ( np, tmp, &deferred_probe_list, domain_list )
> +        {
> +            rc = device_init(np, DEVICE_IOMMU, NULL);
> +            if ( !rc )
> +            {
> +                num_iommus++;
> +
> +                /* Remove initialized device from the deferred list. */
> +                list_del_init(&np->domain_list);
> +            }
> +            else if ( rc != -EAGAIN )
> +                return rc;
> +        }
> +    }
> +
> +    return rc;
>   }
>   
>   void __hwdom_init arch_iommu_check_autotranslated_hwdom(struct domain *d)
> diff --git a/xen/include/asm-arm/device.h b/xen/include/asm-arm/device.h
> index 63a0f36..ee1c3bc 100644
> --- a/xen/include/asm-arm/device.h
> +++ b/xen/include/asm-arm/device.h
> @@ -44,7 +44,11 @@ struct device_desc {
>       enum device_class class;
>       /* List of devices supported by this driver */
>       const struct dt_device_match *dt_match;
> -    /* Device initialization */
> +    /*
> +     * Device initialization.
> +     *
> +     * -EAGAIN is used to indicate that device probing is deferred.
> +     */
>       int (*init)(struct dt_device_node *dev, const void *data);
>   };
>   
> diff --git a/xen/include/xen/device_tree.h b/xen/include/xen/device_tree.h
> index 9a7a8f2..3702e9b 100644
> --- a/xen/include/xen/device_tree.h
> +++ b/xen/include/xen/device_tree.h
> @@ -92,6 +92,13 @@ struct dt_device_node {
>   
>       /* IOMMU specific fields */
>       bool is_protected;
> +    /*
> +     * The main purpose of this list node is to link the structure in the list
> +     * of devices assigned to domain.
> +     *
> +     * Boot code (iommu_hardware_setup) re-uses this list to link the structure
> +     * in the list of devices for which driver requested deferred probing.
> +     */
>       struct list_head domain_list;
>   
>       struct device dev;
> 

Cheers,

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 6/8] iommu: Add of_xlate callback
  2019-08-27 15:11       ` Jan Beulich
@ 2019-09-09 12:37         ` Julien Grall
  2019-09-09 14:28           ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Julien Grall @ 2019-09-09 12:37 UTC (permalink / raw)
  To: Jan Beulich, Oleksandr
  Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk, xen-devel

Hi,

On 8/27/19 4:11 PM, Jan Beulich wrote:
> On 27.08.2019 16:59, Oleksandr wrote:
>> There was a preference to introduce callback in a separate patch [2]. 
>> Anyway, shall I fold it?
> 
> Hmm, I disagree with Julien here. I don't think we should have unused
> hooks in the tree, not even intermediately.

I have stated my preference before, but this is not a strong one nor a 
must. If this is your condition to get the series accepted, then 
Oleksandr should follow your requested.

Cheers,

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 1/8] iommu/arm: Add iommu_helpers.c file to keep common for IOMMUs stuff
  2019-09-09 11:45   ` Julien Grall
@ 2019-09-09 14:12     ` Oleksandr
  0 siblings, 0 replies; 41+ messages in thread
From: Oleksandr @ 2019-09-09 14:12 UTC (permalink / raw)
  To: Julien Grall, xen-devel
  Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk


On 09.09.19 14:45, Julien Grall wrote:
> Hi Oleksandr,

Hi, Julien


>
> On 8/20/19 7:09 PM, Oleksandr Tyshchenko wrote:
>> From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
>>
>> Introduce a separate file to keep various helpers which could be used
>> by more than one IOMMU driver in order not to duplicate code.
>>
>> The first candidates to be moved to the new file are SMMU driver's
>> "map_page/unmap_page" callbacks. There callbacks neither contain any
>
> s/There/These/ I think.

ok


>
>>   static __init const struct arm_smmu_device *find_smmu(const struct 
>> device *dev)
>> diff --git a/xen/include/asm-arm/iommu.h b/xen/include/asm-arm/iommu.h
>> index 904c9ae..20d865e 100644
>> --- a/xen/include/asm-arm/iommu.h
>> +++ b/xen/include/asm-arm/iommu.h
>> @@ -26,6 +26,13 @@ struct arch_iommu
>>   const struct iommu_ops *iommu_get_ops(void);
>>   void iommu_set_ops(const struct iommu_ops *ops);
>>   +/* mapping helpers */
>
> I would specify this only works when the PT is shared between the 
> IOMMU and CPU.

ok


>
>
> With the two requests addressed:
>
> Acked-by: Julien Grall <julien.grall@arm.com>

Thank you


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 2/8] iommu/arm: Add ability to handle deferred probing request
  2019-09-09 12:24   ` Julien Grall
@ 2019-09-09 14:19     ` Oleksandr
  0 siblings, 0 replies; 41+ messages in thread
From: Oleksandr @ 2019-09-09 14:19 UTC (permalink / raw)
  To: Julien Grall, xen-devel
  Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk


On 09.09.19 15:24, Julien Grall wrote:
> Hi Oleksandr,

Hi, Julien


>
> The code looks code, few comments below.
>
> On 8/20/19 7:09 PM, Oleksandr Tyshchenko wrote:
>> From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
>>
>> This patch adds minimal required support to General IOMMU framework
>> to be able to handle a case when IOMMU driver requesting deferred
>> probing for a device.
>>
>> In order not to pull Linux's error code (-EPROBE_DEFER) to Xen
>> we have chosen -EAGAIN to be used for indicating that device
>> probing is deferred.
>>
>> This is needed for the upcoming IPMMU driver which may request
>> deferred probing depending on what device will be probed the first
>> (there is some dependency between these devices, Root device must be
>> registered before Cache devices. If not the case, driver will deny
>> further Cache device probes until Root device is registered).
>> As we can't guarantee a fixed pre-defined order for the device nodes
>> in DT, we need to be ready for the situation where devices being
>> probed in "any" order.
>>
>> While here, order the headers alphabetically.
>
> It is common to clean code you modify in the same patch if they are 
> not complex, but this is not the case here... Indeed, the headers are 
> not touched. So I would prefer this to be in a separate patch unless 
> it breaks the compilation without it.

Well, will make this change in a separate patch.


>
>
>>
>> Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
>> CC: Julien Grall <julien.grall@arm.com>
>>
>> ---
>> Changes V2 -> V3:
>>      - removed deferred_probe field from struct dt_device_node,
>>        re-used domain_list instead
>>      - documented domain_list usage
>>      - added ASSERT to check that np->domain_list is empty
>>        before re-using it
>>      - put deferred_probe_list to init section
>>      - used more strict logic regarding processing devices in
>>        the deferred list
>>      - added more comments to code
>>      - put headers in alphabetical order
>> ---
>>   xen/drivers/passthrough/arm/iommu.c | 59 
>> ++++++++++++++++++++++++++++++++++---
>>   xen/include/asm-arm/device.h        |  6 +++-
>>   xen/include/xen/device_tree.h       |  7 +++++
>>   3 files changed, 67 insertions(+), 5 deletions(-)
>>
>> diff --git a/xen/drivers/passthrough/arm/iommu.c 
>> b/xen/drivers/passthrough/arm/iommu.c
>> index f219de9..72a30e0 100644
>> --- a/xen/drivers/passthrough/arm/iommu.c
>> +++ b/xen/drivers/passthrough/arm/iommu.c
>> @@ -15,11 +15,20 @@
>>    * GNU General Public License for more details.
>>    */
>>   -#include <xen/lib.h>
>> -#include <xen/iommu.h>
>>   #include <xen/device_tree.h>
>> +#include <xen/iommu.h>
>> +#include <xen/lib.h>
>> +
>>   #include <asm/device.h>
>>   +/*
>> + * Deferred probe list is used to keep track of devices for which 
>> driver
>> + * requested deferred probing (returned -EAGAIN).
>> + *
>> + * We re-use device's domain_list to link the device in the deferred 
>> list.
>> + */
>> +static __initdata LIST_HEAD(deferred_probe_list);
>> +
>>   static const struct iommu_ops *iommu_ops;
>>     const struct iommu_ops *iommu_get_ops(void)
>> @@ -42,7 +51,7 @@ void __init iommu_set_ops(const struct iommu_ops *ops)
>>     int __init iommu_hardware_setup(void)
>>   {
>> -    struct dt_device_node *np;
>> +    struct dt_device_node *np, *tmp;
>>       int rc;
>>       unsigned int num_iommus = 0;
>>   @@ -51,6 +60,17 @@ int __init iommu_hardware_setup(void)
>>           rc = device_init(np, DEVICE_IOMMU, NULL);
>>           if ( !rc )
>>               num_iommus++;
>> +        else if ( rc == -EAGAIN )
>> +        {
>> +            /* We expect nobody uses domain_list at such early 
>> stage. */
>
> AFAICT, this comment is only an English version of the next line. It 
> would be best if you explain why domain_list is re-used here.

Will do.


>
>
>> + ASSERT(list_empty(&np->domain_list));
>> +
>> +            /*
>> +             * Driver requested deferred probing, so add this device to
>> +             * the deferred list for further processing.
>> +             */
>> +            list_add(&np->domain_list, &deferred_probe_list);
>> +        }
>>           /*
>>            * Ignore the following error codes:
>>            *   - EBADF: Indicate the current not is not an IOMMU
>> @@ -61,7 +81,38 @@ int __init iommu_hardware_setup(void)
>>               return rc;
>>       }
>>   -    return ( num_iommus > 0 ) ? 0 : -ENODEV;
>> +    /* Return immediately if there are no initialized devices. */
>> +    if ( !num_iommus )
>> +        return ( list_empty(&deferred_probe_list) ) ? -ENODEV : 
>> -EAGAIN;
>
> NIT: Do you need the outer ()?

No, I don't.


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 6/8] iommu: Add of_xlate callback
  2019-09-09 12:37         ` Julien Grall
@ 2019-09-09 14:28           ` Oleksandr
  0 siblings, 0 replies; 41+ messages in thread
From: Oleksandr @ 2019-09-09 14:28 UTC (permalink / raw)
  To: Julien Grall, Jan Beulich
  Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk, xen-devel


On 09.09.19 15:37, Julien Grall wrote:
> Hi,

Hi, all.


>
>
> On 8/27/19 4:11 PM, Jan Beulich wrote:
>> On 27.08.2019 16:59, Oleksandr wrote:
>>> There was a preference to introduce callback in a separate patch 
>>> [2]. Anyway, shall I fold it?
>>
>> Hmm, I disagree with Julien here. I don't think we should have unused
>> hooks in the tree, not even intermediately.
>
> I have stated my preference before, but this is not a strong one nor a 
> must. If this is your condition to get the series accepted, then 
> Oleksandr should follow your requested.

Will fold it as requested. And will rename callback to "dt_xlate".


>
> Cheers,
>
-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support
  2019-09-02  7:04       ` Yoshihiro Shimoda
@ 2019-09-09 14:33         ` Oleksandr
  0 siblings, 0 replies; 41+ messages in thread
From: Oleksandr @ 2019-09-09 14:33 UTC (permalink / raw)
  To: Yoshihiro Shimoda, xen-devel
  Cc: Oleksandr Tyshchenko, julien.grall, sstabellini, Volodymyr_Babchuk


On 02.09.19 10:04, Yoshihiro Shimoda wrote:
> Hi Oleksandr-san,

Hi, Shimoda-san


>
>> From: Oleksandr, Sent: Thursday, August 29, 2019 7:56 PM
> <snip>
>>> About this hardware handling, this patch seems good to me. But, since
>>> I'm not familiar about Xen passthrough framework, I think I cannot
>>> add my Reviewed-by tag into this patch. What do you think?
>> I am not completely sure regarding that, but I have seen cases when the
>> people give their R-b not for the entire patch, but for a part of it.
>>
>> Especially, when patch touches many sub-systems/archs. Would you mind if
>> I specify what your R-b covers? -> [for the IPMMU H/W bits]
> I got it. When you submit v4 patch, I'll review and send such a tag.

Thank you.


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 5/8] iommu/arm: Add lightweight iommu_fwspec support
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 5/8] iommu/arm: Add lightweight iommu_fwspec support Oleksandr Tyshchenko
@ 2019-09-09 14:36   ` Julien Grall
  2019-09-09 14:41     ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Julien Grall @ 2019-09-09 14:36 UTC (permalink / raw)
  To: Oleksandr Tyshchenko, xen-devel
  Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk

Hi Oleksandr,

On 8/20/19 7:09 PM, Oleksandr Tyshchenko wrote:
> From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
> 
> We need to have some abstract way to add new device to the IOMMU
> based on the generic IOMMU DT bindings [1] which can be used for
> both DT (right now) and ACPI (in future).
> 
> For that reason we can borrow the idea used in Linux these days
> called "iommu_fwspec". Having this in, it will be possible
> to configure IOMMU master interfaces of the device (device IDs)
> from a single common place and avoid keeping almost identical look-up
> implementations in each IOMMU driver.
> 
> There is no need to port the whole implementation of "iommu_fwspec"
> to Xen, we could, probably, end up with a much simpler solution,
> some "stripped down" version which fits our requirements.
> 
> So, this patch adds the following:
> 1. A common structure "iommu_fwspec" to hold the the per-device
>     firmware data
> 2. New member "iommu_fwspec" of struct device
> 3. Functions/helpers to deal with "dev->iommu_fwspec"
> 
> It should be noted that in comparing with original "iommu_fwspec"

s/comparing with/comparison of/
s/original/the Linux/ or "the original".

> Xen's variant doesn't contain some fields, which are not really
> needed at the moment (ops, flag) and "iommu_fwnode" field was replaced
> by "iommu_dev" to avoid porting a lot of code (to support "fwnode_handle")
> with little benefit.


It would be good to mention which version of Linux this is based on. So 
if there is a critical bug in Linux we can port it.

The rest of the patch looks good to me.

Cheers,

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 5/8] iommu/arm: Add lightweight iommu_fwspec support
  2019-09-09 14:36   ` Julien Grall
@ 2019-09-09 14:41     ` Oleksandr
  0 siblings, 0 replies; 41+ messages in thread
From: Oleksandr @ 2019-09-09 14:41 UTC (permalink / raw)
  To: Julien Grall, xen-devel
  Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk


On 09.09.19 17:36, Julien Grall wrote:
> Hi Oleksandr,

Hi, Julien


>
> On 8/20/19 7:09 PM, Oleksandr Tyshchenko wrote:
>> From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
>>
>> We need to have some abstract way to add new device to the IOMMU
>> based on the generic IOMMU DT bindings [1] which can be used for
>> both DT (right now) and ACPI (in future).
>>
>> For that reason we can borrow the idea used in Linux these days
>> called "iommu_fwspec". Having this in, it will be possible
>> to configure IOMMU master interfaces of the device (device IDs)
>> from a single common place and avoid keeping almost identical look-up
>> implementations in each IOMMU driver.
>>
>> There is no need to port the whole implementation of "iommu_fwspec"
>> to Xen, we could, probably, end up with a much simpler solution,
>> some "stripped down" version which fits our requirements.
>>
>> So, this patch adds the following:
>> 1. A common structure "iommu_fwspec" to hold the the per-device
>>     firmware data
>> 2. New member "iommu_fwspec" of struct device
>> 3. Functions/helpers to deal with "dev->iommu_fwspec"
>>
>> It should be noted that in comparing with original "iommu_fwspec"
>
> s/comparing with/comparison of/
> s/original/the Linux/ or "the original".

ok


>
>> Xen's variant doesn't contain some fields, which are not really
>> needed at the moment (ops, flag) and "iommu_fwnode" field was replaced
>> by "iommu_dev" to avoid porting a lot of code (to support 
>> "fwnode_handle")
>> with little benefit.
>
>
> It would be good to mention which version of Linux this is based on. 
> So if there is a critical bug in Linux we can port it.

It was based on current Linux master. I will mention exact version.


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 7/8] iommu/arm: Introduce iommu_add_dt_device API
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 7/8] iommu/arm: Introduce iommu_add_dt_device API Oleksandr Tyshchenko
@ 2019-09-09 15:04   ` Julien Grall
  2019-09-09 15:48     ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Julien Grall @ 2019-09-09 15:04 UTC (permalink / raw)
  To: Oleksandr Tyshchenko, xen-devel
  Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk

Hi Oleksandr,

On 8/20/19 7:09 PM, Oleksandr Tyshchenko wrote:
> From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
> 
> This patch adds new iommu_add_dt_device API for adding DT device
> to the IOMMU using generic IOMMU DT bindings [1] and previously
> added "iommu_fwspec" support and "add_device/of_xlate" callbacks.
> 
> New function does the following:
> - Parse the DT bindings according to the specification
> - Provide DT IOMMU specifier which describes the IOMMU master
>    interfaces of that device (device IDs, etc) to the driver
> - Add master device to the IOMMU if latter is present and available
> 
> The additional benefit here is to avoid to go through the whole DT
> multiple times in IOMMU driver trying to locate master devices which
> belong to each IOMMU device being probed.

So the commit title/message describes the new function 
iommu_add_dt_device, but not the main important thing i.e. "Why is it 
called when building dom0".

While I agree the new function is the big part of the function what 
matter is we need to register device using the generic IOMMU bindings 
before assigning the device to a domain. The split is to keep separate 
"add" and "assign". The later can be called from dom0.

> 
> [1] https://www.kernel.org/doc/Documentation/devicetree/bindings/iommu/iommu.txt
> 
> Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
> CC: Julien Grall <julien.grall@arm.com>
> 
> ---
> Changes V2 -> V3:
>      - clarified patch description
>      - clarified comments in code
>      - modified to provide DT IOMMU specifier to the driver
>        using "of_xlate" callback
>      - documented function usage
>      - modified to return an error if ops is not present/implemented,
>      - added ability to return a possitive value to indicate
>        that device doesn't need to be protected
>      - removed check for the "iommu" property presence
>        in the common code
>      - included <asm/iommu_fwspec.h> directly
> ---
>   xen/arch/arm/domain_build.c         | 11 ++++++++
>   xen/drivers/passthrough/arm/iommu.c | 55 +++++++++++++++++++++++++++++++++++++
>   xen/include/asm-arm/iommu.h         | 11 ++++++++
>   3 files changed, 77 insertions(+)
> 
> diff --git a/xen/arch/arm/domain_build.c b/xen/arch/arm/domain_build.c
> index e79d4e2..159ea6a 100644
> --- a/xen/arch/arm/domain_build.c
> +++ b/xen/arch/arm/domain_build.c
> @@ -1240,6 +1240,7 @@ static int __init map_device_children(struct domain *d,
>   
>   /*
>    * For a given device node:
> + *  - Try to call iommu_add_dt_device to protect the device by an IOMMU
>    *  - Give permission to the guest to manage IRQ and MMIO range
>    *  - Retrieve the IRQ configuration (i.e edge/level) from device tree
>    * When the device is not marked for guest passthrough:
> @@ -1257,6 +1258,16 @@ static int __init handle_device(struct domain *d, struct dt_device_node *dev,
>       u64 addr, size;
>       bool need_mapping = !dt_device_for_passthrough(dev);
>   
> +    dt_dprintk("%s add to iommu\n", dt_node_full_name(dev));

This message is slightly confusing. You are not adding the device, you 
are trying to. So how about "Check if %s is behind an IOMMU and add it".

> +
> +    res = iommu_add_dt_device(dev);
> +    if ( res < 0 )
> +    {
> +        printk(XENLOG_ERR "Failed to add %s to the IOMMU\n",
> +               dt_node_full_name(dev));
> +        return res;
> +    }
> +
>       nirq = dt_number_of_irq(dev);
>       naddr = dt_number_of_address(dev);
>   
> diff --git a/xen/drivers/passthrough/arm/iommu.c b/xen/drivers/passthrough/arm/iommu.c
> index 72a30e0..47e4bc6 100644
> --- a/xen/drivers/passthrough/arm/iommu.c
> +++ b/xen/drivers/passthrough/arm/iommu.c
> @@ -20,6 +20,7 @@
>   #include <xen/lib.h>
>   
>   #include <asm/device.h>
> +#include <asm/iommu_fwspec.h>
>   
>   /*
>    * Deferred probe list is used to keep track of devices for which driver
> @@ -139,3 +140,57 @@ int arch_iommu_populate_page_table(struct domain *d)
>   void __hwdom_init arch_iommu_hwdom_init(struct domain *d)
>   {
>   }
> +
> +int __init iommu_add_dt_device(struct dt_device_node *np)
> +{
> +    const struct iommu_ops *ops = iommu_get_ops();
> +    struct dt_phandle_args iommu_spec;
> +    struct device *dev = dt_to_dev(np);
> +    int rc = 1, index = 0;
> +
> +    if ( !iommu_enabled )
> +        return 1;
> +
> +    if ( !ops || !ops->add_device || !ops->of_xlate )

The SMMU does not implement of_xlate(). It is actually only mandatory if 
you are using the generic bindings. So I would only check ops->of_xlate 
if "iommus" exists.

> +        return -EINVAL;
> +
> +    if ( dev_iommu_fwspec_get(dev) )
> +        return -EEXIST; > +
> +    /* According Documentation/devicetree/bindings/iommu/iommu.txt from Linux */

s/According/According to/

> +    while ( !dt_parse_phandle_with_args(np, "iommus", "#iommu-cells",
> +                                        index, &iommu_spec) )
> +    {
> +        if ( !dt_device_is_available(iommu_spec.np) )
> +            break;
> +
> +        rc = iommu_fwspec_init(dev, &iommu_spec.np->dev);
> +        if ( rc )
> +            break;
> +
> +        /*
> +         * Provide DT IOMMU specifier which describes the IOMMU master
> +         * interfaces of that device (device IDs, etc) to the driver.
> +         * The driver's responsibility is to decide how to interpret them.

NIT: "The driver is responsible to decide...".

> +         * It should also initialize/verify that device.

What do you mean? of_xlate should mostly translate the specifier to fwspec.

> +         */
> +        rc = ops->of_xlate(dev, &iommu_spec);
> +        if ( rc )
> +            break;
> +
> +        index++;
> +    }
> +
> +    /*
> +     * Add master device to the IOMMU if latter is present and available.
> +     * The driver's responsibility is to check whether that device
> +     * was initialized/verified before and mark that device as protected.

I don't understand the last sentence. For me, "device" refers to what's 
pointed by "dev". But the IOMMU driver is not responsible for 
initializing the device.

> +     */
> +    if ( !rc )
> +        rc = ops->add_device(0, dev);
> +
> +    if ( rc < 0 )
> +        iommu_fwspec_free(dev);
> +
> +    return rc;
> +}
> diff --git a/xen/include/asm-arm/iommu.h b/xen/include/asm-arm/iommu.h
> index 20d865e..e75359c 100644
> --- a/xen/include/asm-arm/iommu.h
> +++ b/xen/include/asm-arm/iommu.h
> @@ -26,6 +26,17 @@ struct arch_iommu
>   const struct iommu_ops *iommu_get_ops(void);
>   void iommu_set_ops(const struct iommu_ops *ops);
>   
> +/*
> + * Helper to add master device to the IOMMU using generic IOMMU DT bindings.
> + *
> + * Return values:
> + *  0 : device is protected by an IOMMU
> + * <0 : device is not protected by an IOMMU, but must be (error condition)
> + * >0 : device doesn't need to be protected by an IOMMU
> + *      (IOMMU is not enabled/present or device is not connected to it).
> + */
> +int iommu_add_dt_device(struct dt_device_node *np);
> +
>   /* mapping helpers */
>   int __must_check arm_iommu_map_page(struct domain *d, dfn_t dfn, mfn_t mfn,
>                                       unsigned int flags,
> 

Cheers,

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 7/8] iommu/arm: Introduce iommu_add_dt_device API
  2019-09-09 15:04   ` Julien Grall
@ 2019-09-09 15:48     ` Oleksandr
  2019-09-10 13:34       ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Oleksandr @ 2019-09-09 15:48 UTC (permalink / raw)
  To: Julien Grall, xen-devel
  Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk


On 09.09.19 18:04, Julien Grall wrote:
> Hi Oleksandr,

Hi Julien


>
>
> On 8/20/19 7:09 PM, Oleksandr Tyshchenko wrote:
>> From: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
>>
>> This patch adds new iommu_add_dt_device API for adding DT device
>> to the IOMMU using generic IOMMU DT bindings [1] and previously
>> added "iommu_fwspec" support and "add_device/of_xlate" callbacks.
>>
>> New function does the following:
>> - Parse the DT bindings according to the specification
>> - Provide DT IOMMU specifier which describes the IOMMU master
>>    interfaces of that device (device IDs, etc) to the driver
>> - Add master device to the IOMMU if latter is present and available
>>
>> The additional benefit here is to avoid to go through the whole DT
>> multiple times in IOMMU driver trying to locate master devices which
>> belong to each IOMMU device being probed.
>
> So the commit title/message describes the new function 
> iommu_add_dt_device, but not the main important thing i.e. "Why is it 
> called when building dom0".
>
> While I agree the new function is the big part of the function what 
> matter is we need to register device using the generic IOMMU bindings 
> before assigning the device to a domain. The split is to keep separate 
> "add" and "assign". The later can be called from dom0.

Good point. I will update description.


>
>
>>
>> [1] 
>> https://www.kernel.org/doc/Documentation/devicetree/bindings/iommu/iommu.txt
>>
>> Signed-off-by: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
>> CC: Julien Grall <julien.grall@arm.com>
>>
>> ---
>> Changes V2 -> V3:
>>      - clarified patch description
>>      - clarified comments in code
>>      - modified to provide DT IOMMU specifier to the driver
>>        using "of_xlate" callback
>>      - documented function usage
>>      - modified to return an error if ops is not present/implemented,
>>      - added ability to return a possitive value to indicate
>>        that device doesn't need to be protected
>>      - removed check for the "iommu" property presence
>>        in the common code
>>      - included <asm/iommu_fwspec.h> directly
>> ---
>>   xen/arch/arm/domain_build.c         | 11 ++++++++
>>   xen/drivers/passthrough/arm/iommu.c | 55 
>> +++++++++++++++++++++++++++++++++++++
>>   xen/include/asm-arm/iommu.h         | 11 ++++++++
>>   3 files changed, 77 insertions(+)
>>
>> diff --git a/xen/arch/arm/domain_build.c b/xen/arch/arm/domain_build.c
>> index e79d4e2..159ea6a 100644
>> --- a/xen/arch/arm/domain_build.c
>> +++ b/xen/arch/arm/domain_build.c
>> @@ -1240,6 +1240,7 @@ static int __init map_device_children(struct 
>> domain *d,
>>     /*
>>    * For a given device node:
>> + *  - Try to call iommu_add_dt_device to protect the device by an IOMMU
>>    *  - Give permission to the guest to manage IRQ and MMIO range
>>    *  - Retrieve the IRQ configuration (i.e edge/level) from device tree
>>    * When the device is not marked for guest passthrough:
>> @@ -1257,6 +1258,16 @@ static int __init handle_device(struct domain 
>> *d, struct dt_device_node *dev,
>>       u64 addr, size;
>>       bool need_mapping = !dt_device_for_passthrough(dev);
>>   +    dt_dprintk("%s add to iommu\n", dt_node_full_name(dev));
>
> This message is slightly confusing. You are not adding the device, you 
> are trying to. So how about "Check if %s is behind an IOMMU and add it".

Sounds reasonable.


>
>
>> +
>> +    res = iommu_add_dt_device(dev);
>> +    if ( res < 0 )
>> +    {
>> +        printk(XENLOG_ERR "Failed to add %s to the IOMMU\n",
>> +               dt_node_full_name(dev));
>> +        return res;
>> +    }
>> +
>>       nirq = dt_number_of_irq(dev);
>>       naddr = dt_number_of_address(dev);
>>   diff --git a/xen/drivers/passthrough/arm/iommu.c 
>> b/xen/drivers/passthrough/arm/iommu.c
>> index 72a30e0..47e4bc6 100644
>> --- a/xen/drivers/passthrough/arm/iommu.c
>> +++ b/xen/drivers/passthrough/arm/iommu.c
>> @@ -20,6 +20,7 @@
>>   #include <xen/lib.h>
>>     #include <asm/device.h>
>> +#include <asm/iommu_fwspec.h>
>>     /*
>>    * Deferred probe list is used to keep track of devices for which 
>> driver
>> @@ -139,3 +140,57 @@ int arch_iommu_populate_page_table(struct domain 
>> *d)
>>   void __hwdom_init arch_iommu_hwdom_init(struct domain *d)
>>   {
>>   }
>> +
>> +int __init iommu_add_dt_device(struct dt_device_node *np)
>> +{
>> +    const struct iommu_ops *ops = iommu_get_ops();
>> +    struct dt_phandle_args iommu_spec;
>> +    struct device *dev = dt_to_dev(np);
>> +    int rc = 1, index = 0;
>> +
>> +    if ( !iommu_enabled )
>> +        return 1;
>> +
>> +    if ( !ops || !ops->add_device || !ops->of_xlate )
>
> The SMMU does not implement of_xlate(). It is actually only mandatory 
> if you are using the generic bindings. So I would only check 
> ops->of_xlate if "iommus" exists.

Agree. Will do.


>
>
>> +        return -EINVAL;
>> +
>> +    if ( dev_iommu_fwspec_get(dev) )
>> +        return -EEXIST; > +
>> +    /* According Documentation/devicetree/bindings/iommu/iommu.txt 
>> from Linux */
>
> s/According/According to/

ok


>
>
>> +    while ( !dt_parse_phandle_with_args(np, "iommus", "#iommu-cells",
>> +                                        index, &iommu_spec) )
>> +    {
>> +        if ( !dt_device_is_available(iommu_spec.np) )
>> +            break;
>> +
>> +        rc = iommu_fwspec_init(dev, &iommu_spec.np->dev);
>> +        if ( rc )
>> +            break;
>> +
>> +        /*
>> +         * Provide DT IOMMU specifier which describes the IOMMU master
>> +         * interfaces of that device (device IDs, etc) to the driver.
>> +         * The driver's responsibility is to decide how to interpret 
>> them.
>
> NIT: "The driver is responsible to decide...".

ok


>
>> +         * It should also initialize/verify that device.
>
> What do you mean? of_xlate should mostly translate the specifier to 
> fwspec.

Yes. Saying "initialize/verify that device" I meant to verify passed DT 
IOMMU specifier and initialize driver's private data for this device 
(iommu_priv). But, this is obvious.

I will remove confusing word "initialize" or even the whole sentence.


>
>
>> +         */
>> +        rc = ops->of_xlate(dev, &iommu_spec);
>> +        if ( rc )
>> +            break;
>> +
>> +        index++;
>> +    }
>> +
>> +    /*
>> +     * Add master device to the IOMMU if latter is present and 
>> available.
>> +     * The driver's responsibility is to check whether that device
>> +     * was initialized/verified before and mark that device as 
>> protected.
>
> I don't understand the last sentence. For me, "device" refers to 
> what's pointed by "dev". But the IOMMU driver is not responsible for 
> initializing the device.

Yes. The same as for comment above. I will remove confusing word 
"initialize".


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support
  2019-08-20 18:09 ` [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support Oleksandr Tyshchenko
  2019-08-29  8:37   ` Yoshihiro Shimoda
  2019-08-29 11:19   ` Oleksandr
@ 2019-09-09 21:24   ` Julien Grall
  2019-09-10 11:04     ` Oleksandr
  2 siblings, 1 reply; 41+ messages in thread
From: Julien Grall @ 2019-09-09 21:24 UTC (permalink / raw)
  To: Oleksandr Tyshchenko, xen-devel
  Cc: Oleksandr Tyshchenko, Yoshihiro Shimoda, sstabellini, Volodymyr_Babchuk

Hi Oleksandr,

On 8/20/19 7:09 PM, Oleksandr Tyshchenko wrote:
> diff --git a/xen/arch/arm/platforms/Kconfig b/xen/arch/arm/platforms/Kconfig
> index bc0e9cd..c93a6b2 100644
> --- a/xen/arch/arm/platforms/Kconfig
> +++ b/xen/arch/arm/platforms/Kconfig
> @@ -25,6 +25,7 @@ config RCAR3
>   	bool "Renesas RCar3 support"
>   	depends on ARM_64
>   	select HAS_SCIF
> +	select IPMMU_VMSA

As discussed previously, I think the IPMMU driver should be merged as 
tech preview for a couple of release to allow more users to test before 
we mark it as supported.

Based on this, I would not advise to select IPMMU_VMSA by default as 
user may not want to use tech preview code by default. Instead I would 
only select if EXPERT is set.

>   	---help---
>   	Enable all the required drivers for Renesas RCar3
>   
> diff --git a/xen/drivers/passthrough/Kconfig b/xen/drivers/passthrough/Kconfig
> index a3c0649..47eadb4 100644
> --- a/xen/drivers/passthrough/Kconfig
> +++ b/xen/drivers/passthrough/Kconfig
> @@ -12,4 +12,17 @@ config ARM_SMMU
>   
>   	  Say Y here if your SoC includes an IOMMU device implementing the
>   	  ARM SMMU architecture.
> +
> +config IPMMU_VMSA
> +	bool "Renesas IPMMU-VMSA found in R-Car Gen3 SoCs"
> +	default n
> +	depends on ARM_64
> +	---help---
> +	  Support for implementations of the Renesas IPMMU-VMSA found
> +	  in R-Car Gen3 SoCs.
> +
> +	  Say Y here if you are using newest R-Car Gen3 SoCs revisions
> +	  (H3 ES3.0, M3-W+, etc) which IPMMU hardware supports stage 2
> +	  translation table format and is able to use CPU's P2M table as is.
> +
>   endif

[...]

> +    /* Wait until the Root device has been registered for sure. */
> +    if ( !mmu->root )
> +    {
> +        dev_err(&node->dev, "Root IPMMU hasn't been registered yet\n");

This is a bit odd to throw an error if we are going to defer the probe.

> +        ret = -EAGAIN;
> +        goto out;
> +    }

[...]

> +static __init bool ipmmu_stage2_supported(void)
> +{
> +    struct dt_device_node *np;
> +    uint64_t addr, size;
> +    void __iomem *base;
> +    uint32_t product, cut;
> +    static enum
> +    {
> +        UNKNOWN,
> +        SUPPORTED,
> +        NOTSUPPORTED
> +    } stage2_supported = UNKNOWN;
> +
> +    /* Use the flag to avoid checking for the compatibility more then once. */

There are only one IOMMU root that will always be initialized first. So 
can't you move this code in the root IOMMU path?

> +    switch ( stage2_supported )
> +    {
> +    case SUPPORTED:
> +        return true;
> +
> +    case NOTSUPPORTED:
> +        return false;
> +
> +    case UNKNOWN:
> +    default:
> +        stage2_supported = NOTSUPPORTED;
> +        break;
> +    }
> +
> +    np = dt_find_compatible_node(NULL, NULL, "renesas,prr");
> +    if ( !np )
> +    {
> +        printk(XENLOG_ERR "ipmmu: Failed to find PRR node\n");
> +        return false;
> +    }
> +
> +    if ( dt_device_get_address(np, 0, &addr, &size) )
> +    {
> +        printk(XENLOG_ERR "ipmmu: Failed to get PRR MMIO\n");
> +        return false;
> +    }
> +
> +    base = ioremap_nocache(addr, size);
> +    if ( !base )
> +    {
> +        printk(XENLOG_ERR "ipmmu: Failed to ioremap PRR MMIO\n");
> +        return false;
> +    }
> +
> +    product = readl(base);
> +    cut = product & RCAR_CUT_MASK;
> +    product &= RCAR_PRODUCT_MASK;
> +
> +    switch ( product )
> +    {
> +    case RCAR_PRODUCT_H3:
> +    case RCAR_PRODUCT_M3W:
> +        if ( cut >= RCAR_CUT_VER30 )
> +            stage2_supported = SUPPORTED;
> +        break;
> +
> +    case RCAR_PRODUCT_M3N:
> +        stage2_supported = SUPPORTED;
> +        break;
> +
> +    default:
> +        printk(XENLOG_ERR "ipmmu: Unsupported SoC version\n");
> +        break;
> +    }
> +
> +    iounmap(base);
> +
> +    return stage2_supported == SUPPORTED;
> +}
> +
> +static const struct dt_device_match ipmmu_dt_match[] __initconst =
> +{
> +    DT_MATCH_COMPATIBLE("renesas,ipmmu-r8a7795"),
> +    DT_MATCH_COMPATIBLE("renesas,ipmmu-r8a77965"),
> +    DT_MATCH_COMPATIBLE("renesas,ipmmu-r8a7796"),
> +    { /* sentinel */ },
> +};
> +
> +static __init int ipmmu_init(struct dt_device_node *node, const void *data)
> +{
> +    int ret;
> +
> +    /*
> +     * Even if the device can't be initialized, we don't want to give
> +     * the IPMMU device to dom0.
> +     */
> +    dt_device_set_used_by(node, DOMID_XEN);
> +
> +    if ( !iommu_hap_pt_share )

iommu_hap_pt_share will soon be hardcoded to true on Arm (see [1]). Even 
without the patch, the value of iommu_hap_pt_share should be ignored as 
done by the SMMU.

> +    {
> +        printk_once(XENLOG_ERR "ipmmu: P2M table must always be shared between the CPU and the IPMMU\n");
> +        return -EINVAL;
> +    }
> +
> +    if ( !ipmmu_stage2_supported() )
> +    {
> +        printk_once(XENLOG_ERR "ipmmu: P2M sharing is not supported in current SoC revision\n");
> +        return -ENODEV;

The if part is returning so...

> +    }
> +    else

... the else part is not necessary removing one layer of indentation.

> +    {
> +        /*
> +         * As 4-level translation table is not supported in IPMMU, we need
> +         * to check IPA size used for P2M table beforehand to be sure it is
> +         * 3-level and the IPMMU will be able to use it.
> +         *
> +         * TODO: First initialize the IOMMU and gather the requirements and
> +         * then initialize the P2M. In the P2M code, take into the account
> +         * the IOMMU requirements and restrict "pa_range" if necessary.
> +         */
> +        if ( IPMMU_MAX_P2M_IPA_BITS < p2m_ipa_bits )
> +        {
> +            printk_once(XENLOG_ERR "ipmmu: P2M IPA size is not supported (P2M=%u IPMMU=%u)!\n",
> +                        p2m_ipa_bits, IPMMU_MAX_P2M_IPA_BITS);
> +            return -ENODEV;
> +        }
> +    }
> +
> +    ret = ipmmu_probe(node);
> +    if ( ret )
> +    {
> +        dev_err(&node->dev, "Failed to init IPMMU (%d)\n", ret);
> +        return ret;
> +    }
> +
> +    iommu_set_ops(&ipmmu_iommu_ops);
> +
> +    return 0;
> +}
> +
> +DT_DEVICE_START(ipmmu, "Renesas IPMMU-VMSA", DEVICE_IOMMU)
> +    .dt_match = ipmmu_dt_match,
> +    .init = ipmmu_init,
> +DT_DEVICE_END
> +
> +/*
> + * Local variables:
> + * mode: C
> + * c-file-style: "BSD"
> + * c-basic-offset: 4
> + * indent-tabs-mode: nil
> + * End:
> + */
> 

[1] <20190902145014.36442-6-paul.durrant@citrix.com>

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support
  2019-09-09 21:24   ` Julien Grall
@ 2019-09-10 11:04     ` Oleksandr
  2019-09-10 14:31       ` Julien Grall
  0 siblings, 1 reply; 41+ messages in thread
From: Oleksandr @ 2019-09-10 11:04 UTC (permalink / raw)
  To: Julien Grall, xen-devel
  Cc: Oleksandr Tyshchenko, Yoshihiro Shimoda, sstabellini, Volodymyr_Babchuk


On 10.09.19 00:24, Julien Grall wrote:
> Hi Oleksandr,

Hi Julien


>
> On 8/20/19 7:09 PM, Oleksandr Tyshchenko wrote:
>> diff --git a/xen/arch/arm/platforms/Kconfig 
>> b/xen/arch/arm/platforms/Kconfig
>> index bc0e9cd..c93a6b2 100644
>> --- a/xen/arch/arm/platforms/Kconfig
>> +++ b/xen/arch/arm/platforms/Kconfig
>> @@ -25,6 +25,7 @@ config RCAR3
>>       bool "Renesas RCar3 support"
>>       depends on ARM_64
>>       select HAS_SCIF
>> +    select IPMMU_VMSA
>
> As discussed previously, I think the IPMMU driver should be merged as 
> tech preview for a couple of release to allow more users to test 
> before we mark it as supported.

Yes


>
> Based on this, I would not advise to select IPMMU_VMSA by default as 
> user may not want to use tech preview code by default. Instead I would 
> only select if EXPERT is set.

Agree. Will do.


>
>>       ---help---
>>       Enable all the required drivers for Renesas RCar3
>>   diff --git a/xen/drivers/passthrough/Kconfig 
>> b/xen/drivers/passthrough/Kconfig
>> index a3c0649..47eadb4 100644
>> --- a/xen/drivers/passthrough/Kconfig
>> +++ b/xen/drivers/passthrough/Kconfig
>> @@ -12,4 +12,17 @@ config ARM_SMMU
>>           Say Y here if your SoC includes an IOMMU device 
>> implementing the
>>         ARM SMMU architecture.
>> +
>> +config IPMMU_VMSA
>> +    bool "Renesas IPMMU-VMSA found in R-Car Gen3 SoCs"

Shall I add EXPERT here also?

bool "Renesas IPMMU-VMSA found in R-Car Gen3 SoCs" if EXPERT = "y"


>> +    default n
>> +    depends on ARM_64
>> +    ---help---
>> +      Support for implementations of the Renesas IPMMU-VMSA found
>> +      in R-Car Gen3 SoCs.
>> +
>> +      Say Y here if you are using newest R-Car Gen3 SoCs revisions
>> +      (H3 ES3.0, M3-W+, etc) which IPMMU hardware supports stage 2
>> +      translation table format and is able to use CPU's P2M table as 
>> is.
>> +
>>   endif
>
> [...]
>
>> +    /* Wait until the Root device has been registered for sure. */
>> +    if ( !mmu->root )
>> +    {
>> +        dev_err(&node->dev, "Root IPMMU hasn't been registered yet\n");
>
> This is a bit odd to throw an error if we are going to defer the probe.

Agree. Will remove.


>
>> +static __init bool ipmmu_stage2_supported(void)
>> +{
>> +    struct dt_device_node *np;
>> +    uint64_t addr, size;
>> +    void __iomem *base;
>> +    uint32_t product, cut;
>> +    static enum
>> +    {
>> +        UNKNOWN,
>> +        SUPPORTED,
>> +        NOTSUPPORTED
>> +    } stage2_supported = UNKNOWN;
>> +
>> +    /* Use the flag to avoid checking for the compatibility more 
>> then once. */
>
> There are only one IOMMU root that will always be initialized first. 
> So can't you move this code in the root IOMMU path?

Actually, I can. Good point.


>
>
>> +    switch ( stage2_supported )
>> +    {
>> +    case SUPPORTED:
>> +        return true;
>> +
>> +    case NOTSUPPORTED:
>> +        return false;
>> +
>> +    case UNKNOWN:
>> +    default:
>> +        stage2_supported = NOTSUPPORTED;
>> +        break;
>> +    }
>> +
>> +    np = dt_find_compatible_node(NULL, NULL, "renesas,prr");
>> +    if ( !np )
>> +    {
>> +        printk(XENLOG_ERR "ipmmu: Failed to find PRR node\n");
>> +        return false;
>> +    }
>> +
>> +    if ( dt_device_get_address(np, 0, &addr, &size) )
>> +    {
>> +        printk(XENLOG_ERR "ipmmu: Failed to get PRR MMIO\n");
>> +        return false;
>> +    }
>> +
>> +    base = ioremap_nocache(addr, size);
>> +    if ( !base )
>> +    {
>> +        printk(XENLOG_ERR "ipmmu: Failed to ioremap PRR MMIO\n");
>> +        return false;
>> +    }
>> +
>> +    product = readl(base);
>> +    cut = product & RCAR_CUT_MASK;
>> +    product &= RCAR_PRODUCT_MASK;
>> +
>> +    switch ( product )
>> +    {
>> +    case RCAR_PRODUCT_H3:
>> +    case RCAR_PRODUCT_M3W:
>> +        if ( cut >= RCAR_CUT_VER30 )
>> +            stage2_supported = SUPPORTED;
>> +        break;
>> +
>> +    case RCAR_PRODUCT_M3N:
>> +        stage2_supported = SUPPORTED;
>> +        break;
>> +
>> +    default:
>> +        printk(XENLOG_ERR "ipmmu: Unsupported SoC version\n");
>> +        break;
>> +    }
>> +
>> +    iounmap(base);
>> +
>> +    return stage2_supported == SUPPORTED;
>> +}
>> +
>> +static const struct dt_device_match ipmmu_dt_match[] __initconst =
>> +{
>> +    DT_MATCH_COMPATIBLE("renesas,ipmmu-r8a7795"),
>> +    DT_MATCH_COMPATIBLE("renesas,ipmmu-r8a77965"),
>> +    DT_MATCH_COMPATIBLE("renesas,ipmmu-r8a7796"),
>> +    { /* sentinel */ },
>> +};
>> +
>> +static __init int ipmmu_init(struct dt_device_node *node, const void 
>> *data)
>> +{
>> +    int ret;
>> +
>> +    /*
>> +     * Even if the device can't be initialized, we don't want to give
>> +     * the IPMMU device to dom0.
>> +     */
>> +    dt_device_set_used_by(node, DOMID_XEN);
>> +
>> +    if ( !iommu_hap_pt_share )
>
> iommu_hap_pt_share will soon be hardcoded to true on Arm (see [1]). 
> Even without the patch, the value of iommu_hap_pt_share should be 
> ignored as done by the SMMU.

I got it. Will ignore.


>
>
>> +    {
>> +        printk_once(XENLOG_ERR "ipmmu: P2M table must always be 
>> shared between the CPU and the IPMMU\n");
>> +        return -EINVAL;
>> +    }
>> +
>> +    if ( !ipmmu_stage2_supported() )
>> +    {
>> +        printk_once(XENLOG_ERR "ipmmu: P2M sharing is not supported 
>> in current SoC revision\n");
>> +        return -ENODEV;
>
> The if part is returning so...
>
>> +    }
>> +    else
>
> ... the else part is not necessary removing one layer of indentation.

ok


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 7/8] iommu/arm: Introduce iommu_add_dt_device API
  2019-09-09 15:48     ` Oleksandr
@ 2019-09-10 13:34       ` Oleksandr
  2019-09-10 14:30         ` Julien Grall
  0 siblings, 1 reply; 41+ messages in thread
From: Oleksandr @ 2019-09-10 13:34 UTC (permalink / raw)
  To: Julien Grall, xen-devel
  Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk


Hi, Julien


>
>>>   diff --git a/xen/drivers/passthrough/arm/iommu.c 
>>> b/xen/drivers/passthrough/arm/iommu.c
>>> index 72a30e0..47e4bc6 100644
>>> --- a/xen/drivers/passthrough/arm/iommu.c
>>> +++ b/xen/drivers/passthrough/arm/iommu.c
>>> @@ -20,6 +20,7 @@
>>>   #include <xen/lib.h>
>>>     #include <asm/device.h>
>>> +#include <asm/iommu_fwspec.h>
>>>     /*
>>>    * Deferred probe list is used to keep track of devices for which 
>>> driver
>>> @@ -139,3 +140,57 @@ int arch_iommu_populate_page_table(struct 
>>> domain *d)
>>>   void __hwdom_init arch_iommu_hwdom_init(struct domain *d)
>>>   {
>>>   }
>>> +
>>> +int __init iommu_add_dt_device(struct dt_device_node *np)
>>> +{
>>> +    const struct iommu_ops *ops = iommu_get_ops();
>>> +    struct dt_phandle_args iommu_spec;
>>> +    struct device *dev = dt_to_dev(np);
>>> +    int rc = 1, index = 0;
>>> +
>>> +    if ( !iommu_enabled )
>>> +        return 1;
>>> +
>>> +    if ( !ops || !ops->add_device || !ops->of_xlate )
>>
>> The SMMU does not implement of_xlate(). It is actually only mandatory 
>> if you are using the generic bindings. So I would only check 
>> ops->of_xlate if "iommus" exists.
>
> Agree. Will do.


Just to clarify.

What about "ops->add_device", shall I check it if "iommus" exists as well?

-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 7/8] iommu/arm: Introduce iommu_add_dt_device API
  2019-09-10 13:34       ` Oleksandr
@ 2019-09-10 14:30         ` Julien Grall
  0 siblings, 0 replies; 41+ messages in thread
From: Julien Grall @ 2019-09-10 14:30 UTC (permalink / raw)
  To: Oleksandr, xen-devel; +Cc: Oleksandr Tyshchenko, sstabellini, Volodymyr_Babchuk

On 9/10/19 2:34 PM, Oleksandr wrote:
> 
> Hi, Julien

Hi,

>>
>>>>   diff --git a/xen/drivers/passthrough/arm/iommu.c 
>>>> b/xen/drivers/passthrough/arm/iommu.c
>>>> index 72a30e0..47e4bc6 100644
>>>> --- a/xen/drivers/passthrough/arm/iommu.c
>>>> +++ b/xen/drivers/passthrough/arm/iommu.c
>>>> @@ -20,6 +20,7 @@
>>>>   #include <xen/lib.h>
>>>>     #include <asm/device.h>
>>>> +#include <asm/iommu_fwspec.h>
>>>>     /*
>>>>    * Deferred probe list is used to keep track of devices for which 
>>>> driver
>>>> @@ -139,3 +140,57 @@ int arch_iommu_populate_page_table(struct 
>>>> domain *d)
>>>>   void __hwdom_init arch_iommu_hwdom_init(struct domain *d)
>>>>   {
>>>>   }
>>>> +
>>>> +int __init iommu_add_dt_device(struct dt_device_node *np)
>>>> +{
>>>> +    const struct iommu_ops *ops = iommu_get_ops();
>>>> +    struct dt_phandle_args iommu_spec;
>>>> +    struct device *dev = dt_to_dev(np);
>>>> +    int rc = 1, index = 0;
>>>> +
>>>> +    if ( !iommu_enabled )
>>>> +        return 1;
>>>> +
>>>> +    if ( !ops || !ops->add_device || !ops->of_xlate )
>>>
>>> The SMMU does not implement of_xlate(). It is actually only mandatory 
>>> if you are using the generic bindings. So I would only check 
>>> ops->of_xlate if "iommus" exists.
>>
>> Agree. Will do.
> 
> 
> Just to clarify.
> 
> What about "ops->add_device", shall I check it if "iommus" exists as well?

Yes. Somehow I thought add_device was implemented for the SMMU driver, 
but I got confused with the Linux IOMMU ops.

Cheers,

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support
  2019-09-10 11:04     ` Oleksandr
@ 2019-09-10 14:31       ` Julien Grall
  2019-09-11 15:29         ` Oleksandr
  0 siblings, 1 reply; 41+ messages in thread
From: Julien Grall @ 2019-09-10 14:31 UTC (permalink / raw)
  To: Oleksandr, xen-devel
  Cc: Oleksandr Tyshchenko, Yoshihiro Shimoda, sstabellini, Volodymyr_Babchuk

Hi,

On 9/10/19 12:04 PM, Oleksandr wrote:
> On 10.09.19 00:24, Julien Grall wrote:
>>>       ---help---
>>>       Enable all the required drivers for Renesas RCar3
>>>   diff --git a/xen/drivers/passthrough/Kconfig 
>>> b/xen/drivers/passthrough/Kconfig
>>> index a3c0649..47eadb4 100644
>>> --- a/xen/drivers/passthrough/Kconfig
>>> +++ b/xen/drivers/passthrough/Kconfig
>>> @@ -12,4 +12,17 @@ config ARM_SMMU
>>>           Say Y here if your SoC includes an IOMMU device 
>>> implementing the
>>>         ARM SMMU architecture.
>>> +
>>> +config IPMMU_VMSA
>>> +    bool "Renesas IPMMU-VMSA found in R-Car Gen3 SoCs"
> 
> Shall I add EXPERT here also?

Good question. Probably, but then I am wondering if the EXPERT = "y" 
would actually be sufficient.

Cheers,

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

* Re: [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support
  2019-09-10 14:31       ` Julien Grall
@ 2019-09-11 15:29         ` Oleksandr
  0 siblings, 0 replies; 41+ messages in thread
From: Oleksandr @ 2019-09-11 15:29 UTC (permalink / raw)
  To: Julien Grall, xen-devel
  Cc: Oleksandr Tyshchenko, Yoshihiro Shimoda, sstabellini, Volodymyr_Babchuk


On 10.09.19 17:31, Julien Grall wrote:
> Hi,

Hi Julien


>
> On 9/10/19 12:04 PM, Oleksandr wrote:
>> On 10.09.19 00:24, Julien Grall wrote:
>>>>       ---help---
>>>>       Enable all the required drivers for Renesas RCar3
>>>>   diff --git a/xen/drivers/passthrough/Kconfig 
>>>> b/xen/drivers/passthrough/Kconfig
>>>> index a3c0649..47eadb4 100644
>>>> --- a/xen/drivers/passthrough/Kconfig
>>>> +++ b/xen/drivers/passthrough/Kconfig
>>>> @@ -12,4 +12,17 @@ config ARM_SMMU
>>>>           Say Y here if your SoC includes an IOMMU device 
>>>> implementing the
>>>>         ARM SMMU architecture.
>>>> +
>>>> +config IPMMU_VMSA
>>>> +    bool "Renesas IPMMU-VMSA found in R-Car Gen3 SoCs"
>>
>> Shall I add EXPERT here also?
>
> Good question. Probably, but then I am wondering if the EXPERT = "y" 
> would actually be sufficient.

Should be in both places, here and where you pointed (config RCAR3).


-- 
Regards,

Oleksandr Tyshchenko


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

^ permalink raw reply	[flat|nested] 41+ messages in thread

end of thread, back to index

Thread overview: 41+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-08-20 18:09 [Xen-devel] [PATCH V3 0/8] iommu/arm: Add Renesas IPMMU-VMSA support + Linux's iommu_fwspec Oleksandr Tyshchenko
2019-08-20 18:09 ` [Xen-devel] [PATCH V3 1/8] iommu/arm: Add iommu_helpers.c file to keep common for IOMMUs stuff Oleksandr Tyshchenko
2019-09-09 11:45   ` Julien Grall
2019-09-09 14:12     ` Oleksandr
2019-08-20 18:09 ` [Xen-devel] [PATCH V3 2/8] iommu/arm: Add ability to handle deferred probing request Oleksandr Tyshchenko
2019-09-09 12:24   ` Julien Grall
2019-09-09 14:19     ` Oleksandr
2019-08-20 18:09 ` [Xen-devel] [PATCH V3 3/8] xen/common: Introduce _xrealloc function Oleksandr Tyshchenko
2019-08-21  8:09   ` Paul Durrant
2019-08-21 14:36     ` Oleksandr
2019-08-21 15:47       ` Paul Durrant
2019-08-21 17:04         ` Oleksandr
2019-08-20 18:09 ` [Xen-devel] [PATCH V3 4/8] xen/common: Introduce xrealloc_flex_struct() helper macros Oleksandr Tyshchenko
2019-08-27 13:28   ` Jan Beulich
2019-08-28 18:23     ` Oleksandr
2019-08-29  7:21       ` Jan Beulich
2019-08-29 19:04         ` Oleksandr
2019-08-20 18:09 ` [Xen-devel] [PATCH V3 5/8] iommu/arm: Add lightweight iommu_fwspec support Oleksandr Tyshchenko
2019-09-09 14:36   ` Julien Grall
2019-09-09 14:41     ` Oleksandr
2019-08-20 18:09 ` [Xen-devel] [PATCH V3 6/8] iommu: Add of_xlate callback Oleksandr Tyshchenko
2019-08-27 13:30   ` Jan Beulich
2019-08-27 14:59     ` Oleksandr
2019-08-27 15:11       ` Jan Beulich
2019-09-09 12:37         ` Julien Grall
2019-09-09 14:28           ` Oleksandr
2019-08-20 18:09 ` [Xen-devel] [PATCH V3 7/8] iommu/arm: Introduce iommu_add_dt_device API Oleksandr Tyshchenko
2019-09-09 15:04   ` Julien Grall
2019-09-09 15:48     ` Oleksandr
2019-09-10 13:34       ` Oleksandr
2019-09-10 14:30         ` Julien Grall
2019-08-20 18:09 ` [Xen-devel] [PATCH V3 8/8] iommu/arm: Add Renesas IPMMU-VMSA support Oleksandr Tyshchenko
2019-08-29  8:37   ` Yoshihiro Shimoda
2019-08-29 10:56     ` Oleksandr
2019-09-02  7:04       ` Yoshihiro Shimoda
2019-09-09 14:33         ` Oleksandr
2019-08-29 11:19   ` Oleksandr
2019-09-09 21:24   ` Julien Grall
2019-09-10 11:04     ` Oleksandr
2019-09-10 14:31       ` Julien Grall
2019-09-11 15:29         ` Oleksandr

Xen-Devel Archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/xen-devel/0 xen-devel/git/0.git
	git clone --mirror https://lore.kernel.org/xen-devel/1 xen-devel/git/1.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 xen-devel xen-devel/ https://lore.kernel.org/xen-devel \
		xen-devel@lists.xenproject.org xen-devel@archiver.kernel.org
	public-inbox-index xen-devel


Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.xenproject.lists.xen-devel


AGPL code for this site: git clone https://public-inbox.org/ public-inbox