rpms/valgrind
7
0
Fork 0
Code Issues Pull Requests Releases Activity
c088b45781
valgrind/valgrind-3.12.0-clone-spawn.patch
Mark Wielaard f88b362722 Add valgrind-3.12.0-clone-spawn.patch
2017-02-18 16:04:37 +01:00

3326 lines
121 KiB
Diff
Raw Blame History

commit e31d72da6cb415d0856ad53dac78e307548cd831
Author: philippe <philippe@a5019735-40e9-0310-863c-91ae7b9d1cf9>
Date: Sun Dec 11 21:39:23 2016 +0000
Fix 342040 Valgrind mishandles clone with CLONE_VFORK | CLONE_VM that clones to a different stack
Fix 373192 Calling posix_spawn in glibc 2.24 completely broken
Functionally, this patch just does the following 2 changes to the
fork clone handling:
* It does not mask anymore CLONE_VFORK :
The only effect of this flag is to suspend the parent, waiting for
the child to either exit or execve.
If some applications depends on this synchronisation, better keep it,
as it will not harm to suspend the parent valgrind waiting for the
child valgrind to exit or execve.
* In case the guest calls the clone syscall providing a non zero client stack,
set the child guest SP after the syscall, before executing guest instructions.
Not setting the guest stack ptr was the source of the problem reported
in the bugs.
This also adds a test case none/tests/linux/clonev.
Before this patch, test gives a SEGV, which is fixed by the patch.
The patch is however a lot bigger : this fix was touching some (mostly
identical/duplicated) code in all the linux platforms.
So, the clone/fork code has been factorised as much as possible.
This removes about 1700 lines of code.
This has been tested on:
* amd64
* x86
* ppc64 be and le
* ppc32
* arm64
This has been compiled on but *not really tested* on:
* mips64 (not too clear how to properly build and run valgrind on gcc22)
It has *not* been compiled and *not* tested on:
* arm
* mips32
* tilegx
* darwin (normally, no impact)
* solaris (normally, no impact)
The changes are relatively mechanical, so it is not impossible that
it will compile and work out of the box on these platforms.
Otherwise, questions welcome.
A few points of interest:
* Some platforms did have a typedef void vki_modify_ldt_t,
and some platforms had no definition for this type at all.
To make it easier to factorise, for such platforms, the following has
been used:
typedef char vki_modify_ldt_t;
When the sizeof vki_modify_ldt_t is > 1, then the arg syscall is checked.
This is somewhat a hack, but was simplifying the factorisation.
* for mips32/mips64 and tilegx, there is a strange unconditional assignment
of 0 to a register (guest_r2 on mips, guest_r0 on tilegx).
Unclear what this is, in particular because this is assigned whatever
the result of the syscall (success or not).
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@16186 a5019735-40e9-0310-863c-91ae7b9d1cf9
diff --git a/coregrind/m_syswrap/priv_syswrap-linux.h b/coregrind/m_syswrap/priv_syswrap-linux.h
index 38fcd7b..06ea7cd 100644
--- a/coregrind/m_syswrap/priv_syswrap-linux.h
+++ b/coregrind/m_syswrap/priv_syswrap-linux.h
@@ -39,12 +39,10 @@ extern Word ML_(start_thread_NORETURN) ( void* arg );
extern Addr ML_(allocstack) ( ThreadId tid );
extern void ML_(call_on_new_stack_0_1) ( Addr stack, Addr retaddr,
void (*f)(Word), Word arg1 );
-extern SysRes ML_(do_fork_clone) ( ThreadId tid, UInt flags,
- Int* parent_tidptr, Int* child_tidptr );
-
// Linux-specific (but non-arch-specific) syscalls
+DECL_TEMPLATE(linux, sys_clone)
DECL_TEMPLATE(linux, sys_mount);
DECL_TEMPLATE(linux, sys_oldumount);
DECL_TEMPLATE(linux, sys_umount);
@@ -61,6 +59,10 @@ DECL_TEMPLATE(linux, sys_vmsplice);
DECL_TEMPLATE(linux, sys_readahead);
DECL_TEMPLATE(linux, sys_move_pages);
+// clone is similar enough between linux variants to have a generic
+// version, but which will call an extern defined in syswrap-<platform>-linux.c
+DECL_TEMPLATE(linux, sys_clone);
+
// POSIX, but various sub-cases differ between Linux and Darwin.
DECL_TEMPLATE(linux, sys_fcntl);
DECL_TEMPLATE(linux, sys_fcntl64);
@@ -368,7 +370,83 @@ DECL_TEMPLATE(linux, sys_getpeername);
DECL_TEMPLATE(linux, sys_socketpair);
DECL_TEMPLATE(linux, sys_kcmp);
-#endif // __PRIV_SYSWRAP_LINUX_H
+// Some arch specific functions called from syswrap-linux.c
+extern Int do_syscall_clone_x86_linux ( Word (*fn)(void *),
+ void* stack,
+ Int flags,
+ void* arg,
+ Int* child_tid,
+ Int* parent_tid,
+ void* tls_ptr);
+extern SysRes ML_(x86_sys_set_thread_area) ( ThreadId tid,
+ vki_modify_ldt_t* info );
+extern void ML_(x86_setup_LDT_GDT) ( /*OUT*/ ThreadArchState *child,
+ /*IN*/ ThreadArchState *parent );
+
+extern Long do_syscall_clone_amd64_linux ( Word (*fn)(void *),
+ void* stack,
+ Long flags,
+ void* arg,
+ Int* child_tid,
+ Int* parent_tid,
+ void* tls_ptr);
+extern ULong do_syscall_clone_ppc32_linux ( Word (*fn)(void *),
+ void* stack,
+ Int flags,
+ void* arg,
+ Int* child_tid,
+ Int* parent_tid,
+ void* tls_ptr);
+extern ULong do_syscall_clone_ppc64_linux ( Word (*fn)(void *),
+ void* stack,
+ Int flags,
+ void* arg,
+ Int* child_tid,
+ Int* parent_tid,
+ void* tls_ptr );
+extern ULong do_syscall_clone_s390x_linux ( void *stack,
+ ULong flags,
+ Int *parent_tid,
+ Int *child_tid,
+ void* tls_ptr,
+ Word (*fn)(void *),
+ void *arg);
+extern Long do_syscall_clone_arm64_linux ( Word (*fn)(void *),
+ void* stack,
+ Long flags,
+ void* arg,
+ Int* child_tid,
+ Int* parent_tid,
+ void* tls_ptr );
+extern ULong do_syscall_clone_arm_linux ( Word (*fn)(void *),
+ void* stack,
+ Int flags,
+ void* arg,
+ Int* child_tid,
+ Int* parent_tid,
+ void* tls_ptr );
+extern ULong do_syscall_clone_mips64_linux ( Word (*fn) (void *), /* a0 - 4 */
+ void* stack, /* a1 - 5 */
+ Int flags, /* a2 - 6 */
+ void* arg, /* a3 - 7 */
+ Int* parent_tid, /* a4 - 8 */
+ void* tls_ptr, /* a5 - 9 */
+ Int* child_tid ); /* a6 - 10 */
+extern UInt do_syscall_clone_mips_linux ( Word (*fn) (void *), //a0 0 32
+ void* stack, //a1 4 36
+ Int flags, //a2 8 40
+ void* arg, //a3 12 44
+ Int* child_tid, //stack 16 48
+ Int* parent_tid, //stack 20 52
+ void* tls_ptr); //stack 24 56
+extern Long do_syscall_clone_tilegx_linux ( Word (*fn) (void *), //r0
+ void* stack, //r1
+ Long flags, //r2
+ void* arg, //r3
+ Long* child_tid, //r4
+ Long* parent_tid, //r5
+ void* tls_ptr ); //r6
+ #endif // __PRIV_SYSWRAP_LINUX_H
/*--------------------------------------------------------------------*/
/*--- end ---*/
diff --git a/coregrind/m_syswrap/syswrap-amd64-linux.c b/coregrind/m_syswrap/syswrap-amd64-linux.c
index 08e9a93..3fe9938 100644
--- a/coregrind/m_syswrap/syswrap-amd64-linux.c
+++ b/coregrind/m_syswrap/syswrap-amd64-linux.c
@@ -130,14 +130,7 @@ asm(
#define __NR_CLONE VG_STRINGIFY(__NR_clone)
#define __NR_EXIT VG_STRINGIFY(__NR_exit)
-extern
-Long do_syscall_clone_amd64_linux ( Word (*fn)(void *),
- void* stack,
- Long flags,
- void* arg,
- Long* child_tid,
- Long* parent_tid,
- vki_modify_ldt_t * );
+// See priv_syswrap-linux.h for arg profile.
asm(
".text\n"
".globl do_syscall_clone_amd64_linux\n"
@@ -183,126 +176,6 @@ asm(
#undef __NR_EXIT
-// forward declaration
-static void setup_child ( ThreadArchState*, ThreadArchState* );
-
-/*
- When a client clones, we need to keep track of the new thread. This means:
- 1. allocate a ThreadId+ThreadState+stack for the thread
-
- 2. initialize the thread's new VCPU state
-
- 3. create the thread using the same args as the client requested,
- but using the scheduler entrypoint for EIP, and a separate stack
- for ESP.
- */
-static SysRes do_clone ( ThreadId ptid,
- ULong flags, Addr rsp,
- Long* parent_tidptr,
- Long* child_tidptr,
- Addr tlsaddr )
-{
- static const Bool debug = False;
-
- ThreadId ctid = VG_(alloc_ThreadState)();
- ThreadState* ptst = VG_(get_ThreadState)(ptid);
- ThreadState* ctst = VG_(get_ThreadState)(ctid);
- UWord* stack;
- SysRes res;
- Long rax;
- vki_sigset_t blockall, savedmask;
-
- VG_(sigfillset)(&blockall);
-
- vg_assert(VG_(is_running_thread)(ptid));
- vg_assert(VG_(is_valid_tid)(ctid));
-
- stack = (UWord*)ML_(allocstack)(ctid);
- if (stack == NULL) {
- res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
- goto out;
- }
-
- /* Copy register state
-
- Both parent and child return to the same place, and the code
- following the clone syscall works out which is which, so we
- don't need to worry about it.
-
- The parent gets the child's new tid returned from clone, but the
- child gets 0.
-
- If the clone call specifies a NULL rsp for the new thread, then
- it actually gets a copy of the parent's rsp.
- */
- setup_child( &ctst->arch, &ptst->arch );
-
- /* Make sys_clone appear to have returned Success(0) in the
- child. */
- ctst->arch.vex.guest_RAX = 0;
-
- if (rsp != 0)
- ctst->arch.vex.guest_RSP = rsp;
-
- ctst->os_state.parent = ptid;
-
- /* inherit signal mask */
- ctst->sig_mask = ptst->sig_mask;
- ctst->tmp_sig_mask = ptst->sig_mask;
-
- /* Start the child with its threadgroup being the same as the
- parent's. This is so that any exit_group calls that happen
- after the child is created but before it sets its
- os_state.threadgroup field for real (in thread_wrapper in
- syswrap-linux.c), really kill the new thread. a.k.a this avoids
- a race condition in which the thread is unkillable (via
- exit_group) because its threadgroup is not set. The race window
- is probably only a few hundred or a few thousand cycles long.
- See #226116. */
- ctst->os_state.threadgroup = ptst->os_state.threadgroup;
-
- ML_(guess_and_register_stack) (rsp, ctst);
-
- /* Assume the clone will succeed, and tell any tool that wants to
- know that this thread has come into existence. If the clone
- fails, we'll send out a ll_exit notification for it at the out:
- label below, to clean up. */
- vg_assert(VG_(owns_BigLock_LL)(ptid));
- VG_TRACK ( pre_thread_ll_create, ptid, ctid );
-
- if (flags & VKI_CLONE_SETTLS) {
- if (debug)
- VG_(printf)("clone child has SETTLS: tls at %#lx\n", tlsaddr);
- ctst->arch.vex.guest_FS_CONST = tlsaddr;
- }
-
- flags &= ~VKI_CLONE_SETTLS;
-
- /* start the thread with everything blocked */
- VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
-
- /* Create the new thread */
- rax = do_syscall_clone_amd64_linux(
- ML_(start_thread_NORETURN), stack, flags, &VG_(threads)[ctid],
- child_tidptr, parent_tidptr, NULL
- );
- res = VG_(mk_SysRes_amd64_linux)( rax );
-
- VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
-
- out:
- if (sr_isError(res)) {
- /* clone failed */
- VG_(cleanup_thread)(&ctst->arch);
- ctst->status = VgTs_Empty;
- /* oops. Better tell the tool the thread exited in a hurry :-) */
- VG_TRACK( pre_thread_ll_exit, ctid );
- }
-
- return res;
-}
-
-
/* ---------------------------------------------------------------------
More thread stuff
------------------------------------------------------------------ */
@@ -311,16 +184,6 @@ void VG_(cleanup_thread) ( ThreadArchState *arch )
{
}
-void setup_child ( /*OUT*/ ThreadArchState *child,
- /*IN*/ ThreadArchState *parent )
-{
- /* We inherit our parent's guest state. */
- child->vex = parent->vex;
- child->vex_shadow1 = parent->vex_shadow1;
- child->vex_shadow2 = parent->vex_shadow2;
-}
-
-
/* ---------------------------------------------------------------------
PRE/POST wrappers for AMD64/Linux-specific syscalls
------------------------------------------------------------------ */
@@ -333,7 +196,6 @@ void setup_child ( /*OUT*/ ThreadArchState *child,
the right thing to do is to make these wrappers 'static' since they
aren't visible outside this file, but that requires even more macro
magic. */
-DECL_TEMPLATE(amd64_linux, sys_clone);
DECL_TEMPLATE(amd64_linux, sys_rt_sigreturn);
DECL_TEMPLATE(amd64_linux, sys_arch_prctl);
DECL_TEMPLATE(amd64_linux, sys_ptrace);
@@ -342,108 +204,6 @@ DECL_TEMPLATE(amd64_linux, sys_mmap);
DECL_TEMPLATE(amd64_linux, sys_syscall184);
-PRE(sys_clone)
-{
- ULong cloneflags;
-
- PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
- PRE_REG_READ2(int, "clone",
- unsigned long, flags,
- void *, child_stack);
-
- if (ARG1 & VKI_CLONE_PARENT_SETTID) {
- if (VG_(tdict).track_pre_reg_read) {
- PRA3("clone", int *, parent_tidptr);
- }
- PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int), VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
- if (ARG1 & VKI_CLONE_SETTLS) {
- if (VG_(tdict).track_pre_reg_read) {
- PRA4("clone", vki_modify_ldt_t *, tlsinfo);
- }
- PRE_MEM_READ("clone(tlsinfo)", ARG4, sizeof(vki_modify_ldt_t));
- if (!VG_(am_is_valid_for_client)(ARG4, sizeof(vki_modify_ldt_t),
- VKI_PROT_READ)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
- if (VG_(tdict).track_pre_reg_read) {
- PRA5("clone", int *, child_tidptr);
- }
- PRE_MEM_WRITE("clone(child_tidptr)", ARG4, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG4, sizeof(Int), VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
-
- cloneflags = ARG1;
-
- if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
- SET_STATUS_Failure( VKI_EINVAL );
- return;
- }
-
- /* Only look at the flags we really care about */
- switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
- | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
- case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
- /* thread creation */
- SET_STATUS_from_SysRes(
- do_clone(tid,
- ARG1, /* flags */
- (Addr)ARG2, /* child ESP */
- (Long *)ARG3, /* parent_tidptr */
- (Long *)ARG4, /* child_tidptr */
- (Addr)ARG5)); /* set_tls */
- break;
-
- case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
- /* FALLTHROUGH - assume vfork == fork */
- cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
-
- case 0: /* plain fork */
- SET_STATUS_from_SysRes(
- ML_(do_fork_clone)(tid,
- cloneflags, /* flags */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG4)); /* child_tidptr */
- break;
-
- default:
- /* should we just ENOSYS? */
- VG_(message)(Vg_UserMsg,
- "Unsupported clone() flags: 0x%lx\n", ARG1);
- VG_(message)(Vg_UserMsg,
- "\n");
- VG_(message)(Vg_UserMsg,
- "The only supported clone() uses are:\n");
- VG_(message)(Vg_UserMsg,
- " - via a threads library (LinuxThreads or NPTL)\n");
- VG_(message)(Vg_UserMsg,
- " - via the implementation of fork or vfork\n");
- VG_(unimplemented)
- ("Valgrind does not support general clone().");
- }
-
- if (SUCCESS) {
- if (ARG1 & VKI_CLONE_PARENT_SETTID)
- POST_MEM_WRITE(ARG3, sizeof(Int));
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
- POST_MEM_WRITE(ARG4, sizeof(Int));
-
- /* Thread creation was successful; let the child have the chance
- to run */
- *flags |= SfYieldAfter;
- }
-}
-
PRE(sys_rt_sigreturn)
{
/* This isn't really a syscall at all - it's a misuse of the
@@ -761,7 +521,7 @@ static SyscallTableEntry syscall_table[] = {
LINX_(__NR_setsockopt, sys_setsockopt), // 54
LINXY(__NR_getsockopt, sys_getsockopt), // 55
- PLAX_(__NR_clone, sys_clone), // 56
+ LINX_(__NR_clone, sys_clone), // 56
GENX_(__NR_fork, sys_fork), // 57
GENX_(__NR_vfork, sys_fork), // 58 treat as fork
GENX_(__NR_execve, sys_execve), // 59
diff --git a/coregrind/m_syswrap/syswrap-arm-linux.c b/coregrind/m_syswrap/syswrap-arm-linux.c
index 3bbd109..b417428 100644
--- a/coregrind/m_syswrap/syswrap-arm-linux.c
+++ b/coregrind/m_syswrap/syswrap-arm-linux.c
@@ -102,14 +102,7 @@ asm(
#define __NR_CLONE VG_STRINGIFY(__NR_clone)
#define __NR_EXIT VG_STRINGIFY(__NR_exit)
-extern
-ULong do_syscall_clone_arm_linux ( Word (*fn)(void *),
- void* stack,
- Int flags,
- void* arg,
- Int* child_tid,
- Int* parent_tid,
- void* tls );
+// See priv_syswrap-linux.h for arg profile.
asm(
".text\n"
".globl do_syscall_clone_arm_linux\n"
@@ -148,104 +141,8 @@ asm(
#undef __NR_EXIT
// forward declarations
-static void setup_child ( ThreadArchState*, ThreadArchState* );
-static void assign_guest_tls(ThreadId ctid, Addr tlsptr);
static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr );
-/*
- When a client clones, we need to keep track of the new thread. This means:
- 1. allocate a ThreadId+ThreadState+stack for the thread
-
- 2. initialize the thread's new VCPU state
-
- 3. create the thread using the same args as the client requested,
- but using the scheduler entrypoint for IP, and a separate stack
- for SP.
- */
-static SysRes do_clone ( ThreadId ptid,
- UInt flags, Addr sp,
- Int *parent_tidptr,
- Int *child_tidptr,
- Addr child_tls)
-{
- ThreadId ctid = VG_(alloc_ThreadState)();
- ThreadState* ptst = VG_(get_ThreadState)(ptid);
- ThreadState* ctst = VG_(get_ThreadState)(ctid);
- UInt r0;
- UWord *stack;
- SysRes res;
- vki_sigset_t blockall, savedmask;
-
- VG_(sigfillset)(&blockall);
-
- vg_assert(VG_(is_running_thread)(ptid));
- vg_assert(VG_(is_valid_tid)(ctid));
-
- stack = (UWord*)ML_(allocstack)(ctid);
-
- if(stack == NULL) {
- res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
- goto out;
- }
-
- setup_child( &ctst->arch, &ptst->arch );
-
- ctst->arch.vex.guest_R0 = 0;
- if(sp != 0)
- ctst->arch.vex.guest_R13 = sp;
-
- ctst->os_state.parent = ptid;
-
- ctst->sig_mask = ptst->sig_mask;
- ctst->tmp_sig_mask = ptst->sig_mask;
-
- /* Start the child with its threadgroup being the same as the
- parent's. This is so that any exit_group calls that happen
- after the child is created but before it sets its
- os_state.threadgroup field for real (in thread_wrapper in
- syswrap-linux.c), really kill the new thread. a.k.a this avoids
- a race condition in which the thread is unkillable (via
- exit_group) because its threadgroup is not set. The race window
- is probably only a few hundred or a few thousand cycles long.
- See #226116. */
- ctst->os_state.threadgroup = ptst->os_state.threadgroup;
-
- ML_(guess_and_register_stack) (sp, ctst);
-
- vg_assert(VG_(owns_BigLock_LL)(ptid));
- VG_TRACK ( pre_thread_ll_create, ptid, ctid );
-
- if (flags & VKI_CLONE_SETTLS) {
- /* Just assign the tls pointer in the guest TPIDRURO. */
- assign_guest_tls(ctid, child_tls);
- }
-
- flags &= ~VKI_CLONE_SETTLS;
-
- VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
-
- r0 = do_syscall_clone_arm_linux(
- ML_(start_thread_NORETURN), stack, flags, &VG_(threads)[ctid],
- child_tidptr, parent_tidptr, NULL
- );
- //VG_(printf)("AFTER SYSCALL, %x and %x CHILD: %d PARENT: %d\n",child_tidptr, parent_tidptr,*child_tidptr,*parent_tidptr);
-
- res = VG_(mk_SysRes_arm_linux)( r0 );
-
- VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
-
-out:
- if (sr_isError(res)) {
- VG_(cleanup_thread)(&ctst->arch);
- ctst->status = VgTs_Empty;
- VG_TRACK( pre_thread_ll_exit, ctid );
- }
-
- return res;
-}
-
-
-
/* ---------------------------------------------------------------------
More thread stuff
------------------------------------------------------------------ */
@@ -256,26 +153,13 @@ void VG_(cleanup_thread) ( ThreadArchState* arch )
{
}
-void setup_child ( /*OUT*/ ThreadArchState *child,
- /*IN*/ ThreadArchState *parent )
-{
- child->vex = parent->vex;
- child->vex_shadow1 = parent->vex_shadow1;
- child->vex_shadow2 = parent->vex_shadow2;
-}
-
-static void assign_guest_tls(ThreadId tid, Addr tlsptr)
-{
- VG_(threads)[tid].arch.vex.guest_TPIDRURO = tlsptr;
-}
-
/* Assigns tlsptr to the guest TPIDRURO.
If needed for the specific hardware, really executes
the set_tls syscall.
*/
static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr )
{
- assign_guest_tls(tid, tlsptr);
+ VG_(threads)[tid].arch.vex.guest_TPIDRURO = tlsptr;
if (KernelVariantiS(KernelVariant_android_no_hw_tls,
VG_(clo_kernel_variant))) {
@@ -333,7 +217,6 @@ DECL_TEMPLATE(arm_linux, sys_stat64);
DECL_TEMPLATE(arm_linux, sys_lstat64);
DECL_TEMPLATE(arm_linux, sys_fstatat64);
DECL_TEMPLATE(arm_linux, sys_fstat64);
-DECL_TEMPLATE(arm_linux, sys_clone);
DECL_TEMPLATE(arm_linux, sys_sigreturn);
DECL_TEMPLATE(arm_linux, sys_rt_sigreturn);
DECL_TEMPLATE(arm_linux, sys_sigsuspend);
@@ -424,100 +307,6 @@ POST(sys_fstat64)
POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
}
-PRE(sys_clone)
-{
- UInt cloneflags;
-
- PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
- PRE_REG_READ5(int, "clone",
- unsigned long, flags,
- void *, child_stack,
- int *, parent_tidptr,
- void *, child_tls,
- int *, child_tidptr);
-
- if (ARG1 & VKI_CLONE_PARENT_SETTID) {
- PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int),
- VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
- PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG5, sizeof(Int),
- VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
- if (ARG1 & VKI_CLONE_SETTLS) {
- PRE_MEM_READ("clone(tls_user_desc)", ARG4, sizeof(vki_modify_ldt_t));
- if (!VG_(am_is_valid_for_client)(ARG4, sizeof(vki_modify_ldt_t),
- VKI_PROT_READ)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
-
- cloneflags = ARG1;
-
- if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
- SET_STATUS_Failure( VKI_EINVAL );
- return;
- }
-
- /* Only look at the flags we really care about */
- switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
- | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
- case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
- /* thread creation */
- SET_STATUS_from_SysRes(
- do_clone(tid,
- ARG1, /* flags */
- (Addr)ARG2, /* child ESP */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG5, /* child_tidptr */
- (Addr)ARG4)); /* set_tls */
- break;
-
- case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
- /* FALLTHROUGH - assume vfork == fork */
- cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
-
- case 0: /* plain fork */
- SET_STATUS_from_SysRes(
- ML_(do_fork_clone)(tid,
- cloneflags, /* flags */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG5)); /* child_tidptr */
- break;
-
- default:
- /* should we just ENOSYS? */
- VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1);
- VG_(message)(Vg_UserMsg, "\n");
- VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
- VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)\n");
- VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n");
- VG_(message)(Vg_UserMsg, " - for the Quadrics Elan3 user-space driver\n");
- VG_(unimplemented)
- ("Valgrind does not support general clone().");
- }
-
- if (SUCCESS) {
- if (ARG1 & VKI_CLONE_PARENT_SETTID)
- POST_MEM_WRITE(ARG3, sizeof(Int));
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
- POST_MEM_WRITE(ARG5, sizeof(Int));
-
- /* Thread creation was successful; let the child have the chance
- to run */
- *flags |= SfYieldAfter;
- }
-}
-
PRE(sys_sigreturn)
{
/* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
@@ -901,7 +690,7 @@ static SyscallTableEntry syscall_main_table[] = {
GENX_(__NR_fsync, sys_fsync), // 118
PLAX_(__NR_sigreturn, sys_sigreturn), // 119 ?/Linux
- PLAX_(__NR_clone, sys_clone), // 120
+ LINX_(__NR_clone, sys_clone), // 120
//zz // (__NR_setdomainname, sys_setdomainname), // 121 */*(?)
GENXY(__NR_uname, sys_newuname), // 122
// PLAX_(__NR_modify_ldt, sys_modify_ldt), // 123
diff --git a/coregrind/m_syswrap/syswrap-arm64-linux.c b/coregrind/m_syswrap/syswrap-arm64-linux.c
index 6b579e8..1be6629 100644
--- a/coregrind/m_syswrap/syswrap-arm64-linux.c
+++ b/coregrind/m_syswrap/syswrap-arm64-linux.c
@@ -138,14 +138,7 @@ asm(
#define __NR_CLONE VG_STRINGIFY(__NR_clone)
#define __NR_EXIT VG_STRINGIFY(__NR_exit)
-extern
-Long do_syscall_clone_arm64_linux ( Word (*fn)(void *),
- void* child_stack,
- Long flags,
- void* arg,
- Int* child_tid,
- Int* parent_tid,
- void* tls );
+// See priv_syswrap-linux.h for arg profile.
asm(
".text\n"
".globl do_syscall_clone_arm64_linux\n"
@@ -196,121 +189,6 @@ static void setup_child ( ThreadArchState*, ThreadArchState* );
static void assign_guest_tls(ThreadId ctid, Addr tlsptr);
//ZZ static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr );
-/*
- When a client clones, we need to keep track of the new thread. This means:
- 1. allocate a ThreadId+ThreadState+stack for the thread
-
- 2. initialize the thread's new VCPU state
-
- 3. create the thread using the same args as the client requested,
- but using the scheduler entrypoint for IP, and a separate stack
- for SP.
- */
-static SysRes do_clone ( ThreadId ptid,
- ULong flags,
- Addr child_xsp,
- Int* parent_tidptr,
- Int* child_tidptr,
- Addr child_tls )
-{
- ThreadId ctid = VG_(alloc_ThreadState)();
- ThreadState* ptst = VG_(get_ThreadState)(ptid);
- ThreadState* ctst = VG_(get_ThreadState)(ctid);
- UWord* stack;
- SysRes res;
- ULong x0;
- vki_sigset_t blockall, savedmask;
-
- VG_(sigfillset)(&blockall);
-
- vg_assert(VG_(is_running_thread)(ptid));
- vg_assert(VG_(is_valid_tid)(ctid));
-
- stack = (UWord*)ML_(allocstack)(ctid);
- if (stack == NULL) {
- res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
- goto out;
- }
-
- /* Copy register state
-
- Both parent and child return to the same place, and the code
- following the clone syscall works out which is which, so we
- don't need to worry about it.
-
- The parent gets the child's new tid returned from clone, but the
- child gets 0.
-
- If the clone call specifies a NULL xsp for the new thread, then
- it actually gets a copy of the parent's xsp.
- */
- setup_child( &ctst->arch, &ptst->arch );
-
- /* Make sys_clone appear to have returned Success(0) in the
- child. */
- ctst->arch.vex.guest_X0 = 0;
-
- if (child_xsp != 0)
- ctst->arch.vex.guest_XSP = child_xsp;
-
- ctst->os_state.parent = ptid;
-
- /* inherit signal mask */
- ctst->sig_mask = ptst->sig_mask;
- ctst->tmp_sig_mask = ptst->sig_mask;
-
- /* Start the child with its threadgroup being the same as the
- parent's. This is so that any exit_group calls that happen
- after the child is created but before it sets its
- os_state.threadgroup field for real (in thread_wrapper in
- syswrap-linux.c), really kill the new thread. a.k.a this avoids
- a race condition in which the thread is unkillable (via
- exit_group) because its threadgroup is not set. The race window
- is probably only a few hundred or a few thousand cycles long.
- See #226116. */
- ctst->os_state.threadgroup = ptst->os_state.threadgroup;
-
- ML_(guess_and_register_stack)(child_xsp, ctst);
-
- /* Assume the clone will succeed, and tell any tool that wants to
- know that this thread has come into existence. If the clone
- fails, we'll send out a ll_exit notification for it at the out:
- label below, to clean up. */
- vg_assert(VG_(owns_BigLock_LL)(ptid));
- VG_TRACK ( pre_thread_ll_create, ptid, ctid );
-
- if (flags & VKI_CLONE_SETTLS) {
- /* Just assign the tls pointer in the guest TPIDR_EL0. */
- assign_guest_tls(ctid, child_tls);
- }
-
- flags &= ~VKI_CLONE_SETTLS;
-
- /* start the thread with everything blocked */
- VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
-
- x0 = do_syscall_clone_arm64_linux(
- ML_(start_thread_NORETURN), stack, flags, &VG_(threads)[ctid],
- child_tidptr, parent_tidptr, NULL
- );
-
- res = VG_(mk_SysRes_arm64_linux)( x0 );
-
- VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
-
- out:
- if (sr_isError(res)) {
- /* clone failed */
- VG_(cleanup_thread)(&ctst->arch);
- ctst->status = VgTs_Empty;
- /* oops. Better tell the tool the thread exited in a hurry :-) */
- VG_TRACK( pre_thread_ll_exit, ctid );
- }
-
- return res;
-}
-
-
/* ---------------------------------------------------------------------
More thread stuff
------------------------------------------------------------------ */
@@ -397,7 +275,6 @@ DECL_TEMPLATE(arm64_linux, sys_mmap);
//ZZ DECL_TEMPLATE(arm_linux, sys_lstat64);
//ZZ DECL_TEMPLATE(arm_linux, sys_fstatat64);
//ZZ DECL_TEMPLATE(arm_linux, sys_fstat64);
-DECL_TEMPLATE(arm64_linux, sys_clone);
//ZZ DECL_TEMPLATE(arm_linux, sys_sigreturn);
DECL_TEMPLATE(arm64_linux, sys_rt_sigreturn);
//ZZ DECL_TEMPLATE(arm_linux, sys_sigsuspend);
@@ -512,110 +389,6 @@ PRE(sys_mmap)
//ZZ POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
//ZZ }
-/* Aarch64 seems to use CONFIG_CLONE_BACKWARDS in the kernel. See:
- http://dev.gentoo.org/~vapier/aarch64/linux-3.12.6.config
- http://people.redhat.com/wcohen/aarch64/aarch64_config
- from linux-3.10.5/kernel/fork.c
- #ifdef CONFIG_CLONE_BACKWARDS
- SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
- int __user *, parent_tidptr,
- int, tls_val,
- int __user *, child_tidptr)
-*/
-PRE(sys_clone)
-{
- UInt cloneflags;
-
- PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
- PRE_REG_READ5(int, "clone",
- unsigned long, flags,
- void *, child_stack,
- int *, parent_tidptr,
- void *, child_tls,
- int *, child_tidptr);
-
- if (ARG1 & VKI_CLONE_PARENT_SETTID) {
- PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int),
- VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
-//ZZ if (ARG1 & VKI_CLONE_SETTLS) {
-//ZZ PRE_MEM_READ("clone(tls_user_desc)", ARG4, sizeof(vki_modify_ldt_t));
-//ZZ if (!VG_(am_is_valid_for_client)(ARG4, sizeof(vki_modify_ldt_t),
-//ZZ VKI_PROT_READ)) {
-//ZZ SET_STATUS_Failure( VKI_EFAULT );
-//ZZ return;
-//ZZ }
-//ZZ }
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
- PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG5, sizeof(Int),
- VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
-
- cloneflags = ARG1;
-
- if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
- SET_STATUS_Failure( VKI_EINVAL );
- return;
- }
-
- /* Only look at the flags we really care about */
- switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
- | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
- case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
- /* thread creation */
- SET_STATUS_from_SysRes(
- do_clone(tid,
- ARG1, /* flags */
- (Addr)ARG2, /* child SP */
- (Int*)ARG3, /* parent_tidptr */
- (Int*)ARG5, /* child_tidptr */
- (Addr)ARG4)); /* tls_val */
- break;
-
- case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
- /* FALLTHROUGH - assume vfork == fork */
- cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
-
- case 0: /* plain fork */
- SET_STATUS_from_SysRes(
- ML_(do_fork_clone)(tid,
- cloneflags, /* flags */
- (Int*)ARG3, /* parent_tidptr */
- (Int*)ARG5)); /* child_tidptr */
- break;
-
- default:
- /* should we just ENOSYS? */
- VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1);
- VG_(message)(Vg_UserMsg, "\n");
- VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
- VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)\n");
- VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n");
- VG_(message)(Vg_UserMsg, " - for the Quadrics Elan3 user-space driver\n");
- VG_(unimplemented)
- ("Valgrind does not support general clone().");
- }
-
- if (SUCCESS) {
- if (ARG1 & VKI_CLONE_PARENT_SETTID)
- POST_MEM_WRITE(ARG3, sizeof(Int));
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
- POST_MEM_WRITE(ARG5, sizeof(Int));
-
- /* Thread creation was successful; let the child have the chance
- to run */
- *flags |= SfYieldAfter;
- }
-}
-
//ZZ PRE(sys_sigreturn)
//ZZ {
//ZZ /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
@@ -1072,7 +845,7 @@ static SyscallTableEntry syscall_main_table[] = {
LINX_(__NR_add_key, sys_add_key), // 217
LINXY(__NR_keyctl, sys_keyctl), // 219
- PLAX_(__NR_clone, sys_clone), // 220
+ LINX_(__NR_clone, sys_clone), // 220
GENX_(__NR_execve, sys_execve), // 221
PLAX_(__NR_mmap, sys_mmap), // 222
PLAX_(__NR_fadvise64, sys_fadvise64), // 223
diff --git a/coregrind/m_syswrap/syswrap-linux.c b/coregrind/m_syswrap/syswrap-linux.c
index b3ffdb1..aa00a5f 100644
--- a/coregrind/m_syswrap/syswrap-linux.c
+++ b/coregrind/m_syswrap/syswrap-linux.c
@@ -93,9 +93,8 @@ static VgSchedReturnCode thread_wrapper(Word /*ThreadId*/ tidW)
VG_TRACK(pre_thread_first_insn, tid);
tst->os_state.lwpid = VG_(gettid)();
- /* Set the threadgroup for real. This overwrites the provisional
- value set in do_clone() syswrap-*-linux.c. See comments in
- do_clone for background, also #226116. */
+ /* Set the threadgroup for real. This overwrites the provisional value set
+ in do_clone(). See comments in do_clone for background, also #226116. */
tst->os_state.threadgroup = VG_(getpid)();
/* Thread created with all signals blocked; scheduler will set the
@@ -430,17 +429,327 @@ void VG_(main_thread_wrapper_NORETURN)(ThreadId tid)
vg_assert(0);
}
+/* Clone a new thread. Note that in the clone syscalls, we hard-code
+ tlsaddr argument as NULL : the guest TLS is emulated via guest
+ registers, and Valgrind itself has no thread local storage. */
+static SysRes clone_new_thread ( Word (*fn)(void *),
+ void* stack,
+ Word flags,
+ ThreadState* ctst,
+ Int* child_tidptr,
+ Int* parent_tidptr)
+{
+ SysRes res;
+ /* Note that in all the below, we make sys_clone appear to have returned
+ Success(0) in the child, by assigning the relevant child guest
+ register(s) just before the clone syscall. */
+#if defined(VGP_x86_linux)
+ Int eax;
+ ctst->arch.vex.guest_EAX = 0;
+ eax = do_syscall_clone_x86_linux
+ (ML_(start_thread_NORETURN), stack, flags, ctst,
+ child_tidptr, parent_tidptr, NULL);
+ res = VG_(mk_SysRes_x86_linux)( eax );
+#elif defined(VGP_amd64_linux)
+ Long rax;
+ ctst->arch.vex.guest_RAX = 0;
+ rax = do_syscall_clone_amd64_linux
+ (ML_(start_thread_NORETURN), stack, flags, ctst,
+ child_tidptr, parent_tidptr, NULL);
+ res = VG_(mk_SysRes_amd64_linux)( rax );
+#elif defined(VGP_ppc32_linux)
+ ULong word64;
+ UInt old_cr = LibVEX_GuestPPC32_get_CR( &ctst->arch.vex );
+ /* %r3 = 0 */
+ ctst->arch.vex.guest_GPR3 = 0;
+ /* %cr0.so = 0 */
+ LibVEX_GuestPPC32_put_CR( old_cr & ~(1<<28), &ctst->arch.vex );
+ word64 = do_syscall_clone_ppc32_linux
+ (ML_(start_thread_NORETURN), stack, flags, ctst,
+ child_tidptr, parent_tidptr, NULL);
+ /* High half word64 is syscall return value. Low half is
+ the entire CR, from which we need to extract CR0.SO. */
+ /* VG_(printf)("word64 = 0x%llx\n", word64); */
+ res = VG_(mk_SysRes_ppc32_linux)(/*val*/(UInt)(word64 >> 32),
+ /*errflag*/ (((UInt)word64) >> 28) & 1);
+#elif defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux)
+ ULong word64;
+ UInt old_cr = LibVEX_GuestPPC64_get_CR( &ctst->arch.vex );
+ /* %r3 = 0 */
+ ctst->arch.vex.guest_GPR3 = 0;
+ /* %cr0.so = 0 */
+ LibVEX_GuestPPC64_put_CR( old_cr & ~(1<<28), &ctst->arch.vex );
+ word64 = do_syscall_clone_ppc64_linux
+ (ML_(start_thread_NORETURN), stack, flags, ctst,
+ child_tidptr, parent_tidptr, NULL);
+ /* Low half word64 is syscall return value. Hi half is
+ the entire CR, from which we need to extract CR0.SO. */
+ /* VG_(printf)("word64 = 0x%llx\n", word64); */
+ res = VG_(mk_SysRes_ppc64_linux)
+ (/*val*/(UInt)(word64 & 0xFFFFFFFFULL),
+ /*errflag*/ (UInt)((word64 >> (32+28)) & 1));
+#elif defined(VGP_s390x_linux)
+ ULong r2;
+ ctst->arch.vex.guest_r2 = 0;
+ r2 = do_syscall_clone_s390x_linux
+ (stack, flags, parent_tidptr, child_tidptr, NULL,
+ ML_(start_thread_NORETURN), ctst);
+ res = VG_(mk_SysRes_s390x_linux)( r2 );
+#elif defined(VGP_arm64_linux)
+ ULong x0;
+ ctst->arch.vex.guest_X0 = 0;
+ x0 = do_syscall_clone_arm64_linux
+ (ML_(start_thread_NORETURN), stack, flags, ctst,
+ child_tidptr, parent_tidptr, NULL);
+ res = VG_(mk_SysRes_arm64_linux)( x0 );
+#elif defined(VGP_arm_linux)
+ UInt r0;
+ ctst->arch.vex.guest_R0 = 0;
+ r0 = do_syscall_clone_arm_linux
+ (ML_(start_thread_NORETURN), stack, flags, ctst,
+ child_tidptr, parent_tidptr, NULL);
+ res = VG_(mk_SysRes_arm_linux)( r0 );
+#elif defined(VGP_mips64_linux)
+ UInt ret = 0;
+ ctst->arch.vex.guest_r2 = 0;
+ ctst->arch.vex.guest_r7 = 0;
+ ret = do_syscall_clone_mips64_linux
+ (ML_(start_thread_NORETURN), stack, flags, ctst,
+ parent_tidptr, NULL, child_tidptr);
+ res = VG_(mk_SysRes_mips64_linux)( /* val */ ret, 0, /* errflag */ 0);
+#elif defined(VGP_mips32_linux)
+ UInt ret = 0;
+ ctst->arch.vex.guest_r2 = 0;
+ ctst->arch.vex.guest_r7 = 0;
+ ret = do_syscall_clone_mips_linux
+ (ML_(start_thread_NORETURN), stack, flags, ctst,
+ child_tidptr, parent_tidptr, NULL);
+ /* High half word64 is syscall return value. Low half is
+ the entire CR, from which we need to extract CR0.SO. */
+ res = VG_ (mk_SysRes_mips32_linux) (/*val */ ret, 0, /*errflag */ 0);
+#elif defined(VGP_tilegx_linux)
+ Long ret = 0;
+ ctst->arch.vex.guest_r0 = 0;
+ ctst->arch.vex.guest_r3 = 0;
+ ret = do_syscall_clone_tilegx_linux
+ (ML_ (start_thread_NORETURN), stack, flags, ctst,
+ child_tidptr, parent_tidptr, NULL);
+ /* High half word64 is syscall return value. */
+ res = VG_(mk_SysRes_tilegx_linux) (/*val */ ret);
+#else
+# error Unknown platform
+#endif
+ return res;
+}
+
+static void setup_child ( /*OUT*/ ThreadArchState *child,
+ /*IN*/ ThreadArchState *parent )
+{
+ /* We inherit our parent's guest state. */
+ child->vex = parent->vex;
+ child->vex_shadow1 = parent->vex_shadow1;
+ child->vex_shadow2 = parent->vex_shadow2;
-/* Do a clone which is really a fork() */
-SysRes ML_(do_fork_clone) ( ThreadId tid, UInt flags,
- Int* parent_tidptr, Int* child_tidptr )
+#if defined(VGP_x86_linux)
+ extern void ML_(x86_setup_LDT_GDT) ( /*OUT*/ ThreadArchState *child,
+ /*IN*/ ThreadArchState *parent );
+ ML_(x86_setup_LDT_GDT)(child, parent);
+#endif
+}
+
+static SysRes setup_child_tls (ThreadId ctid, Addr tlsaddr)
+{
+ static const Bool debug = False;
+ ThreadState* ctst = VG_(get_ThreadState)(ctid);
+ // res is succesful by default, overriden if a real syscall is needed/done.
+ SysRes res = VG_(mk_SysRes_Success)(0);
+
+ if (debug)
+ VG_(printf)("clone child has SETTLS: tls at %#lx\n", tlsaddr);
+
+#if defined(VGP_x86_linux)
+ vki_modify_ldt_t* tlsinfo = (vki_modify_ldt_t*)tlsaddr;
+ if (debug)
+ VG_(printf)("clone child has SETTLS: tls info at %p: idx=%u "
+ "base=%#lx limit=%x; esp=%#x fs=%x gs=%x\n",
+ tlsinfo, tlsinfo->entry_number,
+ tlsinfo->base_addr, tlsinfo->limit,
+ ctst->arch.vex.guest_ESP,
+ ctst->arch.vex.guest_FS, ctst->arch.vex.guest_GS);
+ res = ML_(x86_sys_set_thread_area)(ctid, tlsinfo);
+#elif defined(VGP_amd64_linux)
+ ctst->arch.vex.guest_FS_CONST = tlsaddr;
+#elif defined(VGP_ppc32_linux)
+ ctst->arch.vex.guest_GPR2 = tlsaddr;
+#elif defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux)
+ ctst->arch.vex.guest_GPR13 = tlsaddr;
+#elif defined(VGP_s390x_linux)
+ ctst->arch.vex.guest_a0 = (UInt) (tlsaddr >> 32);
+ ctst->arch.vex.guest_a1 = (UInt) tlsaddr;
+#elif defined(VGP_arm64_linux)
+ /* Just assign the tls pointer in the guest TPIDR_EL0. */
+ ctst->arch.vex.guest_TPIDR_EL0 = tlsaddr;
+#elif defined(VGP_arm_linux)
+ /* Just assign the tls pointer in the guest TPIDRURO. */
+ ctst->arch.vex.guest_TPIDRURO = tlsaddr;
+#elif defined(VGP_mips64_linux)
+ ctst->arch.vex.guest_ULR = tlsaddr;
+ ctst->arch.vex.guest_r27 = tlsaddr;
+#elif defined(VGP_mips32_linux)
+ ctst->arch.vex.guest_ULR = tlsaddr;
+ ctst->arch.vex.guest_r27 = tlsaddr;
+#elif defined(VGP_tilegx_linux)
+ ctst->arch.vex.guest_r53 = tlsaddr;
+#else
+# error Unknown platform
+#endif
+ return res;
+}
+
+/*
+ When a client clones, we need to keep track of the new thread. This means:
+ 1. allocate a ThreadId+ThreadState+stack for the thread
+
+ 2. initialize the thread's new VCPU state
+
+ 3. create the thread using the same args as the client requested,
+ but using the scheduler entrypoint for EIP, and a separate stack
+ for ESP.
+ */
+static SysRes do_clone ( ThreadId ptid,
+ UWord flags, Addr sp,
+ Int* parent_tidptr,
+ Int* child_tidptr,
+ Addr tlsaddr)
+{
+ ThreadId ctid = VG_(alloc_ThreadState)();
+ ThreadState* ptst = VG_(get_ThreadState)(ptid);
+ ThreadState* ctst = VG_(get_ThreadState)(ctid);
+ UWord* stack;
+ SysRes res;
+ vki_sigset_t blockall, savedmask;
+
+ VG_(sigfillset)(&blockall);
+
+ vg_assert(VG_(is_running_thread)(ptid));
+ vg_assert(VG_(is_valid_tid)(ctid));
+
+ stack = (UWord*)ML_(allocstack)(ctid);
+ if (stack == NULL) {
+ res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
+ goto out;
+ }
+
+ /* Copy register state
+
+ Both parent and child return to the same place, and the code
+ following the clone syscall works out which is which, so we
+ don't need to worry about it.
+
+ The parent gets the child's new tid returned from clone, but the
+ child gets 0.
+
+ If the clone call specifies a NULL sp for the new thread, then
+ it actually gets a copy of the parent's sp.
+ */
+ setup_child( &ctst->arch, &ptst->arch );
+
+ if (sp != 0)
+ VG_(set_SP)(ctid, sp);
+
+ ctst->os_state.parent = ptid;
+
+ /* inherit signal mask */
+ ctst->sig_mask = ptst->sig_mask;
+ ctst->tmp_sig_mask = ptst->sig_mask;
+
+ /* Start the child with its threadgroup being the same as the
+ parent's. This is so that any exit_group calls that happen
+ after the child is created but before it sets its
+ os_state.threadgroup field for real (in thread_wrapper in
+ syswrap-linux.c), really kill the new thread. a.k.a this avoids
+ a race condition in which the thread is unkillable (via
+ exit_group) because its threadgroup is not set. The race window
+ is probably only a few hundred or a few thousand cycles long.
+ See #226116. */
+ ctst->os_state.threadgroup = ptst->os_state.threadgroup;
+
+ ML_(guess_and_register_stack) (sp, ctst);
+
+ /* Assume the clone will succeed, and tell any tool that wants to
+ know that this thread has come into existence. We cannot defer
+ it beyond this point because setup_tls, just below,
+ causes checks to assert by making references to the new ThreadId
+ if we don't state the new thread exists prior to that point.
+ If the clone fails, we'll send out a ll_exit notification for it
+ at the out: label below, to clean up. */
+ vg_assert(VG_(owns_BigLock_LL)(ptid));
+ VG_TRACK ( pre_thread_ll_create, ptid, ctid );
+
+ if (flags & VKI_CLONE_SETTLS) {
+ res = setup_child_tls(ctid, tlsaddr);
+ if (sr_isError(res))
+ goto out;
+ }
+ flags &= ~VKI_CLONE_SETTLS;
+
+ /* start the thread with everything blocked */
+ VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
+
+ /* Create the new thread */
+ res = clone_new_thread ( ML_(start_thread_NORETURN), stack, flags, ctst,
+ child_tidptr, parent_tidptr);
+
+ VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
+
+ out:
+ if (sr_isError(res)) {
+ /* clone failed */
+ VG_(cleanup_thread)(&ctst->arch);
+ ctst->status = VgTs_Empty;
+ /* oops. Better tell the tool the thread exited in a hurry :-) */
+ VG_TRACK( pre_thread_ll_exit, ctid );
+ }
+
+#if defined(VGP_mips64_linux) || defined(VGP_mips32_linux)
+ // ??? why do we set unconditionally r2 to 0, even when error out ???
+ ptst->arch.vex.guest_r2 = 0;
+#elif defined(VGP_tilegx_linux)
+ // ??? why do we set unconditionally r0 to 0, even when error out ???
+ ptst->arch.vex.guest_r0 = 0;
+#endif
+
+ return res;
+}
+
+/* Do a clone which is really a fork().
+ ML_(do_fork_clone) uses the clone syscall to fork a child process.
+ Note that this should not be called for a thread creation.
+ Also, some flags combinations are not supported, and such combinations
+ are handled either by masking the non supported flags or by asserting.
+
+ The CLONE_VFORK flag is accepted, as this just tells that the parent is
+ suspended till the child exits or calls execve. We better keep this flag,
+ just in case the guests parent/client code depends on this synchronisation.
+
+ We cannot keep the flag CLONE_VM, as Valgrind will do whatever host
+ instructions in the child process, that will mess up the parent host
+ memory. So, we hope for the best and assumes that the guest application does
+ not (really) depends on sharing the memory between parent and child in the
+ interval between clone and exits/execve.
+
+ If child_sp != 0, the child (guest) sp will be set to child_sp just after the
+ clone syscall, before child guest instructions are executed. */
+static SysRes ML_(do_fork_clone) ( ThreadId tid, UInt flags,
+ Int* parent_tidptr, Int* child_tidptr,
+ Addr child_sp)
{
vki_sigset_t fork_saved_mask;
vki_sigset_t mask;
SysRes res;
if (flags & (VKI_CLONE_SETTLS | VKI_CLONE_FS | VKI_CLONE_VM
- | VKI_CLONE_FILES | VKI_CLONE_VFORK))
+ | VKI_CLONE_FILES))
return VG_(mk_SysRes_Error)( VKI_EINVAL );
/* Block all signals during fork, so that we can fix things up in
@@ -476,6 +785,8 @@ SysRes ML_(do_fork_clone) ( ThreadId tid, UInt flags,
if (!sr_isError(res) && sr_Res(res) == 0) {
/* child */
+ if (child_sp != 0)
+ VG_(set_SP)(tid, child_sp);
VG_(do_atfork_child)(tid);
/* restore signal mask */
@@ -508,7 +819,6 @@ SysRes ML_(do_fork_clone) ( ThreadId tid, UInt flags,
return res;
}
-
/* ---------------------------------------------------------------------
PRE/POST wrappers for arch-generic, Linux-specific syscalls
------------------------------------------------------------------ */
@@ -519,6 +829,157 @@ SysRes ML_(do_fork_clone) ( ThreadId tid, UInt flags,
#error Unknown endianness
#endif
+PRE(sys_clone)
+{
+ UInt cloneflags;
+ Bool badarg = False;
+
+ PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
+
+// Order of arguments differs between platforms.
+#if defined(VGP_x86_linux) \
+ || defined(VGP_ppc32_linux) \
+ || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \
+ || defined(VGP_arm_linux) || defined(VGP_mips32_linux) \
+ || defined(VGP_mips64_linux) || defined(VGP_arm64_linux)
+#define ARG_CHILD_TIDPTR ARG5
+#define PRA_CHILD_TIDPTR PRA5
+#define ARG_TLS ARG4
+#define PRA_TLS PRA4
+#elif defined(VGP_amd64_linux) || defined(VGP_tilegx_linux) \
+ || defined(VGP_s390x_linux)
+#define ARG_CHILD_TIDPTR ARG4
+#define PRA_CHILD_TIDPTR PRA4
+#define ARG_TLS ARG5
+#define PRA_TLS PRA5
+#else
+# error Unknown platform
+#endif
+// And s390x is even more special, and inverts flags and child stack args
+#if defined(VGP_s390x_linux)
+#define ARG_FLAGS ARG2
+#define PRA_FLAGS PRA2
+#define ARG_CHILD_STACK ARG1
+#define PRA_CHILD_STACK PRA1
+#else
+#define ARG_FLAGS ARG1
+#define PRA_FLAGS PRA1
+#define ARG_CHILD_STACK ARG2
+#define PRA_CHILD_STACK PRA2
+#endif
+
+ if (VG_(tdict).track_pre_reg_read) {
+ PRA_FLAGS("clone", unsigned long, flags);
+ PRA_CHILD_STACK("clone", void *, child_stack);
+ }
+
+ if (ARG_FLAGS & VKI_CLONE_PARENT_SETTID) {
+ if (VG_(tdict).track_pre_reg_read) {
+ PRA3("clone", int *, parent_tidptr);
+ }
+ PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
+ if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int),
+ VKI_PROT_WRITE)) {
+ badarg = True;
+ }
+ }
+ if (ARG_FLAGS & VKI_CLONE_SETTLS) {
+ if (VG_(tdict).track_pre_reg_read) {
+ PRA_TLS("clone", vki_modify_ldt_t *, tlsinfo);
+ }
+ /* Not very clear what is vki_modify_ldt_t: for many platforms, it is a
+ dummy type (that we define as a char). We only dereference/check the
+ ARG_TLS pointer if the type looks like a real type, i.e. sizeof > 1. */
+ if (sizeof(vki_modify_ldt_t) > 1) {
+ PRE_MEM_READ("clone(tlsinfo)", ARG_TLS, sizeof(vki_modify_ldt_t));
+ if (!VG_(am_is_valid_for_client)(ARG_TLS, sizeof(vki_modify_ldt_t),
+ VKI_PROT_READ)) {
+ badarg = True;
+ }
+ }
+ }
+ if (ARG_FLAGS & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
+ if (VG_(tdict).track_pre_reg_read) {
+ PRA_CHILD_TIDPTR("clone", int *, child_tidptr);
+ }
+ PRE_MEM_WRITE("clone(child_tidptr)", ARG_CHILD_TIDPTR, sizeof(Int));
+ if (!VG_(am_is_valid_for_client)(ARG_CHILD_TIDPTR, sizeof(Int),
+ VKI_PROT_WRITE)) {
+ badarg = True;
+ }
+ }
+
+ if (badarg) {
+ SET_STATUS_Failure( VKI_EFAULT );
+ return;
+ }
+
+ cloneflags = ARG_FLAGS;
+
+ if (!ML_(client_signal_OK)(ARG_FLAGS & VKI_CSIGNAL)) {
+ SET_STATUS_Failure( VKI_EINVAL );
+ return;
+ }
+
+ /* Only look at the flags we really care about */
+ switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
+ | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
+ case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
+ /* thread creation */
+ SET_STATUS_from_SysRes(
+ do_clone(tid,
+ ARG_FLAGS, /* flags */
+ (Addr)ARG_CHILD_STACK, /* child ESP */
+ (Int*)ARG3, /* parent_tidptr */
+ (Int*)ARG_CHILD_TIDPTR, /* child_tidptr */
+ (Addr)ARG_TLS)); /* set_tls */
+ break;
+
+ case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
+ // FALLTHROUGH - assume vfork (somewhat) == fork, see ML_(do_fork_clone).
+ cloneflags &= ~VKI_CLONE_VM;
+
+ case 0: /* plain fork */
+ SET_STATUS_from_SysRes(
+ ML_(do_fork_clone)(tid,
+ cloneflags, /* flags */
+ (Int*)ARG3, /* parent_tidptr */
+ (Int*)ARG_CHILD_TIDPTR, /* child_tidptr */
+ (Addr)ARG_CHILD_STACK));
+ break;
+
+ default:
+ /* should we just ENOSYS? */
+ VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG_FLAGS);
+ VG_(message)(Vg_UserMsg, "\n");
+ VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
+ VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)\n");
+ VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n");
+ VG_(unimplemented)
+ ("Valgrind does not support general clone().");
+ }
+
+ if (SUCCESS) {
+ if (ARG_FLAGS & VKI_CLONE_PARENT_SETTID)
+ POST_MEM_WRITE(ARG3, sizeof(Int));
+ if (ARG_FLAGS & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
+ POST_MEM_WRITE(ARG_CHILD_TIDPTR, sizeof(Int));
+
+ /* Thread creation was successful; let the child have the chance
+ to run */
+ *flags |= SfYieldAfter;
+ }
+
+#undef ARG_CHILD_TIDPTR
+#undef PRA_CHILD_TIDPTR
+#undef ARG_TLS
+#undef PRA_TLS
+#undef ARG_FLAGS
+#undef PRA_FLAGS
+#undef ARG_CHILD_STACK
+#undef PRA_CHILD_STACK
+}
+
/* ---------------------------------------------------------------------
*mount wrappers
------------------------------------------------------------------ */
diff --git a/coregrind/m_syswrap/syswrap-mips64-linux.c b/coregrind/m_syswrap/syswrap-mips64-linux.c
index 6e3db74..d3d70c5 100644
--- a/coregrind/m_syswrap/syswrap-mips64-linux.c
+++ b/coregrind/m_syswrap/syswrap-mips64-linux.c
@@ -136,14 +136,7 @@ asm (
#define __NR_CLONE __NR_clone
#define __NR_EXIT __NR_exit
-ULong do_syscall_clone_mips64_linux ( Word (*fn) (void *), /* a0 - 4 */
- void* stack, /* a1 - 5 */
- Int flags, /* a2 - 6 */
- void* arg, /* a3 - 7 */
- Int* parent_tid, /* a4 - 8 */
- void* /* Int tls */, /* a5 - 9 */
- Int* child_tid ); /* a6 - 10 */
-
+// See priv_syswrap-linux.h for arg profile.
asm(
".text\n"
".set noreorder\n"
@@ -199,104 +192,13 @@ asm(
#undef __NR_EXIT
/* forward declarations */
-static void setup_child ( ThreadArchState *, ThreadArchState *);
static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr);
-/* When a client clones, we need to keep track of the new thread. This means:
- 1. allocate a ThreadId+ThreadState+stack for the thread
-
- 2. initialize the thread's new VCPU state
-
- 3. create the thread using the same args as the client requested, but using
- the scheduler entrypoint for IP, and a separate stack for SP. */
-static SysRes do_clone ( ThreadId ptid,
- UInt flags, Addr sp,
- Int* parent_tidptr,
- Int* child_tidptr,
- Addr child_tls )
-{
- const Bool debug = False;
- ThreadId ctid = VG_ (alloc_ThreadState) ();
- ThreadState * ptst = VG_ (get_ThreadState) (ptid);
- ThreadState * ctst = VG_ (get_ThreadState) (ctid);
- UInt ret = 0;
- UWord * stack;
- SysRes res;
- vki_sigset_t blockall, savedmask;
-
- VG_(sigfillset)(&blockall);
- vg_assert(VG_(is_running_thread)(ptid));
- vg_assert(VG_(is_valid_tid)(ctid));
- stack = (UWord *)ML_(allocstack)(ctid);
- if (stack == NULL) {
- res = VG_(mk_SysRes_Error)(VKI_ENOMEM);
- goto out;
- }
- setup_child(&ctst->arch, &ptst->arch);
-
- /* on MIPS we need to set V0 and A3 to zero */
- ctst->arch.vex.guest_r2 = 0;
- ctst->arch.vex.guest_r7 = 0;
- if (sp != 0)
- ctst->arch.vex.guest_r29 = sp;
-
- ctst->os_state.parent = ptid;
- ctst->sig_mask = ptst->sig_mask;
- ctst->tmp_sig_mask = ptst->sig_mask;
-
- ctst->os_state.threadgroup = ptst->os_state.threadgroup;
-
- ML_(guess_and_register_stack) (sp, ctst);
-
- VG_TRACK(pre_thread_ll_create, ptid, ctid);
- if (flags & VKI_CLONE_SETTLS) {
- if (debug)
- VG_(printf)("clone child has SETTLS: tls at %#lx\n", child_tls);
- res = sys_set_tls(ctid, child_tls);
- if (sr_isError(res))
- goto out;
- ctst->arch.vex.guest_r27 = child_tls;
- }
-
- flags &= ~VKI_CLONE_SETTLS;
- VG_ (sigprocmask) (VKI_SIG_SETMASK, &blockall, &savedmask);
- /* Create the new thread */
- ret = do_syscall_clone_mips64_linux(ML_(start_thread_NORETURN),
- stack, flags, &VG_(threads)[ctid],
- parent_tidptr, NULL /*child_tls*/,
- child_tidptr);
- if (debug)
- VG_(printf)("ret: 0x%x\n", ret);
-
- res = VG_(mk_SysRes_mips64_linux)( /* val */ ret, 0, /* errflag */ 0);
-
- VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
-
- out:
- if (sr_isError (res)) {
- VG_ (cleanup_thread) (&ctst->arch);
- ctst->status = VgTs_Empty;
- VG_TRACK (pre_thread_ll_exit, ctid);
- }
- ptst->arch.vex.guest_r2 = 0;
-
- return res;
-}
-
/* ---------------------------------------------------------------------
More thread stuff
------------------------------------------------------------------ */
void VG_(cleanup_thread) ( ThreadArchState * arch ) { };
-void setup_child ( /* OUT */ ThreadArchState * child,
- /* IN */ ThreadArchState * parent )
-{
- /* We inherit our parent's guest state. */
- child->vex = parent->vex;
- child->vex_shadow1 = parent->vex_shadow1;
- child->vex_shadow2 = parent->vex_shadow2;
-}
-
SysRes sys_set_tls ( ThreadId tid, Addr tlsptr )
{
VG_(threads)[tid].arch.vex.guest_ULR = tlsptr;
@@ -316,7 +218,6 @@ SysRes sys_set_tls ( ThreadId tid, Addr tlsptr )
file, but that requires even more macro magic. */
DECL_TEMPLATE (mips_linux, sys_set_thread_area);
-DECL_TEMPLATE (mips_linux, sys_clone);
DECL_TEMPLATE (mips_linux, sys_tee);
DECL_TEMPLATE (mips_linux, sys_splice);
DECL_TEMPLATE (mips_linux, sys_vmsplice);
@@ -494,84 +395,6 @@ PRE(sys_mmap)
(Off64T) ARG6);
SET_STATUS_from_SysRes(r);
}
-
-PRE(sys_clone)
-{
- Bool badarg = False;
- UInt cloneflags;
- PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )", ARG1, ARG2, ARG3,
- ARG4, ARG5);
- PRE_REG_READ2(int, "clone", unsigned long, flags, void *, child_stack);
- if (ARG1 & VKI_CLONE_PARENT_SETTID) {
- if (VG_(tdict).track_pre_reg_read) {
- PRA3("clone", int *, parent_tidptr);
- }
- PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int), VKI_PROT_WRITE)) {
- badarg = True;
- }
- }
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
- if (VG_(tdict).track_pre_reg_read) {
- PRA5("clone", int *, child_tidptr);
- }
- PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof (Int));
- if (!VG_(am_is_valid_for_client)(ARG5, sizeof (Int), VKI_PROT_WRITE))
- badarg = True;
- }
- if (badarg) {
- SET_STATUS_Failure(VKI_EFAULT);
- return;
- }
- cloneflags = ARG1;
- if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
- SET_STATUS_Failure(VKI_EINVAL);
- return;
- }
- /* Only look at the flags we really care about */
- switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
- |VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
- case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
- /* thread creation */
- SET_STATUS_from_SysRes(do_clone(tid,
- ARG1, /* flags */
- (Addr)ARG2, /* child SP */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG5, /* child_tidptr */
- (Addr)ARG4)); /* child_tls */
- break;
-
- case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
- /* FALLTHROUGH - assume vfork == fork */
- cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
- case 0: /* plain fork */
- SET_STATUS_from_SysRes(ML_(do_fork_clone)(tid,
- cloneflags, /* flags */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG5)); /* child_tidptr */
- break;
-
- default:
- /* should we just ENOSYS? */
- VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1);
- VG_(message)(Vg_UserMsg, "\n");
- VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
- VG_(message)(Vg_UserMsg,
- " - via a threads library (LinuxThreads or NPTL)\n");
- VG_(message)(Vg_UserMsg,
- " - via the implementation of fork or vfork\n");
- VG_(unimplemented)("Valgrind does not support general clone().");
- }
- if (SUCCESS) {
- if (ARG1 & VKI_CLONE_PARENT_SETTID)
- POST_MEM_WRITE(ARG3, sizeof(Int));
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
- POST_MEM_WRITE(ARG5, sizeof(Int));
- /* Thread creation was successful; let the child have the chance to run */
- *flags |= SfYieldAfter;
- }
-}
-
PRE(sys_rt_sigreturn)
{
/* See comments on PRE(sys_rt_sigreturn) in syswrap-s390x-linux.c for
@@ -766,7 +589,7 @@ static SyscallTableEntry syscall_main_table[] = {
LINXY (__NR_socketpair, sys_socketpair),
LINX_ (__NR_setsockopt, sys_setsockopt),
LINXY (__NR_getsockopt, sys_getsockopt),
- PLAX_ (__NR_clone, sys_clone),
+ LINX_ (__NR_clone, sys_clone),
GENX_ (__NR_fork, sys_fork),
GENX_ (__NR_execve, sys_execve),
GENX_ (__NR_exit, sys_exit),
diff --git a/coregrind/m_syswrap/syswrap-ppc32-linux.c b/coregrind/m_syswrap/syswrap-ppc32-linux.c
index 379fcb3..a654a90 100644
--- a/coregrind/m_syswrap/syswrap-ppc32-linux.c
+++ b/coregrind/m_syswrap/syswrap-ppc32-linux.c
@@ -146,14 +146,7 @@ asm(
#define __NR_CLONE VG_STRINGIFY(__NR_clone)
#define __NR_EXIT VG_STRINGIFY(__NR_exit)
-extern
-ULong do_syscall_clone_ppc32_linux ( Word (*fn)(void *),
- void* stack,
- Int flags,
- void* arg,
- Int* child_tid,
- Int* parent_tid,
- vki_modify_ldt_t * );
+// See priv_syswrap-linux.h for arg profile.
asm(
".text\n"
".globl do_syscall_clone_ppc32_linux\n"
@@ -216,145 +209,6 @@ asm(
#undef __NR_CLONE
#undef __NR_EXIT
-// forward declarations
-static void setup_child ( ThreadArchState*, ThreadArchState* );
-
-/*
- When a client clones, we need to keep track of the new thread. This means:
- 1. allocate a ThreadId+ThreadState+stack for the thread
-
- 2. initialize the thread's new VCPU state
-
- 3. create the thread using the same args as the client requested,
- but using the scheduler entrypoint for IP, and a separate stack
- for SP.
- */
-static SysRes do_clone ( ThreadId ptid,
- UInt flags, Addr sp,
- Int *parent_tidptr,
- Int *child_tidptr,
- Addr child_tls)
-{
- const Bool debug = False;
-
- ThreadId ctid = VG_(alloc_ThreadState)();
- ThreadState* ptst = VG_(get_ThreadState)(ptid);
- ThreadState* ctst = VG_(get_ThreadState)(ctid);
- ULong word64;
- UWord* stack;
- SysRes res;
- vki_sigset_t blockall, savedmask;
-
- VG_(sigfillset)(&blockall);
-
- vg_assert(VG_(is_running_thread)(ptid));
- vg_assert(VG_(is_valid_tid)(ctid));
-
- stack = (UWord*)ML_(allocstack)(ctid);
- if (stack == NULL) {
- res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
- goto out;
- }
-
-//? /* make a stack frame */
-//? stack -= 16;
-//? *(UWord *)stack = 0;
-
-
- /* Copy register state
-
- Both parent and child return to the same place, and the code
- following the clone syscall works out which is which, so we
- don't need to worry about it.
-
- The parent gets the child's new tid returned from clone, but the
- child gets 0.
-
- If the clone call specifies a NULL SP for the new thread, then
- it actually gets a copy of the parent's SP.
-
- The child's TLS register (r2) gets set to the tlsaddr argument
- if the CLONE_SETTLS flag is set.
- */
- setup_child( &ctst->arch, &ptst->arch );
-
- /* Make sys_clone appear to have returned Success(0) in the
- child. */
- { UInt old_cr = LibVEX_GuestPPC32_get_CR( &ctst->arch.vex );
- /* %r3 = 0 */
- ctst->arch.vex.guest_GPR3 = 0;
- /* %cr0.so = 0 */
- LibVEX_GuestPPC32_put_CR( old_cr & ~(1<<28), &ctst->arch.vex );
- }
-
- if (sp != 0)
- ctst->arch.vex.guest_GPR1 = sp;
-
- ctst->os_state.parent = ptid;
-
- /* inherit signal mask */
- ctst->sig_mask = ptst->sig_mask;
- ctst->tmp_sig_mask = ptst->sig_mask;
-
- /* Start the child with its threadgroup being the same as the
- parent's. This is so that any exit_group calls that happen
- after the child is created but before it sets its
- os_state.threadgroup field for real (in thread_wrapper in
- syswrap-linux.c), really kill the new thread. a.k.a this avoids
- a race condition in which the thread is unkillable (via
- exit_group) because its threadgroup is not set. The race window
- is probably only a few hundred or a few thousand cycles long.
- See #226116. */
- ctst->os_state.threadgroup = ptst->os_state.threadgroup;
-
- ML_(guess_and_register_stack) (sp, ctst);
-
- /* Assume the clone will succeed, and tell any tool that wants to
- know that this thread has come into existence. If the clone
- fails, we'll send out a ll_exit notification for it at the out:
- label below, to clean up. */
- vg_assert(VG_(owns_BigLock_LL)(ptid));
- VG_TRACK ( pre_thread_ll_create, ptid, ctid );
-
- if (flags & VKI_CLONE_SETTLS) {
- if (debug)
- VG_(printf)("clone child has SETTLS: tls at %#lx\n", child_tls);
- ctst->arch.vex.guest_GPR2 = child_tls;
- }
-
- flags &= ~VKI_CLONE_SETTLS;
-
- /* start the thread with everything blocked */
- VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
-
- /* Create the new thread */
- word64 = do_syscall_clone_ppc32_linux(
- ML_(start_thread_NORETURN), stack, flags, &VG_(threads)[ctid],
- child_tidptr, parent_tidptr, NULL
- );
- /* High half word64 is syscall return value. Low half is
- the entire CR, from which we need to extract CR0.SO. */
- /* VG_(printf)("word64 = 0x%llx\n", word64); */
- res = VG_(mk_SysRes_ppc32_linux)(
- /*val*/(UInt)(word64 >> 32),
- /*errflag*/ (((UInt)word64) >> 28) & 1
- );
-
- VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
-
- out:
- if (sr_isError(res)) {
- /* clone failed */
- VG_(cleanup_thread)(&ctst->arch);
- ctst->status = VgTs_Empty;
- /* oops. Better tell the tool the thread exited in a hurry :-) */
- VG_TRACK( pre_thread_ll_exit, ctid );
- }
-
- return res;
-}
-
-
/* ---------------------------------------------------------------------
More thread stuff
@@ -364,16 +218,6 @@ void VG_(cleanup_thread) ( ThreadArchState* arch )
{
}
-void setup_child ( /*OUT*/ ThreadArchState *child,
- /*IN*/ ThreadArchState *parent )
-{
- /* We inherit our parent's guest state. */
- child->vex = parent->vex;
- child->vex_shadow1 = parent->vex_shadow1;
- child->vex_shadow2 = parent->vex_shadow2;
-}
-
-
/* ---------------------------------------------------------------------
PRE/POST wrappers for ppc32/Linux-specific syscalls
------------------------------------------------------------------ */
@@ -393,7 +237,6 @@ DECL_TEMPLATE(ppc32_linux, sys_stat64);
DECL_TEMPLATE(ppc32_linux, sys_lstat64);
DECL_TEMPLATE(ppc32_linux, sys_fstatat64);
DECL_TEMPLATE(ppc32_linux, sys_fstat64);
-DECL_TEMPLATE(ppc32_linux, sys_clone);
DECL_TEMPLATE(ppc32_linux, sys_sigreturn);
DECL_TEMPLATE(ppc32_linux, sys_rt_sigreturn);
DECL_TEMPLATE(ppc32_linux, sys_sigsuspend);
@@ -530,91 +373,6 @@ POST(sys_fstat64)
//.. }
//.. }
-PRE(sys_clone)
-{
- UInt cloneflags;
-
- PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
- PRE_REG_READ5(int, "clone",
- unsigned long, flags,
- void *, child_stack,
- int *, parent_tidptr,
- void *, child_tls,
- int *, child_tidptr);
-
- if (ARG1 & VKI_CLONE_PARENT_SETTID) {
- PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int),
- VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
- PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG5, sizeof(Int),
- VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
-
- cloneflags = ARG1;
-
- if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
- SET_STATUS_Failure( VKI_EINVAL );
- return;
- }
-
- /* Only look at the flags we really care about */
- switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
- | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
- case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
- /* thread creation */
- SET_STATUS_from_SysRes(
- do_clone(tid,
- ARG1, /* flags */
- (Addr)ARG2, /* child SP */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG5, /* child_tidptr */
- (Addr)ARG4)); /* child_tls */
- break;
-
- case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
- /* FALLTHROUGH - assume vfork == fork */
- cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
-
- case 0: /* plain fork */
- SET_STATUS_from_SysRes(
- ML_(do_fork_clone)(tid,
- cloneflags, /* flags */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG5)); /* child_tidptr */
- break;
-
- default:
- /* should we just ENOSYS? */
- VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1);
- VG_(message)(Vg_UserMsg, "\n");
- VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
- VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)\n");
- VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n");
- VG_(unimplemented)
- ("Valgrind does not support general clone().");
- }
-
- if (SUCCESS) {
- if (ARG1 & VKI_CLONE_PARENT_SETTID)
- POST_MEM_WRITE(ARG3, sizeof(Int));
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
- POST_MEM_WRITE(ARG5, sizeof(Int));
-
- /* Thread creation was successful; let the child have the chance
- to run */
- *flags |= SfYieldAfter;
- }
-}
-
PRE(sys_sigreturn)
{
/* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
@@ -999,7 +757,7 @@ static SyscallTableEntry syscall_table[] = {
GENX_(__NR_fsync, sys_fsync), // 118
PLAX_(__NR_sigreturn, sys_sigreturn), // 119 ?/Linux
//..
- PLAX_(__NR_clone, sys_clone), // 120
+ LINX_(__NR_clone, sys_clone), // 120
//.. // (__NR_setdomainname, sys_setdomainname), // 121 */*(?)
GENXY(__NR_uname, sys_newuname), // 122
//.. PLAX_(__NR_modify_ldt, sys_modify_ldt), // 123
diff --git a/coregrind/m_syswrap/syswrap-ppc64-linux.c b/coregrind/m_syswrap/syswrap-ppc64-linux.c
index 1ae4454..f90140d 100644
--- a/coregrind/m_syswrap/syswrap-ppc64-linux.c
+++ b/coregrind/m_syswrap/syswrap-ppc64-linux.c
@@ -209,14 +209,7 @@ asm(
#define __NR_CLONE VG_STRINGIFY(__NR_clone)
#define __NR_EXIT VG_STRINGIFY(__NR_exit)
-extern
-ULong do_syscall_clone_ppc64_linux ( Word (*fn)(void *),
- void* stack,
- Int flags,
- void* arg,
- Int* child_tid,
- Int* parent_tid,
- void/*vki_modify_ldt_t*/ * );
+// See priv_syswrap-linux.h for arg profile.
asm(
#if defined(VGP_ppc64be_linux)
" .align 2\n"
@@ -366,148 +359,6 @@ asm(
#undef __NR_CLONE
#undef __NR_EXIT
-// forward declarations
-static void setup_child ( ThreadArchState*, ThreadArchState* );
-
-/*
- When a client clones, we need to keep track of the new thread. This means:
- 1. allocate a ThreadId+ThreadState+stack for the thread
-
- 2. initialize the thread's new VCPU state
-
- 3. create the thread using the same args as the client requested,
- but using the scheduler entrypoint for IP, and a separate stack
- for SP.
- */
-static SysRes do_clone ( ThreadId ptid,
- UInt flags, Addr sp,
- Int *parent_tidptr,
- Int *child_tidptr,
- Addr child_tls)
-{
- const Bool debug = False;
-
- ThreadId ctid = VG_(alloc_ThreadState)();
- ThreadState* ptst = VG_(get_ThreadState)(ptid);
- ThreadState* ctst = VG_(get_ThreadState)(ctid);
- ULong word64;
- UWord* stack;
- SysRes res;
- vki_sigset_t blockall, savedmask;
-
- VG_(sigfillset)(&blockall);
-
- vg_assert(VG_(is_running_thread)(ptid));
- vg_assert(VG_(is_valid_tid)(ctid));
-
- stack = (UWord*)ML_(allocstack)(ctid);
- if (stack == NULL) {
- res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
- goto out;
- }
-
-//? /* make a stack frame */
-//? stack -= 16;
-//? *(UWord *)stack = 0;
-
-
- /* Copy register state
-
- Both parent and child return to the same place, and the code
- following the clone syscall works out which is which, so we
- don't need to worry about it.
-
- The parent gets the child's new tid returned from clone, but the
- child gets 0.
-
- If the clone call specifies a NULL SP for the new thread, then
- it actually gets a copy of the parent's SP.
-
- The child's TLS register (r2) gets set to the tlsaddr argument
- if the CLONE_SETTLS flag is set.
- */
- setup_child( &ctst->arch, &ptst->arch );
-
- /* Make sys_clone appear to have returned Success(0) in the
- child. */
- { UInt old_cr = LibVEX_GuestPPC64_get_CR( &ctst->arch.vex );
- /* %r3 = 0 */
- ctst->arch.vex.guest_GPR3 = 0;
- /* %cr0.so = 0 */
- LibVEX_GuestPPC64_put_CR( old_cr & ~(1<<28), &ctst->arch.vex );
- }
-
- if (sp != 0)
- ctst->arch.vex.guest_GPR1 = sp;
-
- ctst->os_state.parent = ptid;
-
- /* inherit signal mask */
- ctst->sig_mask = ptst->sig_mask;
- ctst->tmp_sig_mask = ptst->sig_mask;
-
- /* Start the child with its threadgroup being the same as the
- parent's. This is so that any exit_group calls that happen
- after the child is created but before it sets its
- os_state.threadgroup field for real (in thread_wrapper in
- syswrap-linux.c), really kill the new thread. a.k.a this avoids
- a race condition in which the thread is unkillable (via
- exit_group) because its threadgroup is not set. The race window
- is probably only a few hundred or a few thousand cycles long.
- See #226116. */
- ctst->os_state.threadgroup = ptst->os_state.threadgroup;
-
- ML_(guess_and_register_stack) (sp, ctst);
-
- /* Assume the clone will succeed, and tell any tool that wants to
- know that this thread has come into existence. If the clone
- fails, we'll send out a ll_exit notification for it at the out:
- label below, to clean up. */
- vg_assert(VG_(owns_BigLock_LL)(ptid));
- VG_TRACK ( pre_thread_ll_create, ptid, ctid );
-
- if (flags & VKI_CLONE_SETTLS) {
- if (debug)
- VG_(printf)("clone child has SETTLS: tls at %#lx\n", child_tls);
- ctst->arch.vex.guest_GPR13 = child_tls;
- }
-
- flags &= ~VKI_CLONE_SETTLS;
-
- /* start the thread with everything blocked */
- VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
-
- /* Create the new thread */
- word64 = do_syscall_clone_ppc64_linux(
- ML_(start_thread_NORETURN),
- stack, flags, &VG_(threads)[ctid],
- child_tidptr, parent_tidptr, NULL
- );
-
- /* Low half word64 is syscall return value. Hi half is
- the entire CR, from which we need to extract CR0.SO. */
- /* VG_(printf)("word64 = 0x%llx\n", word64); */
- res = VG_(mk_SysRes_ppc64_linux)(
- /*val*/(UInt)(word64 & 0xFFFFFFFFULL),
- /*errflag*/ (UInt)((word64 >> (32+28)) & 1)
- );
-
- VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
-
- out:
- if (sr_isError(res)) {
- /* clone failed */
- VG_(cleanup_thread)(&ctst->arch);
- ctst->status = VgTs_Empty;
- /* oops. Better tell the tool the thread exited in a hurry :-) */
- VG_TRACK( pre_thread_ll_exit, ctid );
- }
-
- return res;
-}
-
-
-
/* ---------------------------------------------------------------------
More thread stuff
------------------------------------------------------------------ */
@@ -516,16 +367,6 @@ void VG_(cleanup_thread) ( ThreadArchState* arch )
{
}
-void setup_child ( /*OUT*/ ThreadArchState *child,
- /*IN*/ ThreadArchState *parent )
-{
- /* We inherit our parent's guest state. */
- child->vex = parent->vex;
- child->vex_shadow1 = parent->vex_shadow1;
- child->vex_shadow2 = parent->vex_shadow2;
-}
-
-
/* ---------------------------------------------------------------------
PRE/POST wrappers for ppc64/Linux-specific syscalls
------------------------------------------------------------------ */
@@ -544,7 +385,6 @@ DECL_TEMPLATE(ppc64_linux, sys_mmap);
//zz DECL_TEMPLATE(ppc64_linux, sys_stat64);
//zz DECL_TEMPLATE(ppc64_linux, sys_lstat64);
//zz DECL_TEMPLATE(ppc64_linux, sys_fstat64);
-DECL_TEMPLATE(ppc64_linux, sys_clone);
//zz DECL_TEMPLATE(ppc64_linux, sys_sigreturn);
DECL_TEMPLATE(ppc64_linux, sys_rt_sigreturn);
DECL_TEMPLATE(ppc64_linux, sys_fadvise64);
@@ -629,92 +469,6 @@ PRE(sys_mmap)
//zz POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
//zz }
-
-PRE(sys_clone)
-{
- UInt cloneflags;
-
- PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
- PRE_REG_READ5(int, "clone",
- unsigned long, flags,
- void *, child_stack,
- int *, parent_tidptr,
- void *, child_tls,
- int *, child_tidptr);
-
- if (ARG1 & VKI_CLONE_PARENT_SETTID) {
- PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int),
- VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
- PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG5, sizeof(Int),
- VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
-
- cloneflags = ARG1;
-
- if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
- SET_STATUS_Failure( VKI_EINVAL );
- return;
- }
-
- /* Only look at the flags we really care about */
- switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
- | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
- case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
- /* thread creation */
- SET_STATUS_from_SysRes(
- do_clone(tid,
- ARG1, /* flags */
- (Addr)ARG2, /* child SP */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG5, /* child_tidptr */
- (Addr)ARG4)); /* child_tls */
- break;
-
- case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
- /* FALLTHROUGH - assume vfork == fork */
- cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
-
- case 0: /* plain fork */
- SET_STATUS_from_SysRes(
- ML_(do_fork_clone)(tid,
- cloneflags, /* flags */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG5)); /* child_tidptr */
- break;
-
- default:
- /* should we just ENOSYS? */
- VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1);
- VG_(message)(Vg_UserMsg, "\n");
- VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
- VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)\n");
- VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n");
- VG_(unimplemented)
- ("Valgrind does not support general clone().");
- }
-
- if (SUCCESS) {
- if (ARG1 & VKI_CLONE_PARENT_SETTID)
- POST_MEM_WRITE(ARG3, sizeof(Int));
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
- POST_MEM_WRITE(ARG5, sizeof(Int));
-
- /* Thread creation was successful; let the child have the chance
- to run */
- *flags |= SfYieldAfter;
- }
-}
-
PRE(sys_fadvise64)
{
PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", SARG1, SARG2, SARG3, SARG4);
@@ -922,7 +676,7 @@ static SyscallTableEntry syscall_table[] = {
GENX_(__NR_fsync, sys_fsync), // 118
// _____(__NR_sigreturn, sys_sigreturn), // 119
- PLAX_(__NR_clone, sys_clone), // 120
+ LINX_(__NR_clone, sys_clone), // 120
// _____(__NR_setdomainname, sys_setdomainname), // 121
GENXY(__NR_uname, sys_newuname), // 122
// _____(__NR_modify_ldt, sys_modify_ldt), // 123
diff --git a/coregrind/m_syswrap/syswrap-s390x-linux.c b/coregrind/m_syswrap/syswrap-s390x-linux.c
index ebb8295..f596341 100644
--- a/coregrind/m_syswrap/syswrap-s390x-linux.c
+++ b/coregrind/m_syswrap/syswrap-s390x-linux.c
@@ -138,14 +138,7 @@ asm(
#define __NR_CLONE VG_STRINGIFY(__NR_clone)
#define __NR_EXIT VG_STRINGIFY(__NR_exit)
-extern
-ULong do_syscall_clone_s390x_linux ( void *stack,
- ULong flags,
- Int *parent_tid,
- Int *child_tid,
- Addr tlsaddr,
- Word (*fn)(void *),
- void *arg);
+// See priv_syswrap-linux.h for arg profile.
asm(
" .text\n"
" .align 4\n"
@@ -182,126 +175,6 @@ void VG_(cleanup_thread) ( ThreadArchState* arch )
/* only used on x86 for descriptor tables */
}
-static void setup_child ( /*OUT*/ ThreadArchState *child,
- /*IN*/ ThreadArchState *parent )
-{
- /* We inherit our parent's guest state. */
- child->vex = parent->vex;
- child->vex_shadow1 = parent->vex_shadow1;
- child->vex_shadow2 = parent->vex_shadow2;
-}
-
-
-/*
- When a client clones, we need to keep track of the new thread. This means:
- 1. allocate a ThreadId+ThreadState+stack for the thread
-
- 2. initialize the thread's new VCPU state
-
- 3. create the thread using the same args as the client requested,
- but using the scheduler entrypoint for IP, and a separate stack
- for SP.
- */
-static SysRes do_clone ( ThreadId ptid,
- Addr sp, ULong flags,
- Int *parent_tidptr,
- Int *child_tidptr,
- Addr tlsaddr)
-{
- static const Bool debug = False;
-
- ThreadId ctid = VG_(alloc_ThreadState)();
- ThreadState* ptst = VG_(get_ThreadState)(ptid);
- ThreadState* ctst = VG_(get_ThreadState)(ctid);
- UWord* stack;
- SysRes res;
- ULong r2;
- vki_sigset_t blockall, savedmask;
-
- VG_(sigfillset)(&blockall);
-
- vg_assert(VG_(is_running_thread)(ptid));
- vg_assert(VG_(is_valid_tid)(ctid));
-
- stack = (UWord*)ML_(allocstack)(ctid);
- if (stack == NULL) {
- res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
- goto out;
- }
-
- /* Copy register state
-
- Both parent and child return to the same place, and the code
- following the clone syscall works out which is which, so we
- don't need to worry about it.
-
- The parent gets the child's new tid returned from clone, but the
- child gets 0.
-
- If the clone call specifies a NULL sp for the new thread, then
- it actually gets a copy of the parent's sp.
- */
- setup_child( &ctst->arch, &ptst->arch );
-
- /* Make sys_clone appear to have returned Success(0) in the
- child. */
- ctst->arch.vex.guest_r2 = 0;
-
- if (sp != 0)
- ctst->arch.vex.guest_SP = sp;
-
- ctst->os_state.parent = ptid;
-
- /* inherit signal mask */
- ctst->sig_mask = ptst->sig_mask;
- ctst->tmp_sig_mask = ptst->sig_mask;
-
- /* have the parents thread group */
- ctst->os_state.threadgroup = ptst->os_state.threadgroup;
-
- ML_(guess_and_register_stack) (sp, ctst);
-
- /* Assume the clone will succeed, and tell any tool that wants to
- know that this thread has come into existence. If the clone
- fails, we'll send out a ll_exit notification for it at the out:
- label below, to clean up. */
- vg_assert(VG_(owns_BigLock_LL)(ptid));
- VG_TRACK ( pre_thread_ll_create, ptid, ctid );
-
- if (flags & VKI_CLONE_SETTLS) {
- if (debug)
- VG_(printf)("clone child has SETTLS: tls at %#lx\n", tlsaddr);
- ctst->arch.vex.guest_a0 = (UInt) (tlsaddr >> 32);
- ctst->arch.vex.guest_a1 = (UInt) tlsaddr;
- }
- flags &= ~VKI_CLONE_SETTLS;
-
- /* start the thread with everything blocked */
- VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
-
- /* Create the new thread */
- r2 = do_syscall_clone_s390x_linux(
- stack, flags, parent_tidptr, child_tidptr, tlsaddr,
- ML_(start_thread_NORETURN), &VG_(threads)[ctid]);
-
- res = VG_(mk_SysRes_s390x_linux)( r2 );
-
- VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
-
- out:
- if (sr_isError(res)) {
- /* clone failed */
- ctst->status = VgTs_Empty;
- /* oops. Better tell the tool the thread exited in a hurry :-) */
- VG_TRACK( pre_thread_ll_exit, ctid );
- }
-
- return res;
-
-}
-
-
-
/* ---------------------------------------------------------------------
PRE/POST wrappers for s390x/Linux-specific syscalls
------------------------------------------------------------------ */
@@ -317,7 +190,6 @@ static SysRes do_clone ( ThreadId ptid,
DECL_TEMPLATE(s390x_linux, sys_ptrace);
DECL_TEMPLATE(s390x_linux, sys_mmap);
-DECL_TEMPLATE(s390x_linux, sys_clone);
DECL_TEMPLATE(s390x_linux, sys_sigreturn);
DECL_TEMPLATE(s390x_linux, sys_rt_sigreturn);
DECL_TEMPLATE(s390x_linux, sys_fadvise64);
@@ -452,99 +324,6 @@ PRE(sys_mmap)
SET_STATUS_from_SysRes(r);
}
-PRE(sys_clone)
-{
- UInt cloneflags;
-
- PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4, ARG5);
- PRE_REG_READ2(int, "clone",
- void *, child_stack,
- unsigned long, flags);
-
- if (ARG2 & VKI_CLONE_PARENT_SETTID) {
- if (VG_(tdict).track_pre_reg_read)
- PRA3("clone(parent_tidptr)", int *, parent_tidptr);
- PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int),
- VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
- if (ARG2 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
- if (VG_(tdict).track_pre_reg_read)
- PRA4("clone(child_tidptr)", int *, child_tidptr);
- PRE_MEM_WRITE("clone(child_tidptr)", ARG4, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG4, sizeof(Int),
- VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
-
- /* The kernel simply copies reg6 (ARG5) into AR0 and AR1, no checks */
- if (ARG2 & VKI_CLONE_SETTLS) {
- if (VG_(tdict).track_pre_reg_read) {
- PRA5("clone", Addr, tlsinfo);
- }
- }
-
- cloneflags = ARG2;
-
- if (!ML_(client_signal_OK)(ARG2 & VKI_CSIGNAL)) {
- SET_STATUS_Failure( VKI_EINVAL );
- return;
- }
-
- /* Only look at the flags we really care about */
- switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
- | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
- case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
- /* thread creation */
- SET_STATUS_from_SysRes(
- do_clone(tid,
- (Addr)ARG1, /* child SP */
- ARG2, /* flags */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG4, /* child_tidptr */
- (Addr)ARG5)); /* tlsaddr */
- break;
-
- case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
- /* FALLTHROUGH - assume vfork == fork */
- cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
-
- case 0: /* plain fork */
- SET_STATUS_from_SysRes(
- ML_(do_fork_clone)(tid,
- cloneflags, /* flags */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG4)); /* child_tidptr */
- break;
-
- default:
- /* should we just ENOSYS? */
- VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG2);
- VG_(message)(Vg_UserMsg, "\n");
- VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
- VG_(message)(Vg_UserMsg, " - via a threads library (NPTL)\n");
- VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n");
- VG_(unimplemented)
- ("Valgrind does not support general clone().");
- }
-
- if (SUCCESS) {
- if (ARG2 & VKI_CLONE_PARENT_SETTID)
- POST_MEM_WRITE(ARG3, sizeof(Int));
- if (ARG2 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
- POST_MEM_WRITE(ARG4, sizeof(Int));
-
- /* Thread creation was successful; let the child have the chance
- to run */
- *flags |= SfYieldAfter;
- }
-}
-
PRE(sys_sigreturn)
{
ThreadState* tst;
@@ -775,7 +554,7 @@ static SyscallTableEntry syscall_table[] = {
GENX_(__NR_fsync, sys_fsync), // 118
PLAX_(__NR_sigreturn, sys_sigreturn), // 119
- PLAX_(__NR_clone, sys_clone), // 120
+ LINX_(__NR_clone, sys_clone), // 120
// ?????(__NR_setdomainname, ), // 121
GENXY(__NR_uname, sys_newuname), // 122
GENX_(123, sys_ni_syscall), /* unimplemented (by the kernel) */ // 123
diff --git a/coregrind/m_syswrap/syswrap-tilegx-linux.c b/coregrind/m_syswrap/syswrap-tilegx-linux.c
index 7501b20..05d81e8 100644
--- a/coregrind/m_syswrap/syswrap-tilegx-linux.c
+++ b/coregrind/m_syswrap/syswrap-tilegx-linux.c
@@ -224,14 +224,7 @@ void ML_(call_on_new_stack_0_1) (Addr stack, Addr retaddr,
#define __NR_CLONE VG_STRINGIFY(__NR_clone)
#define __NR_EXIT VG_STRINGIFY(__NR_exit)
-Long do_syscall_clone_tilegx_linux ( Word (*fn) (void *), //r0
- void *stack, //r1
- Long flags, //r2
- void *arg, //r3
- Long * child_tid, //r4
- Long * parent_tid, //r5
- Long tls ); //r6
- /*
+ /*
stack
high -> 4 r29
3
@@ -239,6 +232,7 @@ Long do_syscall_clone_tilegx_linux ( Word (*fn) (void *), //r0
1 r10
low -> 0 lr <- sp
*/
+// See priv_syswrap-linux.h for arg profile.
asm (
".text\n"
" .globl do_syscall_clone_tilegx_linux\n"
@@ -315,101 +309,6 @@ Long do_syscall_clone_tilegx_linux ( Word (*fn) (void *), //r0
#undef __NR_EXIT
// forward declarations
-static void setup_child ( ThreadArchState *, ThreadArchState * );
-static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr );
- /*
- When a client clones, we need to keep track of the new thread. This means:
- 1. allocate a ThreadId+ThreadState+stack for the thread
- 2. initialize the thread's new VCPU state
- 3. create the thread using the same args as the client requested,
- but using the scheduler entrypoint for IP, and a separate stack
- for SP.
- */
-static SysRes do_clone ( ThreadId ptid,
- Long flags, Addr sp,
- Long * parent_tidptr,
- Long * child_tidptr,
- Addr child_tls )
-{
- const Bool debug = False;
- ThreadId ctid = VG_ (alloc_ThreadState) ();
- ThreadState * ptst = VG_ (get_ThreadState) (ptid);
- ThreadState * ctst = VG_ (get_ThreadState) (ctid);
- Long ret = 0;
- Long * stack;
- SysRes res;
- vki_sigset_t blockall, savedmask;
-
- VG_ (sigfillset) (&blockall);
- vg_assert (VG_ (is_running_thread) (ptid));
- vg_assert (VG_ (is_valid_tid) (ctid));
- stack = (Long *) ML_ (allocstack) (ctid);
- if (stack == NULL) {
- res = VG_ (mk_SysRes_Error) (VKI_ENOMEM);
- goto out;
- }
- setup_child (&ctst->arch, &ptst->arch);
-
- /* On TILEGX we need to set r0 and r3 to zero */
- ctst->arch.vex.guest_r0 = 0;
- ctst->arch.vex.guest_r3 = 0;
- if (sp != 0)
- ctst->arch.vex.guest_r54 = sp;
-
- ctst->os_state.parent = ptid;
- ctst->sig_mask = ptst->sig_mask;
- ctst->tmp_sig_mask = ptst->sig_mask;
-
- /* Start the child with its threadgroup being the same as the
- parent's. This is so that any exit_group calls that happen
- after the child is created but before it sets its
- os_state.threadgroup field for real (in thread_wrapper in
- syswrap-linux.c), really kill the new thread. a.k.a this avoids
- a race condition in which the thread is unkillable (via
- exit_group) because its threadgroup is not set. The race window
- is probably only a few hundred or a few thousand cycles long.
- See #226116. */
-
- ctst->os_state.threadgroup = ptst->os_state.threadgroup;
- ML_(guess_and_register_stack) (sp, ctst);
-
- VG_TRACK (pre_thread_ll_create, ptid, ctid);
- if (flags & VKI_CLONE_SETTLS) {
- if (debug)
- VG_(printf)("clone child has SETTLS: tls at %#lx\n", child_tls);
- ctst->arch.vex.guest_r53 = child_tls;
- res = sys_set_tls(ctid, child_tls);
- if (sr_isError(res))
- goto out;
- }
-
- flags &= ~VKI_CLONE_SETTLS;
- VG_ (sigprocmask) (VKI_SIG_SETMASK, &blockall, &savedmask);
- /* Create the new thread */
- ret = do_syscall_clone_tilegx_linux (ML_ (start_thread_NORETURN),
- stack, flags, &VG_ (threads)[ctid],
- child_tidptr, parent_tidptr,
- (Long)NULL /*child_tls*/);
-
- /* High half word64 is syscall return value. */
- if (debug)
- VG_(printf)("ret: 0x%llx\n", (ULong)ret);
-
- res = VG_(mk_SysRes_tilegx_linux) (/*val */ ret);
-
- VG_ (sigprocmask) (VKI_SIG_SETMASK, &savedmask, NULL);
-
- out:
- if (sr_isError (res)) {
- VG_(cleanup_thread) (&ctst->arch);
- ctst->status = VgTs_Empty;
- VG_TRACK (pre_thread_ll_exit, ctid);
- }
- ptst->arch.vex.guest_r0 = 0;
-
- return res;
-}
-
extern Addr do_brk ( Addr newbrk );
extern
@@ -428,23 +327,6 @@ extern Bool linux_kernel_2_6_22(void);
void
VG_ (cleanup_thread) ( ThreadArchState * arch ) { }
-void
-setup_child ( /*OUT*/ ThreadArchState * child,
- /*IN*/ ThreadArchState * parent )
-{
- /* We inherit our parent's guest state. */
- child->vex = parent->vex;
- child->vex_shadow1 = parent->vex_shadow1;
- child->vex_shadow2 = parent->vex_shadow2;
-}
-
-SysRes sys_set_tls ( ThreadId tid, Addr tlsptr )
-{
- VG_(threads)[tid].arch.vex.guest_r53 = tlsptr;
- return VG_(mk_SysRes_Success)( 0 );
-}
-
-
/* ---------------------------------------------------------------------
PRE/POST wrappers for tilegx/Linux-specific syscalls
------------------------------------------------------------------ */
@@ -457,7 +339,6 @@ SysRes sys_set_tls ( ThreadId tid, Addr tlsptr )
aren't visible outside this file, but that requires even more macro
magic. */
-DECL_TEMPLATE (tilegx_linux, sys_clone);
DECL_TEMPLATE (tilegx_linux, sys_rt_sigreturn);
DECL_TEMPLATE (tilegx_linux, sys_socket);
DECL_TEMPLATE (tilegx_linux, sys_setsockopt);
@@ -496,94 +377,6 @@ DECL_TEMPLATE (tilegx_linux, sys_syscall184);
DECL_TEMPLATE (tilegx_linux, sys_cacheflush);
DECL_TEMPLATE (tilegx_linux, sys_set_dataplane);
-PRE(sys_clone)
-{
- ULong cloneflags;
-
- PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
- PRE_REG_READ5(int, "clone",
- unsigned long, flags,
- void *, child_stack,
- int *, parent_tidptr,
- int *, child_tidptr,
- void *, tlsaddr);
-
- if (ARG1 & VKI_CLONE_PARENT_SETTID) {
- PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int), VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
- PRE_MEM_WRITE("clone(child_tidptr)", ARG4, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG4, sizeof(Int), VKI_PROT_WRITE)) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
- }
-
- cloneflags = ARG1;
-
- if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
- SET_STATUS_Failure( VKI_EINVAL );
- return;
- }
-
- /* Only look at the flags we really care about */
- switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
- | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
- case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
- /* thread creation */
- SET_STATUS_from_SysRes(
- do_clone(tid,
- ARG1, /* flags */
- (Addr)ARG2, /* child ESP */
- (Long *)ARG3, /* parent_tidptr */
- (Long *)ARG4, /* child_tidptr */
- (Addr)ARG5)); /* set_tls */
- break;
-
- case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
- /* FALLTHROUGH - assume vfork == fork */
- cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
-
- case 0: /* plain fork */
- SET_STATUS_from_SysRes(
- ML_(do_fork_clone)(tid,
- cloneflags, /* flags */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG4)); /* child_tidptr */
- break;
-
- default:
- /* should we just ENOSYS? */
- VG_(message)(Vg_UserMsg,
- "Unsupported clone() flags: 0x%lx\n", ARG1);
- VG_(message)(Vg_UserMsg,
- "\n");
- VG_(message)(Vg_UserMsg,
- "The only supported clone() uses are:\n");
- VG_(message)(Vg_UserMsg,
- " - via a threads library (LinuxThreads or NPTL)\n");
- VG_(message)(Vg_UserMsg,
- " - via the implementation of fork or vfork\n");
- VG_(unimplemented)
- ("Valgrind does not support general clone().");
- }
-
- if (SUCCESS) {
- if (ARG1 & VKI_CLONE_PARENT_SETTID)
- POST_MEM_WRITE(ARG3, sizeof(Int));
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
- POST_MEM_WRITE(ARG4, sizeof(Int));
-
- /* Thread creation was successful; let the child have the chance
- to run */
- *flags |= SfYieldAfter;
- }
-}
-
PRE(sys_rt_sigreturn)
{
/* This isn't really a syscall at all - it's a misuse of the
@@ -1344,7 +1137,7 @@ static SyscallTableEntry syscall_table[] = {
LINX_(__NR_add_key, sys_add_key), // 217
LINX_(__NR_request_key, sys_request_key), // 218
LINXY(__NR_keyctl, sys_keyctl), // 219
- PLAX_(__NR_clone, sys_clone), // 220
+ LINX_(__NR_clone, sys_clone), // 220
GENX_(__NR_execve, sys_execve), // 221
PLAX_(__NR_mmap, sys_mmap), // 222
GENXY(__NR_mprotect, sys_mprotect), // 226
diff --git a/coregrind/m_syswrap/syswrap-x86-linux.c b/coregrind/m_syswrap/syswrap-x86-linux.c
index 0e5af98..f8c4eb4 100644
--- a/coregrind/m_syswrap/syswrap-x86-linux.c
+++ b/coregrind/m_syswrap/syswrap-x86-linux.c
@@ -131,14 +131,7 @@ asm(
#define __NR_CLONE VG_STRINGIFY(__NR_clone)
#define __NR_EXIT VG_STRINGIFY(__NR_exit)
-extern
-Int do_syscall_clone_x86_linux ( Word (*fn)(void *),
- void* stack,
- Int flags,
- void* arg,
- Int* child_tid,
- Int* parent_tid,
- vki_modify_ldt_t * );
+// See priv_syswrap-linux.h for arg profile.
asm(
".text\n"
".globl do_syscall_clone_x86_linux\n"
@@ -191,141 +184,6 @@ asm(
#undef __NR_EXIT
-// forward declarations
-static void setup_child ( ThreadArchState*, ThreadArchState*, Bool );
-static SysRes sys_set_thread_area ( ThreadId, vki_modify_ldt_t* );
-
-/*
- When a client clones, we need to keep track of the new thread. This means:
- 1. allocate a ThreadId+ThreadState+stack for the thread
-
- 2. initialize the thread's new VCPU state
-
- 3. create the thread using the same args as the client requested,
- but using the scheduler entrypoint for EIP, and a separate stack
- for ESP.
- */
-static SysRes do_clone ( ThreadId ptid,
- UInt flags, Addr esp,
- Int* parent_tidptr,
- Int* child_tidptr,
- vki_modify_ldt_t *tlsinfo)
-{
- static const Bool debug = False;
-
- ThreadId ctid = VG_(alloc_ThreadState)();
- ThreadState* ptst = VG_(get_ThreadState)(ptid);
- ThreadState* ctst = VG_(get_ThreadState)(ctid);
- UWord* stack;
- SysRes res;
- Int eax;
- vki_sigset_t blockall, savedmask;
-
- VG_(sigfillset)(&blockall);
-
- vg_assert(VG_(is_running_thread)(ptid));
- vg_assert(VG_(is_valid_tid)(ctid));
-
- stack = (UWord*)ML_(allocstack)(ctid);
- if (stack == NULL) {
- res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
- goto out;
- }
-
- /* Copy register state
-
- Both parent and child return to the same place, and the code
- following the clone syscall works out which is which, so we
- don't need to worry about it.
-
- The parent gets the child's new tid returned from clone, but the
- child gets 0.
-
- If the clone call specifies a NULL esp for the new thread, then
- it actually gets a copy of the parent's esp.
- */
- /* Note: the clone call done by the Quadrics Elan3 driver specifies
- clone flags of 0xF00, and it seems to rely on the assumption
- that the child inherits a copy of the parent's GDT.
- setup_child takes care of setting that up. */
- setup_child( &ctst->arch, &ptst->arch, True );
-
- /* Make sys_clone appear to have returned Success(0) in the
- child. */
- ctst->arch.vex.guest_EAX = 0;
-
- if (esp != 0)
- ctst->arch.vex.guest_ESP = esp;
-
- ctst->os_state.parent = ptid;
-
- /* inherit signal mask */
- ctst->sig_mask = ptst->sig_mask;
- ctst->tmp_sig_mask = ptst->sig_mask;
-
- /* Start the child with its threadgroup being the same as the
- parent's. This is so that any exit_group calls that happen
- after the child is created but before it sets its
- os_state.threadgroup field for real (in thread_wrapper in
- syswrap-linux.c), really kill the new thread. a.k.a this avoids
- a race condition in which the thread is unkillable (via
- exit_group) because its threadgroup is not set. The race window
- is probably only a few hundred or a few thousand cycles long.
- See #226116. */
- ctst->os_state.threadgroup = ptst->os_state.threadgroup;
-
- ML_(guess_and_register_stack) (esp, ctst);
-
- /* Assume the clone will succeed, and tell any tool that wants to
- know that this thread has come into existence. We cannot defer
- it beyond this point because sys_set_thread_area, just below,
- causes tCheck to assert by making references to the new ThreadId
- if we don't state the new thread exists prior to that point.
- If the clone fails, we'll send out a ll_exit notification for it
- at the out: label below, to clean up. */
- vg_assert(VG_(owns_BigLock_LL)(ptid));
- VG_TRACK ( pre_thread_ll_create, ptid, ctid );
-
- if (flags & VKI_CLONE_SETTLS) {
- if (debug)
- VG_(printf)("clone child has SETTLS: tls info at %p: idx=%u "
- "base=%#lx limit=%x; esp=%#x fs=%x gs=%x\n",
- tlsinfo, tlsinfo->entry_number,
- tlsinfo->base_addr, tlsinfo->limit,
- ptst->arch.vex.guest_ESP,
- ctst->arch.vex.guest_FS, ctst->arch.vex.guest_GS);
- res = sys_set_thread_area(ctid, tlsinfo);
- if (sr_isError(res))
- goto out;
- }
-
- flags &= ~VKI_CLONE_SETTLS;
-
- /* start the thread with everything blocked */
- VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
-
- /* Create the new thread */
- eax = do_syscall_clone_x86_linux(
- ML_(start_thread_NORETURN), stack, flags, &VG_(threads)[ctid],
- child_tidptr, parent_tidptr, NULL
- );
- res = VG_(mk_SysRes_x86_linux)( eax );
-
- VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
-
- out:
- if (sr_isError(res)) {
- /* clone failed */
- VG_(cleanup_thread)(&ctst->arch);
- ctst->status = VgTs_Empty;
- /* oops. Better tell the tool the thread exited in a hurry :-) */
- VG_TRACK( pre_thread_ll_exit, ctid );
- }
-
- return res;
-}
-
-
/* ---------------------------------------------------------------------
LDT/GDT simulation
------------------------------------------------------------------ */
@@ -630,7 +488,7 @@ static SysRes sys_modify_ldt ( ThreadId tid,
}
-static SysRes sys_set_thread_area ( ThreadId tid, vki_modify_ldt_t* info )
+SysRes ML_(x86_sys_set_thread_area) ( ThreadId tid, vki_modify_ldt_t* info )
{
Int idx;
VexGuestX86SegDescr* gdt;
@@ -738,15 +596,9 @@ void VG_(cleanup_thread) ( ThreadArchState* arch )
}
-static void setup_child ( /*OUT*/ ThreadArchState *child,
- /*IN*/ ThreadArchState *parent,
- Bool inherit_parents_GDT )
+void ML_(x86_setup_LDT_GDT) ( /*OUT*/ ThreadArchState *child,
+ /*IN*/ ThreadArchState *parent )
{
- /* We inherit our parent's guest state. */
- child->vex = parent->vex;
- child->vex_shadow1 = parent->vex_shadow1;
- child->vex_shadow2 = parent->vex_shadow2;
-
/* We inherit our parent's LDT. */
if (parent->vex.guest_LDT == (HWord)NULL) {
/* We hope this is the common case. */
@@ -763,7 +615,7 @@ static void setup_child ( /*OUT*/ ThreadArchState *child,
only). */
child->vex.guest_GDT = (HWord)NULL;
- if (inherit_parents_GDT && parent->vex.guest_GDT != (HWord)NULL) {
+ if (parent->vex.guest_GDT != (HWord)NULL) {
child->vex.guest_GDT = (HWord)alloc_zeroed_x86_GDT();
copy_GDT_from_to( (VexGuestX86SegDescr*)parent->vex.guest_GDT,
(VexGuestX86SegDescr*)child->vex.guest_GDT );
@@ -787,7 +639,6 @@ DECL_TEMPLATE(x86_linux, sys_stat64);
DECL_TEMPLATE(x86_linux, sys_fstatat64);
DECL_TEMPLATE(x86_linux, sys_fstat64);
DECL_TEMPLATE(x86_linux, sys_lstat64);
-DECL_TEMPLATE(x86_linux, sys_clone);
DECL_TEMPLATE(x86_linux, old_mmap);
DECL_TEMPLATE(x86_linux, sys_mmap2);
DECL_TEMPLATE(x86_linux, sys_sigreturn);
@@ -835,137 +686,6 @@ PRE(old_select)
}
}
-PRE(sys_clone)
-{
- UInt cloneflags;
- Bool badarg = False;
-
- PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
- PRE_REG_READ2(int, "clone",
- unsigned long, flags,
- void *, child_stack);
-
- if (ARG1 & VKI_CLONE_PARENT_SETTID) {
- if (VG_(tdict).track_pre_reg_read) {
- PRA3("clone", int *, parent_tidptr);
- }
- PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int),
- VKI_PROT_WRITE)) {
- badarg = True;
- }
- }
- if (ARG1 & VKI_CLONE_SETTLS) {
- if (VG_(tdict).track_pre_reg_read) {
- PRA4("clone", vki_modify_ldt_t *, tlsinfo);
- }
- PRE_MEM_READ("clone(tlsinfo)", ARG4, sizeof(vki_modify_ldt_t));
- if (!VG_(am_is_valid_for_client)(ARG4, sizeof(vki_modify_ldt_t),
- VKI_PROT_READ)) {
- badarg = True;
- }
- }
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
- if (VG_(tdict).track_pre_reg_read) {
- PRA5("clone", int *, child_tidptr);
- }
- PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof(Int));
- if (!VG_(am_is_valid_for_client)(ARG5, sizeof(Int),
- VKI_PROT_WRITE)) {
- badarg = True;
- }
- }
-
- if (badarg) {
- SET_STATUS_Failure( VKI_EFAULT );
- return;
- }
-
- cloneflags = ARG1;
-
- if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
- SET_STATUS_Failure( VKI_EINVAL );
- return;
- }
-
- /* Be ultra-paranoid and filter out any clone-variants we don't understand:
- - ??? specifies clone flags of 0x100011
- - ??? specifies clone flags of 0x1200011.
- - NPTL specifies clone flags of 0x7D0F00.
- - The Quadrics Elan3 driver specifies clone flags of 0xF00.
- - Newer Quadrics Elan3 drivers with NTPL support specify 0x410F00.
- Everything else is rejected.
- */
- if (
- 1 ||
- /* 11 Nov 05: for the time being, disable this ultra-paranoia.
- The switch below probably does a good enough job. */
- (cloneflags == 0x100011 || cloneflags == 0x1200011
- || cloneflags == 0x7D0F00
- || cloneflags == 0x790F00
- || cloneflags == 0x3D0F00
- || cloneflags == 0x410F00
- || cloneflags == 0xF00
- || cloneflags == 0xF21)) {
- /* OK */
- }
- else {
- /* Nah. We don't like it. Go away. */
- goto reject;
- }
-
- /* Only look at the flags we really care about */
- switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
- | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
- case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
- /* thread creation */
- SET_STATUS_from_SysRes(
- do_clone(tid,
- ARG1, /* flags */
- (Addr)ARG2, /* child ESP */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG5, /* child_tidptr */
- (vki_modify_ldt_t *)ARG4)); /* set_tls */
- break;
-
- case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
- /* FALLTHROUGH - assume vfork == fork */
- cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
-
- case 0: /* plain fork */
- SET_STATUS_from_SysRes(
- ML_(do_fork_clone)(tid,
- cloneflags, /* flags */
- (Int *)ARG3, /* parent_tidptr */
- (Int *)ARG5)); /* child_tidptr */
- break;
-
- default:
- reject:
- /* should we just ENOSYS? */
- VG_(message)(Vg_UserMsg, "\n");
- VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1);
- VG_(message)(Vg_UserMsg, "\n");
- VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
- VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)\n");
- VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n");
- VG_(message)(Vg_UserMsg, " - for the Quadrics Elan3 user-space driver\n");
- VG_(unimplemented)
- ("Valgrind does not support general clone().");
- }
-
- if (SUCCESS) {
- if (ARG1 & VKI_CLONE_PARENT_SETTID)
- POST_MEM_WRITE(ARG3, sizeof(Int));
- if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
- POST_MEM_WRITE(ARG5, sizeof(Int));
-
- /* Thread creation was successful; let the child have the chance
- to run */
- *flags |= SfYieldAfter;
- }
-}
-
PRE(sys_sigreturn)
{
/* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
@@ -1063,7 +783,7 @@ PRE(sys_set_thread_area)
PRE_MEM_READ( "set_thread_area(u_info)", ARG1, sizeof(vki_modify_ldt_t) );
/* "do" the syscall ourselves; the kernel never sees it */
- SET_STATUS_from_SysRes( sys_set_thread_area( tid, (void *)ARG1 ) );
+ SET_STATUS_from_SysRes( ML_(x86_sys_set_thread_area)( tid, (void *)ARG1 ) );
}
PRE(sys_get_thread_area)
@@ -1553,7 +1273,7 @@ static SyscallTableEntry syscall_table[] = {
GENX_(__NR_fsync, sys_fsync), // 118
PLAX_(__NR_sigreturn, sys_sigreturn), // 119 ?/Linux
- PLAX_(__NR_clone, sys_clone), // 120
+ LINX_(__NR_clone, sys_clone), // 120
//zz // (__NR_setdomainname, sys_setdomainname), // 121 */*(?)
GENXY(__NR_uname, sys_newuname), // 122
PLAX_(__NR_modify_ldt, sys_modify_ldt), // 123
diff --git a/include/vki/vki-arm64-linux.h b/include/vki/vki-arm64-linux.h
index df34dd6..5a3b08f 100644
--- a/include/vki/vki-arm64-linux.h
+++ b/include/vki/vki-arm64-linux.h
@@ -586,7 +586,8 @@ struct vki_ucontext {
//ZZ };
//ZZ
//ZZ // [[Nb: for our convenience within Valgrind, use a more specific name]]
-//ZZ typedef struct vki_user_desc vki_modify_ldt_t;
+
+typedef char vki_modify_ldt_t;
//----------------------------------------------------------------------
// From linux-3.10.5/include/asm-generic/ipcbuf.h
diff --git a/include/vki/vki-mips32-linux.h b/include/vki/vki-mips32-linux.h
index 5be8e15..b6c9914 100644
--- a/include/vki/vki-mips32-linux.h
+++ b/include/vki/vki-mips32-linux.h
@@ -679,7 +679,7 @@ struct vki_ucontext {
};
// CAB: TODO
-typedef void vki_modify_ldt_t;
+typedef char vki_modify_ldt_t;
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/ipcbuf.h
diff --git a/include/vki/vki-mips64-linux.h b/include/vki/vki-mips64-linux.h
index 26b8e9f..ca49b10 100644
--- a/include/vki/vki-mips64-linux.h
+++ b/include/vki/vki-mips64-linux.h
@@ -710,6 +710,7 @@ struct vki_ucontext {
vki_sigset_t uc_sigmask; /* mask last for extensibility */
};
+typedef char vki_modify_ldt_t;
//----------------------------------------------------------------------
// From linux-2.6.35.9/include/asm-mips/ipcbuf.h
//----------------------------------------------------------------------
diff --git a/include/vki/vki-ppc32-linux.h b/include/vki/vki-ppc32-linux.h
index 70c2835..0fd3c79 100644
--- a/include/vki/vki-ppc32-linux.h
+++ b/include/vki/vki-ppc32-linux.h
@@ -811,10 +811,9 @@ struct vki_ucontext {
//.. };
//..
//.. // [[Nb: for our convenience within Valgrind, use a more specific name]]
-//.. typedef struct vki_user_desc vki_modify_ldt_t;
// CAB: TODO
-typedef void vki_modify_ldt_t;
+typedef char vki_modify_ldt_t;
//----------------------------------------------------------------------
diff --git a/include/vki/vki-ppc64-linux.h b/include/vki/vki-ppc64-linux.h
index b410663..fd5cea6 100644
--- a/include/vki/vki-ppc64-linux.h
+++ b/include/vki/vki-ppc64-linux.h
@@ -685,6 +685,9 @@ struct vki_ucontext {
struct vki_sigcontext uc_mcontext; /* last for extensibility */
};
+// CAB: TODO
+typedef char vki_modify_ldt_t;
+
//----------------------------------------------------------------------
// From linux-2.6.13/include/asm-ppc64/ipcbuf.h
//----------------------------------------------------------------------
diff --git a/include/vki/vki-s390x-linux.h b/include/vki/vki-s390x-linux.h
index c3f6d00..1ef5cf7 100644
--- a/include/vki/vki-s390x-linux.h
+++ b/include/vki/vki-s390x-linux.h
@@ -822,6 +822,8 @@ struct vki_ucontext {
vki_sigset_t uc_sigmask; /* mask last for extensibility */
};
+typedef char vki_modify_ldt_t;
+
//----------------------------------------------------------------------
// From linux-2.6.16.60/include/asm-s390/ipcbuf.h
//----------------------------------------------------------------------
Reference in New Issue View Git Blame Copy Permalink