Allow creating a NaClAppThread without creating a new host OS thread

src/trusted/service_runtime/sel_ldr_standard.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 Simple/secure ELF loader (NaCl SEL).
  */
 
@@ skipping 649 matching lines @@
   }
   nap->exit_status = exit_status;
   nap->running = 0;
   NaClXCondVarSignal(&nap->cv);
 
   NaClXMutexUnlock(&nap->mu);
 
   return rv;
 }
 
+uintptr_t NaClGetInitialStackTop(struct NaClApp *nap) {
+  /*
+   * We keep the top of useful memory a page below the top of the
+   * sandbox region so that compilers can do tricks like computing a
+   * base register of sp + constant and then using a
+   * register-minus-constant addressing mode, which comes up at least
+   * on ARM where the compiler is trying to optimize given the limited
+   * size of immediate offsets available.  The maximum such negative
+   * constant on ARM will be -4095, but we use page size (64k) for
+   * good measure and do it on all machines just for uniformity.
+   */
+  return ((uintptr_t) 1U << nap->addr_bits) - NACL_MAP_PAGESIZE;
+}
+
 /*
  * preconditions:
  *  * argc is the length of the argv array
  *  * envv may be NULL (this happens on MacOS/Cocoa and in tests)
  *  * if envv is non-NULL it is 'consistent', null terminated etc.
  */
 int NaClCreateMainThread(struct NaClApp     *nap,
                          int                argc,
                          char               **argv,
                          char const *const  *envv) {
   /*
    * Compute size of string tables for argv and envv
    */
   int                   retval;
   int                   envc;
   size_t                size;
   int                   auxv_entries;
   size_t                ptr_tbl_size;
   int                   i;
   uint32_t              *p;
   char                  *strp;
   size_t                *argv_len;
   size_t                *envv_len;
-  struct NaClAppThread  *natp;
   uintptr_t             stack_ptr;
 
   retval = 0;  /* fail */
   CHECK(argc >= 0);
   CHECK(NULL != argv || 0 == argc);
 
   envc = 0;
   if (NULL != envv) {
     char const *const *pp;
     for (pp = envv; NULL != *pp; ++pp) {
@@ skipping 68 matching lines @@
   size += ptr_tbl_size;
 
   size = (size + NACL_STACK_ALIGN_MASK) & ~NACL_STACK_ALIGN_MASK;
 
   if (size > nap->stack_size) {
     retval = 0;
     goto cleanup;
   }
 
   /*
-   * Write strings and char * arrays to stack.  We keep the top of useful
-   * memory a page below the top of the sandbox region so that compilers
-   * can do tricks like computing a base register of sp + constant and then
-   * using a register-minus-constant addressing mode, which comes up at
-   * least on ARM where the compiler is trying to optimize given the
-   * limited size of immediate offsets available.  The maximum such
-   * negative constant on ARM will be -4095, but we use page size (64k)
-   * for good measure and do it on all machines just for uniformity.
+   * Write strings and char * arrays to stack.
    */
-  stack_ptr = (nap->mem_start +
-               ((uintptr_t) 1U << nap->addr_bits) - NACL_MAP_PAGESIZE -
-               size);
+  stack_ptr = NaClUserToSysAddrRange(nap, NaClGetInitialStackTop(nap) - size,
+                                     size);
+  if (stack_ptr == kNaClBadAddress) {
+    retval = 0;
+    goto cleanup;
+  }
 
   NaClLog(2, "setting stack to : %016"NACL_PRIxPTR"\n", stack_ptr);
 
   VCHECK(0 == (stack_ptr & NACL_STACK_ALIGN_MASK),
          ("stack_ptr not aligned: %016"NACL_PRIxPTR"\n", stack_ptr));
 
   p = (uint32_t *) stack_ptr;
   strp = (char *) stack_ptr + ptr_tbl_size;
 
   /*
@@ skipping 54 matching lines @@
   if (NACL_STACK_PAD_BELOW_ALIGN != 0) {
     stack_ptr -= NACL_STACK_PAD_BELOW_ALIGN;
     memset((void *) stack_ptr, 0, NACL_STACK_PAD_BELOW_ALIGN);
   }
 
   NaClLog(2, "system stack ptr : %016"NACL_PRIxPTR"\n", stack_ptr);
   NaClLog(2, "  user stack ptr : %016"NACL_PRIxPTR"\n",
           NaClSysToUserStackAddr(nap, stack_ptr));
 
   /* e_entry is user addr */
-  natp = NaClAppThreadMake(nap,
-                           nap->initial_entry_pt,
-                           NaClSysToUserStackAddr(nap, stack_ptr),
-                           /* user_tls1= */ (uint32_t) nap->break_addr,
-                           /* user_tls2= */ 0);
-  if (natp == NULL) {
-    retval = 0;
-    goto cleanup;
-  }
+  retval = NaClAppThreadSpawn(nap,
+                              nap->initial_entry_pt,
+                              NaClSysToUserStackAddr(nap, stack_ptr),
+                              /* user_tls1= */ (uint32_t) nap->break_addr,
+                              /* user_tls2= */ 0);
 
-  retval = 1;
 cleanup:
   free(argv_len);
   free(envv_len);
 
   return retval;
 }
 
 int NaClWaitForMainThreadToExit(struct NaClApp  *nap) {
   NaClLog(3, "NaClWaitForMainThreadToExit: taking NaClApp lock\n");
   NaClXMutexLock(&nap->mu);
@@ skipping 16 matching lines @@
 }
 
 /*
  * stack_ptr is from syscall, so a 32-bit address.
  */
 int32_t NaClCreateAdditionalThread(struct NaClApp *nap,
                                    uintptr_t      prog_ctr,
                                    uintptr_t      sys_stack_ptr,
                                    uint32_t       user_tls1,
                                    uint32_t       user_tls2) {
-  struct NaClAppThread  *natp;
-
-  natp = NaClAppThreadMake(nap,
-                           prog_ctr,
-                           NaClSysToUserStackAddr(nap, sys_stack_ptr),
-                           user_tls1,
-                           user_tls2);
-  if (natp == NULL) {
+  if (!NaClAppThreadSpawn(nap,
+                          prog_ctr,
+                          NaClSysToUserStackAddr(nap, sys_stack_ptr),
+                          user_tls1,
+                          user_tls2)) {
     NaClLog(LOG_WARNING,
             ("NaClCreateAdditionalThread: could not allocate thread."
              "  Returning EAGAIN per POSIX specs.\n"));
     return -NACL_ABI_EAGAIN;
   }
   return 0;
 }