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;