/*
* ELF-loader for ARM systems.
*
* We are currently running out of physical memory, with an ELF file for the
* kernel and one or more ELF files for the userspace image. (Typically there
* will only be one userspace ELF file, though if we are running a multi-core
* CPU, we may have multiple userspace images; one per CPU.) These ELF files
* are packed into an 'ar' archive.
*
* The kernel ELF file indicates what physical address it wants to be loaded
* at, while userspace images run out of virtual memory, so don't have any
* requirements about where they are located. We place the kernel at its
* desired location, and then load userspace images straight after it in
* physical memory.
*
* Several things could possibly go wrong:
*
* 1. The physical load address of the kernel might want to overwrite this
* ELF-loader;
*
* 2. The physical load addresses of the kernel might not actually be in
* physical memory;
*
* 3. Userspace images may not fit in physical memory, or may try to overlap
* the ELF-loader.
*
* We attempt to check for some of these, but some may go unnoticed.
*/
void load_images(struct image_info *kernel_info, struct image_info *user_info,
int max_user_images, int *num_images)
{
int i;
uint64_t kernel_phys_start, kernel_phys_end;
paddr_t next_phys_addr;
const char *elf_filename;
unsigned long unused;
/* Load kernel. */
void *kernel_elf = cpio_get_file(_archive_start, "kernel.elf", &unused);
if (kernel_elf == NULL) {
printf("No kernel image present in archive!\n");
abort();
}
if (elf_checkFile(kernel_elf)) {
printf("Kernel image not a valid ELF file!\n");
abort();
}
elf_getMemoryBounds(kernel_elf, 1, &kernel_phys_start, &kernel_phys_end);
next_phys_addr = load_elf("kernel", kernel_elf,
(paddr_t)kernel_phys_start, kernel_info);
/*
* Load userspace images.
*
* We assume (and check) that the kernel is the first file in the archive,
* and then load the (n+1)'th file in the archive onto the (n)'th CPU.
*/
(void)cpio_get_entry(_archive_start, 0, &elf_filename, &unused);
if (strcmp(elf_filename, "kernel.elf") != 0) {
printf("Kernel image not first image in archive.\n");
abort();
}
*num_images = 0;
for (i = 0; i < max_user_images; i++) {
/* Fetch info about the next ELF file in the archive. */
void *user_elf = cpio_get_entry(_archive_start, i + 1,
&elf_filename, &unused);
if (user_elf == NULL) {
break;
}
/* Load the file into memory. */
next_phys_addr = load_elf(elf_filename, user_elf,
next_phys_addr, &user_info[*num_images]);
*num_images = i + 1;
}
}
/* Boot PROM (OpenBIOS) */
static void prom_init(hwaddr addr, const char *bios_name)
{
DeviceState *dev;
SysBusDevice *s;
char *filename;
int ret;
dev = qdev_create(NULL, "openprom");
qdev_init_nofail(dev);
s = SYS_BUS_DEVICE(dev);
sysbus_mmio_map(s, 0, addr);
/* load boot prom */
if (bios_name == NULL) {
bios_name = PROM_FILENAME;
}
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
if (filename) {
ret = load_elf(filename, translate_prom_address, &addr,
NULL, NULL, NULL, 1, ELF_MACHINE, 0);
if (ret < 0 || ret > PROM_SIZE_MAX) {
ret = load_image_targphys(filename, addr, PROM_SIZE_MAX);
}
g_free(filename);
} else {
ret = -1;
}
if (ret < 0 || ret > PROM_SIZE_MAX) {
fprintf(stderr, "qemu: could not load prom '%s'\n", bios_name);
exit(1);
}
}
int
create_map(int elf_fd, char *out_name)
{
unsigned long elf_size;
int out_fd;
char page[PAGESIZE],
* elfmag = ELFMAG,
* elf_image;
Elf32_Ehdr * ehdr;
Elf32_Phdr * phdr;
if ((out_fd = open(out_name, O_RDWR|O_CREAT, 0600)) == -1)
fatal("Couldn't open output file");
if (read(elf_fd, page, sizeof(page)) != sizeof(page))
fatal("read of test failed");
ehdr = (Elf32_Ehdr *)page;
if (memcmp(ehdr->e_ident, elfmag, SELFMAG))
return (-1);
/* We need the program headers to create the memory image */
phdr = (Elf32_Phdr *)(page + ehdr->e_phoff);
if ((elf_size = load_elf(elf_fd, ehdr, phdr, &elf_image)) < 0 )
fatal ("Humungous error loading ELF binary");
if (dump_it(elf_image, elf_size) < 0)
fatal("dumping the file failed");
if (write(out_fd, elf_image, elf_size) != elf_size)
fatal("didn't work");
return (0);
}
static void load_kernel (CPUState *env)
{
int64_t entry, kernel_low, kernel_high;
long kernel_size, initrd_size;
ram_addr_t initrd_offset;
kernel_size = load_elf(loaderparams.kernel_filename, VIRT_TO_PHYS_ADDEND,
(uint64_t *)&entry, (uint64_t *)&kernel_low,
(uint64_t *)&kernel_high);
if (kernel_size >= 0) {
if ((entry & ~0x7fffffffULL) == 0x80000000)
entry = (int32_t)entry;
env->active_tc.PC = entry;
} else {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
loaderparams.kernel_filename);
exit(1);
}
/* load initrd */
initrd_size = 0;
initrd_offset = 0;
if (loaderparams.initrd_filename) {
initrd_size = get_image_size (loaderparams.initrd_filename);
if (initrd_size > 0) {
initrd_offset = (kernel_high + ~TARGET_PAGE_MASK) & TARGET_PAGE_MASK;
if (initrd_offset + initrd_size > ram_size) {
fprintf(stderr,
"qemu: memory too small for initial ram disk '%s'\n",
loaderparams.initrd_filename);
exit(1);
}
initrd_size = load_image(loaderparams.initrd_filename,
phys_ram_base + initrd_offset);
}
if (initrd_size == (target_ulong) -1) {
fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
loaderparams.initrd_filename);
exit(1);
}
}
/* Store command line. */
if (initrd_size > 0) {
int ret;
ret = sprintf((char *)(phys_ram_base + (16 << 20) - 256),
"rd_start=0x" TARGET_FMT_lx " rd_size=%li ",
PHYS_TO_VIRT((uint32_t)initrd_offset),
initrd_size);
strcpy ((char *)(phys_ram_base + (16 << 20) - 256 + ret),
loaderparams.kernel_cmdline);
}
else {
strcpy ((char *)(phys_ram_base + (16 << 20) - 256),
loaderparams.kernel_cmdline);
}
*(int32_t *)(phys_ram_base + (16 << 20) - 260) = tswap32 (0x12345678);
*(int32_t *)(phys_ram_base + (16 << 20) - 264) = tswap32 (ram_size);
}
static int
loadprog(int *addrp, struct prog *p)
{
#if DEBUG
if (debug)
printf("loadprog(%s)\n", p->name);
#endif
if (openrd(p->name, &p->basename)) {
printf("Can't find %s\n", p->name);
usage();
return 1;
}
printf("Loading %cd(%d,%c)%s\n",
dev, unit, 'a'+ part, p->basename);
if (load_elf(p->name, addrp, regions)) {
return 1;
}
p->sym_start = sym_start;
p->sym_size = *addrp - sym_start;
p->args_start = *addrp;
pcpy(p->args, (void *) p->args_start, p->args_size);
*addrp = align((*addrp) + p->args_size);
return 0;
}
static void an5206_init(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
CPUState *env;
int kernel_size;
uint64_t elf_entry;
target_phys_addr_t entry;
MemoryRegion *address_space_mem = get_system_memory();
MemoryRegion *ram = g_new(MemoryRegion, 1);
MemoryRegion *sram = g_new(MemoryRegion, 1);
if (!cpu_model)
cpu_model = "m5206";
env = cpu_init(cpu_model);
if (!env) {
hw_error("Unable to find m68k CPU definition\n");
}
/* Initialize CPU registers. */
env->vbr = 0;
/* TODO: allow changing MBAR and RAMBAR. */
env->mbar = AN5206_MBAR_ADDR | 1;
env->rambar0 = AN5206_RAMBAR_ADDR | 1;
/* DRAM at address zero */
memory_region_init_ram(ram, NULL, "an5206.ram", ram_size);
memory_region_add_subregion(address_space_mem, 0, ram);
/* Internal SRAM. */
memory_region_init_ram(sram, NULL, "an5206.sram", 512);
memory_region_add_subregion(address_space_mem, AN5206_RAMBAR_ADDR, sram);
mcf5206_init(AN5206_MBAR_ADDR, env);
/* Load kernel. */
if (!kernel_filename) {
fprintf(stderr, "Kernel image must be specified\n");
exit(1);
}
kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry,
NULL, NULL, 1, ELF_MACHINE, 0);
entry = elf_entry;
if (kernel_size < 0) {
kernel_size = load_uimage(kernel_filename, &entry, NULL, NULL);
}
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename, KERNEL_LOAD_ADDR,
ram_size - KERNEL_LOAD_ADDR);
entry = KERNEL_LOAD_ADDR;
}
if (kernel_size < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n", kernel_filename);
exit(1);
}
env->pc = entry;
}
static void cpu_openrisc_load_kernel(ram_addr_t ram_size,
const char *kernel_filename,
OpenRISCCPU *cpu)
{
long kernel_size;
uint64_t elf_entry;
hwaddr entry;
if (kernel_filename && !qtest_enabled()) {
kernel_size = load_elf(kernel_filename, NULL, NULL,
&elf_entry, NULL, NULL, 1, ELF_MACHINE, 1);
entry = elf_entry;
if (kernel_size < 0) {
kernel_size = load_uimage(kernel_filename,
&entry, NULL, NULL);
}
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename,
KERNEL_LOAD_ADDR,
ram_size - KERNEL_LOAD_ADDR);
entry = KERNEL_LOAD_ADDR;
}
if (kernel_size < 0) {
qemu_log("QEMU: couldn't load the kernel '%s'\n",
kernel_filename);
exit(1);
}
}
cpu->env.pc = entry;
}
static void openrisc_load_kernel(ram_addr_t ram_size,
const char *kernel_filename)
{
long kernel_size;
uint64_t elf_entry;
hwaddr entry;
if (kernel_filename && !qtest_enabled()) {
kernel_size = load_elf(kernel_filename, NULL, NULL,
&elf_entry, NULL, NULL, 1, EM_OPENRISC,
1, 0);
entry = elf_entry;
if (kernel_size < 0) {
kernel_size = load_uimage(kernel_filename,
&entry, NULL, NULL, NULL, NULL);
}
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename,
KERNEL_LOAD_ADDR,
ram_size - KERNEL_LOAD_ADDR);
}
if (entry <= 0) {
entry = KERNEL_LOAD_ADDR;
}
if (kernel_size < 0) {
error_report("couldn't load the kernel '%s'", kernel_filename);
exit(1);
}
boot_info.bootstrap_pc = entry;
}
}
void cris_load_image(CRISCPU *cpu, struct cris_load_info *li)
{
CPUCRISState *env = &cpu->env;
uint64_t entry, high;
int kcmdline_len;
int image_size;
env->load_info = li;
/* Boots a kernel elf binary, os/linux-2.6/vmlinux from the axis
devboard SDK. */
image_size = load_elf(li->image_filename, translate_kernel_address, NULL,
&entry, NULL, &high, 0, ELF_MACHINE, 0);
li->entry = entry;
if (image_size < 0) {
/* Takes a kimage from the axis devboard SDK. */
image_size = load_image_targphys(li->image_filename, 0x40004000,
ram_size);
li->entry = 0x40004000;
}
if (image_size < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
li->image_filename);
exit(1);
}
if (li->cmdline && (kcmdline_len = strlen(li->cmdline))) {
if (kcmdline_len > 256) {
fprintf(stderr, "Too long CRIS kernel cmdline (max 256)\n");
exit(1);
}
pstrcpy_targphys("cmdline", 0x40000000, 256, li->cmdline);
}
qemu_register_reset(main_cpu_reset, cpu);
}
void load_ramdisk_app(uint32_t appIdx)
{
/*
* ramdisk.img is already loaded to 0x3000000 by the bootloader.
* load_ramdisk_img create ramdisk file system.
*/
char *app_load_addr;
char temp[16];
struct file *fp;
if (appIdx >= MAX_USR_TASK) {
xil_printf("err: user task idx overflow\n");
return;
}
app_load_addr = (char *)(USER_APP_BASE +
APP_LOAD_OFFSET +
USER_APP_GAP * appIdx);
sprintf(temp,"App_%u", (unsigned int)appIdx);
fp = find_file_by_name(temp);
if (fp) {
read(fp, fp->fsz, app_load_addr);
load_elf(app_load_addr, appIdx);
}
}
void *
mc_dlopen(const char *path)
{
struct ext_host *host;
if ((host = mc_calloc(1, sizeof(struct ext_host))) == NULL) {
errno = ENOMEM;
return NULL;
}
#if XIP && !XS_ARCHIVE
/* first look up the linked list */
if ((host->ext = mc_lookup_module(path)) != NULL)
return host;
#endif
if (load_elf(path, &host->base, &host->ext) != 0) {
mc_free(host);
return NULL;
}
#if MC_NUM_XREF > 0
if (host->ext->xrefs != NULL) {
int i;
struct mc_extension *ext = host->ext;
for (i = 0; i < ext->num_xrefs; i++) {
struct mc_xref *xref = &ext->xrefs[i];
xref_stubs[xref->fnum] = xref->fp;
}
}
#endif
return host;
}
static unsigned long sun4u_load_kernel(const char *kernel_filename,
const char *initrd_filename,
ram_addr_t RAM_size, long *initrd_size)
{
int linux_boot;
unsigned int i;
long kernel_size;
linux_boot = (kernel_filename != NULL);
kernel_size = 0;
if (linux_boot) {
int bswap_needed;
#ifdef BSWAP_NEEDED
bswap_needed = 1;
#else
bswap_needed = 0;
#endif
kernel_size = load_elf(kernel_filename, 0, NULL, NULL, NULL,
1, ELF_MACHINE, 0);
if (kernel_size < 0)
kernel_size = load_aout(kernel_filename, KERNEL_LOAD_ADDR,
RAM_size - KERNEL_LOAD_ADDR, bswap_needed,
TARGET_PAGE_SIZE);
if (kernel_size < 0)
kernel_size = load_image_targphys(kernel_filename,
KERNEL_LOAD_ADDR,
RAM_size - KERNEL_LOAD_ADDR);
if (kernel_size < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
kernel_filename);
exit(1);
}
/* load initrd */
*initrd_size = 0;
if (initrd_filename) {
*initrd_size = load_image_targphys(initrd_filename,
INITRD_LOAD_ADDR,
RAM_size - INITRD_LOAD_ADDR);
if (*initrd_size < 0) {
fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
initrd_filename);
exit(1);
}
}
if (*initrd_size > 0) {
for (i = 0; i < 64 * TARGET_PAGE_SIZE; i += TARGET_PAGE_SIZE) {
if (ldl_phys(KERNEL_LOAD_ADDR + i) == 0x48647253) { // HdrS
stl_phys(KERNEL_LOAD_ADDR + i + 16, INITRD_LOAD_ADDR);
stl_phys(KERNEL_LOAD_ADDR + i + 20, *initrd_size);
break;
}
}
}
}
return kernel_size;
}
//
// Creates a new env running a specific binary.
// The new env's parent ID is set to 0.
// The implementation is a simple wrapper around env_alloc and load_elf.
//
void
env_create(uint8_t *binary, size_t size)
{
struct Env *e;
if(env_alloc(&e, 0))
panic("env_create: Environment allocation failed");
load_elf(e, binary, size);
}
static void dump_elf(const char *memblock)
{
struct elf_t *elf = load_elf(memblock);
elf_dynamic(elf, &need, &provide);
if (ids)
elf_build_id(elf, &build_id);
}
int
do_exec(const char *elf_path, int argc, char *argv[], char **envp)
{
int err;
int fd;
struct stat st;
char *data;
if ((err = do_access(elf_path, X_OK)) < 0) {
return err;
}
if ((fd = vkern_open(elf_path, LINUX_O_RDONLY, 0)) < 0) {
return fd;
}
if (proc.nr_tasks > 1) {
warnk("Multi-thread execve is not implemented yet\n");
return -LINUX_EINVAL;
}
/* Now do exec */
fstat(fd, &st);
if (!S_ISREG(st.st_mode)) {
vkern_close(fd);
return -LINUX_EACCES;
}
prepare_newproc();
data = mmap(0, st.st_size, PROT_READ | PROT_EXEC, MAP_PRIVATE, fd, 0);
vkern_close(fd);
drop_privilege();
if (4 <= st.st_size && memcmp(data, ELFMAG, 4) == 0) {
if ((err = load_elf((Elf64_Ehdr *) data, argc, argv, envp)) < 0)
return err;
if (st.st_mode & 04000) {
elevate_privilege();
}
}
else if (2 <= st.st_size && data[0] == '#' && data[1] == '!') {
if ((err = load_script(data, st.st_size, elf_path, argc, argv, envp)) < 0)
return err;
}
/*else if (4 <= st.st_size && memcmp(data, "\xcf\xfa\xed\xfe", 4) == 0) {
// Mach-O
return syswrap(execve(elf_path, argv, envp));
}*/
else {
return -LINUX_ENOEXEC; /* unsupported file type */
}
munmap(data, st.st_size);
proc.mm->current_brk = proc.mm->start_brk;
return 0;
}
int
runprogram(char *progname)
{
struct addrspace *as;
struct vnode *v;
vaddr_t entrypoint, stackptr;
int result;
/* Open the file. */
result = vfs_open(progname, O_RDONLY, 0, &v);
if (result) {
return result;
}
/* We should be a new process. */
KASSERT(curproc_getas() == NULL);
/* Create a new address space. */
#if OPT_A3
as = as_create(progname);
#else
as = as_create();
#endif
if (as ==NULL) {
vfs_close(v);
return ENOMEM;
}
/* Switch to it and activate it. */
curproc_setas(as);
as_activate();
/* Load the executable. */
result = load_elf(v, &entrypoint);
if (result) {
/* p_addrspace will go away when curproc is destroyed */
vfs_close(v);
return result;
}
/* Done with the file now. */
vfs_close(v);
/* Define the user stack in the address space */
result = as_define_stack(as, &stackptr);
if (result) {
/* p_addrspace will go away when curproc is destroyed */
return result;
}
/* Warp to user mode. */
enter_new_process(0 /*argc*/, NULL /*userspace addr of argv*/,
stackptr, entrypoint);
/* enter_new_process does not return. */
panic("enter_new_process returned\n");
return EINVAL;
}
/*
* Load program "progname" and start running it in usermode.
* Does not return except on error.
*
* Calls vfs_open on progname and thus may destroy it.
*/
int
runprogram(char *progname)
{
struct vnode *v;
vaddr_t entrypoint, stackptr;
int result;
/* Open the file. */
result = vfs_open(progname, O_RDONLY, 0, &v);
if (result) {
return result;
}
/* We should be a new thread. */
KASSERT(curthread->t_addrspace == NULL);
/* Create a new address space. */
curthread->t_addrspace = as_create();
if (curthread->t_addrspace==NULL) {
vfs_close(v);
return ENOMEM;
}
curthread->t_filetable = filetable_create();
if(curthread->t_filetable == NULL){
return ENOMEM;
}
/* Activate it. */
as_activate(curthread->t_addrspace);
/* Load the executable. */
result = load_elf(v, &entrypoint);
if (result) {
/* thread_exit destroys curthread->t_addrspace */
vfs_close(v);
return result;
}
/* Done with the file now. */
vfs_close(v);
/* Define the user stack in the address space */
result = as_define_stack(curthread->t_addrspace, &stackptr);
if (result) {
/* thread_exit destroys curthread->t_addrspace */
return result;
}
/* Warp to user mode. */
enter_new_process(0 /*argc*/, NULL /*userspace addr of argv*/,
stackptr, entrypoint);
/* enter_new_process does not return. */
panic("enter_new_process returned\n");
return EINVAL;
}
int boxer_main(int argc, char *argv[])
{
int ret;
uintptr_t sp;
struct elf_data data;
if (argc < 2)
return -EINVAL;
/* XXX needed. Probably does some libc stuff */
printf(" \b");
// printf("%s\n", environ[0]);
ret = dune_init(0);
if (ret) {
printf("sandbox: failed to initialize Dune\n");
return ret;
}
ret = dune_enter();
if (ret) {
printf("sandbox: failed to enter Dune mode\n");
return ret;
}
ret = load_elf(argv[1], &data);
if (ret)
return ret;
// printf("sandbox: entry addr is %lx\n", data.entry);
dune_set_user_fs(0); // default starting fs
ret = trap_init();
if (ret) {
printf("failed to initialize trap handlers\n");
return ret;
}
ret = umm_alloc_stack(&sp);
if (ret) {
printf("failed to alloc stack\n");
return ret;
}
sp = setup_arguments(sp, argv[1], &argv[2], environ, data);
if (!sp) {
printf("failed to setup arguments\n");
return -EINVAL;
}
ret = run_app(sp, data.entry);
return ret;
}
static void an5206_init(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
CPUState *env;
int kernel_size;
uint64_t elf_entry;
target_ulong entry;
if (!cpu_model)
cpu_model = "m5206";
env = cpu_init(cpu_model);
if (!env) {
hw_error("Unable to find m68k CPU definition\n");
}
/* Initialize CPU registers. */
env->vbr = 0;
/* TODO: allow changing MBAR and RAMBAR. */
env->mbar = AN5206_MBAR_ADDR | 1;
env->rambar0 = AN5206_RAMBAR_ADDR | 1;
/* DRAM at address zero */
cpu_register_physical_memory(0, ram_size,
qemu_ram_alloc(ram_size) | IO_MEM_RAM);
/* Internal SRAM. */
cpu_register_physical_memory(AN5206_RAMBAR_ADDR, 512,
qemu_ram_alloc(512) | IO_MEM_RAM);
mcf5206_init(AN5206_MBAR_ADDR, env);
/* Load kernel. */
if (!kernel_filename) {
fprintf(stderr, "Kernel image must be specified\n");
exit(1);
}
kernel_size = load_elf(kernel_filename, 0, &elf_entry, NULL, NULL);
entry = elf_entry;
if (kernel_size < 0) {
kernel_size = load_uimage(kernel_filename, &entry, NULL, NULL);
}
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename, KERNEL_LOAD_ADDR,
ram_size - KERNEL_LOAD_ADDR);
entry = KERNEL_LOAD_ADDR;
}
if (kernel_size < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n", kernel_filename);
exit(1);
}
env->pc = entry;
}
void boot_loader()
{
// load program named "boot"
long phdrs[128];
current.phdr = (uintptr_t)phdrs;
current.phdr_size = sizeof(phdrs);
load_elf("vmlinux", ¤t);
run_loaded_program();
}
static void dummy_ppc_init(ram_addr_t ram_size, int vga_ram_size,
const char *boot_device, DisplayState *ds,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
CPUState *env;
int kernel_size;
uint64_t elf_entry;
target_ulong entry;
if (!cpu_model)
cpu_model = "default";
env = cpu_init(cpu_model);
if (!env) {
fprintf(stderr, "Unable to find ppc CPU definition\n");
exit(1);
}
cpu_ppc_tb_init(env, 100UL * 1000UL * 1000UL);
/* RAM at address zero */
cpu_register_physical_memory(0x10000000, ram_size,
qemu_ram_alloc(ram_size) | IO_MEM_RAM);
/* Load kernel. */
if (kernel_filename) {
kernel_size = load_elf(kernel_filename, 0, &elf_entry, NULL, NULL);
entry = elf_entry;
if (kernel_size < 0) {
kernel_size = load_uimage(kernel_filename, &entry, NULL, NULL);
}
if (kernel_size < 0) {
kernel_size = load_image(kernel_filename, phys_ram_base);
entry = 0;
}
if (kernel_size < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
kernel_filename);
exit(1);
}
} else {
entry = 0;
}
env->nip = entry;
if (semihosting_enabled) {
/* Setup initial stack. */
target_ulong *p;
p = (target_ulong *)(phys_ram_base + ram_size);
*(--p) = 0;
*(--p) = 0;
env->gpr[1] = 0x10000000 + ram_size - 2 * sizeof(target_ulong);
/* Enable FPU. */
env->msr |= (1 << MSR_FP);
}
}
/*
* Load program "progname" and start running it in usermode.
* Does not return except on error.
*
* Calls vfs_open on progname and thus may destroy it.
*/
int
runprogram(char *progname)
{
struct vnode *v;
vaddr_t entrypoint, stackptr;
int result;
/* Open the file. */
result = vfs_open(progname, O_RDONLY, &v);
if (result) {
return result;
}
/* We should be a new thread. */
assert(curthread->t_vmspace == NULL);
/* Create a new address space. */
curthread->t_vmspace = as_create();
if (curthread->t_vmspace==NULL) {
vfs_close(v);
return ENOMEM;
}
//kprintf("\n in runprogram");
assignPid();
/* Activate it. */
as_activate(curthread->t_vmspace);
/* Load the executable. */
result = load_elf(v, &entrypoint);
if (result) {
/* thread_exit destroys curthread->t_vmspace */
vfs_close(v);
return result;
}
/* Done with the file now. */
vfs_close(v);
/* Define the user stack in the address space */
result = as_define_stack(curthread->t_vmspace, &stackptr);
if (result) {
/* thread_exit destroys curthread->t_vmspace */
return result;
}
/* Warp to user mode. */
md_usermode(0 /*argc*/, NULL /*userspace addr of argv*/,
stackptr, entrypoint);
/* md_usermode does not return */
panic("md_usermode returned\n");
return EINVAL;
}
void boot_loader()
{
// load program named "boot"
long phdrs[128];
current.phdr = (uintptr_t)phdrs;
current.phdr_size = sizeof(phdrs);
uart_send_string("Loadng linux ELF\n");
load_elf("vmlinux", ¤t);
uart_send_string("Linux ELF loaded\n");
run_loaded_program();
}
static void dummy_m68k_init(QEMUMachineInitArgs *args)
{
ram_addr_t ram_size = args->ram_size;
const char *cpu_model = args->cpu_model;
const char *kernel_filename = args->kernel_filename;
CPUM68KState *env;
MemoryRegion *address_space_mem = get_system_memory();
MemoryRegion *ram = g_new(MemoryRegion, 1);
int kernel_size;
uint64_t elf_entry;
hwaddr entry;
if (!cpu_model)
cpu_model = "cfv4e";
env = cpu_init(cpu_model);
if (!env) {
fprintf(stderr, "Unable to find m68k CPU definition\n");
exit(1);
}
/* Initialize CPU registers. */
env->vbr = 0;
/* RAM at address zero */
memory_region_init_ram(ram, "dummy_m68k.ram", ram_size);
vmstate_register_ram_global(ram);
memory_region_add_subregion(address_space_mem, 0, ram);
/* Load kernel. */
if (kernel_filename) {
kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry,
NULL, NULL, 1, ELF_MACHINE, 0);
entry = elf_entry;
if (kernel_size < 0) {
kernel_size = load_uimage(kernel_filename, &entry, NULL, NULL);
}
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename,
KERNEL_LOAD_ADDR,
ram_size - KERNEL_LOAD_ADDR);
entry = KERNEL_LOAD_ADDR;
}
if (kernel_size < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
kernel_filename);
exit(1);
}
} else {
entry = 0;
}
env->pc = entry;
}
Task* Core::load_executable(unsigned int start, unsigned int size, char* command_line)
{
unsigned char* file = (unsigned char*) start;
if(file[0] == 0x7f && file[1] == 'E' && file[2] == 'L' && file[3] == 'F')
return load_elf(start, size);
else if(file[0] == 'M' && file[1] == 'Z')
{
printf("\nload_executable: PE not supported\n");
return NULL;
}
printf("\nload_executable: wrong file format\n");
return NULL;
}
static int64_t load_kernel(void)
{
int64_t entry, kernel_high;
long kernel_size;
long initrd_size;
ram_addr_t initrd_offset;
int big_endian;
#ifdef TARGET_WORDS_BIGENDIAN
big_endian = 1;
#else
big_endian = 0;
#endif
kernel_size = load_elf(loaderparams.kernel_filename, cpu_mips_kseg0_to_phys,
NULL, (uint64_t *)&entry, NULL,
(uint64_t *)&kernel_high, big_endian,
ELF_MACHINE, 1);
if (kernel_size >= 0) {
if ((entry & ~0x7fffffffULL) == 0x80000000)
entry = (int32_t)entry;
} else {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
loaderparams.kernel_filename);
exit(1);
}
/* load initrd */
initrd_size = 0;
initrd_offset = 0;
if (loaderparams.initrd_filename) {
initrd_size = get_image_size (loaderparams.initrd_filename);
if (initrd_size > 0) {
initrd_offset = (kernel_high + ~TARGET_PAGE_MASK) & TARGET_PAGE_MASK;
if (initrd_offset + initrd_size > loaderparams.ram_size) {
fprintf(stderr,
"qemu: memory too small for initial ram disk '%s'\n",
loaderparams.initrd_filename);
exit(1);
}
initrd_size = load_image_targphys(loaderparams.initrd_filename,
initrd_offset, loaderparams.ram_size - initrd_offset);
}
if (initrd_size == (target_ulong) -1) {
fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
loaderparams.initrd_filename);
exit(1);
}
}
return entry;
}
static void dummy_m68k_init(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
CPUState *env;
int kernel_size;
uint64_t elf_entry;
target_phys_addr_t entry;
if (!cpu_model)
cpu_model = "cfv4e";
env = cpu_init(cpu_model);
if (!env) {
fprintf(stderr, "Unable to find m68k CPU definition\n");
exit(1);
}
/* Initialize CPU registers. */
env->vbr = 0;
/* RAM at address zero */
cpu_register_physical_memory(0, ram_size,
qemu_ram_alloc(ram_size) | IO_MEM_RAM);
/* Load kernel. */
if (kernel_filename) {
kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry,
NULL, NULL, 1, ELF_MACHINE, 0);
entry = elf_entry;
if (kernel_size < 0) {
kernel_size = load_uimage(kernel_filename, &entry, NULL, NULL);
}
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename,
KERNEL_LOAD_ADDR,
ram_size - KERNEL_LOAD_ADDR);
entry = KERNEL_LOAD_ADDR;
}
if (kernel_size < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
kernel_filename);
exit(1);
}
} else {
entry = 0;
}
env->pc = entry;
}
static int64_t load_kernel(void)
{
int64_t kernel_entry, kernel_high;
int big_endian;
big_endian = 0;
if (load_elf(loaderparams.kernel_filename, identity_translate, NULL,
(uint64_t *)&kernel_entry, NULL, (uint64_t *)&kernel_high,
big_endian, ELF_MACHINE, 1, 0) < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
loaderparams.kernel_filename);
exit(1);
}
return kernel_entry;
}
static void rest_of_boot_loader(uintptr_t kstack_top)
{
arg_buf args;
size_t argc = parse_args(&args);
if (!argc)
panic("tell me what ELF to load!");
// load program named by argv[0]
long phdrs[128];
current.phdr = (uintptr_t)phdrs;
current.phdr_size = sizeof(phdrs);
load_elf(args.argv[0], ¤t);
run_loaded_program(argc, args.argv, kstack_top);
}
static void xtensa_sim_init(MachineState *machine)
{
XtensaCPU *cpu = NULL;
CPUXtensaState *env = NULL;
MemoryRegion *ram, *rom;
ram_addr_t ram_size = machine->ram_size;
const char *cpu_model = machine->cpu_model;
const char *kernel_filename = machine->kernel_filename;
int n;
if (!cpu_model) {
cpu_model = XTENSA_DEFAULT_CPU_MODEL;
}
for (n = 0; n < smp_cpus; n++) {
cpu = cpu_xtensa_init(cpu_model);
if (cpu == NULL) {
error_report("unable to find CPU definition '%s'",
cpu_model);
exit(EXIT_FAILURE);
}
env = &cpu->env;
env->sregs[PRID] = n;
qemu_register_reset(sim_reset, cpu);
/* Need MMU initialized prior to ELF loading,
* so that ELF gets loaded into virtual addresses
*/
sim_reset(cpu);
}
ram = g_malloc(sizeof(*ram));
memory_region_init_ram(ram, NULL, "xtensa.sram", ram_size, &error_fatal);
vmstate_register_ram_global(ram);
memory_region_add_subregion(get_system_memory(), 0, ram);
rom = g_malloc(sizeof(*rom));
memory_region_init_ram(rom, NULL, "xtensa.rom", 0x1000, &error_fatal);
vmstate_register_ram_global(rom);
memory_region_add_subregion(get_system_memory(), 0xfe000000, rom);
if (kernel_filename) {
uint64_t elf_entry;
uint64_t elf_lowaddr;
#ifdef TARGET_WORDS_BIGENDIAN
int success = load_elf(kernel_filename, translate_phys_addr, cpu,
&elf_entry, &elf_lowaddr, NULL, 1, ELF_MACHINE, 0);
#else
int success = load_elf(kernel_filename, translate_phys_addr, cpu,
&elf_entry, &elf_lowaddr, NULL, 0, ELF_MACHINE, 0);
#endif
if (success > 0) {
env->pc = elf_entry;
}
}
}