Merge pull request #214 from cuviper/attach-thread-sync

proccontrol: Synchronize additional threads found during attach

proccontrol/src/int_process.h

@@ -271,7 +271,10 @@ class int_process
    static bool reattach(int_processSet *pset);
    virtual bool plat_attach(bool allStopped, bool &should_sync) = 0;
 
+   bool attachThreads(bool &found_new_threads);
    bool attachThreads();
+   virtual bool plat_attachThreadsSync();
+
    virtual async_ret_t post_attach(bool wasDetached, std::set<response::ptr> &aresps);
    async_ret_t initializeAddressSpace(std::set<response::ptr> &async_responses);
 

proccontrol/src/linux.C

@@ -1110,6 +1110,44 @@ bool linux_process::plat_attach(bool, bool &)
    return true;
 }
 
+// Attach any new threads and synchronize, until there are no new threads
+bool linux_process::plat_attachThreadsSync()
+{
+   while (true) {
+      bool found_new_threads = false;
+
+      ProcPool()->condvar()->lock();
+      bool result = attachThreads(found_new_threads);
+      if (found_new_threads)
+         ProcPool()->condvar()->broadcast();
+      ProcPool()->condvar()->unlock();
+
+      if (!result) {
+         pthrd_printf("Failed to attach to threads in %d\n", pid);
+         setLastError(err_internal, "Could not get threads during attach\n");
+         return false;
+      }
+
+      if (!found_new_threads)
+         return true;
+
+      while (Counter::processCount(Counter::NeonatalThreads, this) > 0) {
+         bool proc_exited = false;
+         pthrd_printf("Waiting for neonatal threads in process %d\n", pid);
+         result = waitAndHandleForProc(true, this, proc_exited);
+         if (!result) {
+            perr_printf("Internal error calling waitAndHandleForProc on %d\n", getPid());
+            return false;
+         }
+         if (proc_exited) {
+            perr_printf("Process exited while waiting for user thread stop, erroring\n");
+            setLastError(err_exited, "Process exited while thread being stopped.\n");
+            return false;
+         }
+      }
+   }
+}
+
 bool linux_process::plat_attachWillTriggerStop() {
     char procName[64];
     char cmd[256];

proccontrol/src/linux.h

@@ -111,6 +111,7 @@ class linux_process : public sysv_process, public unix_process, public thread_db
    virtual bool plat_create();
    virtual bool plat_create_int();
    virtual bool plat_attach(bool allStopped, bool &);
+   virtual bool plat_attachThreadsSync();
    virtual bool plat_attachWillTriggerStop();
    virtual bool plat_forked();
    virtual bool plat_execed();

proccontrol/src/process.C

@@ -211,8 +211,10 @@ void int_process::plat_threadAttachDone()
 {
 }
 
-bool int_process::attachThreads()
+bool int_process::attachThreads(bool &found_new_threads)
 {
+   found_new_threads = false;
+
    if (!needIndividualThreadAttach())
       return true;
 
@@ -224,9 +226,9 @@ bool int_process::attachThreads()
     * a list of LWPs, but then new threads are created before we attach to
     * all the existing threads.
     **/
-   bool found_new_threads;
+   bool loop_new_threads;
    do {
-      found_new_threads = false;
+      loop_new_threads = false;
       vector<Dyninst::LWP> lwps;
       bool result = getThreadLWPs(lwps);
       if (!result) {
@@ -242,10 +244,28 @@ bool int_process::attachThreads()
          }
          pthrd_printf("Creating new thread for %d/%d during attach\n", pid, *i);
          thr = int_thread::createThread(this, NULL_THR_ID, *i, false, int_thread::as_needs_attach);
-         found_new_threads = true;
+         found_new_threads = loop_new_threads = true;
       }
-   } while (found_new_threads);
+   } while (loop_new_threads);
+
+   return true;
+}
+
+bool int_process::attachThreads()
+{
+   bool found_new_threads = false;
+   return attachThreads(found_new_threads);
+}
 
+bool int_process::plat_attachThreadsSync()
+{
+   // By default, platforms just call the idempotent attachThreads().
+   // Some platforms may override, e.g. Linux should sync with all threads.
+   if (!attachThreads()) {
+      pthrd_printf("Failed to attach to threads in %d\n", pid);
+      setLastError(err_internal, "Could not get threads during attach\n");
+      return false;
+   }
    return true;
 }
 
@@ -443,10 +463,9 @@ bool int_process::attach(int_processSet *ps, bool reattach)
       int_process *proc = *i;
       if (proc->getState() == errorstate)
          continue;
-      bool result = proc->attachThreads();
+      bool result = proc->plat_attachThreadsSync();
       if (!result) {
          pthrd_printf("Failed to attach to threads in %d--now an error\n", proc->pid);
-         proc->setLastError(err_internal, "Could not get threads during attach\n");
          procs.erase(i++);
          had_error = true;
          continue;