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 "console.h"
#include "execimage.h"
#include "mmu.h"
#include "malloc.h"


struct scheduler_thread* execimage(void* image, bool copy, int argc, const char* const* argv)
{
    int i;
    struct emcoreapp_header* header = (struct emcoreapp_header*)image;
    if (memcmp(header, "emCOexec", 8))
    {
        cprintf(CONSOLE_BOOT, "execimage: Bad signature: "
                              "%02X %02X %02X %02X %02X %02X %02X %02X\n",
                header->signature[0], header->signature[1], header->signature[2],
                header->signature[3], header->signature[4], header->signature[5],
                header->signature[6], header->signature[7]);
        if (!copy) free(image);
        return NULL;
    }
    if (header->version != EMCOREAPP_HEADER_VERSION)
    {
        cprintf(CONSOLE_BOOT, "execimage: Unsupported version! (%08X)\n", header->version);
        if (!copy) free(image);
        return NULL;
    }
    off_t offset = header->textstart;
    size_t textsize = header->textsize;
    size_t bsssize = header->bsssize;
    size_t stacksize = header->stacksize;
        off_t entrypoint = header->entrypoint;
        off_t relocstart = header->relocstart - offset;
        uint32_t reloccount = header->reloccount;
        bool compressed = header->flags & EMCOREAPP_FLAG_COMPRESSED;
        bool lib = header->flags & EMCOREAPP_FLAG_LIBRARY;
    uint32_t argsize = 0;
    if (argv)
        for (i = 0; i < argc; i++)
            argsize += 5 + strlen(argv[i]);
    else argc = 0;
    argsize = (argsize + 3) & ~3;
    size_t finalsize;
    if (lib) finalsize = textsize + bsssize;
    else finalsize = textsize + bsssize + argsize + stacksize;
    size_t datasize = relocstart + reloccount * 4;
    size_t tempsize = MAX(finalsize, datasize);
    if (compressed)
    {
        void* alloc = memalign(CACHEALIGN_SIZE, tempsize);
        if (!alloc)
        {
            cprintf(CONSOLE_BOOT, "execimage: Out of memory!\n");
            if (!copy) free(image);
            return NULL;
        }
        uint32_t decompsize;
        ucl_decompress(image + offset, datasize, alloc, &decompsize);
        if (!copy) free(image);
        if (datasize != decompsize)
        {
            cprintf(CONSOLE_BOOT, "execimage: Decompression failed!\n");
            free(alloc);
            return NULL;
        }
        image = alloc;
    }
    else if (copy || (((uint32_t)image) & (CACHEALIGN_SIZE - 1)))
    {
        void* alloc = memalign(CACHEALIGN_SIZE, tempsize);
        if (!alloc)
        {
            cprintf(CONSOLE_BOOT, "execimage: Out of memory!\n");
            if (!copy) free(image);
            return NULL;
        }
        memcpy(alloc, image + offset, datasize);
        if (!copy) free(image);
        image = alloc;
    }
    else
    {
        memcpy(image, image + offset, datasize);
        void* newimage = realign(image, CACHEALIGN_SIZE, tempsize);
        if (!newimage)
        {
            free(image);
            cprintf(CONSOLE_BOOT, "execimage: Out of memory!\n");
            return NULL;
        }
        else image = newimage;
    }
    for (; reloccount; reloccount--, relocstart += 4)
    {
        off_t reloc = *((off_t*)(image + relocstart));
        uint32_t data = *((uint32_t*)(image + reloc));
        *((void**)(image + reloc)) = image + data;
    }
    if (tempsize != finalsize) realloc(image, finalsize); /* Can only shrink => safe */
    void* ptr = image + textsize;
    memset(ptr, 0, bsssize);
    ptr += bsssize;
    void* argv_copy = ptr;
    if (argv)
    {
        memcpy(image + textsize + bsssize, argv, argc * 4);
        ptr += argc * 4;
        for (i = 0; i < argc; i++)
        {
            uint32_t len = strlen(argv[i]);
            memcpy(ptr, argv[i], len);
            ptr += len;
        }
    }
    ptr = (void*)(((int)ptr + 3) & ~3);
    clean_dcache();
    invalidate_icache();
    struct scheduler_thread* thread;
    if (lib)
        thread = (struct scheduler_thread*)library_register(image, image + entrypoint, argc, argv);
    else
    {
        thread = thread_create(NULL, NULL, image + entrypoint, ptr, stacksize,
                               USER_THREAD, 127, false, (void*)argc, argv_copy, NULL, NULL);
        if (thread)
        {
            reownalloc(image, OWNER_TYPE(OWNER_THREAD, thread));
            thread_resume(thread);
        }
        else free(image);
    }
    return thread;
}