linux-imx

 * mempool_init - initialize a memory pool

 * @pool:      pointer to the memory pool that should be initialized

 * @min_nr:    the minimum number of elements guaranteed to be

 *             allocated for this pool.

 * @alloc_fn:  user-defined element-allocation function.

 * @free_fn:   user-defined element-freeing function.

 * @pool_data: optional private data available to the user-defined functions.

 *

 * Like mempool_create(), but initializes the pool in (i.e. embedded in another

 * structure).

 */

int mempool_init(mempool_t *pool, int min_nr, mempool_alloc_t *alloc_fn,

         mempool_free_t *free_fn, void *pool_data)

{

    return mempool_init_node(pool, min_nr, alloc_fn, free_fn,

                 pool_data, GFP_KERNEL, NUMA_NO_NODE);

​

}

EXPORT_SYMBOL(mempool_init);

​

 *             allocated for this pool.

 * @alloc_fn:  user-defined element-allocation function.

 * @free_fn:   user-defined element-freeing function.

 * @pool_data: optional private data available to the user-defined functions.

 *

 * this function creates and allocates a guaranteed size, preallocated

 * memory pool. The pool can be used from the mempool_alloc() and mempool_free()

 * functions. This function might sleep. Both the alloc_fn() and the free_fn()

 * functions might sleep - as long as the mempool_alloc() function is not called

 * from IRQ contexts.

 */

mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn,

                mempool_free_t *free_fn, void *pool_data)

{

    return mempool_create_node(min_nr,alloc_fn,free_fn, pool_data,

                   GFP_KERNEL, NUMA_NO_NODE);

}

EXPORT_SYMBOL(mempool_create);

​

mempool_t *mempool_create_node(int min_nr, mempool_alloc_t *alloc_fn,

 *              allocated for this pool.

 *

 * This function shrinks/grows the pool. In the case of growing,

 * it cannot be guaranteed that the pool will be grown to the new

 * size immediately, but new mempool_free() calls will refill it.

 * This function may sleep.

 *

 * Note, the caller must guarantee that no mempool_destroy is called

 * while this function is running. mempool_alloc() & mempool_free()

 * might be called (eg. from IRQ contexts) while this function executes.

 */

int mempool_resize(mempool_t *pool, int new_min_nr)

{

    void *element;

    void **new_elements;

    unsigned long flags;

​

    BUG_ON(new_min_nr <= 0);

    might_sleep();

​

 * mempool_alloc - allocate an element from a specific memory pool

 * @pool:      pointer to the memory pool which was allocated via

 *             mempool_create().

 * @gfp_mask:  the usual allocation bitmask.

 *

 * this function only sleeps if the alloc_fn() function sleeps or

 * returns NULL. Note that due to preallocation, this function

 * *never* fails when called from process contexts. (it might

 * fail if called from an IRQ context.)

 * Note: using __GFP_ZERO is not supported.

 */

void *mempool_alloc(mempool_t *pool, gfp_t gfp_mask)

{

    void *element;

    unsigned long flags;

    wait_queue_entry_t wait;

    gfp_t gfp_temp;

​

    VM_WARN_ON_ONCE(gfp_mask & __GFP_ZERO);

    might_sleep_if(gfp_mask & __GFP_DIRECT_RECLAIM);