dma-direct: simplify the DMA_ATTR_NO_KERNEL_MAPPING handling

Use and entirely separate code path for the DMA_ATTR_NO_KERNEL_MAPPING
path.  This avoids any confusion about the ret type, and avoids lots of
attr checks and helpers that can be significantly simplified now.

It also ensures that common handling is applied to architetures still
using the arch alloc/free hooks.

Signed-off-by: Christoph Hellwig <hch@lst.de>

diff --git a/include/linux/dma-map-ops.h b/include/linux/dma-map-ops.h
index 33c6e24707a94b610360744f57b16a1177c0a47a..8029f7e0414521a593733c2c927e6322be5fc191 100644 (file)
--- a/include/linux/dma-map-ops.h
+++ b/include/linux/dma-map-ops.h
@@ -219,19 +219,6 @@ static inline bool dev_is_dma_coherent(struct device *dev)
 }
 #endif /* CONFIG_ARCH_HAS_DMA_COHERENCE_H */
 
-/*
- * Check if an allocation needs to be marked uncached to be coherent.
- */
-static __always_inline bool dma_alloc_need_uncached(struct device *dev,
-               unsigned long attrs)
-{
-       if (dev_is_dma_coherent(dev))
-               return false;
-       if (attrs & DMA_ATTR_NO_KERNEL_MAPPING)
-               return false;
-       return true;
-}
-
 void *arch_dma_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
                gfp_t gfp, unsigned long attrs);
 void arch_dma_free(struct device *dev, size_t size, void *cpu_addr,

diff --git a/kernel/dma/direct.c b/kernel/dma/direct.c
index eddcb70251c9a3cfe53ab0cfc9734f3e30ec965f..b92d08e65999db23b279c7d4f2daebf519700c0a 100644 (file)
--- a/kernel/dma/direct.c
+++ b/kernel/dma/direct.c
@@ -75,39 +75,6 @@ static bool dma_coherent_ok(struct device *dev, phys_addr_t phys, size_t size)
                min_not_zero(dev->coherent_dma_mask, dev->bus_dma_limit);
 }
 
-/*
- * Decrypting memory is allowed to block, so if this device requires
- * unencrypted memory it must come from atomic pools.
- */
-static inline bool dma_should_alloc_from_pool(struct device *dev, gfp_t gfp,
-                                             unsigned long attrs)
-{
-       if (!IS_ENABLED(CONFIG_DMA_COHERENT_POOL))
-               return false;
-       if (gfpflags_allow_blocking(gfp))
-               return false;
-       if (force_dma_unencrypted(dev))
-               return true;
-       if (!IS_ENABLED(CONFIG_DMA_DIRECT_REMAP))
-               return false;
-       if (dma_alloc_need_uncached(dev, attrs))
-               return true;
-       return false;
-}
-
-static inline bool dma_should_free_from_pool(struct device *dev,
-                                            unsigned long attrs)
-{
-       if (IS_ENABLED(CONFIG_DMA_COHERENT_POOL))
-               return true;
-       if ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) &&
-           !force_dma_unencrypted(dev))
-               return false;
-       if (IS_ENABLED(CONFIG_DMA_DIRECT_REMAP))
-               return true;
-       return false;
-}
-
 static struct page *__dma_direct_alloc_pages(struct device *dev, size_t size,
                gfp_t gfp)
 {
@@ -170,35 +137,45 @@ void *dma_direct_alloc(struct device *dev, size_t size,
        void *ret;
        int err;
 
-       if (!IS_ENABLED(CONFIG_ARCH_HAS_DMA_SET_UNCACHED) &&
-           !IS_ENABLED(CONFIG_DMA_DIRECT_REMAP) &&
-           dma_alloc_need_uncached(dev, attrs))
-               return arch_dma_alloc(dev, size, dma_handle, gfp, attrs);
-
        size = PAGE_ALIGN(size);
        if (attrs & DMA_ATTR_NO_WARN)
                gfp |= __GFP_NOWARN;
 
-       if (dma_should_alloc_from_pool(dev, gfp, attrs))
-               return dma_direct_alloc_from_pool(dev, size, dma_handle, gfp);
-
-       /* we always manually zero the memory once we are done */
-       page = __dma_direct_alloc_pages(dev, size, gfp & ~__GFP_ZERO);
-       if (!page)
-               return NULL;
-
        if ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) &&
            !force_dma_unencrypted(dev)) {
+               page = __dma_direct_alloc_pages(dev, size, gfp & ~__GFP_ZERO);
+               if (!page)
+                       return NULL;
                /* remove any dirty cache lines on the kernel alias */
                if (!PageHighMem(page))
                        arch_dma_prep_coherent(page, size);
+               *dma_handle = phys_to_dma_direct(dev, page_to_phys(page));
                /* return the page pointer as the opaque cookie */
-               ret = page;
-               goto done;
+               return page;
        }
 
