Debug stub: suspend/resume threads on Linux

src/trusted/gdb_rsp/target.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 <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 
@@ skipping 23 matching lines @@
 namespace gdb_rsp {
 
 
 Target::Target(const Abi* abi)
   : abi_(abi),
     mutex_(NULL),
     sig_start_(NULL),
     sig_done_(NULL),
     session_(NULL),
     ctx_(NULL),
+    stepping_over_breakpoint_(false),
     cur_signal_(-1),
     sig_thread_(0),
     run_thread_(-1),
     reg_thread_(-1),
     mem_base_(0) {
   if (NULL == abi_) abi_ = Abi::Get();
 }
 
 Target::~Target() {
   Destroy();
@@ skipping 121 matching lines @@
 
   return true;
 }
 
 
 
 void Target::Signal(uint32_t id, int8_t sig, bool wait) {
   // Wait for this signal's turn in the signal Q.
   sig_start_->Wait();
   {
-    // Now lock the target, sleeping all active threads
+    // Now lock the target
     MutexLock lock(mutex_);
 
-    // Suspend all threads except this one
-    uint32_t curId;
-    bool more = GetFirstThreadId(&curId);
-    while (more) {
-      if (curId != id) {
-        IThread *thread = threads_[curId];
-        thread->Suspend();
-      }
-      more = GetNextThreadId(&curId);
-    }
-
     // Signal the stub (Run thread) that we are ready to process
     // a trap, by updating the signal information and releasing
     // the lock.
     cur_signal_ = sig;
     sig_thread_ = id;
     reg_thread_ = id;
     run_thread_ = id;
   }
 
   // Wait for permission to continue
@@ skipping 18 matching lines @@
 
     // If no signal is waiting for this iteration...
     if (-1 == cur_signal_) {
       // but the debugger is talking to us then force a break
       if (ses->DataAvailable()) {
         // set signal to 0 to signify paused
         cur_signal_ = 0;
         sig_thread_ = 0;
 
         // put all the threads to sleep.
-        uint32_t curId;
-        bool more = GetFirstThreadId(&curId);
-        while (more) {
-          if (curId != id) {
-            IThread *thread = threads_[curId];
-            thread->Suspend();
-          }
-          more = GetNextThreadId(&curId);
-        }
+        IThread::SuspendAll(0);
       } else {
         // otherwise, nothing to do so try again.
         continue;
       }
     } else {
       // otherwise there really is an exception so get the id of the thread
-      id = GetRegThreadId();
+      id = sig_thread_;
+
+      // Suspend all threads, unless we just did a step over breakpoint without
+      // resuming threads.
+      if (!stepping_over_breakpoint_) {
+        IThread::SuspendAll(id);
+      }
+      stepping_over_breakpoint_ = false;
 
       // Reset single stepping.
       IThread *thread = threads_[id];
       thread->SetStep(false);
 
       RemoveTemporaryBreakpoints(thread);
     }
 
     // Next update the current thread info
     char tmp[16];
@@ skipping 19 matching lines @@
         if (ProcessPacket(&recv, &reply)) {
           // If this is a continue command, break out of this loop
           break;
         } else {
           // Othwerise send the reponse
           ses->SendPacket(&reply);
         }
       }
     } while (ses->Connected());
 
-
-    // Now that we are done, we want to continue in the "correct order".
-    // This means letting the active thread go first, in case we are single
-    // stepping and want to catch it again.  This is a desired behavior but
-    // it is not guaranteed since another thread may already be in an
-    // exception state and next in line to notify the target.
-
-    // If the run thread is not the exception thread, wake it up now.
-    uint32_t run_thread = GetRunThreadId();
-    if (run_thread != id
-        && run_thread != static_cast<uint32_t>(-1)) {
-      IThread* thread = threads_[run_thread];
-      thread->Resume();
-    }
-
-    // Now wake up everyone else
-    uint32_t curId;
-    bool more = GetFirstThreadId(&curId);
-    while (more) {
-      if ((curId != id) && (curId != GetRunThreadId())) {
-        IThread *thread = threads_[curId];
-        thread->Resume();
-      }
-      more = GetNextThreadId(&curId);
+    // Resume all threads, unless we need to single step signaled thread over
+    // breakpoint.
+    if (!stepping_over_breakpoint_) {
+      IThread::ResumeAll(id);
     }
 
     // Reset the signal value
     cur_signal_ = -1;
 
     // If there is no signaled thread, then we were interrupted by GDB, and
     // there is no signal handler waiting.
     // If there was a signaled thread, let the signal handler resume.
     if (id != 0) {
       sig_done_->Signal();
@@ skipping 330 matching lines @@
           }
 
           ThreadMap_t::iterator it = threads_.find(thread_id);
           if (it == threads_.end()) {
             err = BAD_ARGS;
             break;
           }
 
           it->second->SetStep(true);
           run_thread_ = thread_id;
+          // TODO: check thread_id is signaled thread id!
+          // This is the only case we allow one thread to single step while
+          // others remain stopped.
+          stepping_over_breakpoint_ = true;
           return true;
         }
 
         // Unsupported form of vCont.
         err = BAD_FORMAT;
         break;
       }
 
       NaClLog(LOG_ERROR, "Unknown command: %s\n", pktIn->GetPayload());
       return false;
@@ skipping 82 matching lines @@
 
   return NULL;
 }
 
 
 }  // namespace gdb_rsp