Non-SFI mode: Add Linux asynchronous signal support

src/nonsfi/linux/linux_sys_private.c

 /*
  * Copyright (c) 2014 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.
  */
 
 /*
  * This file defines various POSIX-like functions directly using Linux
  * syscalls.  This is analogous to src/untrusted/nacl/sys_private.c, which
  * defines functions using NaCl syscalls directly.
@@ skipping 617 matching lines @@
 
 int linux_sigprocmask(int how,
                       const linux_sigset_t *set,
                       linux_sigset_t *oset) {
   return errno_value_call(
       linux_syscall4(__NR_rt_sigprocmask, how,
                      (uintptr_t) set, (uintptr_t) oset,
                      sizeof(*set)));
 }
 
+int linux_tgkill(int tgid, int tid, int sig) {
+  return errno_value_call(
+      linux_syscall3(__NR_tgkill, tgid, tid, sig));
+}
+
 /*
  * Obtain Linux signal number from portable signal number.
  */
 static int nacl_signum_to_linux_signum(int signum) {
   /* SIGSTKFLT is not defined in newlib, hence no mapping. */
 #define HANDLE_SIGNUM(SIGNUM) case SIGNUM: return LINUX_##SIGNUM;
   switch(signum) {
     HANDLE_SIGNUM(SIGHUP);
     HANDLE_SIGNUM(SIGINT);
     HANDLE_SIGNUM(SIGQUIT);
@@ skipping 115 matching lines @@
   /*
    * This function is called only from clone() below or
    * nacl_irt_thread_create() defined in linux_pthread_private.c.
    * In both cases, |child_stack| will never be NULL, although it is allowed
    * for direct clone() syscall. So, we skip that case's implementation for
    * simplicity here.
    *
    * Here we reserve 6 * 4 bytes for three purposes described below:
    * 1) At the beginning of the child process, we call fn(arg). To pass
    *    the function pointer and arguments, we use |stack| for |arg|,
-   *    |stack - 4| for |fn|. Here, we need 4-byte extra memory on top of
-   *    stack for |arg|.
+   *    |stack + 4| for |fn|.
    * 2) Our syscall() implementation reads six 4-byte arguments regardless
    *    of its actual arguments.
    * 3) Similar to 2), our clone() implementation reads three 4-byte arguments
    *    regardless of its actual arguments.
    * So, here we need max size of those three cases (= 6 * 4 bytes) on top of
    * the stack, with 16-byte alignment.
    */
   static const int kStackAlignmentMask = ~15;
   void *stack = (void *) (((uintptr_t) child_stack - sizeof(uintptr_t) * 6) &
                           kStackAlignmentMask);
   /* Put |fn| and |arg| on child process's stack. */
-  ((uintptr_t *) stack)[-1] = fn;
   ((uintptr_t *) stack)[0] = arg;
+  ((uintptr_t *) stack)[1] = fn;
 
 #if defined(__i386__)
   uint32_t result;
   __asm__ __volatile__("int $0x80\n"
                        /*
                         * If the return value of clone is non-zero, we are
                         * in the parent thread of clone.
                         */
                        "cmp $0, %%eax\n"
                        "jne 0f\n"
                        /*
                         * In child thread. Clear the frame pointer to
                         * prevent debuggers from unwinding beyond this.
                         */
                        "mov $0, %%ebp\n"
                        /*
                         * Call fn(arg). Note that |arg| is already ready on top
                         * of the stack, here.
                         */
-                       "call *-4(%%esp)\n"
+                       "call *4(%%esp)\n"
                        /* Then call _exit(2) with the return value. */
                        "mov %%eax, %%ebx\n"
                        "mov %[exit_sysno], %%eax\n"
                        "int $0x80\n"
                        /* _exit(2) will never return. */
                        "hlt\n"
                        "0:\n"
                        : "=a"(result)
                        : "a"(__NR_clone), "b"(flags), "c"(stack),
                          "d"(ptid), "S"(&desc), "D"(ctid),
@@ skipping 15 matching lines @@
                        "cmp r0, #0\n"
                        "bne 0f\n"
                        /*
                         * In child thread. Clear the frame pointer to
                         * prevent debuggers from unwinding beyond this,
                         * load start_func from the stack and call it.
                         */
                        "mov fp, #0\n"
                        /* Load |arg| to r0 register, then call |fn|. */
                        "ldr r0, [sp]\n"
-                       "ldr r1, [sp, #-4]\n"
+                       "ldr r1, [sp, #4]\n"
                        "blx r1\n"
                        /*
                         * Then, call _exit(2) with the returned value.
                         * r0 keeps the return value of |fn(arg)|.
                         */
                        "mov r7, %[exit_sysno]\n"
                        "svc #0\n"
                        /* _exit(2) will never return. */
                        "bkpt #0\n"
                        "0:\n"
@@ skipping 22 matching lines @@
   va_list ap;
   va_start(ap, arg);
   void *ptid = va_arg(ap, void *);
   void *tls = va_arg(ap, void *);
   void *ctid = va_arg(ap, void *);
   va_end(ap);
 
   return errno_value_call(linux_clone_wrapper(
       (uintptr_t) fn, (uintptr_t) arg, flags, child_stack, ptid, tls, ctid));
 }