+       if (!IS_ENABLED(CONFIG_ARCH_HAS_DMA_SET_UNCACHED) &&
+           !IS_ENABLED(CONFIG_DMA_DIRECT_REMAP) &&
+           !dev_is_dma_coherent(dev))
+               return arch_dma_alloc(dev, size, dma_handle, gfp, attrs);
+
+       /*
+        * Remapping or decrypting memory may block. If either is required and
+        * we can't block, allocate the memory from the atomic pools.
+        */
+       if (IS_ENABLED(CONFIG_DMA_COHERENT_POOL) &&
+           !gfpflags_allow_blocking(gfp) &&
+           (force_dma_unencrypted(dev) ||
+            (IS_ENABLED(CONFIG_DMA_DIRECT_REMAP) && !dev_is_dma_coherent(dev))))
+               return dma_direct_alloc_from_pool(dev, size, dma_handle, gfp);
+
+       /* we always manually zero the memory once we are done */
+       page = __dma_direct_alloc_pages(dev, size, gfp & ~__GFP_ZERO);
+       if (!page)
+               return NULL;
+
        if ((IS_ENABLED(CONFIG_DMA_DIRECT_REMAP) &&
-            dma_alloc_need_uncached(dev, attrs)) ||
+            !dev_is_dma_coherent(dev)) ||
            (IS_ENABLED(CONFIG_DMA_REMAP) && PageHighMem(page))) {
                /* remove any dirty cache lines on the kernel alias */
                arch_dma_prep_coherent(page, size);
@@ -241,7 +218,7 @@ void *dma_direct_alloc(struct device *dev, size_t size,
        memset(ret, 0, size);
 
        if (IS_ENABLED(CONFIG_ARCH_HAS_DMA_SET_UNCACHED) &&
-           dma_alloc_need_uncached(dev, attrs)) {
+           !dev_is_dma_coherent(dev)) {
                arch_dma_prep_coherent(page, size);
                ret = arch_dma_set_uncached(ret, size);
                if (IS_ERR(ret))
@@ -269,25 +246,25 @@ void dma_direct_free(struct device *dev, size_t size,
 {
        unsigned int page_order = get_order(size);
 
+       if ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) &&
+           !force_dma_unencrypted(dev)) {
+               /* cpu_addr is a struct page cookie, not a kernel address */
+               dma_free_contiguous(dev, cpu_addr, size);
+               return;
+       }
+
        if (!IS_ENABLED(CONFIG_ARCH_HAS_DMA_SET_UNCACHED) &&
            !IS_ENABLED(CONFIG_DMA_DIRECT_REMAP) &&
-           dma_alloc_need_uncached(dev, attrs)) {
+           !dev_is_dma_coherent(dev)) {
                arch_dma_free(dev, size, cpu_addr, dma_addr, attrs);
                return;
        }
 
        /* If cpu_addr is not from an atomic pool, dma_free_from_pool() fails */
-       if (dma_should_free_from_pool(dev, attrs) &&
+       if (IS_ENABLED(CONFIG_DMA_COHERENT_POOL) &&
            dma_free_from_pool(dev, cpu_addr, PAGE_ALIGN(size)))
                return;
 
-       if ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) &&
-           !force_dma_unencrypted(dev)) {
-               /* cpu_addr is a struct page cookie, not a kernel address */
-               dma_free_contiguous(dev, cpu_addr, size);
-               return;
-       }
-
        if (force_dma_unencrypted(dev))
                set_memory_encrypted((unsigned long)cpu_addr, 1 << page_order);
 
@@ -305,7 +282,8 @@ struct page *dma_direct_alloc_pages(struct device *dev, size_t size,
        struct page *page;
        void *ret;
 
-       if (dma_should_alloc_from_pool(dev, gfp, 0))
+       if (IS_ENABLED(CONFIG_DMA_COHERENT_POOL) &&
+           force_dma_unencrypted(dev) && !gfpflags_allow_blocking(gfp))
                return dma_direct_alloc_from_pool(dev, size, dma_handle, gfp);
 
        page = __dma_direct_alloc_pages(dev, size, gfp);
@@ -344,7 +322,7 @@ void dma_direct_free_pages(struct device *dev, size_t size,
        void *vaddr = page_address(page);
 
        /* If cpu_addr is not from an atomic pool, dma_free_from_pool() fails */
-       if (dma_should_free_from_pool(dev, 0) &&
+       if (IS_ENABLED(CONFIG_DMA_COHERENT_POOL) &&
            dma_free_from_pool(dev, vaddr, size))
                return;