]> git.openfabrics.org - ~shefty/rdma-dev.git/commitdiff
mm: dmapool: use provided gfp flags for all dma_alloc_coherent() calls
authorMarek Szyprowski <m.szyprowski@samsung.com>
Wed, 7 Nov 2012 14:37:07 +0000 (15:37 +0100)
committerMarek Szyprowski <m.szyprowski@samsung.com>
Tue, 11 Dec 2012 08:28:08 +0000 (09:28 +0100)
dmapool always calls dma_alloc_coherent() with GFP_ATOMIC flag,
regardless the flags provided by the caller. This causes excessive
pruning of emergency memory pools without any good reason. Additionaly,
on ARM architecture any driver which is using dmapools will sooner or
later  trigger the following error:
"ERROR: 256 KiB atomic DMA coherent pool is too small!
Please increase it with coherent_pool= kernel parameter!".
Increasing the coherent pool size usually doesn't help much and only
delays such error, because all GFP_ATOMIC DMA allocations are always
served from the special, very limited memory pool.

This patch changes the dmapool code to correctly use gfp flags provided
by the dmapool caller.

Reported-by: Soeren Moch <smoch@web.de>
Reported-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
Tested-by: Andrew Lunn <andrew@lunn.ch>
Tested-by: Soeren Moch <smoch@web.de>
Cc: stable@vger.kernel.org
mm/dmapool.c

index c5ab33bca0a8183bffc1b00e92583b5514d45c96..da1b0f0b8709d1eaf485fcd8bd8c86c0e69db6d6 100644 (file)
@@ -50,7 +50,6 @@ struct dma_pool {             /* the pool */
        size_t allocation;
        size_t boundary;
        char name[32];
        size_t allocation;
        size_t boundary;
        char name[32];
-       wait_queue_head_t waitq;
        struct list_head pools;
 };
 
        struct list_head pools;
 };
 
@@ -62,8 +61,6 @@ struct dma_page {             /* cacheable header for 'allocation' bytes */
        unsigned int offset;
 };
 
        unsigned int offset;
 };
 
-#define        POOL_TIMEOUT_JIFFIES    ((100 /* msec */ * HZ) / 1000)
-
 static DEFINE_MUTEX(pools_lock);
 
 static ssize_t
 static DEFINE_MUTEX(pools_lock);
 
 static ssize_t
@@ -172,7 +169,6 @@ struct dma_pool *dma_pool_create(const char *name, struct device *dev,
        retval->size = size;
        retval->boundary = boundary;
        retval->allocation = allocation;
        retval->size = size;
        retval->boundary = boundary;
        retval->allocation = allocation;
-       init_waitqueue_head(&retval->waitq);
 
        if (dev) {
                int ret;
 
        if (dev) {
                int ret;
@@ -227,7 +223,6 @@ static struct dma_page *pool_alloc_page(struct dma_pool *pool, gfp_t mem_flags)
                memset(page->vaddr, POOL_POISON_FREED, pool->allocation);
 #endif
                pool_initialise_page(pool, page);
                memset(page->vaddr, POOL_POISON_FREED, pool->allocation);
 #endif
                pool_initialise_page(pool, page);
-               list_add(&page->page_list, &pool->page_list);
                page->in_use = 0;
                page->offset = 0;
        } else {
                page->in_use = 0;
                page->offset = 0;
        } else {
@@ -315,30 +310,21 @@ void *dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags,
        might_sleep_if(mem_flags & __GFP_WAIT);
 
        spin_lock_irqsave(&pool->lock, flags);
        might_sleep_if(mem_flags & __GFP_WAIT);
 
        spin_lock_irqsave(&pool->lock, flags);
- restart:
        list_for_each_entry(page, &pool->page_list, page_list) {
                if (page->offset < pool->allocation)
                        goto ready;
        }
        list_for_each_entry(page, &pool->page_list, page_list) {
                if (page->offset < pool->allocation)
                        goto ready;
        }
-       page = pool_alloc_page(pool, GFP_ATOMIC);
-       if (!page) {
-               if (mem_flags & __GFP_WAIT) {
-                       DECLARE_WAITQUEUE(wait, current);
 
 
-                       __set_current_state(TASK_UNINTERRUPTIBLE);
-                       __add_wait_queue(&pool->waitq, &wait);
-                       spin_unlock_irqrestore(&pool->lock, flags);
+       /* pool_alloc_page() might sleep, so temporarily drop &pool->lock */
+       spin_unlock_irqrestore(&pool->lock, flags);
 
 
-                       schedule_timeout(POOL_TIMEOUT_JIFFIES);
+       page = pool_alloc_page(pool, mem_flags);
+       if (!page)
+               return NULL;
 
 
-                       spin_lock_irqsave(&pool->lock, flags);
-                       __remove_wait_queue(&pool->waitq, &wait);
-                       goto restart;
-               }
-               retval = NULL;
-               goto done;
-       }
+       spin_lock_irqsave(&pool->lock, flags);
 
 
+       list_add(&page->page_list, &pool->page_list);
  ready:
        page->in_use++;
        offset = page->offset;
  ready:
        page->in_use++;
        offset = page->offset;
@@ -348,7 +334,6 @@ void *dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags,
 #ifdef DMAPOOL_DEBUG
        memset(retval, POOL_POISON_ALLOCATED, pool->size);
 #endif
 #ifdef DMAPOOL_DEBUG
        memset(retval, POOL_POISON_ALLOCATED, pool->size);
 #endif
- done:
        spin_unlock_irqrestore(&pool->lock, flags);
        return retval;
 }
        spin_unlock_irqrestore(&pool->lock, flags);
        return retval;
 }
@@ -435,8 +420,6 @@ void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t dma)
        page->in_use--;
        *(int *)vaddr = page->offset;
        page->offset = offset;
        page->in_use--;
        *(int *)vaddr = page->offset;
        page->offset = offset;
-       if (waitqueue_active(&pool->waitq))
-               wake_up_locked(&pool->waitq);
        /*
         * Resist a temptation to do
         *    if (!is_page_busy(page)) pool_free_page(pool, page);
        /*
         * Resist a temptation to do
         *    if (!is_page_busy(page)) pool_free_page(pool, page);