Allow creating a NaClAppThread without creating a new host OS thread

src/trusted/service_runtime/nacl_app_thread.c

 /*
  * Copyright (c) 2012 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.
  */
 
 /*
  * NaCl Server Runtime user thread state.
  */
+
+#include <string.h>
+
 #include "native_client/src/shared/platform/aligned_malloc.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/shared/platform/nacl_exit.h"
 #include "native_client/src/shared/platform/nacl_sync_checked.h"
 
 #include "native_client/src/trusted/service_runtime/arch/sel_ldr_arch.h"
 #include "native_client/src/trusted/service_runtime/nacl_desc_effector_ldr.h"
 #include "native_client/src/trusted/service_runtime/nacl_globals.h"
 #include "native_client/src/trusted/service_runtime/nacl_tls.h"
 #include "native_client/src/trusted/service_runtime/nacl_switch_to_app.h"
 #include "native_client/src/trusted/service_runtime/nacl_stack_safety.h"
 #include "native_client/src/trusted/service_runtime/nacl_syscall_common.h"
 
 
-void WINAPI NaClThreadLauncher(void *state) {
+void WINAPI NaClAppThreadLauncher(void *state) {
   struct NaClAppThread *natp = (struct NaClAppThread *) state;
   uint32_t thread_idx;
-  NaClLog(4, "NaClThreadLauncher: entered\n");
+  NaClLog(4, "NaClAppThreadLauncher: entered\n");
 
   NaClSignalStackRegister(natp->signal_stack);
 
   NaClLog(4, "      natp = 0x%016"NACL_PRIxPTR"\n", (uintptr_t) natp);
   NaClLog(4, " prog_ctr  = 0x%016"NACL_PRIxNACL_REG"\n", natp->user.prog_ctr);
   NaClLog(4, "stack_ptr  = 0x%016"NACL_PRIxPTR"\n",
           NaClGetThreadCtxSp(&natp->user));
 
   thread_idx = NaClGetThreadIdx(natp);
   CHECK(0 < thread_idx);
@@ skipping 96 matching lines @@
   /* NOTREACHED */
 }
 
 
 struct NaClAppThread *NaClAppThreadMake(struct NaClApp *nap,
                                         uintptr_t      usr_entry,
                                         uintptr_t      usr_stack_ptr,
                                         uint32_t       user_tls1,
                                         uint32_t       user_tls2) {
   struct NaClAppThread *natp;
-  int rv;
   uint32_t tls_idx;
 
   natp = NaClAlignedMalloc(sizeof *natp, __alignof(struct NaClAppThread));
   if (natp == NULL) {
     return NULL;
   }
 
   NaClLog(4, "         natp = 0x%016"NACL_PRIxPTR"\n", (uintptr_t) natp);
   NaClLog(4, "          nap = 0x%016"NACL_PRIxPTR"\n", (uintptr_t) nap);
   NaClLog(4, "usr_stack_ptr = 0x%016"NACL_PRIxPTR"\n", usr_stack_ptr);
 
   /*
    * Set these early, in case NaClTlsAllocate() wants to examine them.
    */
   natp->nap = nap;
   natp->thread_num = -1;  /* illegal index */
+  natp->host_thread_is_defined = 0;
+  memset(&natp->host_thread, 0, sizeof(natp->host_thread));
 
   /*
    * Even though we don't know what segment base/range should gs/r9/nacl_tls_idx
    * select, we still need one, since it identifies the thread when we context
    * switch back.  This use of a dummy tls is only needed for the main thread,
    * which is expected to invoke the tls_init syscall from its crt code (before
    * main or much of libc can run).  Other threads are spawned with the thread
    * pointer address as a parameter.
    */
   tls_idx = NaClTlsAllocate(natp);
@@ skipping 20 matching lines @@
   }
 
   if (!NaClMutexCtor(&natp->suspend_mu)) {
     goto cleanup_mu;
   }
   natp->suspend_state = NACL_APP_THREAD_TRUSTED;
   natp->suspended_registers = NULL;
   natp->fault_signal = 0;
 
   natp->dynamic_delete_generation = 0;
+  return natp;
 
-  rv = NaClThreadCtor(&natp->thread,
-                      NaClThreadLauncher,
-                      (void *) natp,
-                      NACL_KERN_STACK_SIZE);
-  if (rv != 0) {
-    return natp; /* Success */
-  }
-
-  NaClMutexDtor(&natp->suspend_mu);
  cleanup_mu:
   NaClMutexDtor(&natp->mu);
   if (NULL != natp->signal_stack) {
     NaClSignalStackFree(&natp->signal_stack);
     natp->signal_stack = NULL;
   }
  cleanup_free:
   NaClAlignedFree(natp);
   return NULL;
 }
 
 
+int NaClAppThreadSpawn(struct NaClApp *nap,
+                       uintptr_t      usr_entry,
+                       uintptr_t      usr_stack_ptr,
+                       uint32_t       user_tls1,
+                       uint32_t       user_tls2) {
+  struct NaClAppThread *natp = NaClAppThreadMake(nap, usr_entry, usr_stack_ptr,
+                                                 user_tls1, user_tls2);
+  if (natp == NULL) {
+    return 0;
+  }
+  /*
+   * We set host_thread_is_defined assuming, for now, that
+   * NaClThreadCtor() will succeed.
+   */
+  natp->host_thread_is_defined = 1;
+  if (!NaClThreadCtor(&natp->host_thread, NaClAppThreadLauncher, (void *) natp,
+                      NACL_KERN_STACK_SIZE)) {
+    /*
+     * No other thread saw the NaClAppThread, so it is OK that
+     * host_thread was not initialized despite host_thread_is_defined
+     * being set.
+     */
+    natp->host_thread_is_defined = 0;
+    NaClAppThreadDelete(natp);
+    return 0;
+  }
+  return 1;
+}
+
+
 void NaClAppThreadDelete(struct NaClAppThread *natp) {
   /*
    * the thread must not be still running, else this crashes the system
    */
 
+  if (natp->host_thread_is_defined) {
+    NaClThreadDtor(&natp->host_thread);
+  }
   free(natp->suspended_registers);
   NaClMutexDtor(&natp->suspend_mu);
-  NaClThreadDtor(&natp->thread);
   NaClSignalStackFree(natp->signal_stack);
   natp->signal_stack = NULL;
   NaClTlsFree(natp);
   NaClMutexDtor(&natp->mu);
   NaClAlignedFree(natp);
 }