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 "library.h"
#include "malloc.h"
#include "execimage.h"
#include "thread.h"
#ifdef HAVE_STORAGE
#include "file.h"
#include "dir.h"
#endif
#ifdef HAVE_BOOTFLASH
#include "bootflash.h"
#endif
#ifdef HAVE_BUTTON
#include "button.h"
#endif


struct library_handle* library_list_head;
struct mutex library_mutex;


struct library_handle* library_register(void* image, struct emcorelib_header* header)
{
    mutex_lock(&library_mutex, TIMEOUT_BLOCK);
    struct library_handle* h;
    for (h = library_list_head; h; h = h->next)
        if (h->lib->identifier == header->identifier && h->lib->version == header->version)
        {
            mutex_unlock(&library_mutex);
            return NULL;
        }
    if (header->initfunc && header->initfunc() < 0)
    {
        mutex_unlock(&library_mutex);
        return NULL;
    }
    struct library_handle* handle = (struct library_handle*)malloc(sizeof(struct library_handle));
    memset(handle, 0, sizeof(struct library_handle));
    reownalloc(handle, (struct scheduler_thread*)handle);
    reownalloc(image, (struct scheduler_thread*)handle);
    handle->next = library_list_head;
    handle->lib = header;
    handle->alloc = image;
    mutex_unlock(&library_mutex);
    return handle;
}

int library_unload(struct library_handle* lib)
{
    mutex_lock(&library_mutex, TIMEOUT_BLOCK);
    int i;
    bool found = false;
    struct library_handle* h;
    for (h = library_list_head; h; h = h->next)
        if (h == lib)
        {
            found = true;
            break;
        }
    if (!found)
    {
        mutex_unlock(&library_mutex);
        return -1;
    }
    for (i = 0; i < ARRAYLEN(lib->users); i++)
        if (lib->users[i])
        {
            mutex_unlock(&library_mutex);
            return -2;
        }
    if (lib->moreusers)
        for (i = 0; i < lib->moreusers_size / 4; i++)
            if (lib->moreusers[i])
            {
                mutex_unlock(&library_mutex);
                return -2;
            }
    if (lib->lib->shutdownfunc && lib->lib->shutdownfunc() < 0)
    {
        mutex_unlock(&library_mutex);
        return -3;
    }
    if (library_list_head == lib) library_list_head = lib->next;
    else
        for (h = library_list_head; h; h = h->next)
            if (h == lib)
            {
                h->next = lib->next;
                break;
            }
    library_release_all_of_thread((struct scheduler_thread*)lib);
#ifdef HAVE_STORAGE
    close_all_of_process((struct scheduler_thread*)lib);
    closedir_all_of_process((struct scheduler_thread*)lib);
#endif
#ifdef HAVE_BUTTON
    button_unregister_all_of_thread((struct scheduler_thread*)lib);
#endif
    free_all_of_thread((struct scheduler_thread*)lib);
    mutex_unlock(&library_mutex);
    return 0;
}

struct emcorelib_header* get_library_ext(uint32_t identifier, uint32_t minversion,
                                         uint32_t maxversion, enum library_sourcetype sourcetype,
                                         void* source, struct scheduler_thread* owner)
{
    int i;
    int version = minversion - 1;
    struct library_handle* h;
    struct library_handle* best = NULL;
    mutex_lock(&library_mutex, TIMEOUT_BLOCK);
    for (h = library_list_head; h; h = h->next)
        if (h->lib->identifier == identifier &&
            h->lib->version > version && h->lib->version <= maxversion)
        {
            best = h;
            version = h->lib->version;
            break;
        }
    if (!best)
    {
        mutex_unlock(&library_mutex);
        return NULL;
    }
    for (i = 0; i < ARRAYLEN(best->users); i++)
        if (best->users[i] == NULL)
        {
            best->users[i] = owner;
            mutex_unlock(&library_mutex);
            return best->lib;
        }
    if (best->moreusers)
        for (i = 0; i < best->moreusers_size / 4; i++)
            if (h->moreusers[i] == NULL)
                {
                    h->moreusers[i] = owner;
                    mutex_unlock(&library_mutex);
                    return best->lib;
                }
    void* newalloc = realloc(best->moreusers, best->moreusers_size + 64);
    if (!newalloc)
    {
        mutex_unlock(&library_mutex);
        return NULL;
    }
    best->moreusers = (void**)newalloc;
    best->moreusers[best->moreusers_size / 4] = owner;
    best->moreusers_size += 64;
    mutex_unlock(&library_mutex);
    return best->lib;
}

struct emcorelib_header* get_library(uint32_t identifier, uint32_t minversion, uint32_t maxversion,
                                     enum library_sourcetype sourcetype, void* source)
{
    return get_library_ext(identifier, minversion, maxversion, sourcetype, source, current_thread);
}

int release_library_ext(struct emcorelib_header* lib, struct scheduler_thread* owner)
{
    int i;
    int rc = -2;
    struct library_handle* h;
    mutex_lock(&library_mutex, TIMEOUT_BLOCK);
    for (h = library_list_head; h; h = h->next)
        if (h->lib == lib)
        {
            rc = -1;
            for (i = 0; i < ARRAYLEN(h->users); i++)
                if (h->users[i] == owner)
                {
                    h->users[i] = NULL;
                    rc = 0;
                    break;
                }
            if (rc && h->moreusers)
                for (i = 0; i < h->moreusers_size / 4; i++)
                    if (h->moreusers[i] == owner)
                        {
                            h->moreusers[i] = NULL;
                            rc = 0;
                            break;
                        }
            break;
        }
    mutex_unlock(&library_mutex);
    return rc;
}

int release_library(struct emcorelib_header* lib)
{
    return release_library_ext(lib, current_thread);
}

int library_release_all_of_thread(struct scheduler_thread* thread)
{
    mutex_lock(&library_mutex, TIMEOUT_BLOCK);
    int i;
    int released = 0;
    struct library_handle* h;
    for (h = library_list_head; h; h = h->next)
    {
        for (i = 0; i < ARRAYLEN(h->users); i++)
            if (h->users[i] == thread)
            {
                h->users[i] = NULL;
                released++;
            }
        if (h->moreusers)
            for (i = 0; i < h->moreusers_size / 4; i++)
                if (h->moreusers[i] == thread)
                    {
                        h->moreusers[i] = NULL;
                        released++;
                    }
    }
    mutex_unlock(&library_mutex);
    return released;
}