/* * qemu main * * Copyright (c) 2003 Fabrice Bellard * * This program 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. * * This program 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 this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include #include "qemu.h" #include "cpu-i386.h" #define DEBUG_LOGFILE "/tmp/qemu.log" FILE *logfile = NULL; int loglevel; static const char *interp_prefix = CONFIG_QEMU_PREFIX; #ifdef __i386__ /* Force usage of an ELF interpreter even if it is an ELF shared object ! */ const char interp[] __attribute__((section(".interp"))) = "/lib/ld-linux.so.2"; /* for recent libc, we add these dummies symbol which are not declared when generating a linked object (bug in ld ?) */ #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3) long __init_array_start[0]; long __init_array_end[0]; long __fini_array_start[0]; long __fini_array_end[0]; #endif #endif /* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so we allocate a bigger stack. Need a better solution, for example by remapping the process stack directly at the right place */ unsigned long x86_stack_size = 512 * 1024; void gemu_log(const char *fmt, ...) { va_list ap; va_start(ap, fmt); vfprintf(stderr, fmt, ap); va_end(ap); } /***********************************************************/ /* CPUX86 core interface */ void cpu_x86_outb(CPUX86State *env, int addr, int val) { fprintf(stderr, "outb: port=0x%04x, data=%02x\n", addr, val); } void cpu_x86_outw(CPUX86State *env, int addr, int val) { fprintf(stderr, "outw: port=0x%04x, data=%04x\n", addr, val); } void cpu_x86_outl(CPUX86State *env, int addr, int val) { fprintf(stderr, "outl: port=0x%04x, data=%08x\n", addr, val); } int cpu_x86_inb(CPUX86State *env, int addr) { fprintf(stderr, "inb: port=0x%04x\n", addr); return 0; } int cpu_x86_inw(CPUX86State *env, int addr) { fprintf(stderr, "inw: port=0x%04x\n", addr); return 0; } int cpu_x86_inl(CPUX86State *env, int addr) { fprintf(stderr, "inl: port=0x%04x\n", addr); return 0; } void write_dt(void *ptr, unsigned long addr, unsigned long limit, int seg32_bit) { unsigned int e1, e2, limit_in_pages; limit_in_pages = 0; if (limit > 0xffff) { limit = limit >> 12; limit_in_pages = 1; } e1 = (addr << 16) | (limit & 0xffff); e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000); e2 |= limit_in_pages << 23; /* byte granularity */ e2 |= seg32_bit << 22; /* 32 bit segment */ stl((uint8_t *)ptr, e1); stl((uint8_t *)ptr + 4, e2); } uint64_t gdt_table[6]; void cpu_loop(CPUX86State *env) { int trapnr; uint8_t *pc; target_siginfo_t info; for(;;) { trapnr = cpu_x86_exec(env); switch(trapnr) { case EXCP0D_GPF: if (env->eflags & VM_MASK) { handle_vm86_fault(env); } else { pc = env->seg_cache[R_CS].base + env->eip; if (pc[0] == 0xcd && pc[1] == 0x80) { /* syscall */ env->eip += 2; env->regs[R_EAX] = do_syscall(env, env->regs[R_EAX], env->regs[R_EBX], env->regs[R_ECX], env->regs[R_EDX], env->regs[R_ESI], env->regs[R_EDI], env->regs[R_EBP]); } else { /* XXX: more precise info */ info.si_signo = SIGSEGV; info.si_errno = 0; info.si_code = TARGET_SI_KERNEL; info._sifields._sigfault._addr = 0; queue_signal(info.si_signo, &info); } } break; case EXCP0E_PAGE: info.si_signo = SIGSEGV; info.si_errno = 0; if (!(env->error_code & 1)) info.si_code = TARGET_SEGV_MAPERR; else info.si_code = TARGET_SEGV_ACCERR; info._sifields._sigfault._addr = env->cr2; queue_signal(info.si_signo, &info); break; case EXCP00_DIVZ: if (env->eflags & VM_MASK) { handle_vm86_trap(env, trapnr); } else { /* division by zero */ info.si_signo = SIGFPE; info.si_errno = 0; info.si_code = TARGET_FPE_INTDIV; info._sifields._sigfault._addr = env->eip; queue_signal(info.si_signo, &info); } break; case EXCP01_SSTP: case EXCP03_INT3: if (env->eflags & VM_MASK) { handle_vm86_trap(env, trapnr); } else { info.si_signo = SIGTRAP; info.si_errno = 0; if (trapnr == EXCP01_SSTP) { info.si_code = TARGET_TRAP_BRKPT; info._sifields._sigfault._addr = env->eip; } else { info.si_code = TARGET_SI_KERNEL; info._sifields._sigfault._addr = 0; } queue_signal(info.si_signo, &info); } break; case EXCP04_INTO: case EXCP05_BOUND: if (env->eflags & VM_MASK) { handle_vm86_trap(env, trapnr); } else { info.si_signo = SIGSEGV; info.si_errno = 0; info.si_code = TARGET_SI_KERNEL; info._sifields._sigfault._addr = 0; queue_signal(info.si_signo, &info); } break; case EXCP06_ILLOP: info.si_signo = SIGILL; info.si_errno = 0; info.si_code = TARGET_ILL_ILLOPN; info._sifields._sigfault._addr = env->eip; queue_signal(info.si_signo, &info); break; case EXCP_INTERRUPT: /* just indicate that signals should be handled asap */ break; default: pc = env->seg_cache[R_CS].base + env->eip; fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n", (long)pc, trapnr); abort(); } process_pending_signals(env); } } void usage(void) { printf("qemu version " QEMU_VERSION ", Copyright (c) 2003 Fabrice Bellard\n" "usage: qemu [-h] [-d] [-L path] [-s size] program [arguments...]\n" "Linux x86 emulator\n" "\n" "-h print this help\n" "-L path set the x86 elf interpreter prefix (default=%s)\n" "-s size set the x86 stack size in bytes (default=%ld)\n" "\n" "debug options:\n" "-d activate log (logfile=%s)\n" "-p pagesize set the host page size to 'pagesize'\n", interp_prefix, x86_stack_size, DEBUG_LOGFILE); _exit(1); } /* XXX: currently only used for async signals (see signal.c) */ CPUX86State *global_env; /* used to free thread contexts */ TaskState *first_task_state; int main(int argc, char **argv) { const char *filename; struct target_pt_regs regs1, *regs = ®s1; struct image_info info1, *info = &info1; TaskState ts1, *ts = &ts1; CPUX86State *env; int optind; const char *r; if (argc <= 1) usage(); loglevel = 0; optind = 1; for(;;) { if (optind >= argc) break; r = argv[optind]; if (r[0] != '-') break; optind++; r++; if (!strcmp(r, "-")) { break; } else if (!strcmp(r, "d")) { loglevel = 1; } else if (!strcmp(r, "s")) { r = argv[optind++]; x86_stack_size = strtol(r, (char **)&r, 0); if (x86_stack_size <= 0) usage(); if (*r == 'M') x86_stack_size *= 1024 * 1024; else if (*r == 'k' || *r == 'K') x86_stack_size *= 1024; } else if (!strcmp(r, "L")) { interp_prefix = argv[optind++]; } else if (!strcmp(r, "p")) { host_page_size = atoi(argv[optind++]); if (host_page_size == 0 || (host_page_size & (host_page_size - 1)) != 0) { fprintf(stderr, "page size must be a power of two\n"); exit(1); } } else { usage(); } } if (optind >= argc) usage(); filename = argv[optind]; /* init debug */ if (loglevel) { logfile = fopen(DEBUG_LOGFILE, "w"); if (!logfile) { perror(DEBUG_LOGFILE); _exit(1); } setvbuf(logfile, NULL, _IOLBF, 0); } /* Zero out regs */ memset(regs, 0, sizeof(struct target_pt_regs)); /* Zero out image_info */ memset(info, 0, sizeof(struct image_info)); /* Scan interp_prefix dir for replacement files. */ init_paths(interp_prefix); /* NOTE: we need to init the CPU at this stage to get the host_page_size */ env = cpu_x86_init(); if (elf_exec(filename, argv+optind, environ, regs, info) != 0) { printf("Error loading %s\n", filename); _exit(1); } if (loglevel) { page_dump(logfile); fprintf(logfile, "start_brk 0x%08lx\n" , info->start_brk); fprintf(logfile, "end_code 0x%08lx\n" , info->end_code); fprintf(logfile, "start_code 0x%08lx\n" , info->start_code); fprintf(logfile, "end_data 0x%08lx\n" , info->end_data); fprintf(logfile, "start_stack 0x%08lx\n" , info->start_stack); fprintf(logfile, "brk 0x%08lx\n" , info->brk); fprintf(logfile, "esp 0x%08lx\n" , regs->esp); fprintf(logfile, "eip 0x%08lx\n" , regs->eip); } target_set_brk((char *)info->brk); syscall_init(); signal_init(); global_env = env; /* build Task State */ memset(ts, 0, sizeof(TaskState)); env->opaque = ts; ts->used = 1; /* linux register setup */ env->regs[R_EAX] = regs->eax; env->regs[R_EBX] = regs->ebx; env->regs[R_ECX] = regs->ecx; env->regs[R_EDX] = regs->edx; env->regs[R_ESI] = regs->esi; env->regs[R_EDI] = regs->edi; env->regs[R_EBP] = regs->ebp; env->regs[R_ESP] = regs->esp; env->eip = regs->eip; /* linux segment setup */ env->gdt.base = (void *)gdt_table; env->gdt.limit = sizeof(gdt_table) - 1; write_dt(&gdt_table[__USER_CS >> 3], 0, 0xffffffff, 1); write_dt(&gdt_table[__USER_DS >> 3], 0, 0xffffffff, 1); cpu_x86_load_seg(env, R_CS, __USER_CS); cpu_x86_load_seg(env, R_DS, __USER_DS); cpu_x86_load_seg(env, R_ES, __USER_DS); cpu_x86_load_seg(env, R_SS, __USER_DS); cpu_x86_load_seg(env, R_FS, __USER_DS); cpu_x86_load_seg(env, R_GS, __USER_DS); cpu_loop(env); /* never exits */ return 0; }