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/logging.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;
 
+  DVLOG(4) << "Registering alternate signal stack: " << context->signal_stack;
+  NaClSignalStackRegister(context->signal_stack);

[Mark Seaborn, 2014/04/23 03:49:50]

This probably doesn't work: the seccomp sandbox will disallow sigaltstack().

Can you run the linux_rel_precise32 trybot, please?  That covers x86-32 Linux,
which is the only Chromium bot that runs Non-SFI NaCl tests currently.

I'd just omit the changes to this file for now.  We can fix the handling of
stack overflow crashes later.  NaClSignalStackAllocate() likely allocates a
stack that's too small for user code (because it wasn't intended for that
purpose).

[Junichi Uekawa, 2014/04/23 07:56:15]

I was wondering why my tests are succeeding and I guess of course I am not
testing thread creation path.

I'll revert changes to this file for now.

+
   // 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)) {
+    DVLOG(1) << "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