Non-SFI mode: Add Linux asynchronous signal support

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 10 matching lines @@
 #if defined(__linux__)
 # include <linux/futex.h>
 # include <sys/syscall.h>
 #endif
 
 #include "native_client/src/include/elf32.h"
 #include "native_client/src/include/elf_auxv.h"
 #include "native_client/src/include/nacl/nacl_exception.h"
 #include "native_client/src/include/nacl_macros.h"
 #include "native_client/src/public/irt_core.h"
-#include "native_client/src/public/nonsfi/irt_exception_handling.h"
 #include "native_client/src/trusted/service_runtime/include/machine/_types.h"
 #include "native_client/src/trusted/service_runtime/include/sys/mman.h"
 #include "native_client/src/trusted/service_runtime/include/sys/stat.h"
 #include "native_client/src/trusted/service_runtime/include/sys/time.h"
 #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/irt_signal_handling.h"
 # 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
@@ skipping 302 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__)
+static int thread_create_nonsfi(void (*start_func)(void), void *stack,
+                                void *thread_ptr, nacl_irt_tid_t *child_tid) {
   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);
+  int error = nacl_user_thread_create(start_thread, stack, args, child_tid);
   if (error != 0)
     free(args);
   return error;
+}
+
+static void thread_exit_nonsfi(int32_t *stack_flag) {
+  nacl_user_thread_exit(stack_flag);
+}
+#endif
+
+static int thread_create(void (*start_func)(void), void *stack,
+                         void *thread_ptr) {
+#if defined(__native_client__)
+  /*
+   * When available, use the nonsfi version that does allow the |stack| to be
+   * set in the new thread.
+   */
+  return thread_create_nonsfi(start_func, stack, thread_ptr, NULL);
 #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);
@@ skipping 11 matching lines @@
   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);
+  /*
+   * Since we used the nonsfi version of thread_create, we must also call the
+   * nonsfi version of thread_exit to correctly clean it up.
+   */
+  thread_exit_nonsfi(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;
 }
 
@@ skipping 230 matching lines @@
   tls_init,
   tls_get,
 };
 
 const struct nacl_irt_thread nacl_irt_thread = {
   thread_create,
   thread_exit,
   thread_nice,
 };
 
+#if defined(__native_client__)
+const struct nacl_irt_thread_v0_2 nacl_irt_thread_v0_2 = {
+  thread_create_nonsfi,
+  thread_exit_nonsfi,
+  thread_nice,
+};
+#endif
+
 #if defined(__linux__)
 const struct nacl_irt_futex nacl_irt_futex = {
   futex_wait_abs,
   futex_wake,
 };
 #elif !defined(__native_client__)
 DEFINE_STUB(futex_wait_abs)
 DEFINE_STUB(futex_wake)
 const struct nacl_irt_futex nacl_irt_futex = {
   USE_STUB(nacl_irt_futex, futex_wait_abs),
@@ skipping 39 matching lines @@
  * The following condition is true when building for Non-SFI Mode,
  * when we're calling Linux syscalls directly.  (Counter-intuitively,
  * "__linux__" is not #defined in this case.)
  */
 #if defined(__native_client__)
 const struct nacl_irt_exception_handling nacl_irt_exception_handling = {
   nacl_exception_get_and_set_handler,
   nacl_exception_set_stack,
   nacl_exception_clear_flag,
 };
+
+const struct nacl_irt_async_signal_handling nacl_irt_async_signal_handling = {
+  nacl_async_signal_set_handler,
+  nacl_async_signal_send_async_signal,
+};
 #endif
 
 #if defined(__native_client__) && defined(__arm__)
 const struct nacl_irt_icache nacl_irt_icache = {
   irt_clear_cache,
 };
 #endif
 
 static int g_allow_dev_interfaces = 0;
 
 void nacl_irt_nonsfi_allow_dev_interfaces() {
   g_allow_dev_interfaces = 1;
 }
 
 static int irt_dev_filter(void) {
   return g_allow_dev_interfaces;
 }
 
 static const struct nacl_irt_interface irt_interfaces[] = {
   { NACL_IRT_BASIC_v0_1, &nacl_irt_basic, sizeof(nacl_irt_basic), NULL },
   { NACL_IRT_DEV_FDIO_v0_2, &nacl_irt_dev_fdio_v0_2,
     sizeof(nacl_irt_dev_fdio_v0_2), NULL },
   { NACL_IRT_FDIO_v0_1, &nacl_irt_fdio, sizeof(nacl_irt_fdio), NULL },
   { NACL_IRT_MEMORY_v0_3, &nacl_irt_memory, sizeof(nacl_irt_memory), NULL },
   { NACL_IRT_TLS_v0_1, &nacl_irt_tls, sizeof(nacl_irt_tls), NULL },
   { NACL_IRT_THREAD_v0_1, &nacl_irt_thread, sizeof(nacl_irt_thread), NULL },
+#if defined(__native_client__)
+  { NACL_IRT_THREAD_v0_2, &nacl_irt_thread_v0_2,
+    sizeof(nacl_irt_thread_v0_2), NULL },
+#endif
   { NACL_IRT_FUTEX_v0_1, &nacl_irt_futex, sizeof(nacl_irt_futex), NULL },
   { NACL_IRT_RANDOM_v0_1, &nacl_irt_random, sizeof(nacl_irt_random), NULL },
 #if defined(__linux__) || defined(__native_client__)
   { NACL_IRT_CLOCK_v0_1, &nacl_irt_clock, sizeof(nacl_irt_clock), NULL },
 #endif
   { NACL_IRT_DEV_FILENAME_v0_3, &nacl_irt_dev_filename,
     sizeof(nacl_irt_dev_filename), irt_dev_filter },
   { NACL_IRT_DEV_GETPID_v0_1, &nacl_irt_dev_getpid,
     sizeof(nacl_irt_dev_getpid), irt_dev_filter },
 #if defined(__native_client__)
   { NACL_IRT_EXCEPTION_HANDLING_v0_1, &nacl_irt_exception_handling,
     sizeof(nacl_irt_exception_handling), NULL },
+  { NACL_IRT_ASYNC_SIGNAL_HANDLING_v0_1, &nacl_irt_async_signal_handling,
+    sizeof(nacl_irt_async_signal_handling), NULL },
 #endif
 #if defined(__native_client__) && defined(__arm__)
   { NACL_IRT_ICACHE_v0_1, &nacl_irt_icache, sizeof(nacl_irt_icache), NULL },
 #endif
 };
 
 size_t nacl_irt_query_core(const char *interface_ident,
                            void *table, size_t tablesize) {
   return nacl_irt_query_list(interface_ident, table, tablesize,
                              irt_interfaces, sizeof(irt_interfaces));
@@ skipping 54 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