* [RFC PATCH v2 0/7] iommu: Permit modular builds of io-pgtable drivers @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, joro, pdaly, pratikp, kernel-team, robin.murphy The goal of the Generic Kernel Image (GKI) effort is to have a common kernel image that works across multiple Android devices. This involves generating a kernel image that has core features integrated into it, while SoC specific functionality can be added to the kernel for the device as a module. Along with modularizing IOMMU drivers, this also means building the io-pgtable code as modules, which allows for SoC vendors to only include the io-pgtable implementations that they use. For example, GKI for arm64 must include support for both the IOMMU ARM LPAE/V7S formats at the moment. Having the code for both formats as modules allows SoC vendors to only provide the page table format that they use, along with their IOMMU driver. Main changes since v1: 1) Retain io-pgtable.c as part of the core kernel The patches are split into 4 parts: 1) Modularizing io-pgtable-arm[-v7s].c, while leaving the io-pgtable.c code as part of the core kernel, requires removing the references to the ARM LPAE and ARM V7S io-pgtable init functions, and using a dynamic method for formats to register their io-pgtable init functions. The reason for defining an io_pgtable_init_fns_node structure is to not have the data structures used to store the init functions seep into the io-pgtable fmt drivers. Doing so allows for changing the internal data structure used to keep track of the init functions, without impacting the client data structures. 2) Taking references to the io-pgtable format drivers to ensure that they cannot be unloaded while in use. 3) Adding pre MODULE_SOFTDEP() dependencies to drivers in the kernel that are tristate, and invoke [alloc/free]_io_pgtable_ops(). This makes it so that the io-pgtable format drivers are loaded before the driver that needs them. 4) Changing the Kconfig options for the ARM LPAE nad ARM V7S to tristate. Thanks in advance for the feedback, Isaac J. Manjarres Isaac J. Manjarres (7): iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration iommu/io-pgtable: Add refcounting for io-pgtable format modules iommu/arm-smmu: Add dependency on io-pgtable format modules iommu/arm-smmu-v3: Add dependency on io-pgtable-arm format module drm/msm: Add dependency on io-pgtable-arm format module drm/panfrost: Add dependency on io-pgtable-arm format module iommu/io-pgtable-arm: Allow building modular io-pgtable fmts drivers/gpu/drm/msm/msm_drv.c | 1 + drivers/gpu/drm/panfrost/panfrost_drv.c | 1 + drivers/iommu/Kconfig | 4 +- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 1 + drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + drivers/iommu/io-pgtable-arm-v7s.c | 37 +++++++++- drivers/iommu/io-pgtable-arm.c | 97 +++++++++++++++++++------- drivers/iommu/io-pgtable.c | 104 +++++++++++++++++++++++----- include/linux/io-pgtable.h | 53 +++++++++----- 9 files changed, 236 insertions(+), 63 deletions(-) -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project ^ permalink raw reply [flat|nested] 73+ messages in thread
* [RFC PATCH v2 0/7] iommu: Permit modular builds of io-pgtable drivers @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, joro, robin.murphy, pratikp The goal of the Generic Kernel Image (GKI) effort is to have a common kernel image that works across multiple Android devices. This involves generating a kernel image that has core features integrated into it, while SoC specific functionality can be added to the kernel for the device as a module. Along with modularizing IOMMU drivers, this also means building the io-pgtable code as modules, which allows for SoC vendors to only include the io-pgtable implementations that they use. For example, GKI for arm64 must include support for both the IOMMU ARM LPAE/V7S formats at the moment. Having the code for both formats as modules allows SoC vendors to only provide the page table format that they use, along with their IOMMU driver. Main changes since v1: 1) Retain io-pgtable.c as part of the core kernel The patches are split into 4 parts: 1) Modularizing io-pgtable-arm[-v7s].c, while leaving the io-pgtable.c code as part of the core kernel, requires removing the references to the ARM LPAE and ARM V7S io-pgtable init functions, and using a dynamic method for formats to register their io-pgtable init functions. The reason for defining an io_pgtable_init_fns_node structure is to not have the data structures used to store the init functions seep into the io-pgtable fmt drivers. Doing so allows for changing the internal data structure used to keep track of the init functions, without impacting the client data structures. 2) Taking references to the io-pgtable format drivers to ensure that they cannot be unloaded while in use. 3) Adding pre MODULE_SOFTDEP() dependencies to drivers in the kernel that are tristate, and invoke [alloc/free]_io_pgtable_ops(). This makes it so that the io-pgtable format drivers are loaded before the driver that needs them. 4) Changing the Kconfig options for the ARM LPAE nad ARM V7S to tristate. Thanks in advance for the feedback, Isaac J. Manjarres Isaac J. Manjarres (7): iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration iommu/io-pgtable: Add refcounting for io-pgtable format modules iommu/arm-smmu: Add dependency on io-pgtable format modules iommu/arm-smmu-v3: Add dependency on io-pgtable-arm format module drm/msm: Add dependency on io-pgtable-arm format module drm/panfrost: Add dependency on io-pgtable-arm format module iommu/io-pgtable-arm: Allow building modular io-pgtable fmts drivers/gpu/drm/msm/msm_drv.c | 1 + drivers/gpu/drm/panfrost/panfrost_drv.c | 1 + drivers/iommu/Kconfig | 4 +- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 1 + drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + drivers/iommu/io-pgtable-arm-v7s.c | 37 +++++++++- drivers/iommu/io-pgtable-arm.c | 97 +++++++++++++++++++------- drivers/iommu/io-pgtable.c | 104 +++++++++++++++++++++++----- include/linux/io-pgtable.h | 53 +++++++++----- 9 files changed, 236 insertions(+), 63 deletions(-) -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* [RFC PATCH v2 0/7] iommu: Permit modular builds of io-pgtable drivers @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, robin.murphy, pratikp The goal of the Generic Kernel Image (GKI) effort is to have a common kernel image that works across multiple Android devices. This involves generating a kernel image that has core features integrated into it, while SoC specific functionality can be added to the kernel for the device as a module. Along with modularizing IOMMU drivers, this also means building the io-pgtable code as modules, which allows for SoC vendors to only include the io-pgtable implementations that they use. For example, GKI for arm64 must include support for both the IOMMU ARM LPAE/V7S formats at the moment. Having the code for both formats as modules allows SoC vendors to only provide the page table format that they use, along with their IOMMU driver. Main changes since v1: 1) Retain io-pgtable.c as part of the core kernel The patches are split into 4 parts: 1) Modularizing io-pgtable-arm[-v7s].c, while leaving the io-pgtable.c code as part of the core kernel, requires removing the references to the ARM LPAE and ARM V7S io-pgtable init functions, and using a dynamic method for formats to register their io-pgtable init functions. The reason for defining an io_pgtable_init_fns_node structure is to not have the data structures used to store the init functions seep into the io-pgtable fmt drivers. Doing so allows for changing the internal data structure used to keep track of the init functions, without impacting the client data structures. 2) Taking references to the io-pgtable format drivers to ensure that they cannot be unloaded while in use. 3) Adding pre MODULE_SOFTDEP() dependencies to drivers in the kernel that are tristate, and invoke [alloc/free]_io_pgtable_ops(). This makes it so that the io-pgtable format drivers are loaded before the driver that needs them. 4) Changing the Kconfig options for the ARM LPAE nad ARM V7S to tristate. Thanks in advance for the feedback, Isaac J. Manjarres Isaac J. Manjarres (7): iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration iommu/io-pgtable: Add refcounting for io-pgtable format modules iommu/arm-smmu: Add dependency on io-pgtable format modules iommu/arm-smmu-v3: Add dependency on io-pgtable-arm format module drm/msm: Add dependency on io-pgtable-arm format module drm/panfrost: Add dependency on io-pgtable-arm format module iommu/io-pgtable-arm: Allow building modular io-pgtable fmts drivers/gpu/drm/msm/msm_drv.c | 1 + drivers/gpu/drm/panfrost/panfrost_drv.c | 1 + drivers/iommu/Kconfig | 4 +- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 1 + drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + drivers/iommu/io-pgtable-arm-v7s.c | 37 +++++++++- drivers/iommu/io-pgtable-arm.c | 97 +++++++++++++++++++------- drivers/iommu/io-pgtable.c | 104 +++++++++++++++++++++++----- include/linux/io-pgtable.h | 53 +++++++++----- 9 files changed, 236 insertions(+), 63 deletions(-) -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration 2020-12-22 0:44 ` Isaac J. Manjarres (?) @ 2020-12-22 0:44 ` Isaac J. Manjarres -1 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, joro, pdaly, pratikp, kernel-team, robin.murphy The io-pgtable code constructs an array of init functions for each page table format at compile time. This is not ideal, as this increases the footprint of the io-pgtable code, as well as prevents io-pgtable formats from being built as kernel modules. In preparation for modularizing the io-pgtable formats, switch to a dynamic registration scheme, where each io-pgtable format can register their init functions with the io-pgtable code at boot or module insertion time. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- drivers/iommu/io-pgtable-arm.c | 90 ++++++++++++++++++++++++++---------- drivers/iommu/io-pgtable.c | 94 ++++++++++++++++++++++++++++++++------ include/linux/io-pgtable.h | 51 +++++++++++++-------- 4 files changed, 209 insertions(+), 60 deletions(-) diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c index 1d92ac9..89aad2f 100644 --- a/drivers/iommu/io-pgtable-arm-v7s.c +++ b/drivers/iommu/io-pgtable-arm-v7s.c @@ -28,6 +28,7 @@ #include <linux/iommu.h> #include <linux/kernel.h> #include <linux/kmemleak.h> +#include <linux/module.h> #include <linux/sizes.h> #include <linux/slab.h> #include <linux/spinlock.h> @@ -835,7 +836,8 @@ static struct io_pgtable *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, return NULL; } -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { + .fmt = ARM_V7S, .alloc = arm_v7s_alloc_pgtable, .free = arm_v7s_free_pgtable, }; @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) pr_info("self test ok\n"); return 0; } -subsys_initcall(arm_v7s_do_selftests); +#else +static int arm_v7s_do_selftests(void) +{ + return 0; +} #endif + +static int __init arm_v7s_init(void) +{ + int ret; + + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); + if (ret < 0) { + pr_err("Failed to register ARM V7S format\n"); + return ret; + } + + ret = arm_v7s_do_selftests(); + if (ret < 0) + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); + + return ret; +} +core_initcall(arm_v7s_init); + +static void __exit arm_v7s_exit(void) +{ + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); +} +module_exit(arm_v7s_exit); diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c index 87def58..ff0ea2f 100644 --- a/drivers/iommu/io-pgtable-arm.c +++ b/drivers/iommu/io-pgtable-arm.c @@ -13,6 +13,7 @@ #include <linux/bitops.h> #include <linux/io-pgtable.h> #include <linux/kernel.h> +#include <linux/module.h> #include <linux/sizes.h> #include <linux/slab.h> #include <linux/types.h> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct io_pgtable_cfg *cfg, void *cookie) return NULL; } -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { - .alloc = arm_64_lpae_alloc_pgtable_s1, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { - .alloc = arm_64_lpae_alloc_pgtable_s2, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { - .alloc = arm_32_lpae_alloc_pgtable_s1, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { - .alloc = arm_32_lpae_alloc_pgtable_s2, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { - .alloc = arm_mali_lpae_alloc_pgtable, - .free = arm_lpae_free_pgtable, +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { + { + .fmt = ARM_32_LPAE_S1, + .alloc = arm_32_lpae_alloc_pgtable_s1, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_32_LPAE_S2, + .alloc = arm_32_lpae_alloc_pgtable_s2, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_64_LPAE_S1, + .alloc = arm_64_lpae_alloc_pgtable_s1, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_64_LPAE_S2, + .alloc = arm_64_lpae_alloc_pgtable_s2, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_MALI_LPAE, + .alloc = arm_mali_lpae_alloc_pgtable, + .free = arm_lpae_free_pgtable, + }, }; #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); return fail ? -EFAULT : 0; } -subsys_initcall(arm_lpae_do_selftests); +#else +static int __init arm_lpae_do_selftests(void) +{ + return 0; +} #endif + +static int __init arm_lpae_init(void) +{ + int ret, i; + + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); + if (ret < 0) { + pr_err("Failed to register ARM LPAE fmt: %d\n"); + goto err_io_pgtable_register; + } + } + + ret = arm_lpae_do_selftests(); + if (ret < 0) + goto err_io_pgtable_register; + + return 0; + +err_io_pgtable_register: + for (i = i - 1; i >= 0; i--) + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); + return ret; +} +core_initcall(arm_lpae_init); + +static void __exit arm_lpae_exit(void) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); +} +module_exit(arm_lpae_exit); diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c index 94394c8..2c6eb2e 100644 --- a/drivers/iommu/io-pgtable.c +++ b/drivers/iommu/io-pgtable.c @@ -10,33 +10,45 @@ #include <linux/bug.h> #include <linux/io-pgtable.h> #include <linux/kernel.h> +#include <linux/rwlock.h> +#include <linux/slab.h> #include <linux/types.h> -static const struct io_pgtable_init_fns * -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, -#endif -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, -#endif +struct io_pgtable_init_fns_node { + struct io_pgtable_init_fns *fns; + struct list_head list; }; +static LIST_HEAD(io_pgtable_init_fns_list); +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); + +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum io_pgtable_fmt fmt) +{ + struct io_pgtable_init_fns_node *iter; + struct io_pgtable_init_fns *fns = NULL; + + read_lock(&io_pgtable_init_fns_list_lock); + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) + if (iter->fns->fmt == fmt) { + fns = iter->fns; + break; + } + read_unlock(&io_pgtable_init_fns_list_lock); + + return fns; +} + struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, struct io_pgtable_cfg *cfg, void *cookie) { struct io_pgtable *iop; - const struct io_pgtable_init_fns *fns; + struct io_pgtable_init_fns *fns; if (fmt >= IO_PGTABLE_NUM_FMTS) return NULL; - fns = io_pgtable_init_table[fmt]; + fns = io_pgtable_get_init_fns(fmt); if (!fns) return NULL; @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); void free_io_pgtable_ops(struct io_pgtable_ops *ops) { struct io_pgtable *iop; + struct io_pgtable_init_fns *fns; if (!ops) return; iop = io_pgtable_ops_to_pgtable(ops); io_pgtable_tlb_flush_all(iop); - io_pgtable_init_table[iop->fmt]->free(iop); + fns = io_pgtable_get_init_fns(iop->fmt); + if (fns) + fns->free(iop); } EXPORT_SYMBOL_GPL(free_io_pgtable_ops); + +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) +{ + struct io_pgtable_init_fns_node *iter, *fns_node; + int ret = 0; + + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || + !init_fns->alloc || !init_fns->free) + return -EINVAL; + + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); + if (!fns_node) + return -ENOMEM; + + write_lock(&io_pgtable_init_fns_list_lock); + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) + if (iter->fns->fmt == init_fns->fmt) { + ret = -EEXIST; + kfree(fns_node); + break; + } + + if (!ret) { + fns_node->fns = init_fns; + INIT_LIST_HEAD(&fns_node->list); + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); + } + write_unlock(&io_pgtable_init_fns_list_lock); + return ret; +} +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); + +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) +{ + struct io_pgtable_init_fns_node *iter, *tmp; + + if (!init_fns) + return; + + write_lock(&io_pgtable_init_fns_list_lock); + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, list) + if (iter->fns == init_fns) { + list_del(&iter->list); + kfree(iter); + break; + } + write_unlock(&io_pgtable_init_fns_list_lock); +} +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h index ea727eb..45b367ce 100644 --- a/include/linux/io-pgtable.h +++ b/include/linux/io-pgtable.h @@ -163,6 +163,38 @@ struct io_pgtable_ops { }; /** + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a + * particular format. + * + * @fmt: The page table format. + * @alloc: Allocate a set of page tables described by cfg. + * @free: Free the page tables associated with iop. + */ +struct io_pgtable_init_fns { + enum io_pgtable_fmt fmt; + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); + void (*free)(struct io_pgtable *iop); +}; + +/** + * io_pgtable_ops_register() - Register the page table routines for a page table + * format. + * + * @init_fns: The functions for allocating and freeing the page tables of + * a particular format. + */ +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); + +/** + * io_pgtable_ops_unregister() - Unregister the page table routines for a page + * table format. + * + * @init_fns: The functions for allocating and freeing the page tables of + * a particular format. + */ +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); + +/** * alloc_io_pgtable_ops() - Allocate a page table allocator for use by an IOMMU. * * @fmt: The page table format. @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, iop->cfg.tlb->tlb_add_page(gather, iova, granule, iop->cookie); } -/** - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a - * particular format. - * - * @alloc: Allocate a set of page tables described by cfg. - * @free: Free the page tables associated with iop. - */ -struct io_pgtable_init_fns { - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); - void (*free)(struct io_pgtable *iop); -}; - -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; - #endif /* __IO_PGTABLE_H */ -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, joro, robin.murphy, pratikp The io-pgtable code constructs an array of init functions for each page table format at compile time. This is not ideal, as this increases the footprint of the io-pgtable code, as well as prevents io-pgtable formats from being built as kernel modules. In preparation for modularizing the io-pgtable formats, switch to a dynamic registration scheme, where each io-pgtable format can register their init functions with the io-pgtable code at boot or module insertion time. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- drivers/iommu/io-pgtable-arm.c | 90 ++++++++++++++++++++++++++---------- drivers/iommu/io-pgtable.c | 94 ++++++++++++++++++++++++++++++++------ include/linux/io-pgtable.h | 51 +++++++++++++-------- 4 files changed, 209 insertions(+), 60 deletions(-) diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c index 1d92ac9..89aad2f 100644 --- a/drivers/iommu/io-pgtable-arm-v7s.c +++ b/drivers/iommu/io-pgtable-arm-v7s.c @@ -28,6 +28,7 @@ #include <linux/iommu.h> #include <linux/kernel.h> #include <linux/kmemleak.h> +#include <linux/module.h> #include <linux/sizes.h> #include <linux/slab.h> #include <linux/spinlock.h> @@ -835,7 +836,8 @@ static struct io_pgtable *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, return NULL; } -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { + .fmt = ARM_V7S, .alloc = arm_v7s_alloc_pgtable, .free = arm_v7s_free_pgtable, }; @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) pr_info("self test ok\n"); return 0; } -subsys_initcall(arm_v7s_do_selftests); +#else +static int arm_v7s_do_selftests(void) +{ + return 0; +} #endif + +static int __init arm_v7s_init(void) +{ + int ret; + + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); + if (ret < 0) { + pr_err("Failed to register ARM V7S format\n"); + return ret; + } + + ret = arm_v7s_do_selftests(); + if (ret < 0) + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); + + return ret; +} +core_initcall(arm_v7s_init); + +static void __exit arm_v7s_exit(void) +{ + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); +} +module_exit(arm_v7s_exit); diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c index 87def58..ff0ea2f 100644 --- a/drivers/iommu/io-pgtable-arm.c +++ b/drivers/iommu/io-pgtable-arm.c @@ -13,6 +13,7 @@ #include <linux/bitops.h> #include <linux/io-pgtable.h> #include <linux/kernel.h> +#include <linux/module.h> #include <linux/sizes.h> #include <linux/slab.h> #include <linux/types.h> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct io_pgtable_cfg *cfg, void *cookie) return NULL; } -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { - .alloc = arm_64_lpae_alloc_pgtable_s1, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { - .alloc = arm_64_lpae_alloc_pgtable_s2, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { - .alloc = arm_32_lpae_alloc_pgtable_s1, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { - .alloc = arm_32_lpae_alloc_pgtable_s2, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { - .alloc = arm_mali_lpae_alloc_pgtable, - .free = arm_lpae_free_pgtable, +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { + { + .fmt = ARM_32_LPAE_S1, + .alloc = arm_32_lpae_alloc_pgtable_s1, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_32_LPAE_S2, + .alloc = arm_32_lpae_alloc_pgtable_s2, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_64_LPAE_S1, + .alloc = arm_64_lpae_alloc_pgtable_s1, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_64_LPAE_S2, + .alloc = arm_64_lpae_alloc_pgtable_s2, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_MALI_LPAE, + .alloc = arm_mali_lpae_alloc_pgtable, + .free = arm_lpae_free_pgtable, + }, }; #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); return fail ? -EFAULT : 0; } -subsys_initcall(arm_lpae_do_selftests); +#else +static int __init arm_lpae_do_selftests(void) +{ + return 0; +} #endif + +static int __init arm_lpae_init(void) +{ + int ret, i; + + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); + if (ret < 0) { + pr_err("Failed to register ARM LPAE fmt: %d\n"); + goto err_io_pgtable_register; + } + } + + ret = arm_lpae_do_selftests(); + if (ret < 0) + goto err_io_pgtable_register; + + return 0; + +err_io_pgtable_register: + for (i = i - 1; i >= 0; i--) + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); + return ret; +} +core_initcall(arm_lpae_init); + +static void __exit arm_lpae_exit(void) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); +} +module_exit(arm_lpae_exit); diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c index 94394c8..2c6eb2e 100644 --- a/drivers/iommu/io-pgtable.c +++ b/drivers/iommu/io-pgtable.c @@ -10,33 +10,45 @@ #include <linux/bug.h> #include <linux/io-pgtable.h> #include <linux/kernel.h> +#include <linux/rwlock.h> +#include <linux/slab.h> #include <linux/types.h> -static const struct io_pgtable_init_fns * -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, -#endif -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, -#endif +struct io_pgtable_init_fns_node { + struct io_pgtable_init_fns *fns; + struct list_head list; }; +static LIST_HEAD(io_pgtable_init_fns_list); +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); + +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum io_pgtable_fmt fmt) +{ + struct io_pgtable_init_fns_node *iter; + struct io_pgtable_init_fns *fns = NULL; + + read_lock(&io_pgtable_init_fns_list_lock); + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) + if (iter->fns->fmt == fmt) { + fns = iter->fns; + break; + } + read_unlock(&io_pgtable_init_fns_list_lock); + + return fns; +} + struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, struct io_pgtable_cfg *cfg, void *cookie) { struct io_pgtable *iop; - const struct io_pgtable_init_fns *fns; + struct io_pgtable_init_fns *fns; if (fmt >= IO_PGTABLE_NUM_FMTS) return NULL; - fns = io_pgtable_init_table[fmt]; + fns = io_pgtable_get_init_fns(fmt); if (!fns) return NULL; @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); void free_io_pgtable_ops(struct io_pgtable_ops *ops) { struct io_pgtable *iop; + struct io_pgtable_init_fns *fns; if (!ops) return; iop = io_pgtable_ops_to_pgtable(ops); io_pgtable_tlb_flush_all(iop); - io_pgtable_init_table[iop->fmt]->free(iop); + fns = io_pgtable_get_init_fns(iop->fmt); + if (fns) + fns->free(iop); } EXPORT_SYMBOL_GPL(free_io_pgtable_ops); + +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) +{ + struct io_pgtable_init_fns_node *iter, *fns_node; + int ret = 0; + + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || + !init_fns->alloc || !init_fns->free) + return -EINVAL; + + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); + if (!fns_node) + return -ENOMEM; + + write_lock(&io_pgtable_init_fns_list_lock); + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) + if (iter->fns->fmt == init_fns->fmt) { + ret = -EEXIST; + kfree(fns_node); + break; + } + + if (!ret) { + fns_node->fns = init_fns; + INIT_LIST_HEAD(&fns_node->list); + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); + } + write_unlock(&io_pgtable_init_fns_list_lock); + return ret; +} +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); + +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) +{ + struct io_pgtable_init_fns_node *iter, *tmp; + + if (!init_fns) + return; + + write_lock(&io_pgtable_init_fns_list_lock); + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, list) + if (iter->fns == init_fns) { + list_del(&iter->list); + kfree(iter); + break; + } + write_unlock(&io_pgtable_init_fns_list_lock); +} +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h index ea727eb..45b367ce 100644 --- a/include/linux/io-pgtable.h +++ b/include/linux/io-pgtable.h @@ -163,6 +163,38 @@ struct io_pgtable_ops { }; /** + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a + * particular format. + * + * @fmt: The page table format. + * @alloc: Allocate a set of page tables described by cfg. + * @free: Free the page tables associated with iop. + */ +struct io_pgtable_init_fns { + enum io_pgtable_fmt fmt; + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); + void (*free)(struct io_pgtable *iop); +}; + +/** + * io_pgtable_ops_register() - Register the page table routines for a page table + * format. + * + * @init_fns: The functions for allocating and freeing the page tables of + * a particular format. + */ +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); + +/** + * io_pgtable_ops_unregister() - Unregister the page table routines for a page + * table format. + * + * @init_fns: The functions for allocating and freeing the page tables of + * a particular format. + */ +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); + +/** * alloc_io_pgtable_ops() - Allocate a page table allocator for use by an IOMMU. * * @fmt: The page table format. @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, iop->cfg.tlb->tlb_add_page(gather, iova, granule, iop->cookie); } -/** - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a - * particular format. - * - * @alloc: Allocate a set of page tables described by cfg. - * @free: Free the page tables associated with iop. - */ -struct io_pgtable_init_fns { - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); - void (*free)(struct io_pgtable *iop); -}; - -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; - #endif /* __IO_PGTABLE_H */ -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, robin.murphy, pratikp The io-pgtable code constructs an array of init functions for each page table format at compile time. This is not ideal, as this increases the footprint of the io-pgtable code, as well as prevents io-pgtable formats from being built as kernel modules. In preparation for modularizing the io-pgtable formats, switch to a dynamic registration scheme, where each io-pgtable format can register their init functions with the io-pgtable code at boot or module insertion time. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- drivers/iommu/io-pgtable-arm.c | 90 ++++++++++++++++++++++++++---------- drivers/iommu/io-pgtable.c | 94 ++++++++++++++++++++++++++++++++------ include/linux/io-pgtable.h | 51 +++++++++++++-------- 4 files changed, 209 insertions(+), 60 deletions(-) diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c index 1d92ac9..89aad2f 100644 --- a/drivers/iommu/io-pgtable-arm-v7s.c +++ b/drivers/iommu/io-pgtable-arm-v7s.c @@ -28,6 +28,7 @@ #include <linux/iommu.h> #include <linux/kernel.h> #include <linux/kmemleak.h> +#include <linux/module.h> #include <linux/sizes.h> #include <linux/slab.h> #include <linux/spinlock.h> @@ -835,7 +836,8 @@ static struct io_pgtable *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, return NULL; } -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { + .fmt = ARM_V7S, .alloc = arm_v7s_alloc_pgtable, .free = arm_v7s_free_pgtable, }; @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) pr_info("self test ok\n"); return 0; } -subsys_initcall(arm_v7s_do_selftests); +#else +static int arm_v7s_do_selftests(void) +{ + return 0; +} #endif + +static int __init arm_v7s_init(void) +{ + int ret; + + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); + if (ret < 0) { + pr_err("Failed to register ARM V7S format\n"); + return ret; + } + + ret = arm_v7s_do_selftests(); + if (ret < 0) + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); + + return ret; +} +core_initcall(arm_v7s_init); + +static void __exit arm_v7s_exit(void) +{ + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); +} +module_exit(arm_v7s_exit); diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c index 87def58..ff0ea2f 100644 --- a/drivers/iommu/io-pgtable-arm.c +++ b/drivers/iommu/io-pgtable-arm.c @@ -13,6 +13,7 @@ #include <linux/bitops.h> #include <linux/io-pgtable.h> #include <linux/kernel.h> +#include <linux/module.h> #include <linux/sizes.h> #include <linux/slab.h> #include <linux/types.h> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct io_pgtable_cfg *cfg, void *cookie) return NULL; } -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { - .alloc = arm_64_lpae_alloc_pgtable_s1, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { - .alloc = arm_64_lpae_alloc_pgtable_s2, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { - .alloc = arm_32_lpae_alloc_pgtable_s1, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { - .alloc = arm_32_lpae_alloc_pgtable_s2, - .free = arm_lpae_free_pgtable, -}; - -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { - .alloc = arm_mali_lpae_alloc_pgtable, - .free = arm_lpae_free_pgtable, +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { + { + .fmt = ARM_32_LPAE_S1, + .alloc = arm_32_lpae_alloc_pgtable_s1, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_32_LPAE_S2, + .alloc = arm_32_lpae_alloc_pgtable_s2, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_64_LPAE_S1, + .alloc = arm_64_lpae_alloc_pgtable_s1, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_64_LPAE_S2, + .alloc = arm_64_lpae_alloc_pgtable_s2, + .free = arm_lpae_free_pgtable, + }, + { + .fmt = ARM_MALI_LPAE, + .alloc = arm_mali_lpae_alloc_pgtable, + .free = arm_lpae_free_pgtable, + }, }; #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); return fail ? -EFAULT : 0; } -subsys_initcall(arm_lpae_do_selftests); +#else +static int __init arm_lpae_do_selftests(void) +{ + return 0; +} #endif + +static int __init arm_lpae_init(void) +{ + int ret, i; + + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); + if (ret < 0) { + pr_err("Failed to register ARM LPAE fmt: %d\n"); + goto err_io_pgtable_register; + } + } + + ret = arm_lpae_do_selftests(); + if (ret < 0) + goto err_io_pgtable_register; + + return 0; + +err_io_pgtable_register: + for (i = i - 1; i >= 0; i--) + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); + return ret; +} +core_initcall(arm_lpae_init); + +static void __exit arm_lpae_exit(void) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); +} +module_exit(arm_lpae_exit); diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c index 94394c8..2c6eb2e 100644 --- a/drivers/iommu/io-pgtable.c +++ b/drivers/iommu/io-pgtable.c @@ -10,33 +10,45 @@ #include <linux/bug.h> #include <linux/io-pgtable.h> #include <linux/kernel.h> +#include <linux/rwlock.h> +#include <linux/slab.h> #include <linux/types.h> -static const struct io_pgtable_init_fns * -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, -#endif -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, -#endif +struct io_pgtable_init_fns_node { + struct io_pgtable_init_fns *fns; + struct list_head list; }; +static LIST_HEAD(io_pgtable_init_fns_list); +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); + +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum io_pgtable_fmt fmt) +{ + struct io_pgtable_init_fns_node *iter; + struct io_pgtable_init_fns *fns = NULL; + + read_lock(&io_pgtable_init_fns_list_lock); + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) + if (iter->fns->fmt == fmt) { + fns = iter->fns; + break; + } + read_unlock(&io_pgtable_init_fns_list_lock); + + return fns; +} + struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, struct io_pgtable_cfg *cfg, void *cookie) { struct io_pgtable *iop; - const struct io_pgtable_init_fns *fns; + struct io_pgtable_init_fns *fns; if (fmt >= IO_PGTABLE_NUM_FMTS) return NULL; - fns = io_pgtable_init_table[fmt]; + fns = io_pgtable_get_init_fns(fmt); if (!fns) return NULL; @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); void free_io_pgtable_ops(struct io_pgtable_ops *ops) { struct io_pgtable *iop; + struct io_pgtable_init_fns *fns; if (!ops) return; iop = io_pgtable_ops_to_pgtable(ops); io_pgtable_tlb_flush_all(iop); - io_pgtable_init_table[iop->fmt]->free(iop); + fns = io_pgtable_get_init_fns(iop->fmt); + if (fns) + fns->free(iop); } EXPORT_SYMBOL_GPL(free_io_pgtable_ops); + +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) +{ + struct io_pgtable_init_fns_node *iter, *fns_node; + int ret = 0; + + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || + !init_fns->alloc || !init_fns->free) + return -EINVAL; + + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); + if (!fns_node) + return -ENOMEM; + + write_lock(&io_pgtable_init_fns_list_lock); + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) + if (iter->fns->fmt == init_fns->fmt) { + ret = -EEXIST; + kfree(fns_node); + break; + } + + if (!ret) { + fns_node->fns = init_fns; + INIT_LIST_HEAD(&fns_node->list); + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); + } + write_unlock(&io_pgtable_init_fns_list_lock); + return ret; +} +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); + +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) +{ + struct io_pgtable_init_fns_node *iter, *tmp; + + if (!init_fns) + return; + + write_lock(&io_pgtable_init_fns_list_lock); + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, list) + if (iter->fns == init_fns) { + list_del(&iter->list); + kfree(iter); + break; + } + write_unlock(&io_pgtable_init_fns_list_lock); +} +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h index ea727eb..45b367ce 100644 --- a/include/linux/io-pgtable.h +++ b/include/linux/io-pgtable.h @@ -163,6 +163,38 @@ struct io_pgtable_ops { }; /** + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a + * particular format. + * + * @fmt: The page table format. + * @alloc: Allocate a set of page tables described by cfg. + * @free: Free the page tables associated with iop. + */ +struct io_pgtable_init_fns { + enum io_pgtable_fmt fmt; + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); + void (*free)(struct io_pgtable *iop); +}; + +/** + * io_pgtable_ops_register() - Register the page table routines for a page table + * format. + * + * @init_fns: The functions for allocating and freeing the page tables of + * a particular format. + */ +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); + +/** + * io_pgtable_ops_unregister() - Unregister the page table routines for a page + * table format. + * + * @init_fns: The functions for allocating and freeing the page tables of + * a particular format. + */ +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); + +/** * alloc_io_pgtable_ops() - Allocate a page table allocator for use by an IOMMU. * * @fmt: The page table format. @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, iop->cfg.tlb->tlb_add_page(gather, iova, granule, iop->cookie); } -/** - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a - * particular format. - * - * @alloc: Allocate a set of page tables described by cfg. - * @free: Free the page tables associated with iop. - */ -struct io_pgtable_init_fns { - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); - void (*free)(struct io_pgtable *iop); -}; - -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; - #endif /* __IO_PGTABLE_H */ -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply related [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration 2020-12-22 0:44 ` Isaac J. Manjarres (?) (?) @ 2020-12-22 19:27 ` Robin Murphy -1 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-22 19:27 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: will, joro, pdaly, pratikp, kernel-team On 2020-12-22 00:44, Isaac J. Manjarres wrote: > The io-pgtable code constructs an array of init functions for each > page table format at compile time. This is not ideal, as this > increases the footprint of the io-pgtable code, as well as prevents > io-pgtable formats from being built as kernel modules. > > In preparation for modularizing the io-pgtable formats, switch to a > dynamic registration scheme, where each io-pgtable format can register > their init functions with the io-pgtable code at boot or module > insertion time. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- > drivers/iommu/io-pgtable-arm.c | 90 ++++++++++++++++++++++++++---------- > drivers/iommu/io-pgtable.c | 94 ++++++++++++++++++++++++++++++++------ > include/linux/io-pgtable.h | 51 +++++++++++++-------- > 4 files changed, 209 insertions(+), 60 deletions(-) > > diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c > index 1d92ac9..89aad2f 100644 > --- a/drivers/iommu/io-pgtable-arm-v7s.c > +++ b/drivers/iommu/io-pgtable-arm-v7s.c > @@ -28,6 +28,7 @@ > #include <linux/iommu.h> > #include <linux/kernel.h> > #include <linux/kmemleak.h> > +#include <linux/module.h> > #include <linux/sizes.h> > #include <linux/slab.h> > #include <linux/spinlock.h> > @@ -835,7 +836,8 @@ static struct io_pgtable *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, > return NULL; > } > > -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { > +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { > + .fmt = ARM_V7S, > .alloc = arm_v7s_alloc_pgtable, > .free = arm_v7s_free_pgtable, > }; > @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) > pr_info("self test ok\n"); > return 0; > } > -subsys_initcall(arm_v7s_do_selftests); > +#else > +static int arm_v7s_do_selftests(void) > +{ > + return 0; > +} > #endif > + > +static int __init arm_v7s_init(void) > +{ > + int ret; > + > + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); > + if (ret < 0) { > + pr_err("Failed to register ARM V7S format\n"); Super-nit: I think "v7s" should probably be lowercase there. Also general consistency WRT to showing the error code and whether or not to abbreviate "format" would be nice. > + return ret; > + } > + > + ret = arm_v7s_do_selftests(); > + if (ret < 0) > + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); > + > + return ret; > +} > +core_initcall(arm_v7s_init); > + > +static void __exit arm_v7s_exit(void) > +{ > + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); > +} > +module_exit(arm_v7s_exit); > diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c > index 87def58..ff0ea2f 100644 > --- a/drivers/iommu/io-pgtable-arm.c > +++ b/drivers/iommu/io-pgtable-arm.c > @@ -13,6 +13,7 @@ > #include <linux/bitops.h> > #include <linux/io-pgtable.h> > #include <linux/kernel.h> > +#include <linux/module.h> > #include <linux/sizes.h> > #include <linux/slab.h> > #include <linux/types.h> > @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct io_pgtable_cfg *cfg, void *cookie) > return NULL; > } > > -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { > - .alloc = arm_64_lpae_alloc_pgtable_s1, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { > - .alloc = arm_64_lpae_alloc_pgtable_s2, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { > - .alloc = arm_32_lpae_alloc_pgtable_s1, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { > - .alloc = arm_32_lpae_alloc_pgtable_s2, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { > - .alloc = arm_mali_lpae_alloc_pgtable, > - .free = arm_lpae_free_pgtable, > +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { > + { > + .fmt = ARM_32_LPAE_S1, > + .alloc = arm_32_lpae_alloc_pgtable_s1, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_32_LPAE_S2, > + .alloc = arm_32_lpae_alloc_pgtable_s2, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_64_LPAE_S1, > + .alloc = arm_64_lpae_alloc_pgtable_s1, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_64_LPAE_S2, > + .alloc = arm_64_lpae_alloc_pgtable_s2, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_MALI_LPAE, > + .alloc = arm_mali_lpae_alloc_pgtable, > + .free = arm_lpae_free_pgtable, > + }, > }; > > #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST > @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) > pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); > return fail ? -EFAULT : 0; > } > -subsys_initcall(arm_lpae_do_selftests); > +#else > +static int __init arm_lpae_do_selftests(void) > +{ > + return 0; > +} > #endif > + > +static int __init arm_lpae_init(void) > +{ > + int ret, i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { > + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); > + if (ret < 0) { > + pr_err("Failed to register ARM LPAE fmt: %d\n"); > + goto err_io_pgtable_register; > + } > + } > + > + ret = arm_lpae_do_selftests(); > + if (ret < 0) > + goto err_io_pgtable_register; > + > + return 0; > + > +err_io_pgtable_register: > + for (i = i - 1; i >= 0; i--) Personally I find "while (i--)" a bit clearer for this kind of unwinding, but maybe post-decrement isn't to everyone's taste. > + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); > + return ret; > +} > +core_initcall(arm_lpae_init); > + > +static void __exit arm_lpae_exit(void) > +{ > + int i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) > + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); > +} > +module_exit(arm_lpae_exit); > diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c > index 94394c8..2c6eb2e 100644 > --- a/drivers/iommu/io-pgtable.c > +++ b/drivers/iommu/io-pgtable.c > @@ -10,33 +10,45 @@ > #include <linux/bug.h> > #include <linux/io-pgtable.h> > #include <linux/kernel.h> > +#include <linux/rwlock.h> > +#include <linux/slab.h> > #include <linux/types.h> > > -static const struct io_pgtable_init_fns * > -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { > -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE > - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, > - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, > - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, > - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, > - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, > -#endif > -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S > - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, > -#endif > +struct io_pgtable_init_fns_node { > + struct io_pgtable_init_fns *fns; > + struct list_head list; > }; > > +static LIST_HEAD(io_pgtable_init_fns_list); > +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); > + > +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum io_pgtable_fmt fmt) > +{ > + struct io_pgtable_init_fns_node *iter; > + struct io_pgtable_init_fns *fns = NULL; > + > + read_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) > + if (iter->fns->fmt == fmt) { > + fns = iter->fns; > + break; > + } > + read_unlock(&io_pgtable_init_fns_list_lock); > + > + return fns; > +} I think it would be a lot easier to stick with a simple array indexed by enum - that way you can just set/clear/test entries without needing to worry about locking. Basically just remove the const and the initialisers from the existing one ;) (and if you think you're concerned about memory, consider that just the list head plus lock is already half the size of the table) Other than that, I think this all looks pretty promising - I'd suggest sending a non-RFC after rc1 so that it gets everyone's proper attention. Thanks, Robin. > + > struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, > struct io_pgtable_cfg *cfg, > void *cookie) > { > struct io_pgtable *iop; > - const struct io_pgtable_init_fns *fns; > + struct io_pgtable_init_fns *fns; > > if (fmt >= IO_PGTABLE_NUM_FMTS) > return NULL; > > - fns = io_pgtable_init_table[fmt]; > + fns = io_pgtable_get_init_fns(fmt); > if (!fns) > return NULL; > > @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); > void free_io_pgtable_ops(struct io_pgtable_ops *ops) > { > struct io_pgtable *iop; > + struct io_pgtable_init_fns *fns; > > if (!ops) > return; > > iop = io_pgtable_ops_to_pgtable(ops); > io_pgtable_tlb_flush_all(iop); > - io_pgtable_init_table[iop->fmt]->free(iop); > + fns = io_pgtable_get_init_fns(iop->fmt); > + if (fns) > + fns->free(iop); > } > EXPORT_SYMBOL_GPL(free_io_pgtable_ops); > + > +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) > +{ > + struct io_pgtable_init_fns_node *iter, *fns_node; > + int ret = 0; > + > + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || > + !init_fns->alloc || !init_fns->free) > + return -EINVAL; > + > + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); > + if (!fns_node) > + return -ENOMEM; > + > + write_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) > + if (iter->fns->fmt == init_fns->fmt) { > + ret = -EEXIST; > + kfree(fns_node); > + break; > + } > + > + if (!ret) { > + fns_node->fns = init_fns; > + INIT_LIST_HEAD(&fns_node->list); > + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); > + } > + write_unlock(&io_pgtable_init_fns_list_lock); > + return ret; > +} > +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); > + > +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) > +{ > + struct io_pgtable_init_fns_node *iter, *tmp; > + > + if (!init_fns) > + return; > + > + write_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, list) > + if (iter->fns == init_fns) { > + list_del(&iter->list); > + kfree(iter); > + break; > + } > + write_unlock(&io_pgtable_init_fns_list_lock); > +} > +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); > diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h > index ea727eb..45b367ce 100644 > --- a/include/linux/io-pgtable.h > +++ b/include/linux/io-pgtable.h > @@ -163,6 +163,38 @@ struct io_pgtable_ops { > }; > > /** > + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a > + * particular format. > + * > + * @fmt: The page table format. > + * @alloc: Allocate a set of page tables described by cfg. > + * @free: Free the page tables associated with iop. > + */ > +struct io_pgtable_init_fns { > + enum io_pgtable_fmt fmt; > + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); > + void (*free)(struct io_pgtable *iop); > +}; > + > +/** > + * io_pgtable_ops_register() - Register the page table routines for a page table > + * format. > + * > + * @init_fns: The functions for allocating and freeing the page tables of > + * a particular format. > + */ > +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); > + > +/** > + * io_pgtable_ops_unregister() - Unregister the page table routines for a page > + * table format. > + * > + * @init_fns: The functions for allocating and freeing the page tables of > + * a particular format. > + */ > +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); > + > +/** > * alloc_io_pgtable_ops() - Allocate a page table allocator for use by an IOMMU. > * > * @fmt: The page table format. > @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, > iop->cfg.tlb->tlb_add_page(gather, iova, granule, iop->cookie); > } > > -/** > - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a > - * particular format. > - * > - * @alloc: Allocate a set of page tables described by cfg. > - * @free: Free the page tables associated with iop. > - */ > -struct io_pgtable_init_fns { > - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); > - void (*free)(struct io_pgtable *iop); > -}; > - > -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; > - > #endif /* __IO_PGTABLE_H */ > ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-22 19:27 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-22 19:27 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: pratikp, joro, kernel-team, will, pdaly On 2020-12-22 00:44, Isaac J. Manjarres wrote: > The io-pgtable code constructs an array of init functions for each > page table format at compile time. This is not ideal, as this > increases the footprint of the io-pgtable code, as well as prevents > io-pgtable formats from being built as kernel modules. > > In preparation for modularizing the io-pgtable formats, switch to a > dynamic registration scheme, where each io-pgtable format can register > their init functions with the io-pgtable code at boot or module > insertion time. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- > drivers/iommu/io-pgtable-arm.c | 90 ++++++++++++++++++++++++++---------- > drivers/iommu/io-pgtable.c | 94 ++++++++++++++++++++++++++++++++------ > include/linux/io-pgtable.h | 51 +++++++++++++-------- > 4 files changed, 209 insertions(+), 60 deletions(-) > > diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c > index 1d92ac9..89aad2f 100644 > --- a/drivers/iommu/io-pgtable-arm-v7s.c > +++ b/drivers/iommu/io-pgtable-arm-v7s.c > @@ -28,6 +28,7 @@ > #include <linux/iommu.h> > #include <linux/kernel.h> > #include <linux/kmemleak.h> > +#include <linux/module.h> > #include <linux/sizes.h> > #include <linux/slab.h> > #include <linux/spinlock.h> > @@ -835,7 +836,8 @@ static struct io_pgtable *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, > return NULL; > } > > -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { > +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { > + .fmt = ARM_V7S, > .alloc = arm_v7s_alloc_pgtable, > .free = arm_v7s_free_pgtable, > }; > @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) > pr_info("self test ok\n"); > return 0; > } > -subsys_initcall(arm_v7s_do_selftests); > +#else > +static int arm_v7s_do_selftests(void) > +{ > + return 0; > +} > #endif > + > +static int __init arm_v7s_init(void) > +{ > + int ret; > + > + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); > + if (ret < 0) { > + pr_err("Failed to register ARM V7S format\n"); Super-nit: I think "v7s" should probably be lowercase there. Also general consistency WRT to showing the error code and whether or not to abbreviate "format" would be nice. > + return ret; > + } > + > + ret = arm_v7s_do_selftests(); > + if (ret < 0) > + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); > + > + return ret; > +} > +core_initcall(arm_v7s_init); > + > +static void __exit arm_v7s_exit(void) > +{ > + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); > +} > +module_exit(arm_v7s_exit); > diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c > index 87def58..ff0ea2f 100644 > --- a/drivers/iommu/io-pgtable-arm.c > +++ b/drivers/iommu/io-pgtable-arm.c > @@ -13,6 +13,7 @@ > #include <linux/bitops.h> > #include <linux/io-pgtable.h> > #include <linux/kernel.h> > +#include <linux/module.h> > #include <linux/sizes.h> > #include <linux/slab.h> > #include <linux/types.h> > @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct io_pgtable_cfg *cfg, void *cookie) > return NULL; > } > > -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { > - .alloc = arm_64_lpae_alloc_pgtable_s1, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { > - .alloc = arm_64_lpae_alloc_pgtable_s2, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { > - .alloc = arm_32_lpae_alloc_pgtable_s1, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { > - .alloc = arm_32_lpae_alloc_pgtable_s2, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { > - .alloc = arm_mali_lpae_alloc_pgtable, > - .free = arm_lpae_free_pgtable, > +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { > + { > + .fmt = ARM_32_LPAE_S1, > + .alloc = arm_32_lpae_alloc_pgtable_s1, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_32_LPAE_S2, > + .alloc = arm_32_lpae_alloc_pgtable_s2, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_64_LPAE_S1, > + .alloc = arm_64_lpae_alloc_pgtable_s1, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_64_LPAE_S2, > + .alloc = arm_64_lpae_alloc_pgtable_s2, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_MALI_LPAE, > + .alloc = arm_mali_lpae_alloc_pgtable, > + .free = arm_lpae_free_pgtable, > + }, > }; > > #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST > @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) > pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); > return fail ? -EFAULT : 0; > } > -subsys_initcall(arm_lpae_do_selftests); > +#else > +static int __init arm_lpae_do_selftests(void) > +{ > + return 0; > +} > #endif > + > +static int __init arm_lpae_init(void) > +{ > + int ret, i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { > + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); > + if (ret < 0) { > + pr_err("Failed to register ARM LPAE fmt: %d\n"); > + goto err_io_pgtable_register; > + } > + } > + > + ret = arm_lpae_do_selftests(); > + if (ret < 0) > + goto err_io_pgtable_register; > + > + return 0; > + > +err_io_pgtable_register: > + for (i = i - 1; i >= 0; i--) Personally I find "while (i--)" a bit clearer for this kind of unwinding, but maybe post-decrement isn't to everyone's taste. > + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); > + return ret; > +} > +core_initcall(arm_lpae_init); > + > +static void __exit arm_lpae_exit(void) > +{ > + int i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) > + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); > +} > +module_exit(arm_lpae_exit); > diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c > index 94394c8..2c6eb2e 100644 > --- a/drivers/iommu/io-pgtable.c > +++ b/drivers/iommu/io-pgtable.c > @@ -10,33 +10,45 @@ > #include <linux/bug.h> > #include <linux/io-pgtable.h> > #include <linux/kernel.h> > +#include <linux/rwlock.h> > +#include <linux/slab.h> > #include <linux/types.h> > > -static const struct io_pgtable_init_fns * > -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { > -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE > - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, > - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, > - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, > - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, > - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, > -#endif > -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S > - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, > -#endif > +struct io_pgtable_init_fns_node { > + struct io_pgtable_init_fns *fns; > + struct list_head list; > }; > > +static LIST_HEAD(io_pgtable_init_fns_list); > +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); > + > +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum io_pgtable_fmt fmt) > +{ > + struct io_pgtable_init_fns_node *iter; > + struct io_pgtable_init_fns *fns = NULL; > + > + read_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) > + if (iter->fns->fmt == fmt) { > + fns = iter->fns; > + break; > + } > + read_unlock(&io_pgtable_init_fns_list_lock); > + > + return fns; > +} I think it would be a lot easier to stick with a simple array indexed by enum - that way you can just set/clear/test entries without needing to worry about locking. Basically just remove the const and the initialisers from the existing one ;) (and if you think you're concerned about memory, consider that just the list head plus lock is already half the size of the table) Other than that, I think this all looks pretty promising - I'd suggest sending a non-RFC after rc1 so that it gets everyone's proper attention. Thanks, Robin. > + > struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, > struct io_pgtable_cfg *cfg, > void *cookie) > { > struct io_pgtable *iop; > - const struct io_pgtable_init_fns *fns; > + struct io_pgtable_init_fns *fns; > > if (fmt >= IO_PGTABLE_NUM_FMTS) > return NULL; > > - fns = io_pgtable_init_table[fmt]; > + fns = io_pgtable_get_init_fns(fmt); > if (!fns) > return NULL; > > @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); > void free_io_pgtable_ops(struct io_pgtable_ops *ops) > { > struct io_pgtable *iop; > + struct io_pgtable_init_fns *fns; > > if (!ops) > return; > > iop = io_pgtable_ops_to_pgtable(ops); > io_pgtable_tlb_flush_all(iop); > - io_pgtable_init_table[iop->fmt]->free(iop); > + fns = io_pgtable_get_init_fns(iop->fmt); > + if (fns) > + fns->free(iop); > } > EXPORT_SYMBOL_GPL(free_io_pgtable_ops); > + > +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) > +{ > + struct io_pgtable_init_fns_node *iter, *fns_node; > + int ret = 0; > + > + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || > + !init_fns->alloc || !init_fns->free) > + return -EINVAL; > + > + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); > + if (!fns_node) > + return -ENOMEM; > + > + write_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) > + if (iter->fns->fmt == init_fns->fmt) { > + ret = -EEXIST; > + kfree(fns_node); > + break; > + } > + > + if (!ret) { > + fns_node->fns = init_fns; > + INIT_LIST_HEAD(&fns_node->list); > + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); > + } > + write_unlock(&io_pgtable_init_fns_list_lock); > + return ret; > +} > +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); > + > +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) > +{ > + struct io_pgtable_init_fns_node *iter, *tmp; > + > + if (!init_fns) > + return; > + > + write_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, list) > + if (iter->fns == init_fns) { > + list_del(&iter->list); > + kfree(iter); > + break; > + } > + write_unlock(&io_pgtable_init_fns_list_lock); > +} > +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); > diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h > index ea727eb..45b367ce 100644 > --- a/include/linux/io-pgtable.h > +++ b/include/linux/io-pgtable.h > @@ -163,6 +163,38 @@ struct io_pgtable_ops { > }; > > /** > + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a > + * particular format. > + * > + * @fmt: The page table format. > + * @alloc: Allocate a set of page tables described by cfg. > + * @free: Free the page tables associated with iop. > + */ > +struct io_pgtable_init_fns { > + enum io_pgtable_fmt fmt; > + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); > + void (*free)(struct io_pgtable *iop); > +}; > + > +/** > + * io_pgtable_ops_register() - Register the page table routines for a page table > + * format. > + * > + * @init_fns: The functions for allocating and freeing the page tables of > + * a particular format. > + */ > +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); > + > +/** > + * io_pgtable_ops_unregister() - Unregister the page table routines for a page > + * table format. > + * > + * @init_fns: The functions for allocating and freeing the page tables of > + * a particular format. > + */ > +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); > + > +/** > * alloc_io_pgtable_ops() - Allocate a page table allocator for use by an IOMMU. > * > * @fmt: The page table format. > @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, > iop->cfg.tlb->tlb_add_page(gather, iova, granule, iop->cookie); > } > > -/** > - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a > - * particular format. > - * > - * @alloc: Allocate a set of page tables described by cfg. > - * @free: Free the page tables associated with iop. > - */ > -struct io_pgtable_init_fns { > - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); > - void (*free)(struct io_pgtable *iop); > -}; > - > -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; > - > #endif /* __IO_PGTABLE_H */ > _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-22 19:27 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-22 19:27 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: pratikp, joro, kernel-team, will, pdaly On 2020-12-22 00:44, Isaac J. Manjarres wrote: > The io-pgtable code constructs an array of init functions for each > page table format at compile time. This is not ideal, as this > increases the footprint of the io-pgtable code, as well as prevents > io-pgtable formats from being built as kernel modules. > > In preparation for modularizing the io-pgtable formats, switch to a > dynamic registration scheme, where each io-pgtable format can register > their init functions with the io-pgtable code at boot or module > insertion time. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- > drivers/iommu/io-pgtable-arm.c | 90 ++++++++++++++++++++++++++---------- > drivers/iommu/io-pgtable.c | 94 ++++++++++++++++++++++++++++++++------ > include/linux/io-pgtable.h | 51 +++++++++++++-------- > 4 files changed, 209 insertions(+), 60 deletions(-) > > diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c > index 1d92ac9..89aad2f 100644 > --- a/drivers/iommu/io-pgtable-arm-v7s.c > +++ b/drivers/iommu/io-pgtable-arm-v7s.c > @@ -28,6 +28,7 @@ > #include <linux/iommu.h> > #include <linux/kernel.h> > #include <linux/kmemleak.h> > +#include <linux/module.h> > #include <linux/sizes.h> > #include <linux/slab.h> > #include <linux/spinlock.h> > @@ -835,7 +836,8 @@ static struct io_pgtable *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, > return NULL; > } > > -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { > +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { > + .fmt = ARM_V7S, > .alloc = arm_v7s_alloc_pgtable, > .free = arm_v7s_free_pgtable, > }; > @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) > pr_info("self test ok\n"); > return 0; > } > -subsys_initcall(arm_v7s_do_selftests); > +#else > +static int arm_v7s_do_selftests(void) > +{ > + return 0; > +} > #endif > + > +static int __init arm_v7s_init(void) > +{ > + int ret; > + > + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); > + if (ret < 0) { > + pr_err("Failed to register ARM V7S format\n"); Super-nit: I think "v7s" should probably be lowercase there. Also general consistency WRT to showing the error code and whether or not to abbreviate "format" would be nice. > + return ret; > + } > + > + ret = arm_v7s_do_selftests(); > + if (ret < 0) > + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); > + > + return ret; > +} > +core_initcall(arm_v7s_init); > + > +static void __exit arm_v7s_exit(void) > +{ > + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); > +} > +module_exit(arm_v7s_exit); > diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c > index 87def58..ff0ea2f 100644 > --- a/drivers/iommu/io-pgtable-arm.c > +++ b/drivers/iommu/io-pgtable-arm.c > @@ -13,6 +13,7 @@ > #include <linux/bitops.h> > #include <linux/io-pgtable.h> > #include <linux/kernel.h> > +#include <linux/module.h> > #include <linux/sizes.h> > #include <linux/slab.h> > #include <linux/types.h> > @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct io_pgtable_cfg *cfg, void *cookie) > return NULL; > } > > -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { > - .alloc = arm_64_lpae_alloc_pgtable_s1, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { > - .alloc = arm_64_lpae_alloc_pgtable_s2, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { > - .alloc = arm_32_lpae_alloc_pgtable_s1, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { > - .alloc = arm_32_lpae_alloc_pgtable_s2, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { > - .alloc = arm_mali_lpae_alloc_pgtable, > - .free = arm_lpae_free_pgtable, > +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { > + { > + .fmt = ARM_32_LPAE_S1, > + .alloc = arm_32_lpae_alloc_pgtable_s1, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_32_LPAE_S2, > + .alloc = arm_32_lpae_alloc_pgtable_s2, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_64_LPAE_S1, > + .alloc = arm_64_lpae_alloc_pgtable_s1, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_64_LPAE_S2, > + .alloc = arm_64_lpae_alloc_pgtable_s2, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_MALI_LPAE, > + .alloc = arm_mali_lpae_alloc_pgtable, > + .free = arm_lpae_free_pgtable, > + }, > }; > > #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST > @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) > pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); > return fail ? -EFAULT : 0; > } > -subsys_initcall(arm_lpae_do_selftests); > +#else > +static int __init arm_lpae_do_selftests(void) > +{ > + return 0; > +} > #endif > + > +static int __init arm_lpae_init(void) > +{ > + int ret, i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { > + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); > + if (ret < 0) { > + pr_err("Failed to register ARM LPAE fmt: %d\n"); > + goto err_io_pgtable_register; > + } > + } > + > + ret = arm_lpae_do_selftests(); > + if (ret < 0) > + goto err_io_pgtable_register; > + > + return 0; > + > +err_io_pgtable_register: > + for (i = i - 1; i >= 0; i--) Personally I find "while (i--)" a bit clearer for this kind of unwinding, but maybe post-decrement isn't to everyone's taste. > + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); > + return ret; > +} > +core_initcall(arm_lpae_init); > + > +static void __exit arm_lpae_exit(void) > +{ > + int i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) > + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); > +} > +module_exit(arm_lpae_exit); > diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c > index 94394c8..2c6eb2e 100644 > --- a/drivers/iommu/io-pgtable.c > +++ b/drivers/iommu/io-pgtable.c > @@ -10,33 +10,45 @@ > #include <linux/bug.h> > #include <linux/io-pgtable.h> > #include <linux/kernel.h> > +#include <linux/rwlock.h> > +#include <linux/slab.h> > #include <linux/types.h> > > -static const struct io_pgtable_init_fns * > -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { > -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE > - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, > - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, > - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, > - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, > - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, > -#endif > -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S > - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, > -#endif > +struct io_pgtable_init_fns_node { > + struct io_pgtable_init_fns *fns; > + struct list_head list; > }; > > +static LIST_HEAD(io_pgtable_init_fns_list); > +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); > + > +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum io_pgtable_fmt fmt) > +{ > + struct io_pgtable_init_fns_node *iter; > + struct io_pgtable_init_fns *fns = NULL; > + > + read_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) > + if (iter->fns->fmt == fmt) { > + fns = iter->fns; > + break; > + } > + read_unlock(&io_pgtable_init_fns_list_lock); > + > + return fns; > +} I think it would be a lot easier to stick with a simple array indexed by enum - that way you can just set/clear/test entries without needing to worry about locking. Basically just remove the const and the initialisers from the existing one ;) (and if you think you're concerned about memory, consider that just the list head plus lock is already half the size of the table) Other than that, I think this all looks pretty promising - I'd suggest sending a non-RFC after rc1 so that it gets everyone's proper attention. Thanks, Robin. > + > struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, > struct io_pgtable_cfg *cfg, > void *cookie) > { > struct io_pgtable *iop; > - const struct io_pgtable_init_fns *fns; > + struct io_pgtable_init_fns *fns; > > if (fmt >= IO_PGTABLE_NUM_FMTS) > return NULL; > > - fns = io_pgtable_init_table[fmt]; > + fns = io_pgtable_get_init_fns(fmt); > if (!fns) > return NULL; > > @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); > void free_io_pgtable_ops(struct io_pgtable_ops *ops) > { > struct io_pgtable *iop; > + struct io_pgtable_init_fns *fns; > > if (!ops) > return; > > iop = io_pgtable_ops_to_pgtable(ops); > io_pgtable_tlb_flush_all(iop); > - io_pgtable_init_table[iop->fmt]->free(iop); > + fns = io_pgtable_get_init_fns(iop->fmt); > + if (fns) > + fns->free(iop); > } > EXPORT_SYMBOL_GPL(free_io_pgtable_ops); > + > +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) > +{ > + struct io_pgtable_init_fns_node *iter, *fns_node; > + int ret = 0; > + > + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || > + !init_fns->alloc || !init_fns->free) > + return -EINVAL; > + > + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); > + if (!fns_node) > + return -ENOMEM; > + > + write_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) > + if (iter->fns->fmt == init_fns->fmt) { > + ret = -EEXIST; > + kfree(fns_node); > + break; > + } > + > + if (!ret) { > + fns_node->fns = init_fns; > + INIT_LIST_HEAD(&fns_node->list); > + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); > + } > + write_unlock(&io_pgtable_init_fns_list_lock); > + return ret; > +} > +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); > + > +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) > +{ > + struct io_pgtable_init_fns_node *iter, *tmp; > + > + if (!init_fns) > + return; > + > + write_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, list) > + if (iter->fns == init_fns) { > + list_del(&iter->list); > + kfree(iter); > + break; > + } > + write_unlock(&io_pgtable_init_fns_list_lock); > +} > +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); > diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h > index ea727eb..45b367ce 100644 > --- a/include/linux/io-pgtable.h > +++ b/include/linux/io-pgtable.h > @@ -163,6 +163,38 @@ struct io_pgtable_ops { > }; > > /** > + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a > + * particular format. > + * > + * @fmt: The page table format. > + * @alloc: Allocate a set of page tables described by cfg. > + * @free: Free the page tables associated with iop. > + */ > +struct io_pgtable_init_fns { > + enum io_pgtable_fmt fmt; > + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); > + void (*free)(struct io_pgtable *iop); > +}; > + > +/** > + * io_pgtable_ops_register() - Register the page table routines for a page table > + * format. > + * > + * @init_fns: The functions for allocating and freeing the page tables of > + * a particular format. > + */ > +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); > + > +/** > + * io_pgtable_ops_unregister() - Unregister the page table routines for a page > + * table format. > + * > + * @init_fns: The functions for allocating and freeing the page tables of > + * a particular format. > + */ > +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); > + > +/** > * alloc_io_pgtable_ops() - Allocate a page table allocator for use by an IOMMU. > * > * @fmt: The page table format. > @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, > iop->cfg.tlb->tlb_add_page(gather, iova, granule, iop->cookie); > } > > -/** > - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a > - * particular format. > - * > - * @alloc: Allocate a set of page tables described by cfg. > - * @free: Free the page tables associated with iop. > - */ > -struct io_pgtable_init_fns { > - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); > - void (*free)(struct io_pgtable *iop); > -}; > - > -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; > - > #endif /* __IO_PGTABLE_H */ > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-22 19:27 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-22 19:27 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: pratikp, kernel-team, will, pdaly On 2020-12-22 00:44, Isaac J. Manjarres wrote: > The io-pgtable code constructs an array of init functions for each > page table format at compile time. This is not ideal, as this > increases the footprint of the io-pgtable code, as well as prevents > io-pgtable formats from being built as kernel modules. > > In preparation for modularizing the io-pgtable formats, switch to a > dynamic registration scheme, where each io-pgtable format can register > their init functions with the io-pgtable code at boot or module > insertion time. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- > drivers/iommu/io-pgtable-arm.c | 90 ++++++++++++++++++++++++++---------- > drivers/iommu/io-pgtable.c | 94 ++++++++++++++++++++++++++++++++------ > include/linux/io-pgtable.h | 51 +++++++++++++-------- > 4 files changed, 209 insertions(+), 60 deletions(-) > > diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c > index 1d92ac9..89aad2f 100644 > --- a/drivers/iommu/io-pgtable-arm-v7s.c > +++ b/drivers/iommu/io-pgtable-arm-v7s.c > @@ -28,6 +28,7 @@ > #include <linux/iommu.h> > #include <linux/kernel.h> > #include <linux/kmemleak.h> > +#include <linux/module.h> > #include <linux/sizes.h> > #include <linux/slab.h> > #include <linux/spinlock.h> > @@ -835,7 +836,8 @@ static struct io_pgtable *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, > return NULL; > } > > -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { > +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { > + .fmt = ARM_V7S, > .alloc = arm_v7s_alloc_pgtable, > .free = arm_v7s_free_pgtable, > }; > @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) > pr_info("self test ok\n"); > return 0; > } > -subsys_initcall(arm_v7s_do_selftests); > +#else > +static int arm_v7s_do_selftests(void) > +{ > + return 0; > +} > #endif > + > +static int __init arm_v7s_init(void) > +{ > + int ret; > + > + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); > + if (ret < 0) { > + pr_err("Failed to register ARM V7S format\n"); Super-nit: I think "v7s" should probably be lowercase there. Also general consistency WRT to showing the error code and whether or not to abbreviate "format" would be nice. > + return ret; > + } > + > + ret = arm_v7s_do_selftests(); > + if (ret < 0) > + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); > + > + return ret; > +} > +core_initcall(arm_v7s_init); > + > +static void __exit arm_v7s_exit(void) > +{ > + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); > +} > +module_exit(arm_v7s_exit); > diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c > index 87def58..ff0ea2f 100644 > --- a/drivers/iommu/io-pgtable-arm.c > +++ b/drivers/iommu/io-pgtable-arm.c > @@ -13,6 +13,7 @@ > #include <linux/bitops.h> > #include <linux/io-pgtable.h> > #include <linux/kernel.h> > +#include <linux/module.h> > #include <linux/sizes.h> > #include <linux/slab.h> > #include <linux/types.h> > @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct io_pgtable_cfg *cfg, void *cookie) > return NULL; > } > > -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { > - .alloc = arm_64_lpae_alloc_pgtable_s1, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { > - .alloc = arm_64_lpae_alloc_pgtable_s2, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { > - .alloc = arm_32_lpae_alloc_pgtable_s1, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { > - .alloc = arm_32_lpae_alloc_pgtable_s2, > - .free = arm_lpae_free_pgtable, > -}; > - > -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { > - .alloc = arm_mali_lpae_alloc_pgtable, > - .free = arm_lpae_free_pgtable, > +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { > + { > + .fmt = ARM_32_LPAE_S1, > + .alloc = arm_32_lpae_alloc_pgtable_s1, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_32_LPAE_S2, > + .alloc = arm_32_lpae_alloc_pgtable_s2, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_64_LPAE_S1, > + .alloc = arm_64_lpae_alloc_pgtable_s1, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_64_LPAE_S2, > + .alloc = arm_64_lpae_alloc_pgtable_s2, > + .free = arm_lpae_free_pgtable, > + }, > + { > + .fmt = ARM_MALI_LPAE, > + .alloc = arm_mali_lpae_alloc_pgtable, > + .free = arm_lpae_free_pgtable, > + }, > }; > > #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST > @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) > pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); > return fail ? -EFAULT : 0; > } > -subsys_initcall(arm_lpae_do_selftests); > +#else > +static int __init arm_lpae_do_selftests(void) > +{ > + return 0; > +} > #endif > + > +static int __init arm_lpae_init(void) > +{ > + int ret, i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { > + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); > + if (ret < 0) { > + pr_err("Failed to register ARM LPAE fmt: %d\n"); > + goto err_io_pgtable_register; > + } > + } > + > + ret = arm_lpae_do_selftests(); > + if (ret < 0) > + goto err_io_pgtable_register; > + > + return 0; > + > +err_io_pgtable_register: > + for (i = i - 1; i >= 0; i--) Personally I find "while (i--)" a bit clearer for this kind of unwinding, but maybe post-decrement isn't to everyone's taste. > + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); > + return ret; > +} > +core_initcall(arm_lpae_init); > + > +static void __exit arm_lpae_exit(void) > +{ > + int i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) > + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); > +} > +module_exit(arm_lpae_exit); > diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c > index 94394c8..2c6eb2e 100644 > --- a/drivers/iommu/io-pgtable.c > +++ b/drivers/iommu/io-pgtable.c > @@ -10,33 +10,45 @@ > #include <linux/bug.h> > #include <linux/io-pgtable.h> > #include <linux/kernel.h> > +#include <linux/rwlock.h> > +#include <linux/slab.h> > #include <linux/types.h> > > -static const struct io_pgtable_init_fns * > -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { > -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE > - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, > - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, > - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, > - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, > - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, > -#endif > -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S > - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, > -#endif > +struct io_pgtable_init_fns_node { > + struct io_pgtable_init_fns *fns; > + struct list_head list; > }; > > +static LIST_HEAD(io_pgtable_init_fns_list); > +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); > + > +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum io_pgtable_fmt fmt) > +{ > + struct io_pgtable_init_fns_node *iter; > + struct io_pgtable_init_fns *fns = NULL; > + > + read_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) > + if (iter->fns->fmt == fmt) { > + fns = iter->fns; > + break; > + } > + read_unlock(&io_pgtable_init_fns_list_lock); > + > + return fns; > +} I think it would be a lot easier to stick with a simple array indexed by enum - that way you can just set/clear/test entries without needing to worry about locking. Basically just remove the const and the initialisers from the existing one ;) (and if you think you're concerned about memory, consider that just the list head plus lock is already half the size of the table) Other than that, I think this all looks pretty promising - I'd suggest sending a non-RFC after rc1 so that it gets everyone's proper attention. Thanks, Robin. > + > struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, > struct io_pgtable_cfg *cfg, > void *cookie) > { > struct io_pgtable *iop; > - const struct io_pgtable_init_fns *fns; > + struct io_pgtable_init_fns *fns; > > if (fmt >= IO_PGTABLE_NUM_FMTS) > return NULL; > > - fns = io_pgtable_init_table[fmt]; > + fns = io_pgtable_get_init_fns(fmt); > if (!fns) > return NULL; > > @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); > void free_io_pgtable_ops(struct io_pgtable_ops *ops) > { > struct io_pgtable *iop; > + struct io_pgtable_init_fns *fns; > > if (!ops) > return; > > iop = io_pgtable_ops_to_pgtable(ops); > io_pgtable_tlb_flush_all(iop); > - io_pgtable_init_table[iop->fmt]->free(iop); > + fns = io_pgtable_get_init_fns(iop->fmt); > + if (fns) > + fns->free(iop); > } > EXPORT_SYMBOL_GPL(free_io_pgtable_ops); > + > +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) > +{ > + struct io_pgtable_init_fns_node *iter, *fns_node; > + int ret = 0; > + > + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || > + !init_fns->alloc || !init_fns->free) > + return -EINVAL; > + > + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); > + if (!fns_node) > + return -ENOMEM; > + > + write_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) > + if (iter->fns->fmt == init_fns->fmt) { > + ret = -EEXIST; > + kfree(fns_node); > + break; > + } > + > + if (!ret) { > + fns_node->fns = init_fns; > + INIT_LIST_HEAD(&fns_node->list); > + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); > + } > + write_unlock(&io_pgtable_init_fns_list_lock); > + return ret; > +} > +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); > + > +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) > +{ > + struct io_pgtable_init_fns_node *iter, *tmp; > + > + if (!init_fns) > + return; > + > + write_lock(&io_pgtable_init_fns_list_lock); > + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, list) > + if (iter->fns == init_fns) { > + list_del(&iter->list); > + kfree(iter); > + break; > + } > + write_unlock(&io_pgtable_init_fns_list_lock); > +} > +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); > diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h > index ea727eb..45b367ce 100644 > --- a/include/linux/io-pgtable.h > +++ b/include/linux/io-pgtable.h > @@ -163,6 +163,38 @@ struct io_pgtable_ops { > }; > > /** > + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a > + * particular format. > + * > + * @fmt: The page table format. > + * @alloc: Allocate a set of page tables described by cfg. > + * @free: Free the page tables associated with iop. > + */ > +struct io_pgtable_init_fns { > + enum io_pgtable_fmt fmt; > + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); > + void (*free)(struct io_pgtable *iop); > +}; > + > +/** > + * io_pgtable_ops_register() - Register the page table routines for a page table > + * format. > + * > + * @init_fns: The functions for allocating and freeing the page tables of > + * a particular format. > + */ > +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); > + > +/** > + * io_pgtable_ops_unregister() - Unregister the page table routines for a page > + * table format. > + * > + * @init_fns: The functions for allocating and freeing the page tables of > + * a particular format. > + */ > +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); > + > +/** > * alloc_io_pgtable_ops() - Allocate a page table allocator for use by an IOMMU. > * > * @fmt: The page table format. > @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, > iop->cfg.tlb->tlb_add_page(gather, iova, granule, iop->cookie); > } > > -/** > - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a > - * particular format. > - * > - * @alloc: Allocate a set of page tables described by cfg. > - * @free: Free the page tables associated with iop. > - */ > -struct io_pgtable_init_fns { > - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); > - void (*free)(struct io_pgtable *iop); > -}; > - > -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; > -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; > - > #endif /* __IO_PGTABLE_H */ > _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration 2020-12-22 19:27 ` Robin Murphy (?) @ 2020-12-22 19:54 ` isaacm -1 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-22 19:54 UTC (permalink / raw) To: Robin Murphy Cc: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm, pratikp, joro, kernel-team, will, pdaly On 2020-12-22 11:27, Robin Murphy wrote: > On 2020-12-22 00:44, Isaac J. Manjarres wrote: >> The io-pgtable code constructs an array of init functions for each >> page table format at compile time. This is not ideal, as this >> increases the footprint of the io-pgtable code, as well as prevents >> io-pgtable formats from being built as kernel modules. >> >> In preparation for modularizing the io-pgtable formats, switch to a >> dynamic registration scheme, where each io-pgtable format can register >> their init functions with the io-pgtable code at boot or module >> insertion time. >> >> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >> --- >> drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- >> drivers/iommu/io-pgtable-arm.c | 90 >> ++++++++++++++++++++++++++---------- >> drivers/iommu/io-pgtable.c | 94 >> ++++++++++++++++++++++++++++++++------ >> include/linux/io-pgtable.h | 51 +++++++++++++-------- >> 4 files changed, 209 insertions(+), 60 deletions(-) >> >> diff --git a/drivers/iommu/io-pgtable-arm-v7s.c >> b/drivers/iommu/io-pgtable-arm-v7s.c >> index 1d92ac9..89aad2f 100644 >> --- a/drivers/iommu/io-pgtable-arm-v7s.c >> +++ b/drivers/iommu/io-pgtable-arm-v7s.c >> @@ -28,6 +28,7 @@ >> #include <linux/iommu.h> >> #include <linux/kernel.h> >> #include <linux/kmemleak.h> >> +#include <linux/module.h> >> #include <linux/sizes.h> >> #include <linux/slab.h> >> #include <linux/spinlock.h> >> @@ -835,7 +836,8 @@ static struct io_pgtable >> *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, >> return NULL; >> } >> -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >> +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >> + .fmt = ARM_V7S, >> .alloc = arm_v7s_alloc_pgtable, >> .free = arm_v7s_free_pgtable, >> }; >> @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) >> pr_info("self test ok\n"); >> return 0; >> } >> -subsys_initcall(arm_v7s_do_selftests); >> +#else >> +static int arm_v7s_do_selftests(void) >> +{ >> + return 0; >> +} >> #endif >> + >> +static int __init arm_v7s_init(void) >> +{ >> + int ret; >> + >> + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); >> + if (ret < 0) { >> + pr_err("Failed to register ARM V7S format\n"); > > Super-nit: I think "v7s" should probably be lowercase there. Also > general consistency WRT to showing the error code and whether or not > to abbreviate "format" would be nice. > Ok, I can fix this accordingly. >> + return ret; >> + } >> + >> + ret = arm_v7s_do_selftests(); >> + if (ret < 0) >> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >> + >> + return ret; >> +} >> +core_initcall(arm_v7s_init); >> + >> +static void __exit arm_v7s_exit(void) >> +{ >> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >> +} >> +module_exit(arm_v7s_exit); >> diff --git a/drivers/iommu/io-pgtable-arm.c >> b/drivers/iommu/io-pgtable-arm.c >> index 87def58..ff0ea2f 100644 >> --- a/drivers/iommu/io-pgtable-arm.c >> +++ b/drivers/iommu/io-pgtable-arm.c >> @@ -13,6 +13,7 @@ >> #include <linux/bitops.h> >> #include <linux/io-pgtable.h> >> #include <linux/kernel.h> >> +#include <linux/module.h> >> #include <linux/sizes.h> >> #include <linux/slab.h> >> #include <linux/types.h> >> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct >> io_pgtable_cfg *cfg, void *cookie) >> return NULL; >> } >> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { >> - .alloc = arm_64_lpae_alloc_pgtable_s1, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { >> - .alloc = arm_64_lpae_alloc_pgtable_s2, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { >> - .alloc = arm_32_lpae_alloc_pgtable_s1, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { >> - .alloc = arm_32_lpae_alloc_pgtable_s2, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { >> - .alloc = arm_mali_lpae_alloc_pgtable, >> - .free = arm_lpae_free_pgtable, >> +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { >> + { >> + .fmt = ARM_32_LPAE_S1, >> + .alloc = arm_32_lpae_alloc_pgtable_s1, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_32_LPAE_S2, >> + .alloc = arm_32_lpae_alloc_pgtable_s2, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_64_LPAE_S1, >> + .alloc = arm_64_lpae_alloc_pgtable_s1, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_64_LPAE_S2, >> + .alloc = arm_64_lpae_alloc_pgtable_s2, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_MALI_LPAE, >> + .alloc = arm_mali_lpae_alloc_pgtable, >> + .free = arm_lpae_free_pgtable, >> + }, >> }; >> #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST >> @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) >> pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); >> return fail ? -EFAULT : 0; >> } >> -subsys_initcall(arm_lpae_do_selftests); >> +#else >> +static int __init arm_lpae_do_selftests(void) >> +{ >> + return 0; >> +} >> #endif >> + >> +static int __init arm_lpae_init(void) >> +{ >> + int ret, i; >> + >> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { >> + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); >> + if (ret < 0) { >> + pr_err("Failed to register ARM LPAE fmt: %d\n"); >> + goto err_io_pgtable_register; >> + } >> + } >> + >> + ret = arm_lpae_do_selftests(); >> + if (ret < 0) >> + goto err_io_pgtable_register; >> + >> + return 0; >> + >> +err_io_pgtable_register: >> + for (i = i - 1; i >= 0; i--) > > Personally I find "while (i--)" a bit clearer for this kind of > unwinding, but maybe post-decrement isn't to everyone's taste. > I'm not particularly attached to the current approach, so a while loop is okay with me :). >> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >> + return ret; >> +} >> +core_initcall(arm_lpae_init); >> + >> +static void __exit arm_lpae_exit(void) >> +{ >> + int i; >> + >> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >> +} >> +module_exit(arm_lpae_exit); >> diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c >> index 94394c8..2c6eb2e 100644 >> --- a/drivers/iommu/io-pgtable.c >> +++ b/drivers/iommu/io-pgtable.c >> @@ -10,33 +10,45 @@ >> #include <linux/bug.h> >> #include <linux/io-pgtable.h> >> #include <linux/kernel.h> >> +#include <linux/rwlock.h> >> +#include <linux/slab.h> >> #include <linux/types.h> >> -static const struct io_pgtable_init_fns * >> -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { >> -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE >> - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, >> - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, >> - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, >> - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, >> - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, >> -#endif >> -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S >> - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, >> -#endif >> +struct io_pgtable_init_fns_node { >> + struct io_pgtable_init_fns *fns; >> + struct list_head list; >> }; >> +static LIST_HEAD(io_pgtable_init_fns_list); >> +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); >> + >> +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum >> io_pgtable_fmt fmt) >> +{ >> + struct io_pgtable_init_fns_node *iter; >> + struct io_pgtable_init_fns *fns = NULL; >> + >> + read_lock(&io_pgtable_init_fns_list_lock); >> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >> + if (iter->fns->fmt == fmt) { >> + fns = iter->fns; >> + break; >> + } >> + read_unlock(&io_pgtable_init_fns_list_lock); >> + >> + return fns; >> +} > > I think it would be a lot easier to stick with a simple array indexed > by enum - that way you can just set/clear/test entries without needing > to worry about locking. Basically just remove the const and the > initialisers from the existing one ;) > > (and if you think you're concerned about memory, consider that just > the list head plus lock is already half the size of the table) > > Other than that, I think this all looks pretty promising - I'd suggest > sending a non-RFC after rc1 so that it gets everyone's proper > attention. > > Thanks, > Robin. > Thanks for all of the feedback! With respect to the comment about keeping the current array, don't we need some sort of lock to protect access to the data structure (e.g. concurrent access if adding two ops for the same format)? Or do you mean that we should use atomic operations to handle this cleanly? Thanks, Isaac >> + >> struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, >> struct io_pgtable_cfg *cfg, >> void *cookie) >> { >> struct io_pgtable *iop; >> - const struct io_pgtable_init_fns *fns; >> + struct io_pgtable_init_fns *fns; >> if (fmt >= IO_PGTABLE_NUM_FMTS) >> return NULL; >> - fns = io_pgtable_init_table[fmt]; >> + fns = io_pgtable_get_init_fns(fmt); >> if (!fns) >> return NULL; >> @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); >> void free_io_pgtable_ops(struct io_pgtable_ops *ops) >> { >> struct io_pgtable *iop; >> + struct io_pgtable_init_fns *fns; >> if (!ops) >> return; >> iop = io_pgtable_ops_to_pgtable(ops); >> io_pgtable_tlb_flush_all(iop); >> - io_pgtable_init_table[iop->fmt]->free(iop); >> + fns = io_pgtable_get_init_fns(iop->fmt); >> + if (fns) >> + fns->free(iop); >> } >> EXPORT_SYMBOL_GPL(free_io_pgtable_ops); >> + >> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) >> +{ >> + struct io_pgtable_init_fns_node *iter, *fns_node; >> + int ret = 0; >> + >> + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || >> + !init_fns->alloc || !init_fns->free) >> + return -EINVAL; >> + >> + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); >> + if (!fns_node) >> + return -ENOMEM; >> + >> + write_lock(&io_pgtable_init_fns_list_lock); >> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >> + if (iter->fns->fmt == init_fns->fmt) { >> + ret = -EEXIST; >> + kfree(fns_node); >> + break; >> + } >> + >> + if (!ret) { >> + fns_node->fns = init_fns; >> + INIT_LIST_HEAD(&fns_node->list); >> + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); >> + } >> + write_unlock(&io_pgtable_init_fns_list_lock); >> + return ret; >> +} >> +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); >> + >> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) >> +{ >> + struct io_pgtable_init_fns_node *iter, *tmp; >> + >> + if (!init_fns) >> + return; >> + >> + write_lock(&io_pgtable_init_fns_list_lock); >> + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, list) >> + if (iter->fns == init_fns) { >> + list_del(&iter->list); >> + kfree(iter); >> + break; >> + } >> + write_unlock(&io_pgtable_init_fns_list_lock); >> +} >> +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); >> diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h >> index ea727eb..45b367ce 100644 >> --- a/include/linux/io-pgtable.h >> +++ b/include/linux/io-pgtable.h >> @@ -163,6 +163,38 @@ struct io_pgtable_ops { >> }; >> /** >> + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >> + * particular format. >> + * >> + * @fmt: The page table format. >> + * @alloc: Allocate a set of page tables described by cfg. >> + * @free: Free the page tables associated with iop. >> + */ >> +struct io_pgtable_init_fns { >> + enum io_pgtable_fmt fmt; >> + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >> *cookie); >> + void (*free)(struct io_pgtable *iop); >> +}; >> + >> +/** >> + * io_pgtable_ops_register() - Register the page table routines for a >> page table >> + * format. >> + * >> + * @init_fns: The functions for allocating and freeing the page >> tables of >> + * a particular format. >> + */ >> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); >> + >> +/** >> + * io_pgtable_ops_unregister() - Unregister the page table routines >> for a page >> + * table format. >> + * >> + * @init_fns: The functions for allocating and freeing the page >> tables of >> + * a particular format. >> + */ >> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); >> + >> +/** >> * alloc_io_pgtable_ops() - Allocate a page table allocator for use >> by an IOMMU. >> * >> * @fmt: The page table format. >> @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, >> iop->cfg.tlb->tlb_add_page(gather, iova, granule, iop->cookie); >> } >> -/** >> - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >> - * particular format. >> - * >> - * @alloc: Allocate a set of page tables described by cfg. >> - * @free: Free the page tables associated with iop. >> - */ >> -struct io_pgtable_init_fns { >> - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >> *cookie); >> - void (*free)(struct io_pgtable *iop); >> -}; >> - >> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; >> - >> #endif /* __IO_PGTABLE_H */ >> > > _______________________________________________ > linux-arm-kernel mailing list > linux-arm-kernel@lists.infradead.org > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-22 19:54 ` isaacm 0 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-22 19:54 UTC (permalink / raw) To: Robin Murphy Cc: kernel-team, will, pdaly, linux-arm-msm, joro, linux-kernel, dri-devel, iommu, freedreno, linux-arm-kernel, pratikp On 2020-12-22 11:27, Robin Murphy wrote: > On 2020-12-22 00:44, Isaac J. Manjarres wrote: >> The io-pgtable code constructs an array of init functions for each >> page table format at compile time. This is not ideal, as this >> increases the footprint of the io-pgtable code, as well as prevents >> io-pgtable formats from being built as kernel modules. >> >> In preparation for modularizing the io-pgtable formats, switch to a >> dynamic registration scheme, where each io-pgtable format can register >> their init functions with the io-pgtable code at boot or module >> insertion time. >> >> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >> --- >> drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- >> drivers/iommu/io-pgtable-arm.c | 90 >> ++++++++++++++++++++++++++---------- >> drivers/iommu/io-pgtable.c | 94 >> ++++++++++++++++++++++++++++++++------ >> include/linux/io-pgtable.h | 51 +++++++++++++-------- >> 4 files changed, 209 insertions(+), 60 deletions(-) >> >> diff --git a/drivers/iommu/io-pgtable-arm-v7s.c >> b/drivers/iommu/io-pgtable-arm-v7s.c >> index 1d92ac9..89aad2f 100644 >> --- a/drivers/iommu/io-pgtable-arm-v7s.c >> +++ b/drivers/iommu/io-pgtable-arm-v7s.c >> @@ -28,6 +28,7 @@ >> #include <linux/iommu.h> >> #include <linux/kernel.h> >> #include <linux/kmemleak.h> >> +#include <linux/module.h> >> #include <linux/sizes.h> >> #include <linux/slab.h> >> #include <linux/spinlock.h> >> @@ -835,7 +836,8 @@ static struct io_pgtable >> *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, >> return NULL; >> } >> -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >> +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >> + .fmt = ARM_V7S, >> .alloc = arm_v7s_alloc_pgtable, >> .free = arm_v7s_free_pgtable, >> }; >> @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) >> pr_info("self test ok\n"); >> return 0; >> } >> -subsys_initcall(arm_v7s_do_selftests); >> +#else >> +static int arm_v7s_do_selftests(void) >> +{ >> + return 0; >> +} >> #endif >> + >> +static int __init arm_v7s_init(void) >> +{ >> + int ret; >> + >> + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); >> + if (ret < 0) { >> + pr_err("Failed to register ARM V7S format\n"); > > Super-nit: I think "v7s" should probably be lowercase there. Also > general consistency WRT to showing the error code and whether or not > to abbreviate "format" would be nice. > Ok, I can fix this accordingly. >> + return ret; >> + } >> + >> + ret = arm_v7s_do_selftests(); >> + if (ret < 0) >> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >> + >> + return ret; >> +} >> +core_initcall(arm_v7s_init); >> + >> +static void __exit arm_v7s_exit(void) >> +{ >> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >> +} >> +module_exit(arm_v7s_exit); >> diff --git a/drivers/iommu/io-pgtable-arm.c >> b/drivers/iommu/io-pgtable-arm.c >> index 87def58..ff0ea2f 100644 >> --- a/drivers/iommu/io-pgtable-arm.c >> +++ b/drivers/iommu/io-pgtable-arm.c >> @@ -13,6 +13,7 @@ >> #include <linux/bitops.h> >> #include <linux/io-pgtable.h> >> #include <linux/kernel.h> >> +#include <linux/module.h> >> #include <linux/sizes.h> >> #include <linux/slab.h> >> #include <linux/types.h> >> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct >> io_pgtable_cfg *cfg, void *cookie) >> return NULL; >> } >> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { >> - .alloc = arm_64_lpae_alloc_pgtable_s1, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { >> - .alloc = arm_64_lpae_alloc_pgtable_s2, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { >> - .alloc = arm_32_lpae_alloc_pgtable_s1, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { >> - .alloc = arm_32_lpae_alloc_pgtable_s2, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { >> - .alloc = arm_mali_lpae_alloc_pgtable, >> - .free = arm_lpae_free_pgtable, >> +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { >> + { >> + .fmt = ARM_32_LPAE_S1, >> + .alloc = arm_32_lpae_alloc_pgtable_s1, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_32_LPAE_S2, >> + .alloc = arm_32_lpae_alloc_pgtable_s2, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_64_LPAE_S1, >> + .alloc = arm_64_lpae_alloc_pgtable_s1, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_64_LPAE_S2, >> + .alloc = arm_64_lpae_alloc_pgtable_s2, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_MALI_LPAE, >> + .alloc = arm_mali_lpae_alloc_pgtable, >> + .free = arm_lpae_free_pgtable, >> + }, >> }; >> #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST >> @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) >> pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); >> return fail ? -EFAULT : 0; >> } >> -subsys_initcall(arm_lpae_do_selftests); >> +#else >> +static int __init arm_lpae_do_selftests(void) >> +{ >> + return 0; >> +} >> #endif >> + >> +static int __init arm_lpae_init(void) >> +{ >> + int ret, i; >> + >> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { >> + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); >> + if (ret < 0) { >> + pr_err("Failed to register ARM LPAE fmt: %d\n"); >> + goto err_io_pgtable_register; >> + } >> + } >> + >> + ret = arm_lpae_do_selftests(); >> + if (ret < 0) >> + goto err_io_pgtable_register; >> + >> + return 0; >> + >> +err_io_pgtable_register: >> + for (i = i - 1; i >= 0; i--) > > Personally I find "while (i--)" a bit clearer for this kind of > unwinding, but maybe post-decrement isn't to everyone's taste. > I'm not particularly attached to the current approach, so a while loop is okay with me :). >> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >> + return ret; >> +} >> +core_initcall(arm_lpae_init); >> + >> +static void __exit arm_lpae_exit(void) >> +{ >> + int i; >> + >> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >> +} >> +module_exit(arm_lpae_exit); >> diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c >> index 94394c8..2c6eb2e 100644 >> --- a/drivers/iommu/io-pgtable.c >> +++ b/drivers/iommu/io-pgtable.c >> @@ -10,33 +10,45 @@ >> #include <linux/bug.h> >> #include <linux/io-pgtable.h> >> #include <linux/kernel.h> >> +#include <linux/rwlock.h> >> +#include <linux/slab.h> >> #include <linux/types.h> >> -static const struct io_pgtable_init_fns * >> -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { >> -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE >> - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, >> - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, >> - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, >> - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, >> - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, >> -#endif >> -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S >> - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, >> -#endif >> +struct io_pgtable_init_fns_node { >> + struct io_pgtable_init_fns *fns; >> + struct list_head list; >> }; >> +static LIST_HEAD(io_pgtable_init_fns_list); >> +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); >> + >> +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum >> io_pgtable_fmt fmt) >> +{ >> + struct io_pgtable_init_fns_node *iter; >> + struct io_pgtable_init_fns *fns = NULL; >> + >> + read_lock(&io_pgtable_init_fns_list_lock); >> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >> + if (iter->fns->fmt == fmt) { >> + fns = iter->fns; >> + break; >> + } >> + read_unlock(&io_pgtable_init_fns_list_lock); >> + >> + return fns; >> +} > > I think it would be a lot easier to stick with a simple array indexed > by enum - that way you can just set/clear/test entries without needing > to worry about locking. Basically just remove the const and the > initialisers from the existing one ;) > > (and if you think you're concerned about memory, consider that just > the list head plus lock is already half the size of the table) > > Other than that, I think this all looks pretty promising - I'd suggest > sending a non-RFC after rc1 so that it gets everyone's proper > attention. > > Thanks, > Robin. > Thanks for all of the feedback! With respect to the comment about keeping the current array, don't we need some sort of lock to protect access to the data structure (e.g. concurrent access if adding two ops for the same format)? Or do you mean that we should use atomic operations to handle this cleanly? Thanks, Isaac >> + >> struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, >> struct io_pgtable_cfg *cfg, >> void *cookie) >> { >> struct io_pgtable *iop; >> - const struct io_pgtable_init_fns *fns; >> + struct io_pgtable_init_fns *fns; >> if (fmt >= IO_PGTABLE_NUM_FMTS) >> return NULL; >> - fns = io_pgtable_init_table[fmt]; >> + fns = io_pgtable_get_init_fns(fmt); >> if (!fns) >> return NULL; >> @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); >> void free_io_pgtable_ops(struct io_pgtable_ops *ops) >> { >> struct io_pgtable *iop; >> + struct io_pgtable_init_fns *fns; >> if (!ops) >> return; >> iop = io_pgtable_ops_to_pgtable(ops); >> io_pgtable_tlb_flush_all(iop); >> - io_pgtable_init_table[iop->fmt]->free(iop); >> + fns = io_pgtable_get_init_fns(iop->fmt); >> + if (fns) >> + fns->free(iop); >> } >> EXPORT_SYMBOL_GPL(free_io_pgtable_ops); >> + >> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) >> +{ >> + struct io_pgtable_init_fns_node *iter, *fns_node; >> + int ret = 0; >> + >> + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || >> + !init_fns->alloc || !init_fns->free) >> + return -EINVAL; >> + >> + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); >> + if (!fns_node) >> + return -ENOMEM; >> + >> + write_lock(&io_pgtable_init_fns_list_lock); >> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >> + if (iter->fns->fmt == init_fns->fmt) { >> + ret = -EEXIST; >> + kfree(fns_node); >> + break; >> + } >> + >> + if (!ret) { >> + fns_node->fns = init_fns; >> + INIT_LIST_HEAD(&fns_node->list); >> + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); >> + } >> + write_unlock(&io_pgtable_init_fns_list_lock); >> + return ret; >> +} >> +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); >> + >> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) >> +{ >> + struct io_pgtable_init_fns_node *iter, *tmp; >> + >> + if (!init_fns) >> + return; >> + >> + write_lock(&io_pgtable_init_fns_list_lock); >> + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, list) >> + if (iter->fns == init_fns) { >> + list_del(&iter->list); >> + kfree(iter); >> + break; >> + } >> + write_unlock(&io_pgtable_init_fns_list_lock); >> +} >> +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); >> diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h >> index ea727eb..45b367ce 100644 >> --- a/include/linux/io-pgtable.h >> +++ b/include/linux/io-pgtable.h >> @@ -163,6 +163,38 @@ struct io_pgtable_ops { >> }; >> /** >> + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >> + * particular format. >> + * >> + * @fmt: The page table format. >> + * @alloc: Allocate a set of page tables described by cfg. >> + * @free: Free the page tables associated with iop. >> + */ >> +struct io_pgtable_init_fns { >> + enum io_pgtable_fmt fmt; >> + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >> *cookie); >> + void (*free)(struct io_pgtable *iop); >> +}; >> + >> +/** >> + * io_pgtable_ops_register() - Register the page table routines for a >> page table >> + * format. >> + * >> + * @init_fns: The functions for allocating and freeing the page >> tables of >> + * a particular format. >> + */ >> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); >> + >> +/** >> + * io_pgtable_ops_unregister() - Unregister the page table routines >> for a page >> + * table format. >> + * >> + * @init_fns: The functions for allocating and freeing the page >> tables of >> + * a particular format. >> + */ >> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); >> + >> +/** >> * alloc_io_pgtable_ops() - Allocate a page table allocator for use >> by an IOMMU. >> * >> * @fmt: The page table format. >> @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, >> iop->cfg.tlb->tlb_add_page(gather, iova, granule, iop->cookie); >> } >> -/** >> - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >> - * particular format. >> - * >> - * @alloc: Allocate a set of page tables described by cfg. >> - * @free: Free the page tables associated with iop. >> - */ >> -struct io_pgtable_init_fns { >> - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >> *cookie); >> - void (*free)(struct io_pgtable *iop); >> -}; >> - >> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; >> - >> #endif /* __IO_PGTABLE_H */ >> > > _______________________________________________ > linux-arm-kernel mailing list > linux-arm-kernel@lists.infradead.org > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-22 19:54 ` isaacm 0 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-22 19:54 UTC (permalink / raw) To: Robin Murphy Cc: kernel-team, will, pdaly, linux-arm-msm, linux-kernel, dri-devel, iommu, freedreno, linux-arm-kernel, pratikp On 2020-12-22 11:27, Robin Murphy wrote: > On 2020-12-22 00:44, Isaac J. Manjarres wrote: >> The io-pgtable code constructs an array of init functions for each >> page table format at compile time. This is not ideal, as this >> increases the footprint of the io-pgtable code, as well as prevents >> io-pgtable formats from being built as kernel modules. >> >> In preparation for modularizing the io-pgtable formats, switch to a >> dynamic registration scheme, where each io-pgtable format can register >> their init functions with the io-pgtable code at boot or module >> insertion time. >> >> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >> --- >> drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- >> drivers/iommu/io-pgtable-arm.c | 90 >> ++++++++++++++++++++++++++---------- >> drivers/iommu/io-pgtable.c | 94 >> ++++++++++++++++++++++++++++++++------ >> include/linux/io-pgtable.h | 51 +++++++++++++-------- >> 4 files changed, 209 insertions(+), 60 deletions(-) >> >> diff --git a/drivers/iommu/io-pgtable-arm-v7s.c >> b/drivers/iommu/io-pgtable-arm-v7s.c >> index 1d92ac9..89aad2f 100644 >> --- a/drivers/iommu/io-pgtable-arm-v7s.c >> +++ b/drivers/iommu/io-pgtable-arm-v7s.c >> @@ -28,6 +28,7 @@ >> #include <linux/iommu.h> >> #include <linux/kernel.h> >> #include <linux/kmemleak.h> >> +#include <linux/module.h> >> #include <linux/sizes.h> >> #include <linux/slab.h> >> #include <linux/spinlock.h> >> @@ -835,7 +836,8 @@ static struct io_pgtable >> *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, >> return NULL; >> } >> -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >> +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >> + .fmt = ARM_V7S, >> .alloc = arm_v7s_alloc_pgtable, >> .free = arm_v7s_free_pgtable, >> }; >> @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) >> pr_info("self test ok\n"); >> return 0; >> } >> -subsys_initcall(arm_v7s_do_selftests); >> +#else >> +static int arm_v7s_do_selftests(void) >> +{ >> + return 0; >> +} >> #endif >> + >> +static int __init arm_v7s_init(void) >> +{ >> + int ret; >> + >> + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); >> + if (ret < 0) { >> + pr_err("Failed to register ARM V7S format\n"); > > Super-nit: I think "v7s" should probably be lowercase there. Also > general consistency WRT to showing the error code and whether or not > to abbreviate "format" would be nice. > Ok, I can fix this accordingly. >> + return ret; >> + } >> + >> + ret = arm_v7s_do_selftests(); >> + if (ret < 0) >> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >> + >> + return ret; >> +} >> +core_initcall(arm_v7s_init); >> + >> +static void __exit arm_v7s_exit(void) >> +{ >> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >> +} >> +module_exit(arm_v7s_exit); >> diff --git a/drivers/iommu/io-pgtable-arm.c >> b/drivers/iommu/io-pgtable-arm.c >> index 87def58..ff0ea2f 100644 >> --- a/drivers/iommu/io-pgtable-arm.c >> +++ b/drivers/iommu/io-pgtable-arm.c >> @@ -13,6 +13,7 @@ >> #include <linux/bitops.h> >> #include <linux/io-pgtable.h> >> #include <linux/kernel.h> >> +#include <linux/module.h> >> #include <linux/sizes.h> >> #include <linux/slab.h> >> #include <linux/types.h> >> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct >> io_pgtable_cfg *cfg, void *cookie) >> return NULL; >> } >> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { >> - .alloc = arm_64_lpae_alloc_pgtable_s1, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { >> - .alloc = arm_64_lpae_alloc_pgtable_s2, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { >> - .alloc = arm_32_lpae_alloc_pgtable_s1, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { >> - .alloc = arm_32_lpae_alloc_pgtable_s2, >> - .free = arm_lpae_free_pgtable, >> -}; >> - >> -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { >> - .alloc = arm_mali_lpae_alloc_pgtable, >> - .free = arm_lpae_free_pgtable, >> +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { >> + { >> + .fmt = ARM_32_LPAE_S1, >> + .alloc = arm_32_lpae_alloc_pgtable_s1, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_32_LPAE_S2, >> + .alloc = arm_32_lpae_alloc_pgtable_s2, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_64_LPAE_S1, >> + .alloc = arm_64_lpae_alloc_pgtable_s1, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_64_LPAE_S2, >> + .alloc = arm_64_lpae_alloc_pgtable_s2, >> + .free = arm_lpae_free_pgtable, >> + }, >> + { >> + .fmt = ARM_MALI_LPAE, >> + .alloc = arm_mali_lpae_alloc_pgtable, >> + .free = arm_lpae_free_pgtable, >> + }, >> }; >> #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST >> @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) >> pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); >> return fail ? -EFAULT : 0; >> } >> -subsys_initcall(arm_lpae_do_selftests); >> +#else >> +static int __init arm_lpae_do_selftests(void) >> +{ >> + return 0; >> +} >> #endif >> + >> +static int __init arm_lpae_init(void) >> +{ >> + int ret, i; >> + >> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { >> + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); >> + if (ret < 0) { >> + pr_err("Failed to register ARM LPAE fmt: %d\n"); >> + goto err_io_pgtable_register; >> + } >> + } >> + >> + ret = arm_lpae_do_selftests(); >> + if (ret < 0) >> + goto err_io_pgtable_register; >> + >> + return 0; >> + >> +err_io_pgtable_register: >> + for (i = i - 1; i >= 0; i--) > > Personally I find "while (i--)" a bit clearer for this kind of > unwinding, but maybe post-decrement isn't to everyone's taste. > I'm not particularly attached to the current approach, so a while loop is okay with me :). >> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >> + return ret; >> +} >> +core_initcall(arm_lpae_init); >> + >> +static void __exit arm_lpae_exit(void) >> +{ >> + int i; >> + >> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >> +} >> +module_exit(arm_lpae_exit); >> diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c >> index 94394c8..2c6eb2e 100644 >> --- a/drivers/iommu/io-pgtable.c >> +++ b/drivers/iommu/io-pgtable.c >> @@ -10,33 +10,45 @@ >> #include <linux/bug.h> >> #include <linux/io-pgtable.h> >> #include <linux/kernel.h> >> +#include <linux/rwlock.h> >> +#include <linux/slab.h> >> #include <linux/types.h> >> -static const struct io_pgtable_init_fns * >> -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { >> -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE >> - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, >> - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, >> - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, >> - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, >> - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, >> -#endif >> -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S >> - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, >> -#endif >> +struct io_pgtable_init_fns_node { >> + struct io_pgtable_init_fns *fns; >> + struct list_head list; >> }; >> +static LIST_HEAD(io_pgtable_init_fns_list); >> +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); >> + >> +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum >> io_pgtable_fmt fmt) >> +{ >> + struct io_pgtable_init_fns_node *iter; >> + struct io_pgtable_init_fns *fns = NULL; >> + >> + read_lock(&io_pgtable_init_fns_list_lock); >> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >> + if (iter->fns->fmt == fmt) { >> + fns = iter->fns; >> + break; >> + } >> + read_unlock(&io_pgtable_init_fns_list_lock); >> + >> + return fns; >> +} > > I think it would be a lot easier to stick with a simple array indexed > by enum - that way you can just set/clear/test entries without needing > to worry about locking. Basically just remove the const and the > initialisers from the existing one ;) > > (and if you think you're concerned about memory, consider that just > the list head plus lock is already half the size of the table) > > Other than that, I think this all looks pretty promising - I'd suggest > sending a non-RFC after rc1 so that it gets everyone's proper > attention. > > Thanks, > Robin. > Thanks for all of the feedback! With respect to the comment about keeping the current array, don't we need some sort of lock to protect access to the data structure (e.g. concurrent access if adding two ops for the same format)? Or do you mean that we should use atomic operations to handle this cleanly? Thanks, Isaac >> + >> struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, >> struct io_pgtable_cfg *cfg, >> void *cookie) >> { >> struct io_pgtable *iop; >> - const struct io_pgtable_init_fns *fns; >> + struct io_pgtable_init_fns *fns; >> if (fmt >= IO_PGTABLE_NUM_FMTS) >> return NULL; >> - fns = io_pgtable_init_table[fmt]; >> + fns = io_pgtable_get_init_fns(fmt); >> if (!fns) >> return NULL; >> @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); >> void free_io_pgtable_ops(struct io_pgtable_ops *ops) >> { >> struct io_pgtable *iop; >> + struct io_pgtable_init_fns *fns; >> if (!ops) >> return; >> iop = io_pgtable_ops_to_pgtable(ops); >> io_pgtable_tlb_flush_all(iop); >> - io_pgtable_init_table[iop->fmt]->free(iop); >> + fns = io_pgtable_get_init_fns(iop->fmt); >> + if (fns) >> + fns->free(iop); >> } >> EXPORT_SYMBOL_GPL(free_io_pgtable_ops); >> + >> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) >> +{ >> + struct io_pgtable_init_fns_node *iter, *fns_node; >> + int ret = 0; >> + >> + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || >> + !init_fns->alloc || !init_fns->free) >> + return -EINVAL; >> + >> + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); >> + if (!fns_node) >> + return -ENOMEM; >> + >> + write_lock(&io_pgtable_init_fns_list_lock); >> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >> + if (iter->fns->fmt == init_fns->fmt) { >> + ret = -EEXIST; >> + kfree(fns_node); >> + break; >> + } >> + >> + if (!ret) { >> + fns_node->fns = init_fns; >> + INIT_LIST_HEAD(&fns_node->list); >> + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); >> + } >> + write_unlock(&io_pgtable_init_fns_list_lock); >> + return ret; >> +} >> +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); >> + >> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) >> +{ >> + struct io_pgtable_init_fns_node *iter, *tmp; >> + >> + if (!init_fns) >> + return; >> + >> + write_lock(&io_pgtable_init_fns_list_lock); >> + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, list) >> + if (iter->fns == init_fns) { >> + list_del(&iter->list); >> + kfree(iter); >> + break; >> + } >> + write_unlock(&io_pgtable_init_fns_list_lock); >> +} >> +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); >> diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h >> index ea727eb..45b367ce 100644 >> --- a/include/linux/io-pgtable.h >> +++ b/include/linux/io-pgtable.h >> @@ -163,6 +163,38 @@ struct io_pgtable_ops { >> }; >> /** >> + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >> + * particular format. >> + * >> + * @fmt: The page table format. >> + * @alloc: Allocate a set of page tables described by cfg. >> + * @free: Free the page tables associated with iop. >> + */ >> +struct io_pgtable_init_fns { >> + enum io_pgtable_fmt fmt; >> + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >> *cookie); >> + void (*free)(struct io_pgtable *iop); >> +}; >> + >> +/** >> + * io_pgtable_ops_register() - Register the page table routines for a >> page table >> + * format. >> + * >> + * @init_fns: The functions for allocating and freeing the page >> tables of >> + * a particular format. >> + */ >> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); >> + >> +/** >> + * io_pgtable_ops_unregister() - Unregister the page table routines >> for a page >> + * table format. >> + * >> + * @init_fns: The functions for allocating and freeing the page >> tables of >> + * a particular format. >> + */ >> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); >> + >> +/** >> * alloc_io_pgtable_ops() - Allocate a page table allocator for use >> by an IOMMU. >> * >> * @fmt: The page table format. >> @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, >> iop->cfg.tlb->tlb_add_page(gather, iova, granule, iop->cookie); >> } >> -/** >> - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >> - * particular format. >> - * >> - * @alloc: Allocate a set of page tables described by cfg. >> - * @free: Free the page tables associated with iop. >> - */ >> -struct io_pgtable_init_fns { >> - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >> *cookie); >> - void (*free)(struct io_pgtable *iop); >> -}; >> - >> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; >> -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; >> - >> #endif /* __IO_PGTABLE_H */ >> > > _______________________________________________ > linux-arm-kernel mailing list > linux-arm-kernel@lists.infradead.org > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration 2020-12-22 19:54 ` isaacm (?) (?) @ 2020-12-23 13:44 ` Robin Murphy -1 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-23 13:44 UTC (permalink / raw) To: isaacm Cc: kernel-team, will, pdaly, linux-arm-msm, linux-kernel, dri-devel, iommu, freedreno, linux-arm-kernel, pratikp On 2020-12-22 19:54, isaacm@codeaurora.org wrote: > On 2020-12-22 11:27, Robin Murphy wrote: >> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>> The io-pgtable code constructs an array of init functions for each >>> page table format at compile time. This is not ideal, as this >>> increases the footprint of the io-pgtable code, as well as prevents >>> io-pgtable formats from being built as kernel modules. >>> >>> In preparation for modularizing the io-pgtable formats, switch to a >>> dynamic registration scheme, where each io-pgtable format can register >>> their init functions with the io-pgtable code at boot or module >>> insertion time. >>> >>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>> --- >>> drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- >>> drivers/iommu/io-pgtable-arm.c | 90 >>> ++++++++++++++++++++++++++---------- >>> drivers/iommu/io-pgtable.c | 94 >>> ++++++++++++++++++++++++++++++++------ >>> include/linux/io-pgtable.h | 51 +++++++++++++-------- >>> 4 files changed, 209 insertions(+), 60 deletions(-) >>> >>> diff --git a/drivers/iommu/io-pgtable-arm-v7s.c >>> b/drivers/iommu/io-pgtable-arm-v7s.c >>> index 1d92ac9..89aad2f 100644 >>> --- a/drivers/iommu/io-pgtable-arm-v7s.c >>> +++ b/drivers/iommu/io-pgtable-arm-v7s.c >>> @@ -28,6 +28,7 @@ >>> #include <linux/iommu.h> >>> #include <linux/kernel.h> >>> #include <linux/kmemleak.h> >>> +#include <linux/module.h> >>> #include <linux/sizes.h> >>> #include <linux/slab.h> >>> #include <linux/spinlock.h> >>> @@ -835,7 +836,8 @@ static struct io_pgtable >>> *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, >>> return NULL; >>> } >>> -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>> +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>> + .fmt = ARM_V7S, >>> .alloc = arm_v7s_alloc_pgtable, >>> .free = arm_v7s_free_pgtable, >>> }; >>> @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) >>> pr_info("self test ok\n"); >>> return 0; >>> } >>> -subsys_initcall(arm_v7s_do_selftests); >>> +#else >>> +static int arm_v7s_do_selftests(void) >>> +{ >>> + return 0; >>> +} >>> #endif >>> + >>> +static int __init arm_v7s_init(void) >>> +{ >>> + int ret; >>> + >>> + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); >>> + if (ret < 0) { >>> + pr_err("Failed to register ARM V7S format\n"); >> >> Super-nit: I think "v7s" should probably be lowercase there. Also >> general consistency WRT to showing the error code and whether or not >> to abbreviate "format" would be nice. >> > Ok, I can fix this accordingly. > >>> + return ret; >>> + } >>> + >>> + ret = arm_v7s_do_selftests(); >>> + if (ret < 0) >>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>> + >>> + return ret; >>> +} >>> +core_initcall(arm_v7s_init); >>> + >>> +static void __exit arm_v7s_exit(void) >>> +{ >>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>> +} >>> +module_exit(arm_v7s_exit); >>> diff --git a/drivers/iommu/io-pgtable-arm.c >>> b/drivers/iommu/io-pgtable-arm.c >>> index 87def58..ff0ea2f 100644 >>> --- a/drivers/iommu/io-pgtable-arm.c >>> +++ b/drivers/iommu/io-pgtable-arm.c >>> @@ -13,6 +13,7 @@ >>> #include <linux/bitops.h> >>> #include <linux/io-pgtable.h> >>> #include <linux/kernel.h> >>> +#include <linux/module.h> >>> #include <linux/sizes.h> >>> #include <linux/slab.h> >>> #include <linux/types.h> >>> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct >>> io_pgtable_cfg *cfg, void *cookie) >>> return NULL; >>> } >>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { >>> - .alloc = arm_64_lpae_alloc_pgtable_s1, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { >>> - .alloc = arm_64_lpae_alloc_pgtable_s2, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { >>> - .alloc = arm_32_lpae_alloc_pgtable_s1, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { >>> - .alloc = arm_32_lpae_alloc_pgtable_s2, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { >>> - .alloc = arm_mali_lpae_alloc_pgtable, >>> - .free = arm_lpae_free_pgtable, >>> +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { >>> + { >>> + .fmt = ARM_32_LPAE_S1, >>> + .alloc = arm_32_lpae_alloc_pgtable_s1, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_32_LPAE_S2, >>> + .alloc = arm_32_lpae_alloc_pgtable_s2, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_64_LPAE_S1, >>> + .alloc = arm_64_lpae_alloc_pgtable_s1, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_64_LPAE_S2, >>> + .alloc = arm_64_lpae_alloc_pgtable_s2, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_MALI_LPAE, >>> + .alloc = arm_mali_lpae_alloc_pgtable, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> }; >>> #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST >>> @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) >>> pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); >>> return fail ? -EFAULT : 0; >>> } >>> -subsys_initcall(arm_lpae_do_selftests); >>> +#else >>> +static int __init arm_lpae_do_selftests(void) >>> +{ >>> + return 0; >>> +} >>> #endif >>> + >>> +static int __init arm_lpae_init(void) >>> +{ >>> + int ret, i; >>> + >>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { >>> + ret = >>> io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); >>> + if (ret < 0) { >>> + pr_err("Failed to register ARM LPAE fmt: %d\n"); >>> + goto err_io_pgtable_register; >>> + } >>> + } >>> + >>> + ret = arm_lpae_do_selftests(); >>> + if (ret < 0) >>> + goto err_io_pgtable_register; >>> + >>> + return 0; >>> + >>> +err_io_pgtable_register: >>> + for (i = i - 1; i >= 0; i--) >> >> Personally I find "while (i--)" a bit clearer for this kind of >> unwinding, but maybe post-decrement isn't to everyone's taste. >> > I'm not particularly attached to the current approach, so a while loop > is okay with me :). > >>> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>> + return ret; >>> +} >>> +core_initcall(arm_lpae_init); >>> + >>> +static void __exit arm_lpae_exit(void) >>> +{ >>> + int i; >>> + >>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >>> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>> +} >>> +module_exit(arm_lpae_exit); >>> diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c >>> index 94394c8..2c6eb2e 100644 >>> --- a/drivers/iommu/io-pgtable.c >>> +++ b/drivers/iommu/io-pgtable.c >>> @@ -10,33 +10,45 @@ >>> #include <linux/bug.h> >>> #include <linux/io-pgtable.h> >>> #include <linux/kernel.h> >>> +#include <linux/rwlock.h> >>> +#include <linux/slab.h> >>> #include <linux/types.h> >>> -static const struct io_pgtable_init_fns * >>> -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { >>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE >>> - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, >>> - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, >>> - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, >>> - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, >>> - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, >>> -#endif >>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S >>> - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, >>> -#endif >>> +struct io_pgtable_init_fns_node { >>> + struct io_pgtable_init_fns *fns; >>> + struct list_head list; >>> }; >>> +static LIST_HEAD(io_pgtable_init_fns_list); >>> +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); >>> + >>> +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum >>> io_pgtable_fmt fmt) >>> +{ >>> + struct io_pgtable_init_fns_node *iter; >>> + struct io_pgtable_init_fns *fns = NULL; >>> + >>> + read_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>> + if (iter->fns->fmt == fmt) { >>> + fns = iter->fns; >>> + break; >>> + } >>> + read_unlock(&io_pgtable_init_fns_list_lock); >>> + >>> + return fns; >>> +} >> >> I think it would be a lot easier to stick with a simple array indexed >> by enum - that way you can just set/clear/test entries without needing >> to worry about locking. Basically just remove the const and the >> initialisers from the existing one ;) >> >> (and if you think you're concerned about memory, consider that just >> the list head plus lock is already half the size of the table) >> >> Other than that, I think this all looks pretty promising - I'd suggest >> sending a non-RFC after rc1 so that it gets everyone's proper >> attention. >> >> Thanks, >> Robin. >> > > Thanks for all of the feedback! With respect to the comment about > keeping the current array, > don't we need some sort of lock to protect access to the data structure > (e.g. concurrent access > if adding two ops for the same format)? Or do you mean that we should > use atomic operations to > handle this cleanly? I don't think any races are realistically possible - built-in initcalls should run sequentially, while module init should be serialised by the module loader lock, so registrations should never be able to race against each other. And if there could be a race between registering a format and somebody trying to use it, then something's fundamentally wrong anyway - sure we could use READ_ONCE/WRITE_ONCE for accessing the table, but that would be basically be admitting that we've failed at the primary purpose of making sure formats are loaded *before* the users that depend on them. With a directly-indexed table there's no contention between looking up one format and registering another unrelated format, unlike with a list. Robin. > > Thanks, > Isaac >>> + >>> struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, >>> struct io_pgtable_cfg *cfg, >>> void *cookie) >>> { >>> struct io_pgtable *iop; >>> - const struct io_pgtable_init_fns *fns; >>> + struct io_pgtable_init_fns *fns; >>> if (fmt >= IO_PGTABLE_NUM_FMTS) >>> return NULL; >>> - fns = io_pgtable_init_table[fmt]; >>> + fns = io_pgtable_get_init_fns(fmt); >>> if (!fns) >>> return NULL; >>> @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); >>> void free_io_pgtable_ops(struct io_pgtable_ops *ops) >>> { >>> struct io_pgtable *iop; >>> + struct io_pgtable_init_fns *fns; >>> if (!ops) >>> return; >>> iop = io_pgtable_ops_to_pgtable(ops); >>> io_pgtable_tlb_flush_all(iop); >>> - io_pgtable_init_table[iop->fmt]->free(iop); >>> + fns = io_pgtable_get_init_fns(iop->fmt); >>> + if (fns) >>> + fns->free(iop); >>> } >>> EXPORT_SYMBOL_GPL(free_io_pgtable_ops); >>> + >>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) >>> +{ >>> + struct io_pgtable_init_fns_node *iter, *fns_node; >>> + int ret = 0; >>> + >>> + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || >>> + !init_fns->alloc || !init_fns->free) >>> + return -EINVAL; >>> + >>> + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); >>> + if (!fns_node) >>> + return -ENOMEM; >>> + >>> + write_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>> + if (iter->fns->fmt == init_fns->fmt) { >>> + ret = -EEXIST; >>> + kfree(fns_node); >>> + break; >>> + } >>> + >>> + if (!ret) { >>> + fns_node->fns = init_fns; >>> + INIT_LIST_HEAD(&fns_node->list); >>> + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); >>> + } >>> + write_unlock(&io_pgtable_init_fns_list_lock); >>> + return ret; >>> +} >>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); >>> + >>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) >>> +{ >>> + struct io_pgtable_init_fns_node *iter, *tmp; >>> + >>> + if (!init_fns) >>> + return; >>> + >>> + write_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, >>> list) >>> + if (iter->fns == init_fns) { >>> + list_del(&iter->list); >>> + kfree(iter); >>> + break; >>> + } >>> + write_unlock(&io_pgtable_init_fns_list_lock); >>> +} >>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); >>> diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h >>> index ea727eb..45b367ce 100644 >>> --- a/include/linux/io-pgtable.h >>> +++ b/include/linux/io-pgtable.h >>> @@ -163,6 +163,38 @@ struct io_pgtable_ops { >>> }; >>> /** >>> + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >>> + * particular format. >>> + * >>> + * @fmt: The page table format. >>> + * @alloc: Allocate a set of page tables described by cfg. >>> + * @free: Free the page tables associated with iop. >>> + */ >>> +struct io_pgtable_init_fns { >>> + enum io_pgtable_fmt fmt; >>> + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>> *cookie); >>> + void (*free)(struct io_pgtable *iop); >>> +}; >>> + >>> +/** >>> + * io_pgtable_ops_register() - Register the page table routines for >>> a page table >>> + * format. >>> + * >>> + * @init_fns: The functions for allocating and freeing the page >>> tables of >>> + * a particular format. >>> + */ >>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); >>> + >>> +/** >>> + * io_pgtable_ops_unregister() - Unregister the page table routines >>> for a page >>> + * table format. >>> + * >>> + * @init_fns: The functions for allocating and freeing the page >>> tables of >>> + * a particular format. >>> + */ >>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); >>> + >>> +/** >>> * alloc_io_pgtable_ops() - Allocate a page table allocator for use >>> by an IOMMU. >>> * >>> * @fmt: The page table format. >>> @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, >>> iop->cfg.tlb->tlb_add_page(gather, iova, granule, >>> iop->cookie); >>> } >>> -/** >>> - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >>> - * particular format. >>> - * >>> - * @alloc: Allocate a set of page tables described by cfg. >>> - * @free: Free the page tables associated with iop. >>> - */ >>> -struct io_pgtable_init_fns { >>> - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>> *cookie); >>> - void (*free)(struct io_pgtable *iop); >>> -}; >>> - >>> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; >>> - >>> #endif /* __IO_PGTABLE_H */ >>> >> >> _______________________________________________ >> linux-arm-kernel mailing list >> linux-arm-kernel@lists.infradead.org >> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel > _______________________________________________ > iommu mailing list > iommu@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 13:44 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-23 13:44 UTC (permalink / raw) To: isaacm Cc: freedreno, kernel-team, pdaly, linux-arm-msm, linux-kernel, dri-devel, iommu, will, linux-arm-kernel, pratikp On 2020-12-22 19:54, isaacm@codeaurora.org wrote: > On 2020-12-22 11:27, Robin Murphy wrote: >> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>> The io-pgtable code constructs an array of init functions for each >>> page table format at compile time. This is not ideal, as this >>> increases the footprint of the io-pgtable code, as well as prevents >>> io-pgtable formats from being built as kernel modules. >>> >>> In preparation for modularizing the io-pgtable formats, switch to a >>> dynamic registration scheme, where each io-pgtable format can register >>> their init functions with the io-pgtable code at boot or module >>> insertion time. >>> >>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>> --- >>> drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- >>> drivers/iommu/io-pgtable-arm.c | 90 >>> ++++++++++++++++++++++++++---------- >>> drivers/iommu/io-pgtable.c | 94 >>> ++++++++++++++++++++++++++++++++------ >>> include/linux/io-pgtable.h | 51 +++++++++++++-------- >>> 4 files changed, 209 insertions(+), 60 deletions(-) >>> >>> diff --git a/drivers/iommu/io-pgtable-arm-v7s.c >>> b/drivers/iommu/io-pgtable-arm-v7s.c >>> index 1d92ac9..89aad2f 100644 >>> --- a/drivers/iommu/io-pgtable-arm-v7s.c >>> +++ b/drivers/iommu/io-pgtable-arm-v7s.c >>> @@ -28,6 +28,7 @@ >>> #include <linux/iommu.h> >>> #include <linux/kernel.h> >>> #include <linux/kmemleak.h> >>> +#include <linux/module.h> >>> #include <linux/sizes.h> >>> #include <linux/slab.h> >>> #include <linux/spinlock.h> >>> @@ -835,7 +836,8 @@ static struct io_pgtable >>> *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, >>> return NULL; >>> } >>> -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>> +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>> + .fmt = ARM_V7S, >>> .alloc = arm_v7s_alloc_pgtable, >>> .free = arm_v7s_free_pgtable, >>> }; >>> @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) >>> pr_info("self test ok\n"); >>> return 0; >>> } >>> -subsys_initcall(arm_v7s_do_selftests); >>> +#else >>> +static int arm_v7s_do_selftests(void) >>> +{ >>> + return 0; >>> +} >>> #endif >>> + >>> +static int __init arm_v7s_init(void) >>> +{ >>> + int ret; >>> + >>> + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); >>> + if (ret < 0) { >>> + pr_err("Failed to register ARM V7S format\n"); >> >> Super-nit: I think "v7s" should probably be lowercase there. Also >> general consistency WRT to showing the error code and whether or not >> to abbreviate "format" would be nice. >> > Ok, I can fix this accordingly. > >>> + return ret; >>> + } >>> + >>> + ret = arm_v7s_do_selftests(); >>> + if (ret < 0) >>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>> + >>> + return ret; >>> +} >>> +core_initcall(arm_v7s_init); >>> + >>> +static void __exit arm_v7s_exit(void) >>> +{ >>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>> +} >>> +module_exit(arm_v7s_exit); >>> diff --git a/drivers/iommu/io-pgtable-arm.c >>> b/drivers/iommu/io-pgtable-arm.c >>> index 87def58..ff0ea2f 100644 >>> --- a/drivers/iommu/io-pgtable-arm.c >>> +++ b/drivers/iommu/io-pgtable-arm.c >>> @@ -13,6 +13,7 @@ >>> #include <linux/bitops.h> >>> #include <linux/io-pgtable.h> >>> #include <linux/kernel.h> >>> +#include <linux/module.h> >>> #include <linux/sizes.h> >>> #include <linux/slab.h> >>> #include <linux/types.h> >>> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct >>> io_pgtable_cfg *cfg, void *cookie) >>> return NULL; >>> } >>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { >>> - .alloc = arm_64_lpae_alloc_pgtable_s1, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { >>> - .alloc = arm_64_lpae_alloc_pgtable_s2, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { >>> - .alloc = arm_32_lpae_alloc_pgtable_s1, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { >>> - .alloc = arm_32_lpae_alloc_pgtable_s2, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { >>> - .alloc = arm_mali_lpae_alloc_pgtable, >>> - .free = arm_lpae_free_pgtable, >>> +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { >>> + { >>> + .fmt = ARM_32_LPAE_S1, >>> + .alloc = arm_32_lpae_alloc_pgtable_s1, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_32_LPAE_S2, >>> + .alloc = arm_32_lpae_alloc_pgtable_s2, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_64_LPAE_S1, >>> + .alloc = arm_64_lpae_alloc_pgtable_s1, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_64_LPAE_S2, >>> + .alloc = arm_64_lpae_alloc_pgtable_s2, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_MALI_LPAE, >>> + .alloc = arm_mali_lpae_alloc_pgtable, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> }; >>> #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST >>> @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) >>> pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); >>> return fail ? -EFAULT : 0; >>> } >>> -subsys_initcall(arm_lpae_do_selftests); >>> +#else >>> +static int __init arm_lpae_do_selftests(void) >>> +{ >>> + return 0; >>> +} >>> #endif >>> + >>> +static int __init arm_lpae_init(void) >>> +{ >>> + int ret, i; >>> + >>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { >>> + ret = >>> io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); >>> + if (ret < 0) { >>> + pr_err("Failed to register ARM LPAE fmt: %d\n"); >>> + goto err_io_pgtable_register; >>> + } >>> + } >>> + >>> + ret = arm_lpae_do_selftests(); >>> + if (ret < 0) >>> + goto err_io_pgtable_register; >>> + >>> + return 0; >>> + >>> +err_io_pgtable_register: >>> + for (i = i - 1; i >= 0; i--) >> >> Personally I find "while (i--)" a bit clearer for this kind of >> unwinding, but maybe post-decrement isn't to everyone's taste. >> > I'm not particularly attached to the current approach, so a while loop > is okay with me :). > >>> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>> + return ret; >>> +} >>> +core_initcall(arm_lpae_init); >>> + >>> +static void __exit arm_lpae_exit(void) >>> +{ >>> + int i; >>> + >>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >>> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>> +} >>> +module_exit(arm_lpae_exit); >>> diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c >>> index 94394c8..2c6eb2e 100644 >>> --- a/drivers/iommu/io-pgtable.c >>> +++ b/drivers/iommu/io-pgtable.c >>> @@ -10,33 +10,45 @@ >>> #include <linux/bug.h> >>> #include <linux/io-pgtable.h> >>> #include <linux/kernel.h> >>> +#include <linux/rwlock.h> >>> +#include <linux/slab.h> >>> #include <linux/types.h> >>> -static const struct io_pgtable_init_fns * >>> -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { >>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE >>> - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, >>> - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, >>> - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, >>> - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, >>> - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, >>> -#endif >>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S >>> - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, >>> -#endif >>> +struct io_pgtable_init_fns_node { >>> + struct io_pgtable_init_fns *fns; >>> + struct list_head list; >>> }; >>> +static LIST_HEAD(io_pgtable_init_fns_list); >>> +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); >>> + >>> +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum >>> io_pgtable_fmt fmt) >>> +{ >>> + struct io_pgtable_init_fns_node *iter; >>> + struct io_pgtable_init_fns *fns = NULL; >>> + >>> + read_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>> + if (iter->fns->fmt == fmt) { >>> + fns = iter->fns; >>> + break; >>> + } >>> + read_unlock(&io_pgtable_init_fns_list_lock); >>> + >>> + return fns; >>> +} >> >> I think it would be a lot easier to stick with a simple array indexed >> by enum - that way you can just set/clear/test entries without needing >> to worry about locking. Basically just remove the const and the >> initialisers from the existing one ;) >> >> (and if you think you're concerned about memory, consider that just >> the list head plus lock is already half the size of the table) >> >> Other than that, I think this all looks pretty promising - I'd suggest >> sending a non-RFC after rc1 so that it gets everyone's proper >> attention. >> >> Thanks, >> Robin. >> > > Thanks for all of the feedback! With respect to the comment about > keeping the current array, > don't we need some sort of lock to protect access to the data structure > (e.g. concurrent access > if adding two ops for the same format)? Or do you mean that we should > use atomic operations to > handle this cleanly? I don't think any races are realistically possible - built-in initcalls should run sequentially, while module init should be serialised by the module loader lock, so registrations should never be able to race against each other. And if there could be a race between registering a format and somebody trying to use it, then something's fundamentally wrong anyway - sure we could use READ_ONCE/WRITE_ONCE for accessing the table, but that would be basically be admitting that we've failed at the primary purpose of making sure formats are loaded *before* the users that depend on them. With a directly-indexed table there's no contention between looking up one format and registering another unrelated format, unlike with a list. Robin. > > Thanks, > Isaac >>> + >>> struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, >>> struct io_pgtable_cfg *cfg, >>> void *cookie) >>> { >>> struct io_pgtable *iop; >>> - const struct io_pgtable_init_fns *fns; >>> + struct io_pgtable_init_fns *fns; >>> if (fmt >= IO_PGTABLE_NUM_FMTS) >>> return NULL; >>> - fns = io_pgtable_init_table[fmt]; >>> + fns = io_pgtable_get_init_fns(fmt); >>> if (!fns) >>> return NULL; >>> @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); >>> void free_io_pgtable_ops(struct io_pgtable_ops *ops) >>> { >>> struct io_pgtable *iop; >>> + struct io_pgtable_init_fns *fns; >>> if (!ops) >>> return; >>> iop = io_pgtable_ops_to_pgtable(ops); >>> io_pgtable_tlb_flush_all(iop); >>> - io_pgtable_init_table[iop->fmt]->free(iop); >>> + fns = io_pgtable_get_init_fns(iop->fmt); >>> + if (fns) >>> + fns->free(iop); >>> } >>> EXPORT_SYMBOL_GPL(free_io_pgtable_ops); >>> + >>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) >>> +{ >>> + struct io_pgtable_init_fns_node *iter, *fns_node; >>> + int ret = 0; >>> + >>> + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || >>> + !init_fns->alloc || !init_fns->free) >>> + return -EINVAL; >>> + >>> + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); >>> + if (!fns_node) >>> + return -ENOMEM; >>> + >>> + write_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>> + if (iter->fns->fmt == init_fns->fmt) { >>> + ret = -EEXIST; >>> + kfree(fns_node); >>> + break; >>> + } >>> + >>> + if (!ret) { >>> + fns_node->fns = init_fns; >>> + INIT_LIST_HEAD(&fns_node->list); >>> + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); >>> + } >>> + write_unlock(&io_pgtable_init_fns_list_lock); >>> + return ret; >>> +} >>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); >>> + >>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) >>> +{ >>> + struct io_pgtable_init_fns_node *iter, *tmp; >>> + >>> + if (!init_fns) >>> + return; >>> + >>> + write_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, >>> list) >>> + if (iter->fns == init_fns) { >>> + list_del(&iter->list); >>> + kfree(iter); >>> + break; >>> + } >>> + write_unlock(&io_pgtable_init_fns_list_lock); >>> +} >>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); >>> diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h >>> index ea727eb..45b367ce 100644 >>> --- a/include/linux/io-pgtable.h >>> +++ b/include/linux/io-pgtable.h >>> @@ -163,6 +163,38 @@ struct io_pgtable_ops { >>> }; >>> /** >>> + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >>> + * particular format. >>> + * >>> + * @fmt: The page table format. >>> + * @alloc: Allocate a set of page tables described by cfg. >>> + * @free: Free the page tables associated with iop. >>> + */ >>> +struct io_pgtable_init_fns { >>> + enum io_pgtable_fmt fmt; >>> + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>> *cookie); >>> + void (*free)(struct io_pgtable *iop); >>> +}; >>> + >>> +/** >>> + * io_pgtable_ops_register() - Register the page table routines for >>> a page table >>> + * format. >>> + * >>> + * @init_fns: The functions for allocating and freeing the page >>> tables of >>> + * a particular format. >>> + */ >>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); >>> + >>> +/** >>> + * io_pgtable_ops_unregister() - Unregister the page table routines >>> for a page >>> + * table format. >>> + * >>> + * @init_fns: The functions for allocating and freeing the page >>> tables of >>> + * a particular format. >>> + */ >>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); >>> + >>> +/** >>> * alloc_io_pgtable_ops() - Allocate a page table allocator for use >>> by an IOMMU. >>> * >>> * @fmt: The page table format. >>> @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, >>> iop->cfg.tlb->tlb_add_page(gather, iova, granule, >>> iop->cookie); >>> } >>> -/** >>> - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >>> - * particular format. >>> - * >>> - * @alloc: Allocate a set of page tables described by cfg. >>> - * @free: Free the page tables associated with iop. >>> - */ >>> -struct io_pgtable_init_fns { >>> - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>> *cookie); >>> - void (*free)(struct io_pgtable *iop); >>> -}; >>> - >>> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; >>> - >>> #endif /* __IO_PGTABLE_H */ >>> >> >> _______________________________________________ >> linux-arm-kernel mailing list >> linux-arm-kernel@lists.infradead.org >> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel > _______________________________________________ > iommu mailing list > iommu@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 13:44 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-23 13:44 UTC (permalink / raw) To: isaacm Cc: freedreno, kernel-team, pdaly, linux-arm-msm, linux-kernel, dri-devel, iommu, will, linux-arm-kernel, pratikp On 2020-12-22 19:54, isaacm@codeaurora.org wrote: > On 2020-12-22 11:27, Robin Murphy wrote: >> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>> The io-pgtable code constructs an array of init functions for each >>> page table format at compile time. This is not ideal, as this >>> increases the footprint of the io-pgtable code, as well as prevents >>> io-pgtable formats from being built as kernel modules. >>> >>> In preparation for modularizing the io-pgtable formats, switch to a >>> dynamic registration scheme, where each io-pgtable format can register >>> their init functions with the io-pgtable code at boot or module >>> insertion time. >>> >>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>> --- >>> drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- >>> drivers/iommu/io-pgtable-arm.c | 90 >>> ++++++++++++++++++++++++++---------- >>> drivers/iommu/io-pgtable.c | 94 >>> ++++++++++++++++++++++++++++++++------ >>> include/linux/io-pgtable.h | 51 +++++++++++++-------- >>> 4 files changed, 209 insertions(+), 60 deletions(-) >>> >>> diff --git a/drivers/iommu/io-pgtable-arm-v7s.c >>> b/drivers/iommu/io-pgtable-arm-v7s.c >>> index 1d92ac9..89aad2f 100644 >>> --- a/drivers/iommu/io-pgtable-arm-v7s.c >>> +++ b/drivers/iommu/io-pgtable-arm-v7s.c >>> @@ -28,6 +28,7 @@ >>> #include <linux/iommu.h> >>> #include <linux/kernel.h> >>> #include <linux/kmemleak.h> >>> +#include <linux/module.h> >>> #include <linux/sizes.h> >>> #include <linux/slab.h> >>> #include <linux/spinlock.h> >>> @@ -835,7 +836,8 @@ static struct io_pgtable >>> *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, >>> return NULL; >>> } >>> -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>> +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>> + .fmt = ARM_V7S, >>> .alloc = arm_v7s_alloc_pgtable, >>> .free = arm_v7s_free_pgtable, >>> }; >>> @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) >>> pr_info("self test ok\n"); >>> return 0; >>> } >>> -subsys_initcall(arm_v7s_do_selftests); >>> +#else >>> +static int arm_v7s_do_selftests(void) >>> +{ >>> + return 0; >>> +} >>> #endif >>> + >>> +static int __init arm_v7s_init(void) >>> +{ >>> + int ret; >>> + >>> + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); >>> + if (ret < 0) { >>> + pr_err("Failed to register ARM V7S format\n"); >> >> Super-nit: I think "v7s" should probably be lowercase there. Also >> general consistency WRT to showing the error code and whether or not >> to abbreviate "format" would be nice. >> > Ok, I can fix this accordingly. > >>> + return ret; >>> + } >>> + >>> + ret = arm_v7s_do_selftests(); >>> + if (ret < 0) >>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>> + >>> + return ret; >>> +} >>> +core_initcall(arm_v7s_init); >>> + >>> +static void __exit arm_v7s_exit(void) >>> +{ >>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>> +} >>> +module_exit(arm_v7s_exit); >>> diff --git a/drivers/iommu/io-pgtable-arm.c >>> b/drivers/iommu/io-pgtable-arm.c >>> index 87def58..ff0ea2f 100644 >>> --- a/drivers/iommu/io-pgtable-arm.c >>> +++ b/drivers/iommu/io-pgtable-arm.c >>> @@ -13,6 +13,7 @@ >>> #include <linux/bitops.h> >>> #include <linux/io-pgtable.h> >>> #include <linux/kernel.h> >>> +#include <linux/module.h> >>> #include <linux/sizes.h> >>> #include <linux/slab.h> >>> #include <linux/types.h> >>> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct >>> io_pgtable_cfg *cfg, void *cookie) >>> return NULL; >>> } >>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { >>> - .alloc = arm_64_lpae_alloc_pgtable_s1, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { >>> - .alloc = arm_64_lpae_alloc_pgtable_s2, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { >>> - .alloc = arm_32_lpae_alloc_pgtable_s1, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { >>> - .alloc = arm_32_lpae_alloc_pgtable_s2, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { >>> - .alloc = arm_mali_lpae_alloc_pgtable, >>> - .free = arm_lpae_free_pgtable, >>> +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { >>> + { >>> + .fmt = ARM_32_LPAE_S1, >>> + .alloc = arm_32_lpae_alloc_pgtable_s1, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_32_LPAE_S2, >>> + .alloc = arm_32_lpae_alloc_pgtable_s2, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_64_LPAE_S1, >>> + .alloc = arm_64_lpae_alloc_pgtable_s1, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_64_LPAE_S2, >>> + .alloc = arm_64_lpae_alloc_pgtable_s2, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_MALI_LPAE, >>> + .alloc = arm_mali_lpae_alloc_pgtable, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> }; >>> #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST >>> @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) >>> pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); >>> return fail ? -EFAULT : 0; >>> } >>> -subsys_initcall(arm_lpae_do_selftests); >>> +#else >>> +static int __init arm_lpae_do_selftests(void) >>> +{ >>> + return 0; >>> +} >>> #endif >>> + >>> +static int __init arm_lpae_init(void) >>> +{ >>> + int ret, i; >>> + >>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { >>> + ret = >>> io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); >>> + if (ret < 0) { >>> + pr_err("Failed to register ARM LPAE fmt: %d\n"); >>> + goto err_io_pgtable_register; >>> + } >>> + } >>> + >>> + ret = arm_lpae_do_selftests(); >>> + if (ret < 0) >>> + goto err_io_pgtable_register; >>> + >>> + return 0; >>> + >>> +err_io_pgtable_register: >>> + for (i = i - 1; i >= 0; i--) >> >> Personally I find "while (i--)" a bit clearer for this kind of >> unwinding, but maybe post-decrement isn't to everyone's taste. >> > I'm not particularly attached to the current approach, so a while loop > is okay with me :). > >>> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>> + return ret; >>> +} >>> +core_initcall(arm_lpae_init); >>> + >>> +static void __exit arm_lpae_exit(void) >>> +{ >>> + int i; >>> + >>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >>> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>> +} >>> +module_exit(arm_lpae_exit); >>> diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c >>> index 94394c8..2c6eb2e 100644 >>> --- a/drivers/iommu/io-pgtable.c >>> +++ b/drivers/iommu/io-pgtable.c >>> @@ -10,33 +10,45 @@ >>> #include <linux/bug.h> >>> #include <linux/io-pgtable.h> >>> #include <linux/kernel.h> >>> +#include <linux/rwlock.h> >>> +#include <linux/slab.h> >>> #include <linux/types.h> >>> -static const struct io_pgtable_init_fns * >>> -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { >>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE >>> - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, >>> - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, >>> - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, >>> - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, >>> - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, >>> -#endif >>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S >>> - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, >>> -#endif >>> +struct io_pgtable_init_fns_node { >>> + struct io_pgtable_init_fns *fns; >>> + struct list_head list; >>> }; >>> +static LIST_HEAD(io_pgtable_init_fns_list); >>> +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); >>> + >>> +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum >>> io_pgtable_fmt fmt) >>> +{ >>> + struct io_pgtable_init_fns_node *iter; >>> + struct io_pgtable_init_fns *fns = NULL; >>> + >>> + read_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>> + if (iter->fns->fmt == fmt) { >>> + fns = iter->fns; >>> + break; >>> + } >>> + read_unlock(&io_pgtable_init_fns_list_lock); >>> + >>> + return fns; >>> +} >> >> I think it would be a lot easier to stick with a simple array indexed >> by enum - that way you can just set/clear/test entries without needing >> to worry about locking. Basically just remove the const and the >> initialisers from the existing one ;) >> >> (and if you think you're concerned about memory, consider that just >> the list head plus lock is already half the size of the table) >> >> Other than that, I think this all looks pretty promising - I'd suggest >> sending a non-RFC after rc1 so that it gets everyone's proper >> attention. >> >> Thanks, >> Robin. >> > > Thanks for all of the feedback! With respect to the comment about > keeping the current array, > don't we need some sort of lock to protect access to the data structure > (e.g. concurrent access > if adding two ops for the same format)? Or do you mean that we should > use atomic operations to > handle this cleanly? I don't think any races are realistically possible - built-in initcalls should run sequentially, while module init should be serialised by the module loader lock, so registrations should never be able to race against each other. And if there could be a race between registering a format and somebody trying to use it, then something's fundamentally wrong anyway - sure we could use READ_ONCE/WRITE_ONCE for accessing the table, but that would be basically be admitting that we've failed at the primary purpose of making sure formats are loaded *before* the users that depend on them. With a directly-indexed table there's no contention between looking up one format and registering another unrelated format, unlike with a list. Robin. > > Thanks, > Isaac >>> + >>> struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, >>> struct io_pgtable_cfg *cfg, >>> void *cookie) >>> { >>> struct io_pgtable *iop; >>> - const struct io_pgtable_init_fns *fns; >>> + struct io_pgtable_init_fns *fns; >>> if (fmt >= IO_PGTABLE_NUM_FMTS) >>> return NULL; >>> - fns = io_pgtable_init_table[fmt]; >>> + fns = io_pgtable_get_init_fns(fmt); >>> if (!fns) >>> return NULL; >>> @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); >>> void free_io_pgtable_ops(struct io_pgtable_ops *ops) >>> { >>> struct io_pgtable *iop; >>> + struct io_pgtable_init_fns *fns; >>> if (!ops) >>> return; >>> iop = io_pgtable_ops_to_pgtable(ops); >>> io_pgtable_tlb_flush_all(iop); >>> - io_pgtable_init_table[iop->fmt]->free(iop); >>> + fns = io_pgtable_get_init_fns(iop->fmt); >>> + if (fns) >>> + fns->free(iop); >>> } >>> EXPORT_SYMBOL_GPL(free_io_pgtable_ops); >>> + >>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) >>> +{ >>> + struct io_pgtable_init_fns_node *iter, *fns_node; >>> + int ret = 0; >>> + >>> + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || >>> + !init_fns->alloc || !init_fns->free) >>> + return -EINVAL; >>> + >>> + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); >>> + if (!fns_node) >>> + return -ENOMEM; >>> + >>> + write_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>> + if (iter->fns->fmt == init_fns->fmt) { >>> + ret = -EEXIST; >>> + kfree(fns_node); >>> + break; >>> + } >>> + >>> + if (!ret) { >>> + fns_node->fns = init_fns; >>> + INIT_LIST_HEAD(&fns_node->list); >>> + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); >>> + } >>> + write_unlock(&io_pgtable_init_fns_list_lock); >>> + return ret; >>> +} >>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); >>> + >>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) >>> +{ >>> + struct io_pgtable_init_fns_node *iter, *tmp; >>> + >>> + if (!init_fns) >>> + return; >>> + >>> + write_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, >>> list) >>> + if (iter->fns == init_fns) { >>> + list_del(&iter->list); >>> + kfree(iter); >>> + break; >>> + } >>> + write_unlock(&io_pgtable_init_fns_list_lock); >>> +} >>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); >>> diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h >>> index ea727eb..45b367ce 100644 >>> --- a/include/linux/io-pgtable.h >>> +++ b/include/linux/io-pgtable.h >>> @@ -163,6 +163,38 @@ struct io_pgtable_ops { >>> }; >>> /** >>> + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >>> + * particular format. >>> + * >>> + * @fmt: The page table format. >>> + * @alloc: Allocate a set of page tables described by cfg. >>> + * @free: Free the page tables associated with iop. >>> + */ >>> +struct io_pgtable_init_fns { >>> + enum io_pgtable_fmt fmt; >>> + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>> *cookie); >>> + void (*free)(struct io_pgtable *iop); >>> +}; >>> + >>> +/** >>> + * io_pgtable_ops_register() - Register the page table routines for >>> a page table >>> + * format. >>> + * >>> + * @init_fns: The functions for allocating and freeing the page >>> tables of >>> + * a particular format. >>> + */ >>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); >>> + >>> +/** >>> + * io_pgtable_ops_unregister() - Unregister the page table routines >>> for a page >>> + * table format. >>> + * >>> + * @init_fns: The functions for allocating and freeing the page >>> tables of >>> + * a particular format. >>> + */ >>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); >>> + >>> +/** >>> * alloc_io_pgtable_ops() - Allocate a page table allocator for use >>> by an IOMMU. >>> * >>> * @fmt: The page table format. >>> @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, >>> iop->cfg.tlb->tlb_add_page(gather, iova, granule, >>> iop->cookie); >>> } >>> -/** >>> - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >>> - * particular format. >>> - * >>> - * @alloc: Allocate a set of page tables described by cfg. >>> - * @free: Free the page tables associated with iop. >>> - */ >>> -struct io_pgtable_init_fns { >>> - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>> *cookie); >>> - void (*free)(struct io_pgtable *iop); >>> -}; >>> - >>> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; >>> - >>> #endif /* __IO_PGTABLE_H */ >>> >> >> _______________________________________________ >> linux-arm-kernel mailing list >> linux-arm-kernel@lists.infradead.org >> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel > _______________________________________________ > iommu mailing list > iommu@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 13:44 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-23 13:44 UTC (permalink / raw) To: isaacm Cc: freedreno, kernel-team, pdaly, linux-arm-msm, linux-kernel, dri-devel, iommu, will, linux-arm-kernel, pratikp On 2020-12-22 19:54, isaacm@codeaurora.org wrote: > On 2020-12-22 11:27, Robin Murphy wrote: >> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>> The io-pgtable code constructs an array of init functions for each >>> page table format at compile time. This is not ideal, as this >>> increases the footprint of the io-pgtable code, as well as prevents >>> io-pgtable formats from being built as kernel modules. >>> >>> In preparation for modularizing the io-pgtable formats, switch to a >>> dynamic registration scheme, where each io-pgtable format can register >>> their init functions with the io-pgtable code at boot or module >>> insertion time. >>> >>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>> --- >>> drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- >>> drivers/iommu/io-pgtable-arm.c | 90 >>> ++++++++++++++++++++++++++---------- >>> drivers/iommu/io-pgtable.c | 94 >>> ++++++++++++++++++++++++++++++++------ >>> include/linux/io-pgtable.h | 51 +++++++++++++-------- >>> 4 files changed, 209 insertions(+), 60 deletions(-) >>> >>> diff --git a/drivers/iommu/io-pgtable-arm-v7s.c >>> b/drivers/iommu/io-pgtable-arm-v7s.c >>> index 1d92ac9..89aad2f 100644 >>> --- a/drivers/iommu/io-pgtable-arm-v7s.c >>> +++ b/drivers/iommu/io-pgtable-arm-v7s.c >>> @@ -28,6 +28,7 @@ >>> #include <linux/iommu.h> >>> #include <linux/kernel.h> >>> #include <linux/kmemleak.h> >>> +#include <linux/module.h> >>> #include <linux/sizes.h> >>> #include <linux/slab.h> >>> #include <linux/spinlock.h> >>> @@ -835,7 +836,8 @@ static struct io_pgtable >>> *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, >>> return NULL; >>> } >>> -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>> +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>> + .fmt = ARM_V7S, >>> .alloc = arm_v7s_alloc_pgtable, >>> .free = arm_v7s_free_pgtable, >>> }; >>> @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) >>> pr_info("self test ok\n"); >>> return 0; >>> } >>> -subsys_initcall(arm_v7s_do_selftests); >>> +#else >>> +static int arm_v7s_do_selftests(void) >>> +{ >>> + return 0; >>> +} >>> #endif >>> + >>> +static int __init arm_v7s_init(void) >>> +{ >>> + int ret; >>> + >>> + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); >>> + if (ret < 0) { >>> + pr_err("Failed to register ARM V7S format\n"); >> >> Super-nit: I think "v7s" should probably be lowercase there. Also >> general consistency WRT to showing the error code and whether or not >> to abbreviate "format" would be nice. >> > Ok, I can fix this accordingly. > >>> + return ret; >>> + } >>> + >>> + ret = arm_v7s_do_selftests(); >>> + if (ret < 0) >>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>> + >>> + return ret; >>> +} >>> +core_initcall(arm_v7s_init); >>> + >>> +static void __exit arm_v7s_exit(void) >>> +{ >>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>> +} >>> +module_exit(arm_v7s_exit); >>> diff --git a/drivers/iommu/io-pgtable-arm.c >>> b/drivers/iommu/io-pgtable-arm.c >>> index 87def58..ff0ea2f 100644 >>> --- a/drivers/iommu/io-pgtable-arm.c >>> +++ b/drivers/iommu/io-pgtable-arm.c >>> @@ -13,6 +13,7 @@ >>> #include <linux/bitops.h> >>> #include <linux/io-pgtable.h> >>> #include <linux/kernel.h> >>> +#include <linux/module.h> >>> #include <linux/sizes.h> >>> #include <linux/slab.h> >>> #include <linux/types.h> >>> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct >>> io_pgtable_cfg *cfg, void *cookie) >>> return NULL; >>> } >>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { >>> - .alloc = arm_64_lpae_alloc_pgtable_s1, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { >>> - .alloc = arm_64_lpae_alloc_pgtable_s2, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { >>> - .alloc = arm_32_lpae_alloc_pgtable_s1, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { >>> - .alloc = arm_32_lpae_alloc_pgtable_s2, >>> - .free = arm_lpae_free_pgtable, >>> -}; >>> - >>> -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { >>> - .alloc = arm_mali_lpae_alloc_pgtable, >>> - .free = arm_lpae_free_pgtable, >>> +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { >>> + { >>> + .fmt = ARM_32_LPAE_S1, >>> + .alloc = arm_32_lpae_alloc_pgtable_s1, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_32_LPAE_S2, >>> + .alloc = arm_32_lpae_alloc_pgtable_s2, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_64_LPAE_S1, >>> + .alloc = arm_64_lpae_alloc_pgtable_s1, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_64_LPAE_S2, >>> + .alloc = arm_64_lpae_alloc_pgtable_s2, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> + { >>> + .fmt = ARM_MALI_LPAE, >>> + .alloc = arm_mali_lpae_alloc_pgtable, >>> + .free = arm_lpae_free_pgtable, >>> + }, >>> }; >>> #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST >>> @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) >>> pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail); >>> return fail ? -EFAULT : 0; >>> } >>> -subsys_initcall(arm_lpae_do_selftests); >>> +#else >>> +static int __init arm_lpae_do_selftests(void) >>> +{ >>> + return 0; >>> +} >>> #endif >>> + >>> +static int __init arm_lpae_init(void) >>> +{ >>> + int ret, i; >>> + >>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { >>> + ret = >>> io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); >>> + if (ret < 0) { >>> + pr_err("Failed to register ARM LPAE fmt: %d\n"); >>> + goto err_io_pgtable_register; >>> + } >>> + } >>> + >>> + ret = arm_lpae_do_selftests(); >>> + if (ret < 0) >>> + goto err_io_pgtable_register; >>> + >>> + return 0; >>> + >>> +err_io_pgtable_register: >>> + for (i = i - 1; i >= 0; i--) >> >> Personally I find "while (i--)" a bit clearer for this kind of >> unwinding, but maybe post-decrement isn't to everyone's taste. >> > I'm not particularly attached to the current approach, so a while loop > is okay with me :). > >>> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>> + return ret; >>> +} >>> +core_initcall(arm_lpae_init); >>> + >>> +static void __exit arm_lpae_exit(void) >>> +{ >>> + int i; >>> + >>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >>> + io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>> +} >>> +module_exit(arm_lpae_exit); >>> diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c >>> index 94394c8..2c6eb2e 100644 >>> --- a/drivers/iommu/io-pgtable.c >>> +++ b/drivers/iommu/io-pgtable.c >>> @@ -10,33 +10,45 @@ >>> #include <linux/bug.h> >>> #include <linux/io-pgtable.h> >>> #include <linux/kernel.h> >>> +#include <linux/rwlock.h> >>> +#include <linux/slab.h> >>> #include <linux/types.h> >>> -static const struct io_pgtable_init_fns * >>> -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { >>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE >>> - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, >>> - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, >>> - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, >>> - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, >>> - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, >>> -#endif >>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S >>> - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, >>> -#endif >>> +struct io_pgtable_init_fns_node { >>> + struct io_pgtable_init_fns *fns; >>> + struct list_head list; >>> }; >>> +static LIST_HEAD(io_pgtable_init_fns_list); >>> +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); >>> + >>> +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum >>> io_pgtable_fmt fmt) >>> +{ >>> + struct io_pgtable_init_fns_node *iter; >>> + struct io_pgtable_init_fns *fns = NULL; >>> + >>> + read_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>> + if (iter->fns->fmt == fmt) { >>> + fns = iter->fns; >>> + break; >>> + } >>> + read_unlock(&io_pgtable_init_fns_list_lock); >>> + >>> + return fns; >>> +} >> >> I think it would be a lot easier to stick with a simple array indexed >> by enum - that way you can just set/clear/test entries without needing >> to worry about locking. Basically just remove the const and the >> initialisers from the existing one ;) >> >> (and if you think you're concerned about memory, consider that just >> the list head plus lock is already half the size of the table) >> >> Other than that, I think this all looks pretty promising - I'd suggest >> sending a non-RFC after rc1 so that it gets everyone's proper >> attention. >> >> Thanks, >> Robin. >> > > Thanks for all of the feedback! With respect to the comment about > keeping the current array, > don't we need some sort of lock to protect access to the data structure > (e.g. concurrent access > if adding two ops for the same format)? Or do you mean that we should > use atomic operations to > handle this cleanly? I don't think any races are realistically possible - built-in initcalls should run sequentially, while module init should be serialised by the module loader lock, so registrations should never be able to race against each other. And if there could be a race between registering a format and somebody trying to use it, then something's fundamentally wrong anyway - sure we could use READ_ONCE/WRITE_ONCE for accessing the table, but that would be basically be admitting that we've failed at the primary purpose of making sure formats are loaded *before* the users that depend on them. With a directly-indexed table there's no contention between looking up one format and registering another unrelated format, unlike with a list. Robin. > > Thanks, > Isaac >>> + >>> struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, >>> struct io_pgtable_cfg *cfg, >>> void *cookie) >>> { >>> struct io_pgtable *iop; >>> - const struct io_pgtable_init_fns *fns; >>> + struct io_pgtable_init_fns *fns; >>> if (fmt >= IO_PGTABLE_NUM_FMTS) >>> return NULL; >>> - fns = io_pgtable_init_table[fmt]; >>> + fns = io_pgtable_get_init_fns(fmt); >>> if (!fns) >>> return NULL; >>> @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); >>> void free_io_pgtable_ops(struct io_pgtable_ops *ops) >>> { >>> struct io_pgtable *iop; >>> + struct io_pgtable_init_fns *fns; >>> if (!ops) >>> return; >>> iop = io_pgtable_ops_to_pgtable(ops); >>> io_pgtable_tlb_flush_all(iop); >>> - io_pgtable_init_table[iop->fmt]->free(iop); >>> + fns = io_pgtable_get_init_fns(iop->fmt); >>> + if (fns) >>> + fns->free(iop); >>> } >>> EXPORT_SYMBOL_GPL(free_io_pgtable_ops); >>> + >>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) >>> +{ >>> + struct io_pgtable_init_fns_node *iter, *fns_node; >>> + int ret = 0; >>> + >>> + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || >>> + !init_fns->alloc || !init_fns->free) >>> + return -EINVAL; >>> + >>> + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); >>> + if (!fns_node) >>> + return -ENOMEM; >>> + >>> + write_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>> + if (iter->fns->fmt == init_fns->fmt) { >>> + ret = -EEXIST; >>> + kfree(fns_node); >>> + break; >>> + } >>> + >>> + if (!ret) { >>> + fns_node->fns = init_fns; >>> + INIT_LIST_HEAD(&fns_node->list); >>> + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); >>> + } >>> + write_unlock(&io_pgtable_init_fns_list_lock); >>> + return ret; >>> +} >>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); >>> + >>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns) >>> +{ >>> + struct io_pgtable_init_fns_node *iter, *tmp; >>> + >>> + if (!init_fns) >>> + return; >>> + >>> + write_lock(&io_pgtable_init_fns_list_lock); >>> + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, >>> list) >>> + if (iter->fns == init_fns) { >>> + list_del(&iter->list); >>> + kfree(iter); >>> + break; >>> + } >>> + write_unlock(&io_pgtable_init_fns_list_lock); >>> +} >>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); >>> diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h >>> index ea727eb..45b367ce 100644 >>> --- a/include/linux/io-pgtable.h >>> +++ b/include/linux/io-pgtable.h >>> @@ -163,6 +163,38 @@ struct io_pgtable_ops { >>> }; >>> /** >>> + * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >>> + * particular format. >>> + * >>> + * @fmt: The page table format. >>> + * @alloc: Allocate a set of page tables described by cfg. >>> + * @free: Free the page tables associated with iop. >>> + */ >>> +struct io_pgtable_init_fns { >>> + enum io_pgtable_fmt fmt; >>> + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>> *cookie); >>> + void (*free)(struct io_pgtable *iop); >>> +}; >>> + >>> +/** >>> + * io_pgtable_ops_register() - Register the page table routines for >>> a page table >>> + * format. >>> + * >>> + * @init_fns: The functions for allocating and freeing the page >>> tables of >>> + * a particular format. >>> + */ >>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); >>> + >>> +/** >>> + * io_pgtable_ops_unregister() - Unregister the page table routines >>> for a page >>> + * table format. >>> + * >>> + * @init_fns: The functions for allocating and freeing the page >>> tables of >>> + * a particular format. >>> + */ >>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns *init_fns); >>> + >>> +/** >>> * alloc_io_pgtable_ops() - Allocate a page table allocator for use >>> by an IOMMU. >>> * >>> * @fmt: The page table format. >>> @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, >>> iop->cfg.tlb->tlb_add_page(gather, iova, granule, >>> iop->cookie); >>> } >>> -/** >>> - * struct io_pgtable_init_fns - Alloc/free a set of page tables for a >>> - * particular format. >>> - * >>> - * @alloc: Allocate a set of page tables described by cfg. >>> - * @free: Free the page tables associated with iop. >>> - */ >>> -struct io_pgtable_init_fns { >>> - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>> *cookie); >>> - void (*free)(struct io_pgtable *iop); >>> -}; >>> - >>> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; >>> -extern struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns; >>> - >>> #endif /* __IO_PGTABLE_H */ >>> >> >> _______________________________________________ >> linux-arm-kernel mailing list >> linux-arm-kernel@lists.infradead.org >> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel > _______________________________________________ > iommu mailing list > iommu@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration 2020-12-23 13:44 ` Robin Murphy (?) @ 2020-12-23 15:14 ` isaacm -1 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-23 15:14 UTC (permalink / raw) To: Robin Murphy Cc: kernel-team, will, pdaly, linux-arm-msm, linux-kernel, dri-devel, iommu, freedreno, linux-arm-kernel, pratikp On 2020-12-23 05:44, Robin Murphy wrote: > On 2020-12-22 19:54, isaacm@codeaurora.org wrote: >> On 2020-12-22 11:27, Robin Murphy wrote: >>> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>>> The io-pgtable code constructs an array of init functions for each >>>> page table format at compile time. This is not ideal, as this >>>> increases the footprint of the io-pgtable code, as well as prevents >>>> io-pgtable formats from being built as kernel modules. >>>> >>>> In preparation for modularizing the io-pgtable formats, switch to a >>>> dynamic registration scheme, where each io-pgtable format can >>>> register >>>> their init functions with the io-pgtable code at boot or module >>>> insertion time. >>>> >>>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>>> --- >>>> drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- >>>> drivers/iommu/io-pgtable-arm.c | 90 >>>> ++++++++++++++++++++++++++---------- >>>> drivers/iommu/io-pgtable.c | 94 >>>> ++++++++++++++++++++++++++++++++------ >>>> include/linux/io-pgtable.h | 51 +++++++++++++-------- >>>> 4 files changed, 209 insertions(+), 60 deletions(-) >>>> >>>> diff --git a/drivers/iommu/io-pgtable-arm-v7s.c >>>> b/drivers/iommu/io-pgtable-arm-v7s.c >>>> index 1d92ac9..89aad2f 100644 >>>> --- a/drivers/iommu/io-pgtable-arm-v7s.c >>>> +++ b/drivers/iommu/io-pgtable-arm-v7s.c >>>> @@ -28,6 +28,7 @@ >>>> #include <linux/iommu.h> >>>> #include <linux/kernel.h> >>>> #include <linux/kmemleak.h> >>>> +#include <linux/module.h> >>>> #include <linux/sizes.h> >>>> #include <linux/slab.h> >>>> #include <linux/spinlock.h> >>>> @@ -835,7 +836,8 @@ static struct io_pgtable >>>> *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, >>>> return NULL; >>>> } >>>> -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>>> +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>>> + .fmt = ARM_V7S, >>>> .alloc = arm_v7s_alloc_pgtable, >>>> .free = arm_v7s_free_pgtable, >>>> }; >>>> @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) >>>> pr_info("self test ok\n"); >>>> return 0; >>>> } >>>> -subsys_initcall(arm_v7s_do_selftests); >>>> +#else >>>> +static int arm_v7s_do_selftests(void) >>>> +{ >>>> + return 0; >>>> +} >>>> #endif >>>> + >>>> +static int __init arm_v7s_init(void) >>>> +{ >>>> + int ret; >>>> + >>>> + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); >>>> + if (ret < 0) { >>>> + pr_err("Failed to register ARM V7S format\n"); >>> >>> Super-nit: I think "v7s" should probably be lowercase there. Also >>> general consistency WRT to showing the error code and whether or not >>> to abbreviate "format" would be nice. >>> >> Ok, I can fix this accordingly. >> >>>> + return ret; >>>> + } >>>> + >>>> + ret = arm_v7s_do_selftests(); >>>> + if (ret < 0) >>>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>>> + >>>> + return ret; >>>> +} >>>> +core_initcall(arm_v7s_init); >>>> + >>>> +static void __exit arm_v7s_exit(void) >>>> +{ >>>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>>> +} >>>> +module_exit(arm_v7s_exit); >>>> diff --git a/drivers/iommu/io-pgtable-arm.c >>>> b/drivers/iommu/io-pgtable-arm.c >>>> index 87def58..ff0ea2f 100644 >>>> --- a/drivers/iommu/io-pgtable-arm.c >>>> +++ b/drivers/iommu/io-pgtable-arm.c >>>> @@ -13,6 +13,7 @@ >>>> #include <linux/bitops.h> >>>> #include <linux/io-pgtable.h> >>>> #include <linux/kernel.h> >>>> +#include <linux/module.h> >>>> #include <linux/sizes.h> >>>> #include <linux/slab.h> >>>> #include <linux/types.h> >>>> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct >>>> io_pgtable_cfg *cfg, void *cookie) >>>> return NULL; >>>> } >>>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { >>>> - .alloc = arm_64_lpae_alloc_pgtable_s1, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { >>>> - .alloc = arm_64_lpae_alloc_pgtable_s2, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { >>>> - .alloc = arm_32_lpae_alloc_pgtable_s1, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { >>>> - .alloc = arm_32_lpae_alloc_pgtable_s2, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { >>>> - .alloc = arm_mali_lpae_alloc_pgtable, >>>> - .free = arm_lpae_free_pgtable, >>>> +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = >>>> { >>>> + { >>>> + .fmt = ARM_32_LPAE_S1, >>>> + .alloc = arm_32_lpae_alloc_pgtable_s1, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_32_LPAE_S2, >>>> + .alloc = arm_32_lpae_alloc_pgtable_s2, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_64_LPAE_S1, >>>> + .alloc = arm_64_lpae_alloc_pgtable_s1, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_64_LPAE_S2, >>>> + .alloc = arm_64_lpae_alloc_pgtable_s2, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_MALI_LPAE, >>>> + .alloc = arm_mali_lpae_alloc_pgtable, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> }; >>>> #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST >>>> @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) >>>> pr_info("selftest: completed with %d PASS %d FAIL\n", pass, >>>> fail); >>>> return fail ? -EFAULT : 0; >>>> } >>>> -subsys_initcall(arm_lpae_do_selftests); >>>> +#else >>>> +static int __init arm_lpae_do_selftests(void) >>>> +{ >>>> + return 0; >>>> +} >>>> #endif >>>> + >>>> +static int __init arm_lpae_init(void) >>>> +{ >>>> + int ret, i; >>>> + >>>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >>>> { >>>> + ret = >>>> io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); >>>> + if (ret < 0) { >>>> + pr_err("Failed to register ARM LPAE fmt: %d\n"); >>>> + goto err_io_pgtable_register; >>>> + } >>>> + } >>>> + >>>> + ret = arm_lpae_do_selftests(); >>>> + if (ret < 0) >>>> + goto err_io_pgtable_register; >>>> + >>>> + return 0; >>>> + >>>> +err_io_pgtable_register: >>>> + for (i = i - 1; i >= 0; i--) >>> >>> Personally I find "while (i--)" a bit clearer for this kind of >>> unwinding, but maybe post-decrement isn't to everyone's taste. >>> >> I'm not particularly attached to the current approach, so a while loop >> is okay with me :). >> >>>> + >>>> io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>>> + return ret; >>>> +} >>>> +core_initcall(arm_lpae_init); >>>> + >>>> +static void __exit arm_lpae_exit(void) >>>> +{ >>>> + int i; >>>> + >>>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >>>> + >>>> io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>>> +} >>>> +module_exit(arm_lpae_exit); >>>> diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c >>>> index 94394c8..2c6eb2e 100644 >>>> --- a/drivers/iommu/io-pgtable.c >>>> +++ b/drivers/iommu/io-pgtable.c >>>> @@ -10,33 +10,45 @@ >>>> #include <linux/bug.h> >>>> #include <linux/io-pgtable.h> >>>> #include <linux/kernel.h> >>>> +#include <linux/rwlock.h> >>>> +#include <linux/slab.h> >>>> #include <linux/types.h> >>>> -static const struct io_pgtable_init_fns * >>>> -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { >>>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE >>>> - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, >>>> - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, >>>> - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, >>>> - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, >>>> - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, >>>> -#endif >>>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S >>>> - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, >>>> -#endif >>>> +struct io_pgtable_init_fns_node { >>>> + struct io_pgtable_init_fns *fns; >>>> + struct list_head list; >>>> }; >>>> +static LIST_HEAD(io_pgtable_init_fns_list); >>>> +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); >>>> + >>>> +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum >>>> io_pgtable_fmt fmt) >>>> +{ >>>> + struct io_pgtable_init_fns_node *iter; >>>> + struct io_pgtable_init_fns *fns = NULL; >>>> + >>>> + read_lock(&io_pgtable_init_fns_list_lock); >>>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>>> + if (iter->fns->fmt == fmt) { >>>> + fns = iter->fns; >>>> + break; >>>> + } >>>> + read_unlock(&io_pgtable_init_fns_list_lock); >>>> + >>>> + return fns; >>>> +} >>> >>> I think it would be a lot easier to stick with a simple array indexed >>> by enum - that way you can just set/clear/test entries without >>> needing >>> to worry about locking. Basically just remove the const and the >>> initialisers from the existing one ;) >>> >>> (and if you think you're concerned about memory, consider that just >>> the list head plus lock is already half the size of the table) >>> >>> Other than that, I think this all looks pretty promising - I'd >>> suggest >>> sending a non-RFC after rc1 so that it gets everyone's proper >>> attention. >>> >>> Thanks, >>> Robin. >>> >> >> Thanks for all of the feedback! With respect to the comment about >> keeping the current array, >> don't we need some sort of lock to protect access to the data >> structure (e.g. concurrent access >> if adding two ops for the same format)? Or do you mean that we should >> use atomic operations to >> handle this cleanly? > > I don't think any races are realistically possible - built-in > initcalls should run sequentially, while module init should be > serialised by the module loader lock, so registrations should never be > able to race against each other. And if there could be a race between > registering a format and somebody trying to use it, then something's > fundamentally wrong anyway - sure we could use READ_ONCE/WRITE_ONCE > for accessing the table, but that would be basically be admitting that > we've failed at the primary purpose of making sure formats are loaded > *before* the users that depend on them. > > With a directly-indexed table there's no contention between looking up > one format and registering another unrelated format, unlike with a > list. > > Robin. > Got it. I'll stick with the array as suggested. Thanks again for the feedback. I'll be sending the version with your suggestions when 5.11-rc1 comes out as a non-RFC. --Isaac >> >> Thanks, >> Isaac >>>> + >>>> struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt >>>> fmt, >>>> struct io_pgtable_cfg *cfg, >>>> void *cookie) >>>> { >>>> struct io_pgtable *iop; >>>> - const struct io_pgtable_init_fns *fns; >>>> + struct io_pgtable_init_fns *fns; >>>> if (fmt >= IO_PGTABLE_NUM_FMTS) >>>> return NULL; >>>> - fns = io_pgtable_init_table[fmt]; >>>> + fns = io_pgtable_get_init_fns(fmt); >>>> if (!fns) >>>> return NULL; >>>> @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); >>>> void free_io_pgtable_ops(struct io_pgtable_ops *ops) >>>> { >>>> struct io_pgtable *iop; >>>> + struct io_pgtable_init_fns *fns; >>>> if (!ops) >>>> return; >>>> iop = io_pgtable_ops_to_pgtable(ops); >>>> io_pgtable_tlb_flush_all(iop); >>>> - io_pgtable_init_table[iop->fmt]->free(iop); >>>> + fns = io_pgtable_get_init_fns(iop->fmt); >>>> + if (fns) >>>> + fns->free(iop); >>>> } >>>> EXPORT_SYMBOL_GPL(free_io_pgtable_ops); >>>> + >>>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) >>>> +{ >>>> + struct io_pgtable_init_fns_node *iter, *fns_node; >>>> + int ret = 0; >>>> + >>>> + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || >>>> + !init_fns->alloc || !init_fns->free) >>>> + return -EINVAL; >>>> + >>>> + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); >>>> + if (!fns_node) >>>> + return -ENOMEM; >>>> + >>>> + write_lock(&io_pgtable_init_fns_list_lock); >>>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>>> + if (iter->fns->fmt == init_fns->fmt) { >>>> + ret = -EEXIST; >>>> + kfree(fns_node); >>>> + break; >>>> + } >>>> + >>>> + if (!ret) { >>>> + fns_node->fns = init_fns; >>>> + INIT_LIST_HEAD(&fns_node->list); >>>> + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); >>>> + } >>>> + write_unlock(&io_pgtable_init_fns_list_lock); >>>> + return ret; >>>> +} >>>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); >>>> + >>>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns >>>> *init_fns) >>>> +{ >>>> + struct io_pgtable_init_fns_node *iter, *tmp; >>>> + >>>> + if (!init_fns) >>>> + return; >>>> + >>>> + write_lock(&io_pgtable_init_fns_list_lock); >>>> + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, >>>> list) >>>> + if (iter->fns == init_fns) { >>>> + list_del(&iter->list); >>>> + kfree(iter); >>>> + break; >>>> + } >>>> + write_unlock(&io_pgtable_init_fns_list_lock); >>>> +} >>>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); >>>> diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h >>>> index ea727eb..45b367ce 100644 >>>> --- a/include/linux/io-pgtable.h >>>> +++ b/include/linux/io-pgtable.h >>>> @@ -163,6 +163,38 @@ struct io_pgtable_ops { >>>> }; >>>> /** >>>> + * struct io_pgtable_init_fns - Alloc/free a set of page tables for >>>> a >>>> + * particular format. >>>> + * >>>> + * @fmt: The page table format. >>>> + * @alloc: Allocate a set of page tables described by cfg. >>>> + * @free: Free the page tables associated with iop. >>>> + */ >>>> +struct io_pgtable_init_fns { >>>> + enum io_pgtable_fmt fmt; >>>> + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>>> *cookie); >>>> + void (*free)(struct io_pgtable *iop); >>>> +}; >>>> + >>>> +/** >>>> + * io_pgtable_ops_register() - Register the page table routines for >>>> a page table >>>> + * format. >>>> + * >>>> + * @init_fns: The functions for allocating and freeing the page >>>> tables of >>>> + * a particular format. >>>> + */ >>>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); >>>> + >>>> +/** >>>> + * io_pgtable_ops_unregister() - Unregister the page table routines >>>> for a page >>>> + * table format. >>>> + * >>>> + * @init_fns: The functions for allocating and freeing the page >>>> tables of >>>> + * a particular format. >>>> + */ >>>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns >>>> *init_fns); >>>> + >>>> +/** >>>> * alloc_io_pgtable_ops() - Allocate a page table allocator for >>>> use by an IOMMU. >>>> * >>>> * @fmt: The page table format. >>>> @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, >>>> iop->cfg.tlb->tlb_add_page(gather, iova, granule, >>>> iop->cookie); >>>> } >>>> -/** >>>> - * struct io_pgtable_init_fns - Alloc/free a set of page tables for >>>> a >>>> - * particular format. >>>> - * >>>> - * @alloc: Allocate a set of page tables described by cfg. >>>> - * @free: Free the page tables associated with iop. >>>> - */ >>>> -struct io_pgtable_init_fns { >>>> - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>>> *cookie); >>>> - void (*free)(struct io_pgtable *iop); >>>> -}; >>>> - >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_32_lpae_s1_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_32_lpae_s2_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_64_lpae_s1_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_64_lpae_s2_init_fns; >>>> -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_mali_lpae_init_fns; >>>> - >>>> #endif /* __IO_PGTABLE_H */ >>>> >>> >>> _______________________________________________ >>> linux-arm-kernel mailing list >>> linux-arm-kernel@lists.infradead.org >>> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel >> _______________________________________________ >> iommu mailing list >> iommu@lists.linux-foundation.org >> https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 15:14 ` isaacm 0 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-23 15:14 UTC (permalink / raw) To: Robin Murphy Cc: freedreno, kernel-team, pdaly, linux-arm-msm, linux-kernel, dri-devel, iommu, will, linux-arm-kernel, pratikp On 2020-12-23 05:44, Robin Murphy wrote: > On 2020-12-22 19:54, isaacm@codeaurora.org wrote: >> On 2020-12-22 11:27, Robin Murphy wrote: >>> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>>> The io-pgtable code constructs an array of init functions for each >>>> page table format at compile time. This is not ideal, as this >>>> increases the footprint of the io-pgtable code, as well as prevents >>>> io-pgtable formats from being built as kernel modules. >>>> >>>> In preparation for modularizing the io-pgtable formats, switch to a >>>> dynamic registration scheme, where each io-pgtable format can >>>> register >>>> their init functions with the io-pgtable code at boot or module >>>> insertion time. >>>> >>>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>>> --- >>>> drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- >>>> drivers/iommu/io-pgtable-arm.c | 90 >>>> ++++++++++++++++++++++++++---------- >>>> drivers/iommu/io-pgtable.c | 94 >>>> ++++++++++++++++++++++++++++++++------ >>>> include/linux/io-pgtable.h | 51 +++++++++++++-------- >>>> 4 files changed, 209 insertions(+), 60 deletions(-) >>>> >>>> diff --git a/drivers/iommu/io-pgtable-arm-v7s.c >>>> b/drivers/iommu/io-pgtable-arm-v7s.c >>>> index 1d92ac9..89aad2f 100644 >>>> --- a/drivers/iommu/io-pgtable-arm-v7s.c >>>> +++ b/drivers/iommu/io-pgtable-arm-v7s.c >>>> @@ -28,6 +28,7 @@ >>>> #include <linux/iommu.h> >>>> #include <linux/kernel.h> >>>> #include <linux/kmemleak.h> >>>> +#include <linux/module.h> >>>> #include <linux/sizes.h> >>>> #include <linux/slab.h> >>>> #include <linux/spinlock.h> >>>> @@ -835,7 +836,8 @@ static struct io_pgtable >>>> *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, >>>> return NULL; >>>> } >>>> -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>>> +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>>> + .fmt = ARM_V7S, >>>> .alloc = arm_v7s_alloc_pgtable, >>>> .free = arm_v7s_free_pgtable, >>>> }; >>>> @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) >>>> pr_info("self test ok\n"); >>>> return 0; >>>> } >>>> -subsys_initcall(arm_v7s_do_selftests); >>>> +#else >>>> +static int arm_v7s_do_selftests(void) >>>> +{ >>>> + return 0; >>>> +} >>>> #endif >>>> + >>>> +static int __init arm_v7s_init(void) >>>> +{ >>>> + int ret; >>>> + >>>> + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); >>>> + if (ret < 0) { >>>> + pr_err("Failed to register ARM V7S format\n"); >>> >>> Super-nit: I think "v7s" should probably be lowercase there. Also >>> general consistency WRT to showing the error code and whether or not >>> to abbreviate "format" would be nice. >>> >> Ok, I can fix this accordingly. >> >>>> + return ret; >>>> + } >>>> + >>>> + ret = arm_v7s_do_selftests(); >>>> + if (ret < 0) >>>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>>> + >>>> + return ret; >>>> +} >>>> +core_initcall(arm_v7s_init); >>>> + >>>> +static void __exit arm_v7s_exit(void) >>>> +{ >>>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>>> +} >>>> +module_exit(arm_v7s_exit); >>>> diff --git a/drivers/iommu/io-pgtable-arm.c >>>> b/drivers/iommu/io-pgtable-arm.c >>>> index 87def58..ff0ea2f 100644 >>>> --- a/drivers/iommu/io-pgtable-arm.c >>>> +++ b/drivers/iommu/io-pgtable-arm.c >>>> @@ -13,6 +13,7 @@ >>>> #include <linux/bitops.h> >>>> #include <linux/io-pgtable.h> >>>> #include <linux/kernel.h> >>>> +#include <linux/module.h> >>>> #include <linux/sizes.h> >>>> #include <linux/slab.h> >>>> #include <linux/types.h> >>>> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct >>>> io_pgtable_cfg *cfg, void *cookie) >>>> return NULL; >>>> } >>>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { >>>> - .alloc = arm_64_lpae_alloc_pgtable_s1, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { >>>> - .alloc = arm_64_lpae_alloc_pgtable_s2, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { >>>> - .alloc = arm_32_lpae_alloc_pgtable_s1, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { >>>> - .alloc = arm_32_lpae_alloc_pgtable_s2, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { >>>> - .alloc = arm_mali_lpae_alloc_pgtable, >>>> - .free = arm_lpae_free_pgtable, >>>> +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = >>>> { >>>> + { >>>> + .fmt = ARM_32_LPAE_S1, >>>> + .alloc = arm_32_lpae_alloc_pgtable_s1, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_32_LPAE_S2, >>>> + .alloc = arm_32_lpae_alloc_pgtable_s2, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_64_LPAE_S1, >>>> + .alloc = arm_64_lpae_alloc_pgtable_s1, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_64_LPAE_S2, >>>> + .alloc = arm_64_lpae_alloc_pgtable_s2, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_MALI_LPAE, >>>> + .alloc = arm_mali_lpae_alloc_pgtable, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> }; >>>> #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST >>>> @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) >>>> pr_info("selftest: completed with %d PASS %d FAIL\n", pass, >>>> fail); >>>> return fail ? -EFAULT : 0; >>>> } >>>> -subsys_initcall(arm_lpae_do_selftests); >>>> +#else >>>> +static int __init arm_lpae_do_selftests(void) >>>> +{ >>>> + return 0; >>>> +} >>>> #endif >>>> + >>>> +static int __init arm_lpae_init(void) >>>> +{ >>>> + int ret, i; >>>> + >>>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >>>> { >>>> + ret = >>>> io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); >>>> + if (ret < 0) { >>>> + pr_err("Failed to register ARM LPAE fmt: %d\n"); >>>> + goto err_io_pgtable_register; >>>> + } >>>> + } >>>> + >>>> + ret = arm_lpae_do_selftests(); >>>> + if (ret < 0) >>>> + goto err_io_pgtable_register; >>>> + >>>> + return 0; >>>> + >>>> +err_io_pgtable_register: >>>> + for (i = i - 1; i >= 0; i--) >>> >>> Personally I find "while (i--)" a bit clearer for this kind of >>> unwinding, but maybe post-decrement isn't to everyone's taste. >>> >> I'm not particularly attached to the current approach, so a while loop >> is okay with me :). >> >>>> + >>>> io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>>> + return ret; >>>> +} >>>> +core_initcall(arm_lpae_init); >>>> + >>>> +static void __exit arm_lpae_exit(void) >>>> +{ >>>> + int i; >>>> + >>>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >>>> + >>>> io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>>> +} >>>> +module_exit(arm_lpae_exit); >>>> diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c >>>> index 94394c8..2c6eb2e 100644 >>>> --- a/drivers/iommu/io-pgtable.c >>>> +++ b/drivers/iommu/io-pgtable.c >>>> @@ -10,33 +10,45 @@ >>>> #include <linux/bug.h> >>>> #include <linux/io-pgtable.h> >>>> #include <linux/kernel.h> >>>> +#include <linux/rwlock.h> >>>> +#include <linux/slab.h> >>>> #include <linux/types.h> >>>> -static const struct io_pgtable_init_fns * >>>> -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { >>>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE >>>> - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, >>>> - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, >>>> - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, >>>> - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, >>>> - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, >>>> -#endif >>>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S >>>> - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, >>>> -#endif >>>> +struct io_pgtable_init_fns_node { >>>> + struct io_pgtable_init_fns *fns; >>>> + struct list_head list; >>>> }; >>>> +static LIST_HEAD(io_pgtable_init_fns_list); >>>> +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); >>>> + >>>> +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum >>>> io_pgtable_fmt fmt) >>>> +{ >>>> + struct io_pgtable_init_fns_node *iter; >>>> + struct io_pgtable_init_fns *fns = NULL; >>>> + >>>> + read_lock(&io_pgtable_init_fns_list_lock); >>>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>>> + if (iter->fns->fmt == fmt) { >>>> + fns = iter->fns; >>>> + break; >>>> + } >>>> + read_unlock(&io_pgtable_init_fns_list_lock); >>>> + >>>> + return fns; >>>> +} >>> >>> I think it would be a lot easier to stick with a simple array indexed >>> by enum - that way you can just set/clear/test entries without >>> needing >>> to worry about locking. Basically just remove the const and the >>> initialisers from the existing one ;) >>> >>> (and if you think you're concerned about memory, consider that just >>> the list head plus lock is already half the size of the table) >>> >>> Other than that, I think this all looks pretty promising - I'd >>> suggest >>> sending a non-RFC after rc1 so that it gets everyone's proper >>> attention. >>> >>> Thanks, >>> Robin. >>> >> >> Thanks for all of the feedback! With respect to the comment about >> keeping the current array, >> don't we need some sort of lock to protect access to the data >> structure (e.g. concurrent access >> if adding two ops for the same format)? Or do you mean that we should >> use atomic operations to >> handle this cleanly? > > I don't think any races are realistically possible - built-in > initcalls should run sequentially, while module init should be > serialised by the module loader lock, so registrations should never be > able to race against each other. And if there could be a race between > registering a format and somebody trying to use it, then something's > fundamentally wrong anyway - sure we could use READ_ONCE/WRITE_ONCE > for accessing the table, but that would be basically be admitting that > we've failed at the primary purpose of making sure formats are loaded > *before* the users that depend on them. > > With a directly-indexed table there's no contention between looking up > one format and registering another unrelated format, unlike with a > list. > > Robin. > Got it. I'll stick with the array as suggested. Thanks again for the feedback. I'll be sending the version with your suggestions when 5.11-rc1 comes out as a non-RFC. --Isaac >> >> Thanks, >> Isaac >>>> + >>>> struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt >>>> fmt, >>>> struct io_pgtable_cfg *cfg, >>>> void *cookie) >>>> { >>>> struct io_pgtable *iop; >>>> - const struct io_pgtable_init_fns *fns; >>>> + struct io_pgtable_init_fns *fns; >>>> if (fmt >= IO_PGTABLE_NUM_FMTS) >>>> return NULL; >>>> - fns = io_pgtable_init_table[fmt]; >>>> + fns = io_pgtable_get_init_fns(fmt); >>>> if (!fns) >>>> return NULL; >>>> @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); >>>> void free_io_pgtable_ops(struct io_pgtable_ops *ops) >>>> { >>>> struct io_pgtable *iop; >>>> + struct io_pgtable_init_fns *fns; >>>> if (!ops) >>>> return; >>>> iop = io_pgtable_ops_to_pgtable(ops); >>>> io_pgtable_tlb_flush_all(iop); >>>> - io_pgtable_init_table[iop->fmt]->free(iop); >>>> + fns = io_pgtable_get_init_fns(iop->fmt); >>>> + if (fns) >>>> + fns->free(iop); >>>> } >>>> EXPORT_SYMBOL_GPL(free_io_pgtable_ops); >>>> + >>>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) >>>> +{ >>>> + struct io_pgtable_init_fns_node *iter, *fns_node; >>>> + int ret = 0; >>>> + >>>> + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || >>>> + !init_fns->alloc || !init_fns->free) >>>> + return -EINVAL; >>>> + >>>> + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); >>>> + if (!fns_node) >>>> + return -ENOMEM; >>>> + >>>> + write_lock(&io_pgtable_init_fns_list_lock); >>>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>>> + if (iter->fns->fmt == init_fns->fmt) { >>>> + ret = -EEXIST; >>>> + kfree(fns_node); >>>> + break; >>>> + } >>>> + >>>> + if (!ret) { >>>> + fns_node->fns = init_fns; >>>> + INIT_LIST_HEAD(&fns_node->list); >>>> + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); >>>> + } >>>> + write_unlock(&io_pgtable_init_fns_list_lock); >>>> + return ret; >>>> +} >>>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); >>>> + >>>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns >>>> *init_fns) >>>> +{ >>>> + struct io_pgtable_init_fns_node *iter, *tmp; >>>> + >>>> + if (!init_fns) >>>> + return; >>>> + >>>> + write_lock(&io_pgtable_init_fns_list_lock); >>>> + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, >>>> list) >>>> + if (iter->fns == init_fns) { >>>> + list_del(&iter->list); >>>> + kfree(iter); >>>> + break; >>>> + } >>>> + write_unlock(&io_pgtable_init_fns_list_lock); >>>> +} >>>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); >>>> diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h >>>> index ea727eb..45b367ce 100644 >>>> --- a/include/linux/io-pgtable.h >>>> +++ b/include/linux/io-pgtable.h >>>> @@ -163,6 +163,38 @@ struct io_pgtable_ops { >>>> }; >>>> /** >>>> + * struct io_pgtable_init_fns - Alloc/free a set of page tables for >>>> a >>>> + * particular format. >>>> + * >>>> + * @fmt: The page table format. >>>> + * @alloc: Allocate a set of page tables described by cfg. >>>> + * @free: Free the page tables associated with iop. >>>> + */ >>>> +struct io_pgtable_init_fns { >>>> + enum io_pgtable_fmt fmt; >>>> + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>>> *cookie); >>>> + void (*free)(struct io_pgtable *iop); >>>> +}; >>>> + >>>> +/** >>>> + * io_pgtable_ops_register() - Register the page table routines for >>>> a page table >>>> + * format. >>>> + * >>>> + * @init_fns: The functions for allocating and freeing the page >>>> tables of >>>> + * a particular format. >>>> + */ >>>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); >>>> + >>>> +/** >>>> + * io_pgtable_ops_unregister() - Unregister the page table routines >>>> for a page >>>> + * table format. >>>> + * >>>> + * @init_fns: The functions for allocating and freeing the page >>>> tables of >>>> + * a particular format. >>>> + */ >>>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns >>>> *init_fns); >>>> + >>>> +/** >>>> * alloc_io_pgtable_ops() - Allocate a page table allocator for >>>> use by an IOMMU. >>>> * >>>> * @fmt: The page table format. >>>> @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, >>>> iop->cfg.tlb->tlb_add_page(gather, iova, granule, >>>> iop->cookie); >>>> } >>>> -/** >>>> - * struct io_pgtable_init_fns - Alloc/free a set of page tables for >>>> a >>>> - * particular format. >>>> - * >>>> - * @alloc: Allocate a set of page tables described by cfg. >>>> - * @free: Free the page tables associated with iop. >>>> - */ >>>> -struct io_pgtable_init_fns { >>>> - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>>> *cookie); >>>> - void (*free)(struct io_pgtable *iop); >>>> -}; >>>> - >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_32_lpae_s1_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_32_lpae_s2_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_64_lpae_s1_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_64_lpae_s2_init_fns; >>>> -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_mali_lpae_init_fns; >>>> - >>>> #endif /* __IO_PGTABLE_H */ >>>> >>> >>> _______________________________________________ >>> linux-arm-kernel mailing list >>> linux-arm-kernel@lists.infradead.org >>> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel >> _______________________________________________ >> iommu mailing list >> iommu@lists.linux-foundation.org >> https://lists.linuxfoundation.org/mailman/listinfo/iommu _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 15:14 ` isaacm 0 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-23 15:14 UTC (permalink / raw) To: Robin Murphy Cc: freedreno, kernel-team, pdaly, linux-arm-msm, linux-kernel, dri-devel, iommu, will, linux-arm-kernel, pratikp On 2020-12-23 05:44, Robin Murphy wrote: > On 2020-12-22 19:54, isaacm@codeaurora.org wrote: >> On 2020-12-22 11:27, Robin Murphy wrote: >>> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>>> The io-pgtable code constructs an array of init functions for each >>>> page table format at compile time. This is not ideal, as this >>>> increases the footprint of the io-pgtable code, as well as prevents >>>> io-pgtable formats from being built as kernel modules. >>>> >>>> In preparation for modularizing the io-pgtable formats, switch to a >>>> dynamic registration scheme, where each io-pgtable format can >>>> register >>>> their init functions with the io-pgtable code at boot or module >>>> insertion time. >>>> >>>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>>> --- >>>> drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- >>>> drivers/iommu/io-pgtable-arm.c | 90 >>>> ++++++++++++++++++++++++++---------- >>>> drivers/iommu/io-pgtable.c | 94 >>>> ++++++++++++++++++++++++++++++++------ >>>> include/linux/io-pgtable.h | 51 +++++++++++++-------- >>>> 4 files changed, 209 insertions(+), 60 deletions(-) >>>> >>>> diff --git a/drivers/iommu/io-pgtable-arm-v7s.c >>>> b/drivers/iommu/io-pgtable-arm-v7s.c >>>> index 1d92ac9..89aad2f 100644 >>>> --- a/drivers/iommu/io-pgtable-arm-v7s.c >>>> +++ b/drivers/iommu/io-pgtable-arm-v7s.c >>>> @@ -28,6 +28,7 @@ >>>> #include <linux/iommu.h> >>>> #include <linux/kernel.h> >>>> #include <linux/kmemleak.h> >>>> +#include <linux/module.h> >>>> #include <linux/sizes.h> >>>> #include <linux/slab.h> >>>> #include <linux/spinlock.h> >>>> @@ -835,7 +836,8 @@ static struct io_pgtable >>>> *arm_v7s_alloc_pgtable(struct io_pgtable_cfg *cfg, >>>> return NULL; >>>> } >>>> -struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>>> +static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { >>>> + .fmt = ARM_V7S, >>>> .alloc = arm_v7s_alloc_pgtable, >>>> .free = arm_v7s_free_pgtable, >>>> }; >>>> @@ -982,5 +984,33 @@ static int __init arm_v7s_do_selftests(void) >>>> pr_info("self test ok\n"); >>>> return 0; >>>> } >>>> -subsys_initcall(arm_v7s_do_selftests); >>>> +#else >>>> +static int arm_v7s_do_selftests(void) >>>> +{ >>>> + return 0; >>>> +} >>>> #endif >>>> + >>>> +static int __init arm_v7s_init(void) >>>> +{ >>>> + int ret; >>>> + >>>> + ret = io_pgtable_ops_register(&io_pgtable_arm_v7s_init_fns); >>>> + if (ret < 0) { >>>> + pr_err("Failed to register ARM V7S format\n"); >>> >>> Super-nit: I think "v7s" should probably be lowercase there. Also >>> general consistency WRT to showing the error code and whether or not >>> to abbreviate "format" would be nice. >>> >> Ok, I can fix this accordingly. >> >>>> + return ret; >>>> + } >>>> + >>>> + ret = arm_v7s_do_selftests(); >>>> + if (ret < 0) >>>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>>> + >>>> + return ret; >>>> +} >>>> +core_initcall(arm_v7s_init); >>>> + >>>> +static void __exit arm_v7s_exit(void) >>>> +{ >>>> + io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); >>>> +} >>>> +module_exit(arm_v7s_exit); >>>> diff --git a/drivers/iommu/io-pgtable-arm.c >>>> b/drivers/iommu/io-pgtable-arm.c >>>> index 87def58..ff0ea2f 100644 >>>> --- a/drivers/iommu/io-pgtable-arm.c >>>> +++ b/drivers/iommu/io-pgtable-arm.c >>>> @@ -13,6 +13,7 @@ >>>> #include <linux/bitops.h> >>>> #include <linux/io-pgtable.h> >>>> #include <linux/kernel.h> >>>> +#include <linux/module.h> >>>> #include <linux/sizes.h> >>>> #include <linux/slab.h> >>>> #include <linux/types.h> >>>> @@ -1043,29 +1044,32 @@ arm_mali_lpae_alloc_pgtable(struct >>>> io_pgtable_cfg *cfg, void *cookie) >>>> return NULL; >>>> } >>>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = { >>>> - .alloc = arm_64_lpae_alloc_pgtable_s1, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = { >>>> - .alloc = arm_64_lpae_alloc_pgtable_s2, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = { >>>> - .alloc = arm_32_lpae_alloc_pgtable_s1, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = { >>>> - .alloc = arm_32_lpae_alloc_pgtable_s2, >>>> - .free = arm_lpae_free_pgtable, >>>> -}; >>>> - >>>> -struct io_pgtable_init_fns io_pgtable_arm_mali_lpae_init_fns = { >>>> - .alloc = arm_mali_lpae_alloc_pgtable, >>>> - .free = arm_lpae_free_pgtable, >>>> +static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = >>>> { >>>> + { >>>> + .fmt = ARM_32_LPAE_S1, >>>> + .alloc = arm_32_lpae_alloc_pgtable_s1, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_32_LPAE_S2, >>>> + .alloc = arm_32_lpae_alloc_pgtable_s2, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_64_LPAE_S1, >>>> + .alloc = arm_64_lpae_alloc_pgtable_s1, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_64_LPAE_S2, >>>> + .alloc = arm_64_lpae_alloc_pgtable_s2, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> + { >>>> + .fmt = ARM_MALI_LPAE, >>>> + .alloc = arm_mali_lpae_alloc_pgtable, >>>> + .free = arm_lpae_free_pgtable, >>>> + }, >>>> }; >>>> #ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST >>>> @@ -1250,5 +1254,43 @@ static int __init arm_lpae_do_selftests(void) >>>> pr_info("selftest: completed with %d PASS %d FAIL\n", pass, >>>> fail); >>>> return fail ? -EFAULT : 0; >>>> } >>>> -subsys_initcall(arm_lpae_do_selftests); >>>> +#else >>>> +static int __init arm_lpae_do_selftests(void) >>>> +{ >>>> + return 0; >>>> +} >>>> #endif >>>> + >>>> +static int __init arm_lpae_init(void) >>>> +{ >>>> + int ret, i; >>>> + >>>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >>>> { >>>> + ret = >>>> io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); >>>> + if (ret < 0) { >>>> + pr_err("Failed to register ARM LPAE fmt: %d\n"); >>>> + goto err_io_pgtable_register; >>>> + } >>>> + } >>>> + >>>> + ret = arm_lpae_do_selftests(); >>>> + if (ret < 0) >>>> + goto err_io_pgtable_register; >>>> + >>>> + return 0; >>>> + >>>> +err_io_pgtable_register: >>>> + for (i = i - 1; i >= 0; i--) >>> >>> Personally I find "while (i--)" a bit clearer for this kind of >>> unwinding, but maybe post-decrement isn't to everyone's taste. >>> >> I'm not particularly attached to the current approach, so a while loop >> is okay with me :). >> >>>> + >>>> io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>>> + return ret; >>>> +} >>>> +core_initcall(arm_lpae_init); >>>> + >>>> +static void __exit arm_lpae_exit(void) >>>> +{ >>>> + int i; >>>> + >>>> + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) >>>> + >>>> io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); >>>> +} >>>> +module_exit(arm_lpae_exit); >>>> diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c >>>> index 94394c8..2c6eb2e 100644 >>>> --- a/drivers/iommu/io-pgtable.c >>>> +++ b/drivers/iommu/io-pgtable.c >>>> @@ -10,33 +10,45 @@ >>>> #include <linux/bug.h> >>>> #include <linux/io-pgtable.h> >>>> #include <linux/kernel.h> >>>> +#include <linux/rwlock.h> >>>> +#include <linux/slab.h> >>>> #include <linux/types.h> >>>> -static const struct io_pgtable_init_fns * >>>> -io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] = { >>>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE >>>> - [ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns, >>>> - [ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns, >>>> - [ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns, >>>> - [ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns, >>>> - [ARM_MALI_LPAE] = &io_pgtable_arm_mali_lpae_init_fns, >>>> -#endif >>>> -#ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S >>>> - [ARM_V7S] = &io_pgtable_arm_v7s_init_fns, >>>> -#endif >>>> +struct io_pgtable_init_fns_node { >>>> + struct io_pgtable_init_fns *fns; >>>> + struct list_head list; >>>> }; >>>> +static LIST_HEAD(io_pgtable_init_fns_list); >>>> +static DEFINE_RWLOCK(io_pgtable_init_fns_list_lock); >>>> + >>>> +static struct io_pgtable_init_fns *io_pgtable_get_init_fns(enum >>>> io_pgtable_fmt fmt) >>>> +{ >>>> + struct io_pgtable_init_fns_node *iter; >>>> + struct io_pgtable_init_fns *fns = NULL; >>>> + >>>> + read_lock(&io_pgtable_init_fns_list_lock); >>>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>>> + if (iter->fns->fmt == fmt) { >>>> + fns = iter->fns; >>>> + break; >>>> + } >>>> + read_unlock(&io_pgtable_init_fns_list_lock); >>>> + >>>> + return fns; >>>> +} >>> >>> I think it would be a lot easier to stick with a simple array indexed >>> by enum - that way you can just set/clear/test entries without >>> needing >>> to worry about locking. Basically just remove the const and the >>> initialisers from the existing one ;) >>> >>> (and if you think you're concerned about memory, consider that just >>> the list head plus lock is already half the size of the table) >>> >>> Other than that, I think this all looks pretty promising - I'd >>> suggest >>> sending a non-RFC after rc1 so that it gets everyone's proper >>> attention. >>> >>> Thanks, >>> Robin. >>> >> >> Thanks for all of the feedback! With respect to the comment about >> keeping the current array, >> don't we need some sort of lock to protect access to the data >> structure (e.g. concurrent access >> if adding two ops for the same format)? Or do you mean that we should >> use atomic operations to >> handle this cleanly? > > I don't think any races are realistically possible - built-in > initcalls should run sequentially, while module init should be > serialised by the module loader lock, so registrations should never be > able to race against each other. And if there could be a race between > registering a format and somebody trying to use it, then something's > fundamentally wrong anyway - sure we could use READ_ONCE/WRITE_ONCE > for accessing the table, but that would be basically be admitting that > we've failed at the primary purpose of making sure formats are loaded > *before* the users that depend on them. > > With a directly-indexed table there's no contention between looking up > one format and registering another unrelated format, unlike with a > list. > > Robin. > Got it. I'll stick with the array as suggested. Thanks again for the feedback. I'll be sending the version with your suggestions when 5.11-rc1 comes out as a non-RFC. --Isaac >> >> Thanks, >> Isaac >>>> + >>>> struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt >>>> fmt, >>>> struct io_pgtable_cfg *cfg, >>>> void *cookie) >>>> { >>>> struct io_pgtable *iop; >>>> - const struct io_pgtable_init_fns *fns; >>>> + struct io_pgtable_init_fns *fns; >>>> if (fmt >= IO_PGTABLE_NUM_FMTS) >>>> return NULL; >>>> - fns = io_pgtable_init_table[fmt]; >>>> + fns = io_pgtable_get_init_fns(fmt); >>>> if (!fns) >>>> return NULL; >>>> @@ -59,12 +71,64 @@ EXPORT_SYMBOL_GPL(alloc_io_pgtable_ops); >>>> void free_io_pgtable_ops(struct io_pgtable_ops *ops) >>>> { >>>> struct io_pgtable *iop; >>>> + struct io_pgtable_init_fns *fns; >>>> if (!ops) >>>> return; >>>> iop = io_pgtable_ops_to_pgtable(ops); >>>> io_pgtable_tlb_flush_all(iop); >>>> - io_pgtable_init_table[iop->fmt]->free(iop); >>>> + fns = io_pgtable_get_init_fns(iop->fmt); >>>> + if (fns) >>>> + fns->free(iop); >>>> } >>>> EXPORT_SYMBOL_GPL(free_io_pgtable_ops); >>>> + >>>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns) >>>> +{ >>>> + struct io_pgtable_init_fns_node *iter, *fns_node; >>>> + int ret = 0; >>>> + >>>> + if (!init_fns || init_fns->fmt >= IO_PGTABLE_NUM_FMTS || >>>> + !init_fns->alloc || !init_fns->free) >>>> + return -EINVAL; >>>> + >>>> + fns_node = kzalloc(sizeof(*fns_node), GFP_KERNEL); >>>> + if (!fns_node) >>>> + return -ENOMEM; >>>> + >>>> + write_lock(&io_pgtable_init_fns_list_lock); >>>> + list_for_each_entry(iter, &io_pgtable_init_fns_list, list) >>>> + if (iter->fns->fmt == init_fns->fmt) { >>>> + ret = -EEXIST; >>>> + kfree(fns_node); >>>> + break; >>>> + } >>>> + >>>> + if (!ret) { >>>> + fns_node->fns = init_fns; >>>> + INIT_LIST_HEAD(&fns_node->list); >>>> + list_add_tail(&fns_node->list, &io_pgtable_init_fns_list); >>>> + } >>>> + write_unlock(&io_pgtable_init_fns_list_lock); >>>> + return ret; >>>> +} >>>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_register); >>>> + >>>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns >>>> *init_fns) >>>> +{ >>>> + struct io_pgtable_init_fns_node *iter, *tmp; >>>> + >>>> + if (!init_fns) >>>> + return; >>>> + >>>> + write_lock(&io_pgtable_init_fns_list_lock); >>>> + list_for_each_entry_safe(iter, tmp, &io_pgtable_init_fns_list, >>>> list) >>>> + if (iter->fns == init_fns) { >>>> + list_del(&iter->list); >>>> + kfree(iter); >>>> + break; >>>> + } >>>> + write_unlock(&io_pgtable_init_fns_list_lock); >>>> +} >>>> +EXPORT_SYMBOL_GPL(io_pgtable_ops_unregister); >>>> diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h >>>> index ea727eb..45b367ce 100644 >>>> --- a/include/linux/io-pgtable.h >>>> +++ b/include/linux/io-pgtable.h >>>> @@ -163,6 +163,38 @@ struct io_pgtable_ops { >>>> }; >>>> /** >>>> + * struct io_pgtable_init_fns - Alloc/free a set of page tables for >>>> a >>>> + * particular format. >>>> + * >>>> + * @fmt: The page table format. >>>> + * @alloc: Allocate a set of page tables described by cfg. >>>> + * @free: Free the page tables associated with iop. >>>> + */ >>>> +struct io_pgtable_init_fns { >>>> + enum io_pgtable_fmt fmt; >>>> + struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>>> *cookie); >>>> + void (*free)(struct io_pgtable *iop); >>>> +}; >>>> + >>>> +/** >>>> + * io_pgtable_ops_register() - Register the page table routines for >>>> a page table >>>> + * format. >>>> + * >>>> + * @init_fns: The functions for allocating and freeing the page >>>> tables of >>>> + * a particular format. >>>> + */ >>>> +int io_pgtable_ops_register(struct io_pgtable_init_fns *init_fns); >>>> + >>>> +/** >>>> + * io_pgtable_ops_unregister() - Unregister the page table routines >>>> for a page >>>> + * table format. >>>> + * >>>> + * @init_fns: The functions for allocating and freeing the page >>>> tables of >>>> + * a particular format. >>>> + */ >>>> +void io_pgtable_ops_unregister(struct io_pgtable_init_fns >>>> *init_fns); >>>> + >>>> +/** >>>> * alloc_io_pgtable_ops() - Allocate a page table allocator for >>>> use by an IOMMU. >>>> * >>>> * @fmt: The page table format. >>>> @@ -233,23 +265,4 @@ io_pgtable_tlb_add_page(struct io_pgtable *iop, >>>> iop->cfg.tlb->tlb_add_page(gather, iova, granule, >>>> iop->cookie); >>>> } >>>> -/** >>>> - * struct io_pgtable_init_fns - Alloc/free a set of page tables for >>>> a >>>> - * particular format. >>>> - * >>>> - * @alloc: Allocate a set of page tables described by cfg. >>>> - * @free: Free the page tables associated with iop. >>>> - */ >>>> -struct io_pgtable_init_fns { >>>> - struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void >>>> *cookie); >>>> - void (*free)(struct io_pgtable *iop); >>>> -}; >>>> - >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_32_lpae_s1_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_32_lpae_s2_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_64_lpae_s1_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_64_lpae_s2_init_fns; >>>> -extern struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns; >>>> -extern struct io_pgtable_init_fns >>>> io_pgtable_arm_mali_lpae_init_fns; >>>> - >>>> #endif /* __IO_PGTABLE_H */ >>>> >>> >>> _______________________________________________ >>> linux-arm-kernel mailing list >>> linux-arm-kernel@lists.infradead.org >>> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel >> _______________________________________________ >> iommu mailing list >> iommu@lists.linux-foundation.org >> https://lists.linuxfoundation.org/mailman/listinfo/iommu _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration 2020-12-22 0:44 ` Isaac J. Manjarres (?) (?) @ 2020-12-23 15:38 ` Georgi Djakov -1 siblings, 0 replies; 73+ messages in thread From: Georgi Djakov @ 2020-12-23 15:38 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: will, joro, pdaly, pratikp, kernel-team, robin.murphy Hi Isaac, On 22.12.20 2:44, Isaac J. Manjarres wrote: > The io-pgtable code constructs an array of init functions for each > page table format at compile time. This is not ideal, as this > increases the footprint of the io-pgtable code, as well as prevents > io-pgtable formats from being built as kernel modules. > > In preparation for modularizing the io-pgtable formats, switch to a > dynamic registration scheme, where each io-pgtable format can register > their init functions with the io-pgtable code at boot or module > insertion time. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- > drivers/iommu/io-pgtable-arm.c | 90 ++++++++++++++++++++++++++---------- > drivers/iommu/io-pgtable.c | 94 ++++++++++++++++++++++++++++++++------ > include/linux/io-pgtable.h | 51 +++++++++++++-------- > 4 files changed, 209 insertions(+), 60 deletions(-) > > diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c > index 1d92ac9..89aad2f 100644 > --- a/drivers/iommu/io-pgtable-arm-v7s.c > +++ b/drivers/iommu/io-pgtable-arm-v7s.c > @@ -28,6 +28,7 @@ [..] > +static int __init arm_lpae_init(void) > +{ > + int ret, i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { > + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); > + if (ret < 0) { > + pr_err("Failed to register ARM LPAE fmt: %d\n"); I guess we want to print the format here? Thanks, Georgi ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 15:38 ` Georgi Djakov 0 siblings, 0 replies; 73+ messages in thread From: Georgi Djakov @ 2020-12-23 15:38 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: will, pdaly, kernel-team, joro, robin.murphy, pratikp Hi Isaac, On 22.12.20 2:44, Isaac J. Manjarres wrote: > The io-pgtable code constructs an array of init functions for each > page table format at compile time. This is not ideal, as this > increases the footprint of the io-pgtable code, as well as prevents > io-pgtable formats from being built as kernel modules. > > In preparation for modularizing the io-pgtable formats, switch to a > dynamic registration scheme, where each io-pgtable format can register > their init functions with the io-pgtable code at boot or module > insertion time. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- > drivers/iommu/io-pgtable-arm.c | 90 ++++++++++++++++++++++++++---------- > drivers/iommu/io-pgtable.c | 94 ++++++++++++++++++++++++++++++++------ > include/linux/io-pgtable.h | 51 +++++++++++++-------- > 4 files changed, 209 insertions(+), 60 deletions(-) > > diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c > index 1d92ac9..89aad2f 100644 > --- a/drivers/iommu/io-pgtable-arm-v7s.c > +++ b/drivers/iommu/io-pgtable-arm-v7s.c > @@ -28,6 +28,7 @@ [..] > +static int __init arm_lpae_init(void) > +{ > + int ret, i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { > + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); > + if (ret < 0) { > + pr_err("Failed to register ARM LPAE fmt: %d\n"); I guess we want to print the format here? Thanks, Georgi _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 15:38 ` Georgi Djakov 0 siblings, 0 replies; 73+ messages in thread From: Georgi Djakov @ 2020-12-23 15:38 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: will, pdaly, kernel-team, joro, robin.murphy, pratikp Hi Isaac, On 22.12.20 2:44, Isaac J. Manjarres wrote: > The io-pgtable code constructs an array of init functions for each > page table format at compile time. This is not ideal, as this > increases the footprint of the io-pgtable code, as well as prevents > io-pgtable formats from being built as kernel modules. > > In preparation for modularizing the io-pgtable formats, switch to a > dynamic registration scheme, where each io-pgtable format can register > their init functions with the io-pgtable code at boot or module > insertion time. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- > drivers/iommu/io-pgtable-arm.c | 90 ++++++++++++++++++++++++++---------- > drivers/iommu/io-pgtable.c | 94 ++++++++++++++++++++++++++++++++------ > include/linux/io-pgtable.h | 51 +++++++++++++-------- > 4 files changed, 209 insertions(+), 60 deletions(-) > > diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c > index 1d92ac9..89aad2f 100644 > --- a/drivers/iommu/io-pgtable-arm-v7s.c > +++ b/drivers/iommu/io-pgtable-arm-v7s.c > @@ -28,6 +28,7 @@ [..] > +static int __init arm_lpae_init(void) > +{ > + int ret, i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { > + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); > + if (ret < 0) { > + pr_err("Failed to register ARM LPAE fmt: %d\n"); I guess we want to print the format here? Thanks, Georgi _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 15:38 ` Georgi Djakov 0 siblings, 0 replies; 73+ messages in thread From: Georgi Djakov @ 2020-12-23 15:38 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: will, pdaly, kernel-team, robin.murphy, pratikp Hi Isaac, On 22.12.20 2:44, Isaac J. Manjarres wrote: > The io-pgtable code constructs an array of init functions for each > page table format at compile time. This is not ideal, as this > increases the footprint of the io-pgtable code, as well as prevents > io-pgtable formats from being built as kernel modules. > > In preparation for modularizing the io-pgtable formats, switch to a > dynamic registration scheme, where each io-pgtable format can register > their init functions with the io-pgtable code at boot or module > insertion time. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/io-pgtable-arm-v7s.c | 34 +++++++++++++- > drivers/iommu/io-pgtable-arm.c | 90 ++++++++++++++++++++++++++---------- > drivers/iommu/io-pgtable.c | 94 ++++++++++++++++++++++++++++++++------ > include/linux/io-pgtable.h | 51 +++++++++++++-------- > 4 files changed, 209 insertions(+), 60 deletions(-) > > diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c > index 1d92ac9..89aad2f 100644 > --- a/drivers/iommu/io-pgtable-arm-v7s.c > +++ b/drivers/iommu/io-pgtable-arm-v7s.c > @@ -28,6 +28,7 @@ [..] > +static int __init arm_lpae_init(void) > +{ > + int ret, i; > + > + for (i = 0; i < ARRAY_SIZE(io_pgtable_arm_lpae_init_fns); i++) { > + ret = io_pgtable_ops_register(&io_pgtable_arm_lpae_init_fns[i]); > + if (ret < 0) { > + pr_err("Failed to register ARM LPAE fmt: %d\n"); I guess we want to print the format here? Thanks, Georgi _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration 2020-12-22 0:44 ` Isaac J. Manjarres ` (2 preceding siblings ...) (?) @ 2020-12-23 19:17 ` kernel test robot -1 siblings, 0 replies; 73+ messages in thread From: kernel test robot @ 2020-12-23 19:17 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: kbuild-all, Isaac J. Manjarres, will, joro, pdaly [-- Attachment #1: Type: text/plain, Size: 3478 bytes --] Hi "Isaac, Thank you for the patch! Perhaps something to improve: [auto build test WARNING on iommu/next] [also build test WARNING on soc/for-next xlnx/master linus/master v5.10 next-20201223] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch] url: https://github.com/0day-ci/linux/commits/Isaac-J-Manjarres/iommu-Permit-modular-builds-of-io-pgtable-drivers/20201222-085121 base: https://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git next config: alpha-randconfig-r023-20201221 (attached as .config) compiler: alpha-linux-gcc (GCC) 9.3.0 reproduce (this is a W=1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # https://github.com/0day-ci/linux/commit/9cc3cfc5f79e5c9072aea2218dd9080227933caa git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Isaac-J-Manjarres/iommu-Permit-modular-builds-of-io-pgtable-drivers/20201222-085121 git checkout 9cc3cfc5f79e5c9072aea2218dd9080227933caa # save the attached .config to linux build tree COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=alpha If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot <lkp@intel.com> All warnings (new ones prefixed by >>): In file included from include/linux/printk.h:7, from include/linux/kernel.h:16, from include/asm-generic/bug.h:20, from arch/alpha/include/asm/bug.h:23, from include/linux/bug.h:5, from include/linux/scatterlist.h:7, from include/linux/iommu.h:10, from include/linux/io-pgtable.h:6, from drivers/iommu/io-pgtable-arm.c:14: drivers/iommu/io-pgtable-arm.c: In function 'arm_lpae_init': >> include/linux/kern_levels.h:5:18: warning: format '%d' expects a matching 'int' argument [-Wformat=] 5 | #define KERN_SOH "\001" /* ASCII Start Of Header */ | ^~~~~~ include/linux/kern_levels.h:11:18: note: in expansion of macro 'KERN_SOH' 11 | #define KERN_ERR KERN_SOH "3" /* error conditions */ | ^~~~~~~~ include/linux/printk.h:343:9: note: in expansion of macro 'KERN_ERR' 343 | printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__) | ^~~~~~~~ drivers/iommu/io-pgtable-arm.c:1257:4: note: in expansion of macro 'pr_err' 1257 | pr_err("Failed to register ARM LPAE fmt: %d\n"); | ^~~~~~ drivers/iommu/io-pgtable-arm.c:1257:46: note: format string is defined here 1257 | pr_err("Failed to register ARM LPAE fmt: %d\n"); | ~^ | | | int vim +5 include/linux/kern_levels.h 314ba3520e513a7 Joe Perches 2012-07-30 4 04d2c8c83d0e3ac Joe Perches 2012-07-30 @5 #define KERN_SOH "\001" /* ASCII Start Of Header */ 04d2c8c83d0e3ac Joe Perches 2012-07-30 6 #define KERN_SOH_ASCII '\001' 04d2c8c83d0e3ac Joe Perches 2012-07-30 7 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org [-- Attachment #2: .config.gz --] [-- Type: application/gzip, Size: 42216 bytes --] ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 19:17 ` kernel test robot 0 siblings, 0 replies; 73+ messages in thread From: kernel test robot @ 2020-12-23 19:17 UTC (permalink / raw) To: kbuild-all [-- Attachment #1: Type: text/plain, Size: 3548 bytes --] Hi "Isaac, Thank you for the patch! Perhaps something to improve: [auto build test WARNING on iommu/next] [also build test WARNING on soc/for-next xlnx/master linus/master v5.10 next-20201223] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch] url: https://github.com/0day-ci/linux/commits/Isaac-J-Manjarres/iommu-Permit-modular-builds-of-io-pgtable-drivers/20201222-085121 base: https://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git next config: alpha-randconfig-r023-20201221 (attached as .config) compiler: alpha-linux-gcc (GCC) 9.3.0 reproduce (this is a W=1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # https://github.com/0day-ci/linux/commit/9cc3cfc5f79e5c9072aea2218dd9080227933caa git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Isaac-J-Manjarres/iommu-Permit-modular-builds-of-io-pgtable-drivers/20201222-085121 git checkout 9cc3cfc5f79e5c9072aea2218dd9080227933caa # save the attached .config to linux build tree COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=alpha If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot <lkp@intel.com> All warnings (new ones prefixed by >>): In file included from include/linux/printk.h:7, from include/linux/kernel.h:16, from include/asm-generic/bug.h:20, from arch/alpha/include/asm/bug.h:23, from include/linux/bug.h:5, from include/linux/scatterlist.h:7, from include/linux/iommu.h:10, from include/linux/io-pgtable.h:6, from drivers/iommu/io-pgtable-arm.c:14: drivers/iommu/io-pgtable-arm.c: In function 'arm_lpae_init': >> include/linux/kern_levels.h:5:18: warning: format '%d' expects a matching 'int' argument [-Wformat=] 5 | #define KERN_SOH "\001" /* ASCII Start Of Header */ | ^~~~~~ include/linux/kern_levels.h:11:18: note: in expansion of macro 'KERN_SOH' 11 | #define KERN_ERR KERN_SOH "3" /* error conditions */ | ^~~~~~~~ include/linux/printk.h:343:9: note: in expansion of macro 'KERN_ERR' 343 | printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__) | ^~~~~~~~ drivers/iommu/io-pgtable-arm.c:1257:4: note: in expansion of macro 'pr_err' 1257 | pr_err("Failed to register ARM LPAE fmt: %d\n"); | ^~~~~~ drivers/iommu/io-pgtable-arm.c:1257:46: note: format string is defined here 1257 | pr_err("Failed to register ARM LPAE fmt: %d\n"); | ~^ | | | int vim +5 include/linux/kern_levels.h 314ba3520e513a7 Joe Perches 2012-07-30 4 04d2c8c83d0e3ac Joe Perches 2012-07-30 @5 #define KERN_SOH "\001" /* ASCII Start Of Header */ 04d2c8c83d0e3ac Joe Perches 2012-07-30 6 #define KERN_SOH_ASCII '\001' 04d2c8c83d0e3ac Joe Perches 2012-07-30 7 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org [-- Attachment #2: config.gz --] [-- Type: application/gzip, Size: 42216 bytes --] ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 19:17 ` kernel test robot 0 siblings, 0 replies; 73+ messages in thread From: kernel test robot @ 2020-12-23 19:17 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, joro, kbuild-all, pdaly [-- Attachment #1: Type: text/plain, Size: 3478 bytes --] Hi "Isaac, Thank you for the patch! Perhaps something to improve: [auto build test WARNING on iommu/next] [also build test WARNING on soc/for-next xlnx/master linus/master v5.10 next-20201223] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch] url: https://github.com/0day-ci/linux/commits/Isaac-J-Manjarres/iommu-Permit-modular-builds-of-io-pgtable-drivers/20201222-085121 base: https://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git next config: alpha-randconfig-r023-20201221 (attached as .config) compiler: alpha-linux-gcc (GCC) 9.3.0 reproduce (this is a W=1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # https://github.com/0day-ci/linux/commit/9cc3cfc5f79e5c9072aea2218dd9080227933caa git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Isaac-J-Manjarres/iommu-Permit-modular-builds-of-io-pgtable-drivers/20201222-085121 git checkout 9cc3cfc5f79e5c9072aea2218dd9080227933caa # save the attached .config to linux build tree COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=alpha If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot <lkp@intel.com> All warnings (new ones prefixed by >>): In file included from include/linux/printk.h:7, from include/linux/kernel.h:16, from include/asm-generic/bug.h:20, from arch/alpha/include/asm/bug.h:23, from include/linux/bug.h:5, from include/linux/scatterlist.h:7, from include/linux/iommu.h:10, from include/linux/io-pgtable.h:6, from drivers/iommu/io-pgtable-arm.c:14: drivers/iommu/io-pgtable-arm.c: In function 'arm_lpae_init': >> include/linux/kern_levels.h:5:18: warning: format '%d' expects a matching 'int' argument [-Wformat=] 5 | #define KERN_SOH "\001" /* ASCII Start Of Header */ | ^~~~~~ include/linux/kern_levels.h:11:18: note: in expansion of macro 'KERN_SOH' 11 | #define KERN_ERR KERN_SOH "3" /* error conditions */ | ^~~~~~~~ include/linux/printk.h:343:9: note: in expansion of macro 'KERN_ERR' 343 | printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__) | ^~~~~~~~ drivers/iommu/io-pgtable-arm.c:1257:4: note: in expansion of macro 'pr_err' 1257 | pr_err("Failed to register ARM LPAE fmt: %d\n"); | ^~~~~~ drivers/iommu/io-pgtable-arm.c:1257:46: note: format string is defined here 1257 | pr_err("Failed to register ARM LPAE fmt: %d\n"); | ~^ | | | int vim +5 include/linux/kern_levels.h 314ba3520e513a7 Joe Perches 2012-07-30 4 04d2c8c83d0e3ac Joe Perches 2012-07-30 @5 #define KERN_SOH "\001" /* ASCII Start Of Header */ 04d2c8c83d0e3ac Joe Perches 2012-07-30 6 #define KERN_SOH_ASCII '\001' 04d2c8c83d0e3ac Joe Perches 2012-07-30 7 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org [-- Attachment #2: .config.gz --] [-- Type: application/gzip, Size: 42216 bytes --] [-- Attachment #3: Type: text/plain, Size: 160 bytes --] _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 19:17 ` kernel test robot 0 siblings, 0 replies; 73+ messages in thread From: kernel test robot @ 2020-12-23 19:17 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, joro, kbuild-all, pdaly [-- Attachment #1: Type: text/plain, Size: 3478 bytes --] Hi "Isaac, Thank you for the patch! Perhaps something to improve: [auto build test WARNING on iommu/next] [also build test WARNING on soc/for-next xlnx/master linus/master v5.10 next-20201223] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch] url: https://github.com/0day-ci/linux/commits/Isaac-J-Manjarres/iommu-Permit-modular-builds-of-io-pgtable-drivers/20201222-085121 base: https://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git next config: alpha-randconfig-r023-20201221 (attached as .config) compiler: alpha-linux-gcc (GCC) 9.3.0 reproduce (this is a W=1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # https://github.com/0day-ci/linux/commit/9cc3cfc5f79e5c9072aea2218dd9080227933caa git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Isaac-J-Manjarres/iommu-Permit-modular-builds-of-io-pgtable-drivers/20201222-085121 git checkout 9cc3cfc5f79e5c9072aea2218dd9080227933caa # save the attached .config to linux build tree COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=alpha If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot <lkp@intel.com> All warnings (new ones prefixed by >>): In file included from include/linux/printk.h:7, from include/linux/kernel.h:16, from include/asm-generic/bug.h:20, from arch/alpha/include/asm/bug.h:23, from include/linux/bug.h:5, from include/linux/scatterlist.h:7, from include/linux/iommu.h:10, from include/linux/io-pgtable.h:6, from drivers/iommu/io-pgtable-arm.c:14: drivers/iommu/io-pgtable-arm.c: In function 'arm_lpae_init': >> include/linux/kern_levels.h:5:18: warning: format '%d' expects a matching 'int' argument [-Wformat=] 5 | #define KERN_SOH "\001" /* ASCII Start Of Header */ | ^~~~~~ include/linux/kern_levels.h:11:18: note: in expansion of macro 'KERN_SOH' 11 | #define KERN_ERR KERN_SOH "3" /* error conditions */ | ^~~~~~~~ include/linux/printk.h:343:9: note: in expansion of macro 'KERN_ERR' 343 | printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__) | ^~~~~~~~ drivers/iommu/io-pgtable-arm.c:1257:4: note: in expansion of macro 'pr_err' 1257 | pr_err("Failed to register ARM LPAE fmt: %d\n"); | ^~~~~~ drivers/iommu/io-pgtable-arm.c:1257:46: note: format string is defined here 1257 | pr_err("Failed to register ARM LPAE fmt: %d\n"); | ~^ | | | int vim +5 include/linux/kern_levels.h 314ba3520e513a7 Joe Perches 2012-07-30 4 04d2c8c83d0e3ac Joe Perches 2012-07-30 @5 #define KERN_SOH "\001" /* ASCII Start Of Header */ 04d2c8c83d0e3ac Joe Perches 2012-07-30 6 #define KERN_SOH_ASCII '\001' 04d2c8c83d0e3ac Joe Perches 2012-07-30 7 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org [-- Attachment #2: .config.gz --] [-- Type: application/gzip, Size: 42216 bytes --] [-- Attachment #3: Type: text/plain, Size: 176 bytes --] _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration @ 2020-12-23 19:17 ` kernel test robot 0 siblings, 0 replies; 73+ messages in thread From: kernel test robot @ 2020-12-23 19:17 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, kbuild-all, pdaly [-- Attachment #1: Type: text/plain, Size: 3478 bytes --] Hi "Isaac, Thank you for the patch! Perhaps something to improve: [auto build test WARNING on iommu/next] [also build test WARNING on soc/for-next xlnx/master linus/master v5.10 next-20201223] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch] url: https://github.com/0day-ci/linux/commits/Isaac-J-Manjarres/iommu-Permit-modular-builds-of-io-pgtable-drivers/20201222-085121 base: https://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git next config: alpha-randconfig-r023-20201221 (attached as .config) compiler: alpha-linux-gcc (GCC) 9.3.0 reproduce (this is a W=1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # https://github.com/0day-ci/linux/commit/9cc3cfc5f79e5c9072aea2218dd9080227933caa git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Isaac-J-Manjarres/iommu-Permit-modular-builds-of-io-pgtable-drivers/20201222-085121 git checkout 9cc3cfc5f79e5c9072aea2218dd9080227933caa # save the attached .config to linux build tree COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=alpha If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot <lkp@intel.com> All warnings (new ones prefixed by >>): In file included from include/linux/printk.h:7, from include/linux/kernel.h:16, from include/asm-generic/bug.h:20, from arch/alpha/include/asm/bug.h:23, from include/linux/bug.h:5, from include/linux/scatterlist.h:7, from include/linux/iommu.h:10, from include/linux/io-pgtable.h:6, from drivers/iommu/io-pgtable-arm.c:14: drivers/iommu/io-pgtable-arm.c: In function 'arm_lpae_init': >> include/linux/kern_levels.h:5:18: warning: format '%d' expects a matching 'int' argument [-Wformat=] 5 | #define KERN_SOH "\001" /* ASCII Start Of Header */ | ^~~~~~ include/linux/kern_levels.h:11:18: note: in expansion of macro 'KERN_SOH' 11 | #define KERN_ERR KERN_SOH "3" /* error conditions */ | ^~~~~~~~ include/linux/printk.h:343:9: note: in expansion of macro 'KERN_ERR' 343 | printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__) | ^~~~~~~~ drivers/iommu/io-pgtable-arm.c:1257:4: note: in expansion of macro 'pr_err' 1257 | pr_err("Failed to register ARM LPAE fmt: %d\n"); | ^~~~~~ drivers/iommu/io-pgtable-arm.c:1257:46: note: format string is defined here 1257 | pr_err("Failed to register ARM LPAE fmt: %d\n"); | ~^ | | | int vim +5 include/linux/kern_levels.h 314ba3520e513a7 Joe Perches 2012-07-30 4 04d2c8c83d0e3ac Joe Perches 2012-07-30 @5 #define KERN_SOH "\001" /* ASCII Start Of Header */ 04d2c8c83d0e3ac Joe Perches 2012-07-30 6 #define KERN_SOH_ASCII '\001' 04d2c8c83d0e3ac Joe Perches 2012-07-30 7 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org [-- Attachment #2: .config.gz --] [-- Type: application/gzip, Size: 42216 bytes --] [-- Attachment #3: Type: text/plain, Size: 156 bytes --] _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v2 2/7] iommu/io-pgtable: Add refcounting for io-pgtable format modules 2020-12-22 0:44 ` Isaac J. Manjarres (?) @ 2020-12-22 0:44 ` Isaac J. Manjarres -1 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, joro, pdaly, pratikp, kernel-team, robin.murphy In preparation for modularizing io-pgtable formats, add support for reference counting the io-pgtable format modules to ensure that the modules are not unloaded while they are in use. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/io-pgtable-arm-v7s.c | 1 + drivers/iommu/io-pgtable-arm.c | 5 +++++ drivers/iommu/io-pgtable.c | 12 ++++++++++-- include/linux/io-pgtable.h | 2 ++ 4 files changed, 18 insertions(+), 2 deletions(-) diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c index 89aad2f..a5cb755a 100644 --- a/drivers/iommu/io-pgtable-arm-v7s.c +++ b/drivers/iommu/io-pgtable-arm-v7s.c @@ -840,6 +840,7 @@ static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { .fmt = ARM_V7S, .alloc = arm_v7s_alloc_pgtable, .free = arm_v7s_free_pgtable, + .owner = THIS_MODULE, }; #ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S_SELFTEST diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c index ff0ea2f..e8b1e34 100644 --- a/drivers/iommu/io-pgtable-arm.c +++ b/drivers/iommu/io-pgtable-arm.c @@ -1049,26 +1049,31 @@ static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { .fmt = ARM_32_LPAE_S1, .alloc = arm_32_lpae_alloc_pgtable_s1, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_32_LPAE_S2, .alloc = arm_32_lpae_alloc_pgtable_s2, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_64_LPAE_S1, .alloc = arm_64_lpae_alloc_pgtable_s1, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_64_LPAE_S2, .alloc = arm_64_lpae_alloc_pgtable_s2, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_MALI_LPAE, .alloc = arm_mali_lpae_alloc_pgtable, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, }; diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c index 2c6eb2e..cc83542 100644 --- a/drivers/iommu/io-pgtable.c +++ b/drivers/iommu/io-pgtable.c @@ -10,6 +10,7 @@ #include <linux/bug.h> #include <linux/io-pgtable.h> #include <linux/kernel.h> +#include <linux/module.h> #include <linux/rwlock.h> #include <linux/slab.h> #include <linux/types.h> @@ -52,9 +53,14 @@ struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, if (!fns) return NULL; + if (!try_module_get(fns->owner)) + return NULL; + iop = fns->alloc(cfg, cookie); - if (!iop) + if (!iop) { + module_put(fns->owner); return NULL; + } iop->fmt = fmt; iop->cookie = cookie; @@ -79,8 +85,10 @@ void free_io_pgtable_ops(struct io_pgtable_ops *ops) iop = io_pgtable_ops_to_pgtable(ops); io_pgtable_tlb_flush_all(iop); fns = io_pgtable_get_init_fns(iop->fmt); - if (fns) + if (fns) { fns->free(iop); + module_put(fns->owner); + } } EXPORT_SYMBOL_GPL(free_io_pgtable_ops); diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h index 45b367ce..a03b262 100644 --- a/include/linux/io-pgtable.h +++ b/include/linux/io-pgtable.h @@ -169,11 +169,13 @@ struct io_pgtable_ops { * @fmt: The page table format. * @alloc: Allocate a set of page tables described by cfg. * @free: Free the page tables associated with iop. + * @owner: Driver module providing these ops. */ struct io_pgtable_init_fns { enum io_pgtable_fmt fmt; struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); void (*free)(struct io_pgtable *iop); + struct module *owner; }; /** -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 2/7] iommu/io-pgtable: Add refcounting for io-pgtable format modules @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, joro, robin.murphy, pratikp In preparation for modularizing io-pgtable formats, add support for reference counting the io-pgtable format modules to ensure that the modules are not unloaded while they are in use. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/io-pgtable-arm-v7s.c | 1 + drivers/iommu/io-pgtable-arm.c | 5 +++++ drivers/iommu/io-pgtable.c | 12 ++++++++++-- include/linux/io-pgtable.h | 2 ++ 4 files changed, 18 insertions(+), 2 deletions(-) diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c index 89aad2f..a5cb755a 100644 --- a/drivers/iommu/io-pgtable-arm-v7s.c +++ b/drivers/iommu/io-pgtable-arm-v7s.c @@ -840,6 +840,7 @@ static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { .fmt = ARM_V7S, .alloc = arm_v7s_alloc_pgtable, .free = arm_v7s_free_pgtable, + .owner = THIS_MODULE, }; #ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S_SELFTEST diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c index ff0ea2f..e8b1e34 100644 --- a/drivers/iommu/io-pgtable-arm.c +++ b/drivers/iommu/io-pgtable-arm.c @@ -1049,26 +1049,31 @@ static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { .fmt = ARM_32_LPAE_S1, .alloc = arm_32_lpae_alloc_pgtable_s1, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_32_LPAE_S2, .alloc = arm_32_lpae_alloc_pgtable_s2, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_64_LPAE_S1, .alloc = arm_64_lpae_alloc_pgtable_s1, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_64_LPAE_S2, .alloc = arm_64_lpae_alloc_pgtable_s2, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_MALI_LPAE, .alloc = arm_mali_lpae_alloc_pgtable, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, }; diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c index 2c6eb2e..cc83542 100644 --- a/drivers/iommu/io-pgtable.c +++ b/drivers/iommu/io-pgtable.c @@ -10,6 +10,7 @@ #include <linux/bug.h> #include <linux/io-pgtable.h> #include <linux/kernel.h> +#include <linux/module.h> #include <linux/rwlock.h> #include <linux/slab.h> #include <linux/types.h> @@ -52,9 +53,14 @@ struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, if (!fns) return NULL; + if (!try_module_get(fns->owner)) + return NULL; + iop = fns->alloc(cfg, cookie); - if (!iop) + if (!iop) { + module_put(fns->owner); return NULL; + } iop->fmt = fmt; iop->cookie = cookie; @@ -79,8 +85,10 @@ void free_io_pgtable_ops(struct io_pgtable_ops *ops) iop = io_pgtable_ops_to_pgtable(ops); io_pgtable_tlb_flush_all(iop); fns = io_pgtable_get_init_fns(iop->fmt); - if (fns) + if (fns) { fns->free(iop); + module_put(fns->owner); + } } EXPORT_SYMBOL_GPL(free_io_pgtable_ops); diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h index 45b367ce..a03b262 100644 --- a/include/linux/io-pgtable.h +++ b/include/linux/io-pgtable.h @@ -169,11 +169,13 @@ struct io_pgtable_ops { * @fmt: The page table format. * @alloc: Allocate a set of page tables described by cfg. * @free: Free the page tables associated with iop. + * @owner: Driver module providing these ops. */ struct io_pgtable_init_fns { enum io_pgtable_fmt fmt; struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); void (*free)(struct io_pgtable *iop); + struct module *owner; }; /** -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 2/7] iommu/io-pgtable: Add refcounting for io-pgtable format modules @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, robin.murphy, pratikp In preparation for modularizing io-pgtable formats, add support for reference counting the io-pgtable format modules to ensure that the modules are not unloaded while they are in use. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/io-pgtable-arm-v7s.c | 1 + drivers/iommu/io-pgtable-arm.c | 5 +++++ drivers/iommu/io-pgtable.c | 12 ++++++++++-- include/linux/io-pgtable.h | 2 ++ 4 files changed, 18 insertions(+), 2 deletions(-) diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c index 89aad2f..a5cb755a 100644 --- a/drivers/iommu/io-pgtable-arm-v7s.c +++ b/drivers/iommu/io-pgtable-arm-v7s.c @@ -840,6 +840,7 @@ static struct io_pgtable_init_fns io_pgtable_arm_v7s_init_fns = { .fmt = ARM_V7S, .alloc = arm_v7s_alloc_pgtable, .free = arm_v7s_free_pgtable, + .owner = THIS_MODULE, }; #ifdef CONFIG_IOMMU_IO_PGTABLE_ARMV7S_SELFTEST diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c index ff0ea2f..e8b1e34 100644 --- a/drivers/iommu/io-pgtable-arm.c +++ b/drivers/iommu/io-pgtable-arm.c @@ -1049,26 +1049,31 @@ static struct io_pgtable_init_fns io_pgtable_arm_lpae_init_fns[] = { .fmt = ARM_32_LPAE_S1, .alloc = arm_32_lpae_alloc_pgtable_s1, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_32_LPAE_S2, .alloc = arm_32_lpae_alloc_pgtable_s2, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_64_LPAE_S1, .alloc = arm_64_lpae_alloc_pgtable_s1, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_64_LPAE_S2, .alloc = arm_64_lpae_alloc_pgtable_s2, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, { .fmt = ARM_MALI_LPAE, .alloc = arm_mali_lpae_alloc_pgtable, .free = arm_lpae_free_pgtable, + .owner = THIS_MODULE, }, }; diff --git a/drivers/iommu/io-pgtable.c b/drivers/iommu/io-pgtable.c index 2c6eb2e..cc83542 100644 --- a/drivers/iommu/io-pgtable.c +++ b/drivers/iommu/io-pgtable.c @@ -10,6 +10,7 @@ #include <linux/bug.h> #include <linux/io-pgtable.h> #include <linux/kernel.h> +#include <linux/module.h> #include <linux/rwlock.h> #include <linux/slab.h> #include <linux/types.h> @@ -52,9 +53,14 @@ struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt, if (!fns) return NULL; + if (!try_module_get(fns->owner)) + return NULL; + iop = fns->alloc(cfg, cookie); - if (!iop) + if (!iop) { + module_put(fns->owner); return NULL; + } iop->fmt = fmt; iop->cookie = cookie; @@ -79,8 +85,10 @@ void free_io_pgtable_ops(struct io_pgtable_ops *ops) iop = io_pgtable_ops_to_pgtable(ops); io_pgtable_tlb_flush_all(iop); fns = io_pgtable_get_init_fns(iop->fmt); - if (fns) + if (fns) { fns->free(iop); + module_put(fns->owner); + } } EXPORT_SYMBOL_GPL(free_io_pgtable_ops); diff --git a/include/linux/io-pgtable.h b/include/linux/io-pgtable.h index 45b367ce..a03b262 100644 --- a/include/linux/io-pgtable.h +++ b/include/linux/io-pgtable.h @@ -169,11 +169,13 @@ struct io_pgtable_ops { * @fmt: The page table format. * @alloc: Allocate a set of page tables described by cfg. * @free: Free the page tables associated with iop. + * @owner: Driver module providing these ops. */ struct io_pgtable_init_fns { enum io_pgtable_fmt fmt; struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie); void (*free)(struct io_pgtable *iop); + struct module *owner; }; /** -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules 2020-12-22 0:44 ` Isaac J. Manjarres (?) @ 2020-12-22 0:44 ` Isaac J. Manjarres -1 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, joro, pdaly, pratikp, kernel-team, robin.murphy The SMMU driver depends on the availability of the ARM LPAE and ARM V7S io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable format modules are loaded before loading the ARM SMMU driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c index d8c6bfd..a72649f 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM architected SMMU implementations"); MODULE_AUTHOR("Will Deacon <will@kernel.org>"); MODULE_ALIAS("platform:arm-smmu"); MODULE_LICENSE("GPL v2"); +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, joro, robin.murphy, pratikp The SMMU driver depends on the availability of the ARM LPAE and ARM V7S io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable format modules are loaded before loading the ARM SMMU driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c index d8c6bfd..a72649f 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM architected SMMU implementations"); MODULE_AUTHOR("Will Deacon <will@kernel.org>"); MODULE_ALIAS("platform:arm-smmu"); MODULE_LICENSE("GPL v2"); +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, robin.murphy, pratikp The SMMU driver depends on the availability of the ARM LPAE and ARM V7S io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable format modules are loaded before loading the ARM SMMU driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c index d8c6bfd..a72649f 100644 --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM architected SMMU implementations"); MODULE_AUTHOR("Will Deacon <will@kernel.org>"); MODULE_ALIAS("platform:arm-smmu"); MODULE_LICENSE("GPL v2"); +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply related [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules 2020-12-22 0:44 ` Isaac J. Manjarres (?) (?) @ 2020-12-22 19:27 ` Robin Murphy -1 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-22 19:27 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: will, joro, pdaly, pratikp, kernel-team On 2020-12-22 00:44, Isaac J. Manjarres wrote: > The SMMU driver depends on the availability of the ARM LPAE and > ARM V7S io-pgtable format code to work properly. In preparation Nit: we don't really depend on v7s - we *can* use it if it's available, address constraints are suitable, and the SMMU implementation actually supports it (many don't), but we can still quite happily not use it even so. LPAE is mandatory in the architecture so that's our only hard requirement, embodied in the kconfig select. This does mean there may technically still be a corner case involving ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime failure rather than a build error, so unless and until anyone demonstrates that it actually matters I don't feel particularly inclined to give it much thought. Robin. > for having the io-pgtable formats as modules, add a "pre" > dependency with MODULE_SOFTDEP() to ensure that the io-pgtable > format modules are loaded before loading the ARM SMMU driver module. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + > 1 file changed, 1 insertion(+) > > diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c > index d8c6bfd..a72649f 100644 > --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c > +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c > @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM architected SMMU implementations"); > MODULE_AUTHOR("Will Deacon <will@kernel.org>"); > MODULE_ALIAS("platform:arm-smmu"); > MODULE_LICENSE("GPL v2"); > +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); > ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-22 19:27 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-22 19:27 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: pratikp, joro, kernel-team, will, pdaly On 2020-12-22 00:44, Isaac J. Manjarres wrote: > The SMMU driver depends on the availability of the ARM LPAE and > ARM V7S io-pgtable format code to work properly. In preparation Nit: we don't really depend on v7s - we *can* use it if it's available, address constraints are suitable, and the SMMU implementation actually supports it (many don't), but we can still quite happily not use it even so. LPAE is mandatory in the architecture so that's our only hard requirement, embodied in the kconfig select. This does mean there may technically still be a corner case involving ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime failure rather than a build error, so unless and until anyone demonstrates that it actually matters I don't feel particularly inclined to give it much thought. Robin. > for having the io-pgtable formats as modules, add a "pre" > dependency with MODULE_SOFTDEP() to ensure that the io-pgtable > format modules are loaded before loading the ARM SMMU driver module. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + > 1 file changed, 1 insertion(+) > > diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c > index d8c6bfd..a72649f 100644 > --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c > +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c > @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM architected SMMU implementations"); > MODULE_AUTHOR("Will Deacon <will@kernel.org>"); > MODULE_ALIAS("platform:arm-smmu"); > MODULE_LICENSE("GPL v2"); > +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); > _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-22 19:27 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-22 19:27 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: pratikp, joro, kernel-team, will, pdaly On 2020-12-22 00:44, Isaac J. Manjarres wrote: > The SMMU driver depends on the availability of the ARM LPAE and > ARM V7S io-pgtable format code to work properly. In preparation Nit: we don't really depend on v7s - we *can* use it if it's available, address constraints are suitable, and the SMMU implementation actually supports it (many don't), but we can still quite happily not use it even so. LPAE is mandatory in the architecture so that's our only hard requirement, embodied in the kconfig select. This does mean there may technically still be a corner case involving ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime failure rather than a build error, so unless and until anyone demonstrates that it actually matters I don't feel particularly inclined to give it much thought. Robin. > for having the io-pgtable formats as modules, add a "pre" > dependency with MODULE_SOFTDEP() to ensure that the io-pgtable > format modules are loaded before loading the ARM SMMU driver module. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + > 1 file changed, 1 insertion(+) > > diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c > index d8c6bfd..a72649f 100644 > --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c > +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c > @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM architected SMMU implementations"); > MODULE_AUTHOR("Will Deacon <will@kernel.org>"); > MODULE_ALIAS("platform:arm-smmu"); > MODULE_LICENSE("GPL v2"); > +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-22 19:27 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-22 19:27 UTC (permalink / raw) To: Isaac J. Manjarres, iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: pratikp, kernel-team, will, pdaly On 2020-12-22 00:44, Isaac J. Manjarres wrote: > The SMMU driver depends on the availability of the ARM LPAE and > ARM V7S io-pgtable format code to work properly. In preparation Nit: we don't really depend on v7s - we *can* use it if it's available, address constraints are suitable, and the SMMU implementation actually supports it (many don't), but we can still quite happily not use it even so. LPAE is mandatory in the architecture so that's our only hard requirement, embodied in the kconfig select. This does mean there may technically still be a corner case involving ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime failure rather than a build error, so unless and until anyone demonstrates that it actually matters I don't feel particularly inclined to give it much thought. Robin. > for having the io-pgtable formats as modules, add a "pre" > dependency with MODULE_SOFTDEP() to ensure that the io-pgtable > format modules are loaded before loading the ARM SMMU driver module. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > --- > drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + > 1 file changed, 1 insertion(+) > > diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c > index d8c6bfd..a72649f 100644 > --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c > +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c > @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM architected SMMU implementations"); > MODULE_AUTHOR("Will Deacon <will@kernel.org>"); > MODULE_ALIAS("platform:arm-smmu"); > MODULE_LICENSE("GPL v2"); > +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); > _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules 2020-12-22 19:27 ` Robin Murphy (?) @ 2020-12-22 19:49 ` isaacm -1 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-22 19:49 UTC (permalink / raw) To: Robin Murphy Cc: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm, pratikp, joro, kernel-team, will, pdaly On 2020-12-22 11:27, Robin Murphy wrote: > On 2020-12-22 00:44, Isaac J. Manjarres wrote: >> The SMMU driver depends on the availability of the ARM LPAE and >> ARM V7S io-pgtable format code to work properly. In preparation > > Nit: we don't really depend on v7s - we *can* use it if it's > available, address constraints are suitable, and the SMMU > implementation actually supports it (many don't), but we can still > quite happily not use it even so. LPAE is mandatory in the > architecture so that's our only hard requirement, embodied in the > kconfig select. > > This does mean there may technically still be a corner case involving > ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime > failure rather than a build error, so unless and until anyone > demonstrates that it actually matters I don't feel particularly > inclined to give it much thought. > > Robin. > Okay, I'll fix up the commit message, as well as the code, so that it only depends on io-pgtable-arm. Thanks, Isaac >> for having the io-pgtable formats as modules, add a "pre" >> dependency with MODULE_SOFTDEP() to ensure that the io-pgtable >> format modules are loaded before loading the ARM SMMU driver module. >> >> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >> --- >> drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + >> 1 file changed, 1 insertion(+) >> >> diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c >> b/drivers/iommu/arm/arm-smmu/arm-smmu.c >> index d8c6bfd..a72649f 100644 >> --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c >> +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c >> @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM >> architected SMMU implementations"); >> MODULE_AUTHOR("Will Deacon <will@kernel.org>"); >> MODULE_ALIAS("platform:arm-smmu"); >> MODULE_LICENSE("GPL v2"); >> +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); >> > > _______________________________________________ > linux-arm-kernel mailing list > linux-arm-kernel@lists.infradead.org > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-22 19:49 ` isaacm 0 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-22 19:49 UTC (permalink / raw) To: Robin Murphy Cc: kernel-team, will, pdaly, linux-arm-msm, joro, linux-kernel, dri-devel, iommu, freedreno, linux-arm-kernel, pratikp On 2020-12-22 11:27, Robin Murphy wrote: > On 2020-12-22 00:44, Isaac J. Manjarres wrote: >> The SMMU driver depends on the availability of the ARM LPAE and >> ARM V7S io-pgtable format code to work properly. In preparation > > Nit: we don't really depend on v7s - we *can* use it if it's > available, address constraints are suitable, and the SMMU > implementation actually supports it (many don't), but we can still > quite happily not use it even so. LPAE is mandatory in the > architecture so that's our only hard requirement, embodied in the > kconfig select. > > This does mean there may technically still be a corner case involving > ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime > failure rather than a build error, so unless and until anyone > demonstrates that it actually matters I don't feel particularly > inclined to give it much thought. > > Robin. > Okay, I'll fix up the commit message, as well as the code, so that it only depends on io-pgtable-arm. Thanks, Isaac >> for having the io-pgtable formats as modules, add a "pre" >> dependency with MODULE_SOFTDEP() to ensure that the io-pgtable >> format modules are loaded before loading the ARM SMMU driver module. >> >> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >> --- >> drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + >> 1 file changed, 1 insertion(+) >> >> diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c >> b/drivers/iommu/arm/arm-smmu/arm-smmu.c >> index d8c6bfd..a72649f 100644 >> --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c >> +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c >> @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM >> architected SMMU implementations"); >> MODULE_AUTHOR("Will Deacon <will@kernel.org>"); >> MODULE_ALIAS("platform:arm-smmu"); >> MODULE_LICENSE("GPL v2"); >> +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); >> > > _______________________________________________ > linux-arm-kernel mailing list > linux-arm-kernel@lists.infradead.org > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-22 19:49 ` isaacm 0 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-22 19:49 UTC (permalink / raw) To: Robin Murphy Cc: kernel-team, will, pdaly, linux-arm-msm, linux-kernel, dri-devel, iommu, freedreno, linux-arm-kernel, pratikp On 2020-12-22 11:27, Robin Murphy wrote: > On 2020-12-22 00:44, Isaac J. Manjarres wrote: >> The SMMU driver depends on the availability of the ARM LPAE and >> ARM V7S io-pgtable format code to work properly. In preparation > > Nit: we don't really depend on v7s - we *can* use it if it's > available, address constraints are suitable, and the SMMU > implementation actually supports it (many don't), but we can still > quite happily not use it even so. LPAE is mandatory in the > architecture so that's our only hard requirement, embodied in the > kconfig select. > > This does mean there may technically still be a corner case involving > ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime > failure rather than a build error, so unless and until anyone > demonstrates that it actually matters I don't feel particularly > inclined to give it much thought. > > Robin. > Okay, I'll fix up the commit message, as well as the code, so that it only depends on io-pgtable-arm. Thanks, Isaac >> for having the io-pgtable formats as modules, add a "pre" >> dependency with MODULE_SOFTDEP() to ensure that the io-pgtable >> format modules are loaded before loading the ARM SMMU driver module. >> >> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >> --- >> drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + >> 1 file changed, 1 insertion(+) >> >> diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c >> b/drivers/iommu/arm/arm-smmu/arm-smmu.c >> index d8c6bfd..a72649f 100644 >> --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c >> +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c >> @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM >> architected SMMU implementations"); >> MODULE_AUTHOR("Will Deacon <will@kernel.org>"); >> MODULE_ALIAS("platform:arm-smmu"); >> MODULE_LICENSE("GPL v2"); >> +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); >> > > _______________________________________________ > linux-arm-kernel mailing list > linux-arm-kernel@lists.infradead.org > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules 2020-12-22 19:49 ` isaacm (?) (?) @ 2020-12-23 13:05 ` Robin Murphy -1 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-23 13:05 UTC (permalink / raw) To: isaacm Cc: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm, pratikp, joro, kernel-team, will, pdaly On 2020-12-22 19:49, isaacm@codeaurora.org wrote: > On 2020-12-22 11:27, Robin Murphy wrote: >> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>> The SMMU driver depends on the availability of the ARM LPAE and >>> ARM V7S io-pgtable format code to work properly. In preparation >> >> Nit: we don't really depend on v7s - we *can* use it if it's >> available, address constraints are suitable, and the SMMU >> implementation actually supports it (many don't), but we can still >> quite happily not use it even so. LPAE is mandatory in the >> architecture so that's our only hard requirement, embodied in the >> kconfig select. >> >> This does mean there may technically still be a corner case involving >> ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime >> failure rather than a build error, so unless and until anyone >> demonstrates that it actually matters I don't feel particularly >> inclined to give it much thought. >> >> Robin. >> > Okay, I'll fix up the commit message, as well as the code, so that it > only depends on io-pgtable-arm. Well, IIUC it would make sense to keep the softdep for when the v7s module *is* present; I just wanted to clarify that it's more of a nice-to-have rather than a necessity. Robin. > Thanks, > Isaac >>> for having the io-pgtable formats as modules, add a "pre" >>> dependency with MODULE_SOFTDEP() to ensure that the io-pgtable >>> format modules are loaded before loading the ARM SMMU driver module. >>> >>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>> --- >>> drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + >>> 1 file changed, 1 insertion(+) >>> >>> diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> index d8c6bfd..a72649f 100644 >>> --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM >>> architected SMMU implementations"); >>> MODULE_AUTHOR("Will Deacon <will@kernel.org>"); >>> MODULE_ALIAS("platform:arm-smmu"); >>> MODULE_LICENSE("GPL v2"); >>> +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); >>> >> >> _______________________________________________ >> linux-arm-kernel mailing list >> linux-arm-kernel@lists.infradead.org >> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-23 13:05 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-23 13:05 UTC (permalink / raw) To: isaacm Cc: kernel-team, will, pdaly, linux-arm-msm, joro, linux-kernel, dri-devel, iommu, freedreno, linux-arm-kernel, pratikp On 2020-12-22 19:49, isaacm@codeaurora.org wrote: > On 2020-12-22 11:27, Robin Murphy wrote: >> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>> The SMMU driver depends on the availability of the ARM LPAE and >>> ARM V7S io-pgtable format code to work properly. In preparation >> >> Nit: we don't really depend on v7s - we *can* use it if it's >> available, address constraints are suitable, and the SMMU >> implementation actually supports it (many don't), but we can still >> quite happily not use it even so. LPAE is mandatory in the >> architecture so that's our only hard requirement, embodied in the >> kconfig select. >> >> This does mean there may technically still be a corner case involving >> ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime >> failure rather than a build error, so unless and until anyone >> demonstrates that it actually matters I don't feel particularly >> inclined to give it much thought. >> >> Robin. >> > Okay, I'll fix up the commit message, as well as the code, so that it > only depends on io-pgtable-arm. Well, IIUC it would make sense to keep the softdep for when the v7s module *is* present; I just wanted to clarify that it's more of a nice-to-have rather than a necessity. Robin. > Thanks, > Isaac >>> for having the io-pgtable formats as modules, add a "pre" >>> dependency with MODULE_SOFTDEP() to ensure that the io-pgtable >>> format modules are loaded before loading the ARM SMMU driver module. >>> >>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>> --- >>> drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + >>> 1 file changed, 1 insertion(+) >>> >>> diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> index d8c6bfd..a72649f 100644 >>> --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM >>> architected SMMU implementations"); >>> MODULE_AUTHOR("Will Deacon <will@kernel.org>"); >>> MODULE_ALIAS("platform:arm-smmu"); >>> MODULE_LICENSE("GPL v2"); >>> +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); >>> >> >> _______________________________________________ >> linux-arm-kernel mailing list >> linux-arm-kernel@lists.infradead.org >> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-23 13:05 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-23 13:05 UTC (permalink / raw) To: isaacm Cc: kernel-team, will, pdaly, linux-arm-msm, joro, linux-kernel, dri-devel, iommu, freedreno, linux-arm-kernel, pratikp On 2020-12-22 19:49, isaacm@codeaurora.org wrote: > On 2020-12-22 11:27, Robin Murphy wrote: >> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>> The SMMU driver depends on the availability of the ARM LPAE and >>> ARM V7S io-pgtable format code to work properly. In preparation >> >> Nit: we don't really depend on v7s - we *can* use it if it's >> available, address constraints are suitable, and the SMMU >> implementation actually supports it (many don't), but we can still >> quite happily not use it even so. LPAE is mandatory in the >> architecture so that's our only hard requirement, embodied in the >> kconfig select. >> >> This does mean there may technically still be a corner case involving >> ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime >> failure rather than a build error, so unless and until anyone >> demonstrates that it actually matters I don't feel particularly >> inclined to give it much thought. >> >> Robin. >> > Okay, I'll fix up the commit message, as well as the code, so that it > only depends on io-pgtable-arm. Well, IIUC it would make sense to keep the softdep for when the v7s module *is* present; I just wanted to clarify that it's more of a nice-to-have rather than a necessity. Robin. > Thanks, > Isaac >>> for having the io-pgtable formats as modules, add a "pre" >>> dependency with MODULE_SOFTDEP() to ensure that the io-pgtable >>> format modules are loaded before loading the ARM SMMU driver module. >>> >>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>> --- >>> drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + >>> 1 file changed, 1 insertion(+) >>> >>> diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> index d8c6bfd..a72649f 100644 >>> --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM >>> architected SMMU implementations"); >>> MODULE_AUTHOR("Will Deacon <will@kernel.org>"); >>> MODULE_ALIAS("platform:arm-smmu"); >>> MODULE_LICENSE("GPL v2"); >>> +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); >>> >> >> _______________________________________________ >> linux-arm-kernel mailing list >> linux-arm-kernel@lists.infradead.org >> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-23 13:05 ` Robin Murphy 0 siblings, 0 replies; 73+ messages in thread From: Robin Murphy @ 2020-12-23 13:05 UTC (permalink / raw) To: isaacm Cc: kernel-team, will, pdaly, linux-arm-msm, linux-kernel, dri-devel, iommu, freedreno, linux-arm-kernel, pratikp On 2020-12-22 19:49, isaacm@codeaurora.org wrote: > On 2020-12-22 11:27, Robin Murphy wrote: >> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>> The SMMU driver depends on the availability of the ARM LPAE and >>> ARM V7S io-pgtable format code to work properly. In preparation >> >> Nit: we don't really depend on v7s - we *can* use it if it's >> available, address constraints are suitable, and the SMMU >> implementation actually supports it (many don't), but we can still >> quite happily not use it even so. LPAE is mandatory in the >> architecture so that's our only hard requirement, embodied in the >> kconfig select. >> >> This does mean there may technically still be a corner case involving >> ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime >> failure rather than a build error, so unless and until anyone >> demonstrates that it actually matters I don't feel particularly >> inclined to give it much thought. >> >> Robin. >> > Okay, I'll fix up the commit message, as well as the code, so that it > only depends on io-pgtable-arm. Well, IIUC it would make sense to keep the softdep for when the v7s module *is* present; I just wanted to clarify that it's more of a nice-to-have rather than a necessity. Robin. > Thanks, > Isaac >>> for having the io-pgtable formats as modules, add a "pre" >>> dependency with MODULE_SOFTDEP() to ensure that the io-pgtable >>> format modules are loaded before loading the ARM SMMU driver module. >>> >>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>> --- >>> drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + >>> 1 file changed, 1 insertion(+) >>> >>> diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> index d8c6bfd..a72649f 100644 >>> --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>> @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM >>> architected SMMU implementations"); >>> MODULE_AUTHOR("Will Deacon <will@kernel.org>"); >>> MODULE_ALIAS("platform:arm-smmu"); >>> MODULE_LICENSE("GPL v2"); >>> +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); >>> >> >> _______________________________________________ >> linux-arm-kernel mailing list >> linux-arm-kernel@lists.infradead.org >> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules 2020-12-23 13:05 ` Robin Murphy (?) @ 2020-12-23 15:10 ` isaacm -1 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-23 15:10 UTC (permalink / raw) To: Robin Murphy Cc: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm, pratikp, joro, kernel-team, will, pdaly On 2020-12-23 05:05, Robin Murphy wrote: > On 2020-12-22 19:49, isaacm@codeaurora.org wrote: >> On 2020-12-22 11:27, Robin Murphy wrote: >>> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>>> The SMMU driver depends on the availability of the ARM LPAE and >>>> ARM V7S io-pgtable format code to work properly. In preparation >>> >>> Nit: we don't really depend on v7s - we *can* use it if it's >>> available, address constraints are suitable, and the SMMU >>> implementation actually supports it (many don't), but we can still >>> quite happily not use it even so. LPAE is mandatory in the >>> architecture so that's our only hard requirement, embodied in the >>> kconfig select. >>> >>> This does mean there may technically still be a corner case involving >>> ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime >>> failure rather than a build error, so unless and until anyone >>> demonstrates that it actually matters I don't feel particularly >>> inclined to give it much thought. >>> >>> Robin. >>> >> Okay, I'll fix up the commit message, as well as the code, so that it >> only depends on io-pgtable-arm. > > Well, IIUC it would make sense to keep the softdep for when the v7s > module *is* present; I just wanted to clarify that it's more of a > nice-to-have rather than a necessity. > > Robin. > Understood, I will keep it there and reword the commit msg. I just tried it out in an environment where the io-pgtable-arm-v7s module isn't present, and I didn't see any warnings or error messages, and the SMMU driver module was loaded properly, so yes, it's good to have it. Thanks, Isaac >> Thanks, >> Isaac >>>> for having the io-pgtable formats as modules, add a "pre" >>>> dependency with MODULE_SOFTDEP() to ensure that the io-pgtable >>>> format modules are loaded before loading the ARM SMMU driver module. >>>> >>>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>>> --- >>>> drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + >>>> 1 file changed, 1 insertion(+) >>>> >>>> diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> index d8c6bfd..a72649f 100644 >>>> --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM >>>> architected SMMU implementations"); >>>> MODULE_AUTHOR("Will Deacon <will@kernel.org>"); >>>> MODULE_ALIAS("platform:arm-smmu"); >>>> MODULE_LICENSE("GPL v2"); >>>> +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); >>>> >>> >>> _______________________________________________ >>> linux-arm-kernel mailing list >>> linux-arm-kernel@lists.infradead.org >>> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-23 15:10 ` isaacm 0 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-23 15:10 UTC (permalink / raw) To: Robin Murphy Cc: kernel-team, will, pdaly, linux-arm-msm, joro, linux-kernel, dri-devel, iommu, freedreno, linux-arm-kernel, pratikp On 2020-12-23 05:05, Robin Murphy wrote: > On 2020-12-22 19:49, isaacm@codeaurora.org wrote: >> On 2020-12-22 11:27, Robin Murphy wrote: >>> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>>> The SMMU driver depends on the availability of the ARM LPAE and >>>> ARM V7S io-pgtable format code to work properly. In preparation >>> >>> Nit: we don't really depend on v7s - we *can* use it if it's >>> available, address constraints are suitable, and the SMMU >>> implementation actually supports it (many don't), but we can still >>> quite happily not use it even so. LPAE is mandatory in the >>> architecture so that's our only hard requirement, embodied in the >>> kconfig select. >>> >>> This does mean there may technically still be a corner case involving >>> ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime >>> failure rather than a build error, so unless and until anyone >>> demonstrates that it actually matters I don't feel particularly >>> inclined to give it much thought. >>> >>> Robin. >>> >> Okay, I'll fix up the commit message, as well as the code, so that it >> only depends on io-pgtable-arm. > > Well, IIUC it would make sense to keep the softdep for when the v7s > module *is* present; I just wanted to clarify that it's more of a > nice-to-have rather than a necessity. > > Robin. > Understood, I will keep it there and reword the commit msg. I just tried it out in an environment where the io-pgtable-arm-v7s module isn't present, and I didn't see any warnings or error messages, and the SMMU driver module was loaded properly, so yes, it's good to have it. Thanks, Isaac >> Thanks, >> Isaac >>>> for having the io-pgtable formats as modules, add a "pre" >>>> dependency with MODULE_SOFTDEP() to ensure that the io-pgtable >>>> format modules are loaded before loading the ARM SMMU driver module. >>>> >>>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>>> --- >>>> drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + >>>> 1 file changed, 1 insertion(+) >>>> >>>> diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> index d8c6bfd..a72649f 100644 >>>> --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM >>>> architected SMMU implementations"); >>>> MODULE_AUTHOR("Will Deacon <will@kernel.org>"); >>>> MODULE_ALIAS("platform:arm-smmu"); >>>> MODULE_LICENSE("GPL v2"); >>>> +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); >>>> >>> >>> _______________________________________________ >>> linux-arm-kernel mailing list >>> linux-arm-kernel@lists.infradead.org >>> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 3/7] iommu/arm-smmu: Add dependency on io-pgtable format modules @ 2020-12-23 15:10 ` isaacm 0 siblings, 0 replies; 73+ messages in thread From: isaacm @ 2020-12-23 15:10 UTC (permalink / raw) To: Robin Murphy Cc: kernel-team, will, pdaly, linux-arm-msm, linux-kernel, dri-devel, iommu, freedreno, linux-arm-kernel, pratikp On 2020-12-23 05:05, Robin Murphy wrote: > On 2020-12-22 19:49, isaacm@codeaurora.org wrote: >> On 2020-12-22 11:27, Robin Murphy wrote: >>> On 2020-12-22 00:44, Isaac J. Manjarres wrote: >>>> The SMMU driver depends on the availability of the ARM LPAE and >>>> ARM V7S io-pgtable format code to work properly. In preparation >>> >>> Nit: we don't really depend on v7s - we *can* use it if it's >>> available, address constraints are suitable, and the SMMU >>> implementation actually supports it (many don't), but we can still >>> quite happily not use it even so. LPAE is mandatory in the >>> architecture so that's our only hard requirement, embodied in the >>> kconfig select. >>> >>> This does mean there may technically still be a corner case involving >>> ARM_SMMU=y and IO_PGTABLE_ARM_V7S=m, but at worst it's now a runtime >>> failure rather than a build error, so unless and until anyone >>> demonstrates that it actually matters I don't feel particularly >>> inclined to give it much thought. >>> >>> Robin. >>> >> Okay, I'll fix up the commit message, as well as the code, so that it >> only depends on io-pgtable-arm. > > Well, IIUC it would make sense to keep the softdep for when the v7s > module *is* present; I just wanted to clarify that it's more of a > nice-to-have rather than a necessity. > > Robin. > Understood, I will keep it there and reword the commit msg. I just tried it out in an environment where the io-pgtable-arm-v7s module isn't present, and I didn't see any warnings or error messages, and the SMMU driver module was loaded properly, so yes, it's good to have it. Thanks, Isaac >> Thanks, >> Isaac >>>> for having the io-pgtable formats as modules, add a "pre" >>>> dependency with MODULE_SOFTDEP() to ensure that the io-pgtable >>>> format modules are loaded before loading the ARM SMMU driver module. >>>> >>>> Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> >>>> --- >>>> drivers/iommu/arm/arm-smmu/arm-smmu.c | 1 + >>>> 1 file changed, 1 insertion(+) >>>> >>>> diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> index d8c6bfd..a72649f 100644 >>>> --- a/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> +++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c >>>> @@ -2351,3 +2351,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM >>>> architected SMMU implementations"); >>>> MODULE_AUTHOR("Will Deacon <will@kernel.org>"); >>>> MODULE_ALIAS("platform:arm-smmu"); >>>> MODULE_LICENSE("GPL v2"); >>>> +MODULE_SOFTDEP("pre: io-pgtable-arm io-pgtable-arm-v7s"); >>>> >>> >>> _______________________________________________ >>> linux-arm-kernel mailing list >>> linux-arm-kernel@lists.infradead.org >>> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v2 4/7] iommu/arm-smmu-v3: Add dependency on io-pgtable-arm format module 2020-12-22 0:44 ` Isaac J. Manjarres (?) @ 2020-12-22 0:44 ` Isaac J. Manjarres -1 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, joro, pdaly, pratikp, kernel-team, robin.murphy The SMMUv3 driver depends on the availability of the ARM LPAE io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable-arm format module is loaded before loading the ARM SMMUv3 driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c index 8ca7415..c498ac8 100644 --- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c @@ -3650,3 +3650,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM architected SMMUv3 implementations"); MODULE_AUTHOR("Will Deacon <will@kernel.org>"); MODULE_ALIAS("platform:arm-smmu-v3"); MODULE_LICENSE("GPL v2"); +MODULE_SOFTDEP("pre: io-pgtable-arm"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 4/7] iommu/arm-smmu-v3: Add dependency on io-pgtable-arm format module @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, joro, robin.murphy, pratikp The SMMUv3 driver depends on the availability of the ARM LPAE io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable-arm format module is loaded before loading the ARM SMMUv3 driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c index 8ca7415..c498ac8 100644 --- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c @@ -3650,3 +3650,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM architected SMMUv3 implementations"); MODULE_AUTHOR("Will Deacon <will@kernel.org>"); MODULE_ALIAS("platform:arm-smmu-v3"); MODULE_LICENSE("GPL v2"); +MODULE_SOFTDEP("pre: io-pgtable-arm"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 4/7] iommu/arm-smmu-v3: Add dependency on io-pgtable-arm format module @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, robin.murphy, pratikp The SMMUv3 driver depends on the availability of the ARM LPAE io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable-arm format module is loaded before loading the ARM SMMUv3 driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c index 8ca7415..c498ac8 100644 --- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c @@ -3650,3 +3650,4 @@ MODULE_DESCRIPTION("IOMMU API for ARM architected SMMUv3 implementations"); MODULE_AUTHOR("Will Deacon <will@kernel.org>"); MODULE_ALIAS("platform:arm-smmu-v3"); MODULE_LICENSE("GPL v2"); +MODULE_SOFTDEP("pre: io-pgtable-arm"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module 2020-12-22 0:44 ` Isaac J. Manjarres (?) @ 2020-12-22 0:44 ` Isaac J. Manjarres -1 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, joro, pdaly, pratikp, kernel-team, robin.murphy The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable-arm format module is loaded before loading the MSM DRM driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/gpu/drm/msm/msm_drv.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c index 535a026..8be3506 100644 --- a/drivers/gpu/drm/msm/msm_drv.c +++ b/drivers/gpu/drm/msm/msm_drv.c @@ -1369,3 +1369,4 @@ module_exit(msm_drm_unregister); MODULE_AUTHOR("Rob Clark <robdclark@gmail.com"); MODULE_DESCRIPTION("MSM DRM Driver"); MODULE_LICENSE("GPL"); +MODULE_SOFTDEP("pre: io-pgtable-arm"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, joro, robin.murphy, pratikp The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable-arm format module is loaded before loading the MSM DRM driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/gpu/drm/msm/msm_drv.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c index 535a026..8be3506 100644 --- a/drivers/gpu/drm/msm/msm_drv.c +++ b/drivers/gpu/drm/msm/msm_drv.c @@ -1369,3 +1369,4 @@ module_exit(msm_drm_unregister); MODULE_AUTHOR("Rob Clark <robdclark@gmail.com"); MODULE_DESCRIPTION("MSM DRM Driver"); MODULE_LICENSE("GPL"); +MODULE_SOFTDEP("pre: io-pgtable-arm"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, robin.murphy, pratikp The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable-arm format module is loaded before loading the MSM DRM driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/gpu/drm/msm/msm_drv.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c index 535a026..8be3506 100644 --- a/drivers/gpu/drm/msm/msm_drv.c +++ b/drivers/gpu/drm/msm/msm_drv.c @@ -1369,3 +1369,4 @@ module_exit(msm_drm_unregister); MODULE_AUTHOR("Rob Clark <robdclark@gmail.com"); MODULE_DESCRIPTION("MSM DRM Driver"); MODULE_LICENSE("GPL"); +MODULE_SOFTDEP("pre: io-pgtable-arm"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply related [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module 2020-12-22 0:44 ` Isaac J. Manjarres (?) (?) @ 2021-01-18 21:16 ` Rob Clark -1 siblings, 0 replies; 73+ messages in thread From: Rob Clark @ 2021-01-18 21:16 UTC (permalink / raw) To: Isaac J. Manjarres Cc: list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>,, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Linux Kernel Mailing List, freedreno, dri-devel, linux-arm-msm, Will Deacon, pdaly, Android Kernel Team, Robin Murphy, Pratik Patel On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres <isaacm@codeaurora.org> wrote: > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > format code to work properly. In preparation for having the io-pgtable > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > ensure that the io-pgtable-arm format module is loaded before loading > the MSM DRM driver module. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> Thanks, I've queued this up locally BR, -R > --- > drivers/gpu/drm/msm/msm_drv.c | 1 + > 1 file changed, 1 insertion(+) > > diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c > index 535a026..8be3506 100644 > --- a/drivers/gpu/drm/msm/msm_drv.c > +++ b/drivers/gpu/drm/msm/msm_drv.c > @@ -1369,3 +1369,4 @@ module_exit(msm_drm_unregister); > MODULE_AUTHOR("Rob Clark <robdclark@gmail.com"); > MODULE_DESCRIPTION("MSM DRM Driver"); > MODULE_LICENSE("GPL"); > +MODULE_SOFTDEP("pre: io-pgtable-arm"); > -- > The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, > a Linux Foundation Collaborative Project > > _______________________________________________ > iommu mailing list > iommu@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module @ 2021-01-18 21:16 ` Rob Clark 0 siblings, 0 replies; 73+ messages in thread From: Rob Clark @ 2021-01-18 21:16 UTC (permalink / raw) To: Isaac J. Manjarres Cc: Android Kernel Team, Will Deacon, pdaly, linux-arm-msm, Linux Kernel Mailing List, dri-devel, list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>, , Pratik Patel, freedreno, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Robin Murphy On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres <isaacm@codeaurora.org> wrote: > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > format code to work properly. In preparation for having the io-pgtable > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > ensure that the io-pgtable-arm format module is loaded before loading > the MSM DRM driver module. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> Thanks, I've queued this up locally BR, -R > --- > drivers/gpu/drm/msm/msm_drv.c | 1 + > 1 file changed, 1 insertion(+) > > diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c > index 535a026..8be3506 100644 > --- a/drivers/gpu/drm/msm/msm_drv.c > +++ b/drivers/gpu/drm/msm/msm_drv.c > @@ -1369,3 +1369,4 @@ module_exit(msm_drm_unregister); > MODULE_AUTHOR("Rob Clark <robdclark@gmail.com"); > MODULE_DESCRIPTION("MSM DRM Driver"); > MODULE_LICENSE("GPL"); > +MODULE_SOFTDEP("pre: io-pgtable-arm"); > -- > The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, > a Linux Foundation Collaborative Project > > _______________________________________________ > iommu mailing list > iommu@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module @ 2021-01-18 21:16 ` Rob Clark 0 siblings, 0 replies; 73+ messages in thread From: Rob Clark @ 2021-01-18 21:16 UTC (permalink / raw) To: Isaac J. Manjarres Cc: Android Kernel Team, Will Deacon, pdaly, linux-arm-msm, Linux Kernel Mailing List, dri-devel, list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>, , Pratik Patel, freedreno, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Robin Murphy On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres <isaacm@codeaurora.org> wrote: > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > format code to work properly. In preparation for having the io-pgtable > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > ensure that the io-pgtable-arm format module is loaded before loading > the MSM DRM driver module. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> Thanks, I've queued this up locally BR, -R > --- > drivers/gpu/drm/msm/msm_drv.c | 1 + > 1 file changed, 1 insertion(+) > > diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c > index 535a026..8be3506 100644 > --- a/drivers/gpu/drm/msm/msm_drv.c > +++ b/drivers/gpu/drm/msm/msm_drv.c > @@ -1369,3 +1369,4 @@ module_exit(msm_drm_unregister); > MODULE_AUTHOR("Rob Clark <robdclark@gmail.com"); > MODULE_DESCRIPTION("MSM DRM Driver"); > MODULE_LICENSE("GPL"); > +MODULE_SOFTDEP("pre: io-pgtable-arm"); > -- > The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, > a Linux Foundation Collaborative Project > > _______________________________________________ > iommu mailing list > iommu@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module @ 2021-01-18 21:16 ` Rob Clark 0 siblings, 0 replies; 73+ messages in thread From: Rob Clark @ 2021-01-18 21:16 UTC (permalink / raw) To: Isaac J. Manjarres Cc: Android Kernel Team, Will Deacon, pdaly, linux-arm-msm, Linux Kernel Mailing List, dri-devel, list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>, , Pratik Patel, freedreno, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Robin Murphy On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres <isaacm@codeaurora.org> wrote: > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > format code to work properly. In preparation for having the io-pgtable > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > ensure that the io-pgtable-arm format module is loaded before loading > the MSM DRM driver module. > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> Thanks, I've queued this up locally BR, -R > --- > drivers/gpu/drm/msm/msm_drv.c | 1 + > 1 file changed, 1 insertion(+) > > diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c > index 535a026..8be3506 100644 > --- a/drivers/gpu/drm/msm/msm_drv.c > +++ b/drivers/gpu/drm/msm/msm_drv.c > @@ -1369,3 +1369,4 @@ module_exit(msm_drm_unregister); > MODULE_AUTHOR("Rob Clark <robdclark@gmail.com"); > MODULE_DESCRIPTION("MSM DRM Driver"); > MODULE_LICENSE("GPL"); > +MODULE_SOFTDEP("pre: io-pgtable-arm"); > -- > The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, > a Linux Foundation Collaborative Project > > _______________________________________________ > iommu mailing list > iommu@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module 2021-01-18 21:16 ` Rob Clark (?) (?) @ 2021-01-18 21:39 ` Will Deacon -1 siblings, 0 replies; 73+ messages in thread From: Will Deacon @ 2021-01-18 21:39 UTC (permalink / raw) To: Rob Clark Cc: Isaac J. Manjarres, list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>,, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Linux Kernel Mailing List, freedreno, dri-devel, linux-arm-msm, pdaly, Android Kernel Team, Robin Murphy, Pratik Patel On Mon, Jan 18, 2021 at 01:16:03PM -0800, Rob Clark wrote: > On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres > <isaacm@codeaurora.org> wrote: > > > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > > format code to work properly. In preparation for having the io-pgtable > > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > > ensure that the io-pgtable-arm format module is loaded before loading > > the MSM DRM driver module. > > > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > > Thanks, I've queued this up locally I don't plan to make the io-pgtable code modular, so please drop this patch. https://lore.kernel.org/r/20210106123428.GA1798@willie-the-truck Will ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module @ 2021-01-18 21:39 ` Will Deacon 0 siblings, 0 replies; 73+ messages in thread From: Will Deacon @ 2021-01-18 21:39 UTC (permalink / raw) To: Rob Clark Cc: Isaac J. Manjarres, Android Kernel Team, pdaly, linux-arm-msm, Linux Kernel Mailing List, dri-devel, list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>, , Pratik Patel, freedreno, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Robin Murphy On Mon, Jan 18, 2021 at 01:16:03PM -0800, Rob Clark wrote: > On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres > <isaacm@codeaurora.org> wrote: > > > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > > format code to work properly. In preparation for having the io-pgtable > > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > > ensure that the io-pgtable-arm format module is loaded before loading > > the MSM DRM driver module. > > > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > > Thanks, I've queued this up locally I don't plan to make the io-pgtable code modular, so please drop this patch. https://lore.kernel.org/r/20210106123428.GA1798@willie-the-truck Will _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module @ 2021-01-18 21:39 ` Will Deacon 0 siblings, 0 replies; 73+ messages in thread From: Will Deacon @ 2021-01-18 21:39 UTC (permalink / raw) To: Rob Clark Cc: Isaac J. Manjarres, Android Kernel Team, pdaly, linux-arm-msm, Linux Kernel Mailing List, dri-devel, list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>, , Pratik Patel, freedreno, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Robin Murphy On Mon, Jan 18, 2021 at 01:16:03PM -0800, Rob Clark wrote: > On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres > <isaacm@codeaurora.org> wrote: > > > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > > format code to work properly. In preparation for having the io-pgtable > > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > > ensure that the io-pgtable-arm format module is loaded before loading > > the MSM DRM driver module. > > > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > > Thanks, I've queued this up locally I don't plan to make the io-pgtable code modular, so please drop this patch. https://lore.kernel.org/r/20210106123428.GA1798@willie-the-truck Will _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module @ 2021-01-18 21:39 ` Will Deacon 0 siblings, 0 replies; 73+ messages in thread From: Will Deacon @ 2021-01-18 21:39 UTC (permalink / raw) To: Rob Clark Cc: Isaac J. Manjarres, Android Kernel Team, pdaly, linux-arm-msm, Linux Kernel Mailing List, dri-devel, list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>, , Pratik Patel, freedreno, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Robin Murphy On Mon, Jan 18, 2021 at 01:16:03PM -0800, Rob Clark wrote: > On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres > <isaacm@codeaurora.org> wrote: > > > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > > format code to work properly. In preparation for having the io-pgtable > > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > > ensure that the io-pgtable-arm format module is loaded before loading > > the MSM DRM driver module. > > > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > > Thanks, I've queued this up locally I don't plan to make the io-pgtable code modular, so please drop this patch. https://lore.kernel.org/r/20210106123428.GA1798@willie-the-truck Will _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module 2021-01-18 21:39 ` Will Deacon (?) (?) @ 2021-01-19 17:19 ` Rob Clark -1 siblings, 0 replies; 73+ messages in thread From: Rob Clark @ 2021-01-19 17:19 UTC (permalink / raw) To: Will Deacon Cc: Isaac J. Manjarres, list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>,, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Linux Kernel Mailing List, freedreno, dri-devel, linux-arm-msm, pdaly, Android Kernel Team, Robin Murphy, Pratik Patel On Mon, Jan 18, 2021 at 1:39 PM Will Deacon <will@kernel.org> wrote: > > On Mon, Jan 18, 2021 at 01:16:03PM -0800, Rob Clark wrote: > > On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres > > <isaacm@codeaurora.org> wrote: > > > > > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > > > format code to work properly. In preparation for having the io-pgtable > > > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > > > ensure that the io-pgtable-arm format module is loaded before loading > > > the MSM DRM driver module. > > > > > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > > > > Thanks, I've queued this up locally > > I don't plan to make the io-pgtable code modular, so please drop this patch. > > https://lore.kernel.org/r/20210106123428.GA1798@willie-the-truck Ok, done. Thanks BR, -R ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module @ 2021-01-19 17:19 ` Rob Clark 0 siblings, 0 replies; 73+ messages in thread From: Rob Clark @ 2021-01-19 17:19 UTC (permalink / raw) To: Will Deacon Cc: Isaac J. Manjarres, Android Kernel Team, pdaly, linux-arm-msm, Linux Kernel Mailing List, dri-devel, list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>, , Pratik Patel, freedreno, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Robin Murphy On Mon, Jan 18, 2021 at 1:39 PM Will Deacon <will@kernel.org> wrote: > > On Mon, Jan 18, 2021 at 01:16:03PM -0800, Rob Clark wrote: > > On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres > > <isaacm@codeaurora.org> wrote: > > > > > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > > > format code to work properly. In preparation for having the io-pgtable > > > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > > > ensure that the io-pgtable-arm format module is loaded before loading > > > the MSM DRM driver module. > > > > > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > > > > Thanks, I've queued this up locally > > I don't plan to make the io-pgtable code modular, so please drop this patch. > > https://lore.kernel.org/r/20210106123428.GA1798@willie-the-truck Ok, done. Thanks BR, -R _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module @ 2021-01-19 17:19 ` Rob Clark 0 siblings, 0 replies; 73+ messages in thread From: Rob Clark @ 2021-01-19 17:19 UTC (permalink / raw) To: Will Deacon Cc: Isaac J. Manjarres, Android Kernel Team, pdaly, linux-arm-msm, Linux Kernel Mailing List, dri-devel, list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>, , Pratik Patel, freedreno, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Robin Murphy On Mon, Jan 18, 2021 at 1:39 PM Will Deacon <will@kernel.org> wrote: > > On Mon, Jan 18, 2021 at 01:16:03PM -0800, Rob Clark wrote: > > On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres > > <isaacm@codeaurora.org> wrote: > > > > > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > > > format code to work properly. In preparation for having the io-pgtable > > > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > > > ensure that the io-pgtable-arm format module is loaded before loading > > > the MSM DRM driver module. > > > > > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > > > > Thanks, I've queued this up locally > > I don't plan to make the io-pgtable code modular, so please drop this patch. > > https://lore.kernel.org/r/20210106123428.GA1798@willie-the-truck Ok, done. Thanks BR, -R _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v2 5/7] drm/msm: Add dependency on io-pgtable-arm format module @ 2021-01-19 17:19 ` Rob Clark 0 siblings, 0 replies; 73+ messages in thread From: Rob Clark @ 2021-01-19 17:19 UTC (permalink / raw) To: Will Deacon Cc: Isaac J. Manjarres, Android Kernel Team, pdaly, linux-arm-msm, Linux Kernel Mailing List, dri-devel, list@263.net:IOMMU DRIVERS <iommu@lists.linux-foundation.org>, Joerg Roedel <joro@8bytes.org>, , Pratik Patel, freedreno, moderated list:ARM/FREESCALE IMX / MXC ARM ARCHITECTURE, Robin Murphy On Mon, Jan 18, 2021 at 1:39 PM Will Deacon <will@kernel.org> wrote: > > On Mon, Jan 18, 2021 at 01:16:03PM -0800, Rob Clark wrote: > > On Mon, Dec 21, 2020 at 4:44 PM Isaac J. Manjarres > > <isaacm@codeaurora.org> wrote: > > > > > > The MSM DRM driver depends on the availability of the ARM LPAE io-pgtable > > > format code to work properly. In preparation for having the io-pgtable > > > formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to > > > ensure that the io-pgtable-arm format module is loaded before loading > > > the MSM DRM driver module. > > > > > > Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> > > > > Thanks, I've queued this up locally > > I don't plan to make the io-pgtable code modular, so please drop this patch. > > https://lore.kernel.org/r/20210106123428.GA1798@willie-the-truck Ok, done. Thanks BR, -R _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v2 6/7] drm/panfrost: Add dependency on io-pgtable-arm format module 2020-12-22 0:44 ` Isaac J. Manjarres (?) @ 2020-12-22 0:44 ` Isaac J. Manjarres -1 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, joro, pdaly, pratikp, kernel-team, robin.murphy The Panfrost DRM driver depends on the availability of the ARM LPAE io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable-arm format module is loaded before loading the Panfrost DRM driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/gpu/drm/panfrost/panfrost_drv.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/gpu/drm/panfrost/panfrost_drv.c b/drivers/gpu/drm/panfrost/panfrost_drv.c index 83a461b..7294622 100644 --- a/drivers/gpu/drm/panfrost/panfrost_drv.c +++ b/drivers/gpu/drm/panfrost/panfrost_drv.c @@ -704,3 +704,4 @@ module_platform_driver(panfrost_driver); MODULE_AUTHOR("Panfrost Project Developers"); MODULE_DESCRIPTION("Panfrost DRM Driver"); MODULE_LICENSE("GPL v2"); +MODULE_SOFTDEP("pre: io-pgtable-arm"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 6/7] drm/panfrost: Add dependency on io-pgtable-arm format module @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, joro, robin.murphy, pratikp The Panfrost DRM driver depends on the availability of the ARM LPAE io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable-arm format module is loaded before loading the Panfrost DRM driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/gpu/drm/panfrost/panfrost_drv.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/gpu/drm/panfrost/panfrost_drv.c b/drivers/gpu/drm/panfrost/panfrost_drv.c index 83a461b..7294622 100644 --- a/drivers/gpu/drm/panfrost/panfrost_drv.c +++ b/drivers/gpu/drm/panfrost/panfrost_drv.c @@ -704,3 +704,4 @@ module_platform_driver(panfrost_driver); MODULE_AUTHOR("Panfrost Project Developers"); MODULE_DESCRIPTION("Panfrost DRM Driver"); MODULE_LICENSE("GPL v2"); +MODULE_SOFTDEP("pre: io-pgtable-arm"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 6/7] drm/panfrost: Add dependency on io-pgtable-arm format module @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, robin.murphy, pratikp The Panfrost DRM driver depends on the availability of the ARM LPAE io-pgtable format code to work properly. In preparation for having the io-pgtable formats as modules, add a "pre" dependency with MODULE_SOFTDEP() to ensure that the io-pgtable-arm format module is loaded before loading the Panfrost DRM driver module. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/gpu/drm/panfrost/panfrost_drv.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/gpu/drm/panfrost/panfrost_drv.c b/drivers/gpu/drm/panfrost/panfrost_drv.c index 83a461b..7294622 100644 --- a/drivers/gpu/drm/panfrost/panfrost_drv.c +++ b/drivers/gpu/drm/panfrost/panfrost_drv.c @@ -704,3 +704,4 @@ module_platform_driver(panfrost_driver); MODULE_AUTHOR("Panfrost Project Developers"); MODULE_DESCRIPTION("Panfrost DRM Driver"); MODULE_LICENSE("GPL v2"); +MODULE_SOFTDEP("pre: io-pgtable-arm"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 7/7] iommu/io-pgtable-arm: Allow building modular io-pgtable fmts 2020-12-22 0:44 ` Isaac J. Manjarres (?) @ 2020-12-22 0:44 ` Isaac J. Manjarres -1 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, joro, pdaly, pratikp, kernel-team, robin.murphy Now that everything is in place for modular io-pgtable formats, allow the ARM LPAE and ARMV7S io-pgtable formats to be built as modules. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/Kconfig | 4 ++-- drivers/iommu/io-pgtable-arm-v7s.c | 2 ++ drivers/iommu/io-pgtable-arm.c | 2 ++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/drivers/iommu/Kconfig b/drivers/iommu/Kconfig index 192ef8f..7e4f44f 100644 --- a/drivers/iommu/Kconfig +++ b/drivers/iommu/Kconfig @@ -30,7 +30,7 @@ config IOMMU_IO_PGTABLE bool config IOMMU_IO_PGTABLE_LPAE - bool "ARMv7/v8 Long Descriptor Format" + tristate "ARMv7/v8 Long Descriptor Format" select IOMMU_IO_PGTABLE depends on ARM || ARM64 || (COMPILE_TEST && !GENERIC_ATOMIC64) help @@ -49,7 +49,7 @@ config IOMMU_IO_PGTABLE_LPAE_SELFTEST If unsure, say N here. config IOMMU_IO_PGTABLE_ARMV7S - bool "ARMv7/v8 Short Descriptor Format" + tristate "ARMv7/v8 Short Descriptor Format" select IOMMU_IO_PGTABLE depends on ARM || ARM64 || COMPILE_TEST help diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c index a5cb755a..9d9f08f 100644 --- a/drivers/iommu/io-pgtable-arm-v7s.c +++ b/drivers/iommu/io-pgtable-arm-v7s.c @@ -1015,3 +1015,5 @@ static void __exit arm_v7s_exit(void) io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); } module_exit(arm_v7s_exit); + +MODULE_LICENSE("GPL v2"); diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c index e8b1e34..e0de4ad 100644 --- a/drivers/iommu/io-pgtable-arm.c +++ b/drivers/iommu/io-pgtable-arm.c @@ -1299,3 +1299,5 @@ static void __exit arm_lpae_exit(void) io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); } module_exit(arm_lpae_exit); + +MODULE_LICENSE("GPL v2"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 7/7] iommu/io-pgtable-arm: Allow building modular io-pgtable fmts @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, joro, robin.murphy, pratikp Now that everything is in place for modular io-pgtable formats, allow the ARM LPAE and ARMV7S io-pgtable formats to be built as modules. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/Kconfig | 4 ++-- drivers/iommu/io-pgtable-arm-v7s.c | 2 ++ drivers/iommu/io-pgtable-arm.c | 2 ++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/drivers/iommu/Kconfig b/drivers/iommu/Kconfig index 192ef8f..7e4f44f 100644 --- a/drivers/iommu/Kconfig +++ b/drivers/iommu/Kconfig @@ -30,7 +30,7 @@ config IOMMU_IO_PGTABLE bool config IOMMU_IO_PGTABLE_LPAE - bool "ARMv7/v8 Long Descriptor Format" + tristate "ARMv7/v8 Long Descriptor Format" select IOMMU_IO_PGTABLE depends on ARM || ARM64 || (COMPILE_TEST && !GENERIC_ATOMIC64) help @@ -49,7 +49,7 @@ config IOMMU_IO_PGTABLE_LPAE_SELFTEST If unsure, say N here. config IOMMU_IO_PGTABLE_ARMV7S - bool "ARMv7/v8 Short Descriptor Format" + tristate "ARMv7/v8 Short Descriptor Format" select IOMMU_IO_PGTABLE depends on ARM || ARM64 || COMPILE_TEST help diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c index a5cb755a..9d9f08f 100644 --- a/drivers/iommu/io-pgtable-arm-v7s.c +++ b/drivers/iommu/io-pgtable-arm-v7s.c @@ -1015,3 +1015,5 @@ static void __exit arm_v7s_exit(void) io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); } module_exit(arm_v7s_exit); + +MODULE_LICENSE("GPL v2"); diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c index e8b1e34..e0de4ad 100644 --- a/drivers/iommu/io-pgtable-arm.c +++ b/drivers/iommu/io-pgtable-arm.c @@ -1299,3 +1299,5 @@ static void __exit arm_lpae_exit(void) io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); } module_exit(arm_lpae_exit); + +MODULE_LICENSE("GPL v2"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel ^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v2 7/7] iommu/io-pgtable-arm: Allow building modular io-pgtable fmts @ 2020-12-22 0:44 ` Isaac J. Manjarres 0 siblings, 0 replies; 73+ messages in thread From: Isaac J. Manjarres @ 2020-12-22 0:44 UTC (permalink / raw) To: iommu, linux-arm-kernel, linux-kernel, freedreno, dri-devel, linux-arm-msm Cc: Isaac J. Manjarres, will, pdaly, kernel-team, robin.murphy, pratikp Now that everything is in place for modular io-pgtable formats, allow the ARM LPAE and ARMV7S io-pgtable formats to be built as modules. Signed-off-by: Isaac J. Manjarres <isaacm@codeaurora.org> --- drivers/iommu/Kconfig | 4 ++-- drivers/iommu/io-pgtable-arm-v7s.c | 2 ++ drivers/iommu/io-pgtable-arm.c | 2 ++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/drivers/iommu/Kconfig b/drivers/iommu/Kconfig index 192ef8f..7e4f44f 100644 --- a/drivers/iommu/Kconfig +++ b/drivers/iommu/Kconfig @@ -30,7 +30,7 @@ config IOMMU_IO_PGTABLE bool config IOMMU_IO_PGTABLE_LPAE - bool "ARMv7/v8 Long Descriptor Format" + tristate "ARMv7/v8 Long Descriptor Format" select IOMMU_IO_PGTABLE depends on ARM || ARM64 || (COMPILE_TEST && !GENERIC_ATOMIC64) help @@ -49,7 +49,7 @@ config IOMMU_IO_PGTABLE_LPAE_SELFTEST If unsure, say N here. config IOMMU_IO_PGTABLE_ARMV7S - bool "ARMv7/v8 Short Descriptor Format" + tristate "ARMv7/v8 Short Descriptor Format" select IOMMU_IO_PGTABLE depends on ARM || ARM64 || COMPILE_TEST help diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c index a5cb755a..9d9f08f 100644 --- a/drivers/iommu/io-pgtable-arm-v7s.c +++ b/drivers/iommu/io-pgtable-arm-v7s.c @@ -1015,3 +1015,5 @@ static void __exit arm_v7s_exit(void) io_pgtable_ops_unregister(&io_pgtable_arm_v7s_init_fns); } module_exit(arm_v7s_exit); + +MODULE_LICENSE("GPL v2"); diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c index e8b1e34..e0de4ad 100644 --- a/drivers/iommu/io-pgtable-arm.c +++ b/drivers/iommu/io-pgtable-arm.c @@ -1299,3 +1299,5 @@ static void __exit arm_lpae_exit(void) io_pgtable_ops_unregister(&io_pgtable_arm_lpae_init_fns[i]); } module_exit(arm_lpae_exit); + +MODULE_LICENSE("GPL v2"); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu ^ permalink raw reply related [flat|nested] 73+ messages in thread
end of thread, other threads:[~2021-01-20 0:02 UTC | newest] Thread overview: 73+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2020-12-22 0:44 [RFC PATCH v2 0/7] iommu: Permit modular builds of io-pgtable drivers Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` [PATCH v2 1/7] iommu/io-pgtable: Introduce dynamic io-pgtable fmt registration Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 19:27 ` Robin Murphy 2020-12-22 19:27 ` Robin Murphy 2020-12-22 19:27 ` Robin Murphy 2020-12-22 19:27 ` Robin Murphy 2020-12-22 19:54 ` isaacm 2020-12-22 19:54 ` isaacm 2020-12-22 19:54 ` isaacm 2020-12-23 13:44 ` Robin Murphy 2020-12-23 13:44 ` Robin Murphy 2020-12-23 13:44 ` Robin Murphy 2020-12-23 13:44 ` Robin Murphy 2020-12-23 15:14 ` isaacm 2020-12-23 15:14 ` isaacm 2020-12-23 15:14 ` isaacm 2020-12-23 15:38 ` Georgi Djakov 2020-12-23 15:38 ` Georgi Djakov 2020-12-23 15:38 ` Georgi Djakov 2020-12-23 15:38 ` Georgi Djakov 2020-12-23 19:17 ` kernel test robot 2020-12-23 19:17 ` kernel test robot 2020-12-23 19:17 ` kernel test robot 2020-12-23 19:17 ` kernel test robot 2020-12-23 19:17 ` kernel test robot 2020-12-22 0:44 ` [PATCH v2 2/7] iommu/io-pgtable: Add refcounting for io-pgtable format modules Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` [PATCH v2 3/7] iommu/arm-smmu: Add dependency on " Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 19:27 ` Robin Murphy 2020-12-22 19:27 ` Robin Murphy 2020-12-22 19:27 ` Robin Murphy 2020-12-22 19:27 ` Robin Murphy 2020-12-22 19:49 ` isaacm 2020-12-22 19:49 ` isaacm 2020-12-22 19:49 ` isaacm 2020-12-23 13:05 ` Robin Murphy 2020-12-23 13:05 ` Robin Murphy 2020-12-23 13:05 ` Robin Murphy 2020-12-23 13:05 ` Robin Murphy 2020-12-23 15:10 ` isaacm 2020-12-23 15:10 ` isaacm 2020-12-23 15:10 ` isaacm 2020-12-22 0:44 ` [PATCH v2 4/7] iommu/arm-smmu-v3: Add dependency on io-pgtable-arm format module Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` [PATCH v2 5/7] drm/msm: " Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2021-01-18 21:16 ` Rob Clark 2021-01-18 21:16 ` Rob Clark 2021-01-18 21:16 ` Rob Clark 2021-01-18 21:16 ` Rob Clark 2021-01-18 21:39 ` Will Deacon 2021-01-18 21:39 ` Will Deacon 2021-01-18 21:39 ` Will Deacon 2021-01-18 21:39 ` Will Deacon 2021-01-19 17:19 ` Rob Clark 2021-01-19 17:19 ` Rob Clark 2021-01-19 17:19 ` Rob Clark 2021-01-19 17:19 ` Rob Clark 2020-12-22 0:44 ` [PATCH v2 6/7] drm/panfrost: " Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` [PATCH v2 7/7] iommu/io-pgtable-arm: Allow building modular io-pgtable fmts Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres 2020-12-22 0:44 ` Isaac J. Manjarres
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.