Archipelago » qemu

/*

 *  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 <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <errno.h>

#include <unistd.h>

#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(int addr, int val)

{

    fprintf(stderr, "outb: port=0x%04x, data=%02x\n", addr, val);

}

void cpu_x86_outw(int addr, int val)

{

    fprintf(stderr, "outw: port=0x%04x, data=%04x\n", addr, val);

}

void cpu_x86_outl(int addr, int val)

{

    fprintf(stderr, "outl: port=0x%04x, data=%08x\n", addr, val);

}

int cpu_x86_inb(int addr)

{

    fprintf(stderr, "inb: port=0x%04x\n", addr);

    return 0;

}

int cpu_x86_inw(int addr)

{

    fprintf(stderr, "inw: port=0x%04x\n", addr);

    return 0;

}

int cpu_x86_inl(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];

//#define DEBUG_VM86

static inline int is_revectored(int nr, struct target_revectored_struct *bitmap)

{

    return (tswap32(bitmap->__map[nr >> 5]) >> (nr & 0x1f)) & 1;

}

static inline uint8_t *seg_to_linear(unsigned int seg, unsigned int reg)

{

    return (uint8_t *)((seg << 4) + (reg & 0xffff));

}

static inline void pushw(CPUX86State *env, int val)

{

    env->regs[R_ESP] = (env->regs[R_ESP] & ~0xffff) | 

        ((env->regs[R_ESP] - 2) & 0xffff);

    *(uint16_t *)seg_to_linear(env->segs[R_SS], env->regs[R_ESP]) = val;

}

static inline unsigned int get_vflags(CPUX86State *env)

{

    unsigned int eflags;

    eflags = env->eflags & ~(VM_MASK | RF_MASK | IF_MASK);

    if (eflags & VIF_MASK)

        eflags |= IF_MASK;

    return eflags;

}

void save_v86_state(CPUX86State *env)

{

    TaskState *ts = env->opaque;

#ifdef DEBUG_VM86

    printf("save_v86_state\n");

#endif

    /* put the VM86 registers in the userspace register structure */

    ts->target_v86->regs.eax = tswap32(env->regs[R_EAX]);

    ts->target_v86->regs.ebx = tswap32(env->regs[R_EBX]);

    ts->target_v86->regs.ecx = tswap32(env->regs[R_ECX]);

    ts->target_v86->regs.edx = tswap32(env->regs[R_EDX]);

    ts->target_v86->regs.esi = tswap32(env->regs[R_ESI]);

    ts->target_v86->regs.edi = tswap32(env->regs[R_EDI]);

    ts->target_v86->regs.ebp = tswap32(env->regs[R_EBP]);

    ts->target_v86->regs.esp = tswap32(env->regs[R_ESP]);

    ts->target_v86->regs.eip = tswap32(env->eip);

    ts->target_v86->regs.cs = tswap16(env->segs[R_CS]);

    ts->target_v86->regs.ss = tswap16(env->segs[R_SS]);

    ts->target_v86->regs.ds = tswap16(env->segs[R_DS]);

    ts->target_v86->regs.es = tswap16(env->segs[R_ES]);

    ts->target_v86->regs.fs = tswap16(env->segs[R_FS]);

    ts->target_v86->regs.gs = tswap16(env->segs[R_GS]);

    ts->target_v86->regs.eflags = tswap32(env->eflags);

    /* restore 32 bit registers */

    env->regs[R_EAX] = ts->vm86_saved_regs.eax;

    env->regs[R_EBX] = ts->vm86_saved_regs.ebx;

    env->regs[R_ECX] = ts->vm86_saved_regs.ecx;

    env->regs[R_EDX] = ts->vm86_saved_regs.edx;

    env->regs[R_ESI] = ts->vm86_saved_regs.esi;

    env->regs[R_EDI] = ts->vm86_saved_regs.edi;

    env->regs[R_EBP] = ts->vm86_saved_regs.ebp;

    env->regs[R_ESP] = ts->vm86_saved_regs.esp;

    env->eflags = ts->vm86_saved_regs.eflags;

    env->eip = ts->vm86_saved_regs.eip;

    cpu_x86_load_seg(env, R_CS, ts->vm86_saved_regs.cs);

    cpu_x86_load_seg(env, R_SS, ts->vm86_saved_regs.ss);

    cpu_x86_load_seg(env, R_DS, ts->vm86_saved_regs.ds);

    cpu_x86_load_seg(env, R_ES, ts->vm86_saved_regs.es);

    cpu_x86_load_seg(env, R_FS, ts->vm86_saved_regs.fs);

    cpu_x86_load_seg(env, R_GS, ts->vm86_saved_regs.gs);

}

