swiotlb-xen cleanups v4
Subsystems (8)
Hi Xen maintainers and friends,
please take a look at this series that cleans up the parts of swiotlb-xen that deal with non-coherent caches.
Changes since v3:
- don't use dma_direct_alloc on x86
Changes since v2:
- further dma_cache_maint improvements
- split the previous patch 1 into 3 patches
Changes since v1:
- rewrite dma_cache_maint to be much simpler
- improve various comments and commit logs
- remove page-coherent.h entirely
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
PATCH 1/11 xen/arm: use dma-noncoherent.h calls for xen-swiotlb cache maintainance
Copy the arm64 code that uses the dma-direct/swiotlb helpers for DMA on-coherent devices.
--- arch/arm/include/asm/device.h | 3 - arch/arm/include/asm/xen/page-coherent.h | 72 +++++++++--------------- arch/arm/mm/dma-mapping.c | 8 +-- drivers/xen/swiotlb-xen.c | 20 ------- 4 files changed, 28 insertions(+), 75 deletions(-)
arch/arm/include/asm/device.h +0 -3
@@ -14,9 +14,6 @@ struct dev_archdata {#endif #ifdef CONFIG_ARM_DMA_USE_IOMMU struct dma_iommu_mapping *mapping; -#endif -#ifdef CONFIG_XEN -const struct dma_map_ops *dev_dma_ops;#endif unsigned int dma_coherent:1; unsigned int dma_ops_setup:1;
arch/arm/include/asm/xen/page-coherent.h +27 -45
100 lines not on this page · raw message
arch/arm/mm/dma-mapping.c +1 -7
@@ -1132,10 +1132,6 @@ static const struct dma_map_ops *arm_get_dma_map_ops(bool coherent)* 32-bit DMA. * Use the generic dma-direct / swiotlb ops code in that case, as that * handles bounce buffering for us. -* -* Note: this checks CONFIG_ARM_LPAE instead of CONFIG_SWIOTLB as the -* latter is also selected by the Xen code, but that code for now relies -* on non-NULL dev_dma_ops. To be cleaned up later. */ if (IS_ENABLED (CONFIG_ARM_LPAE ))return NULL ;
@@ -2363,10 +2359,8 @@ void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size,set_dma_ops (dev, dma_ops);#ifdef CONFIG_XEN -if (xen_initial_domain ()) { - dev->archdata.dev_dma_ops = dev->dma_ops; +if (xen_initial_domain ()) dev->dma_ops = xen_dma_ops; - }#endif dev->archdata.dma_ops_setup = true; }
drivers/xen/swiotlb-xen.c +0 -20
@@ -557,11 +557,6 @@ xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma, void *cpu_addr, dma_addr_t dma_addr, size_t size, unsigned long attrs) { -#ifdef CONFIG_ARM - if (xen_get_dma_ops(dev)->mmap) - return xen_get_dma_ops(dev)->mmap(dev, vma, cpu_addr, - dma_addr, size, attrs); -#endif return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size, attrs); }
@@ -574,21 +569,6 @@ xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr, dma_addr_t handle, size_t size, unsigned long attrs) { -#ifdef CONFIG_ARM - if (xen_get_dma_ops(dev)->get_sgtable) { -#if 0 -/* -* This check verifies that the page belongs to the current domain and -* is not one mapped from another domain. -* This check is for debug only, and should not go to production build -*/ -unsigned long bfn =PHYS_PFN (dma_to_phys (dev, handle)); -BUG_ON (!page_is_ram (bfn)); -#endif -return xen_get_dma_ops (dev)->get_sgtable (dev, sgt, cpu_addr, - handle, size, attrs); - } -#endif return dma_common_get_sgtable(dev, sgt, cpu_addr, handle, size, attrs); }
Signature · 6 lines
2.20.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [PATCH 01/11] xen/arm: use dma-noncoherent.h calls for xen-swiotlb cache maintainance
Quoted 4 lines · Christoph Hellwig
Copy the arm64 code that uses the dma-direct/swiotlb helpers for DMA on-coherent devices.
Signed-off-by Christoph Hellwig <[email protected]>
This is much better and much more readable.
Quoted 196 lines
--- arch/arm/include/asm/device.h | 3 - arch/arm/include/asm/xen/page-coherent.h | 72 +++++++++--------------- arch/arm/mm/dma-mapping.c | 8 +-- drivers/xen/swiotlb-xen.c | 20 ------- 4 files changed, 28 insertions(+), 75 deletions(-)arch/arm/include/asm/device.h +0
-3@@ -14,9 +14,6 @@ struct dev_archdata {#endif #ifdef CONFIG_ARM_DMA_USE_IOMMU struct dma_iommu_mapping *mapping; -#endif -#ifdef CONFIG_XEN -const struct dma_map_ops *dev_dma_ops;#endif unsigned int dma_coherent:1; unsigned int dma_ops_setup:1;arch/arm/include/asm/xen/page-coherent.h +27
-45@@ -6,23 +6,37 @@#include <asm/page.h> #include <xen/arm/page-coherent.h> -static inline const struct dma_map_ops *xen_get_dma_ops (struct device *dev) -{ -if (dev && dev->archdata.dev_dma_ops) -return dev->archdata.dev_dma_ops; -return get_arch_dma_ops (NULL ); -} -static inline void *xen_alloc_coherent_pages (struct device *hwdev,size_t size,dma_addr_t *dma_handle,gfp_t flags,unsigned long attrs) { -return xen_get_dma_ops (hwdev)->alloc (hwdev, size, dma_handle, flags, attrs); +return dma_direct_alloc (hwdev, size, dma_handle, flags, attrs); }static inline void xen_free_coherent_pages (struct device *hwdev,size_t size,void *cpu_addr,dma_addr_t dma_handle,unsigned long attrs) { -xen_get_dma_ops (hwdev)->free (hwdev, size, cpu_addr, dma_handle, attrs); +dma_direct_free (hwdev, size, cpu_addr, dma_handle, attrs); +} + +static inline void xen_dma_sync_single_for_cpu (struct device *hwdev, +dma_addr_t handle,size_t size,enum dma_data_direction dir) +{ +unsigned long pfn =PFN_DOWN (handle); + +if (pfn_valid (pfn)) +dma_direct_sync_single_for_cpu (hwdev, handle, size, dir); +else +__xen_dma_sync_single_for_cpu (hwdev, handle, size, dir); +} + +static inline void xen_dma_sync_single_for_device (struct device *hwdev, +dma_addr_t handle,size_t size,enum dma_data_direction dir) +{ +unsigned long pfn =PFN_DOWN (handle); +if (pfn_valid (pfn)) +dma_direct_sync_single_for_device (hwdev, handle, size, dir); +else +__xen_dma_sync_single_for_device (hwdev, handle, size, dir); } static inline void xen_dma_map_page(struct device *hwdev, struct page *page,@@ -36,17 +50,8 @@ static inline void xen_dma_map_page(struct device *hwdev, struct page *page,bool local = (page_pfn <= dev_pfn) && (dev_pfn - page_pfn < compound_pages); -/* -* Dom0 is mapped 1:1, while the Linux page can span across -* multiple Xen pages, it's not possible for it to contain a -* mix of local and foreign Xen pages. So if the first xen_pfn -* == mfn the page is local otherwise it's a foreign page -* grant-mapped in dom0. If the page is local we can safely -* call the native dma_ops function, otherwise we call the xen -* specific function. -*/ if (local) -xen_get_dma_ops (hwdev)->map_page (hwdev, page, offset, size, dir, attrs); +dma_direct_map_page (hwdev, page, offset, size, dir, attrs);else __xen_dma_map_page (hwdev, page, dev_addr, offset, size, dir, attrs); }@@ -63,33 +68,10 @@ static inline void xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle,* safely call the native dma_ops function, otherwise we call the xen * specific function. */ -if (pfn_valid (pfn)) { -if (xen_get_dma_ops (hwdev)->unmap_page) -xen_get_dma_ops (hwdev)->unmap_page (hwdev, handle, size, dir, attrs); - }else +if (pfn_valid (pfn)) +dma_direct_unmap_page (hwdev, handle, size, dir, attrs); +else __xen_dma_unmap_page(hwdev, handle, size, dir, attrs); } -static inline void xen_dma_sync_single_for_cpu (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) -{ -unsigned long pfn =PFN_DOWN (handle); -if (pfn_valid (pfn)) { -if (xen_get_dma_ops (hwdev)->sync_single_for_cpu) -xen_get_dma_ops (hwdev)->sync_single_for_cpu (hwdev, handle, size, dir); - }else -__xen_dma_sync_single_for_cpu (hwdev, handle, size, dir); -} - -static inline void xen_dma_sync_single_for_device (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) -{ -unsigned long pfn =PFN_DOWN (handle); -if (pfn_valid (pfn)) { -if (xen_get_dma_ops (hwdev)->sync_single_for_device) -xen_get_dma_ops (hwdev)->sync_single_for_device (hwdev, handle, size, dir); - }else -__xen_dma_sync_single_for_device (hwdev, handle, size, dir); -} -#endif /* _ASM_ARM_XEN_PAGE_COHERENT_H */ arch/arm/mm/dma-mapping.c +1
-7@@ -1132,10 +1132,6 @@ static const struct dma_map_ops *arm_get_dma_map_ops(bool coherent)* 32-bit DMA. * Use the generic dma-direct / swiotlb ops code in that case, as that * handles bounce buffering for us. -* -* Note: this checks CONFIG_ARM_LPAE instead of CONFIG_SWIOTLB as the -* latter is also selected by the Xen code, but that code for now relies -* on non-NULL dev_dma_ops. To be cleaned up later. */ if (IS_ENABLED (CONFIG_ARM_LPAE ))return NULL ;@@ -2363,10 +2359,8 @@ void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size,set_dma_ops (dev, dma_ops);#ifdef CONFIG_XEN -if (xen_initial_domain ()) { - dev->archdata.dev_dma_ops = dev->dma_ops; +if (xen_initial_domain ()) dev->dma_ops = xen_dma_ops; - }#endif dev->archdata.dma_ops_setup = true; }drivers/xen/swiotlb-xen.c +0
-20@@ -557,11 +557,6 @@ xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma, void *cpu_addr, dma_addr_t dma_addr, size_t size, unsigned long attrs) { -#ifdef CONFIG_ARM - if (xen_get_dma_ops(dev)->mmap) - return xen_get_dma_ops(dev)->mmap(dev, vma, cpu_addr, - dma_addr, size, attrs); -#endif return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size, attrs); }@@ -574,21 +569,6 @@ xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr, dma_addr_t handle, size_t size, unsigned long attrs) { -#ifdef CONFIG_ARM - if (xen_get_dma_ops(dev)->get_sgtable) { -#if 0 -/* -* This check verifies that the page belongs to the current domain and -* is not one mapped from another domain. -* This check is for debug only, and should not go to production build -*/ -unsigned long bfn =PHYS_PFN (dma_to_phys (dev, handle)); -BUG_ON (!page_is_ram (bfn)); -#endif -return xen_get_dma_ops (dev)->get_sgtable (dev, sgt, cpu_addr, - handle, size, attrs); - } -#endif return dma_common_get_sgtable(dev, sgt, cpu_addr, handle, size, attrs); }Signature · 1 line
2.20.1
PATCH 2/11 xen/arm: consolidate page-coherent.h
In reply to Christoph HellwigShared the duplicate arm/arm64 code in include/xen/arm/page-coherent.h.
--- arch/arm/include/asm/xen/page-coherent.h | 75 -------------------- arch/arm64/include/asm/xen/page-coherent.h | 75 -------------------- include/xen/arm/page-coherent.h | 80 ++++++++++++++++++++++ 3 files changed, 80 insertions(+), 150 deletions(-)
arch/arm/include/asm/xen/page-coherent.h +0 -75
@@ -1,77 +1,2 @@/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef _ASM_ARM_XEN_PAGE_COHERENT_H -#define _ASM_ARM_XEN_PAGE_COHERENT_H - -#include <linux/dma-mapping.h> -#include <asm/page.h> #include <xen/arm/page-coherent.h> - -static inline void *xen_alloc_coherent_pages (struct device *hwdev,size_t size, -dma_addr_t *dma_handle,gfp_t flags,unsigned long attrs) -{ -return dma_direct_alloc (hwdev, size, dma_handle, flags, attrs); -} - -static inline void xen_free_coherent_pages (struct device *hwdev,size_t size, -void *cpu_addr,dma_addr_t dma_handle,unsigned long attrs) -{ -dma_direct_free (hwdev, size, cpu_addr, dma_handle, attrs); -} - -static inline void xen_dma_sync_single_for_cpu (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) -{ -unsigned long pfn =PFN_DOWN (handle); - -if (pfn_valid (pfn)) -dma_direct_sync_single_for_cpu (hwdev, handle, size, dir); -else -__xen_dma_sync_single_for_cpu (hwdev, handle, size, dir); -} - -static inline void xen_dma_sync_single_for_device (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) -{ -unsigned long pfn =PFN_DOWN (handle); -if (pfn_valid (pfn)) -dma_direct_sync_single_for_device (hwdev, handle, size, dir); -else -__xen_dma_sync_single_for_device (hwdev, handle, size, dir); -} - -static inline void xen_dma_map_page (struct device *hwdev,struct page *page, -dma_addr_t dev_addr,unsigned long offset,size_t size, -enum dma_data_direction dir,unsigned long attrs) -{ -unsigned long page_pfn =page_to_xen_pfn (page); -unsigned long dev_pfn =XEN_PFN_DOWN (dev_addr); -unsigned long compound_pages = - (1 <<compound_order (page)) *XEN_PFN_PER_PAGE ; -bool local = (page_pfn <= dev_pfn) && - (dev_pfn - page_pfn < compound_pages); - -if (local) -dma_direct_map_page (hwdev, page, offset, size, dir, attrs); -else -__xen_dma_map_page (hwdev, page, dev_addr, offset, size, dir, attrs); -} - -static inline void xen_dma_unmap_page (struct device *hwdev,dma_addr_t handle, -size_t size,enum dma_data_direction dir,unsigned long attrs) -{ -unsigned long pfn =PFN_DOWN (handle); -/* -* Dom0 is mapped 1:1, while the Linux page can be spanned accross -* multiple Xen page, it's not possible to have a mix of local and -* foreign Xen page. Dom0 is mapped 1:1, so calling pfn_valid on a -* foreign mfn will always return false. If the page is local we can -* safely call the native dma_ops function, otherwise we call the xen -* specific function. -*/ -if (pfn_valid (pfn)) -dma_direct_unmap_page (hwdev, handle, size, dir, attrs); -else -__xen_dma_unmap_page (hwdev, handle, size, dir, attrs); -} - -#endif /* _ASM_ARM_XEN_PAGE_COHERENT_H */
arch/arm64/include/asm/xen/page-coherent.h +0 -75
77 lines not on this page · raw message
include/xen/arm/page-coherent.h +80 -0
90 lines not on this page · raw message
Signature · 1 line
2.20.1
Re: [PATCH 02/11] xen/arm: consolidate page-coherent.h
Quoted 3 lines · Christoph Hellwig
Shared the duplicate arm/arm64 code in
include/xen/arm/page-coherent.h.Signed-off-by Christoph Hellwig <[email protected]>
Quoted 269 lines
--- arch/arm/include/asm/xen/page-coherent.h | 75 -------------------- arch/arm64/include/asm/xen/page-coherent.h | 75 -------------------- include/xen/arm/page-coherent.h | 80 ++++++++++++++++++++++ 3 files changed, 80 insertions(+), 150 deletions(-)arch/arm/include/asm/xen/page-coherent.h +0
-75@@ -1,77 +1,2 @@/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef _ASM_ARM_XEN_PAGE_COHERENT_H -#define _ASM_ARM_XEN_PAGE_COHERENT_H - -#include <linux/dma-mapping.h> -#include <asm/page.h> #include <xen/arm/page-coherent.h> - -static inline void *xen_alloc_coherent_pages (struct device *hwdev,size_t size, -dma_addr_t *dma_handle,gfp_t flags,unsigned long attrs) -{ -return dma_direct_alloc (hwdev, size, dma_handle, flags, attrs); -} - -static inline void xen_free_coherent_pages (struct device *hwdev,size_t size, -void *cpu_addr,dma_addr_t dma_handle,unsigned long attrs) -{ -dma_direct_free (hwdev, size, cpu_addr, dma_handle, attrs); -} - -static inline void xen_dma_sync_single_for_cpu (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) -{ -unsigned long pfn =PFN_DOWN (handle); - -if (pfn_valid (pfn)) -dma_direct_sync_single_for_cpu (hwdev, handle, size, dir); -else -__xen_dma_sync_single_for_cpu (hwdev, handle, size, dir); -} - -static inline void xen_dma_sync_single_for_device (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) -{ -unsigned long pfn =PFN_DOWN (handle); -if (pfn_valid (pfn)) -dma_direct_sync_single_for_device (hwdev, handle, size, dir); -else -__xen_dma_sync_single_for_device (hwdev, handle, size, dir); -} - -static inline void xen_dma_map_page (struct device *hwdev,struct page *page, -dma_addr_t dev_addr,unsigned long offset,size_t size, -enum dma_data_direction dir,unsigned long attrs) -{ -unsigned long page_pfn =page_to_xen_pfn (page); -unsigned long dev_pfn =XEN_PFN_DOWN (dev_addr); -unsigned long compound_pages = - (1 <<compound_order (page)) *XEN_PFN_PER_PAGE ; -bool local = (page_pfn <= dev_pfn) && - (dev_pfn - page_pfn < compound_pages); - -if (local) -dma_direct_map_page (hwdev, page, offset, size, dir, attrs); -else -__xen_dma_map_page (hwdev, page, dev_addr, offset, size, dir, attrs); -} - -static inline void xen_dma_unmap_page (struct device *hwdev,dma_addr_t handle, -size_t size,enum dma_data_direction dir,unsigned long attrs) -{ -unsigned long pfn =PFN_DOWN (handle); -/* -* Dom0 is mapped 1:1, while the Linux page can be spanned accross -* multiple Xen page, it's not possible to have a mix of local and -* foreign Xen page. Dom0 is mapped 1:1, so calling pfn_valid on a -* foreign mfn will always return false. If the page is local we can -* safely call the native dma_ops function, otherwise we call the xen -* specific function. -*/ -if (pfn_valid (pfn)) -dma_direct_unmap_page (hwdev, handle, size, dir, attrs); -else -__xen_dma_unmap_page (hwdev, handle, size, dir, attrs); -} - -#endif /* _ASM_ARM_XEN_PAGE_COHERENT_H */ arch/arm64/include/asm/xen/page-coherent.h +0
-75@@ -1,77 +1,2 @@/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef _ASM_ARM64_XEN_PAGE_COHERENT_H -#define _ASM_ARM64_XEN_PAGE_COHERENT_H - -#include <linux/dma-mapping.h> -#include <asm/page.h> #include <xen/arm/page-coherent.h> - -static inline void *xen_alloc_coherent_pages (struct device *hwdev,size_t size, -dma_addr_t *dma_handle,gfp_t flags,unsigned long attrs) -{ -return dma_direct_alloc (hwdev, size, dma_handle, flags, attrs); -} - -static inline void xen_free_coherent_pages (struct device *hwdev,size_t size, -void *cpu_addr,dma_addr_t dma_handle,unsigned long attrs) -{ -dma_direct_free (hwdev, size, cpu_addr, dma_handle, attrs); -} - -static inline void xen_dma_sync_single_for_cpu (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) -{ -unsigned long pfn =PFN_DOWN (handle); - -if (pfn_valid (pfn)) -dma_direct_sync_single_for_cpu (hwdev, handle, size, dir); -else -__xen_dma_sync_single_for_cpu (hwdev, handle, size, dir); -} - -static inline void xen_dma_sync_single_for_device (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) -{ -unsigned long pfn =PFN_DOWN (handle); -if (pfn_valid (pfn)) -dma_direct_sync_single_for_device (hwdev, handle, size, dir); -else -__xen_dma_sync_single_for_device (hwdev, handle, size, dir); -} - -static inline void xen_dma_map_page (struct device *hwdev,struct page *page, -dma_addr_t dev_addr,unsigned long offset,size_t size, -enum dma_data_direction dir,unsigned long attrs) -{ -unsigned long page_pfn =page_to_xen_pfn (page); -unsigned long dev_pfn =XEN_PFN_DOWN (dev_addr); -unsigned long compound_pages = - (1 <<compound_order (page)) *XEN_PFN_PER_PAGE ; -bool local = (page_pfn <= dev_pfn) && - (dev_pfn - page_pfn < compound_pages); - -if (local) -dma_direct_map_page (hwdev, page, offset, size, dir, attrs); -else -__xen_dma_map_page (hwdev, page, dev_addr, offset, size, dir, attrs); -} - -static inline void xen_dma_unmap_page (struct device *hwdev,dma_addr_t handle, -size_t size,enum dma_data_direction dir,unsigned long attrs) -{ -unsigned long pfn =PFN_DOWN (handle); -/* -* Dom0 is mapped 1:1, while the Linux page can be spanned accross -* multiple Xen page, it's not possible to have a mix of local and -* foreign Xen page. Dom0 is mapped 1:1, so calling pfn_valid on a -* foreign mfn will always return false. If the page is local we can -* safely call the native dma_ops function, otherwise we call the xen -* specific function. -*/ -if (pfn_valid (pfn)) -dma_direct_unmap_page (hwdev, handle, size, dir, attrs); -else -__xen_dma_unmap_page (hwdev, handle, size, dir, attrs); -} - -#endif /* _ASM_ARM64_XEN_PAGE_COHERENT_H */ include/xen/arm/page-coherent.h +80
-0@@ -2,6 +2,9 @@#ifndef _XEN_ARM_PAGE_COHERENT_H#define _XEN_ARM_PAGE_COHERENT_H +#include <linux/dma-mapping.h> +#include <asm/page.h> +void __xen_dma_map_page (struct device *hwdev,struct page *page,dma_addr_t dev_addr,unsigned long offset,size_t size,enum dma_data_direction dir,unsigned long attrs);@@ -13,4 +16,81 @@ void __xen_dma_sync_single_for_cpu(struct device *hwdev,void __xen_dma_sync_single_for_device (struct device *hwdev,dma_addr_t handle,size_t size,enum dma_data_direction dir); +static inline void *xen_alloc_coherent_pages (struct device *hwdev,size_t size, +dma_addr_t *dma_handle,gfp_t flags,unsigned long attrs) +{ +return dma_direct_alloc (hwdev, size, dma_handle, flags, attrs); +} + +static inline void xen_free_coherent_pages (struct device *hwdev,size_t size, +void *cpu_addr,dma_addr_t dma_handle,unsigned long attrs) +{ +dma_direct_free (hwdev, size, cpu_addr, dma_handle, attrs); +} + +static inline void xen_dma_sync_single_for_cpu (struct device *hwdev, +dma_addr_t handle,size_t size,enum dma_data_direction dir) +{ +unsigned long pfn =PFN_DOWN (handle); + +if (pfn_valid (pfn)) +dma_direct_sync_single_for_cpu (hwdev, handle, size, dir); +else +__xen_dma_sync_single_for_cpu (hwdev, handle, size, dir); +} + +static inline void xen_dma_sync_single_for_device (struct device *hwdev, +dma_addr_t handle,size_t size,enum dma_data_direction dir) +{ +unsigned long pfn =PFN_DOWN (handle); +if (pfn_valid (pfn)) +dma_direct_sync_single_for_device (hwdev, handle, size, dir); +else +__xen_dma_sync_single_for_device (hwdev, handle, size, dir); +} + +static inline void xen_dma_map_page (struct device *hwdev,struct page *page, +dma_addr_t dev_addr,unsigned long offset,size_t size, +enum dma_data_direction dir,unsigned long attrs) +{ +unsigned long page_pfn =page_to_xen_pfn (page); +unsigned long dev_pfn =XEN_PFN_DOWN (dev_addr); +unsigned long compound_pages = + (1 <<compound_order (page)) *XEN_PFN_PER_PAGE ; +bool local = (page_pfn <= dev_pfn) && + (dev_pfn - page_pfn < compound_pages); + +/* +* Dom0 is mapped 1:1, while the Linux page can span across +* multiple Xen pages, it's not possible for it to contain a +* mix of local and foreign Xen pages. So if the first xen_pfn +* == mfn the page is local otherwise it's a foreign page +* grant-mapped in dom0. If the page is local we can safely +* call the native dma_ops function, otherwise we call the xen +* specific function. +*/ +if (local) +dma_direct_map_page (hwdev, page, offset, size, dir, attrs); +else +__xen_dma_map_page (hwdev, page, dev_addr, offset, size, dir, attrs); +} + +static inline void xen_dma_unmap_page (struct device *hwdev,dma_addr_t handle, +size_t size,enum dma_data_direction dir,unsigned long attrs) +{ +unsigned long pfn =PFN_DOWN (handle); +/* +* Dom0 is mapped 1:1, while the Linux page can be spanned accross +* multiple Xen page, it's not possible to have a mix of local and +* foreign Xen page. Dom0 is mapped 1:1, so calling pfn_valid on a +* foreign mfn will always return false. If the page is local we can +* safely call the native dma_ops function, otherwise we call the xen +* specific function. +*/ +if (pfn_valid (pfn)) +dma_direct_unmap_page (hwdev, handle, size, dir, attrs); +else +__xen_dma_unmap_page (hwdev, handle, size, dir, attrs); +} +#endif /* _XEN_ARM_PAGE_COHERENT_H */ Signature · 1 line
2.20.1
PATCH 3/11 xen/arm: use dev_is_dma_coherent
In reply to Christoph HellwigUse the dma-noncoherent dev_is_dma_coherent helper instead of the home grown variant. Note that both are always initialized to the same value in arch_setup_dma_ops.
--- arch/arm/include/asm/dma-mapping.h | 6 ------ arch/arm/xen/mm.c | 12 ++++++------ arch/arm64/include/asm/dma-mapping.h | 9 --------- 3 files changed, 6 insertions(+), 21 deletions(-)
arch/arm/include/asm/dma-mapping.h +0 -6
@@ -91,12 +91,6 @@ static inline dma_addr_t virt_to_dma(struct device *dev, void *addr) }#endif -/* do not use this function in a driver */ -static inline bool is_device_dma_coherent (struct device *dev) -{ -return dev->archdata.dma_coherent; -} -/** * arm_dma_alloc - allocate consistent memory for DMA * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
arch/arm/xen/mm.c +6 -6
@@ -1,6 +1,6 @@// SPDX-License-Identifier: GPL-2.0-only #include <linux/cpu.h> -#include <linux/dma-mapping.h> +#include <linux/dma-noncoherent.h> #include <linux/gfp.h> #include <linux/highmem.h> #include <linux/export.h>
@@ -99,7 +99,7 @@ void __xen_dma_map_page(struct device *hwdev, struct page *page, dma_addr_t dev_addr, unsigned long offset, size_t size, enum dma_data_direction dir, unsigned long attrs) { - if (is_device_dma_coherent(hwdev)) + if (dev_is_dma_coherent(hwdev)) return;if (attrs &DMA_ATTR_SKIP_CPU_SYNC )return ;
@@ -112,7 +112,7 @@ void __xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle, unsigned long attrs) { -if (is_device_dma_coherent (hwdev)) +if (dev_is_dma_coherent (hwdev))return ;if (attrs &DMA_ATTR_SKIP_CPU_SYNC )return ;
@@ -123,7 +123,7 @@ void __xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle,void __xen_dma_sync_single_for_cpu (struct device *hwdev,dma_addr_t handle,size_t size,enum dma_data_direction dir) { -if (is_device_dma_coherent (hwdev)) +if (dev_is_dma_coherent (hwdev))return ;__xen_dma_page_dev_to_cpu (hwdev, handle, size, dir); }
@@ -131,7 +131,7 @@ void __xen_dma_sync_single_for_cpu(struct device *hwdev,void __xen_dma_sync_single_for_device (struct device *hwdev,dma_addr_t handle,size_t size,enum dma_data_direction dir) { -if (is_device_dma_coherent (hwdev)) +if (dev_is_dma_coherent (hwdev))return ;__xen_dma_page_cpu_to_dev (hwdev, handle, size, dir); }
@@ -159,7 +159,7 @@ bool xen_arch_need_swiotlb(struct device *dev,* memory and we are not able to flush the cache. */ return (!hypercall_cflush && (xen_pfn != bfn) && - !is_device_dma_coherent (dev)); + !dev_is_dma_coherent (dev)); } int xen_create_contiguous_region(phys_addr_t pstart, unsigned int order,
arch/arm64/include/asm/dma-mapping.h +0 -9
@@ -18,14 +18,5 @@ static inline const struct dma_map_ops *get_arch_dma_ops(struct bus_type *bus)return NULL ; } -/* -* Do not use this function in a driver, it is only provided for -* arch/arm/mm/xen.c, which is used by arm64 as well. -*/ -static inline bool is_device_dma_coherent (struct device *dev) -{ -return dev->dma_coherent; -} -#endif /* __KERNEL__ */ #endif /* __ASM_DMA_MAPPING_H */
Signature · 1 line
2.20.1
PATCH 4/11 xen/arm: simplify dma_cache_maint
In reply to Christoph HellwigCalculate the required operation in the caller, and pass it directly instead of recalculating it for each page, and use simple arithmetics to get from the physical address to Xen page size aligned chunks.
--- arch/arm/xen/mm.c | 61 ++++++++++++++++------------------------------- 1 file changed, 21 insertions(+), 40 deletions(-)
arch/arm/xen/mm.c +21 -40
@@ -35,64 +35,45 @@ unsigned long xen_get_swiotlb_free_pages(unsigned int order)return __get_free_pages (flags, order); } -enum dma_cache_op { -DMA_UNMAP , -DMA_MAP , -};static bool hypercall_cflush = false; -/* functions called by SWIOTLB */ - -static void dma_cache_maint (dma_addr_t handle,unsigned long offset, -size_t size,enum dma_data_direction dir,enum dma_cache_op op) +/* buffers in highmem or foreign pages cannot cross page boundaries */ +static void dma_cache_maint (dma_addr_t handle,size_t size,u32 op) {struct gnttab_cache_flush cflush; -unsigned long xen_pfn; -size_t left = size; - xen_pfn = (handle >>XEN_PAGE_SHIFT ) + offset /XEN_PAGE_SIZE ; - offset %=XEN_PAGE_SIZE ; + cflush.a.dev_bus_addr = handle &XEN_PAGE_MASK ; + cflush.offset =xen_offset_in_page (handle); + cflush.op = op;do { -size_t len = left; - -/* buffers in highmem or foreign pages cannot cross page -* boundaries */ -if (len + offset >XEN_PAGE_SIZE ) - len =XEN_PAGE_SIZE - offset; - - cflush.op =0 ; - cflush.a.dev_bus_addr = xen_pfn <<XEN_PAGE_SHIFT ; - cflush.offset = offset; - cflush.length = len; - -if (op ==DMA_UNMAP && dir !=DMA_TO_DEVICE ) - cflush.op =GNTTAB_CACHE_INVAL ; -if (op ==DMA_MAP ) { -if (dir ==DMA_FROM_DEVICE ) - cflush.op =GNTTAB_CACHE_INVAL ; -else - cflush.op =GNTTAB_CACHE_CLEAN ; - } -if (cflush.op) -HYPERVISOR_grant_table_op (GNTTABOP_cache_flush, &cflush,1 ); +if (size + cflush.offset >XEN_PAGE_SIZE ) + cflush.length =XEN_PAGE_SIZE - cflush.offset; +else + cflush.length = size; + +HYPERVISOR_grant_table_op (GNTTABOP_cache_flush, &cflush,1 ); - offset =0 ; - xen_pfn++; - left -= len; - }while (left); + cflush.offset =0 ; + cflush.a.dev_bus_addr += cflush.length; + size -= cflush.length; + }while (size); }static void __xen_dma_page_dev_to_cpu (struct device *hwdev,dma_addr_t handle,size_t size,enum dma_data_direction dir) { -dma_cache_maint (handle &PAGE_MASK , handle & ~PAGE_MASK , size, dir,DMA_UNMAP ); +if (dir !=DMA_TO_DEVICE ) +dma_cache_maint (handle, size,GNTTAB_CACHE_INVAL ); }static void __xen_dma_page_cpu_to_dev (struct device *hwdev,dma_addr_t handle,size_t size,enum dma_data_direction dir) { -dma_cache_maint (handle &PAGE_MASK , handle & ~PAGE_MASK , size, dir,DMA_MAP ); +if (dir ==DMA_FROM_DEVICE ) +dma_cache_maint (handle, size,GNTTAB_CACHE_INVAL ); +else +dma_cache_maint (handle, size,GNTTAB_CACHE_CLEAN ); } void __xen_dma_map_page(struct device *hwdev, struct page *page,
Signature · 1 line
2.20.1
PATCH 5/11 xen/arm: remove xen_dma_ops
In reply to Christoph Hellwigarm and arm64 can just use xen_swiotlb_dma_ops directly like x86, no need for a pointer indirection.
--- arch/arm/mm/dma-mapping.c | 3 ++- arch/arm/xen/mm.c | 4 ---- arch/arm64/mm/dma-mapping.c | 3 ++- include/xen/arm/hypervisor.h | 2 -- 4 files changed, 4 insertions(+), 8 deletions(-)
arch/arm/mm/dma-mapping.c +2 -1
@@ -35,6 +35,7 @@#include <asm/mach/map.h> #include <asm/system_info.h> #include <asm/dma-contiguous.h> +#include <xen/swiotlb-xen.h> #include "dma.h" #include "mm.h"
@@ -2360,7 +2361,7 @@ void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size,#ifdef CONFIG_XEN if (xen_initial_domain ()) - dev->dma_ops = xen_dma_ops; + dev->dma_ops = &xen_swiotlb_dma_ops;#endif dev->archdata.dma_ops_setup = true; }
arch/arm/xen/mm.c +0 -4
@@ -162,16 +162,12 @@ void xen_destroy_contiguous_region(phys_addr_t pstart, unsigned int order) }EXPORT_SYMBOL_GPL (xen_destroy_contiguous_region); -const struct dma_map_ops *xen_dma_ops; -EXPORT_SYMBOL (xen_dma_ops); -int __init xen_mm_init (void ) {struct gnttab_cache_flush cflush;if (!xen_initial_domain ())return 0 ;xen_swiotlb_init (1 , false); - xen_dma_ops = &xen_swiotlb_dma_ops; cflush.op =0 ; cflush.a.dev_bus_addr =0 ;
arch/arm64/mm/dma-mapping.c +2 -1
@@ -8,6 +8,7 @@#include <linux/cache.h> #include <linux/dma-noncoherent.h> #include <linux/dma-iommu.h> +#include <xen/swiotlb-xen.h> #include <asm/cacheflush.h>
@@ -64,6 +65,6 @@ void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size,#ifdef CONFIG_XEN if (xen_initial_domain ()) - dev->dma_ops = xen_dma_ops; + dev->dma_ops = &xen_swiotlb_dma_ops;#endif }
include/xen/arm/hypervisor.h +0 -2
@@ -19,8 +19,6 @@ static inline enum paravirt_lazy_mode paravirt_get_lazy_mode(void)return PARAVIRT_LAZY_NONE ; } -extern const struct dma_map_ops *xen_dma_ops; -#ifdef CONFIG_XEN void __init xen_early_init (void );#else
Signature · 1 line
2.20.1
PATCH 6/11 xen: remove the exports for xen_{create,destroy}_contiguous_region
In reply to Christoph HellwigThese routines are only used by swiotlb-xen, which cannot be modular.
--- arch/arm/xen/mm.c | 2 -- arch/x86/xen/mmu_pv.c | 2 -- 2 files changed, 4 deletions(-)
arch/arm/xen/mm.c +0 -2
@@ -154,13 +154,11 @@ int xen_create_contiguous_region(phys_addr_t pstart, unsigned int order, *dma_handle = pstart;return 0 ; } -EXPORT_SYMBOL_GPL (xen_create_contiguous_region);void xen_destroy_contiguous_region (phys_addr_t pstart,unsigned int order) {return ; } -EXPORT_SYMBOL_GPL (xen_destroy_contiguous_region);int __init xen_mm_init (void ) {
arch/x86/xen/mmu_pv.c +0 -2
@@ -2625,7 +2625,6 @@ int xen_create_contiguous_region(phys_addr_t pstart, unsigned int order, *dma_handle =virt_to_machine (vstart).maddr;return success ?0 : -ENOMEM ; } -EXPORT_SYMBOL_GPL (xen_create_contiguous_region);void xen_destroy_contiguous_region (phys_addr_t pstart,unsigned int order) {
@@ -2660,7 +2659,6 @@ void xen_destroy_contiguous_region(phys_addr_t pstart, unsigned int order)spin_unlock_irqrestore (&xen_reservation_lock, flags); } -EXPORT_SYMBOL_GPL (xen_destroy_contiguous_region); static noinline void xen_flush_tlb_all(void) {
Signature · 1 line
2.20.1
PATCH 7/11 swiotlb-xen: remove xen_swiotlb_dma_mmap and xen_swiotlb_dma_get_sgtable
In reply to Christoph HellwigThere is no need to wrap the common version, just wire them up directly.
--- drivers/xen/swiotlb-xen.c | 29 ++--------------------------- 1 file changed, 2 insertions(+), 27 deletions(-)
drivers/xen/swiotlb-xen.c +2 -27
@@ -547,31 +547,6 @@ xen_swiotlb_dma_supported(struct device *hwdev, u64 mask)return xen_virt_to_bus (xen_io_tlb_end -1 ) <= mask; } -/* -* Create userspace mapping for the DMA-coherent memory. -* This function should be called with the pages from the current domain only, -* passing pages mapped from other domains would lead to memory corruption. -*/ -static int -xen_swiotlb_dma_mmap (struct device *dev,struct vm_area_struct *vma, -void *cpu_addr,dma_addr_t dma_addr,size_t size, -unsigned long attrs) -{ -return dma_common_mmap (dev, vma, cpu_addr, dma_addr, size, attrs); -} - -/* -* This function should be called with the pages from the current domain only, -* passing pages mapped from other domains would lead to memory corruption. -*/ -static int -xen_swiotlb_get_sgtable (struct device *dev,struct sg_table *sgt, -void *cpu_addr,dma_addr_t handle,size_t size, -unsigned long attrs) -{ -return dma_common_get_sgtable (dev, sgt, cpu_addr, handle, size, attrs); -} -const struct dma_map_ops xen_swiotlb_dma_ops = { .alloc = xen_swiotlb_alloc_coherent, .free = xen_swiotlb_free_coherent,
@@ -584,6 +559,6 @@ const struct dma_map_ops xen_swiotlb_dma_ops = { .map_page = xen_swiotlb_map_page, .unmap_page = xen_swiotlb_unmap_page, .dma_supported = xen_swiotlb_dma_supported, - .mmap = xen_swiotlb_dma_mmap, - .get_sgtable = xen_swiotlb_get_sgtable, + .mmap = dma_common_mmap, + .get_sgtable = dma_common_get_sgtable, };
Signature · 1 line
2.20.1
PATCH 8/11 swiotlb-xen: use the same foreign page check everywhere
In reply to Christoph Hellwigxen_dma_map_page uses a different and more complicated check for foreign pages than the other three cache maintainance helpers. Switch it to the simpler pfn_valid method a well, and document the scheme with a single improved comment in xen_dma_map_page.
--- include/xen/arm/page-coherent.h | 31 +++++++++---------------------- 1 file changed, 9 insertions(+), 22 deletions(-)
include/xen/arm/page-coherent.h +9 -22
@@ -53,23 +53,17 @@ static inline void xen_dma_map_page(struct device *hwdev, struct page *page, dma_addr_t dev_addr, unsigned long offset, size_t size, enum dma_data_direction dir, unsigned long attrs) { - unsigned long page_pfn = page_to_xen_pfn(page); -unsigned long dev_pfn =XEN_PFN_DOWN (dev_addr); -unsigned long compound_pages = - (1 <<compound_order (page)) *XEN_PFN_PER_PAGE ; -bool local = (page_pfn <= dev_pfn) && - (dev_pfn - page_pfn < compound_pages); + unsigned long pfn = PFN_DOWN(dev_addr);/* -* Dom0 is mapped 1:1, while the Linux page can span across -* multiple Xen pages, it's not possible for it to contain a -* mix of local and foreign Xen pages. So if the first xen_pfn -* == mfn the page is local otherwise it's a foreign page -* grant-mapped in dom0. If the page is local we can safely -* call the native dma_ops function, otherwise we call the xen -* specific function. +* Dom0 is mapped 1:1, and while the Linux page can span across multiple +* Xen pages, it is not possible for it to contain a mix of local and +* foreign Xen pages. Calling pfn_valid on a foreign mfn will always +* return false, so if pfn_valid returns true the pages is local and we +* can use the native dma-direct functions, otherwise we call the Xen +* specific version. */ -if (local) +if (pfn_valid (pfn))dma_direct_map_page (hwdev, page, offset, size, dir, attrs);else __xen_dma_map_page (hwdev, page, dev_addr, offset, size, dir, attrs);
@@ -79,14 +73,7 @@ static inline void xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle, size_t size, enum dma_data_direction dir, unsigned long attrs) { unsigned long pfn = PFN_DOWN(handle); -/* -* Dom0 is mapped 1:1, while the Linux page can be spanned accross -* multiple Xen page, it's not possible to have a mix of local and -* foreign Xen page. Dom0 is mapped 1:1, so calling pfn_valid on a -* foreign mfn will always return false. If the page is local we can -* safely call the native dma_ops function, otherwise we call the xen -* specific function. -*/ +if (pfn_valid (pfn))dma_direct_unmap_page (hwdev, handle, size, dir, attrs);else
Signature · 1 line
2.20.1
PATCH 9/11 swiotlb-xen: simplify cache maintainance
In reply to Christoph HellwigNow that we know we always have the dma-noncoherent.h helpers available if we are on an architecture with support for non-coherent devices, we can just call them directly, and remove the calls to the dma-direct routines, including the fact that we call the dma_direct_map_page routines but ignore the value returned from it. Instead we now have Xen wrappers for the arch_sync_dma_for_{device,cpu} helpers that call the special Xen versions of those routines for foreign pages.
Note that the new helpers get the physical address passed in addition to the dma address to avoid another translation for the local cache maintainance. The pfn_valid checks remain on the dma address as in the old code, even if that looks a little funny.
--- arch/arm/xen/mm.c | 64 +++++++----------------- arch/x86/include/asm/xen/page-coherent.h | 14 ------ drivers/xen/swiotlb-xen.c | 20 ++++---- include/xen/arm/page-coherent.h | 63 ----------------------- include/xen/swiotlb-xen.h | 5 ++ 5 files changed, 32 insertions(+), 134 deletions(-)
arch/arm/xen/mm.c +17 -47
@@ -60,63 +60,33 @@ static void dma_cache_maint(dma_addr_t handle, size_t size, u32 op) }while (size); } -static void __xen_dma_page_dev_to_cpu (struct device *hwdev,dma_addr_t handle, -size_t size,enum dma_data_direction dir) +/* +* Dom0 is mapped 1:1, and while the Linux page can span across multiple Xen +* pages, it is not possible for it to contain a mix of local and foreign Xen +* pages. Calling pfn_valid on a foreign mfn will always return false, so if +* pfn_valid returns true the pages is local and we can use the native +* dma-direct functions, otherwise we call the Xen specific version. +*/ +void xen_dma_sync_for_cpu (struct device *dev,dma_addr_t handle, +phys_addr_t paddr,size_t size,enum dma_data_direction dir) { -if (dir !=DMA_TO_DEVICE ) +if (pfn_valid (PFN_DOWN (handle))) +arch_sync_dma_for_cpu (dev, paddr, size, dir); +else if (dir !=DMA_TO_DEVICE )dma_cache_maint (handle, size,GNTTAB_CACHE_INVAL ); } -static void __xen_dma_page_cpu_to_dev (struct device *hwdev,dma_addr_t handle, -size_t size,enum dma_data_direction dir) +void xen_dma_sync_for_device (struct device *dev,dma_addr_t handle, +phys_addr_t paddr,size_t size,enum dma_data_direction dir) { -if (dir ==DMA_FROM_DEVICE ) +if (pfn_valid (PFN_DOWN (handle))) +arch_sync_dma_for_device (dev, paddr, size, dir); +else if (dir ==DMA_FROM_DEVICE )dma_cache_maint (handle, size,GNTTAB_CACHE_INVAL );else dma_cache_maint (handle, size,GNTTAB_CACHE_CLEAN ); } -void __xen_dma_map_page (struct device *hwdev,struct page *page, -dma_addr_t dev_addr,unsigned long offset,size_t size, -enum dma_data_direction dir,unsigned long attrs) -{ -if (dev_is_dma_coherent (hwdev)) -return ; -if (attrs &DMA_ATTR_SKIP_CPU_SYNC ) -return ; - -__xen_dma_page_cpu_to_dev (hwdev, dev_addr, size, dir); -} - -void __xen_dma_unmap_page (struct device *hwdev,dma_addr_t handle, -size_t size,enum dma_data_direction dir, -unsigned long attrs) - -{ -if (dev_is_dma_coherent (hwdev)) -return ; -if (attrs &DMA_ATTR_SKIP_CPU_SYNC ) -return ; - -__xen_dma_page_dev_to_cpu (hwdev, handle, size, dir); -} - -void __xen_dma_sync_single_for_cpu (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) -{ -if (dev_is_dma_coherent (hwdev)) -return ; -__xen_dma_page_dev_to_cpu (hwdev, handle, size, dir); -} - -void __xen_dma_sync_single_for_device (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) -{ -if (dev_is_dma_coherent (hwdev)) -return ; -__xen_dma_page_cpu_to_dev (hwdev, handle, size, dir); -} -bool xen_arch_need_swiotlb (struct device *dev,phys_addr_t phys,dma_addr_t dev_addr)
arch/x86/include/asm/xen/page-coherent.h +0 -14
@@ -21,18 +21,4 @@ static inline void xen_free_coherent_pages(struct device *hwdev, size_t size, free_pages((unsigned long) cpu_addr, get_order(size)); } -static inline void xen_dma_map_page (struct device *hwdev,struct page *page, -dma_addr_t dev_addr,unsigned long offset,size_t size, -enum dma_data_direction dir,unsigned long attrs) { } - -static inline void xen_dma_unmap_page (struct device *hwdev,dma_addr_t handle, -size_t size,enum dma_data_direction dir, -unsigned long attrs) { } - -static inline void xen_dma_sync_single_for_cpu (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) { } - -static inline void xen_dma_sync_single_for_device (struct device *hwdev, -dma_addr_t handle,size_t size,enum dma_data_direction dir) { } -#endif /* _ASM_X86_XEN_PAGE_COHERENT_H */
drivers/xen/swiotlb-xen.c +10 -10
@@ -28,6 +28,7 @@#include <linux/memblock.h> #include <linux/dma-direct.h> +#include <linux/dma-noncoherent.h> #include <linux/export.h> #include <xen/swiotlb-xen.h> #include <xen/page.h>
@@ -391,6 +392,7 @@ static dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,if (map == (phys_addr_t )DMA_MAPPING_ERROR )return DMA_MAPPING_ERROR ; + phys = map; dev_addr =xen_phys_to_bus (map);/*
@@ -402,14 +404,9 @@ static dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,return DMA_MAPPING_ERROR ; } - page =pfn_to_page (map >>PAGE_SHIFT ); - offset = map & ~PAGE_MASK ; done: -/* -* we are not interested in the dma_addr returned by xen_dma_map_page, -* only in the potential cache flushes executed by the function. -*/ -xen_dma_map_page (dev, page, dev_addr, offset, size, dir, attrs); +if (!dev_is_dma_coherent (dev) && !(attrs &DMA_ATTR_SKIP_CPU_SYNC )) +xen_dma_sync_for_device (dev, dev_addr, phys, size, dir);return dev_addr; }
@@ -429,7 +426,8 @@ static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr,BUG_ON (dir ==DMA_NONE ); -xen_dma_unmap_page (hwdev, dev_addr, size, dir, attrs); +if (!dev_is_dma_coherent (hwdev) && !(attrs &DMA_ATTR_SKIP_CPU_SYNC )) +xen_dma_sync_for_cpu (hwdev, dev_addr, paddr, size, dir);/* NOTE: We use dev_addr here, not paddr! */ if (is_xen_swiotlb_buffer (dev_addr))
@@ -449,7 +447,8 @@ xen_swiotlb_sync_single_for_cpu(struct device *dev, dma_addr_t dma_addr, {phys_addr_t paddr =xen_bus_to_phys (dma_addr); -xen_dma_sync_single_for_cpu (dev, dma_addr, size, dir); +if (!dev_is_dma_coherent (dev)) +xen_dma_sync_for_cpu (dev, dma_addr, paddr, size, dir);if (is_xen_swiotlb_buffer (dma_addr))swiotlb_tbl_sync_single (dev, paddr, size, dir,SYNC_FOR_CPU );
@@ -464,7 +463,8 @@ xen_swiotlb_sync_single_for_device(struct device *dev, dma_addr_t dma_addr,if (is_xen_swiotlb_buffer (dma_addr))swiotlb_tbl_sync_single (dev, paddr, size, dir,SYNC_FOR_DEVICE ); -xen_dma_sync_single_for_device (dev, dma_addr, size, dir); +if (!dev_is_dma_coherent (dev)) +xen_dma_sync_for_device (dev, dma_addr, paddr, size, dir); }/*
include/xen/arm/page-coherent.h +0 -63
73 lines not on this page · raw message
include/xen/swiotlb-xen.h +5 -0
@@ -4,6 +4,11 @@#include <linux/swiotlb.h> +void xen_dma_sync_for_cpu (struct device *dev,dma_addr_t handle, +phys_addr_t paddr,size_t size,enum dma_data_direction dir); +void xen_dma_sync_for_device (struct device *dev,dma_addr_t handle, +phys_addr_t paddr,size_t size,enum dma_data_direction dir); +extern int xen_swiotlb_init (int verbose,bool early);extern const struct dma_map_ops xen_swiotlb_dma_ops;
Signature · 1 line
2.20.1
Boris Ostrovsky
reviewerRe: [PATCH 09/11] swiotlb-xen: simplify cache maintainance
Quoted 5 lines · Christoph Hellwig
include/xen/swiotlb-xen.h +0
-0
include/xen/swiotlb-xen.h line 13
Quoted 10 lines
include/xen/swiotlb-xen.h +5
-0@@ -4,6 +4,11 @@#include <linux/swiotlb.h> +void xen_dma_sync_for_cpu (struct device *dev,dma_addr_t handle, +phys_addr_t paddr,size_t size,enum dma_data_direction dir); +void xen_dma_sync_for_device (struct device *dev,dma_addr_t handle, +phys_addr_t paddr,size_t size,enum dma_data_direction dir); +extern int xen_swiotlb_init (int verbose,bool early);extern const struct dma_map_ops xen_swiotlb_dma_ops;
We need nop definitions of these two for x86.
Everything builds now but that's probably because the calls are under 'if (!dev_is_dma_coherent(dev))' which is always false so compiler optimized is out. I don't think we should rely on that.
-boris
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [PATCH 09/11] swiotlb-xen: simplify cache maintainance
Quoted 5 lines · Boris Ostrovsky
We need nop definitions of these two for x86.
Everything builds now but that's probably because the calls are under 'if (!dev_is_dma_coherent(dev))' which is always false so compiler optimized is out. I don't think we should rely on that.
That is how a lot of the kernel works. Provide protypes only for code that is semantically compiled, but can't ever be called due to IS_ENABLED() checks. It took me a while to get used to it, but it actually is pretty nice as the linker does the work for you to check that it really is never called. Much better than say a BUILD_BUG_ON().
Re: [Xen-devel] [PATCH 09/11] swiotlb-xen: simplify cache maintainance
Quoted 11 lines · Christoph Hellwig
Quoted 5 lines · Boris Ostrovsky
We need nop definitions of these two for x86.
Everything builds now but that's probably because the calls are under 'if (!dev_is_dma_coherent(dev))' which is always false so compiler optimized is out. I don't think we should rely on that.
That is how a lot of the kernel works. Provide protypes only for code that is semantically compiled, but can't ever be called due to
IS_ENABLED()checks. It took me a while to get used to it, but it actually is pretty nice as the linker does the work for you to check that it really is never called. Much better than say aBUILD_BUG_ON().
Yeah - its a weird concept to get used to, but it results in much clearer code.
~Andrew
Re: [PATCH 09/11] swiotlb-xen: simplify cache maintainance
In reply to Christoph HellwigQuoted 11 lines · Christoph Hellwig
Quoted 5 lines · Boris Ostrovsky
We need nop definitions of these two for x86.
Everything builds now but that's probably because the calls are under 'if (!dev_is_dma_coherent(dev))' which is always false so compiler optimized is out. I don't think we should rely on that.
That is how a lot of the kernel works. Provide protypes only for code that is semantically compiled, but can't ever be called due to
IS_ENABLED()checks. It took me a while to get used to it, but it actually is pretty nice as the linker does the work for you to check that it really is never called. Much better than say aBUILD_BUG_ON().
(with corrected Juergen's email)
I know about IS_ENABLED() but I didn't realize that this is allowed for compile-time inlines and such as well.
Anyway, for non-ARM bits
If this goes via Xen tree then the first couple of patches need an ack from ARM maintainers.
-boris
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Konrad Rzeszutek Wilk
Acked-byRe: [PATCH 09/11] swiotlb-xen: simplify cache maintainance
Quoted 14 lines · Boris Ostrovsky
Quoted 11 lines · Christoph Hellwig
Quoted 5 lines · Boris Ostrovsky
We need nop definitions of these two for x86.
Everything builds now but that's probably because the calls are under 'if (!dev_is_dma_coherent(dev))' which is always false so compiler optimized is out. I don't think we should rely on that.
That is how a lot of the kernel works. Provide protypes only for code that is semantically compiled, but can't ever be called due to
IS_ENABLED()checks. It took me a while to get used to it, but it actually is pretty nice as the linker does the work for you to check that it really is never called. Much better than say aBUILD_BUG_ON().
Quoted 8 lines
(with corrected Juergen's email)
I know about
IS_ENABLED()but I didn't realize that this is allowed for compile-time inlines and such as well.Anyway, for non-ARM bits
Reviewed-by Boris Ostrovsky <[email protected]>
as well.
Albeit folks have tested this under x86 Xen with 'swiotlb=force' right?
I can test it myself but it will take a couple of days.
Quoted 5 lines
If this goes via Xen tree then the first couple of patches need an ack from ARM maintainers.
-boris
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Boris Ostrovsky
reviewerRe: [PATCH 09/11] swiotlb-xen: simplify cache maintainance
Quoted 19 lines · Konrad Rzeszutek Wilk
Quoted 18 lines · Boris Ostrovsky
Quoted 11 lines · Christoph Hellwig
Quoted 5 lines · Boris Ostrovsky
We need nop definitions of these two for x86.
Everything builds now but that's probably because the calls are under 'if (!dev_is_dma_coherent(dev))' which is always false so compiler optimized is out. I don't think we should rely on that.
That is how a lot of the kernel works. Provide protypes only for code that is semantically compiled, but can't ever be called due to
IS_ENABLED()checks. It took me a while to get used to it, but it actually is pretty nice as the linker does the work for you to check that it really is never called. Much better than say aBUILD_BUG_ON().(with corrected Juergen's email)
I know about
IS_ENABLED()but I didn't realize that this is allowed for compile-time inlines and such as well.
Quoted 8 lines
Quoted 3 lines
Anyway, for non-ARM bits
Reviewed-by Boris Ostrovsky <[email protected]>as well.
Albeit folks have tested this under x86 Xen with 'swiotlb=force' right?
Yes, I did.
-boris
Quoted 6 lines
I can test it myself but it will take a couple of days.
Quoted 4 lines
If this goes via Xen tree then the first couple of patches need an ack from ARM maintainers.
-boris
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH 10/11 swiotlb-xen: merge xen_unmap_single into xen_swiotlb_unmap_page
In reply to Christoph HellwigNo need for a no-op wrapper.
--- drivers/xen/swiotlb-xen.c | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-)
drivers/xen/swiotlb-xen.c +4 -11
@@ -418,9 +418,8 @@ static dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,* After this call, reads by the cpu to the buffer are guaranteed to see * whatever the device wrote there. */ -static void xen_unmap_single (struct device *hwdev,dma_addr_t dev_addr, -size_t size,enum dma_data_direction dir, -unsigned long attrs) +static void xen_swiotlb_unmap_page (struct device *hwdev,dma_addr_t dev_addr, +size_t size,enum dma_data_direction dir,unsigned long attrs) {phys_addr_t paddr =xen_bus_to_phys (dev_addr);
@@ -434,13 +433,6 @@ static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr,swiotlb_tbl_unmap_single (hwdev, paddr, size, dir, attrs); } -static void xen_swiotlb_unmap_page (struct device *hwdev,dma_addr_t dev_addr, -size_t size,enum dma_data_direction dir, -unsigned long attrs) -{ -xen_unmap_single (hwdev, dev_addr, size, dir, attrs); -} -static void xen_swiotlb_sync_single_for_cpu (struct device *dev,dma_addr_t dma_addr,size_t size,enum dma_data_direction dir)
@@ -481,7 +473,8 @@ xen_swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sgl, int nelems,BUG_ON (dir ==DMA_NONE );for_each_sg (sgl, sg, nelems, i) -xen_unmap_single (hwdev, sg->dma_address,sg_dma_len (sg), dir, attrs); +xen_swiotlb_unmap_page (hwdev, sg->dma_address,sg_dma_len (sg), + dir, attrs); }
Signature · 1 line
2.20.1
PATCH 11/11 arm64: use asm-generic/dma-mapping.h
In reply to Christoph HellwigNow that the Xen special cases are gone nothing worth mentioning is left in the arm64 <asm/dma-mapping.h> file, so switch to use the asm-generic version instead.
--- arch/arm64/include/asm/Kbuild | 1 + arch/arm64/include/asm/dma-mapping.h | 22 ---------------------- arch/arm64/mm/dma-mapping.c | 1 + 3 files changed, 2 insertions(+), 22 deletions(-) delete mode 100644 arch/arm64/include/asm/dma-mapping.h
arch/arm64/include/asm/Kbuild +1 -0
@@ -4,6 +4,7 @@ generic-y += delay.h generic-y += div64.h generic-y += dma.h generic-y += dma-contiguous.h +generic-y += dma-mapping.h generic-y += early_ioremap.h generic-y += emergency-restart.h generic-y += hw_irq.h
arch/arm64/include/asm/dma-mapping.h deleted +0 -22
@@ -1,22 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* -* Copyright (C) 2012 ARM Ltd. -*/ -#ifndef __ASM_DMA_MAPPING_H -#define __ASM_DMA_MAPPING_H - -#ifdef __KERNEL__ - -#include <linux/types.h> -#include <linux/vmalloc.h> - -#include <xen/xen.h> -#include <asm/xen/hypervisor.h> - -static inline const struct dma_map_ops *get_arch_dma_ops (struct bus_type *bus) -{ -return NULL ; -} - -#endif /* __KERNEL__ */ -#endif /* __ASM_DMA_MAPPING_H */
arch/arm64/mm/dma-mapping.c +1 -0
@@ -8,6 +8,7 @@#include <linux/cache.h> #include <linux/dma-noncoherent.h> #include <linux/dma-iommu.h> +#include <xen/xen.h> #include <xen/swiotlb-xen.h> #include <asm/cacheflush.h>
Signature · 1 line
2.20.1
Christoph Hellwig
AppliedApplied to the dma-mapping tree.