NonSFI NaCl: Plumb Exception IRT enough for breakpad.

components/nacl/loader/nonsfi/irt_thread.cc

 // Copyright 2014 The Chromium 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 <errno.h>
 #include <pthread.h>
 #include <stdlib.h>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/nacl/loader/nonsfi/irt_interfaces.h"
+#include "native_client/src/trusted/service_runtime/nacl_signal.h"
 
 namespace nacl {
 namespace nonsfi {
 namespace {
 
 // We heuristically chose 1M for the stack size per thread.
 const int kStackSize = 1024 * 1024;
 
 // For RAII of pthread_attr_t.
 class ScopedPthreadAttrPtr {
  public:
   ScopedPthreadAttrPtr(pthread_attr_t* attr) : attr_(attr) {
   }
   ~ScopedPthreadAttrPtr() {
     pthread_attr_destroy(attr_);
   }
 
  private:
   pthread_attr_t* attr_;
 };
 
 struct ThreadContext {
   void (*start_func)();
   void* thread_ptr;
+  void* signal_stack;
 };
 
 // A thread local pointer to support nacl_irt_tls.
 // This should be initialized at the beginning of ThreadMain, which is a thin
 // wrapper of a user function called on a newly created thread, and may be
 // reset via IrtTlsInit(). The pointer can be obtained via IrtTlsGet().
 __thread void* g_thread_ptr;
 
 void* ThreadMain(void *arg) {
   ::scoped_ptr<ThreadContext> context(static_cast<ThreadContext*>(arg));
   g_thread_ptr = context->thread_ptr;
 
+  // NaClLog(4, "Registering alternate signal stack: %p\n",
+  //         context->signal_stack);
+  NaClSignalStackRegister(context->signal_stack);
+
   // Release the memory of context before running start_func.
   void (*start_func)() = context->start_func;
   context.reset();
 
   start_func();
   abort();
 }
 
 int IrtThreadCreate(void (*start_func)(), void* stack, void* thread_ptr) {
   pthread_attr_t attr;
   int error = pthread_attr_init(&attr);
   if (error != 0)
     return error;
   ScopedPthreadAttrPtr scoped_attr_ptr(&attr);
 
   // Note: Currently we ignore the argument stack.
   error = pthread_attr_setstacksize(&attr, kStackSize);
   if (error != 0)
     return error;
 
   error = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
   if (error != 0)
     return error;
 
   ::scoped_ptr<ThreadContext> context(new ThreadContext);
   context->start_func = start_func;
   context->thread_ptr = thread_ptr;
+  if (!NaClSignalStackAllocate(&context->signal_stack)) {
+    // NaClLog(4, "Failed to allocate alternate stack\n");
+    return error;
+  }
 
   pthread_t tid;
   error = pthread_create(&tid, &attr, ThreadMain, context.get());
   if (error != 0)
     return error;
 
   // The ownership of the context is taken by the created thread. So, here we
   // just manually release it.
   ignore_result(context.release());
   return 0;
@@ skipping 32 matching lines @@
   IrtThreadNice,
 };
 
 const nacl_irt_tls kIrtTls = {
   IrtTlsInit,
   IrtTlsGet,
 };
 
 }  // namespace nonsfi
 }  // namespace nacl