Subversion Repositories freemyipod

//
//
//    Copyright 2010 TheSeven
//
//
//    This file is part of emCORE.
//
//    emCORE is free software: you can redistribute it and/or
//    modify it under the terms of the GNU General Public License as
//    published by the Free Software Foundation, either version 2 of the
//    License, or (at your option) any later version.
//
//    emCORE is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//    See the GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License along
//    with emCORE.  If not, see <http://www.gnu.org/licenses/>.
//
//


#include "global.h"
#include "malloc.h"
#include "libc/tlsf/tlsf.h"


extern char _poolstart;   // These aren't chars at all, but gcc complains about void types being
extern char _poolend;     // used here, and we only need the address, so just make it happy...

struct mutex malloc_mutex;
tlsf_pool global_mallocpool;


void* malloc(size_t size)
{
    mutex_lock(&malloc_mutex, TIMEOUT_BLOCK);
    void* ptr = tlsf_malloc(global_mallocpool, size + 4);
    if (ptr)
    {
        size = tlsf_block_size(ptr);
        *((struct scheduler_thread**)(ptr + size - 4)) = current_thread;
    }
    DEBUGF("malloc(%08X) => %08X (thread: %08X)", size, ptr, current_thread);
    mutex_unlock(&malloc_mutex);
    return ptr;
}

void* memalign(size_t align, size_t size)
{
    mutex_lock(&malloc_mutex, TIMEOUT_BLOCK);
    void* ptr = tlsf_memalign(global_mallocpool, align, size + 4);
    if (ptr)
    {
        size = tlsf_block_size(ptr);
        *((struct scheduler_thread**)(ptr + size - 4)) = current_thread;
    }
    DEBUGF("memalign(%X, %08X) => %08X (thread: %08X)", align, size, ptr, current_thread);
    mutex_unlock(&malloc_mutex);
    return ptr;
}

void* realign(void* ptr, size_t align, size_t size)
{
    mutex_lock(&malloc_mutex, TIMEOUT_BLOCK);
    size_t oldsize = tlsf_block_size(ptr);
    struct scheduler_thread* owner = *((struct scheduler_thread**)(ptr + oldsize - 4));
    void* ptr_new = tlsf_realign(global_mallocpool, ptr, align, size + 4);
    if (ptr_new)
    {
        size = tlsf_block_size(ptr_new);
        *((struct scheduler_thread**)(ptr_new + size - 4)) = owner;
    }
    DEBUGF("realign(%08X, %X, %08X) => %08X (old size: %08X, owner: %08X, thread: %08X)",
           ptr, align, size, ptr_new, owner, current_thread);
    mutex_unlock(&malloc_mutex);
    return ptr_new;
}

void* realloc(void* ptr, size_t size)
{
    return realign(ptr, 4, size);
}

void reownalloc(void* ptr, struct scheduler_thread* owner)
{
    mutex_lock(&malloc_mutex, TIMEOUT_BLOCK);
    size_t size = tlsf_block_size(ptr);
    DEBUGF("reownalloc(%08X, %08X) (size: %08X, old owner: %08X, thread: %08X)",
           ptr, owner, size, *((struct scheduler_thread**)(ptr + size - 4)), current_thread);
    *((struct scheduler_thread**)(ptr + size - 4)) = owner;
    mutex_unlock(&malloc_mutex);
}

void free(void* ptr)
{
    mutex_lock(&malloc_mutex, TIMEOUT_BLOCK);
    size_t size = tlsf_block_size(ptr);
    DEBUGF("free(%08X) (size: %08X, owner: %08X, thread: %08X)", ptr, size,
           *((struct scheduler_thread**)(ptr + size - 4)), current_thread);
    tlsf_free(global_mallocpool, ptr);
    mutex_unlock(&malloc_mutex);
}

void free_if_thread(void* ptr, size_t size, int used, void* owner)
{
    if (*((void**)(ptr + size - 4)) == owner) free(ptr);
}

void free_all_of_thread(struct scheduler_thread* owner)
{
    mutex_lock(&malloc_mutex, TIMEOUT_BLOCK);
    DEBUGF("free_all_of_thread(%08X) (thread: %08X)", owner, current_thread);
    tlsf_walk_heap(global_mallocpool, free_if_thread, owner);
    mutex_unlock(&malloc_mutex);
}

void malloc_walk(void (*walker), void* user)
{
    mutex_lock(&malloc_mutex, TIMEOUT_BLOCK);
    tlsf_walk_heap(global_mallocpool, walker, user);
    mutex_unlock(&malloc_mutex);
}

void malloc_lock()
{
    mutex_lock(&malloc_mutex, TIMEOUT_BLOCK);
}

void malloc_unlock()
{
    mutex_unlock(&malloc_mutex);
}

void malloc_init()
{
    mutex_init(&malloc_mutex);
    global_mallocpool = tlsf_create(&_poolstart, &_poolend - &_poolstart);
}