(void) INTERNAL_SYSCALL (tkill, err, 2, pd->tid, SIGCONT);
(void) INTERNAL_SYSCALL (tkill, err2, 2, pd->tid, SIGCONT); #endif
do_clone (struct pthread *pd, const struct pthread_attr *attr,	  int clone_flags, int (*fct) (void *), STACK_VARIABLES_PARMS){#ifdef PREPARE_CREATE  PREPARE_CREATE;#endif  if (ARCH_CLONE (fct, STACK_VARIABLES_ARGS, clone_flags,		  pd, &pd->tid, TLS_VALUE, &pd->tid) == -1)    /* Failed.  */    return errno;  /* Now we have the possibility to set scheduling parameters etc.  */  if (__builtin_expect ((clone_flags & CLONE_STOPPED) != 0, 0))    {      INTERNAL_SYSCALL_DECL (err);      int res = 0;      /* Set the affinity mask if necessary.  */      if (attr->cpuset != NULL)	{	  res = INTERNAL_SYSCALL (sched_setaffinity, err, 3, pd->tid,				  sizeof (cpu_set_t), attr->cpuset);	  if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (res, err), 0))	    goto err_out;	}      /* Set the scheduling parameters.  */      if ((attr->flags & ATTR_FLAG_NOTINHERITSCHED) != 0)	{	  res = INTERNAL_SYSCALL (sched_setscheduler, err, 3, pd->tid,				  pd->schedpolicy, &pd->schedparam);	  if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (res, err), 0))	    goto err_out;	}      /* Now start the thread for real.  */      res = INTERNAL_SYSCALL (tkill, err, 2, pd->tid, SIGCONT);      /* If something went wrong, kill the thread.  */      if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (res, err), 0))	{	  /* The operation failed.  We have to kill the thread.  First             send it the cancellation signal.  */	  INTERNAL_SYSCALL_DECL (err2);	err_out:	  (void) INTERNAL_SYSCALL (tkill, err2, 2, pd->tid, SIGCANCEL);	  /* Then wake it up so that the signal can be processed.  */	  (void) INTERNAL_SYSCALL (tkill, err, 2, pd->tid, SIGCONT);	  return INTERNAL_SYSCALL_ERRNO (res, err);	}    }  /* We now have for sure more than one thread.  The main thread might     not yet have the flag set.  No need to set the global variable     again if this is what we use.  */  THREAD_SETMEM (THREAD_SELF, header.multiple_threads, 1);  return 0;}