Subversion Repositories Kolibri OS

extern int __stdcall mnt_exec(void *raw, size_t raw_size, char *path,

              char *cmdline, u32_t flags) asm ("mnt_exec");

void * memcpy(void * _dest, const void *_src, size_t _n)

{

int d0, d1, d2;

 __asm__ __volatile__(

	"rep ; movsl\n\t"

	"testb $2,%b4\n\t"

	"je 1f\n\t"

	"movsw\n"

	"1:\ttestb $1,%b4\n\t"

	"je 2f\n\t"

	"movsb\n"

	"2:"

	: "=&c" (d0), "=&D" (d1), "=&S" (d2)

	:"0" (_n/4), "q" (_n),"1" ((long)_dest),"2" ((long)_src)

	: "memory");

 return (_dest);

}

size_t strlen(const char *str)

{

int d0;

register int __res;

__asm__ __volatile__(

	"repne\n\t"

	"scasb\n\t"

	"notl %0\n\t"

	"decl %0"

	:"=c" (__res), "=&D" (d0) :"1" (str),"a" (0), "0" (0xffffffff));

return __res;

}

typedef struct

{

    int a_type;

    union

    {

        long  a_val;

        void *a_ptr;

        void  (*a_fcn)( ) ;

    }a_un;

}auxv_t;

#define AUX_COUNT       0

typedef struct

{

    int     argc;       /*  always 2                                */

    char   *path;       /*  argv[0]   program path                  */

    char   *cmdline;    /*  argv[1]   command  line. May be null    */

    u32_t   sep1;       /*  separator.  must be zero                */

    char   *env;        /*  single environment string               */

    u32_t   sep2;       /*  separator.  must be zero                */

    auxv_t  aux[1];     /*  aux. AT_NULL for now                    */

}exec_stack_t;

addr_t new_app_space(void);

int __stdcall pe_app_param(char *path, void *raw, addr_t ex_pg_dir,

                          addr_t ex_stack_page) asm ("pe_app_param");

int sys_exec(char *path, char *cmdline, u32_t flags)

{

    addr_t        ex_pg_dir;

    addr_t        ex_stack_tab;

    addr_t        ex_stack_page;

    addr_t        ex_pl0_stack;

    exec_stack_t *ex_stack;

    int           stack_size;

    char         *ex_path;

    char         *ex_cmdline = NULL;

    size_t        raw_size;

    u32_t        *raw;

    int pathsize = 0;

    int cmdsize  = 0;

    int envsize  = 0;

    u32_t tmp;

    DBG("\nexec %s cmd %s flags %x\n", path, cmdline, flags);

    if( ! path)

    {

        DBG("invalid path\n");

        return;

    };

    raw = load_file(path, &raw_size);

    if( ! raw )

        return -5;                                      /* FIXME */

    if( (raw[0] == 0x554E454D) &&

        ( ( raw[1] == 0x31305445) ||

          ( raw[1] == 0x30305445) ) )

    {

        DBG("leagacy Kolibri application\n");

        int tmp =  mnt_exec(raw, raw_size, path, cmdline, flags);

        return tmp;

    }

    if( ! validate_pe(raw, raw_size) )

    {

        DBG("invalid executable file %s\n", path);

        mem_free(raw);

        return -31;

    }

    pathsize = strlen(path)+1;

    if( cmdline )

        cmdsize = strlen(cmdline)+1;

    stack_size = sizeof(exec_stack_t) + pathsize +

                 cmdsize + envsize + AUX_COUNT*sizeof(auxv_t);

    stack_size = (stack_size + 15) & ~15;               /* keep stack aligned */

    DBG("stacksize %d\n", stack_size);

    if( stack_size > 4096 )

    {

        DBG("command line too long\n");

        return -30;

    }

    ex_pg_dir      = new_app_space();

    if( !ex_pg_dir )

    {

        mem_free(raw);

        return -30;                                    /* FIXME          */

    };

    ex_stack_tab   = ex_pg_dir + 4096;

    ex_pl0_stack   = ex_pg_dir + 4096 * 2;

    ex_stack_page  = core_alloc(0);                    /* 2^0 = 1 page   */

    if( ! ex_stack_page )

    {

        core_free(ex_stack_tab);

        mem_free(raw);

        return -30;                                    /* FIXME          */

    };

    __asm__ __volatile__ (

    "xorl %%eax, %%eax      \n\t"

    "rep stosl"

    :"=c"(tmp),"=D"(tmp)

    :"c"(1024),"D"(ex_stack_page + OS_BASE)

    :"eax","cc");

    ((u32_t*)(ex_stack_tab+OS_BASE))[1023] = ex_stack_page | 7;

    ex_stack = (exec_stack_t*)(ex_stack_page + OS_BASE

                               + PAGE_SIZE - stack_size);

    ex_stack->argc = 2;

    ex_path = MakePtr(char*, ex_stack, sizeof(exec_stack_t)+AUX_COUNT*sizeof(auxv_t));

    memcpy(ex_path, path, pathsize);

    ex_stack->path = (char*)(((addr_t)ex_path & 0xFFF) + 0x7FCFF000);  /* top of stack */

    if( cmdline )

    {

        ex_cmdline = ex_path + pathsize;

        memcpy(ex_cmdline, cmdline, cmdsize);

        ex_stack->cmdline = ex_stack->path + pathsize;

    };

/*

    ex_stack.env = null

    ex_stack.aux[0] = AT_NULL

 */

    DBG("create stack at %x\n\tpath %x\n\tcmdline %x\n",

         ex_stack, ex_stack->path, ex_stack->cmdline);

    pe_app_param(path, raw, ex_pg_dir, ex_stack_page);

    return 0;

};

#define  master_tab    (page_tabs+ (page_tabs>>10))

void sys_app_entry(addr_t raw, addr_t ex_stack)

{

    PIMAGE_DOS_HEADER     dos;

    PIMAGE_NT_HEADERS32   nt;

    size_t   img_size;

    count_t  img_pages;

    count_t  img_tabs;

    count_t  i;

    u32_t    tmp;

    __asm__ __volatile__ ("sti");

    DBG("pe_app_entry: raw %x esp %x\n", raw, ex_stack);

    dos = (PIMAGE_DOS_HEADER)raw;

    nt =  MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);

    img_size  =  nt->OptionalHeader.SizeOfImage;

    img_pages = img_size >> 12;

    img_tabs  = ((img_size + 0x3FFFFF) & ~0x3FFFFF) >> 22;

    DBG("app pages %d app tabs %d\n", img_pages, img_tabs);

    for(i = 0; i < img_tabs; i++)

    {

        addr_t tab = core_alloc(0);

        ((u32_t*)master_tab)[i] = tab|7;                            /*   FIXME     */

    }

    ((u32_t*)master_tab)[0x7FC/4] = (ex_stack & 0xFFFFF000)|7;                                /*   FIXME     */

    __asm__ __volatile__ (

    "xorl %%eax, %%eax      \n\t"

    "rep stosl"

    :"=c"(tmp),"=D"(tmp)

    :"c"(img_tabs<<10),"D"(page_tabs)

    :"eax","cc");

    for(i = 0; i < img_pages; i++)

    {

        addr_t page = core_alloc(0);

        ((u32_t*)page_tabs)[i] = page | 7;                          /*   FIXME     */

    }

    create_image(0, raw);

    __asm__ __volatile__ (

    "xchgw %bx, %bx");

    addr_t entry = nt->OptionalHeader.AddressOfEntryPoint +

                   nt->OptionalHeader.ImageBase;

  //  __asm__ __volatile__ (

  //  "call %0":: "r" (entry));

    while(1);

};