Non-SFI mode: Use clone() instead of pthread_create()

src/nonsfi/irt/irt_interfaces.c

 /*
  * Copyright (c) 2013 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "native_client/src/nonsfi/irt/irt_interfaces.h"
 
 #include <assert.h>
 #include <errno.h>
@@ skipping 25 matching lines @@
 #include "native_client/src/trusted/service_runtime/include/sys/unistd.h"
 #include "native_client/src/untrusted/irt/irt.h"
 #include "native_client/src/untrusted/irt/irt_dev.h"
 #include "native_client/src/untrusted/irt/irt_interfaces.h"
 #include "native_client/src/untrusted/nacl/nacl_random.h"
 
 #if defined(__native_client__) && defined(__arm__)
 #include "native_client/src/nonsfi/irt/irt_icache.h"
 #endif
 
+#if defined(__native_client__)
+# include "native_client/src/nonsfi/linux/linux_pthread_private.h"
+#endif
+
 /*
  * This is an implementation of NaCl's IRT interfaces that runs
  * outside of the NaCl sandbox.
  *
  * This allows PNaCl to be used as a portability layer without the
  * SFI-based sandboxing.  PNaCl pexes can be translated to
  * non-SFI-sandboxed native code and linked against this IRT
  * implementation.
  */
 
@@ skipping 291 matching lines @@
 static void *start_thread(void *arg) {
   struct thread_args args = *(struct thread_args *) arg;
   free(arg);
   g_tls_value = args.thread_ptr;
   args.start_func();
   abort();
 }
 
 static int thread_create(void (*start_func)(void), void *stack,
                          void *thread_ptr) {
+#if defined(__native_client__)
+  struct thread_args *args = malloc(sizeof(struct thread_args));
+  if (args == NULL) {
+    return ENOMEM;
+  }
+  args->start_func = start_func;
+  args->thread_ptr = thread_ptr;
+  /* In Linux, it is possible to use the provided stack directly. */
+  int error = nacl_user_thread_create(start_thread, stack, args);
+  if (error != 0)
+    free(args);
+  return error;
+#else
   /*
    * For now, we ignore the stack that user code provides and just use
    * the stack that the host libpthread allocates.
    */
   pthread_attr_t attr;
   int error = pthread_attr_init(&attr);
   if (error != 0)
     return error;
   error = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
   if (error != 0)
     return error;
   struct thread_args *args = malloc(sizeof(struct thread_args));
   if (args == NULL) {
     error = ENOMEM;
     goto cleanup;
   }
   args->start_func = start_func;
   args->thread_ptr = thread_ptr;
   pthread_t tid;
   error = pthread_create(&tid, &attr, start_thread, args);
   if (error != 0)
     free(args);
  cleanup:
   pthread_attr_destroy(&attr);
   return error;
+#endif
 }
 
 static void thread_exit(int32_t *stack_flag) {
+#if defined(__native_client__)
+  nacl_user_thread_exit(stack_flag);
+#else
   *stack_flag = 0;  /* Indicate that the user code's stack can be freed. */
   pthread_exit(NULL);
+#endif
 }
 
 static int thread_nice(const int nice) {
   return 0;
 }
 
 /*
  * Mac OS X does not provide futexes or clock_gettime()/getres() natively.
  * TODO(mseaborn):  Make threads and clock_gettime() work on Mac OS X.
  */
@@ skipping 356 matching lines @@
   nacl_entry_func_t entry_func =
 #if defined(__APPLE__)
     _start;
 #else
     _user_start;
 #endif
 
   return nacl_irt_nonsfi_entry(argc, argv, environ, entry_func);
 }
 #endif