git-svn-id: https://svn.o-hand.com/repos/poky/trunk@4332 311d38ba-8fff-0310-9ca6-ca027cbcb966
1101 lines
31 KiB
Diff
1101 lines
31 KiB
Diff
---
|
|
configure | 25 ++++++
|
|
exec-all.h | 165 ------------------------------------------
|
|
linux-user/arm/syscall.h | 4 -
|
|
linux-user/main.c | 94 +++++++++++++++++++++---
|
|
linux-user/qemu.h | 3
|
|
linux-user/syscall.c | 91 ++++++++++++++++++++++-
|
|
qemu_spinlock.h | 181 +++++++++++++++++++++++++++++++++++++++++++++++
|
|
target-arm/cpu.h | 10 ++
|
|
target-arm/op.c | 6 +
|
|
target-arm/translate.c | 9 ++
|
|
10 files changed, 405 insertions(+), 183 deletions(-)
|
|
|
|
Index: trunk/configure
|
|
===================================================================
|
|
--- trunk.orig/configure 2008-04-24 20:16:52.000000000 +0100
|
|
+++ trunk/configure 2008-04-24 20:16:53.000000000 +0100
|
|
@@ -112,6 +112,7 @@
|
|
build_docs="no"
|
|
uname_release=""
|
|
curses="yes"
|
|
+nptl="yes"
|
|
|
|
# OS specific
|
|
targetos=`uname -s`
|
|
@@ -339,6 +340,8 @@
|
|
;;
|
|
*) echo "ERROR: unknown option $opt"; show_help="yes"
|
|
;;
|
|
+ --disable-nptl) nptl="no"
|
|
+ ;;
|
|
esac
|
|
done
|
|
|
|
@@ -436,6 +439,7 @@
|
|
echo " --disable-linux-user disable all linux usermode emulation targets"
|
|
echo " --enable-darwin-user enable all darwin usermode emulation targets"
|
|
echo " --disable-darwin-user disable all darwin usermode emulation targets"
|
|
+echo " --disable-nptl disable usermode NPTL guest support"
|
|
echo " --fmod-lib path to FMOD library"
|
|
echo " --fmod-inc path to FMOD includes"
|
|
echo " --enable-uname-release=R Return R for uname -r in usermode emulation"
|
|
@@ -647,6 +651,23 @@
|
|
}
|
|
EOF
|
|
|
|
+# check NPTL support
|
|
+cat > $TMPC <<EOF
|
|
+#include <sched.h>
|
|
+void foo()
|
|
+{
|
|
+#ifndef CLONE_SETTLS
|
|
+#error bork
|
|
+#endif
|
|
+}
|
|
+EOF
|
|
+
|
|
+if $cc -c -o $TMPO $TMPC 2> /dev/null ; then
|
|
+ :
|
|
+else
|
|
+ nptl="no"
|
|
+fi
|
|
+
|
|
##########################################
|
|
# SDL probe
|
|
|
|
@@ -845,6 +866,7 @@
|
|
echo "Documentation $build_docs"
|
|
[ ! -z "$uname_release" ] && \
|
|
echo "uname -r $uname_release"
|
|
+echo "NPTL support $nptl"
|
|
|
|
if test $sdl_too_old = "yes"; then
|
|
echo "-> Your SDL version is too old - please upgrade to have SDL support"
|
|
@@ -1228,6 +1250,9 @@
|
|
echo "#define TARGET_ARM 1" >> $config_h
|
|
echo "#define CONFIG_NO_DYNGEN_OP 1" >> $config_h
|
|
bflt="yes"
|
|
+ if test "$nptl" = "yes" ; then
|
|
+ echo "#define USE_NPTL 1" >> $config_h
|
|
+ fi
|
|
;;
|
|
cris)
|
|
echo "TARGET_ARCH=cris" >> $config_mak
|
|
Index: trunk/exec-all.h
|
|
===================================================================
|
|
--- trunk.orig/exec-all.h 2008-04-24 20:16:41.000000000 +0100
|
|
+++ trunk/exec-all.h 2008-04-24 20:16:53.000000000 +0100
|
|
@@ -303,217 +303,7 @@
|
|
extern CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4];
|
|
extern void *io_mem_opaque[IO_MEM_NB_ENTRIES];
|
|
|
|
-#if defined(__hppa__)
|
|
-
|
|
-typedef int spinlock_t[4];
|
|
-
|
|
-#define SPIN_LOCK_UNLOCKED { 1, 1, 1, 1 }
|
|
-
|
|
-static inline void resetlock (spinlock_t *p)
|
|
-{
|
|
- (*p)[0] = (*p)[1] = (*p)[2] = (*p)[3] = 1;
|
|
-}
|
|
-
|
|
-#else
|
|
-
|
|
-typedef int spinlock_t;
|
|
-
|
|
-#define SPIN_LOCK_UNLOCKED 0
|
|
-
|
|
-static inline void resetlock (spinlock_t *p)
|
|
-{
|
|
- *p = SPIN_LOCK_UNLOCKED;
|
|
-}
|
|
-
|
|
-#endif
|
|
-
|
|
-#if defined(__powerpc__)
|
|
-static inline int testandset (int *p)
|
|
-{
|
|
- int ret;
|
|
- __asm__ __volatile__ (
|
|
- "0: lwarx %0,0,%1\n"
|
|
- " xor. %0,%3,%0\n"
|
|
- " bne 1f\n"
|
|
- " stwcx. %2,0,%1\n"
|
|
- " bne- 0b\n"
|
|
- "1: "
|
|
- : "=&r" (ret)
|
|
- : "r" (p), "r" (1), "r" (0)
|
|
- : "cr0", "memory");
|
|
- return ret;
|
|
-}
|
|
-#elif defined(__i386__)
|
|
-static inline int testandset (int *p)
|
|
-{
|
|
- long int readval = 0;
|
|
-
|
|
- __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
|
|
- : "+m" (*p), "+a" (readval)
|
|
- : "r" (1)
|
|
- : "cc");
|
|
- return readval;
|
|
-}
|
|
-#elif defined(__x86_64__)
|
|
-static inline int testandset (int *p)
|
|
-{
|
|
- long int readval = 0;
|
|
-
|
|
- __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
|
|
- : "+m" (*p), "+a" (readval)
|
|
- : "r" (1)
|
|
- : "cc");
|
|
- return readval;
|
|
-}
|
|
-#elif defined(__s390__)
|
|
-static inline int testandset (int *p)
|
|
-{
|
|
- int ret;
|
|
-
|
|
- __asm__ __volatile__ ("0: cs %0,%1,0(%2)\n"
|
|
- " jl 0b"
|
|
- : "=&d" (ret)
|
|
- : "r" (1), "a" (p), "0" (*p)
|
|
- : "cc", "memory" );
|
|
- return ret;
|
|
-}
|
|
-#elif defined(__alpha__)
|
|
-static inline int testandset (int *p)
|
|
-{
|
|
- int ret;
|
|
- unsigned long one;
|
|
-
|
|
- __asm__ __volatile__ ("0: mov 1,%2\n"
|
|
- " ldl_l %0,%1\n"
|
|
- " stl_c %2,%1\n"
|
|
- " beq %2,1f\n"
|
|
- ".subsection 2\n"
|
|
- "1: br 0b\n"
|
|
- ".previous"
|
|
- : "=r" (ret), "=m" (*p), "=r" (one)
|
|
- : "m" (*p));
|
|
- return ret;
|
|
-}
|
|
-#elif defined(__sparc__)
|
|
-static inline int testandset (int *p)
|
|
-{
|
|
- int ret;
|
|
-
|
|
- __asm__ __volatile__("ldstub [%1], %0"
|
|
- : "=r" (ret)
|
|
- : "r" (p)
|
|
- : "memory");
|
|
-
|
|
- return (ret ? 1 : 0);
|
|
-}
|
|
-#elif defined(__arm__)
|
|
-static inline int testandset (int *spinlock)
|
|
-{
|
|
- register unsigned int ret;
|
|
- __asm__ __volatile__("swp %0, %1, [%2]"
|
|
- : "=r"(ret)
|
|
- : "0"(1), "r"(spinlock));
|
|
-
|
|
- return ret;
|
|
-}
|
|
-#elif defined(__mc68000)
|
|
-static inline int testandset (int *p)
|
|
-{
|
|
- char ret;
|
|
- __asm__ __volatile__("tas %1; sne %0"
|
|
- : "=r" (ret)
|
|
- : "m" (p)
|
|
- : "cc","memory");
|
|
- return ret;
|
|
-}
|
|
-#elif defined(__hppa__)
|
|
-
|
|
-/* Because malloc only guarantees 8-byte alignment for malloc'd data,
|
|
- and GCC only guarantees 8-byte alignment for stack locals, we can't
|
|
- be assured of 16-byte alignment for atomic lock data even if we
|
|
- specify "__attribute ((aligned(16)))" in the type declaration. So,
|
|
- we use a struct containing an array of four ints for the atomic lock
|
|
- type and dynamically select the 16-byte aligned int from the array
|
|
- for the semaphore. */
|
|
-#define __PA_LDCW_ALIGNMENT 16
|
|
-static inline void *ldcw_align (void *p) {
|
|
- unsigned long a = (unsigned long)p;
|
|
- a = (a + __PA_LDCW_ALIGNMENT - 1) & ~(__PA_LDCW_ALIGNMENT - 1);
|
|
- return (void *)a;
|
|
-}
|
|
-
|
|
-static inline int testandset (spinlock_t *p)
|
|
-{
|
|
- unsigned int ret;
|
|
- p = ldcw_align(p);
|
|
- __asm__ __volatile__("ldcw 0(%1),%0"
|
|
- : "=r" (ret)
|
|
- : "r" (p)
|
|
- : "memory" );
|
|
- return !ret;
|
|
-}
|
|
-
|
|
-#elif defined(__ia64)
|
|
-
|
|
-#include <ia64intrin.h>
|
|
-
|
|
-static inline int testandset (int *p)
|
|
-{
|
|
- return __sync_lock_test_and_set (p, 1);
|
|
-}
|
|
-#elif defined(__mips__)
|
|
-static inline int testandset (int *p)
|
|
-{
|
|
- int ret;
|
|
-
|
|
- __asm__ __volatile__ (
|
|
- " .set push \n"
|
|
- " .set noat \n"
|
|
- " .set mips2 \n"
|
|
- "1: li $1, 1 \n"
|
|
- " ll %0, %1 \n"
|
|
- " sc $1, %1 \n"
|
|
- " beqz $1, 1b \n"
|
|
- " .set pop "
|
|
- : "=r" (ret), "+R" (*p)
|
|
- :
|
|
- : "memory");
|
|
-
|
|
- return ret;
|
|
-}
|
|
-#else
|
|
-#error unimplemented CPU support
|
|
-#endif
|
|
-
|
|
-#if defined(CONFIG_USER_ONLY)
|
|
-static inline void spin_lock(spinlock_t *lock)
|
|
-{
|
|
- while (testandset(lock));
|
|
-}
|
|
-
|
|
-static inline void spin_unlock(spinlock_t *lock)
|
|
-{
|
|
- resetlock(lock);
|
|
-}
|
|
-
|
|
-static inline int spin_trylock(spinlock_t *lock)
|
|
-{
|
|
- return !testandset(lock);
|
|
-}
|
|
-#else
|
|
-static inline void spin_lock(spinlock_t *lock)
|
|
-{
|
|
-}
|
|
-
|
|
-static inline void spin_unlock(spinlock_t *lock)
|
|
-{
|
|
-}
|
|
-
|
|
-static inline int spin_trylock(spinlock_t *lock)
|
|
-{
|
|
- return 1;
|
|
-}
|
|
-#endif
|
|
+#include "qemu_spinlock.h"
|
|
|
|
extern spinlock_t tb_lock;
|
|
|
|
Index: trunk/linux-user/arm/syscall.h
|
|
===================================================================
|
|
--- trunk.orig/linux-user/arm/syscall.h 2008-04-24 20:16:41.000000000 +0100
|
|
+++ trunk/linux-user/arm/syscall.h 2008-04-24 20:16:53.000000000 +0100
|
|
@@ -28,7 +28,9 @@
|
|
#define ARM_SYSCALL_BASE 0x900000
|
|
#define ARM_THUMB_SYSCALL 0
|
|
|
|
-#define ARM_NR_cacheflush (ARM_SYSCALL_BASE + 0xf0000 + 2)
|
|
+#define ARM_NR_BASE 0xf0000
|
|
+#define ARM_NR_cacheflush (ARM_NR_BASE + 2)
|
|
+#define ARM_NR_set_tls (ARM_NR_BASE + 5)
|
|
|
|
#define ARM_NR_semihosting 0x123456
|
|
#define ARM_NR_thumb_semihosting 0xAB
|
|
Index: trunk/linux-user/main.c
|
|
===================================================================
|
|
--- trunk.orig/linux-user/main.c 2008-04-24 20:16:47.000000000 +0100
|
|
+++ trunk/linux-user/main.c 2008-04-24 20:17:38.000000000 +0100
|
|
@@ -365,6 +365,50 @@
|
|
}
|
|
}
|
|
|
|
+/* Handle a jump to the kernel code page. */
|
|
+static int
|
|
+do_kernel_trap(CPUARMState *env)
|
|
+{
|
|
+ uint32_t addr;
|
|
+ uint32_t *ptr;
|
|
+ uint32_t cpsr;
|
|
+
|
|
+ switch (env->regs[15]) {
|
|
+ case 0xffff0fc0: /* __kernel_cmpxchg */
|
|
+ /* XXX: This only works between threads, not between processes.
|
|
+ Use native atomic operations. */
|
|
+ /* ??? This probably breaks horribly if the access segfaults. */
|
|
+ cpu_lock();
|
|
+ ptr = (uint32_t *)env->regs[2];
|
|
+ cpsr = cpsr_read(env);
|
|
+ if (*ptr == env->regs[0]) {
|
|
+ *ptr = env->regs[1];
|
|
+ env->regs[0] = 0;
|
|
+ cpsr |= CPSR_C;
|
|
+ } else {
|
|
+ env->regs[0] = -1;
|
|
+ cpsr &= ~CPSR_C;
|
|
+ }
|
|
+ cpsr_write(env, cpsr, CPSR_C);
|
|
+ cpu_unlock();
|
|
+ break;
|
|
+ case 0xffff0fe0: /* __kernel_get_tls */
|
|
+ env->regs[0] = env->cp15.c13_tls2;
|
|
+ break;
|
|
+ default:
|
|
+ return 1;
|
|
+ }
|
|
+ /* Jump back to the caller. */
|
|
+ addr = env->regs[14];
|
|
+ if (addr & 1) {
|
|
+ env->thumb = 1;
|
|
+ addr &= ~1;
|
|
+ }
|
|
+ env->regs[15] = addr;
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+
|
|
void cpu_loop(CPUARMState *env)
|
|
{
|
|
int trapnr;
|
|
@@ -475,10 +519,8 @@
|
|
}
|
|
}
|
|
|
|
- if (n == ARM_NR_cacheflush) {
|
|
- arm_cache_flush(env->regs[0], env->regs[1]);
|
|
- } else if (n == ARM_NR_semihosting
|
|
- || n == ARM_NR_thumb_semihosting) {
|
|
+ if (n == ARM_NR_semihosting
|
|
+ || n == ARM_NR_thumb_semihosting) {
|
|
env->regs[0] = do_arm_semihosting (env);
|
|
} else if (n == 0 || n >= ARM_SYSCALL_BASE
|
|
|| (env->thumb && n == ARM_THUMB_SYSCALL)) {
|
|
@@ -489,14 +531,34 @@
|
|
n -= ARM_SYSCALL_BASE;
|
|
env->eabi = 0;
|
|
}
|
|
- env->regs[0] = do_syscall(env,
|
|
- n,
|
|
- env->regs[0],
|
|
- env->regs[1],
|
|
- env->regs[2],
|
|
- env->regs[3],
|
|
- env->regs[4],
|
|
- env->regs[5]);
|
|
+ if ( n > ARM_NR_BASE) {
|
|
+ switch (n)
|
|
+ {
|
|
+ case ARM_NR_cacheflush:
|
|
+ arm_cache_flush(env->regs[0], env->regs[1]);
|
|
+ break;
|
|
+#ifdef USE_NPTL
|
|
+ case ARM_NR_set_tls:
|
|
+ cpu_set_tls(env, env->regs[0]);
|
|
+ env->regs[0] = 0;
|
|
+ break;
|
|
+#endif
|
|
+ default:
|
|
+ printf ("Error: Bad syscall: %x\n", n);
|
|
+ goto error;
|
|
+ }
|
|
+ }
|
|
+ else
|
|
+ {
|
|
+ env->regs[0] = do_syscall(env,
|
|
+ n,
|
|
+ env->regs[0],
|
|
+ env->regs[1],
|
|
+ env->regs[2],
|
|
+ env->regs[3],
|
|
+ env->regs[4],
|
|
+ env->regs[5]);
|
|
+ }
|
|
} else {
|
|
goto error;
|
|
}
|
|
@@ -535,6 +597,10 @@
|
|
}
|
|
}
|
|
break;
|
|
+ case EXCP_KERNEL_TRAP:
|
|
+ if (do_kernel_trap(env))
|
|
+ goto error;
|
|
+ break;
|
|
default:
|
|
error:
|
|
fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
|
|
@@ -1994,6 +2060,11 @@
|
|
int drop_ld_preload = 0, environ_count = 0;
|
|
char **target_environ, **wrk, **dst;
|
|
|
|
+ char *assume_kernel = getenv("QEMU_ASSUME_KERNEL");
|
|
+
|
|
+ if (assume_kernel)
|
|
+ setenv("LD_ASSUME_KERNEL", assume_kernel, 1);
|
|
+
|
|
if (argc <= 1)
|
|
usage();
|
|
|
|
@@ -2403,6 +2474,10 @@
|
|
ts->heap_base = info->brk;
|
|
/* This will be filled in on the first SYS_HEAPINFO call. */
|
|
ts->heap_limit = 0;
|
|
+ /* Register the magic kernel code page. The cpu will generate a
|
|
+ special exception when it tries to execute code here. We can't
|
|
+ put real code here because it may be in use by the host kernel. */
|
|
+ page_set_flags(0xffff0000, 0xffff0fff, 0);
|
|
#endif
|
|
|
|
if (gdbstub_port) {
|
|
Index: trunk/linux-user/qemu.h
|
|
===================================================================
|
|
--- trunk.orig/linux-user/qemu.h 2008-04-24 20:16:41.000000000 +0100
|
|
+++ trunk/linux-user/qemu.h 2008-04-24 20:16:53.000000000 +0100
|
|
@@ -107,6 +107,9 @@
|
|
uint32_t heap_base;
|
|
uint32_t heap_limit;
|
|
#endif
|
|
+#ifdef USE_NPTL
|
|
+ uint32_t *child_tidptr;
|
|
+#endif
|
|
int used; /* non zero if used */
|
|
struct image_info *info;
|
|
uint8_t stack[0];
|
|
Index: trunk/linux-user/syscall.c
|
|
===================================================================
|
|
--- trunk.orig/linux-user/syscall.c 2008-04-24 20:16:50.000000000 +0100
|
|
+++ trunk/linux-user/syscall.c 2008-04-24 20:19:52.000000000 +0100
|
|
@@ -61,6 +61,7 @@
|
|
#define tchars host_tchars /* same as target */
|
|
#define ltchars host_ltchars /* same as target */
|
|
|
|
+#include <linux/futex.h>
|
|
#include <linux/termios.h>
|
|
#include <linux/unistd.h>
|
|
#include <linux/utsname.h>
|
|
@@ -71,9 +72,18 @@
|
|
#include <linux/kd.h>
|
|
|
|
#include "qemu.h"
|
|
+#include "qemu_spinlock.h"
|
|
|
|
//#define DEBUG
|
|
|
|
+#ifdef USE_NPTL
|
|
+#define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \
|
|
+ CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)
|
|
+#else
|
|
+/* XXX: Hardcode the above values. */
|
|
+#define CLONE_NPTL_FLAGS2 0
|
|
+#endif
|
|
+
|
|
#if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC) \
|
|
|| defined(TARGET_M68K) || defined(TARGET_SH4) || defined(TARGET_CRIS)
|
|
/* 16 bit uid wrappers emulation */
|
|
@@ -2695,16 +2705,25 @@
|
|
return 0;
|
|
}
|
|
#endif
|
|
-
|
|
#endif /* defined(TARGET_I386) */
|
|
|
|
/* this stack is the equivalent of the kernel stack associated with a
|
|
thread/process */
|
|
#define NEW_STACK_SIZE 8192
|
|
|
|
+#ifdef USE_NPTL
|
|
+static spinlock_t nptl_lock = SPIN_LOCK_UNLOCKED;
|
|
+#endif
|
|
+
|
|
static int clone_func(void *arg)
|
|
{
|
|
CPUState *env = arg;
|
|
+#ifdef HAVE_NPTL
|
|
+ /* Wait until the parent has finshed initializing the tls state. */
|
|
+ while (!spin_trylock(&nptl_lock))
|
|
+ usleep(1);
|
|
+ spin_unlock(&nptl_lock);
|
|
+#endif
|
|
cpu_loop(env);
|
|
/* never exits */
|
|
return 0;
|
|
@@ -2712,15 +2731,27 @@
|
|
|
|
/* do_fork() Must return host values and target errnos (unlike most
|
|
do_*() functions). */
|
|
-int do_fork(CPUState *env, unsigned int flags, abi_ulong newsp)
|
|
+int do_fork(CPUState *env, unsigned int flags, unsigned long newsp,
|
|
+ uint32_t *parent_tidptr, void *newtls,
|
|
+ uint32_t *child_tidptr)
|
|
{
|
|
int ret;
|
|
TaskState *ts;
|
|
uint8_t *new_stack;
|
|
CPUState *new_env;
|
|
+#if defined(TARGET_I386)
|
|
+ uint64_t *new_gdt_table;
|
|
+#endif
|
|
+#ifdef USE_NPTL
|
|
+ unsigned int nptl_flags;
|
|
|
|
+ if (flags & CLONE_PARENT_SETTID)
|
|
+ *parent_tidptr = gettid();
|
|
+#endif
|
|
if (flags & CLONE_VM) {
|
|
ts = malloc(sizeof(TaskState) + NEW_STACK_SIZE);
|
|
+ if (!ts)
|
|
+ return -ENOMEM;
|
|
memset(ts, 0, sizeof(TaskState));
|
|
new_stack = ts->stack;
|
|
ts->used = 1;
|
|
@@ -2732,6 +2763,29 @@
|
|
#if defined(TARGET_I386)
|
|
if (!newsp)
|
|
newsp = env->regs[R_ESP];
|
|
+ new_gdt_table = malloc(9 * 8);
|
|
+ if (!new_gdt_table) {
|
|
+ free(new_env);
|
|
+ return -ENOMEM;
|
|
+ }
|
|
+ /* Copy main GDT table from parent, but clear TLS entries */
|
|
+ memcpy(new_gdt_table, g2h(env->gdt.base), 6 * 8);
|
|
+ memset(&new_gdt_table[6], 0, 3 * 8);
|
|
+ new_env->gdt.base = h2g(new_gdt_table);
|
|
+ if (flags & 0x00080000 /* CLONE_SETTLS */) {
|
|
+ ret = do_set_thread_area(new_env, new_env->regs[R_ESI]);
|
|
+ if (ret) {
|
|
+ free(new_gdt_table);
|
|
+ free(new_env);
|
|
+ return ret;
|
|
+ }
|
|
+ }
|
|
+ cpu_x86_load_seg(env, R_CS, new_env->regs[R_CS]);
|
|
+ cpu_x86_load_seg(env, R_DS, new_env->regs[R_DS]);
|
|
+ cpu_x86_load_seg(env, R_ES, new_env->regs[R_ES]);
|
|
+ cpu_x86_load_seg(env, R_SS, new_env->regs[R_SS]);
|
|
+ cpu_x86_load_seg(env, R_FS, new_env->regs[R_FS]);
|
|
+ cpu_x86_load_seg(env, R_GS, new_env->regs[R_GS]);
|
|
new_env->regs[R_ESP] = newsp;
|
|
new_env->regs[R_EAX] = 0;
|
|
#elif defined(TARGET_ARM)
|
|
@@ -2784,16 +2838,67 @@
|
|
#error unsupported target CPU
|
|
#endif
|
|
new_env->opaque = ts;
|
|
+#ifdef USE_NPTL
|
|
+ nptl_flags = flags;
|
|
+ flags &= ~CLONE_NPTL_FLAGS2;
|
|
+
|
|
+ if (nptl_flags & CLONE_CHILD_CLEARTID) {
|
|
+ ts->child_tidptr = child_tidptr;
|
|
+ }
|
|
+
|
|
+ if (nptl_flags & CLONE_SETTLS)
|
|
+ cpu_set_tls (new_env, newtls);
|
|
+
|
|
+ /* Grab the global cpu lock so that the thread setup appears
|
|
+ atomic. */
|
|
+ if (nptl_flags & CLONE_CHILD_SETTID)
|
|
+ spin_lock(&nptl_lock);
|
|
+
|
|
+#else
|
|
+ if (flags & CLONE_NPTL_FLAGS2)
|
|
+ return -EINVAL;
|
|
+#endif
|
|
+
|
|
+ if (CLONE_VFORK & flags)
|
|
+ flags ^= CLONE_VM;
|
|
#ifdef __ia64__
|
|
ret = __clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
|
|
#else
|
|
ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
|
|
#endif
|
|
+#ifdef USE_NPTL
|
|
+ if (ret != -1) {
|
|
+ if (nptl_flags & CLONE_CHILD_SETTID)
|
|
+ *child_tidptr = ret;
|
|
+ }
|
|
+
|
|
+ /* Allow the child to continue. */
|
|
+ if (nptl_flags & CLONE_CHILD_SETTID)
|
|
+ spin_unlock(&nptl_lock);
|
|
+#endif
|
|
} else {
|
|
/* if no CLONE_VM, we consider it is a fork */
|
|
- if ((flags & ~CSIGNAL) != 0)
|
|
+ if ((flags & ~(CSIGNAL | CLONE_NPTL_FLAGS2)) != 0)
|
|
return -EINVAL;
|
|
ret = fork();
|
|
+#ifdef USE_NPTL
|
|
+ /* 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
|
|
+ (not implemented) or having *_tidptr to point at a shared memory
|
|
+ mapping. We can't repeat the spinlock hack used above because
|
|
+ the child process gets its own copy of the lock. */
|
|
+ if (ret == 0) {
|
|
+ /* Child Process. */
|
|
+ if (flags & CLONE_CHILD_SETTID)
|
|
+ *child_tidptr = gettid();
|
|
+ ts = (TaskState *)env->opaque;
|
|
+ if (flags & CLONE_CHILD_CLEARTID)
|
|
+ ts->child_tidptr = child_tidptr;
|
|
+ if (flags & CLONE_SETTLS)
|
|
+ cpu_set_tls (env, newtls);
|
|
+ }
|
|
+#endif
|
|
}
|
|
return ret;
|
|
}
|
|
@@ -3052,6 +3157,68 @@
|
|
unlock_user_struct(target_ts, target_addr, 1);
|
|
}
|
|
|
|
+static long do_futex(target_ulong uaddr, int op, uint32_t val,
|
|
+ target_ulong utime, target_ulong uaddr2,
|
|
+ uint32_t val3)
|
|
+{
|
|
+ struct timespec host_utime;
|
|
+ unsigned long val2 = utime;
|
|
+
|
|
+ if (utime && (op == FUTEX_WAIT || op == FUTEX_LOCK_PI)) {
|
|
+ target_to_host_timespec(&host_utime, utime);
|
|
+ val2 = (unsigned long)&host_utime;
|
|
+ }
|
|
+
|
|
+#ifdef BSWAP_NEEDED
|
|
+ switch(op) {
|
|
+ case FUTEX_CMP_REQUEUE:
|
|
+ val3 = tswap32(val3);
|
|
+ case FUTEX_REQUEUE:
|
|
+ val2 = tswap32(val2);
|
|
+ case FUTEX_WAIT:
|
|
+ case FUTEX_WAKE:
|
|
+ val = tswap32(val);
|
|
+ case FUTEX_LOCK_PI: /* This one's icky, but comes out OK */
|
|
+ case FUTEX_UNLOCK_PI:
|
|
+ break;
|
|
+ default:
|
|
+ gemu_log("qemu: Unsupported futex op %d\n", op);
|
|
+ return -ENOSYS;
|
|
+ }
|
|
+#if 0 /* No, it's worse than this */
|
|
+ if (op == FUTEX_WAKE_OP) {
|
|
+ /* Need to munge the secondary operation (val3) */
|
|
+ val3 = tswap32(val3);
|
|
+ int op2 = (val3 >> 28) & 7;
|
|
+ int cmp = (val3 >> 24) & 15;
|
|
+ int oparg = (val3 << 8) >> 20;
|
|
+ int cmparg = (val3 << 20) >> 20;
|
|
+ int shift = val3 & (FUTEX_OP_OPARG_SHIFT << 28);
|
|
+
|
|
+ if (shift)
|
|
+ oparg = (oparg & 7) + 24 - (oparg & 24);
|
|
+ else oparg =
|
|
+ if (op2 == FUTEX_OP_ADD) {
|
|
+ gemu_log("qemu: Unsupported wrong-endian FUTEX_OP_ADD\n");
|
|
+ return -ENOSYS;
|
|
+ }
|
|
+ if (cmparg == FUTEX_OP_CMP_LT || cmparg == FUTEX_OP_CMP_GE ||
|
|
+ cmparg == FUTEX_OP_CMP_LE || cmparg == FUTEX_OP_CMP_GT) {
|
|
+ gemu_log("qemu: Unsupported wrong-endian futex cmparg %d\n", cmparg);
|
|
+ return -ENOSYS;
|
|
+ }
|
|
+ val3 = shift | (op2<<28) | (cmp<<24) | (oparg<<12) | cmparg;
|
|
+ }
|
|
+#endif
|
|
+#endif
|
|
+ return syscall(__NR_futex, g2h(uaddr), op, val, val2, g2h(uaddr2), val3);
|
|
+}
|
|
+
|
|
+int do_set_tid_address(target_ulong tidptr)
|
|
+{
|
|
+ return syscall(__NR_set_tid_address, g2h(tidptr));
|
|
+}
|
|
+
|
|
/* do_syscall() should always have a single exit point at the end so
|
|
that actions, such as logging of syscall results, can be performed.
|
|
All errnos that do_syscall() returns must be -TARGET_<errcode>. */
|
|
@@ -3076,7 +3243,7 @@
|
|
_mcleanup();
|
|
#endif
|
|
gdb_exit(cpu_env, arg1);
|
|
- /* XXX: should free thread stack and CPU env */
|
|
+ /* XXX: should free thread stack, GDT and CPU env */
|
|
_exit(arg1);
|
|
ret = 0; /* avoid warning */
|
|
break;
|
|
@@ -3118,7 +3285,7 @@
|
|
ret = do_brk(arg1);
|
|
break;
|
|
case TARGET_NR_fork:
|
|
- ret = get_errno(do_fork(cpu_env, SIGCHLD, 0));
|
|
+ ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, NULL, NULL, NULL));
|
|
break;
|
|
#ifdef TARGET_NR_waitpid
|
|
case TARGET_NR_waitpid:
|
|
@@ -4482,7 +4649,8 @@
|
|
ret = get_errno(fsync(arg1));
|
|
break;
|
|
case TARGET_NR_clone:
|
|
- ret = get_errno(do_fork(cpu_env, arg1, arg2));
|
|
+ ret = get_errno(do_fork(cpu_env, arg1, arg2, (uint32_t *)arg3,
|
|
+ (void *)arg4, (uint32_t *)arg5));
|
|
break;
|
|
#ifdef __NR_exit_group
|
|
/* new thread calls */
|
|
@@ -4943,7 +5111,8 @@
|
|
#endif
|
|
#ifdef TARGET_NR_vfork
|
|
case TARGET_NR_vfork:
|
|
- ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD, 0));
|
|
+ ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
|
|
+ NULL, NULL, NULL));
|
|
break;
|
|
#endif
|
|
#ifdef TARGET_NR_ugetrlimit
|
|
@@ -5521,6 +5690,9 @@
|
|
#elif defined(TARGET_I386) && defined(TARGET_ABI32)
|
|
ret = do_set_thread_area(cpu_env, arg1);
|
|
break;
|
|
+#elif TARGET_i386
|
|
+ ret = get_errno(do_set_thread_area(cpu_env, arg1));
|
|
+ break;
|
|
#else
|
|
goto unimplemented_nowarn;
|
|
#endif
|
|
@@ -5538,6 +5710,12 @@
|
|
goto unimplemented_nowarn;
|
|
#endif
|
|
|
|
+#ifdef TARGET_NR_futex
|
|
+ case TARGET_NR_futex:
|
|
+ ret = get_errno(do_futex(arg1, arg2, arg3, arg4, arg5, arg6));
|
|
+ break;
|
|
+#endif
|
|
+
|
|
#ifdef TARGET_NR_clock_gettime
|
|
case TARGET_NR_clock_gettime:
|
|
{
|
|
Index: trunk/qemu_spinlock.h
|
|
===================================================================
|
|
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
|
|
+++ trunk/qemu_spinlock.h 2008-04-24 20:16:53.000000000 +0100
|
|
@@ -0,0 +1,250 @@
|
|
+/*
|
|
+ * Atomic operation helper include
|
|
+ *
|
|
+ * Copyright (c) 2005 Fabrice Bellard
|
|
+ *
|
|
+ * This library is free software; you can redistribute it and/or
|
|
+ * modify it under the terms of the GNU Lesser General Public
|
|
+ * License as published by the Free Software Foundation; either
|
|
+ * version 2 of the License, or (at your option) any later version.
|
|
+ *
|
|
+ * This library 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
|
|
+ * Lesser General Public License for more details.
|
|
+ *
|
|
+ * You should have received a copy of the GNU Lesser General Public
|
|
+ * License along with this library; if not, write to the Free Software
|
|
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
+ */
|
|
+#ifndef QEMU_SPINLOCK_H
|
|
+#define QEMU_SPINLOCK_H
|
|
+
|
|
+#ifdef __powerpc__
|
|
+static inline int testandset (int *p)
|
|
+{
|
|
+ int ret;
|
|
+ __asm__ __volatile__ (
|
|
+ "0: lwarx %0,0,%1\n"
|
|
+ " xor. %0,%3,%0\n"
|
|
+ " bne 1f\n"
|
|
+ " stwcx. %2,0,%1\n"
|
|
+ " bne- 0b\n"
|
|
+ "1: "
|
|
+ : "=&r" (ret)
|
|
+ : "r" (p), "r" (1), "r" (0)
|
|
+ : "cr0", "memory");
|
|
+ return ret;
|
|
+}
|
|
+#endif
|
|
+
|
|
+#ifdef __i386__
|
|
+static inline int testandset (int *p)
|
|
+{
|
|
+ long int readval = 0;
|
|
+
|
|
+ __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
|
|
+ : "+m" (*p), "+a" (readval)
|
|
+ : "r" (1)
|
|
+ : "cc");
|
|
+ return readval;
|
|
+}
|
|
+#endif
|
|
+
|
|
+#ifdef __x86_64__
|
|
+static inline int testandset (int *p)
|
|
+{
|
|
+ long int readval = 0;
|
|
+
|
|
+ __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
|
|
+ : "+m" (*p), "+a" (readval)
|
|
+ : "r" (1)
|
|
+ : "cc");
|
|
+ return readval;
|
|
+}
|
|
+#endif
|
|
+
|
|
+#ifdef __s390__
|
|
+static inline int testandset (int *p)
|
|
+{
|
|
+ int ret;
|
|
+
|
|
+ __asm__ __volatile__ ("0: cs %0,%1,0(%2)\n"
|
|
+ " jl 0b"
|
|
+ : "=&d" (ret)
|
|
+ : "r" (1), "a" (p), "0" (*p)
|
|
+ : "cc", "memory" );
|
|
+ return ret;
|
|
+}
|
|
+#endif
|
|
+
|
|
+#ifdef __alpha__
|
|
+static inline int testandset (int *p)
|
|
+{
|
|
+ int ret;
|
|
+ unsigned long one;
|
|
+
|
|
+ __asm__ __volatile__ ("0: mov 1,%2\n"
|
|
+ " ldl_l %0,%1\n"
|
|
+ " stl_c %2,%1\n"
|
|
+ " beq %2,1f\n"
|
|
+ ".subsection 2\n"
|
|
+ "1: br 0b\n"
|
|
+ ".previous"
|
|
+ : "=r" (ret), "=m" (*p), "=r" (one)
|
|
+ : "m" (*p));
|
|
+ return ret;
|
|
+}
|
|
+#endif
|
|
+
|
|
+#ifdef __sparc__
|
|
+static inline int testandset (int *p)
|
|
+{
|
|
+ int ret;
|
|
+
|
|
+ __asm__ __volatile__("ldstub [%1], %0"
|
|
+ : "=r" (ret)
|
|
+ : "r" (p)
|
|
+ : "memory");
|
|
+
|
|
+ return (ret ? 1 : 0);
|
|
+}
|
|
+#endif
|
|
+
|
|
+#ifdef __arm__
|
|
+static inline int testandset (int *spinlock)
|
|
+{
|
|
+ register unsigned int ret;
|
|
+ __asm__ __volatile__("swp %0, %1, [%2]"
|
|
+ : "=r"(ret)
|
|
+ : "0"(1), "r"(spinlock));
|
|
+
|
|
+ return ret;
|
|
+}
|
|
+#endif
|
|
+
|
|
+#ifdef __mc68000
|
|
+static inline int testandset (int *p)
|
|
+{
|
|
+ char ret;
|
|
+ __asm__ __volatile__("tas %1; sne %0"
|
|
+ : "=r" (ret)
|
|
+ : "m" (p)
|
|
+ : "cc","memory");
|
|
+ return ret;
|
|
+}
|
|
+#endif
|
|
+
|
|
+#ifdef __hppa__
|
|
+/* Because malloc only guarantees 8-byte alignment for malloc'd data,
|
|
+ and GCC only guarantees 8-byte alignment for stack locals, we can't
|
|
+ be assured of 16-byte alignment for atomic lock data even if we
|
|
+ specify "__attribute ((aligned(16)))" in the type declaration. So,
|
|
+ we use a struct containing an array of four ints for the atomic lock
|
|
+ type and dynamically select the 16-byte aligned int from the array
|
|
+ for the semaphore. */
|
|
+#define __PA_LDCW_ALIGNMENT 16
|
|
+static inline void *ldcw_align (void *p) {
|
|
+ unsigned long a = (unsigned long)p;
|
|
+ a = (a + __PA_LDCW_ALIGNMENT - 1) & ~(__PA_LDCW_ALIGNMENT - 1);
|
|
+ return (void *)a;
|
|
+}
|
|
+
|
|
+static inline int testandset (spinlock_t *p)
|
|
+{
|
|
+ unsigned int ret;
|
|
+ p = ldcw_align(p);
|
|
+ __asm__ __volatile__("ldcw 0(%1),%0"
|
|
+ : "=r" (ret)
|
|
+ : "r" (p)
|
|
+ : "memory" );
|
|
+ return !ret;
|
|
+}
|
|
+#endif
|
|
+
|
|
+#ifdef __ia64
|
|
+#include <ia64intrin.h>
|
|
+
|
|
+static inline int testandset (int *p)
|
|
+{
|
|
+ return __sync_lock_test_and_set (p, 1);
|
|
+}
|
|
+#endif
|
|
+
|
|
+#ifdef __mips__
|
|
+static inline int testandset (int *p)
|
|
+{
|
|
+ int ret;
|
|
+
|
|
+ __asm__ __volatile__ (
|
|
+ " .set push \n"
|
|
+ " .set noat \n"
|
|
+ " .set mips2 \n"
|
|
+ "1: li $1, 1 \n"
|
|
+ " ll %0, %1 \n"
|
|
+ " sc $1, %1 \n"
|
|
+ " beqz $1, 1b \n"
|
|
+ " .set pop "
|
|
+ : "=r" (ret), "+R" (*p)
|
|
+ :
|
|
+ : "memory");
|
|
+
|
|
+ return ret;
|
|
+}
|
|
+#endif
|
|
+
|
|
+#if defined(__hppa__)
|
|
+
|
|
+typedef int spinlock_t[4];
|
|
+
|
|
+#define SPIN_LOCK_UNLOCKED { 1, 1, 1, 1 }
|
|
+
|
|
+static inline void resetlock (spinlock_t *p)
|
|
+{
|
|
+ (*p)[0] = (*p)[1] = (*p)[2] = (*p)[3] = 1;
|
|
+}
|
|
+
|
|
+#else
|
|
+
|
|
+typedef int spinlock_t;
|
|
+
|
|
+#define SPIN_LOCK_UNLOCKED 0
|
|
+
|
|
+static inline void resetlock (spinlock_t *p)
|
|
+{
|
|
+ *p = SPIN_LOCK_UNLOCKED;
|
|
+}
|
|
+
|
|
+#endif
|
|
+
|
|
+#if defined(CONFIG_USER_ONLY)
|
|
+static inline void spin_lock(spinlock_t *lock)
|
|
+{
|
|
+ while (testandset(lock));
|
|
+}
|
|
+
|
|
+static inline void spin_unlock(spinlock_t *lock)
|
|
+{
|
|
+ resetlock(lock);
|
|
+}
|
|
+
|
|
+static inline int spin_trylock(spinlock_t *lock)
|
|
+{
|
|
+ return !testandset(lock);
|
|
+}
|
|
+#else
|
|
+static inline void spin_lock(spinlock_t *lock)
|
|
+{
|
|
+}
|
|
+
|
|
+static inline void spin_unlock(spinlock_t *lock)
|
|
+{
|
|
+}
|
|
+
|
|
+static inline int spin_trylock(spinlock_t *lock)
|
|
+{
|
|
+ return 1;
|
|
+}
|
|
+#endif
|
|
+
|
|
+#endif
|
|
Index: trunk/target-arm/cpu.h
|
|
===================================================================
|
|
--- trunk.orig/target-arm/cpu.h 2008-04-24 20:16:41.000000000 +0100
|
|
+++ trunk/target-arm/cpu.h 2008-04-24 20:16:53.000000000 +0100
|
|
@@ -38,6 +38,7 @@
|
|
#define EXCP_FIQ 6
|
|
#define EXCP_BKPT 7
|
|
#define EXCP_EXCEPTION_EXIT 8 /* Return from v7M exception. */
|
|
+#define EXCP_KERNEL_TRAP 9 /* Jumped to kernel code page. */
|
|
|
|
#define ARMV7M_EXCP_RESET 1
|
|
#define ARMV7M_EXCP_NMI 2
|
|
@@ -218,6 +219,15 @@
|
|
void cpu_lock(void);
|
|
void cpu_unlock(void);
|
|
|
|
+void cpu_lock(void);
|
|
+void cpu_unlock(void);
|
|
+#if defined(USE_NPTL)
|
|
+static inline void cpu_set_tls(CPUARMState *env, void *newtls)
|
|
+{
|
|
+ env->cp15.c13_tls2 = (uint32_t)(long)newtls;
|
|
+}
|
|
+#endif
|
|
+
|
|
#define CPSR_M (0x1f)
|
|
#define CPSR_T (1 << 5)
|
|
#define CPSR_F (1 << 6)
|
|
Index: trunk/target-arm/translate.c
|
|
===================================================================
|
|
--- trunk.orig/target-arm/translate.c 2008-04-24 20:16:41.000000000 +0100
|
|
+++ trunk/target-arm/translate.c 2008-04-24 20:16:53.000000000 +0100
|
|
@@ -8606,7 +8606,14 @@
|
|
gen_exception(EXCP_EXCEPTION_EXIT);
|
|
}
|
|
#endif
|
|
-
|
|
+#ifdef CONFIG_USER_ONLY
|
|
+ /* Intercept jump to the magic kernel page. */
|
|
+ if (dc->pc > 0xffff0000) {
|
|
+ gen_exception(EXCP_KERNEL_TRAP);
|
|
+ dc->is_jmp = DISAS_UPDATE;
|
|
+ break;
|
|
+ }
|
|
+#endif
|
|
if (env->nb_breakpoints > 0) {
|
|
for(j = 0; j < env->nb_breakpoints; j++) {
|
|
if (env->breakpoints[j] == dc->pc) {
|