/*

 *  qemu user main

 *

 *  Copyright (c) 2003-2008 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 <sys/mman.h>

#include "qemu.h"

#include "qemu-common.h"

#include "cache-utils.h"

/* For tb_lock */

#include "exec-all.h"

#define DEBUG_LOGFILE "/tmp/qemu.log"

static const char *interp_prefix = CONFIG_QEMU_PREFIX;

const char *qemu_uname_release = CONFIG_UNAME_RELEASE;

int show_missing_syscalls;

int gdb_wrapper;

#ifndef CONFIG_STATIC

/* Reserve an are of memory to prevent the host ld.so doing silly things.

   Starting at address zero seems to cause problems, so start shortly

   after.  We reserve an arbitrary size of 64M.  This should be large

   enough for most applications without hitting too many ulimits.  */

/* These values must be consistent with the linker script.  Note that the

   page for the program headers is not unmapped.  */

# define RESERVED_SEGMENT_START 0x2000ul

# define RESERVED2_SEGMENT_START 0x10000000ul

# ifndef TARGET_PPC

#  define RESERVED_SEGMENT_SIZE 1024*1024*64

#  define RESERVED2_SEGMENT_SIZE 0

# else

#  define RESERVED_SEGMENT_SIZE 0

#  define RESERVED2_SEGMENT_SIZE 1024*1024*64

# endif

asm (".section .reserved, \"a\", %nobits\n"

     ".space " stringify(RESERVED_SEGMENT_SIZE) " + 0x100\n"

     ".previous");

asm (".section .reserved2, \"a\", %nobits\n"

     ".space " stringify(RESERVED2_SEGMENT_SIZE) "\n"

     ".previous");

#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 = 16 * 1024 * 1024;

void gemu_log(const char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    vfprintf(stderr, fmt, ap);

    va_end(ap);

}

void cpu_outb(CPUState *env, int addr, int val)

{

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

}

void cpu_outw(CPUState *env, int addr, int val)

{

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

}

void cpu_outl(CPUState *env, int addr, int val)

{

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

}

int cpu_inb(CPUState *env, int addr)

{

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

    return 0;

}

int cpu_inw(CPUState *env, int addr)

{

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

    return 0;

}

int cpu_inl(CPUState *env, int addr)

{

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

    return 0;

}

#if defined(TARGET_I386)

int cpu_get_pic_interrupt(CPUState *env)

{

    return -1;

}

#endif

/* timers for rdtsc */

#if 0

static uint64_t emu_time;

int64_t cpu_get_real_ticks(void)

{

    return emu_time++;

}

#endif

#if defined(USE_NPTL)

/***********************************************************/

/* Helper routines for implementing atomic operations.  */

/* To implement exclusive operations we force all cpus to syncronise.

   We don't require a full sync, only that no cpus are executing guest code.

   The alternative is to map target atomic ops onto host equivalents,

   which requires quite a lot of per host/target work.  */

static pthread_mutex_t exclusive_lock = PTHREAD_MUTEX_INITIALIZER;

static pthread_cond_t exclusive_cond = PTHREAD_COND_INITIALIZER;

static pthread_cond_t exclusive_resume = PTHREAD_COND_INITIALIZER;

static int pending_cpus;

/* Make sure everything is in a consistent state for calling fork().  */

void fork_start(void)

{

    mmap_fork_start();

    pthread_mutex_lock(&tb_lock);

    pthread_mutex_lock(&exclusive_lock);

}

void fork_end(int child)

{

    if (child) {

        /* Child processes created by fork() only have a single thread.

           Discard information about the parent threads.  */

        first_cpu = thread_env;

        thread_env->next_cpu = NULL;

        pending_cpus = 0;

        pthread_mutex_init(&exclusive_lock, NULL);

        pthread_cond_init(&exclusive_cond, NULL);

        pthread_cond_init(&exclusive_resume, NULL);

        pthread_mutex_init(&tb_lock, NULL);

        gdbserver_fork(thread_env);

    } else {

        pthread_mutex_unlock(&exclusive_lock);

        pthread_mutex_unlock(&tb_lock);

    }

    mmap_fork_end(child);

}

/* Wait for pending exclusive operations to complete.  The exclusive lock

   must be held.  */