/* return from vm86 mode to 32 bit. The vm86() syscall will return

   'retval' */

static inline void return_to_32bit(CPUX86State *env, int retval)

{

#ifdef DEBUG_VM86

    printf("return_to_32bit: ret=0x%x\n", retval);

#endif

    save_v86_state(env);

    env->regs[R_EAX] = retval;

}

/* handle VM86 interrupt (NOTE: the CPU core currently does not

   support TSS interrupt revectoring, so this code is always executed) */

static void do_int(CPUX86State *env, int intno)

{

    TaskState *ts = env->opaque;

    uint32_t *int_ptr, segoffs;

    if (env->segs[R_CS] == TARGET_BIOSSEG)

        goto cannot_handle; /* XXX: I am not sure this is really useful */

    if (is_revectored(intno, &ts->target_v86->int_revectored))

        goto cannot_handle;

    if (intno == 0x21 && is_revectored((env->regs[R_EAX] >> 8) & 0xff, 

                                       &ts->target_v86->int21_revectored))

        goto cannot_handle;

    int_ptr = (uint32_t *)(intno << 2);

    segoffs = tswap32(*int_ptr);

    if ((segoffs >> 16) == TARGET_BIOSSEG)

        goto cannot_handle;

#ifdef DEBUG_VM86

    printf("VM86: emulating int 0x%x. CS:IP=%04x:%04x\n", 

           intno, segoffs >> 16, segoffs & 0xffff);

#endif

    /* save old state */

    pushw(env, get_vflags(env));

    pushw(env, env->segs[R_CS]);

    pushw(env, env->eip);

    /* goto interrupt handler */

    env->eip = segoffs & 0xffff;

    cpu_x86_load_seg(env, R_CS, segoffs >> 16);

    env->eflags &= ~(VIF_MASK | TF_MASK);

    return;

 cannot_handle:

#ifdef DEBUG_VM86

    printf("VM86: return to 32 bits int 0x%x\n", intno);

#endif

    return_to_32bit(env, TARGET_VM86_INTx | (intno << 8));

}

void cpu_loop(struct CPUX86State *env)

{

    int trapnr;

    uint8_t *pc;

    target_siginfo_t info;

    for(;;) {

        trapnr = cpu_x86_exec(env);

        pc = env->seg_cache[R_CS].base + env->eip;

        switch(trapnr) {

        case EXCP0D_GPF:

            if (env->eflags & VM_MASK) {

#ifdef DEBUG_VM86

                printf("VM86 exception %04x:%08x %02x %02x\n",

                       env->segs[R_CS], env->eip, pc[0], pc[1]);

#endif

                /* VM86 mode */

                switch(pc[0]) {

                case 0xcd: /* int */

                    env->eip += 2;

                    do_int(env, pc[1]);

                    break;

                case 0x66:

                    switch(pc[1]) {

                    case 0xfb: /* sti */

                    case 0x9d: /* popf */

                    case 0xcf: /* iret */

                        env->eip += 2;

                        return_to_32bit(env, TARGET_VM86_STI);

                        break;

                    default:

                        goto vm86_gpf;

                    }

                    break;

                case 0xfb: /* sti */

                case 0x9d: /* popf */

                case 0xcf: /* iret */

                    env->eip++;

                    return_to_32bit(env, TARGET_VM86_STI);

                    break;

                default:

                vm86_gpf:

                    /* real VM86 GPF exception */

                    return_to_32bit(env, TARGET_VM86_UNKNOWN);

                    break;

                }

            } else {

                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 = 0;

                    info._sifields._sigfault._addr = 0;

                    queue_signal(info.si_signo, &info);

                }

            }

            break;

        case EXCP00_DIVZ:

            if (env->eflags & VM_MASK) {

                do_int(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 EXCP04_INTO:

        case EXCP05_BOUND:

            if (env->eflags & VM_MASK) {

                do_int(env, trapnr);

            } else {

                info.si_signo = SIGSEGV;

                info.si_errno = 0;

                info.si_code = 0;

                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:

            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"

           "-d        activate log (logfile=%s)\n"

           "-L path   set the x86 elf interpreter prefix (default=%s)\n"

           "-s size   set the x86 stack size in bytes (default=%ld)\n",

           DEBUG_LOGFILE,

           interp_prefix, 

           x86_stack_size);

    _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 = &regs1;

    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 {

            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);

    if (elf_exec(filename, argv+optind, environ, regs, info) != 0) {

        printf("Error loading %s\n", filename);

        _exit(1);

    }

    if (loglevel) {

        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();

    env = cpu_x86_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;

}