Archipelago » qemu

//#define DEBUG_MMAP

pthread_mutex_t mmap_mutex;

static int __thread mmap_lock_count;

#include "target_signal.h"

#include "gdbstub.h"

#define THREAD __thread

#else

#define THREAD

void mmap_unlock(void);

void cpu_list_lock(void);

void cpu_list_unlock(void);

void mmap_fork_start(void);

void mmap_fork_end(int child);

#endif

#define unlock_user_struct(host_ptr, guest_addr, copy)          \

    unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)

#include <pthread.h>

#endif

fi

if test "$target_user_only" = "yes" \

        -a "$nptl" = "yes" -a "$target_nptl" = "yes"; then

fi

# 32 bit ELF loader in addition to native 64 bit loader?

if test "$target_user_only" = "yes" -a "$elfload32" = "yes"; then

    value=${line#*=}

    echo "#define $name $value"

    ;;

esac

done # read

static void cpu_unlink_tb(CPUState *env)

{

    /* FIXME: TB unchaining isn't SMP safe.  For now just ignore the

       problem and hope the cpu will stop of its own accord.  For userspace

       emulation this often isn't actually as bad as it sounds.  Often

static inline int gdb_id(CPUState *env)

{

    return env->host_tid;

#else

    return env->cpu_index + 1;

#endif

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

/* Helper routines for implementing atomic operations.  */

{

    pthread_mutex_unlock(&cpu_list_mutex);

}

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

static inline void cpu_exec_start(CPUState *env)

{

void task_settid(TaskState *ts)

{

    if (ts->ts_tid == 0) {

        ts->ts_tid = (pid_t)syscall(SYS_gettid);

#else

        /* when no threads are used, tid becomes pid */

//#define DEBUG_MMAP

pthread_mutex_t mmap_mutex = PTHREAD_MUTEX_INITIALIZER;

static int __thread mmap_lock_count;

#include "gdbstub.h"

#include "sys-queue.h"

#define THREAD __thread

#else

#define THREAD

    uint32_t v86flags;

    uint32_t v86mask;

#endif

    abi_ulong child_tidptr;

#endif

#ifdef TARGET_M68K

abi_ulong mmap_find_vma(abi_ulong, abi_ulong);

void cpu_list_lock(void);

void cpu_list_unlock(void);

void mmap_fork_start(void);

void mmap_fork_end(int child);

#endif

#define unlock_user_struct(host_ptr, guest_addr, copy)		\

    unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)

#include <pthread.h>

#endif

#include "qemu.h"

#include "qemu-common.h"

#define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \

    CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)

#else

#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)

_syscall1(int,set_tid_address,int *,tidptr)

#endif

#if defined(TARGET_NR_futex) && defined(__NR_futex)

_syscall6(int,sys_futex,int *,uaddr,int,op,int,val,

          const struct timespec *,timeout,int *,uaddr2,int,val3)

#endif /* defined(TARGET_I386) */

#define NEW_STACK_SIZE PTHREAD_STACK_MIN

    TaskState *ts;

    uint8_t *new_stack;

    CPUState *new_env;

    unsigned int nptl_flags;

    sigset_t sigmask;

#endif

    if (flags & CLONE_VM) {

        TaskState *parent_ts = (TaskState *)env->opaque;

        new_thread_info info;

        pthread_attr_t attr;

#endif

        new_env->opaque = ts;

        ts->bprm = parent_ts->bprm;

        ts->info = parent_ts->info;

        nptl_flags = flags;

        flags &= ~CLONE_NPTL_FLAGS2;

            /* Child Process.  */

            cpu_clone_regs(env, newsp);

            fork_end(1);

            /* There is a race condition here.  The parent process could

               theoretically read the TID in the child process before the child

               tid is set.  This would require using either ptrace

}

#endif

/* ??? Using host futex calls even when target atomic operations

   are not really atomic probably breaks things.  However implementing

   futexes locally would make futexes shared between multiple processes

    switch(num) {

    case TARGET_NR_exit:

      /* In old applications this may be used to implement _exit(2).

         However in threaded applictions it is used for thread termination,

         and _exit_group is used for application termination.

        }

	break;

#endif

    case TARGET_NR_futex:

        ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);

        break;

   likely to release it soon.  In environments where you have more threads

   than physical CPUs (the extreme case being a single CPU host) a spinlock

   simply wastes CPU until the OS decides to preempt it.  */

#include <pthread.h>

#define spin_lock pthread_mutex_lock