Archipelago » qemu

/* This is the Linux kernel elf-loading code, ported into user space */

/* XXX: this code is not used as it is under the GPL license. Please

   remove or recode it */

//#define USE_ELF_LOADER

#ifdef USE_ELF_LOADER

/* should probably go in elf.h */

#ifndef ELIBBAD

#define ELIBBAD 80

#endif

#define ELF_START_MMAP 0x80000000

#define elf_check_arch(x) ( (x) == EM_SPARC )

/*

 * This structure is used to hold the arguments that are 

 * used when loading binaries.

 */

struct linux_binprm {

        char buf[128];

	int fd;

};

#define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE

#define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))

#define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))

static int prepare_binprm(struct linux_binprm *bprm)

    int retval;

    memset(bprm->buf, 0, sizeof(bprm->buf));

    retval = lseek(bprm->fd, 0L, SEEK_SET);

    if(retval >= 0) {

        retval = read(bprm->fd, bprm->buf, 128);

    }

    if(retval < 0) {

	perror("prepare_binprm");

	exit(-1);

	/* return(-errno); */

    }

    else {

	return(retval);

/* Best attempt to load symbols from this ELF object. */

static void load_symbols(struct elfhdr *hdr, int fd)

    unsigned int i;

    struct elf_shdr sechdr, symtab, strtab;

    char *strings;

    lseek(fd, hdr->e_shoff, SEEK_SET);

    for (i = 0; i < hdr->e_shnum; i++) {

	if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr))

	    return;

#ifdef BSWAP_NEEDED

	bswap_shdr(&sechdr);

#endif

	if (sechdr.sh_type == SHT_SYMTAB) {

	    symtab = sechdr;

	    lseek(fd, hdr->e_shoff

		  + sizeof(sechdr) * sechdr.sh_link, SEEK_SET);

	    if (read(fd, &strtab, sizeof(strtab))

		!= sizeof(strtab))

		return;

#ifdef BSWAP_NEEDED

	    bswap_shdr(&strtab);

#endif

	    goto found;

	}

    return; /* Shouldn't happen... */

 found:

    /* Now know where the strtab and symtab are.  Snarf them. */

    disas_symtab = qemu_malloc(symtab.sh_size);

    disas_strtab = strings = qemu_malloc(strtab.sh_size);

    if (!disas_symtab || !disas_strtab)

	return;

    lseek(fd, symtab.sh_offset, SEEK_SET);

    if (read(fd, disas_symtab, symtab.sh_size) != symtab.sh_size)

	return;

#ifdef BSWAP_NEEDED

    for (i = 0; i < symtab.sh_size / sizeof(struct elf_sym); i++)

	bswap_sym(disas_symtab + sizeof(struct elf_sym)*i);

#endif

    lseek(fd, strtab.sh_offset, SEEK_SET);

    if (read(fd, strings, strtab.sh_size) != strtab.sh_size)

	return;

    disas_num_syms = symtab.sh_size / sizeof(struct elf_sym);

static int load_elf_binary(struct linux_binprm * bprm, uint8_t *addr)

    struct elfhdr elf_ex;

    unsigned long startaddr = addr;

    int i;

    struct elf_phdr * elf_ppnt;

    struct elf_phdr *elf_phdata;

    elf_ex = *((struct elfhdr *) bprm->buf);          /* exec-header */

#ifdef BSWAP_NEEDED

    bswap_ehdr(&elf_ex);

#endif

    if (elf_ex.e_ident[0] != 0x7f ||

	strncmp(&elf_ex.e_ident[1], "ELF",3) != 0) {

	return  -ENOEXEC;

    }

    /* First of all, some simple consistency checks */

    if (! elf_check_arch(elf_ex.e_machine)) {

	return -ENOEXEC;

    }

    /* Now read in all of the header information */

    elf_phdata = (struct elf_phdr *)qemu_malloc(elf_ex.e_phentsize*elf_ex.e_phnum);

    if (elf_phdata == NULL) {

	return -ENOMEM;

    }

    retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET);

    if(retval > 0) {

	retval = read(bprm->fd, (char *) elf_phdata, 

				elf_ex.e_phentsize * elf_ex.e_phnum);

    }

    if (retval < 0) {

	perror("load_elf_binary");

	exit(-1);

	qemu_free (elf_phdata);

	return -errno;

    }

#ifdef BSWAP_NEEDED

    elf_ppnt = elf_phdata;

    for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) {

        bswap_phdr(elf_ppnt);

    }

#endif

    elf_ppnt = elf_phdata;

    /* Now we do a little grungy work by mmaping the ELF image into

     * the correct location in memory.  At this point, we assume that

     * the image should be loaded at fixed address, not at a variable

     * address.

     */

    for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {

        unsigned long error, offset, len;

	if (elf_ppnt->p_type != PT_LOAD)

            continue;

#if 0        

        error = target_mmap(TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr),

                            elf_prot,

                            (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),

                            bprm->fd,

                            (elf_ppnt->p_offset - 

                             TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));

#endif

	//offset = elf_ppnt->p_offset - TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr);

	offset = 0x4000;

	lseek(bprm->fd, offset, SEEK_SET);

	len = elf_ppnt->p_filesz + TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr);

	error = read(bprm->fd, addr, len); 

        if (error == -1) {

            perror("mmap");

            exit(-1);

        }

	addr += len;

    }

    qemu_free(elf_phdata);

    load_symbols(&elf_ex, bprm->fd);

    return addr-startaddr;

}

int elf_exec(const char * filename, uint8_t *addr)

{

        struct linux_binprm bprm;

        int retval;

        retval = open(filename, O_RDONLY);

        if (retval < 0)

            return retval;

        bprm.fd = retval;

        retval = prepare_binprm(&bprm);

        if(retval>=0) {

	    retval = load_elf_binary(&bprm, addr);

	}

	return retval;

#endif

static char saved_kfn[1024];

static uint32_t saved_addr;

static int magic_state;

    if (magic_state == 0) {

#ifdef USE_ELF_LOADER

        ret = elf_exec(saved_kfn, saved_addr);

#else

        ret = load_kernel(saved_kfn, (uint8_t *)saved_addr);

#endif

                    saved_kfn);

	magic_state = 1; /* No more magic */

    return ret;

void magic_init(const char *kfn, int kloadaddr)

    strcpy(saved_kfn, kfn);

    saved_addr = kloadaddr;

    magic_state = 0;

    magic_io_memory = cpu_register_io_memory(0, magic_mem_read, magic_mem_write, 0);

    cpu_register_physical_memory(0x20000000, 4,

                                 magic_io_memory);