Non-SFI mode: Add Linux asynchronous signal support

src/untrusted/irt/irt.h

 /*
  * 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.
  */
 #ifndef NATIVE_CLIENT_SRC_UNTRUSTED_IRT_IRT_H_
 #define NATIVE_CLIENT_SRC_UNTRUSTED_IRT_IRT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/types.h>
 #include <time.h>
 
 struct timeval;
 struct timespec;
 struct stat;
 struct dirent;
 
 struct NaClExceptionContext;
 struct NaClMemMappingInfo;
 
 typedef int64_t nacl_irt_off_t;
 typedef uint32_t nacl_irt_clockid_t;
+typedef uintptr_t nacl_irt_tid_t;
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
 /*
  * The only interface exposed directly to user code is a single function
  * of this type.  It is passed via the AT_SYSINFO field of the ELF
  * auxiliary vector on the stack at program startup.  The interfaces
  * below are accessed by calling this function with the appropriate
@@ skipping 199 matching lines @@
    * If |stack_flag| is non-NULL, thread_exit() will write 0 to
    * |*stack_flag|.  This is intended to be used by a threading
    * library to determine when the thread's stack can be deallocated
    * or reused.  The system will not read or write the thread's stack
    * after writing 0 to |*stack_flag|.
    */
   void (*thread_exit)(int32_t *stack_flag);
   int (*thread_nice)(const int nice);
 };
 
+#define NACL_IRT_THREAD_v0_2   "nacl-irt-thread-0.2"

[Mark Seaborn, 2015/06/26 18:32:00]

Please comment that this is implemented for Non-SFI NaCl only.

[Luis Héctor Chávez, 2015/07/06 23:45:00]

Done.

+struct nacl_irt_thread_v0_2 {
+  /*
+   * Now this interface returns the thread ID of the child thread as

[Mark Seaborn, 2015/06/26 18:31:59]

Nit: It assigns it to *child_tid rather than returning it.  Please document when
it does the assignment.

[Luis Héctor Chávez, 2015/07/06 23:45:00]

Done.

+   * |tid|. |tid| is valid until thread_exit is called.
+   */
+  int (*thread_create)(void (*start_func)(void), void *stack, void *thread_ptr,
+                       nacl_irt_tid_t *child_tid);
+  void (*thread_exit)(int32_t *stack_flag);
+  int (*thread_nice)(const int nice);
+};
+
 /*
  * The irt_futex interface is based on Linux's futex() system call.
  *
  * irt_futex provides process-private futexes, so futex wait queues are
  * associated with numeric virtual addresses only.  This is equivalent to
  * Linux's FUTEX_PRIVATE_FLAG.  If a page is mmap()'d twice, futex_wake()
  * on one mapping will *not* wake a thread that is waiting on the other
  * mapping with futex_wait_abs() -- futex wait queues are not associated
  * with pages' identities.
  */
@@ skipping 130 matching lines @@
 #define NACL_IRT_EXCEPTION_HANDLING_v0_1 \
   "nacl-irt-exception-handling-0.1"
 typedef void (*NaClExceptionHandler)(struct NaClExceptionContext *context);
 struct nacl_irt_exception_handling {
   int (*exception_handler)(NaClExceptionHandler handler,
                            NaClExceptionHandler *old_handler);
   int (*exception_stack)(void *stack, size_t size);
   int (*exception_clear_flag)(void);
 };
 
+#define NACL_IRT_SIGNAL_HANDLING_v0_1 "nacl-irt-signal-handling-0.1"

[Mark Seaborn, 2015/06/26 18:31:59]

Please comment that this is implemented for Non-SFI NaCl only (just as
nacl_irt_icache is).  For that reason, it should probably go at the end of the
file, next to nacl_irt_icache.

[Luis Héctor Chávez, 2015/07/06 23:45:00]

Done.

+typedef void (*NaClIrtSignalHandler)(struct NaClExceptionContext *context);
+struct nacl_irt_signal_handling {

[Mark Seaborn, 2015/06/26 18:31:59]

Let's add "async" into the name to make it clear that this is for async signals
only.

[Luis Héctor Chávez, 2015/07/06 23:45:00]

Done.

+  /*
+   * When send_async_signal is called, |handler| is invoked on the thread
+   * specified by |tid| on the thread's stack and without modifying the
+   * underlying signal mask, so |handler| must be reentrant.
+   *
+   * You can safely use only async-signal-safe operations in |handler|. The
+   * following NaCl IRT functions are async-signal-safe:
+   *
+   * - tls_get
+   * - futex_wait_abs
+   * - futex_wake
+   * - send_async_signal
+   *
+   * If the thread was executing an IRT function, the suspended thread will
+   * continue it after |handler| finishes.  In other words, no IRT function will
+   * be aborted.
+   */
+  int (*set_async_signal_handler)(NaClIrtSignalHandler handler);
+  /*
+   * |tid| should be zero or a value returned by thread_create.  If |tid| is
+   * zero, the signal will be sent to the main thread.
+   *
+   * When |tid| is invalid, the result is unspecified.  This IRT function
+   * returns 0 on success or may return ESRCH or EINVAL.
+   */
+  int (*send_async_signal)(nacl_irt_tid_t tid);
+};
+
 #define NACL_IRT_CODE_DATA_ALLOC_v0_1 "nacl-irt-code-data-alloc-0.1"
 struct nacl_irt_code_data_alloc {
   /*
    * Atomically allocate a code segment along with an associated data
    * segment with a specified offset. The caller can then call mmap or
    * dyncode_create for each of the segments starting with the value returned
    * by |*begin|.
    *
    * |hint| is a desired address where the code should begin. If |hint| is 0
    * this value is ignored and the next available combination of code and data
@@ skipping 31 matching lines @@
    * range from |addr| to |(intptr_t)addr + size| (exclusive) coherent.
    */
   int (*clear_cache)(void *addr, size_t size);
 };
 
 #if defined(__cplusplus)
 }
 #endif
 
 #endif /* NATIVE_CLIENT_SRC_UNTRUSTED_IRT_IRT_H */