Subversion Repositories or1k

/*

 *  linux/fs/binfmt_flat.c

 *

 *  Copyright (C) 1998  Kenneth Albanowski <kjahds@kjahds.com>

 *                      The Silver Hammer Group, Ltd.

 *

 *  This is a relatively simple binary format, intended solely to contain

 *  the bare minimum needed to load and execute simple binaries, with

 *  special attention to executing from ROM, when possible.

 *

 *  Originally based on:

 *

 *  linux/fs/binfmt_aout.c

 *

 *  Copyright (C) 1991, 1992, 1996  Linus Torvalds

 */

#include <linux/module.h>

#include <linux/fs.h>

#include <linux/sched.h>

#include <linux/kernel.h>

#include <linux/mm.h>

#include <linux/mman.h>

#include <linux/a.out.h>

#include <linux/errno.h>

#include <linux/signal.h>

#include <linux/string.h>

#include <linux/stat.h>

#include <linux/fcntl.h>

#include <linux/ptrace.h>

#include <linux/user.h>

#include <linux/malloc.h>

#include <linux/binfmts.h>

#include <linux/personality.h>

#include <asm/system.h>

#include <asm/segment.h>

#include <asm/pgtable.h>

#include <asm/flat.h>

#undef DEBUG

static int load_flat_binary(struct linux_binprm *, struct pt_regs * regs);

extern void dump_thread(struct pt_regs *, struct user *);

static struct linux_binfmt flat_format = {

#ifndef MODULE

        NULL, NULL, load_flat_binary, NULL, NULL

#else

        NULL, &mod_use_count_, load_flat_binary, NULL, NULL

#endif

};

static unsigned long putstring(unsigned long p, char * string)

{

        unsigned long l = strlen(string)+1;

#ifdef DEBUG

        printk("put_string '%s'\n", string);

#endif

        p -= l;

        memcpy((void*)p, string, l);

        return p;

}

static unsigned long putstringarray(unsigned long p, int count, char ** array)

{

        /*p=putstring(p, "");*/

        /*printk("p1=%x, array=%x\n", p, array);

        printk("array[0]=%x\n", array[0]);*/

#ifdef DEBUG

        printk("putstringarray(%d)\n", count);

#endif

        while(count) {

                p=putstring(p, array[--count]);

#ifdef DEBUG

                printk("p2=%x\n", p);

#endif

        }

        return p;

}

static unsigned long stringarraylen(int count, char ** array)

{

        int l = 4;

        while(count) {

                l += strlen(array[--count]);

                l++;

                l+=4;

        }

        return l;

}

/*

 * create_flat_tables() parses the env- and arg-strings in new user

 * memory and creates the pointer tables from them, and puts their

 * addresses on the "stack", returning the new stack pointer value.

 */

static unsigned long create_flat_tables(unsigned long pp, struct linux_binprm * bprm)

{

        unsigned long *argv,*envp;

        unsigned long * sp;

        char * p = (char*)pp;

        int argc = bprm->argc;

        int envc = bprm->envc;

        sp = (unsigned long *) ((-(unsigned long)sizeof(char *)) & (unsigned long) p);

#ifdef __alpha__

/* whee.. test-programs are so much fun. */

        put_user(0, --sp);

        put_user(0, --sp);

        if (bprm->loader) {

                put_user(0, --sp);

                put_user(0x3eb, --sp);

                put_user(bprm->loader, --sp);

                put_user(0x3ea, --sp);

        }

        put_user(bprm->exec, --sp);

        put_user(0x3e9, --sp);

#endif

        sp -= envc+1;

        envp = sp;

        sp -= argc+1;

        argv = sp;

#if defined(__i386__) || defined(__mc68000__)

        put_user(envp,--sp);

        put_user(argv,--sp);

#endif

        put_user(argc,--sp);

        current->mm->arg_start = (unsigned long) p;

        while (argc-->0) {

                put_user(p,argv++);

                while (get_user(p++)) /* nothing */ ;

        }

        put_user(NULL,argv);

        current->mm->arg_end = current->mm->env_start = (unsigned long) p;

        while (envc-->0) {

                put_user(p,envp++);

                while (get_user(p++)) /* nothing */ ;

        }

        put_user(NULL,envp);

        current->mm->env_end = (unsigned long) p;

        return (unsigned long)sp;

}

void do_reloc(struct flat_reloc * r)

