X-Git-Url: http://vcs.maemo.org/git/?a=blobdiff_plain;f=linux-user%2Fmain.c;h=b85637f8bf167aeb0770d6d79cb339a05938ea2b;hb=3802ce26a1b60fe791aee1ff3e15ab6dc0bdac27;hp=544953eb2503102e0e4ffb427da583d2189e633e;hpb=5147f5aac0e725ce73ee04d0f1ca39284acf456c;p=qemu diff --git a/linux-user/main.c b/linux-user/main.c index 544953e..b85637f 100644 --- a/linux-user/main.c +++ b/linux-user/main.c @@ -1,5 +1,5 @@ /* - * emu main + * qemu main * * Copyright (c) 2003 Fabrice Bellard * @@ -20,14 +20,37 @@ #include #include #include +#include #include +#include -#include "gemu.h" +#include "qemu.h" -#include "i386/hsw_interp.h" +#define DEBUG_LOGFILE "/tmp/qemu.log" -unsigned long x86_stack_size; -unsigned long stktop; +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"; +#endif + +/* 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 + +/* 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, ...) { @@ -38,184 +61,334 @@ void gemu_log(const char *fmt, ...) va_end(ap); } -/* virtual x86 CPU stuff */ - -extern int invoke_code16(Interp_ENV *, int, int); -extern int invoke_code32(Interp_ENV *, int); -extern char *e_print_cpuemu_regs(ENVPARAMS, int is32); -extern char *e_emu_disasm(ENVPARAMS, unsigned char *org, int is32); -extern void init_npu(void); - -Interp_ENV env_global; -Interp_ENV *envp_global; - -QWORD EMUtime = 0; - -int CEmuStat = 0; - -long instr_count; - -/* who will initialize this? */ -unsigned long io_bitmap[IO_BITMAP_SIZE+1]; - -/* debug flag, 0=disable 1..9=level */ -int d_emu = 0; +#ifdef TARGET_I386 +/***********************************************************/ +/* CPUX86 core interface */ -unsigned long CRs[5] = +void cpu_x86_outb(CPUX86State *env, int addr, int val) { - 0x00000013, /* valid bits: 0xe005003f */ - 0x00000000, /* invalid */ - 0x00000000, - 0x00000000, - 0x00000000 -}; + fprintf(stderr, "outb: port=0x%04x, data=%02x\n", addr, val); +} -/* - * DR0-3 = linear address of breakpoint 0-3 - * DR4=5 = reserved - * DR6 b0-b3 = BP active - * b13 = BD - * b14 = BS - * b15 = BT - * DR7 b0-b1 = G:L bp#0 - * b2-b3 = G:L bp#1 - * b4-b5 = G:L bp#2 - * b6-b7 = G:L bp#3 - * b8-b9 = GE:LE - * b13 = GD - * b16-19= LLRW bp#0 LL=00(1),01(2),11(4) - * b20-23= LLRW bp#1 RW=00(x),01(w),11(rw) - * b24-27= LLRW bp#2 - * b28-31= LLRW bp#3 - */ -unsigned long DRs[8] = +void cpu_x86_outw(CPUX86State *env, int addr, int val) { - 0x00000000, - 0x00000000, - 0x00000000, - 0x00000000, - 0xffff1ff0, - 0x00000400, - 0xffff1ff0, - 0x00000400 -}; - -unsigned long TRs[2] = + fprintf(stderr, "outw: port=0x%04x, data=%04x\n", addr, val); +} + +void cpu_x86_outl(CPUX86State *env, int addr, int val) { - 0x00000000, - 0x00000000 -}; + fprintf(stderr, "outl: port=0x%04x, data=%08x\n", addr, val); +} -void FatalAppExit(UINT wAction, LPCSTR lpText) +int cpu_x86_inb(CPUX86State *env, int addr) { - fprintf(stderr, "Fatal error '%s' in CPU\n", lpText); - exit(1); + fprintf(stderr, "inb: port=0x%04x\n", addr); + return 0; } -int e_debug_check(unsigned char *PC) +int cpu_x86_inw(CPUX86State *env, int addr) { - register unsigned long d7 = DRs[7]; - - if (d7&0x03) { - if (d7&0x30000) return 0; /* only execute(00) bkp */ - if ((long)PC==DRs[0]) { - e_printf("DBRK: DR0 hit at %p\n",PC); - DRs[6] |= 1; - return 1; - } - } - if (d7&0x0c) { - if (d7&0x300000) return 0; - if ((long)PC==DRs[1]) { - e_printf("DBRK: DR1 hit at %p\n",PC); - DRs[6] |= 2; - return 1; - } - } - if (d7&0x30) { - if (d7&0x3000000) return 0; - if ((long)PC==DRs[2]) { - e_printf("DBRK: DR2 hit at %p\n",PC); - DRs[6] |= 4; - return 1; - } - } - if (d7&0xc0) { - if (d7&0x30000000) return 0; - if ((long)PC==DRs[3]) { - e_printf("DBRK: DR3 hit at %p\n",PC); - DRs[6] |= 8; - return 1; - } - } + fprintf(stderr, "inw: port=0x%04x\n", addr); return 0; } -/* Debug stuff */ -void logstr(unsigned long mask, const char *fmt,...) +int cpu_x86_inl(CPUX86State *env, int addr) { - va_list ap; + fprintf(stderr, "inl: port=0x%04x\n", addr); + return 0; +} - va_start(ap, fmt); - vfprintf(stderr, fmt, ap); - va_end(ap); +int cpu_x86_get_pic_interrupt(CPUX86State *env) +{ + return -1; } -/* unconditional message into debug log and stderr */ -#undef error -void error(const char *fmt, ...) +static void write_dt(void *ptr, unsigned long addr, unsigned long limit, + int flags) { - va_list ap; + unsigned int e1, e2; + e1 = (addr << 16) | (limit & 0xffff); + e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000); + e2 |= flags; + stl((uint8_t *)ptr, e1); + stl((uint8_t *)ptr + 4, e2); +} - va_start(ap, fmt); - vfprintf(stderr, fmt, ap); - va_end(ap); - exit(1); +static void set_gate(void *ptr, unsigned int type, unsigned int dpl, + unsigned long addr, unsigned int sel) +{ + unsigned int e1, e2; + e1 = (addr & 0xffff) | (sel << 16); + e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8); + stl((uint8_t *)ptr, e1); + stl((uint8_t *)ptr + 4, e2); } -int PortIO(DWORD port, DWORD value, UINT size, BOOL is_write) +uint64_t gdt_table[6]; +uint64_t idt_table[256]; + +/* only dpl matters as we do only user space emulation */ +static void set_idt(int n, unsigned int dpl) { - fprintf(stderr, "IO: %s port=0x%lx value=0x%lx size=%d", - is_write ? "write" : "read", port, value, size); - return value; + set_gate(idt_table + n, 0, dpl, 0, 0); } -void LogProcName(WORD wSel, WORD wOff, WORD wAction) +void cpu_loop(CPUX86State *env) { + int trapnr; + uint8_t *pc; + target_siginfo_t info; + for(;;) { + trapnr = cpu_x86_exec(env); + switch(trapnr) { + case 0x80: + /* linux syscall */ + 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]); + break; + case EXCP0B_NOSEG: + case EXCP0C_STACK: + info.si_signo = SIGBUS; + info.si_errno = 0; + info.si_code = TARGET_SI_KERNEL; + info._sifields._sigfault._addr = 0; + queue_signal(info.si_signo, &info); + break; + case EXCP0D_GPF: + if (env->eflags & VM_MASK) { + handle_vm86_fault(env); + } 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 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->cr[2]; + 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->segs[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); + } } +#endif -void INT_handler(int num, void *env) +#ifdef TARGET_ARM + +void cpu_loop(CPUARMState *env) { - fprintf(stderr, "EM86: int %d\n", num); + int trapnr; + unsigned int n, insn; + target_siginfo_t info; + + for(;;) { + trapnr = cpu_arm_exec(env); + switch(trapnr) { + case EXCP_UDEF: + info.si_signo = SIGILL; + info.si_errno = 0; + info.si_code = TARGET_ILL_ILLOPN; + info._sifields._sigfault._addr = env->regs[15]; + queue_signal(info.si_signo, &info); + break; + case EXCP_SWI: + { + /* system call */ + insn = ldl((void *)(env->regs[15] - 4)); + n = insn & 0xffffff; + if (n >= ARM_SYSCALL_BASE) { + /* linux syscall */ + n -= ARM_SYSCALL_BASE; + env->regs[0] = do_syscall(env, + n, + env->regs[0], + env->regs[1], + env->regs[2], + env->regs[3], + env->regs[4], + 0); + } else { + goto error; + } + } + break; + case EXCP_INTERRUPT: + /* just indicate that signals should be handled asap */ + break; + default: + error: + fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", + trapnr); + cpu_arm_dump_state(env, stderr, 0); + abort(); + } + process_pending_signals(env); + } } -/***********************************************************/ - -/* XXX: currently we use LDT entries */ -#define __USER_CS (0x23|4) -#define __USER_DS (0x2B|4) +#endif void usage(void) { - printf("gemu version 0.1, Copyright (c) 2003 Fabrice Bellard\n" - "usage: gemu program [arguments...]\n" - "Linux x86 emulator\n" - ); - exit(1); + printf("qemu version " QEMU_VERSION ", Copyright (c) 2003 Fabrice Bellard\n" + "usage: qemu [-h] [-d] [-L path] [-s size] program [arguments...]\n" + "Linux CPU emulator (compiled for %s emulation)\n" + "\n" + "-h print this help\n" + "-L path set the elf interpreter prefix (default=%s)\n" + "-s size set the 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", + TARGET_ARCH, + interp_prefix, + x86_stack_size, + DEBUG_LOGFILE); + _exit(1); } +/* XXX: currently only used for async signals (see signal.c) */ +CPUState *global_env; +/* used only if single thread */ +CPUState *cpu_single_env = NULL; + +/* 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; - Interp_ENV *env; - + TaskState ts1, *ts = &ts1; + CPUState *env; + int optind; + const char *r; + if (argc <= 1) usage(); - - filename = argv[1]; + + 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)); @@ -223,88 +396,110 @@ int main(int argc, char **argv) /* Zero out image_info */ memset(info, 0, sizeof(struct image_info)); - if(elf_exec(filename, argv+1, environ, regs, info) != 0) { + /* 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_init(); + + if (elf_exec(filename, argv+optind, environ, regs, info) != 0) { printf("Error loading %s\n", filename); - exit(1); + _exit(1); } -#if 0 - printf("start_brk 0x%08lx\n" , info->start_brk); - printf("end_code 0x%08lx\n" , info->end_code); - printf("start_code 0x%08lx\n" , info->start_code); - printf("end_data 0x%08lx\n" , info->end_data); - printf("start_stack 0x%08lx\n" , info->start_stack); - printf("brk 0x%08lx\n" , info->brk); - printf("esp 0x%08lx\n" , regs->esp); - printf("eip 0x%08lx\n" , regs->eip); -#endif + 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, "entry 0x%08lx\n" , info->entry); + } target_set_brk((char *)info->brk); syscall_init(); + signal_init(); - env = &env_global; - envp_global = env; - memset(env, 0, sizeof(Interp_ENV)); - - env->rax.e = regs->eax; - env->rbx.e = regs->ebx; - env->rcx.e = regs->ecx; - env->rdx.e = regs->edx; - env->rsi.esi = regs->esi; - env->rdi.edi = regs->edi; - env->rbp.ebp = regs->ebp; - env->rsp.esp = regs->esp; - env->cs.cs = __USER_CS; - env->ds.ds = __USER_DS; - env->es.es = __USER_DS; - env->ss.ss = __USER_DS; - env->fs.fs = __USER_DS; - env->gs.gs = __USER_DS; - env->trans_addr = regs->eip; - - LDT[__USER_CS >> 3].w86Flags = DF_PRESENT | DF_PAGES | DF_32; - LDT[__USER_CS >> 3].dwSelLimit = 0xfffff; - LDT[__USER_CS >> 3].lpSelBase = NULL; - - LDT[__USER_DS >> 3].w86Flags = DF_PRESENT | DF_PAGES | DF_32; - LDT[__USER_DS >> 3].dwSelLimit = 0xfffff; - LDT[__USER_DS >> 3].lpSelBase = NULL; - init_npu(); - - for(;;) { - int err; - uint8_t *pc; + global_env = env; - err = invoke_code32(env, -1); - env->trans_addr = env->return_addr; - pc = env->seg_regs[0] + env->trans_addr; - switch(err) { - case EXCP0D_GPF: - if (pc[0] == 0xcd && pc[1] == 0x80) { - /* syscall */ - env->trans_addr += 2; - env->rax.e = do_syscall(env->rax.e, - env->rbx.e, - env->rcx.e, - env->rdx.e, - env->rsi.esi, - env->rdi.edi, - env->rbp.ebp); - } else { - goto trap_error; - } - break; - default: - trap_error: - fprintf(stderr, "GEMU: Unknown error %d, aborting\n", err); -#ifndef NO_TRACE_MSGS - d_emu = 9; - fprintf(stderr, "%s\n%s\n", - e_print_cpuemu_regs(env, 1), - e_emu_disasm(env,pc,1)); -#endif - abort(); + /* build Task State */ + memset(ts, 0, sizeof(TaskState)); + env->opaque = ts; + ts->used = 1; + env->user_mode_only = 1; + +#if defined(TARGET_I386) + env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK; + + /* 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 interrupt setup */ + env->idt.base = (void *)idt_table; + env->idt.limit = sizeof(idt_table) - 1; + set_idt(0, 0); + set_idt(1, 0); + set_idt(2, 0); + set_idt(3, 3); + set_idt(4, 3); + set_idt(5, 3); + set_idt(6, 0); + set_idt(7, 0); + set_idt(8, 0); + set_idt(9, 0); + set_idt(10, 0); + set_idt(11, 0); + set_idt(12, 0); + set_idt(13, 0); + set_idt(14, 0); + set_idt(15, 0); + set_idt(16, 0); + set_idt(17, 0); + set_idt(18, 0); + set_idt(19, 0); + set_idt(0x80, 3); + + /* linux segment setup */ + env->gdt.base = (void *)gdt_table; + env->gdt.limit = sizeof(gdt_table) - 1; + write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff, + DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | + (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT)); + write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff, + DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | + (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT)); + 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); + +#elif defined(TARGET_ARM) + { + int i; + for(i = 0; i < 16; i++) { + env->regs[i] = regs->uregs[i]; } + env->cpsr = regs->uregs[16]; } +#else +#error unsupported target CPU +#endif + + cpu_loop(env); + /* never exits */ return 0; }