static inline void exclusive_idle(void)

{

    while (pending_cpus) {

        pthread_cond_wait(&exclusive_resume, &exclusive_lock);

    }

}

/* Start an exclusive operation.

   Must only be called from outside cpu_arm_exec.   */

static inline void start_exclusive(void)

{

    CPUState *other;

    pthread_mutex_lock(&exclusive_lock);

    exclusive_idle();

    pending_cpus = 1;

    /* Make all other cpus stop executing.  */

    for (other = first_cpu; other; other = other->next_cpu) {

        if (other->running) {

            pending_cpus++;

            cpu_interrupt(other, CPU_INTERRUPT_EXIT);

        }

    }

    if (pending_cpus > 1) {

        pthread_cond_wait(&exclusive_cond, &exclusive_lock);

    }

}

/* Finish an exclusive operation.  */

static inline void end_exclusive(void)

{

    pending_cpus = 0;

    pthread_cond_broadcast(&exclusive_resume);

    pthread_mutex_unlock(&exclusive_lock);

}

/* Wait for exclusive ops to finish, and begin cpu execution.  */

static inline void cpu_exec_start(CPUState *env)

{

    pthread_mutex_lock(&exclusive_lock);

    exclusive_idle();

    env->running = 1;

    pthread_mutex_unlock(&exclusive_lock);

}

/* Mark cpu as not executing, and release pending exclusive ops.  */

static inline void cpu_exec_end(CPUState *env)

{

    pthread_mutex_lock(&exclusive_lock);

    env->running = 0;

    if (pending_cpus > 1) {

        pending_cpus--;

        if (pending_cpus == 1) {

            pthread_cond_signal(&exclusive_cond);

        }

    }

    exclusive_idle();

    pthread_mutex_unlock(&exclusive_lock);

}

#else /* if !USE_NPTL */

/* These are no-ops because we are not threadsafe.  */

static inline void cpu_exec_start(CPUState *env)

{

}

static inline void cpu_exec_end(CPUState *env)

{

}

static inline void start_exclusive(void)

{

}

static inline void end_exclusive(void)

{

}

void fork_start(void)

{

}

void fork_end(int child)

{

    if (child) {

        gdbserver_fork(thread_env);

    }

}

#endif

#ifdef TARGET_I386

/***********************************************************/

/* CPUX86 core interface */

void cpu_smm_update(CPUState *env)

{

}

uint64_t cpu_get_tsc(CPUX86State *env)

{

    return cpu_get_real_ticks();

}

static void write_dt(void *ptr, unsigned long addr, unsigned long limit,

                     int flags)

{

    unsigned int e1, e2;

    uint32_t *p;

    e1 = (addr << 16) | (limit & 0xffff);

    e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);

    e2 |= flags;

    p = ptr;

    p[0] = tswap32(e1);

    p[1] = tswap32(e2);

}

static uint64_t *idt_table;

#ifdef TARGET_X86_64

static void set_gate64(void *ptr, unsigned int type, unsigned int dpl,

                       uint64_t addr, unsigned int sel)

{

    uint32_t *p, e1, e2;

    e1 = (addr & 0xffff) | (sel << 16);

    e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);

    p = ptr;

    p[0] = tswap32(e1);

    p[1] = tswap32(e2);

    p[2] = tswap32(addr >> 32);

    p[3] = 0;

}

/* only dpl matters as we do only user space emulation */

static void set_idt(int n, unsigned int dpl)

{

    set_gate64(idt_table + n * 2, 0, dpl, 0, 0);

}

#else

static void set_gate(void *ptr, unsigned int type, unsigned int dpl,

                     uint32_t addr, unsigned int sel)

{

    uint32_t *p, e1, e2;

    e1 = (addr & 0xffff) | (sel << 16);

    e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);

    p = ptr;

    p[0] = tswap32(e1);

    p[1] = tswap32(e2);

}

/* only dpl matters as we do only user space emulation */

static void set_idt(int n, unsigned int dpl)

{

    set_gate(idt_table + n, 0, dpl, 0, 0);

}

#endif

void cpu_loop(CPUX86State *env)