{

        unsigned long * ptr = (unsigned long*)

                (current->mm->start_data + r->offset);

#ifdef DEBUG

        printk("Relocation of variable at DATASEG+%x (address %p, currently %x) into segment %x+%x\n",

                r->offset, ptr, *ptr, r->type, *ptr);

        printk("TEXTSEG=%x, DATASEG=%x, BSSSEG=%x\n",

                current->mm->start_code,

                current->mm->start_data,

                current->mm->end_data);

        printk("Relocation type = %d, offset = %d\n", r->type, r->offset);

#endif

        switch (r->type) {

        case FLAT_RELOC_TYPE_TEXT:

                *ptr += current->mm->start_code;

                break;

        case FLAT_RELOC_TYPE_DATA:

                *ptr += current->mm->start_data;

                break;

        case FLAT_RELOC_TYPE_BSS:

                *ptr += current->mm->end_data;

                break;

        default:

                printk("Unknown relocation\n");

        }

#ifdef DEBUG

        printk("Relocation became %x\n", *ptr);

#endif

}

/*

 * These are the functions used to load a.out style executables and shared

 * libraries.  There is no binary dependent code anywhere else.

 */

inline int

do_load_flat_binary(struct linux_binprm * bprm, struct pt_regs * regs)

{

        struct flat_hdr * hdr;

        struct file * file;

        unsigned long error;

        unsigned long pos;

        unsigned long p = bprm->p;

        unsigned long data_len, bss_len, stack_len, code_len;

        current->personality = PER_LINUX;

        file = current->files->fd[open_inode(bprm->inode, O_RDONLY)];

#ifdef DEBUG

        printk("BINFMT_FLAT: Loading file: %x\n", file);

        show_free_areas();

#endif

        hdr = (struct flat_hdr*)bprm->buf;

        if (strncmp(hdr->magic, "bFLT", 4) || (hdr->rev != 2)) {

                printk("bad magic/rev (%ld, need %d)\n", hdr->rev, 2);

                return -ENOEXEC;

        }

        if (flush_old_exec(bprm)) {

                printk("unable to flush\n");

                return -ENOMEM;

        }

        /*printk("hdr->entry = %d, hdr->data_start = %d, hdr->data_end = %d, hdr->bss_end = %d, hdr->stack_size = %d\n",

                hdr->entry, hdr->data_start, hdr->data_end,

                hdr->bss_end, hdr->stack_size);*/

        /* OK, This is the point of no return */

        code_len = hdr->data_start;

        data_len = hdr->data_end - hdr->data_start;

        bss_len = hdr->bss_end - hdr->data_end;

        stack_len = hdr->stack_size;

        /* Make room on stack for arguments & environment */

        stack_len += strlen(bprm->filename) + 1;

        stack_len += stringarraylen(bprm->envc, bprm->envp);

        stack_len += stringarraylen(bprm->argc, bprm->argv);

        /*stack_len += 4-((pos+data_len+bss_len+stack_len) & 3);*/ /* Align stack */

        /*printk("Stack = %d, (%d)\n", stack_len, stack_len & 3);*/

        error = do_mmap(file,

                0,

               code_len + data_len + bss_len + stack_len,

               PROT_READ|PROT_EXEC | ((hdr->flags & FLAT_FLAG_RAM) ? PROT_WRITE : 0),

               0);

        if (error >= -4096) {

          printk("Unable to map flat executable, errno %d\n", (int)-error);

          return error; /* Beyond point of no return? Oh well... */

        }

#ifdef DEBUG

        printk("BINFMT_FLAT: mmap returned: %x\n", error);

        show_free_areas();

#endif

        current->mm->executable = 0;

        if (is_in_rom(error)) {

                unsigned long result;

#ifdef DEBUG

                printk("BINFMT_FLAT: ROM mapping of file\n");

#endif

                /* do_mmap returned a ROM mapping, so allocate RAM for data + bss + stack */

                /*pos = kmalloc(data_len+bss_len+stack_len, GFP_KERNEL);*/

                pos = do_mmap(0, 0, data_len+bss_len+stack_len, PROT_READ|PROT_WRITE|PROT_EXEC, 0, 0);

                if (pos >= (unsigned long)-4096) {

                        printk("Unable to allocate RAM for process, errno %d\n", (int)-pos);

                        return pos;

                }

#ifdef DEBUG

                printk("BINFMT_FLAT: Allocated data+bss+stack (%d bytes): %x\n", data_len+bss_len+stack_len, pos);

                show_free_areas();

#endif

                /* And then fill it in */

                /*printk("Reading data from %d-%d to %x\n", hdr->data_start, hdr->data_end - hdr->data_start, pos);*/

                result = read_exec(bprm->inode, hdr->data_start, (char *)pos,

                          data_len, 0);

                if (result >= (unsigned long)-4096) {

                          do_munmap(pos, 0);

                          printk("Unable to read data+bss, errno %d\n", (int)-result);

                }

                /*printk("Clearing %x to %x\n", pos+data_len, pos+data_len+bss_len+stack_len);*/

                memset((void*)(pos + data_len), 0, bss_len + stack_len);

                if (bprm->inode->i_sb->s_flags & MS_SYNCHRONOUS) {

#ifdef DEBUG

                        printk("Retaining inode\n");

#endif

                        current->mm->executable = bprm->inode;

                        bprm->inode->i_count++;

                }

        } else {

#ifdef DEBUG

                printk("BINFMT_FLAT: RAM mapping of file\n");

#endif

                /* Since we got a RAM mapping, mmap has already allocated a block for us, and

                   read in the data. . */

                pos = error + code_len;

        }

#ifdef DEBUG

        printk("ROM mapping is %x, Entry point is %x, data_start is %x\n", error, hdr->entry, hdr->data_start);

#endif

        current->mm->start_code = error + hdr->entry;

        current->mm->end_code = error + hdr->data_start;

        current->mm->start_data = pos;

        current->mm->end_data = pos + data_len;

        current->mm->brk = pos + data_len + bss_len;

        /*printk("start_code: %x, end_code: %x\n", current->mm->start_code,current->mm->end_code);

        printk("start_data: %x, end_data: %x\n", current->mm->start_data,current->mm->end_data);*/

        /*printk("Loaded flat file, BSS=%x, DATA=%x, TEXT=%x\n",

                current->mm->end_data,

                current->mm->start_data,

                current->mm->start_code);*/

        if (is_in_rom(error)) {

                int r;

                for(r=0;r<hdr->reloc_count;r++) {

                        struct flat_reloc * reloc = (struct flat_reloc*)

                                (error + hdr->reloc_start + (sizeof(struct flat_reloc)*r));

                        do_reloc(reloc);

                }

        } else {

                int r;

                for(r=0;r<hdr->reloc_count;r++) {

                        struct flat_reloc reloc;

                        unsigned long result = read_exec(bprm->inode,

                                hdr->reloc_start + (sizeof(struct flat_reloc)*r),

                                (char *)&reloc,

                                sizeof(struct flat_reloc),

                                0);

                        if (result >= (unsigned long)-4096) {

                                printk("Failure reloading relocation\n");

                        } else

                                do_reloc(&reloc);

                }

        }

        current->mm->rss = 0;

        current->suid = current->euid = current->fsuid = bprm->e_uid;

        current->sgid = current->egid = current->fsgid = bprm->e_gid;

        current->flags &= ~PF_FORKNOEXEC;

        /*for(i=0;i<16;i++) {

                printk("%.2x ", ((char*)pos)[i] & 0xff);

        }

        printk("\n");*/

        if (current->exec_domain && current->exec_domain->use_count)

                (*current->exec_domain->use_count)--;

        if (current->binfmt && current->binfmt->use_count)

                (*current->binfmt->use_count)--;

        current->exec_domain = lookup_exec_domain(current->personality);

        current->binfmt = &flat_format;

        if (current->exec_domain && current->exec_domain->use_count)

                (*current->exec_domain->use_count)++;

        if (current->binfmt && current->binfmt->use_count)

                (*current->binfmt->use_count)++;

        /*set_brk(current->mm->start_brk, current->mm->brk);*/

        p = pos + data_len + bss_len + stack_len - 4;

#ifdef DEBUG

        printk("p=%x\n", p);

#endif

        p = putstringarray(p, 1, &bprm->filename);

#ifdef DEBUG

        printk("p(filename)=%x\n", p);

#endif

        p = putstringarray(p, bprm->envc, bprm->envp);

#ifdef DEBUG

        printk("p(envp)=%x\n", p);

#endif

        p = putstringarray(p, bprm->argc, bprm->argv);

#ifdef DEBUG

        printk("p(argv)=%x\n", p);

#endif

        p = create_flat_tables(p, bprm);

#ifdef DEBUG

        printk("p(create_flat_tables)=%x\n", p);

        printk("arg_start = %x\n", current->mm->arg_start);

        printk("arg_end = %x\n", current->mm->arg_end);

        printk("env_start = %x\n", current->mm->env_start);

        printk("env_end = %x\n", current->mm->env_end);

#endif

        current->mm->start_stack = p;

        /*printk("start_stack: %x\n", current->mm->start_stack);*/

        /*(*(volatile unsigned char *)0xdeadbee0) = 1;*/

#ifdef DEBUG    

        show_free_areas();

#endif

        start_thread(regs, current->mm->start_code /*, current->mm->start_data*/ /*- hdr->data_start*/, p);

        if (current->flags & PF_PTRACED)

                send_sig(SIGTRAP, current, 0);

        return 0;

}

static int

load_flat_binary(struct linux_binprm * bprm, struct pt_regs * regs)

{

        int retval;

        MOD_INC_USE_COUNT;

        retval = do_load_flat_binary(bprm, regs);

        MOD_DEC_USE_COUNT;

        return retval;

}

int init_flat_binfmt(void) {

        return register_binfmt(&flat_format);

}

#ifdef MODULE

int init_module(void) {

        return init_flat_binfmt();

}

void cleanup_module( void) {

        unregister_binfmt(&flat_format);

}

#endif