malloc.c

Go to the documentation of this file.

/*
 * \brief   Simple allocator implementation
 * \author  Christian Helmuth
 * \date    2006-10-30
 *
 * This simple allocator provides malloc() and free() using dm_mem dataspaces
 * as backing store. The actual list-based allocator implementation is from
 * l4util resp. Fiasco.
 *
 * For large allocations and slab-based OS-specific allocators
 * ddekit_large_malloc and ddekit_slab_*() should be used. The blocks
 * allocated via this allocator CANNOT be used for DMA or other device
 * operations, i.e., there exists no virt->phys mapping.
 *
 * FIXME check thread-safety and add locks where appropriate
 */

#include <l4/dde/ddekit/memory.h>
#include <l4/dde/ddekit/printf.h>
#include <l4/dde/ddekit/panic.h>

#include <l4/sys/consts.h>
#include <l4/util/list_alloc.h>
#include <l4/dm_mem/dm_mem.h>
#include <l4/lock/lock.h>

/* configuration */
#define ALLOC_SIZE     (4 * L4_PAGESIZE)

/* malloc pool is a list allocator */
static l4la_free_t *malloc_pool;
static l4lock_t     malloc_lock = L4LOCK_UNLOCKED;


/**
 * Allocate memory block via simple allocator
 *
 * \param size  block size
 * \return pointer to new memory block
 *
 * The blocks allocated via this allocator CANNOT be used for DMA or other
 * device operations, i.e., there exists no virt->phys mapping.
 *
 * Each chunk stores its size in the first word for free() to work.
 */
void *ddekit_simple_malloc(unsigned size)
{
        l4lock_lock(&malloc_lock);
        /* we store chunk size in the first word of the chunk */
        size += sizeof(unsigned);

        /* try to allocate */
        unsigned *p = l4la_alloc(&malloc_pool, size, 0);

        /* fill pool if allocation fails */
        if (!p) {
                /* size of allocated dataspace is at least ALLOC_SIZE */
                unsigned ds_size = l4_round_page(size);
                ds_size = (ds_size > ALLOC_SIZE) ? ds_size : ALLOC_SIZE;

                void *res = l4dm_mem_allocate_named(ds_size, L4RM_MAP, "ddekit malloc");
                if (!res) 
                        p = NULL;
                else
                {
                        l4la_free(&malloc_pool, res, ds_size);
                        p = l4la_alloc(&malloc_pool, size, 0);
                }
        }

        /* store chunk size */
        if (p) {
                *p = size;
                p++;
        }

        l4lock_unlock(&malloc_lock);
        return p;
}


/**
 * Free memory block via simple allocator
 *
 * \param p  pointer to memory block
 */
void ddekit_simple_free(void *p)
{
        l4lock_lock(&malloc_lock);
        unsigned *chunk = (unsigned *)p - 1;
        if (p)
                l4la_free(&malloc_pool, chunk, *chunk);
        l4lock_unlock(&malloc_lock);
}

---