{

    int trapnr;

    abi_ulong pc;

    target_siginfo_t info;

    for(;;) {

        trapnr = cpu_x86_exec(env);

        switch(trapnr) {

        case 0x80:

            /* linux syscall from int $0x80 */

            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;

#ifndef TARGET_ABI32

        case EXCP_SYSCALL:

            /* linux syscall from syscall intruction */

            env->regs[R_EAX] = do_syscall(env,

                                          env->regs[R_EAX],

                                          env->regs[R_EDI],

                                          env->regs[R_ESI],

                                          env->regs[R_EDX],

                                          env->regs[10],

                                          env->regs[8],

                                          env->regs[9]);

            env->eip = env->exception_next_eip;

            break;

#endif

        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(env, info.si_signo, &info);

            break;

        case EXCP0D_GPF:

            /* XXX: potential problem if ABI32 */

#ifndef TARGET_X86_64

            if (env->eflags & VM_MASK) {

                handle_vm86_fault(env);

            } else

#endif

            {

                info.si_signo = SIGSEGV;

                info.si_errno = 0;

                info.si_code = TARGET_SI_KERNEL;

                info._sifields._sigfault._addr = 0;

                queue_signal(env, 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(env, info.si_signo, &info);

            break;

        case EXCP00_DIVZ:

#ifndef TARGET_X86_64

            if (env->eflags & VM_MASK) {

                handle_vm86_trap(env, trapnr);

            } else

#endif

            {

                /* 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(env, info.si_signo, &info);

            }

            break;

        case EXCP01_DB:

        case EXCP03_INT3:

#ifndef TARGET_X86_64

            if (env->eflags & VM_MASK) {

                handle_vm86_trap(env, trapnr);

            } else

#endif

            {

                info.si_signo = SIGTRAP;

                info.si_errno = 0;

                if (trapnr == EXCP01_DB) {

                    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(env, info.si_signo, &info);

            }

            break;

        case EXCP04_INTO:

        case EXCP05_BOUND:

#ifndef TARGET_X86_64

            if (env->eflags & VM_MASK) {

                handle_vm86_trap(env, trapnr);

            } else

#endif

            {

                info.si_signo = SIGSEGV;

                info.si_errno = 0;

                info.si_code = TARGET_SI_KERNEL;

                info._sifields._sigfault._addr = 0;

                queue_signal(env, 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(env, info.si_signo, &info);

            break;

        case EXCP_INTERRUPT:

            /* just indicate that signals should be handled asap */

            break;

        case EXCP_DEBUG:

            {

                int sig;

                sig = gdb_handlesig (env, TARGET_SIGTRAP);

                if (sig)

                  {

                    info.si_signo = sig;

                    info.si_errno = 0;

                    info.si_code = TARGET_TRAP_BRKPT;

                    queue_signal(env, info.si_signo, &info);

                  }

            }

            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

#ifdef TARGET_ARM

static void arm_cache_flush(abi_ulong start, abi_ulong last)

{

    abi_ulong addr, last1;

    if (last < start)

        return;

    addr = start;

    for(;;) {

        last1 = ((addr + TARGET_PAGE_SIZE) & TARGET_PAGE_MASK) - 1;

        if (last1 > last)

            last1 = last;

        tb_invalidate_page_range(addr, last1 + 1);

        if (last1 == last)

            break;

        addr = last1 + 1;

    }

}

/* Handle a jump to the kernel code page.  */

static int

do_kernel_trap(CPUARMState *env)

{

    uint32_t addr;

    uint32_t cpsr;

    uint32_t val;

    switch (env->regs[15]) {

    case 0xffff0fa0: /* __kernel_memory_barrier */

        /* ??? No-op. Will need to do better for SMP.  */

        break;

    case 0xffff0fc0: /* __kernel_cmpxchg */

         /* XXX: This only works between threads, not between processes.

            It's probably possible to implement this with native host

            operations. However things like ldrex/strex are much harder so

            there's not much point trying.  */

        start_exclusive();

        cpsr = cpsr_read(env);

        addr = env->regs[2];

        /* FIXME: This should SEGV if the access fails.  */

        if (get_user_u32(val, addr))

            val = ~env->regs[0];

        if (val == env->regs[0]) {

            val = env->regs[1];

            /* FIXME: Check for segfaults.  */

            put_user_u32(val, addr);

            env->regs[0] = 0;

            cpsr |= CPSR_C;