Debug stub: suspend/resume threads on Linux

src/trusted/debug_stub/posix/thread_impl.cc

 /*
  * 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.
  */
 
 #include <stdexcept>
 #include <string.h>
 
 #include "native_client/src/shared/platform/nacl_log.h"
 #include "native_client/src/trusted/gdb_rsp/abi.h"
 #include "native_client/src/trusted/port/mutex.h"
 #include "native_client/src/trusted/port/platform.h"
 #include "native_client/src/trusted/port/thread.h"
+#include "native_client/src/trusted/service_runtime/nacl_app_thread.h"  // only for NaClAppThread->nap
 #include "native_client/src/trusted/service_runtime/nacl_signal.h"
+#include "native_client/src/trusted/service_runtime/sel_ldr.h"
 
 /*
  * Define the OS specific portions of IThread interface.
  */
 
 namespace {
 
 const int kX86TrapFlag = 1 << 8;
 
 }  // namespace
 
 namespace port {
 
 static IThread::CatchFunc_t s_CatchFunc = NULL;
 static void* s_CatchCookie = NULL;
 
 static IMutex* ThreadGetLock() {
   static IMutex* mutex_ = IMutex::Allocate();
   return mutex_;
 }
 
 static IThread::ThreadMap_t *ThreadGetMap() {
   static IThread::ThreadMap_t* map_ = new IThread::ThreadMap_t;
   return map_;
 }
 
+volatile int signaled_ = 0;
+
 class Thread : public IThread {
  public:
   Thread(uint32_t id, struct NaClAppThread *natp)
       : ref_(1), id_(id), natp_(natp), state_(DEAD) {}
   ~Thread() {}
 
   uint32_t GetId() {
     return id_;
   }
 
@@ skipping 44 matching lines @@
     return false;
   }
 
   // This is not used and could be removed.
   virtual void* GetContext() { return NULL; }
 
   static enum NaClSignalResult SignalHandler(int signal, void *ucontext) {
     struct NaClSignalContext context;
     NaClSignalContextFromHandler(&context, ucontext);
     if (NaClSignalContextIsUntrusted(&context)) {
+      while (__sync_lock_test_and_set(&signaled_, 1)) {
+        usleep(100);
+      }
       uint32_t thread_id = IPlatform::GetCurrentThread();
       Thread* thread = static_cast<Thread*>(Acquire(thread_id));
       State old_state = thread->state_;
       thread->state_ = SIGNALED;
       thread->context_ = context;
 
       if (s_CatchFunc != NULL)
         s_CatchFunc(thread_id, signal, s_CatchCookie);
 
       NaClSignalContextToHandler(ucontext, &thread->context_);
       thread->state_ = old_state;
       Release(thread);
+      __sync_lock_release(&signaled_);
       return NACL_SIGNAL_RETURN;
     } else {
       // Do not attempt to debug crashes in trusted code.
       return NACL_SIGNAL_SEARCH;
     }
   }
 
  private:
   uint32_t ref_;
   uint32_t id_;
@@ skipping 45 matching lines @@
     delete static_cast<IThread*>(thread);
   }
 }
 
 void IThread::SetExceptionCatch(IThread::CatchFunc_t func, void *cookie) {
   NaClSignalHandlerAdd(Thread::SignalHandler);
   s_CatchFunc = func;
   s_CatchCookie = cookie;
 }
 
+void IThread::SuspendAll(uint32_t signaled_id) {
+  if (signaled_id == 0) {
+    NaClLog(LOG_FATAL, "IThread::SuspendAll: not implemented\n");
+  } else {
+    Thread* thread = static_cast<Thread*>(Acquire(signaled_id));
+    NaClUntrustedThreadsSuspendAll2(thread->natp_->nap, thread->natp_);
+    Release(thread);
+  }
+}
 
-}  // End of port namespace
+void IThread::ResumeAll(uint32_t signaled_id) {
+  if (signaled_id == 0) {
+    NaClLog(LOG_FATAL, "IThread::ResumeAll: not implemented\n");
+  } else {
+    Thread* thread = static_cast<Thread*>(Acquire(signaled_id));
+    NaClUntrustedThreadsResumeAll2(thread->natp_->nap, thread->natp_);
+    Release(thread);
+  }
+}
 
+}  // namespace port