util/mempool.c

Go to the documentation of this file.

#include <assert.h>
#include <debug.h>
#include <interrupt.h>
#include <mempool.h>
#include <physmem.h>
#include <util.h>
#include <stdint.h>

struct mem_pool_object {
        struct mem_pool_object  *next;
};

void mem_pool_init(struct mem_pool *pool, void *start, size_t size,
                size_t objsize, unsigned int align_order)
{
        struct mem_pool_object  *obj;
        struct mem_pool_object  *prev_obj;
        uintptr_t               aligned_start;
        unsigned int            offset;

        assert(pool);
        assert(start);
        assert((uintptr_t)start + size > (uintptr_t)start);

        aligned_start = round_up((uintptr_t)start, align_order);
        size -= (aligned_start - (uintptr_t)start);
        objsize = round_up(objsize, align_order);

        assert(objsize >= sizeof(struct mem_pool_object));
        assert(size >= objsize);

        obj = prev_obj = (void *)aligned_start;
        pool->freelist = obj;

        for (offset = objsize; (offset + objsize) <= size; offset += objsize) {
                obj = (void *)(aligned_start + offset);
                prev_obj->next = obj;
                prev_obj = obj;
        }
        obj->next = NULL;

        dbg_info("mempool @ %p initialized with %zu objects of size %zu\n",
                        start, size / objsize, objsize);
}

void mem_pool_init_physmem(struct mem_pool *mempool,
                struct physmem_pool *phys_pool, unsigned int nr_objects,
                size_t objsize, unsigned int align_order)
{
        phys_addr_t     pool_addr;
        size_t          pool_size;
        size_t          block_size;
        void            *pool_vaddr;

        assert(mempool);
        assert(phys_pool);
        assert(nr_objects > 0);

        block_size = round_up(objsize, align_order);
        pool_size = nr_objects * block_size;

        pool_addr = physmem_alloc(phys_pool, pool_size, align_order);
        assert(pool_addr != PHYSMEM_ALLOC_ERR);

        pool_vaddr = physmem_map(pool_addr, pool_size,
                        PHYS_MAP_WRBUF | PHYS_MAP_WRBACK);
        mem_pool_init(mempool, pool_vaddr, pool_size, objsize, align_order);
}

void *mem_pool_alloc(struct mem_pool *pool)
{
        struct mem_pool_object  *obj;
        unsigned long           iflags;

        assert(pool);

        iflags = cpu_irq_save();
        obj = pool->freelist;
        if (obj)
                pool->freelist = obj->next;
        cpu_irq_restore(iflags);

        return obj;
}

void mem_pool_free(struct mem_pool *pool, const void *obj)
{
        struct mem_pool_object  *free_obj;
        unsigned long           iflags;

        assert(pool);

        if (!obj)
                return;

        free_obj = (struct mem_pool_object *)obj;

        iflags = cpu_irq_save();
        free_obj->next = pool->freelist;
        pool->freelist = free_obj;
        cpu_irq_restore(iflags);
}

---