Version goes to 9.2. All independent defines/constants for version should be replaced...
[dyninst.git] / proccontrol / src / process.C
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  *
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  *
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  *
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  *
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  *
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30 #include "version.h"
31 #include "int_process.h"
32 #include "irpc.h"
33 #include "procpool.h"
34 #include "int_handler.h"
35 #include "response.h"
36 #include "int_event.h"
37 #include "processplat.h"
38 #include "Mailbox.h"
39 #include "PCErrors.h"
40 #include "Generator.h"
41 #include "Event.h"
42 #include "Handler.h"
43 #include "ProcessSet.h"
44 #include "PlatFeatures.h"
45
46 #if defined(os_windows)
47 #include "windows_process.h"
48 #include "windows_thread.h"
49 #endif
50
51 #include "loadLibrary/injector.h"
52
53 #include <climits>
54 #include <cstring>
55 #include <cassert>
56 #include <map>
57 #include <sstream>
58 #include <iostream>
59 #include <iterator>
60 #include <errno.h>
61
62 #if defined(os_windows)
63 #pragma warning(disable:4355)
64 #endif
65
66 using namespace Dyninst;
67 using namespace ProcControlAPI;
68 using namespace std;
69
70 const map<int,int> Process::emptyFDs;
71 const vector<string> Process::emptyEnvp;
72 Process::thread_mode_t threadingMode = Process::GeneratorThreading;
73 bool int_process::in_callback = false;
74 std::set<int_thread::continue_cb_t> int_thread::continue_cbs;
75 SymbolReaderFactory *int_process::user_set_symbol_reader = NULL;
76
77 static const int ProcControl_major_version = DYNINST_MAJOR_VERSION;
78 static const int ProcControl_minor_version = DYNINST_MINOR_VERSION;
79 static const int ProcControl_maintenance_version = DYNINST_PATCH_VERSION;
80
81 bool Dyninst::ProcControlAPI::is_restricted_ptrace = false;
82
83
84
85 void Process::version(int& major, int& minor, int& maintenance)
86 {
87     major = ProcControl_major_version;
88     minor = ProcControl_minor_version;
89     maintenance = ProcControl_maintenance_version;
90 }
91
92 bool int_process::create(int_processSet *ps) {
93    bool had_error = false;
94    set<int_process *> procs;
95    transform(ps->begin(), ps->end(), inserter(procs, procs.end()), ProcToIntProc());
96
97    //Should be called with procpool lock held
98    pthrd_printf("Calling plat_create for %d processes\n", (int) procs.size());
99    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
100       int_process *proc = *i;
101       bool result = proc->plat_create();
102       if (!result) {
103          pthrd_printf("Could not create debuggee, %s\n", proc->executable.c_str());
104          proc->setLastError(err_noproc, "Could not create process");
105          procs.erase(i++);
106          had_error = true;
107          continue;
108       }
109       i++;
110    }
111
112    pthrd_printf("Creating initial threads for %d processes\n", (int) procs.size());
113    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); i++) {
114       int_process *proc = *i;
115           // Because yo, windows processes have threads when they're created...
116           if (proc->threadPool()->empty()) {
117         int_thread::createThread(proc, NULL_THR_ID, NULL_LWP, true, int_thread::as_created_attached);
118           }
119           ProcPool()->addProcess(proc);
120       proc->setState(neonatal_intermediate);
121       pthrd_printf("Created debugged %s on pid %d\n", proc->executable.c_str(), proc->pid);
122    }
123
124    ProcPool()->condvar()->broadcast();
125    ProcPool()->condvar()->unlock();
126
127
128    pthrd_printf("Waiting for startup for %d processes\n", (int) procs.size());
129    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
130       int_process *proc = *i;
131
132       bool result = proc->waitfor_startup();
133       if (proc->getState() == int_process::exited) {
134          pthrd_printf("Process %s/%d exited during create\n", proc->executable.c_str(), proc->pid);
135          procs.erase(i++);
136          had_error = true;
137          continue;
138       }
139       if (!result) {
140          pthrd_printf("Error during process create for %d\n", proc->pid);
141          procs.erase(i++);
142          had_error = true;
143          continue;
144       }
145       i++;
146    }
147
148    pthrd_printf("Triggering post-create for %d processes\n", (int) procs.size());
149    while (!procs.empty()) {
150       set<response::ptr> async_responses;
151       bool ret_async = false;
152       for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
153          int_process *proc = *i;
154
155          async_ret_t result = proc->post_create(async_responses);
156          if (result == aret_error) {
157             pthrd_printf("Error during post create for %d\n", proc->pid);
158             had_error = true;
159             procs.erase(i++);
160          }
161          else if (result == aret_success) {
162             assert(proc->getState() == running);
163             pthrd_printf("Finished post-create for %d.  Process is ready\n", proc->pid);
164             procs.erase(i++);
165          }
166          else {
167             pthrd_printf("post-create for %d return async\n", proc->pid);
168             ret_async = true;
169             i++;
170          }
171       }
172       if (ret_async) {
173          waitForAsyncEvent(async_responses);
174       }
175    }
176
177    return !had_error;
178 }
179
180 bool int_process::waitfor_startup()
181 {
182    bool proc_exited = false;
183    while (getState() != running) {
184       if (proc_exited || getState() == exited) {
185          pthrd_printf("Error.  Process exited during create/attach\n");
186          globalSetLastError(err_exited, "Process exited during startup");
187          return false;
188       }
189       pthrd_printf("Waiting for startup to complete for %d\n", pid);
190       bool result = waitAndHandleForProc(true, this, proc_exited);
191       if (!proc_exited && (!result || getState() == errorstate)) {
192          pthrd_printf("Error.  Process %d errored during create/attach\n", pid);
193          globalSetLastError(err_internal, "Process failed to startup");
194          return false;
195       }
196       if (proc_exited || getState() == exited) {
197          pthrd_printf("Error.  Proces exited during create/attach\n");
198          globalSetLastError(err_exited, "Process exited during startup");
199          return false;
200       }
201       if (getState() == errorstate) {
202          pthrd_printf("Error.  Process in error state\n");
203          globalSetLastError(err_internal, "Process errored during startup");
204          return false;
205       }
206    }
207    return true;
208 }
209
210 void int_process::plat_threadAttachDone()
211 {
212 }
213
214 bool int_process::attachThreads()
215 {
216    if (!needIndividualThreadAttach())
217       return true;
218
219    /**
220     * This OS (linux) needs us to attach to each thread manually.
221     * Get all the thread LWPs and create new thread objects for them.
222     * After we have all the threads, check again to see if there are any
223     * new ones.  We're dealing with the race condition where we could get
224     * a list of LWPs, but then new threads are created before we attach to
225     * all the existing threads.
226     **/
227    bool found_new_threads;
228    do {
229       found_new_threads = false;
230       vector<Dyninst::LWP> lwps;
231       bool result = getThreadLWPs(lwps);
232       if (!result) {
233          pthrd_printf("Failed to get thread LWPs for %d\n", pid);
234          return false;
235       }
236
237       for (vector<Dyninst::LWP>::iterator i = lwps.begin(); i != lwps.end(); ++i) {
238          int_thread *thr = threadpool->findThreadByLWP(*i);
239          if (thr) {
240             pthrd_printf("Already have thread %d in process %d\n", *i, pid);
241             continue;
242          }
243          pthrd_printf("Creating new thread for %d/%d during attach\n", pid, *i);
244          thr = int_thread::createThread(this, NULL_THR_ID, *i, false, int_thread::as_needs_attach);
245          found_new_threads = true;
246       }
247    } while (found_new_threads);
248
249    return true;
250 }
251
252 bool int_process::attach(int_processSet *ps, bool reattach)
253 {
254    bool had_error = false, should_sync = false;
255    set<int_process *> procs;
256    vector<Event::ptr> observedEvents;
257    set<response::ptr> async_responses;
258    transform(ps->begin(), ps->end(), inserter(procs, procs.end()), ProcToIntProc());
259
260    //Should be called with procpool lock held
261
262         pthrd_printf("Calling plat_attach for %d processes\n", (int) procs.size());
263    map<pair<int_process *, Dyninst::LWP>, bool> runningStates;
264    for (set<int_process *>::iterator i = procs.begin(); i != procs.end();) {
265            int_process *proc = *i;
266       if (!proc) {
267          procs.erase(i++);
268          continue;
269       }
270       if (reattach && proc->getState() != int_process::detached) {
271          perr_printf("Attempted to reattach to attached process %d\n", proc->getPid());
272          proc->setLastError(err_attached, "Cannot reAttach to attached process.\n");
273          procs.erase(i++);
274          had_error = true;
275          continue;
276       }
277
278       // Determine the running state of all threads before attaching
279       map<Dyninst::LWP, bool> temp_runningStates;
280       if (!proc->plat_getOSRunningStates(temp_runningStates)) {
281          pthrd_printf("Could not get OS running states for %d\n", proc->getPid());
282          procs.erase(i++);
283          had_error = true;
284          continue;
285       }
286
287       //Keep track of the initial running states for each thread.  We'll fill them in latter
288       // after we create the int_thread objects.
289       bool allStopped = true;
290       for(map<Dyninst::LWP, bool>::iterator j = temp_runningStates.begin(); j != temp_runningStates.end(); ++j) {
291          if (j->second) {
292             allStopped = false;
293          }
294          runningStates[pair<int_process *, LWP>(proc, j->first)] = j->second;
295       }
296
297       bool local_should_sync = false;
298       pthrd_printf("Calling plat_attach for process %d\n", proc->getPid());
299       bool result = proc->plat_attach(allStopped, local_should_sync);
300       if (!result) {
301          pthrd_printf("Failed to plat_attach to %d\n", proc->getPid());
302          procs.erase(i++);
303          proc->setLastError(err_noproc, "Could not attach to process");
304          had_error = true;
305          continue;
306       }
307       if (local_should_sync)
308          should_sync = true;
309       i++;
310    }
311
312    //Create the int_thread objects via attach_threads
313    if (!reattach) {
314       for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); i++) {
315          int_process *proc = *i;
316          ProcPool()->addProcess(proc);
317          int_thread::createThread(proc, NULL_THR_ID, NULL_LWP, true,
318                                   int_thread::as_created_attached); //initial thread
319       }
320    }
321
322    if (should_sync) {
323       ProcPool()->condvar()->broadcast();
324       ProcPool()->condvar()->unlock();
325       for (;;) {
326          bool have_neonatal = false;
327          for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); i++) {
328             int_process *proc = *i;
329             if (proc->getState() == neonatal) {
330                have_neonatal = true;
331                break;
332             }
333          }
334          if (!have_neonatal)
335             break;
336          bool result = waitAndHandleEvents(true);
337          if (!result) {
338             pthrd_printf("Error during waitAndHandleEvents during attach\n");
339             return false;
340          }
341       }
342       ProcPool()->condvar()->lock();
343    }
344    else {
345       pthrd_printf("Attach done, moving processes to neonatal_intermediate\n");
346       for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); i++) {
347          int_process *proc = *i;
348          proc->setState(neonatal_intermediate);
349       }
350    }
351
352
353    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
354       int_process *proc = *i;
355       if (proc->getState() == errorstate) {
356          pthrd_printf("Removing process %d in error state\n", proc->getPid());
357          procs.erase(i++);
358          had_error = true;
359          continue;
360       }
361       pthrd_printf("Attaching to threads for %d\n", proc->getPid());
362       bool result = proc->attachThreads();
363       if (!result) {
364          pthrd_printf("Could not attach to threads in %d--will try again\n", proc->pid);
365          procs.erase(i++);
366       }
367
368       if (reattach) {
369          // Now, go back and set non-existing threads to detached to exclude them
370          // from the bootstrap handling, creating thread destruction events for
371          // these non-existing threads
372          //
373          // Also, at the same time issue attaches to existing threads
374          int_threadPool *tp = proc->threadPool();
375          for(int_threadPool::iterator j = tp->begin(); j != tp->end(); j++)
376          {
377             int_thread *thr = *j;
378
379             if (thr->getDetachState().getState() != int_thread::detached) {
380                //Small hack: This thread is new since we're reattaching.  Every old
381                //thread has it's DetachState in 'detached', and we'd like to unset
382                //those for the entire process.  Temporarily set this thread to detached
383                //so that it gets properly restored with the rest.
384                thr->getDetachState().desyncState(int_thread::detached);
385                continue;
386             }
387
388             pair<int_process *, LWP> key(proc, thr->getLWP());
389             map<pair<int_process *, LWP>, bool>::iterator findIter = runningStates.find(key);
390
391             pthrd_printf("Re-attaching to thread %d/%d\n", proc->getPid(), thr->getLWP());
392             if (findIter == runningStates.end() || !thr->attach()) {
393                pthrd_printf("Creating thread destroy event for thread %d/%d\n", proc->getPid(), thr->getLWP());
394                thr->getGeneratorState().setState(int_thread::detached);
395                thr->getHandlerState().setState(int_thread::detached);
396                thr->getUserState().setState(int_thread::detached);
397                thr->getDetachState().setState(int_thread::detached);
398
399                Event::ptr destroyEv;
400                if (proc->plat_supportLWPPostDestroy()) {
401                   destroyEv = Event::ptr(new EventLWPDestroy(EventType::Post));
402                }
403                else if (proc->plat_supportThreadEvents()) {
404                   destroyEv = Event::ptr(new EventUserThreadDestroy(EventType::Post));
405                }
406                else {
407                   perr_printf("Platform does not support any thread destroy events.  Now what?\n");
408                   assert(0);
409                }
410
411                destroyEv->setProcess(proc->proc());
412                destroyEv->setThread(thr->thread());
413                destroyEv->setSyncType(Event::async);
414                destroyEv->setUserEvent(true);
415                observedEvents.push_back(destroyEv);
416             }
417          }
418          proc->threadPool()->initialThread()->getDetachState().restoreStateProc();
419       }
420       i++;
421    }
422
423    ProcPool()->condvar()->broadcast();
424    ProcPool()->condvar()->unlock();
425
426    //Wait for each process to make it to the 'running' state.
427    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
428       int_process *proc = *i;
429       pthrd_printf("Wait for attach from process %d\n", proc->pid);
430
431       bool result = proc->waitfor_startup();
432       if (!result) {
433          pthrd_printf("Error waiting for attach to %d\n", proc->pid);
434          procs.erase(i++);
435          had_error = true;
436       }
437       i++;
438    }
439
440    //Some OSs need to do their attachThreads here.  Since the operation is supposed to be
441    //idempotent after success, then just do it again.
442    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
443       int_process *proc = *i;
444       if (proc->getState() == errorstate)
445          continue;
446       bool result = proc->attachThreads();
447       if (!result) {
448          pthrd_printf("Failed to attach to threads in %d--now an error\n", proc->pid);
449          proc->setLastError(err_internal, "Could not get threads during attach\n");
450          procs.erase(i++);
451          had_error = true;
452          continue;
453       }
454
455       // Now that all the threads are created, set their running states
456       int_threadPool *tp = proc->threadPool();
457       for(int_threadPool::iterator j = tp->begin(); j != tp->end(); j++) {
458          int_thread *thr = *j;
459          pair<int_process *, LWP> key(proc, thr->getLWP());
460          map<pair<int_process *, LWP>, bool>::iterator findIter = runningStates.find(key);
461
462          // There is a race that could be visible here where we are not
463          // guaranteed to determine the running state of all threads in a process
464          // before we attach -- if for some reason we don't know the running
465          // state, assume it was running
466          thr->setRunningWhenAttached(findIter == runningStates.end() ? true : findIter->second);
467       }
468
469       pthrd_printf("Thread attach is done for process %d\n", proc->getPid());
470       proc->plat_threadAttachDone();
471       i++;
472    }
473
474    pthrd_printf("Triggering post-attach for %d processes\n", (int) procs.size());
475    std::set<int_process *> pa_procs = procs;
476    while (!pa_procs.empty()) {
477       async_responses.clear();
478       bool ret_async = false;
479       for (set<int_process *>::iterator i = pa_procs.begin(); i != pa_procs.end(); ) {
480          int_process *proc = *i;
481
482          async_ret_t result = proc->post_attach(false, async_responses);
483          if (result == aret_error) {
484             pthrd_printf("Error during post attach for %d\n", proc->pid);
485             had_error = true;
486             pa_procs.erase(i++);
487          }
488          else if (result == aret_success) {
489             assert(proc->getState() == running);
490             pthrd_printf("Finished post-attach for %d.  Process is ready\n", proc->pid);
491             pa_procs.erase(i++);
492          }
493          else {
494             pthrd_printf("post-attach for %d return async\n", proc->pid);
495             ret_async = true;
496             i++;
497          }
498       }
499       if (ret_async) {
500          waitForAsyncEvent(async_responses);
501       }
502    }
503
504    //
505    //Everything below this point is targeted at DOTF reattach--
506    //reinstalling BPs and throwing dead thread events.
507    if (!reattach)
508       return !had_error;
509
510    async_responses.clear();
511    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); i++) {
512       // Resume all breakpoints
513       int_process *proc = *i;
514       for(std::map<Dyninst::Address, sw_breakpoint *>::iterator j = proc->mem->breakpoints.begin();
515           j != proc->mem->breakpoints.end(); j++)
516       {
517          pthrd_printf("Resuming breakpoint at 0x%lx in process %d\n", j->first, proc->getPid());
518          bool result = j->second->resume(proc, async_responses);
519          if(!result) {
520             pthrd_printf("Error resuming breakpoint at %lx\n", j->first);
521             //Drop this error.  The library containing this BP was likely unloaded.
522          }
523       }
524    }
525    waitForAsyncEvent(async_responses);
526
527    // Report all events for observed process state changes
528    for(vector<Event::ptr>::iterator i = observedEvents.begin(); i!= observedEvents.end(); i++)
529    {
530        int_thread *thrd = (*i)->getThread()->llthrd();
531        pthrd_printf("Queuing event %s for thread %d/%d\n",
532                     (*i)->getEventType().name().c_str(), (*i)->getProcess()->getPid(),
533                     (*i)->getThread()->getLWP());
534
535        // Make sure the thread is the correct state while in event handling
536        thrd->getGeneratorState().setState(int_thread::detached);
537        thrd->getHandlerState().setState(int_thread::detached);
538        thrd->getUserState().setState(int_thread::detached);
539        thrd->getDetachState().setState(int_thread::detached);
540
541            mbox()->enqueue(*i);
542    }
543
544    if (!observedEvents.empty()) {
545       // As a sanity check, don't block
546       bool result = waitAndHandleEvents(false);
547       if (!result) {
548          perr_printf("Internal error in waitAndHandleEvents under reattach\n");
549       }
550    }
551
552    return !had_error;
553 }
554
555 bool int_process::reattach(int_processSet *pset)
556 {
557    return attach(pset, true);
558 }
559
560 bool int_process::execed()
561 {
562    ProcPool()->condvar()->lock();
563
564    bool should_clean = false;
565    mem->rmProc(this, should_clean);
566    if (should_clean)
567       delete mem;
568    mem = new mem_state(this);
569
570    arch = Dyninst::Arch_none;
571    exec_mem_cache.clear();
572
573    int_thread::State user_initial_thrd_state = threadpool->initialThread()->getUserState().getState();
574    int_thread::State gen_initial_thrd_state = threadpool->initialThread()->getGeneratorState().getState();
575    int_thread::State handler_initial_thrd_state = threadpool->initialThread()->getHandlerState().getState();
576
577    int_threadPool::iterator i = threadpool->begin();
578    for (; i != threadpool->end(); ++i) {
579       int_thread *thrd = *i;
580       thrd->getUserState().setState(int_thread::exited);
581       thrd->getGeneratorState().setState(int_thread::exited);
582       ProcPool()->rmThread(thrd);
583       delete thrd;
584    }
585    threadpool->clear();
586
587    int_thread *initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP,
588                                                          true, int_thread::as_created_attached);
589    initial_thread->getUserState().setState(user_initial_thrd_state);
590    initial_thread->getGeneratorState().setState(gen_initial_thrd_state);
591    initial_thread->getHandlerState().setState(handler_initial_thrd_state);
592
593    ProcPool()->condvar()->broadcast();
594    ProcPool()->condvar()->unlock();
595
596    bool result = plat_execed();
597
598    return result;
599 }
600
601 bool int_process::plat_execed()
602 {
603    return true;
604 }
605
606 bool int_process::forked()
607 {
608    ProcPool()->condvar()->lock();
609
610    pthrd_printf("Setting up forked process %d\n", pid);
611    creation_mode = ct_fork;
612    bool result = plat_forked();
613    if (!result) {
614       pthrd_printf("Could not handle forked debuggee, %d\n", pid);
615       return false;
616    }
617
618    int_thread *initial_thread;
619    initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP, true, int_thread::as_created_attached);
620    (void)initial_thread; // suppress unused warning
621
622    ProcPool()->addProcess(this);
623
624    result = attachThreads();
625    if (!result) {
626       pthrd_printf("Failed to attach to threads in %d\n", pid);
627       setLastError(err_internal, "Could not attach to process' threads");
628       goto error;
629    }
630
631    ProcPool()->condvar()->broadcast();
632    ProcPool()->condvar()->unlock();
633
634    result = post_forked();
635    if (!result) {
636       pthrd_printf("Post-fork failed on %d\n", pid);
637       setLastError(err_internal, "Error handling forked process");
638       goto error;
639    }
640    return true;
641
642   error:
643    if (getState() == exited) {
644       setLastError(err_exited, "Process exited unexpectedly during attach\n");
645       return false;
646    }
647    pthrd_printf("Error during process attach for %d\n", pid);
648    return false;
649 }
650
651 bool int_process::post_forked()
652 {
653    setState(running);
654    return true;
655 }
656
657 async_ret_t int_process::initializeAddressSpace(std::set<response::ptr> &async_responses)
658 {
659    std::set<int_library*> added, rmd;
660
661    //This call will determine and cache the appropriate symbol reader, or NOP
662    // if that's already been done.
663    getSymReader();
664
665    bool have_asyncs = false;
666    bool result = refresh_libraries(added, rmd, have_asyncs, async_responses);
667    if (!result && have_asyncs) {
668       pthrd_printf("Postponing initializeAddressSpace of %d for async operations\n", getPid());
669       return aret_async;
670
671    }
672    if (!result) {
673       pthrd_printf("Failure refreshing libraries for %d\n", getPid());
674       return aret_error;
675    }
676    pthrd_printf("Successfully initialized address space for %d\n", getPid());
677    return aret_success;
678 }
679
680 async_ret_t int_process::post_attach(bool, std::set<response::ptr> &async_responses)
681 {
682    pthrd_printf("Starting post_attach for process %d\n", getPid());
683    return initializeAddressSpace(async_responses);
684 }
685
686 async_ret_t int_process::post_create(std::set<response::ptr> &async_responses)
687 {
688    pthrd_printf("Starting post_create for process %d\n", getPid());
689    return initializeAddressSpace(async_responses);
690 }
691
692 bool int_process::plat_processGroupContinues()
693 {
694    return false;
695 }
696
697 bool int_process::getThreadLWPs(std::vector<Dyninst::LWP> &)
698 {
699    return false;
700 }
701
702 const char *int_process::stateName(int_process::State s)
703 {
704    switch (s) {
705       case neonatal: return "neonatal";
706       case neonatal_intermediate: return "neonatal_intermediate";
707       case detached: return "detached";
708       case running: return "running";
709       case exited: return "exited";
710       case errorstate: return "errorstate";
711    }
712    assert(0);
713    return NULL;
714 }
715
716 void int_process::setState(int_process::State s)
717 {
718    int old_state = (int) state;
719    int new_state = (int) s;
720
721    if (new_state < old_state && new_state != detached && old_state != detached) {
722       perr_printf("Regression of state %s to %s on %d\n",
723                   stateName(state), stateName(s), pid);
724       return;
725    }
726    pthrd_printf("Changing state of process from %s to %s on %d\n",
727                 stateName(state), stateName(s), pid);
728    state = s;
729
730
731    int_thread::State new_thr_state = int_thread::errorstate;
732    switch (s) {
733       case neonatal: new_thr_state = int_thread::neonatal; break;
734       case neonatal_intermediate: new_thr_state = int_thread::neonatal_intermediate; break;
735       case running: new_thr_state = threadpool->initialThread()->getHandlerState().getState(); break;
736       case exited: new_thr_state = int_thread::exited; break;
737       case detached: new_thr_state = int_thread::detached; break;
738       case errorstate: new_thr_state = int_thread::errorstate; break;
739    }
740    pthrd_printf("Setting state of all threads in %d to %s\n", pid,
741                 int_thread::stateStr(new_thr_state));
742    for (int_threadPool::iterator i = threadpool->begin(); i != threadpool->end(); ++i)
743    {
744       (*i)->getUserState().setState(new_thr_state);
745       (*i)->getHandlerState().setState(new_thr_state);
746       (*i)->getGeneratorState().setState(new_thr_state);
747           if(new_thr_state == int_thread::exited)
748           {
749         if((*i)->getPendingStopState().getState() != int_thread::dontcare) {
750            (*i)->getPendingStopState().restoreState();
751            (*i)->pendingStopsCount().dec();
752         }
753      }
754    }
755 }
756
757 int_process::State int_process::getState() const
758 {
759    return state;
760 }
761
762 int_process::creationMode_t int_process::getCreationMode() const
763 {
764    return creation_mode;
765 }
766
767 void int_process::setContSignal(int sig) {
768     continueSig = sig;
769 }
770
771 int int_process::getContSignal() const {
772     return continueSig;
773 }
774
775 void int_process::setPid(Dyninst::PID p)
776 {
777    pthrd_printf("Setting int_process %p to pid %d\n", this, p);
778    pid = p;
779 }
780
781 Dyninst::PID int_process::getPid() const
782 {
783    return pid;
784 }
785
786 int_threadPool *int_process::threadPool() const
787 {
788    return threadpool;
789 }
790
791 Process::ptr int_process::proc() const
792 {
793    return up_proc;
794 }
795
796 bool int_process::syncRunState()
797 {
798    pthrd_printf("At top of syncRunState for %d\n", getPid());
799    int_threadPool *tp = threadPool();
800
801    /**
802     * We can have some events (currently BreakpointClear and RPCLaunch) that
803     * get thrown when a thread is continued.  We'll create and throw those
804     * events here.
805     * 1), we'll identify each thread that would be continued.  We calculate
806     * this ahead of time as the act of throwing one of these events on a thread
807     * can change the running state of another thread.
808     * 2), for each thread that would run, we check if it has one of these
809     * events and throw it.
810     * 3), Check if any proc stopper events are ready, and if so then re-throw them
811     * 4), we redo the target_state calculation in-case anything changed.
812     **/
813    //1)
814    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
815       int_thread *thr = *i;
816       int_thread::State new_state = thr->getActiveState().getState();
817       if (new_state == int_thread::ditto)
818          new_state = thr->getHandlerState().getState();
819       thr->setTargetState(new_state);
820    }
821
822    //2)
823    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
824       int_thread *thr = *i;
825       if (!RUNNING_STATE(thr->getTargetState()))
826          continue;
827       if (thr->getActiveState().getID() == int_thread::PendingStopStateID) {
828          //A pending-stop-state continue isn't a real continue.  Don't throw
829          // new events.
830          continue;
831       }
832       thr->throwEventsBeforeContinue();
833    }
834    //3)
835    pthrd_printf("Checking if any ProcStop events on %d are ready\n", getPid());
836    getProcStopManager().checkEvents();
837    //4)
838    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
839       int_thread *thr = *i;
840       int_thread::State new_state = thr->getActiveState().getState();
841       if (new_state == int_thread::ditto)
842          new_state = thr->getHandlerState().getState();
843       thr->setTargetState(new_state);
844    }
845    if (dyninst_debug_proccontrol) {
846       pc_print_lock();
847       pthrd_printf("Current Threading State for %d:\n", getPid());
848       for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
849          int_thread *thr = *i;
850          int_thread::StateTracker &target = thr->getActiveState();
851
852          char state_code[int_thread::NumStateIDs+1];
853          for (int i = 0; i < int_thread::NumStateIDs; i++) {
854             state_code[i] = int_thread::stateLetter(thr->getStateByID(i).getState());
855          }
856          state_code[int_thread::NumStateIDs] = '\0';
857          pthrd_printf("%d/%d hand: %s, gen: %s, %s: %s, code: %s\n",
858                       getPid(), thr->getLWP(),
859                       int_thread::stateStr(thr->getHandlerState().getState()),
860                       int_thread::stateStr(thr->getGeneratorState().getState()),
861                       int_thread::stateIDToName(target.getID()).c_str(),
862                       int_thread::stateStr(target.getState()),
863                       state_code);
864       }
865           if(tp->empty())
866           {
867                   pthrd_printf("Threadpool for %d is empty\n", getPid());
868           }
869      pc_print_unlock();
870    }
871
872    pthrd_printf("Running plat_syncRunState on %d\n", getPid());
873    bool result = plat_syncRunState();
874
875    return result;
876 }
877
878 bool int_process::waitForAsyncEvent(response::ptr resp)
879 {
880   if (resp) {
881     int_process *proc = resp->getProcess();
882     if (proc)
883        proc->plat_preAsyncWait();
884   }
885   return getResponses().waitFor(resp);
886 }
887
888 bool int_process::waitForAsyncEvent(std::set<response::ptr> resp)
889 {
890    for (set<response::ptr>::iterator i = resp.begin(); i != resp.end(); i++) {
891      response::ptr r = *i;
892      if (!r)
893        continue;
894      int_process *proc = r->getProcess();
895      assert(proc);
896      proc->plat_preAsyncWait();
897    }
898
899    bool has_error = false;
900    for (set<response::ptr>::iterator i = resp.begin(); i != resp.end(); i++) {
901       bool result = getResponses().waitFor(*i);
902       if (!result)
903          has_error = true;
904    }
905
906    return !has_error;
907 }
908
909 Counter &int_process::asyncEventCount()
910 {
911    return async_event_count;
912 }
913
914 Counter &int_process::getForceGeneratorBlockCount()
915 {
916    return force_generator_block_count;
917 }
918
919 Counter &int_process::getStartupTeardownProcs()
920 {
921    return startupteardown_procs;
922 }
923
924 bool int_process::plat_waitAndHandleForProc()
925 {
926   return true;
927 }
928
929 int_process *int_process::in_waitHandleProc = NULL;
930
931 bool int_process::waitAndHandleForProc(bool block, int_process *proc, bool &proc_exited)
932 {
933    assert(in_waitHandleProc == NULL);
934    in_waitHandleProc = proc;
935
936    if (!proc->plat_waitAndHandleForProc()) {
937      perr_printf("Failed platform specific waitAndHandle for %d\n", proc->getPid());
938      return false;
939    }
940
941    bool result = waitAndHandleEvents(block);
942
943    if (proc->getState() == int_process::exited) {
944       pthrd_printf("Deleting proc %d from waitAndHandleForProc\n", proc->getPid());
945       delete proc;
946       proc_exited = true;
947    }
948    else {
949       proc_exited = false;
950    }
951
952    in_waitHandleProc = NULL;
953    return result;
954 }
955
956 #define checkHandlerThread      (hasHandlerThread      = (int) isHandlerThread())
957 #define checkBlock              (hasBlock              = (int) block)
958 #define checkGotEvent           (hasGotEvent           = (int) gotEvent)
959 #define checkAsyncPending       (hasAsyncPending       = (int) HandlerPool::hasProcAsyncPending())
960 #define checkRunningThread      (hasRunningThread      = (int) Counter::global(Counter::HandlerRunningThreads))
961 #define checkClearingBP         (hasClearingBP         = (int) Counter::global(Counter::ClearingBPs))
962 #define checkStopPending        (hasStopPending        = (int) Counter::global(Counter::PendingStops))
963 #define checkSyncRPCRunningThrd (hasSyncRPCRunningThrd = (int) Counter::global(Counter::SyncRPCRunningThreads))
964 #define checkProcStopRPC        (hasProcStopRPC        = (int) Counter::global(Counter::ProcStopRPCs))
965 #define checkStartupTeardownProcs (hasStartupTeardownProc = (int) Counter::global(Counter::StartupTeardownProcesses))
966 #define checkNeonatalThreads     (hasNeonatalThreads   = (int) Counter::global(Counter::NeonatalThreads))
967 #define checkAsyncEvents        (hasAsyncEvents        = (int) Counter::global(Counter::AsyncEvents))
968 #define UNSET_CHECK        -8
969 #define printCheck(VAL)    (((int) VAL) == UNSET_CHECK ? '?' : (VAL ? 'T' : 'F'))
970
971 bool int_process::waitAndHandleEvents(bool block)
972 {
973    pthrd_printf("Top of waitAndHandleEvents.  Block = %s\n", block ? "true" : "false");
974    bool gotEvent = false;
975    assert(!int_process::in_callback);
976    bool error = false;
977
978    static bool recurse = false;
979    assert(!recurse);
980    recurse = true;
981
982    for (;;)
983    {
984       /**
985        * Check for possible blocking combinations using Counters
986        *
987        * The weirdness in the #defines and variables here is to record the result of
988        * each check, which is used if debug printing is turned on, while also letting the
989        * C++ partial evaluator not check parts this expression (as the checks involve an
990        * expensive locking operation).
991        *
992        * For most people, just ignore the #defines.  The important bit is that we're really
993        * calling the Counter::global(...) function to determine whether we should block.
994        **/
995       int hasHandlerThread = UNSET_CHECK, hasAsyncPending = UNSET_CHECK, hasRunningThread = UNSET_CHECK;
996       int hasClearingBP = UNSET_CHECK, hasStopPending = UNSET_CHECK, hasSyncRPCRunningThrd = UNSET_CHECK;
997       int hasProcStopRPC  = UNSET_CHECK, hasBlock = UNSET_CHECK, hasGotEvent = UNSET_CHECK;
998       int hasStartupTeardownProc = UNSET_CHECK, hasNeonatalThreads = UNSET_CHECK, hasAsyncEvents = UNSET_CHECK;
999
1000       bool should_block = (!checkHandlerThread &&
1001                            ((checkBlock && !checkGotEvent && checkRunningThread) ||
1002                             (checkSyncRPCRunningThrd) ||
1003                             (checkStopPending) ||
1004                             (checkClearingBP) ||
1005                             (checkProcStopRPC) ||
1006                             (checkAsyncPending) ||
1007                             (checkStartupTeardownProcs) ||
1008                             (checkNeonatalThreads) ||
1009                             (checkAsyncEvents)
1010                            )
1011                           );
1012       //Entry for this print match the above tests in order and one-for-one.
1013       pthrd_printf("%s for events = !%c && ((%c && !%c && %c) || %c || %c || %c || %c || %c || %c || %c || %c)\n",
1014                    should_block ? "Blocking" : "Polling",
1015                    printCheck(hasHandlerThread),
1016                    printCheck(hasBlock), printCheck(hasGotEvent), printCheck(hasRunningThread),
1017                    printCheck(hasSyncRPCRunningThrd),
1018                    printCheck(hasStopPending),
1019                    printCheck(hasClearingBP),
1020                    printCheck(hasProcStopRPC),
1021                    printCheck(hasAsyncPending),
1022                    printCheck(hasStartupTeardownProc),
1023                    printCheck(hasNeonatalThreads),
1024                    printCheck(hasAsyncEvents));
1025
1026       //TODO: If/When we move to per-process locks, then we'll need a smarter should_block check
1027       //      We don't want the should_block changing between the above measurement
1028       //      and the below dequeue.  Perhaps dequeue should alway poll, and the user thread loops
1029       //      over it while (should_block == true), with a condition variable signaling when the
1030       //      should_block would go to false (so we don't just spin).
1031
1032       if (should_block && Counter::globalCount(Counter::ForceGeneratorBlock)) {
1033          // Entirely possible we didn't continue anything, but we want the generator to
1034          // wake up anyway
1035          ProcPool()->condvar()->broadcast();
1036       }
1037
1038       Event::ptr ev = mbox()->dequeue(should_block);
1039
1040       if (ev == Event::ptr())
1041       {
1042          if (gotEvent) {
1043             pthrd_printf("Returning after handling events\n");
1044             goto done;
1045          }
1046          if (should_block) {
1047             perr_printf("Blocking wait failed to get events\n");
1048             ProcControlAPI::globalSetLastError(err_internal, "Blocking wait returned without events");
1049             error = true;
1050             goto done;
1051          }
1052          if (hasHandlerThread) {
1053             pthrd_printf("Handler thread found nothing to do\n");
1054             goto done;
1055          }
1056          if (!hasRunningThread) {
1057             pthrd_printf("No threads are running to produce events\n");
1058             ProcControlAPI::globalSetLastError(err_notrunning, "No threads are running to produce events\n");
1059             error = true;
1060             goto done;
1061          }
1062
1063          ProcControlAPI::globalSetLastError(err_noevents, "Poll failed to find events");
1064          pthrd_printf("Poll failed to find events\n");
1065          error = true;
1066          goto done;
1067       }
1068       if (mt()->getThreadMode() == Process::NoThreads ||
1069           mt()->getThreadMode() == Process::GeneratorThreading)
1070       {
1071          pthrd_printf("Clearing event from pipe after dequeue\n");
1072          notify()->clearEvent();
1073       }
1074
1075       gotEvent = true;
1076
1077       bool terminating = (ev->getProcess()->isTerminated());
1078
1079       bool exitEvent = (ev->getEventType().time() == EventType::Post &&
1080                         ev->getEventType().code() == EventType::Exit);
1081       Process::const_ptr proc = ev->getProcess();
1082       int_process *llproc = proc->llproc();
1083
1084       if (terminating) {
1085         if(!exitEvent || !llproc) {
1086           // Since the user will never handle this one...
1087           pthrd_printf("Received event %s on terminated process, ignoring\n",
1088                        ev->name().c_str());
1089           if (!isHandlerThread() && ev->noted_event) notify()->clearEvent();
1090           continue;
1091         }
1092       }
1093
1094       HandlerPool *hpool = llproc->handlerpool;
1095
1096       if (!ev->handling_started) {
1097          llproc->updateSyncState(ev, false);
1098          llproc->noteNewDequeuedEvent(ev);
1099          ev->handling_started = true;
1100       }
1101
1102       llproc->plat_preHandleEvent();
1103
1104       bool should_handle_ev = llproc->getProcStopManager().prepEvent(ev);
1105       if (should_handle_ev) {
1106          hpool->handleEvent(ev);
1107       }
1108
1109       llproc = proc->llproc();
1110
1111       if (llproc) {
1112          bool result = llproc->syncRunState();
1113          if (!result) {
1114             pthrd_printf("syncRunState failed.  Returning error from waitAndHandleEvents\n");
1115             error = true;
1116             goto done;
1117          }
1118          llproc->plat_postHandleEvent();
1119       }
1120       else
1121       {
1122          //Special case event handling, the process cleaned itself
1123          // under this event (likely post-exit or post-crash), but was
1124          // unable to clean its handlerpool (as we were using it).
1125          // Clean this for the process now.
1126                         pthrd_printf("Process is gone, skipping syncRunState and deleting handler pool\n");
1127                   delete hpool;
1128       }
1129    }
1130   done:
1131    pthrd_printf("Leaving WaitAndHandleEvents with return %s, 'cause we're done\n", !error ? "true" : "false");
1132    recurse = false;
1133    return !error;
1134 }
1135
1136 void int_process::throwDetachEvent(bool temporary, bool leaveStopped)
1137 {
1138    pthrd_printf("%s detaching from process %d\n", temporary ? "Temporary" : "Permanent", getPid());
1139    EventDetach::ptr detach_ev = EventDetach::ptr(new EventDetach());
1140    detach_ev->getInternal()->temporary_detach = temporary;
1141    detach_ev->getInternal()->leave_stopped = leaveStopped;
1142    detach_ev->setProcess(proc());
1143    detach_ev->setThread(threadPool()->initialThread()->thread());
1144    detach_ev->setSyncType(Event::async);
1145
1146    getStartupTeardownProcs().inc();
1147    threadPool()->initialThread()->getDetachState().desyncStateProc(int_thread::stopped);
1148
1149    mbox()->enqueue(detach_ev);
1150 }
1151
1152 bool int_process::plat_detachDone() {
1153    return true;
1154 }
1155
1156 bool int_process::terminate(bool &needs_sync)
1157 {
1158
1159    //Should be called with the ProcPool lock held.
1160    pthrd_printf("Terminate requested on process %d\n", getPid());
1161    getStartupTeardownProcs().inc();
1162
1163    bool result = plat_terminate(needs_sync);
1164    if (!result) {
1165       pthrd_printf("plat_terminate failed on %d\n", getPid());
1166       return false;
1167    }
1168    forcedTermination = true;
1169
1170         // On windows this leads to doubling up events
1171 #if defined(os_windows)
1172    // If we're on windows, we want to force the generator thread into waiting for a debug
1173    // event _if the process is stopped_. If the process is running then we're already
1174    // waiting (or will wait) for a debug event, and forcing the generator to block may
1175    // lead to doubling up.
1176
1177    // The following code is similar to GeneratorWindows::hasLiveProc. This is not a coincidence.
1178         bool all_stopped = true;
1179    for (int_threadPool::iterator iter = threadpool->begin(); iter != threadpool->end(); ++iter) {
1180                 if (RUNNING_STATE((*iter)->getActiveState().getState())) {
1181                         all_stopped = false;
1182                         break;
1183                 }
1184    }
1185    if (all_stopped) {
1186            setForceGeneratorBlock(true);
1187    }
1188 #else
1189    // Do it all the time
1190    setForceGeneratorBlock(true);
1191 #endif
1192
1193    return true;
1194 }
1195
1196 bool int_process::preTerminate() {
1197     return true;
1198 }
1199
1200 int_libraryTracking *int_process::getLibraryTracking()
1201 {
1202    if (LibraryTracking_set)
1203       return pLibraryTracking;
1204    LibraryTracking_set = true;
1205    pLibraryTracking = dynamic_cast<int_libraryTracking *>(this);
1206    if (!pLibraryTracking)
1207       return NULL;
1208    if (!pLibraryTracking->up_ptr)
1209       pLibraryTracking->up_ptr = new LibraryTracking(proc());
1210    return pLibraryTracking;
1211 }
1212
1213 int_LWPTracking *int_process::getLWPTracking()
1214 {
1215    if (LWPTracking_set){
1216       return pLWPTracking;
1217    }
1218    LWPTracking_set = true;
1219    pLWPTracking = dynamic_cast<int_LWPTracking *>(this);
1220    if (!pLWPTracking)
1221       return NULL;
1222    if (!pLWPTracking->up_ptr)
1223       pLWPTracking->up_ptr = new LWPTracking(proc());
1224    return pLWPTracking;
1225 }
1226
1227 int_threadTracking *int_process::getThreadTracking()
1228 {
1229    if (ThreadTracking_set)
1230       return pThreadTracking;
1231    ThreadTracking_set = true;
1232    pThreadTracking = dynamic_cast<int_threadTracking *>(this);
1233    if (!pThreadTracking)
1234       return NULL;
1235    if (!pThreadTracking->up_ptr)
1236       pThreadTracking->up_ptr = new ThreadTracking(proc());
1237    return pThreadTracking;
1238 }
1239
1240 int_followFork *int_process::getFollowFork()
1241 {
1242    if (FollowFork_set)
1243       return pFollowFork;
1244    FollowFork_set = true;
1245    pFollowFork = dynamic_cast<int_followFork *>(this);
1246    if (!pFollowFork)
1247       return NULL;
1248    if (!pFollowFork->up_ptr)
1249       pFollowFork->up_ptr = new FollowFork(proc());
1250    return pFollowFork;
1251 }
1252
1253 int_callStackUnwinding *int_process::getCallStackUnwinding()
1254 {
1255    if (CallStackUnwinding_set)
1256       return pCallStackUnwinding;
1257    CallStackUnwinding_set = true;
1258    pCallStackUnwinding = dynamic_cast<int_callStackUnwinding *>(this);
1259    return pCallStackUnwinding;
1260 }
1261
1262 int_multiToolControl *int_process::getMultiToolControl()
1263 {
1264    if (MultiToolControl_set)
1265       return pMultiToolControl;
1266    MultiToolControl_set = true;
1267    pMultiToolControl = dynamic_cast<int_multiToolControl *>(this);
1268    if (!pMultiToolControl)
1269       return NULL;
1270    if (!pMultiToolControl->up_ptr)
1271       pMultiToolControl->up_ptr = new MultiToolControl(proc());
1272    return pMultiToolControl;
1273 }
1274
1275 int_memUsage *int_process::getMemUsage()
1276 {
1277    if (MemUsage_set)
1278       return pMemUsage;
1279    MemUsage_set = true;
1280    pMemUsage = dynamic_cast<int_memUsage *>(this);
1281    if (!pMemUsage)
1282       return NULL;
1283    if (!pMemUsage->up_ptr)
1284       pMemUsage->up_ptr = new MemoryUsage(proc());
1285    return pMemUsage;
1286 }
1287
1288 int_signalMask *int_process::getSignalMask()
1289 {
1290    if (SignalMask_set)
1291       return pSignalMask;
1292    SignalMask_set = true;
1293    pSignalMask = dynamic_cast<int_signalMask *>(this);
1294    if (!pSignalMask)
1295       return NULL;
1296    if (!pSignalMask->up_ptr)
1297       pSignalMask->up_ptr = new SignalMask(proc());
1298    return pSignalMask;
1299 }
1300
1301 int_BGQData *int_process::getBGQData()
1302 {
1303    if (BGQData_set)
1304       return pBGQData;
1305    BGQData_set = true;
1306    pBGQData = dynamic_cast<int_BGQData *>(this);
1307    if (!pBGQData)
1308       return NULL;
1309    if (!pBGQData->up_ptr)
1310       pBGQData->up_ptr = new BGQData(proc());
1311    return pBGQData;
1312 }
1313
1314 int_remoteIO *int_process::getRemoteIO()
1315 {
1316    if (remoteIO_set)
1317       return pRemoteIO;
1318    remoteIO_set = true;
1319    pRemoteIO = dynamic_cast<int_remoteIO *>(this);
1320    if (!pRemoteIO)
1321       return NULL;
1322    if (!pRemoteIO->up_ptr)
1323       pRemoteIO->up_ptr = new RemoteIO(proc());
1324    return pRemoteIO;
1325 }
1326
1327 int_process::int_process(Dyninst::PID p, std::string e,
1328                          std::vector<std::string> a,
1329                          std::vector<std::string> envp,
1330                          std::map<int,int> f) :
1331    state(neonatal),
1332    pid(p),
1333    creation_mode(ct_launch),
1334    executable(e),
1335    argv(a),
1336    env(envp),
1337    fds(f),
1338    arch(Dyninst::Arch_none),
1339    threadpool(NULL),
1340    up_proc(Process::ptr()),
1341    handlerpool(NULL),
1342    hasCrashSignal(false),
1343    crashSignal(0),
1344    hasExitCode(false),
1345    forcedTermination(false),
1346    silent_mode(false),
1347    exitCode(0),
1348    mem(NULL),
1349    continueSig(0),
1350    mem_cache(this),
1351    async_event_count(Counter::AsyncEvents),
1352    force_generator_block_count(Counter::ForceGeneratorBlock),
1353    startupteardown_procs(Counter::StartupTeardownProcesses),
1354    proc_stop_manager(this),
1355    user_data(NULL),
1356    last_error_string(NULL),
1357    symbol_reader(NULL),
1358    pLibraryTracking(NULL),
1359    pLWPTracking(NULL),
1360    pThreadTracking(NULL),
1361    pFollowFork(NULL),
1362    pMultiToolControl(NULL),
1363    pSignalMask(NULL),
1364    pCallStackUnwinding(NULL),
1365    pMemUsage(NULL),
1366    pBGQData(NULL),
1367    pRemoteIO(NULL),
1368    LibraryTracking_set(false),
1369    LWPTracking_set(false),
1370    ThreadTracking_set(false),
1371    FollowFork_set(false),
1372    MultiToolControl_set(false),
1373    SignalMask_set(false),
1374    CallStackUnwinding_set(false),
1375    MemUsage_set(false),
1376    BGQData_set(false),
1377    remoteIO_set(false)
1378 {
1379     pthrd_printf("New int_process at %p\n", this);
1380     clearLastError();
1381         wasCreatedViaAttach(pid == 0);
1382    //Put any object initialization in 'initializeProcess', below.
1383 }
1384
1385 int_process::int_process(Dyninst::PID pid_, int_process *p) :
1386    state(int_process::running),
1387    pid(pid_),
1388    creation_mode(ct_attach),
1389    executable(p->executable),
1390    argv(p->argv),
1391    env(p->env),
1392    arch(p->arch),
1393    hasCrashSignal(p->hasCrashSignal),
1394    crashSignal(p->crashSignal),
1395    hasExitCode(p->hasExitCode),
1396    forcedTermination(false),
1397    silent_mode(false),
1398    exitCode(p->exitCode),
1399    continueSig(p->continueSig),
1400    mem_cache(this),
1401    async_event_count(Counter::AsyncEvents),
1402    force_generator_block_count(Counter::ForceGeneratorBlock),
1403    startupteardown_procs(Counter::StartupTeardownProcesses),
1404    proc_stop_manager(this),
1405    user_data(NULL),
1406    last_error_string(NULL),
1407    symbol_reader(NULL),
1408    pLibraryTracking(NULL),
1409    pLWPTracking(NULL),
1410    pThreadTracking(NULL),
1411    pFollowFork(NULL),
1412    pMultiToolControl(NULL),
1413    pSignalMask(NULL),
1414    pCallStackUnwinding(NULL),
1415    pMemUsage(NULL),
1416    pBGQData(NULL),
1417    pRemoteIO(NULL),
1418    LibraryTracking_set(false),
1419    LWPTracking_set(false),
1420    ThreadTracking_set(false),
1421    FollowFork_set(false),
1422    MultiToolControl_set(false),
1423    SignalMask_set(false),
1424    CallStackUnwinding_set(false),
1425    MemUsage_set(false),
1426    BGQData_set(false),
1427    remoteIO_set(false)
1428 {
1429    pthrd_printf("New int_process at %p\n", this);
1430    Process::ptr hlproc = Process::ptr(new Process());
1431    clearLastError();
1432    mem = new mem_state(*p->mem, this);
1433    initializeProcess(hlproc);
1434 }
1435
1436 void int_process::initializeProcess(Process::ptr p)
1437 {
1438    assert(!p->llproc_);
1439    p->llproc_ = this;
1440    up_proc = p;
1441    threadpool = new int_threadPool(this);
1442    handlerpool = createDefaultHandlerPool(this);
1443    libpool.proc = this;
1444    if (!mem)
1445       mem = new mem_state(this);
1446    Generator::getDefaultGenerator(); //May create generator thread
1447 }
1448
1449 int_thread *int_process::findStoppedThread()
1450 {
1451    int_thread *result = NULL;
1452    for (int_threadPool::iterator i = threadpool->begin(); i != threadpool->end(); ++i)
1453    {
1454       int_thread *thr = *i;
1455       if (thr->getHandlerState().getState() == int_thread::stopped) {
1456          result = thr;
1457          break;
1458       }
1459    }
1460    return result;
1461 }
1462
1463 bool int_process::readMem(Dyninst::Address remote, mem_response::ptr result, int_thread *thr)
1464 {
1465    if (getAddressWidth() == 4) {
1466       Address old = remote;
1467       remote &= 0xffffffff;
1468       pthrd_printf("Address cropping for 32-bit: 0x%lx to 0x%lx\n",
1469                    old, remote);
1470    }
1471
1472    if (!thr && plat_needsThreadForMemOps())
1473    {
1474       thr = findStoppedThread();
1475       if (!thr) {
1476          setLastError(err_notstopped, "A thread must be stopped to read from memory");
1477          perr_printf("Unable to find a stopped thread for read in process %d\n", getPid());
1478          return false;
1479       }
1480    }
1481
1482    result->setProcess(this);
1483    bool bresult;
1484
1485
1486    if (!plat_needsAsyncIO()) {
1487       pthrd_printf("Reading from remote memory %lx to %p, size = %lu on %d/%d\n",
1488                    remote, result->getBuffer(), (unsigned long) result->getSize(),
1489                                    getPid(), thr ? thr->getLWP() : (Dyninst::LWP)(-1));
1490
1491       bresult = plat_readMem(thr, result->getBuffer(), remote, result->getSize());
1492       if (!bresult) {
1493           perr_printf("plat_readMem failed!\n");
1494          result->markError();
1495       }
1496       result->setResponse();
1497
1498       int_eventAsyncIO *iev = result->getAsyncIOEvent();
1499       if (iev) {
1500          pthrd_printf("Enqueueing new EventAsyncRead into mailbox on synchronous platform\n");
1501          EventAsyncRead::ptr ev = EventAsyncRead::ptr(new EventAsyncRead(iev));
1502          ev->setProcess(proc());
1503          ev->setThread(threadPool()->initialThread()->thread());
1504          ev->setSyncType(Event::async);
1505          mbox()->enqueue(ev);
1506       }
1507    }
1508    else {
1509       pthrd_printf("Async read from remote memory %lx to %p, size = %lu on %d/%d\n",
1510                    remote, result->getBuffer(), (unsigned long) result->getSize(),
1511                    getPid(), thr ? thr->getLWP() : (Dyninst::LWP)(-1));
1512
1513       getResponses().lock();
1514       bresult = plat_readMemAsync(thr, remote, result);
1515       if (bresult) {
1516          getResponses().addResponse(result, this);
1517       }
1518       getResponses().unlock();
1519       getResponses().noteResponse();
1520    }
1521    return bresult;
1522 }
1523
1524 bool int_process::writeMem(const void *local, Dyninst::Address remote, size_t size, result_response::ptr result, int_thread *thr, bp_write_t bp_write)
1525 {
1526    if (getAddressWidth() == 4) {
1527       Address old = remote;
1528       remote &= 0xffffffff;
1529       pthrd_printf("Address cropping for 32-bit: 0x%lx to 0x%lx\n",
1530                    old, remote);
1531    }
1532
1533    if (!thr && plat_needsThreadForMemOps())
1534    {
1535       thr = findStoppedThread();
1536       if (!thr) {
1537          setLastError(err_notstopped, "A thread must be stopped to write to memory");
1538          perr_printf("Unable to find a stopped thread for write in process %d\n", getPid());
1539          return false;
1540       }
1541    }
1542    result->setProcess(this);
1543    bool bresult;
1544    if (!plat_needsAsyncIO()) {
1545       pthrd_printf("Writing to remote memory %lx from %p, size = %lu on %d/%d\n",
1546                    remote, local, (unsigned long) size,
1547                    getPid(), thr ? thr->getLWP() : (Dyninst::LWP)(-1));
1548       bresult = plat_writeMem(thr, local, remote, size, bp_write);
1549       if (!bresult) {
1550          result->markError();
1551       }
1552       result->setResponse(bresult);
1553
1554       int_eventAsyncIO *iev = result->getAsyncIOEvent();
1555       if (iev) {
1556          pthrd_printf("Enqueueing new EventAsyncWrite into mailbox on synchronous platform\n");
1557          EventAsyncWrite::ptr ev = EventAsyncWrite::ptr(new EventAsyncWrite(iev));
1558          ev->setProcess(proc());
1559          ev->setThread(threadPool()->initialThread()->thread());
1560          ev->setSyncType(Event::async);
1561          mbox()->enqueue(ev);
1562       }
1563    }
1564    else {
1565       pthrd_printf("Async writing to remote memory %lx from %p, size = %lu on %d/%d\n",
1566                    remote, local, (unsigned long) size,
1567                    getPid(), thr ? thr->getLWP() : (Dyninst::LWP)(-1));
1568
1569       getResponses().lock();
1570       bresult = plat_writeMemAsync(thr, local, remote, size, result, bp_write);
1571       if (bresult) {
1572          getResponses().addResponse(result, this);
1573       }
1574       getResponses().unlock();
1575       getResponses().noteResponse();
1576    }
1577    return bresult;
1578 }
1579
1580 unsigned int_process::plat_getRecommendedReadSize()
1581 {
1582    return getTargetPageSize();
1583 }
1584
1585 Dyninst::Address int_process::mallocExecMemory(unsigned size)
1586 {
1587    Dyninst::Address max = 0;
1588    std::map<Dyninst::Address, unsigned>::iterator i;
1589    for (i = exec_mem_cache.begin(); i != exec_mem_cache.end(); ++i) {
1590       if (i->first + i->second > max)
1591          max = i->first + i->second;
1592    }
1593
1594    Dyninst::Address addr = plat_mallocExecMemory(max, size);
1595    exec_mem_cache[addr] = size;
1596    return addr;
1597 }
1598
1599 void int_process::freeExecMemory(Dyninst::Address addr)
1600 {
1601    std::map<Dyninst::Address, unsigned>::iterator i;
1602    i = exec_mem_cache.find(addr);
1603    assert(i != exec_mem_cache.end());
1604    exec_mem_cache.erase(i);
1605 }
1606
1607 Dyninst::Address int_process::direct_infMalloc(unsigned long, bool, Dyninst::Address)
1608 {
1609    assert(0);
1610    return 0;
1611 }
1612
1613 bool int_process::direct_infFree(Dyninst::Address)
1614 {
1615    assert(0);
1616    return false;
1617 }
1618
1619 Address int_process::infMalloc(unsigned long size, bool use_addr, Address addr)
1620 {
1621    int_addressSet as;
1622    as.insert(make_pair(addr, proc()));
1623    bool result = int_process::infMalloc(size, &as, use_addr);
1624    if (!result)
1625       return 0;
1626    return as.begin()->first;
1627 }
1628
1629 bool int_process::infFree(Address addr) {
1630    int_addressSet as;
1631    as.insert(make_pair(addr, proc()));
1632    return int_process::infFree(&as);
1633 }
1634
1635 bool int_process::infMalloc(unsigned long size, int_addressSet *aset, bool use_addr)
1636 {
1637    bool had_error = false;
1638    set<pair<int_process *, int_iRPC::ptr> > active_mallocs;
1639    int_addressSet direct_results;
1640
1641    for (int_addressSet::iterator i = aset->begin(); i != aset->end(); i++) {
1642       Process::ptr p = i->second;
1643       Address addr = i->first;
1644       if (!p)
1645          continue;
1646       int_process *proc = p->llproc();
1647       if (proc->getState() == int_process::detached)
1648          continue;
1649       pthrd_printf("Process %d is allocating memory of size %lu at 0x%lx\n", proc->getPid(), size, addr);
1650
1651       if (proc->plat_supportDirectAllocation()) {
1652          //Platforms like Windows don't need IRPCs for allocation.  Just do it and put the results
1653          // in direct_results, which will be unioned with aset latter.
1654          Dyninst::Address addr_result = proc->direct_infMalloc(size, use_addr, addr);
1655          if (addr_result == 0) {
1656             had_error = true;
1657             continue;
1658          }
1659          direct_results.insert(make_pair(addr_result, p));
1660          continue;
1661       }
1662
1663       int_iRPC::ptr rpc = rpcMgr()->createInfMallocRPC(proc, size, use_addr, addr);
1664       assert(rpc);
1665       bool result = rpcMgr()->postRPCToProc(proc, rpc);
1666       if (!result) {
1667          p->setLastError(err_internal, "Error posting infMalloc RPC to process\n");
1668          pthrd_printf("Error posting RPC to thread");
1669          had_error = true;
1670          continue;
1671       }
1672
1673       int_thread *thr = rpc->thread();
1674       assert(thr);
1675       active_mallocs.insert(make_pair(proc, rpc));
1676       thr->getInternalState().desyncState(int_thread::running);
1677       rpc->setRestoreInternal(true);
1678       proc->throwNopEvent();
1679    }
1680
1681    if (!active_mallocs.empty()) {
1682       bool result = int_process::waitAndHandleEvents(false);
1683       if (!result) {
1684          perr_printf("Internal error calling waitAndHandleEvents\n");
1685          for_each(aset->begin(), aset->end(),
1686                   setError(err_internal, "Error while calling waitAndHandleForProc from infMalloc\n"));
1687          return false;
1688       }
1689    }
1690
1691    if (!use_addr)
1692       aset->clear();
1693    if (!direct_results.empty())
1694       aset->insert(direct_results.begin(), direct_results.end());
1695
1696
1697    for (set<pair<int_process *, int_iRPC::ptr> >::iterator i = active_mallocs.begin();
1698         i != active_mallocs.end(); i++)
1699    {
1700       int_process *proc = i->first;
1701       int_iRPC::ptr rpc = i->second;
1702       assert(rpc->getState() == int_iRPC::Finished);
1703       Dyninst::Address aresult = rpc->infMallocResult();
1704       pthrd_printf("Inferior malloc returning %lx on %d\n", aresult, proc->getPid());
1705       if (aresult == (unsigned long) -1) {
1706          perr_printf("infMalloc returned invalid address\n");
1707          proc->setLastError(err_procread, "Unable to allocate memory at given address");
1708          had_error = true;
1709          continue;
1710       }
1711       proc->memory()->inf_malloced_memory.insert(make_pair(aresult, size));
1712       if (use_addr)
1713          continue;
1714       aset->insert(make_pair(aresult, proc->proc()));
1715    }
1716
1717    return !had_error;
1718 }
1719
1720 bool int_process::infFree(int_addressSet *aset)
1721 {
1722    bool had_error = false;
1723    set<pair<Process::ptr, int_iRPC::ptr> > active_frees;
1724
1725    for (int_addressSet::iterator i = aset->begin(); i != aset->end(); i++) {
1726       Address addr = i->first;
1727       Process::ptr p = i->second;
1728       if (!p) {
1729          had_error = true;
1730          continue;
1731       }
1732       int_process *proc = p->llproc();
1733       if (!proc || proc->getState() == int_process::detached) {
1734          had_error = true;
1735          continue;
1736       }
1737
1738       std::map<Dyninst::Address, unsigned long>::iterator j = proc->mem->inf_malloced_memory.find(addr);
1739       if (j == proc->mem->inf_malloced_memory.end()) {
1740          proc->setLastError(err_badparam, "Unknown address passed to freeMemory");
1741          perr_printf("Passed bad address, %lx, to infFree on %d\n", addr, proc->getPid());
1742          had_error = true;
1743          continue;
1744       }
1745       unsigned long size = j->second;
1746
1747       if (proc->plat_supportDirectAllocation()) {
1748          bool result = proc->direct_infFree(addr);
1749          if (!result)
1750             had_error = true;
1751          continue;
1752       }
1753
1754       int_iRPC::ptr rpc = rpcMgr()->createInfFreeRPC(proc, size, addr);
1755       assert(rpc);
1756       pthrd_printf("Process %d is freeing memory of size %lu at 0x%lx with rpc %lu\n", proc->getPid(),
1757                    size, addr, rpc->id());
1758       bool result = rpcMgr()->postRPCToProc(proc, rpc);
1759       if (!result) {
1760          pthrd_printf("Failed to post free rpc to process\n");
1761          had_error = true;
1762          continue;
1763       }
1764
1765       int_thread *thr = rpc->thread();
1766       assert(thr);
1767       thr->getInternalState().desyncState(int_thread::running);
1768       rpc->setRestoreInternal(true);
1769
1770       proc->throwNopEvent();
1771       active_frees.insert(make_pair(p, rpc));
1772    }
1773
1774    if (!active_frees.empty()) {
1775       bool result = int_process::waitAndHandleEvents(false);
1776       if (!result) {
1777          perr_printf("Internal error calling waitAndHandleEvents\n");
1778          for_each(aset->begin(), aset->end(),
1779                   setError(err_internal, "Error while calling waitAndHandleForProc from infFree\n"));
1780          return false;
1781       }
1782    }
1783
1784    for (set<pair<Process::ptr, int_iRPC::ptr> >::iterator i = active_frees.begin(); i != active_frees.end(); i++) {
1785       Process::ptr p = i->first;
1786       int_iRPC::ptr rpc = i->second;
1787       int_process *proc = p->llproc();
1788
1789       if (!proc) {
1790          perr_printf("Process %d exited during infFree\n", p->getPid());
1791          p->setLastError(err_exited, "Process exited during infFree\n");
1792          had_error = true;
1793          continue;
1794       }
1795       assert(rpc->getState() == int_iRPC::Finished);
1796       Address addr = rpc->getInfFreeTarget();
1797       map<Dyninst::Address, unsigned long>::iterator j = proc->mem->inf_malloced_memory.find(addr);
1798       proc->mem->inf_malloced_memory.erase(j);
1799    }
1800
1801    return !had_error;
1802 }
1803
1804 bool int_process::plat_decodeMemoryRights(Process::mem_perm& rights_internal,
1805                                           unsigned long rights) {
1806     (void)rights_internal;
1807     (void)rights;
1808     perr_printf("Called decodeMemoryRights on unspported platform\n");
1809     setLastError(err_unsupported, "Decode Mem Permission not supported on this platform\n");
1810         return false;
1811 }
1812
1813 bool int_process::plat_encodeMemoryRights(Process::mem_perm rights_internal,
1814                                           unsigned long& rights) {
1815     (void)rights_internal;
1816     (void)rights;
1817     perr_printf("Called encodeMemoryRights on unspported platform\n");
1818     setLastError(err_unsupported, "Encode Memory Permission not supported on this platform\n");
1819         return false;
1820 }
1821
1822 bool int_process::getMemoryAccessRights(Dyninst::Address addr, Process::mem_perm& rights) {
1823     if (!plat_getMemoryAccessRights(addr, rights)) {
1824         pthrd_printf("Error get rights from memory %lx on target process %d\n",
1825                      addr, getPid());
1826         return false;
1827     }
1828
1829     return true;
1830 }
1831
1832 bool int_process::plat_getMemoryAccessRights(Dyninst::Address addr, Process::mem_perm& rights) {
1833     (void)addr;
1834     (void)rights;
1835     perr_printf("Called getMemoryAccessRights on unspported platform\n");
1836     setLastError(err_unsupported, "Get Memory Permission not supported on this platform\n");
1837         return false;
1838 }
1839
1840 bool int_process::setMemoryAccessRights(Dyninst::Address addr, size_t size,
1841                                         Process::mem_perm rights,
1842                                         Process::mem_perm& oldRights) {
1843     if (!plat_setMemoryAccessRights(addr, size, rights, oldRights)) {
1844         pthrd_printf("ERROR: set rights to %s from memory %lx on target process %d\n",
1845                      rights.getPermName().c_str(), addr, getPid());
1846         return false;
1847     }
1848
1849     return true;
1850 }
1851
1852 bool int_process::plat_setMemoryAccessRights(Dyninst::Address addr, size_t size,
1853                                              Process::mem_perm rights,
1854                                              Process::mem_perm& oldRights) {
1855     (void)addr;
1856     (void)size;
1857     (void)rights;
1858     (void)oldRights;
1859     perr_printf("Called setMemoryAccessRights on unspported platform\n");
1860     setLastError(err_unsupported, "Set Memory Permission not supported on this platform\n");
1861         return false;
1862 }
1863
1864 bool int_process::findAllocatedRegionAround(Dyninst::Address addr,
1865                                             Process::MemoryRegion& memRegion) {
1866     if (!plat_findAllocatedRegionAround(addr, memRegion)) {
1867         pthrd_printf("Error when find allocated memory region"
1868                      " for %lx on target process %d\n", addr, getPid());
1869         return false;
1870     }
1871
1872     return true;
1873 }
1874
1875 bool int_process::plat_findAllocatedRegionAround(Dyninst::Address addr,
1876                                                  Process::MemoryRegion& memRegion) {
1877     (void)addr;
1878     memRegion.first  = 0;
1879     memRegion.second = 0;
1880     perr_printf("Called findAllocatedRegionAround on unspported platform\n");
1881     setLastError(err_unsupported,
1882                  "Find Allocated Region Addr not supported on this platform\n");
1883         return false;
1884 }
1885
1886 SymbolReaderFactory *int_process::getSymReader()
1887 {
1888    if (symbol_reader) {
1889       return symbol_reader;
1890    }
1891    else if (user_set_symbol_reader) {
1892       symbol_reader = user_set_symbol_reader;
1893       return symbol_reader;
1894    }
1895    symbol_reader = plat_defaultSymReader();
1896    return symbol_reader;
1897 }
1898
1899 void int_process::setSymReader(SymbolReaderFactory *fact)
1900 {
1901    symbol_reader = fact;
1902 }
1903
1904 SymbolReaderFactory *int_process::plat_defaultSymReader()
1905 {
1906    //Default version of function for systems without symbol readers
1907    return NULL;
1908 }
1909
1910 void int_process::setForceGeneratorBlock(bool b)
1911 {
1912    if (b) {
1913       force_generator_block_count.inc();
1914    }
1915    else {
1916       if (force_generator_block_count.local())
1917          force_generator_block_count.dec();
1918    }
1919
1920    pthrd_printf("forceGeneratorBlock - Count is now %d/%d\n",
1921                 force_generator_block_count.localCount(),
1922                 Counter::globalCount(Counter::ForceGeneratorBlock));
1923 }
1924
1925 int int_process::getAddressWidth()
1926 {
1927    switch (getTargetArch()) {
1928       case Arch_x86:
1929       case Arch_ppc32:
1930       case Arch_aarch32:
1931          return 4;
1932       case Arch_x86_64:
1933       case Arch_ppc64:
1934       case Arch_aarch64:
1935          return 8;
1936       case Arch_none:
1937          assert(0);
1938    }
1939    return 0;
1940 }
1941
1942 HandlerPool *int_process::handlerPool() const
1943 {
1944    return handlerpool;
1945 }
1946
1947 bool int_process::addBreakpoint_phase1(bp_install_state *is)
1948 {
1949    is->ibp = NULL;
1950    map<Address, sw_breakpoint *>::iterator i = mem->breakpoints.find(is->addr);
1951    is->do_install = (i == mem->breakpoints.end());
1952    if (!is->do_install) {
1953      is->ibp = i->second;
1954      assert(is->ibp && is->ibp->isInstalled());
1955      bool result = is->ibp->addToIntBreakpoint(is->bp, this);
1956      if (!result) {
1957        pthrd_printf("Failed to install new breakpoint\n");
1958        return false;
1959      }
1960      return true;
1961    }
1962
1963    is->ibp = new sw_breakpoint(mem, is->addr);
1964
1965    if (!is->ibp->checkBreakpoint(is->bp, this)) {
1966       pthrd_printf("Failed check breakpoint\n");
1967       delete is->ibp;
1968       is->ibp = NULL;
1969       return false;
1970    }
1971
1972    is->mem_resp = mem_response::createMemResponse();
1973    is->mem_resp->markSyncHandled();
1974    bool result = is->ibp->prepBreakpoint(this, is->mem_resp);
1975    if (!result) {
1976       pthrd_printf("Failed to prep breakpoint\n");
1977       delete is->ibp;
1978       return false;
1979    }
1980    return true;
1981 }
1982
1983 bool int_process::addBreakpoint_phase2(bp_install_state *is)
1984 {
1985    if (!is->do_install)
1986       return true;
1987
1988    if (is->mem_resp->hasError()) {
1989       pthrd_printf("Error prepping breakpoint\n");
1990       delete is->ibp;
1991       return false;
1992    }
1993
1994    is->res_resp = result_response::createResultResponse();
1995    is->res_resp->markSyncHandled();
1996    bool result = is->ibp->insertBreakpoint(this, is->res_resp);
1997    if (!result) {
1998       pthrd_printf("Error writing new breakpoint\n");
1999       delete is->ibp;
2000       return false;
2001    }
2002    return true;
2003 }
2004
2005 bool int_process::addBreakpoint_phase3(bp_install_state *is)
2006 {
2007    if (!is->do_install)
2008       return true;
2009
2010    bool result = is->ibp->addToIntBreakpoint(is->bp, this);
2011    if (!result) {
2012       pthrd_printf("Failed to install new breakpoint\n");
2013       return false;
2014    }
2015
2016    if (is->res_resp->hasError()) {
2017       pthrd_printf("Error writing new breakpoint\n");
2018       delete is->ibp;
2019       return false;
2020    }
2021
2022    return true;
2023 }
2024
2025 bool int_process::addBreakpoint(Dyninst::Address addr, int_breakpoint *bp)
2026 {
2027    if (getState() != running) {
2028       perr_printf("Attempted to add breakpoint at %lx to exited process %d\n", addr, getPid());
2029       setLastError(err_exited, "Attempted to insert breakpoint into exited process\n");
2030       return false;
2031    }
2032
2033    bp_instance *instance = NULL;
2034    if (bp->isHW()) {
2035       instance = hw_breakpoint::create(this, bp, addr);
2036    }
2037    else {
2038       instance = sw_breakpoint::create(this, bp, addr);
2039    }
2040    return (instance != NULL);
2041 }
2042
2043 bool int_process::removeAllBreakpoints() {
2044    if (!mem) return true;
2045    bool ret = true;
2046
2047    for (std::map<Dyninst::Address, sw_breakpoint *>::iterator iter = mem->breakpoints.begin();
2048         iter != mem->breakpoints.end(); ++iter) {
2049       std::set<response::ptr> resps;
2050       if (!iter->second->uninstall(this, resps)) ret = false;
2051       assert(resps.empty());
2052    }
2053    return ret;
2054 }
2055
2056 bool int_process::removeBreakpoint(Dyninst::Address addr, int_breakpoint *bp, set<response::ptr> &resps)
2057 {
2058    pthrd_printf("Removing breakpoint at %lx in %d\n", addr, getPid());
2059    set<bp_instance *> bps_to_remove;
2060    map<Address, sw_breakpoint *>::iterator i = mem->breakpoints.find(addr);
2061    if (i != mem->breakpoints.end()) {
2062       sw_breakpoint *swbp = i->second;
2063       assert(swbp && swbp->isInstalled());
2064       if (swbp->containsIntBreakpoint(bp))
2065           bps_to_remove.insert(static_cast<bp_instance *>(swbp));
2066    }
2067
2068    for (int_threadPool::iterator i = threadPool()->begin(); i != threadPool()->end(); i++) {
2069       int_thread *thr = *i;
2070       hw_breakpoint *hwbp = thr->getHWBreakpoint(addr);
2071       if (hwbp && hwbp->containsIntBreakpoint(bp)) {
2072          bps_to_remove.insert(static_cast<bp_instance *>(hwbp));
2073       }
2074    }
2075
2076    if (bps_to_remove.empty()) {
2077       perr_printf("Attempted to removed breakpoint that isn't installed\n");
2078       setLastError(err_notfound, "Tried to uninstall breakpoint that isn't installed.\n");
2079       return false;
2080    }
2081
2082    for (set<bp_instance *>::iterator i = bps_to_remove.begin(); i != bps_to_remove.end(); i++) {
2083       bool empty;
2084       bp_instance *ibp = *i;
2085       bool result = ibp->rmBreakpoint(this, bp, empty, resps);
2086       if (!result) {
2087          pthrd_printf("rmBreakpoint failed on breakpoint at %lx in %d\n", addr, getPid());
2088          return false;
2089       }
2090       if (empty) {
2091          delete ibp;
2092       }
2093    }
2094
2095    return true;
2096 }
2097
2098 sw_breakpoint *int_process::getBreakpoint(Dyninst::Address addr)
2099 {
2100    std::map<Dyninst::Address, sw_breakpoint *>::iterator  i = mem->breakpoints.find(addr);
2101    if (i == mem->breakpoints.end())
2102       return NULL;
2103    return i->second;
2104 }
2105
2106 int_library *int_process::getLibraryByName(std::string s) const
2107 {
2108         // Exact matches first, but find substring matches and return if unique.
2109         // TODO: is this the behavior we actually want?
2110         bool substring_unique = true;
2111         std::set<int_library*>::iterator substring_match = mem->libs.end();
2112    for (set<int_library *>::iterator i = mem->libs.begin();
2113         i != mem->libs.end(); ++i)
2114    {
2115            std::string n = (*i)->getName();
2116       if (s == n)
2117          return *i;
2118           if((n.find(s) != std::string::npos)) {
2119                   if(substring_match == mem->libs.end()) {
2120                         substring_match = i;
2121                   }
2122                   else {
2123                         substring_unique = false;
2124                   }
2125           }
2126    }
2127         if(substring_match != mem->libs.end() && substring_unique)
2128         {
2129                 return *substring_match;
2130         }
2131    return NULL;
2132 }
2133
2134 unsigned int int_process::plat_getCapabilities()
2135 {
2136    return (Process::pc_read | Process::pc_write | Process::pc_irpc | Process::pc_control);
2137 }
2138
2139 Event::ptr int_process::plat_throwEventsBeforeContinue(int_thread *)
2140 {
2141    return Event::ptr();
2142 }
2143
2144 bool int_process::plat_threadOpsNeedProcStop()
2145 {
2146    return false;
2147 }
2148
2149 size_t int_process::numLibs() const
2150 {
2151    return mem->libs.size();
2152 }
2153
2154 std::string int_process::getExecutable() const
2155 {
2156    return executable; //The name of the exec passed to PC
2157 }
2158
2159 bool int_process::isInCallback()
2160 {
2161    return in_callback;
2162 }
2163
2164 mem_state::ptr int_process::memory() const
2165 {
2166    return mem;
2167 }
2168
2169 err_t int_process::getLastError() {
2170    return last_error;
2171 }
2172
2173 const char *int_process::getLastErrorMsg() {
2174    return last_error_string;
2175 }
2176
2177 void int_process::clearLastError() {
2178    last_error = err_none;
2179    last_error_string = "ok";
2180 }
2181
2182 void int_process::setLastError(err_t err, const char *str) {
2183    last_error = err;
2184    last_error_string = str;
2185    ProcControlAPI::globalSetLastError(err, str);
2186 }
2187
2188 void int_process::setExitCode(int c)
2189 {
2190    assert(!hasCrashSignal);
2191    hasExitCode = true;
2192    exitCode = c;
2193 }
2194
2195 void int_process::setCrashSignal(int s)
2196 {
2197    assert(!hasExitCode);
2198    hasCrashSignal = true;
2199    crashSignal = s;
2200 }
2201
2202 bool int_process::getExitCode(int &c)
2203 {
2204    c = exitCode;
2205    return hasExitCode;
2206 }
2207
2208 bool int_process::getCrashSignal(int &s)
2209 {
2210    s = crashSignal;
2211    return hasCrashSignal;
2212 }
2213
2214 bool int_process::wasForcedTerminated() const
2215 {
2216    return forcedTermination;
2217 }
2218
2219 bool int_process::plat_individualRegRead(Dyninst::MachRegister, int_thread *)
2220 {
2221    return plat_individualRegAccess();
2222 }
2223
2224 bool int_process::plat_individualRegSet()
2225 {
2226    return plat_individualRegAccess();
2227 }
2228
2229 bool int_process::isInCB()
2230 {
2231    return in_callback;
2232 }
2233
2234 void int_process::setInCB(bool b)
2235 {
2236    assert(in_callback == !b);
2237    in_callback = b;
2238 }
2239
2240 void int_process::throwNopEvent()
2241 {
2242    EventNop::ptr ev = EventNop::ptr(new EventNop());
2243    ev->setProcess(proc());
2244    ev->setThread(threadPool()->initialThread()->thread());
2245    ev->setSyncType(Event::async);
2246
2247    mbox()->enqueue(ev);
2248 }
2249
2250 async_ret_t int_process::plat_calcTLSAddress(int_thread *, int_library *, Offset,
2251                                              Address &, std::set<response::ptr> &)
2252 {
2253    perr_printf("Unsupported access to plat_calcTLSAddress\n");
2254    setLastError(err_unsupported, "TLS Access not supported on this platform\n");
2255    return aret_error;
2256 }
2257
2258 bool int_process::plat_needsAsyncIO() const
2259 {
2260    return false;
2261 }
2262
2263 bool int_process::plat_readMemAsync(int_thread *, Dyninst::Address,
2264                                     mem_response::ptr )
2265 {
2266    assert(0);
2267    return false;
2268 }
2269
2270 bool int_process::plat_writeMemAsync(int_thread *, const void *, Dyninst::Address,
2271                                      size_t, result_response::ptr, bp_write_t)
2272 {
2273    assert(0);
2274    return false;
2275 }
2276
2277 memCache *int_process::getMemCache()
2278 {
2279    return &mem_cache;
2280 }
2281
2282 void int_process::updateSyncState(Event::ptr ev, bool gen)
2283 {
2284    // This works around a Linux bug where a continue races with a whole-process exit
2285    plat_adjustSyncType(ev, gen);
2286
2287    EventType etype = ev->getEventType();
2288    switch (ev->getSyncType()) {
2289           case Event::async: {
2290          break;
2291      }
2292       case Event::sync_thread: {
2293          int_thread *thrd = ev->getThread()->llthrd();
2294          int_thread::StateTracker &st = gen ? thrd->getGeneratorState() : thrd->getHandlerState();
2295          if (!thrd) {
2296             pthrd_printf("No thread for sync thread event, assuming thread exited\n");
2297             return;
2298          }
2299          int_thread::State old_state = st.getState();
2300          if (old_state == int_thread::exited) {
2301             //Silly, linux.  Giving us events on processes that have exited.
2302             pthrd_printf("Recieved events for exited thread, not changing thread state\n");
2303             break;
2304          }
2305          pthrd_printf("Event %s is thread synchronous, marking thread %d %s stopped\n",
2306                       etype.name().c_str(), thrd->getLWP(), gen ? "generator" : "handler");
2307          assert(RUNNING_STATE(old_state) ||
2308                 thrd->llproc()->wasForcedTerminated() ||
2309                 (old_state == int_thread::stopped && (thrd->isExiting() || thrd->isExitingInGenerator())));
2310          if (old_state == int_thread::errorstate)
2311             break;
2312          st.setState(int_thread::stopped);
2313          break;
2314       }
2315       case Event::sync_process: {
2316          pthrd_printf("Event %s is process synchronous, marking process %d %s stopped\n",
2317                       etype.name().c_str(), getPid(), gen ? "generator" : "handler");
2318          int_threadPool *tp = threadPool();
2319          for (int_threadPool::iterator i = tp->begin(); i != tp->end(); ++i) {
2320             int_thread *thrd = *i;
2321             int_thread::StateTracker &st = gen ? thrd->getGeneratorState() : thrd->getHandlerState();
2322             int_thread::State old_state = st.getState();
2323             if (!RUNNING_STATE(old_state))
2324                continue;
2325             st.setState(int_thread::stopped);
2326          }
2327          break;
2328       }
2329       case Event::unset: {
2330          assert(0);
2331       }
2332    }
2333 }
2334
2335 ProcStopEventManager &int_process::getProcStopManager()
2336 {
2337    return proc_stop_manager;
2338 }
2339
2340 bool int_process::plat_supportThreadEvents()
2341 {
2342    return false;
2343 }
2344
2345 bool int_process::plat_supportLWPCreate()
2346 {
2347    return false;
2348 }
2349
2350 bool int_process::plat_supportLWPPreDestroy()
2351 {
2352    return false;
2353 }
2354
2355 bool int_process::plat_supportLWPPostDestroy()
2356 {
2357    return false;
2358 }
2359
2360 bool int_process::plat_supportHWBreakpoint()
2361 {
2362    return false;
2363 }
2364
2365 bool int_process::plat_supportFork()
2366 {
2367    return false;
2368 }
2369
2370 bool int_process::plat_supportExec()
2371 {
2372    return false;
2373 }
2374
2375 async_ret_t int_process::plat_needsEmulatedSingleStep(int_thread *, std::vector<Address> &) {
2376    return aret_success;
2377 }
2378
2379 void int_process::plat_getEmulatedSingleStepAsyncs(int_thread *, std::set<response::ptr>) {
2380    assert(0);
2381 }
2382
2383 bool int_process::plat_needsPCSaveBeforeSingleStep()
2384 {
2385    return false;
2386 }
2387
2388 map<int, int> &int_process::getProcDesyncdStates()
2389 {
2390    return proc_desyncd_states;
2391 }
2392
2393 bool int_process::isRunningSilent()
2394 {
2395    return silent_mode;
2396 }
2397
2398 void int_process::setRunningSilent(bool b)
2399 {
2400    silent_mode = b;
2401 }
2402
2403 bool int_process::plat_supportDOTF()
2404 {
2405    return true;
2406 }
2407
2408 void int_process::noteNewDequeuedEvent(Event::ptr)
2409 {
2410 }
2411
2412 bool int_process::plat_preHandleEvent()
2413 {
2414    return true;
2415 }
2416
2417 bool int_process::plat_postHandleEvent()
2418 {
2419    return true;
2420 }
2421
2422 bool int_process::plat_preAsyncWait()
2423 {
2424   return true;
2425 }
2426
2427 int_process::~int_process()
2428 {
2429    pthrd_printf("Deleting int_process at %p\n", this);
2430    if (up_proc != Process::ptr())
2431    {
2432       proc_exitstate *exitstate = new proc_exitstate();
2433       exitstate->pid = pid;
2434       exitstate->exited = hasExitCode && !forcedTermination;
2435       exitstate->exit_code = exitCode;
2436       exitstate->crashed = hasCrashSignal;
2437       exitstate->crash_signal = crashSignal;
2438       exitstate->user_data = user_data;
2439       assert(!up_proc->exitstate_);
2440       up_proc->exitstate_ = exitstate;
2441       up_proc->llproc_ = NULL;
2442    }
2443
2444    if (threadpool) {
2445       delete threadpool;
2446       threadpool = NULL;
2447    }
2448
2449    //Do not delete handlerpool yet, we're currently under
2450    // an event handler.  We do want to delete this if called
2451    // from detach.
2452    bool should_clean;
2453    mem->rmProc(this, should_clean);
2454    if (should_clean) {
2455       delete mem;
2456    }
2457    mem = NULL;
2458
2459    if(ProcPool()->findProcByPid(getPid())) ProcPool()->rmProcess(this);
2460 }
2461
2462 indep_lwp_control_process::indep_lwp_control_process(Dyninst::PID p, std::string e, std::vector<std::string> a,
2463                                                      std::vector<std::string> envp, std::map<int,int> f) :
2464    int_process(p, e, a, envp, f)
2465 {
2466 }
2467
2468 indep_lwp_control_process::indep_lwp_control_process(Dyninst::PID pid_, int_process *p) :
2469    int_process(pid_, p)
2470 {
2471 }
2472
2473 bool indep_lwp_control_process::plat_syncRunState()
2474 {
2475    for (int_threadPool::iterator i = threadPool()->begin(); i != threadPool()->end(); i++) {
2476       int_thread *thr = *i;
2477       int_thread::State handler_state = thr->getHandlerState().getState();
2478       int_thread::State target_state = thr->getTargetState();
2479       bool result = true;
2480
2481       if (handler_state == target_state) {
2482          continue;
2483       }
2484       else if (handler_state == int_thread::stopped && RUNNING_STATE(target_state)) {
2485          result = thr->intCont();
2486       }
2487       else if (RUNNING_STATE(handler_state) && target_state == int_thread::stopped) {
2488          result = thr->intStop();
2489       }
2490       if (!result && getLastError() == err_exited) {
2491          pthrd_printf("Suppressing error of continue on exited process\n");
2492          pthrd_printf("TESTING: setting handler to running anyway\n");
2493          thr->getHandlerState().setState(int_thread::running);
2494       }
2495       else if (!result) {
2496          pthrd_printf("Error changing process state from plat_syncRunState\n");
2497          return false;
2498       }
2499    }
2500    return true;
2501 }
2502
2503 indep_lwp_control_process::~indep_lwp_control_process()
2504 {
2505 }
2506
2507 unified_lwp_control_process::unified_lwp_control_process(Dyninst::PID p, std::string e,
2508                                                          std::vector<std::string> a,
2509                                                          std::vector<std::string> envp,
2510                                                          std::map<int,int> f) :
2511    int_process(p, e, a, envp, f)
2512 {
2513 }
2514
2515 unified_lwp_control_process::unified_lwp_control_process(Dyninst::PID pid_, int_process *p) :
2516    int_process(pid_, p)
2517 {
2518 }
2519
2520 unified_lwp_control_process::~unified_lwp_control_process()
2521 {
2522 }
2523
2524 bool unified_lwp_control_process::plat_syncRunState()
2525 {
2526    bool want_ss_running = false;
2527    bool result = true;
2528
2529    bool want_all_stopped = true;
2530    bool want_all_running = true;
2531    bool want_some_stopped = false;
2532    bool want_some_running = false;
2533
2534    bool is_all_stopped = true;
2535    bool is_all_running = true;
2536
2537    if (getState() == detached || getState() == exited || getState() == errorstate) {
2538       pthrd_printf("Process %d is in state %s, doing nothing in plat_syncRunState\n",
2539                    getPid(), int_process::stateName(getState()));
2540       return true;
2541    }
2542
2543    for (int_threadPool::iterator i = threadPool()->begin(); i != threadPool()->end(); i++) {
2544       int_thread *thr = *i;
2545       int_thread::State handler_state = thr->getHandlerState().getState();
2546       int_thread::State target_state = thr->getTargetState();
2547       if (target_state == int_thread::ditto)
2548          target_state = thr->getHandlerState().getState();
2549
2550       if (RUNNING_STATE(target_state)) {
2551          want_some_running = true;
2552          want_all_stopped = false;
2553       }
2554       else if (target_state == int_thread::stopped) {
2555          want_some_stopped = true;
2556          want_all_running = false;
2557       }
2558       else {
2559          want_all_stopped = false;
2560          want_all_running = false;
2561       }
2562
2563       if (RUNNING_STATE(handler_state)) {
2564          is_all_stopped = false;
2565       }
2566       else if (handler_state == int_thread::stopped) {
2567          is_all_running = false;
2568       }
2569       else {
2570          is_all_stopped = false;
2571          is_all_running = false;
2572       }
2573
2574       if (!RUNNING_STATE(handler_state) && RUNNING_STATE(target_state) && thr->singleStep()) {
2575          want_ss_running = true;
2576       }
2577    }
2578
2579    pthrd_printf("In plat_syncRunState: want_all_stopped = %s, want_all_running = %s, want_some_stopped = %s, want_some_running = %s, is_all_stopped = %s, is_all_running = %s, want_ss_running = %s\n",
2580                 want_all_stopped ? "t" : "f",
2581                 want_all_running ? "t" : "f",
2582                 want_some_stopped ? "t" : "f",
2583                 want_some_running ? "t" : "f",
2584                 is_all_stopped ? "t" : "f",
2585                 is_all_running ? "t" : "f",
2586                 want_ss_running ? "t" : "f");
2587
2588    if (want_ss_running) {
2589       pthrd_printf("Process %d is single-stepping.  Continuing select threads\n", getPid());
2590       for (int_threadPool::iterator i = threadPool()->begin(); i != threadPool()->end(); i++) {
2591          int_thread *thr = *i;
2592          if (thr->singleStep() && thr->getHandlerState().getState() == int_thread::stopped &&
2593              RUNNING_STATE(thr->getTargetState()))
2594          {
2595             bool tresult = thr->intCont();
2596             if (!tresult) {
2597                pthrd_printf("plat_syncRunState single-step failed on %d/%d\n", getPid(), thr->getLWP());
2598                result = false;
2599             }
2600          }
2601       }
2602    }
2603    else if (want_all_running && is_all_running) {
2604       pthrd_printf("Process %d is running, needs to run.  Doing nothing\n", getPid());
2605    }
2606    else if (want_all_running && is_all_stopped) {
2607       pthrd_printf("Process %d is stopped, needs to run.  Continuing process\n", getPid());
2608       result = threadPool()->initialThread()->intCont();
2609    }
2610    else if (want_all_stopped && is_all_running) {
2611       pthrd_printf("Process %d is running, needs to stop.  Stopping process\n", getPid());
2612       result = threadPool()->initialThread()->intStop();
2613    }
2614    else if (want_all_stopped && is_all_stopped) {
2615       pthrd_printf("Process %d is stopped, needs to stop.  Doing nothing\n", getPid());
2616    }
2617    else if (want_some_stopped && !is_all_stopped) {
2618       pthrd_printf("Process %d is partially stopped, needs to stop.  Stopping process\n", getPid());
2619       result = threadPool()->initialThread()->intStop();
2620    }
2621    else if (want_some_running && !is_all_running) {
2622       pthrd_printf("Process %d is partially running, needs to run.  Continuing process\n", getPid());
2623       result = threadPool()->initialThread()->intCont();
2624    }
2625    else {
2626       pthrd_printf("Process %d is in startup or teardown state.  Doing nothing\n", getPid());
2627    }
2628
2629    if (!result) {
2630       pthrd_printf("plat_syncRunState operation failed.  Returning false\n");
2631       return false;
2632    }
2633
2634    return true;
2635 }
2636
2637 bool unified_lwp_control_process::plat_processGroupContinues()
2638 {
2639    return true;
2640 }
2641
2642 hybrid_lwp_control_process::hybrid_lwp_control_process(Dyninst::PID p, std::string e,
2643                                                          std::vector<std::string> a,
2644                                                          std::vector<std::string> envp,
2645                                                          std::map<int,int> f) :
2646   int_process(p, e, a, envp, f),
2647   debugger_stopped(false)
2648 {
2649 }
2650
2651 hybrid_lwp_control_process::hybrid_lwp_control_process(Dyninst::PID pid_, int_process *p) :
2652   int_process(pid_, p),
2653   debugger_stopped(false)
2654 {
2655   // Clone debugger_stopped from parent
2656   hybrid_lwp_control_process *par = dynamic_cast<hybrid_lwp_control_process *>(p);
2657   assert(par); // Otherwise we have a very, very strange system
2658   debugger_stopped = par->debugger_stopped;
2659   pthrd_printf("Set debugger stopped to %s on %d, matching parent %d\n",
2660                (debugger_stopped ? "true" : "false"),
2661                pid_,
2662                p->getPid());
2663
2664 }
2665
2666 hybrid_lwp_control_process::~hybrid_lwp_control_process()
2667 {
2668 }
2669
2670 bool hybrid_lwp_control_process::suspendThread(int_thread *thr)
2671 {
2672    if (thr->isSuspended())
2673       return true;
2674
2675    bool result = plat_suspendThread(thr);
2676    if (!result)
2677       return false;
2678    thr->setSuspended(true);
2679    return true;
2680 }
2681
2682 bool hybrid_lwp_control_process::resumeThread(int_thread *thr)
2683 {
2684    if (!thr->isSuspended())
2685       return true;
2686
2687    bool result = plat_resumeThread(thr);
2688    if (!result)
2689       return false;
2690    thr->setSuspended(false);
2691    return true;
2692 }
2693
2694 bool hybrid_lwp_control_process::plat_processGroupContinues()
2695 {
2696    return true;
2697 }
2698
2699 void hybrid_lwp_control_process::noteNewDequeuedEvent(Event::ptr ev)
2700 {
2701    if (ev->getSyncType() == Event::sync_process) {
2702            pthrd_printf("Marking %d debugger suspended on event: %s\n", getPid(), ev->name().c_str());
2703       debugger_stopped = true;
2704       pthrd_printf("Setting, debugger stopped: %d (%p) (%d)\n", debugger_stopped, this, getPid());
2705    }
2706 }
2707
2708 bool hybrid_lwp_control_process::plat_debuggerSuspended()
2709 {
2710   pthrd_printf("Querying, debugger stopped: %d (%p) (%p) (%d)\n", debugger_stopped, &debugger_stopped, this, getPid());
2711    return debugger_stopped;
2712 }
2713
2714 bool hybrid_lwp_control_process::plat_syncRunState()
2715 {
2716    bool any_target_stopped = false, any_target_running = false;
2717    bool any_stopped = false, any_running = false;
2718
2719    int_thread *a_running_thread = NULL;
2720
2721    if (getState() == exited) {
2722       pthrd_printf("Returning from plat_syncRunState for exited process %d\n", getPid());
2723       return true;
2724    }
2725
2726    int_threadPool *tp = threadPool();
2727    int_threadPool::iterator i;
2728    for (i = tp->begin(); i != tp->end(); i++) {
2729       int_thread *thr = *i;
2730       pthrd_printf("Checking %d/%d: state %s\n", getPid(), thr->getLWP(), int_thread::stateStr(thr->getUserState().getState()));
2731 #if defined(os_freebsd)
2732            if (thr->getUserState().getState() == int_thread::exited) {
2733              // Let it go, man...
2734              continue;
2735            }
2736 #endif
2737            if (thr->getDetachState().getState() == int_thread::detached) {
2738              pthrd_printf("%d/%d detached, skipping\n", getPid(), thr->getLWP());
2739              continue;
2740            }
2741            if (!RUNNING_STATE(thr->getHandlerState().getState())) {
2742              pthrd_printf("%d/%d not running, any_stopped = true\n", getPid(), thr->getLWP());
2743              any_stopped = true;
2744            } else {
2745              pthrd_printf("%d/%d running, any_running = true\n", getPid(), thr->getLWP());
2746              any_running = true;
2747              if (!a_running_thread) a_running_thread = thr;
2748            }
2749            if (RUNNING_STATE(thr->getTargetState())) {
2750              pthrd_printf("%d/%d target running, any_target_running = true\n", getPid(), thr->getLWP());
2751              any_target_running = true;
2752            }
2753            if (!RUNNING_STATE(thr->getTargetState())) {
2754              pthrd_printf("%d/%d target stopped, any_target_stopped = true\n", getPid(), thr->getLWP());
2755              any_target_stopped = true;
2756            }
2757    }
2758    if(!a_running_thread) {
2759      a_running_thread = tp->initialThread();
2760    }
2761
2762
2763    if (!any_target_running && !any_running) {
2764       pthrd_printf("Target process state %d is stopped and process is stopped, leaving\n", getPid());
2765       return true;
2766    }
2767    if (!any_target_stopped && !any_stopped) {
2768       pthrd_printf("Target process state %d is running and process is running, leaving\n", getPid());
2769       return true;
2770    }
2771    if (!plat_debuggerSuspended()) {
2772       pthrd_printf("Process %d is not debugger suspended, but have changes.  Stopping process.\n", getPid());
2773       return a_running_thread->intStop();
2774    }
2775
2776    //If we're here, we must be debuggerSuspended, and thus no threads are running (!any_running)
2777    // since we didn't trigger the above if statement, we must have some thread we want to run
2778    // (any_target_running)
2779    assert(!any_running && any_target_running);
2780    pthrd_printf("Begin suspend/resume loop\n");
2781    for (i = tp->begin(); i != tp->end(); i++) {
2782       int_thread *thr = *i;
2783       bool result = true;
2784           if (!thr->isUser()) {
2785                   // Pretend is member of Wu Tang clan -- Bill Williams, 13JUN2012
2786                   resumeThread(thr);
2787                   continue;
2788           }
2789           if (thr->getDetachState().getState() == int_thread::detached)
2790             continue;
2791
2792 #if defined(os_freebsd)
2793            if (thr->getUserState().getState() == int_thread::exited) {
2794              // Let it go, man...
2795              continue;
2796            }
2797 #endif
2798
2799       if (thr->isSuspended() && RUNNING_STATE(thr->getTargetState())) {
2800          pthrd_printf("Resuming thread %d/%d\n", getPid(), thr->getLWP());
2801          result = resumeThread(thr);
2802       }
2803       if (thr->getDetachState().getState() == int_thread::detached)
2804          continue;
2805       if (RUNNING_STATE(thr->getTargetState())) {
2806          if (thr->isSuspended()) {
2807             pthrd_printf("Resuming thread %d/%d\n", getPid(), thr->getLWP());
2808             result = resumeThread(thr);
2809          }
2810          else {
2811             pthrd_printf("Thread %d/%d is already resumed, not resuming\n", getPid(), thr->getLWP());
2812          }
2813       }
2814       else if (!RUNNING_STATE(thr->getTargetState())) {
2815          if (!thr->isSuspended()) {
2816             pthrd_printf("Suspending thread %d/%d\n", getPid(), thr->getLWP());
2817             result = suspendThread(thr);
2818          }
2819          else {
2820             pthrd_printf("Thread %d/%d is already suspended, not suspending\n", getPid(), thr->getLWP());
2821          }
2822       }
2823       if (!result) {
2824          pthrd_printf("Error suspending/resuming threads\n");
2825          return false;
2826       }
2827    }
2828
2829    pthrd_printf("Continuing process %d after suspend/resume of threads\n", getPid());
2830    debugger_stopped = false;
2831    return threadPool()->initialThread()->intCont();
2832 }
2833
2834 int_thread::int_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l) :
2835    tid(t),
2836    lwp(l),
2837    proc_(p),
2838    continueSig_(0),
2839    attach_status(as_unknown),
2840    handler_running_thrd_count(Counter::HandlerRunningThreads),
2841    generator_running_thrd_count(Counter::GeneratorRunningThreads),
2842    sync_rpc_count(Counter::SyncRPCs),
2843    sync_rpc_running_thr_count(Counter::SyncRPCRunningThreads),
2844    pending_stop(Counter::PendingStops),
2845    clearing_bp_count(Counter::ClearingBPs),
2846    proc_stop_rpc_count(Counter::ProcStopRPCs),
2847    generator_nonexited_thrd_count(Counter::GeneratorNonExitedThreads),
2848    neonatal_threads(Counter::NeonatalThreads),
2849    pending_stackwalk_count(Counter::PendingStackwalks),
2850    postponed_syscall_state(this, PostponedSyscallStateID, dontcare),
2851    exiting_state(this, ExitingStateID, dontcare),
2852    startup_state(this, StartupStateID, dontcare),
2853    pending_stop_state(this, PendingStopStateID, dontcare),
2854    callback_state(this, CallbackStateID, dontcare),
2855    breakpoint_state(this, BreakpointStateID, dontcare),
2856    breakpoint_hold_state(this, BreakpointHoldStateID, dontcare),
2857    breakpoint_resume_state(this, BreakpointResumeStateID, dontcare),
2858    irpc_setup_state(this, IRPCSetupStateID, dontcare),
2859    irpc_wait_state(this, IRPCWaitStateID, dontcare),
2860    irpc_state(this, IRPCStateID, dontcare),
2861    async_state(this, AsyncStateID, dontcare),
2862    internal_state(this, InternalStateID, dontcare),
2863    detach_state(this, DetachStateID, dontcare),
2864    user_irpc_state(this, UserRPCStateID, dontcare),
2865    control_authority_state(this, ControlAuthorityStateID, dontcare),
2866    user_state(this, UserStateID, neonatal),
2867    handler_state(this, HandlerStateID, neonatal),
2868    generator_state(this, GeneratorStateID, neonatal),
2869    target_state(int_thread::none),
2870    saved_user_state(int_thread::none),
2871    user_single_step(false),
2872    single_step(false),
2873    handler_exiting_state(false),
2874    generator_exiting_state(false),
2875    running_when_attached(true),
2876    suspended(false),
2877    user_syscall(false),
2878    next_syscall_is_exit(false),
2879    stopped_on_breakpoint_addr(0x0),
2880    postponed_stopped_on_breakpoint_addr(0x0),
2881    clearing_breakpoint(NULL),
2882    em_singlestep(NULL),
2883    user_data(NULL),
2884    unwinder(NULL)
2885 {
2886    Thread::ptr new_thr(new Thread());
2887
2888    new_thr->llthread_ = this;
2889    up_thread = new_thr;
2890
2891    getGeneratorNonExitedThreadCount().inc();
2892 }
2893
2894 int_thread::~int_thread()
2895 {
2896    assert(!up_thread->exitstate_);
2897
2898    thread_exitstate *tes = new thread_exitstate();
2899    tes->lwp = lwp;
2900    tes->thr_id = tid;
2901    tes->proc_ptr = proc();
2902    tes->user_data = user_data;
2903    up_thread->exitstate_ = tes;
2904    up_thread->llthread_ = NULL;
2905 }
2906
2907 bool int_thread::intStop()
2908 {
2909    pthrd_printf("intStop on thread %d/%d\n", llproc()->getPid(), getLWP());
2910    if (!llproc()->plat_processGroupContinues()) {
2911       assert(!RUNNING_STATE(target_state));
2912       assert(RUNNING_STATE(getHandlerState().getState()));
2913
2914       if (hasPendingStop()) {
2915          pthrd_printf("Not throwing a second stop while another is in flight\n");
2916          return true;
2917       }
2918    }
2919    else {
2920       int_threadPool *tp = llproc()->threadPool();
2921       for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
2922          if ((*i)->hasPendingStop()) {
2923             pthrd_printf("Not throwing a second stop while another is in flight\n");
2924             return true;
2925          }
2926       }
2927    }
2928
2929    setPendingStop(true);
2930    bool result = plat_stop();
2931    if (!result) {
2932       setPendingStop(false);
2933       if (getLastError() == err_noproc) {
2934          //Swallow this.
2935          result = true;
2936       }
2937    }
2938    return result;
2939 }
2940
2941 bool int_thread::intCont()
2942 {
2943    pthrd_printf("intCont on thread %d/%d\n", llproc()->getPid(), getLWP());
2944    if (!llproc()->plat_processGroupContinues()) {
2945       assert(RUNNING_STATE(target_state));
2946       assert(!RUNNING_STATE(getHandlerState().getState()));
2947    }
2948
2949    async_ret_t aret = handleSingleStepContinue();
2950    if (aret == aret_async) {
2951       pthrd_printf("Postponing intCont on %d/%d due to single-step handling\n",
2952                    llproc()->getPid(), getLWP());
2953       return true;
2954    }
2955    else if (aret == aret_error) {
2956       pthrd_printf("Error in intCont %d/%d during single-step handling\n",
2957                    llproc()->getPid(), getLWP());
2958       return false;
2959    }
2960
2961    ProcPool()->condvar()->lock();
2962
2963    bool result = plat_cont();
2964    if (result) {
2965       if (llproc()->plat_processGroupContinues()) {
2966          int_threadPool *pool = llproc()->threadPool();
2967          for (int_threadPool::iterator i = pool->begin(); i != pool->end(); i++) {
2968             if ((*i)->isSuspended())
2969                continue;
2970             (*i)->getHandlerState().setState(int_thread::running);
2971             (*i)->getGeneratorState().setState(int_thread::running);
2972          }
2973       }
2974       else {
2975          getHandlerState().setState(int_thread::running);
2976          getGeneratorState().setState(int_thread::running);
2977       }
2978       triggerContinueCBs();
2979    }
2980
2981
2982    ProcPool()->condvar()->broadcast();
2983    ProcPool()->condvar()->unlock();
2984
2985    if (!result) {
2986       pthrd_printf("Failed to plat_cont %d/%d\n", llproc()->getPid(), getLWP());
2987       return false;
2988    }
2989
2990    return true;
2991 }
2992
2993 async_ret_t int_thread::handleSingleStepContinue()
2994 {
2995    async_ret_t ret;
2996    set<int_thread *> thrds;
2997
2998    if (llproc()->plat_processGroupContinues()) {
2999       int_threadPool *pool = llproc()->threadPool();
3000       for (int_threadPool::iterator i = pool->begin(); i != pool->end(); i++) {
3001          if (!(*i)->isSuspended() && (*i)->singleStepUserMode()) {
3002             thrds.insert(*i);
3003          }
3004       }
3005
3006    }
3007    else if (singleStepUserMode()) {
3008       thrds.insert(this);
3009    }
3010
3011    if (thrds.empty()) {
3012       //No threads are single-steping.
3013       return aret_success;
3014    }
3015    pthrd_printf("Found %d threads doing single step under continue.  Handling\n", (int) thrds.size());
3016
3017    if (llproc()->plat_needsAsyncIO()) {
3018       /**
3019        * We want any async responses associated with an event, but this is under
3020        * a continue, which never has an associated event.  We'll make an EventNop
3021        * to accompany the async request.  However, since this isn't going to be
3022        * a common thing to have happen, we'll set a flag that just tells the
3023        * HandlerPool to create the nop event lazily only if anyone asks for it.
3024        **/
3025       llproc()->handlerPool()->setNopAsCurEvent();
3026    }
3027
3028    for (set<int_thread *>::iterator i = thrds.begin(); i != thrds.end(); i++) {
3029       int_thread *thr = *i;
3030       vector<Address> addrs;
3031       async_ret_t aresult = llproc()->plat_needsEmulatedSingleStep(thr, addrs);
3032       if (aresult == aret_async) {
3033          pthrd_printf("Async return from plat_needsEmulatedSingleStep on %d/%d\n",
3034                       llproc()->getPid(), thr->getLWP());
3035          //We're not actually under a handler, so fake all the async handling
3036          // the handlerpool would have done if we were.
3037          set<response::ptr> resps;
3038          Event::ptr cur_nop_event = llproc()->handlerPool()->curEvent();
3039          llproc()->plat_getEmulatedSingleStepAsyncs(thr, resps);
3040          llproc()->handlerPool()->notifyOfPendingAsyncs(resps, cur_nop_event);
3041          llproc()->handlerPool()->markEventAsyncPending(cur_nop_event);
3042          ret = aret_async;
3043          goto done;
3044       }
3045       else if (aresult == aret_error) {
3046          pthrd_printf("Error in plat_needsEmultatedSingleStep on %d/%d\n",
3047                       llproc()->getPid(), thr->getLWP());
3048          ret = aret_error;
3049          goto done;
3050       }
3051       else if (addrs.empty()) {
3052          pthrd_printf("Thread %d/%d does not need emulated single-step\n",
3053                       llproc()->getPid(), thr->getLWP());
3054          continue;
3055       }
3056
3057       pthrd_printf("Creating emulated single step for %d/%d\n",
3058                    llproc()->getPid(), thr->getLWP());
3059       emulated_singlestep *new_es = thr->getEmulatedSingleStep();
3060       if (!new_es)
3061          new_es = new emulated_singlestep(thr);
3062       for (vector<Address>::iterator j = addrs.begin(); j != addrs.end(); j++) {
3063          Address addr = *j;
3064          pthrd_printf("Installing emulated single-step breakpoint for %d/%d at %lx\n",
3065                       llproc()->getPid(), thr->getLWP(), addr);
3066          aresult = new_es->add(addr);
3067          if (aresult == aret_async) {
3068             pthrd_printf("Async return while installing breakpoint for emulated_singlestep\n");
3069             ret = aret_async;
3070             goto done;
3071          }
3072          if (aresult == aret_error) {
3073             pthrd_printf("Error return while installing breakpoint for emulated_singlestep\n");
3074             ret = aret_error;
3075             goto done;
3076          }
3077       }
3078    }
3079
3080    ret = aret_success;
3081   done:
3082
3083    if (llproc()->plat_needsAsyncIO())
3084       llproc()->handlerPool()->clearNopAsCurEvent();
3085
3086    return ret;
3087 }
3088
3089 bool int_thread::isStopped(int state_id)
3090 {
3091    if (getHandlerState().getState() != stopped)
3092       return false;
3093    if (getStateByID(state_id).getState() != stopped &&
3094        getStateByID(state_id).getState() != ditto)
3095       return false;
3096    for (int i=0; i<state_id; i++) {
3097       if (getStateByID(i).getState() != dontcare)
3098          return false;
3099    }
3100    return true;
3101 }
3102
3103 void int_thread::setPendingStop(bool b)
3104 {
3105    pthrd_printf("Setting pending stop to %s, thread %d/%d\n", b ? "true" : "false", proc()->getPid(), getLWP());
3106    if (b) {
3107       pending_stop.inc();
3108
3109       //You may ask why stopping moves the pending stop state to running.
3110       // We've sent the process a stop request, and we need that request to
3111       // be delivered.  The process won't take delivery of the stop request
3112       // unless it's running.
3113       getPendingStopState().desyncState(int_thread::running);
3114    }
3115    else {
3116       if (getPendingStopState().getState() != int_thread::dontcare) {
3117          getPendingStopState().restoreState();
3118          pending_stop.dec();
3119       }
3120       else {
3121          pthrd_printf("Pending stop state == dontcare, ignoring\n");
3122       }
3123    }
3124    pthrd_printf("\t Pending stop level is %d\n", pending_stop.localCount());
3125 }
3126
3127 bool int_thread::hasPendingStop() const
3128 {
3129    return pending_stop.local();
3130 }
3131
3132 bool int_thread::wasRunningWhenAttached() const {
3133     return running_when_attached;
3134 }
3135
3136 void int_thread::setRunningWhenAttached(bool b) {
3137     running_when_attached = b;
3138 }
3139
3140 Process::ptr int_thread::proc() const
3141 {
3142    return proc_->proc();
3143 }
3144
3145 int_process *int_thread::llproc() const
3146 {
3147    return proc_;
3148 }
3149
3150 Dyninst::LWP int_thread::getLWP() const
3151 {
3152    return lwp;
3153 }
3154
3155 void int_thread::addContinueCB(continue_cb_t cb)
3156 {
3157    continue_cbs.insert(cb);
3158 }
3159
3160 void int_thread::triggerContinueCBs()
3161 {
3162    bool sync_conts = llproc()->plat_processGroupContinues();
3163    for (set<continue_cb_t>::iterator i = continue_cbs.begin(); i != continue_cbs.end(); i++) {
3164       if (!sync_conts) {
3165          //Independent lwp control--only do this thread.
3166          (*i)(this);
3167       }
3168       else {
3169          //Threads are continued at once--do every thread
3170          int_threadPool *tp = llproc()->threadPool();
3171          for (int_threadPool::iterator j = tp->begin(); j != tp->end(); j++) {
3172             if ((*j)->isSuspended())
3173                continue;
3174             (*i)(*j);
3175          }
3176       }
3177    }
3178 }
3179
3180 int_thread::StateTracker &int_thread::getPostponedSyscallState()
3181 {
3182    return postponed_syscall_state;
3183 }
3184
3185 int_thread::StateTracker &int_thread::getBreakpointState()
3186 {
3187    return breakpoint_state;
3188 }
3189
3190 int_thread::StateTracker &int_thread::getBreakpointHoldState()
3191 {
3192    return breakpoint_hold_state;
3193 }
3194
3195 int_thread::StateTracker &int_thread::getBreakpointResumeState()
3196 {
3197    return breakpoint_resume_state;
3198 }
3199
3200 int_thread::StateTracker &int_thread::getIRPCState()
3201 {
3202    return irpc_state;
3203 }
3204
3205 int_thread::StateTracker &int_thread::getIRPCSetupState()
3206 {
3207    return irpc_setup_state;
3208 }
3209
3210 int_thread::StateTracker &int_thread::getIRPCWaitState()
3211 {
3212    return irpc_wait_state;
3213 }
3214
3215 int_thread::StateTracker &int_thread::getAsyncState()
3216 {
3217    return async_state;
3218 }
3219
3220 int_thread::StateTracker &int_thread::getInternalState()
3221 {
3222    return internal_state;
3223 }
3224
3225 int_thread::StateTracker &int_thread::getDetachState()
3226 {
3227    return detach_state;
3228 }
3229
3230 int_thread::StateTracker &int_thread::getUserRPCState()
3231 {
3232         return user_irpc_state;
3233 }
3234
3235 int_thread::StateTracker &int_thread::getControlAuthorityState()
3236 {
3237    return control_authority_state;
3238 }
3239
3240 int_thread::StateTracker &int_thread::getUserState()
3241 {
3242    return user_state;
3243 }
3244
3245 int_thread::StateTracker &int_thread::getHandlerState()
3246 {
3247    return handler_state;
3248 }
3249
3250 int_thread::StateTracker &int_thread::getGeneratorState()
3251 {
3252    return generator_state;
3253 }
3254
3255 int_thread::StateTracker &int_thread::getExitingState()
3256 {
3257    return exiting_state;
3258 }
3259
3260 int_thread::StateTracker &int_thread::getStartupState()
3261 {
3262    return startup_state;
3263 }
3264
3265 int_thread::StateTracker &int_thread::getCallbackState()
3266 {
3267    return callback_state;
3268 }
3269
3270 int_thread::StateTracker &int_thread::getPendingStopState()
3271 {
3272    return pending_stop_state;
3273 }
3274
3275 int_thread::State int_thread::getTargetState() const
3276 {
3277    return target_state;
3278 }
3279
3280 void int_thread::setTargetState(State s)
3281 {
3282         pthrd_printf("%d/%d: setting target state to %s\n", proc_->getPid(), getLWP(),
3283                 RUNNING_STATE(s) ? "Running" : "Stopped");
3284    target_state = s;
3285 }
3286
3287 int_thread::StateTracker &int_thread::getActiveState() {
3288    for (int i=0; i<int_thread::NumTargetStateIDs; i++) {
3289       if (all_states[i]->getState() != int_thread::dontcare) {
3290          return *all_states[i];
3291       }
3292    }
3293    assert(0); //At least user state should never be 'dontcare'
3294    return *all_states[0];
3295 }
3296
3297 int_thread::StateTracker &int_thread::getStateByID(int id)
3298 {
3299    switch (id) {
3300       case PostponedSyscallStateID: return postponed_syscall_state;
3301       case ExitingStateID: return exiting_state;
3302       case StartupStateID: return startup_state;
3303       case AsyncStateID: return async_state;
3304       case CallbackStateID: return callback_state;
3305       case PendingStopStateID: return pending_stop_state;
3306       case IRPCStateID: return irpc_state;
3307       case IRPCSetupStateID: return irpc_setup_state;
3308       case IRPCWaitStateID: return irpc_wait_state;
3309       case BreakpointStateID: return breakpoint_state;
3310       case BreakpointHoldStateID: return breakpoint_hold_state;
3311       case BreakpointResumeStateID: return breakpoint_resume_state;
3312       case InternalStateID: return internal_state;
3313       case DetachStateID: return detach_state;
3314       case UserRPCStateID: return user_irpc_state;
3315       case ControlAuthorityStateID: return control_authority_state;
3316       case UserStateID: return user_state;
3317       case HandlerStateID: return handler_state;
3318       case GeneratorStateID: return generator_state;
3319    }
3320    assert(0);
3321    return exiting_state;
3322 }
3323
3324 std::string int_thread::stateIDToName(int id)
3325 {
3326    switch (id) {
3327       case PostponedSyscallStateID: return "postponed syscall";
3328       case ExitingStateID: return "exiting";
3329       case StartupStateID: return "startup";
3330       case AsyncStateID: return "async";
3331       case CallbackStateID: return "callback";
3332       case PendingStopStateID: return "pending stop";
3333       case IRPCStateID: return "irpc";
3334       case IRPCSetupStateID: return "irpc setup";
3335       case IRPCWaitStateID: return "irpc wait";
3336       case BreakpointStateID: return "breakpoint";
3337       case BreakpointHoldStateID: return "bp hold";
3338       case BreakpointResumeStateID: return "breakpoint resume";
3339       case InternalStateID: return "internal";
3340       case UserRPCStateID: return "irpc user";
3341       case ControlAuthorityStateID: return "control authority";
3342       case UserStateID: return "user";
3343       case DetachStateID: return "detach";
3344       case HandlerStateID: return "handler";
3345       case GeneratorStateID: return "generator";
3346    }
3347    assert(0);
3348    return "";
3349 }
3350
3351
3352 const char *int_thread::stateStr(int_thread::State s)
3353 {
3354    switch (s) {
3355       case none: return "none";
3356       case neonatal: return "neonatal";
3357       case neonatal_intermediate: return "neonatal_intermediate";
3358       case running: return "running";
3359       case stopped: return "stopped";
3360       case dontcare: return "dontcare";
3361       case ditto: return "ditto";
3362       case exited: return "exited";
3363       case detached: return "detached";
3364       case errorstate: return "errorstate";
3365    }
3366    assert(0);
3367    return NULL;
3368 }
3369
3370 char int_thread::stateLetter(int_thread::State s)
3371 {
3372    switch (s) {
3373       case none: return '0';
3374       case neonatal: return 'N';
3375       case neonatal_intermediate: return 'I';
3376       case running: return 'R';
3377       case stopped: return 'S';
3378       case dontcare: return '-';
3379       case ditto: return 'H';
3380       case exited: return 'X';
3381       case detached: return 'D';
3382       case errorstate: return 'E';
3383    }
3384    assert(0);
3385    return '\0';
3386 }
3387
3388 Counter &int_thread::handlerRunningThreadsCount()
3389 {
3390    return handler_running_thrd_count;
3391 }
3392
3393 Counter &int_thread::generatorRunningThreadsCount()
3394 {
3395    return generator_running_thrd_count;
3396 }
3397
3398 Counter &int_thread::syncRPCCount()
3399 {
3400    return sync_rpc_count;
3401 }
3402
3403 Counter &int_thread::runningSyncRPCThreadCount()
3404 {
3405    return sync_rpc_running_thr_count;
3406 }
3407
3408 Counter &int_thread::pendingStopsCount()
3409 {
3410    return pending_stop;
3411 }
3412
3413 Counter &int_thread::clearingBPCount()
3414 {
3415    return clearing_bp_count;
3416 }
3417
3418 Counter &int_thread::procStopRPCCount()
3419 {
3420    return proc_stop_rpc_count;
3421 }
3422
3423 Counter &int_thread::getGeneratorNonExitedThreadCount()
3424 {
3425    return generator_nonexited_thrd_count;
3426 }
3427
3428 Counter &int_thread::neonatalThreadCount()
3429 {
3430    return neonatal_threads;
3431 }
3432
3433 Counter &int_thread::pendingStackwalkCount()
3434 {
3435    return pending_stackwalk_count;
3436 }
3437
3438 void int_thread::setContSignal(int sig)
3439 {
3440    continueSig_ = sig;
3441 }
3442
3443 int int_thread::getContSignal() {
3444     return continueSig_;
3445 }
3446
3447 int_thread *int_thread::createThread(int_process *proc,
3448                                      Dyninst::THR_ID thr_id,
3449                                      Dyninst::LWP lwp_id,
3450                                      bool initial_thrd,
3451                                      attach_status_t astatus)
3452 {
3453    // See if we already created a skeleton/dummy thread for this thread ID.
3454    int_thread *newthr = proc->threadPool()->findThreadByLWP(lwp_id);
3455    if (newthr) return newthr;
3456
3457    newthr = createThreadPlat(proc, thr_id, lwp_id, initial_thrd);
3458    if(!newthr)
3459    {
3460            pthrd_printf("createThreadPlat failed, returning NULL\n");
3461            return NULL;
3462    }
3463    pthrd_printf("Creating %s thread %d/%d, thr_id = 0x%lx\n",
3464                 initial_thrd ? "initial" : "new",
3465                 proc->getPid(), newthr->getLWP(), thr_id);
3466
3467    proc->threadPool()->addThread(newthr);
3468    if (initial_thrd) {
3469       proc->threadPool()->setInitialThread(newthr);
3470    }
3471    ProcPool()->addThread(proc, newthr);
3472    newthr->attach_status = astatus;
3473
3474    bool result = newthr->attach();
3475    if (!result) {
3476       pthrd_printf("Failed to attach to new thread %d/%d\n", proc->getPid(), lwp_id);
3477       return NULL;
3478    }
3479    if (newthr->isUser() && newthr->getUserState().getState() == neonatal) {
3480            newthr->getUserState().setState(neonatal_intermediate);
3481            newthr->getHandlerState().setState(neonatal_intermediate);
3482                 newthr->getGeneratorState().setState(neonatal_intermediate);
3483    }
3484
3485    return newthr;
3486 }
3487
3488 void int_thread::changeLWP(Dyninst::LWP new_lwp)
3489 {
3490   pthrd_printf("Changing LWP of %d/%d to %d\n", llproc()->getPid(), lwp, new_lwp);
3491
3492   int_threadPool *tpool = llproc()->threadPool();
3493   map<Dyninst::LWP, int_thread *>::iterator i = tpool->thrds_by_lwp.find(lwp);
3494   assert(i != tpool->thrds_by_lwp.end());
3495   tpool->thrds_by_lwp.erase(i);
3496   tpool->thrds_by_lwp.insert(make_pair(new_lwp, this));
3497
3498   ProcPool()->condvar()->lock();
3499   ProcPool()->rmThread(this);
3500   lwp = new_lwp;
3501   ProcPool()->addThread(llproc(), this);
3502   ProcPool()->condvar()->unlock();
3503 }
3504
3505 void int_thread::throwEventsBeforeContinue()
3506 {
3507   pthrd_printf("Checking thread %d/%d for events thrown before continue\n",
3508                llproc()->getPid(), getLWP());
3509    if (llproc()->wasForcedTerminated()) return;
3510
3511    Event::ptr new_ev;
3512
3513    int_iRPC::ptr rpc = nextPostedIRPC();
3514    bp_instance *bpi = isStoppedOnBP();
3515    if (rpc && !runningRPC() && rpc->getState() == int_iRPC::Posted) {
3516       pthrd_printf("Found thread %d/%d ready to run IRPC, not continuing\n", llproc()->getPid(), getLWP());
3517
3518       if (rpc->isProcStopRPC() || llproc()->plat_threadOpsNeedProcStop()) {
3519          getIRPCSetupState().desyncStateProc(int_thread::stopped);
3520       }
3521       else {
3522          getIRPCSetupState().desyncState(int_thread::stopped);
3523       }
3524       rpc->setState(int_iRPC::Prepping);
3525       new_ev = EventRPCLaunch::ptr(new EventRPCLaunch());
3526    }
3527    else if (bpi) {
3528       if (bpi->swBP()) {
3529          //Stop the process to clear a software breakpoint
3530          pthrd_printf("Found thread %d/%d to be stopped on a software BP, not continuing\n",
3531                       llproc()->getPid(), getLWP());
3532          getBreakpointState().desyncStateProc(int_thread::stopped);
3533          EventBreakpointClear::ptr evclear =  EventBreakpointClear::ptr(new EventBreakpointClear());
3534          evclear->getInternal()->stopped_proc = true;
3535          new_ev = evclear;
3536       }
3537       else {
3538          //No process stop needed for a hardware breakpoint
3539          pthrd_printf("Found thread %d/%d to be stopped on a hardware BP, not continuing\n",
3540                       llproc()->getPid(), getLWP());
3541          getBreakpointState().desyncState(int_thread::stopped);
3542          new_ev = EventBreakpointClear::ptr(new EventBreakpointClear());
3543       }
3544    }
3545    else {
3546       new_ev = llproc()->plat_throwEventsBeforeContinue(this);
3547    }
3548
3549    if (new_ev) {
3550       new_ev->setProcess(proc());
3551       new_ev->setThread(thread());
3552       new_ev->setSyncType(Event::async);
3553       new_ev->setSuppressCB(true);
3554       mbox()->enqueue(new_ev);
3555    }
3556 }
3557
3558 bool int_thread::suppressSanityChecks()
3559 {
3560    return false;
3561 }
3562
3563 bool int_thread::isExiting() const
3564 {
3565     return handler_exiting_state;
3566 }
3567
3568 void int_thread::setExiting(bool b)
3569 {
3570     handler_exiting_state = b;
3571 }
3572
3573 bool int_thread::isExitingInGenerator() const
3574 {
3575     return generator_exiting_state;
3576 }
3577
3578 void int_thread::setExitingInGenerator(bool b)
3579 {
3580     generator_exiting_state = b;
3581 }
3582
3583 void int_thread::cleanFromHandler(int_thread *thrd, bool should_delete)
3584 {
3585    ProcPool()->condvar()->lock();
3586
3587 #if !defined(os_freebsd)
3588    thrd->getUserState().setState(int_thread::exited);
3589 #else
3590    thrd->setExiting(true);
3591 #endif
3592
3593    if (should_delete) {
3594       thrd->getExitingState().setState(int_thread::exited);
3595           if(ProcPool()->findThread(thrd->getLWP()) != NULL) {
3596               ProcPool()->rmThread(thrd);
3597           }
3598           else {
3599                         pthrd_printf("%d/%d already gone from top level ProcPool(), not removing\n",
3600                                 thrd->llproc()->getPid(), thrd->getLWP());
3601           }
3602       thrd->llproc()->threadPool()->rmThread(thrd);
3603       delete thrd;
3604    }
3605    else {
3606       //If we're not yet deleting this thread, then we're dealing with
3607       // a pre-mature exit event.  The thread will be exiting soon, but
3608       // isn't there yet.  We'll run the thread instead to make sure it
3609       // reaches a proper exit.
3610
3611       // If we're freeBSD, they don't give us a thread exit event and
3612       // so running only the exiting thread can result in a process
3613       // that is "executing" with no continued threads. That is bad.
3614 #if !defined(os_freebsd)
3615       thrd->getExitingState().setState(int_thread::running);
3616 #endif
3617    }
3618    ProcPool()->condvar()->broadcast();
3619    ProcPool()->condvar()->unlock();
3620 }
3621
3622 Thread::ptr int_thread::thread()
3623 {
3624    return up_thread;
3625 }
3626
3627 bool int_thread::getAllRegisters(allreg_response::ptr response)
3628 {
3629    response->setThread(this);
3630    response->setProcess(llproc());
3631
3632    pthrd_printf("Reading registers for thread %d\n", getLWP());
3633
3634    regpool_lock.lock();
3635    if (cached_regpool.full && 0) {
3636       *response->getRegPool() = cached_regpool;
3637       response->getRegPool()->thread = this;
3638       response->markReady();
3639       pthrd_printf("Returning cached register set\n");
3640       regpool_lock.unlock();
3641       return true;
3642    }
3643
3644    if (!llproc()->plat_needsAsyncIO())
3645    {
3646       pthrd_printf("plat_getAllRegisters on %d/%d\n", llproc()->getPid(), getLWP());
3647       bool result = plat_getAllRegisters(cached_regpool);
3648       if (!result) {
3649          pthrd_printf("plat_getAllRegisters returned error on %d\n", getLWP());
3650          response->markError();
3651          regpool_lock.unlock();
3652          return false;
3653       }
3654       cached_regpool.full = true;
3655       *(response->getRegPool()) = cached_regpool;
3656       response->getRegPool()->thread = this;
3657       response->markReady();
3658       regpool_lock.unlock();
3659
3660       int_eventAsyncIO *iev = response->getAsyncIOEvent();
3661       if (iev) {
3662          pthrd_printf("Enqueueing new EventAsyncReadAllRegs into mailbox on synchronous platform\n");
3663          EventAsyncReadAllRegs::ptr ev = EventAsyncReadAllRegs::ptr(new EventAsyncReadAllRegs(iev));
3664          ev->setProcess(proc());
3665          ev->setThread(thread());
3666          ev->setSyncType(Event::async);
3667          mbox()->enqueue(ev);
3668       }
3669
3670       pthrd_printf("Successfully retrieved all registers for %d\n", getLWP());
3671    }
3672    else
3673    {
3674       pthrd_printf("Async plat_getAllRegisters on %d/%d\n", llproc()->getPid(),
3675                    getLWP());
3676       regpool_lock.unlock();
3677       getResponses().lock();
3678       bool result = plat_getAllRegistersAsync(response);
3679       if (result) {
3680          getResponses().addResponse(response, llproc());
3681       }
3682       getResponses().unlock();
3683       getResponses().noteResponse();
3684       if (!result) {
3685          pthrd_printf("plat_getAllRegistersAsync returned error on %d\n", getLWP());
3686          return false;
3687       }
3688    }
3689
3690    return true;
3691 }
3692
3693 bool int_thread::setAllRegisters(int_registerPool &pool, result_response::ptr response)
3694 {
3695    assert(getHandlerState().getState() == int_thread::stopped);
3696    assert(getGeneratorState().getState() == int_thread::stopped);
3697    response->setProcess(llproc());
3698
3699    if (!llproc()->plat_needsAsyncIO()) {
3700
3701       pthrd_printf("Setting registers for thread %d\n", getLWP());
3702       bool result = plat_setAllRegisters(pool);
3703       response->setResponse(result);
3704       if (!result) {
3705          pthrd_printf("plat_setAllRegisters returned error on %d\n", getLWP());
3706          return false;
3707       }
3708
3709       int_eventAsyncIO *iev = response->getAsyncIOEvent();
3710       if (iev) {
3711          pthrd_printf("Enqueueing new EventAsyncSetAllRegs into mailbox on synchronous platform\n");
3712          EventAsyncSetAllRegs::ptr ev = EventAsyncSetAllRegs::ptr(new EventAsyncSetAllRegs(iev));
3713          ev->setProcess(proc());
3714          ev->setThread(thread());
3715          ev->setSyncType(Event::async);
3716          mbox()->enqueue(ev);
3717       }
3718       pthrd_printf("Successfully set all registers for %d\n", getLWP());
3719    }
3720    else {
3721       pthrd_printf("Async setting registers for thread %d\n", getLWP());
3722       getResponses().lock();
3723       bool result = plat_setAllRegistersAsync(pool, response);
3724       if (result) {
3725          getResponses().addResponse(response, llproc());
3726       }
3727       getResponses().unlock();
3728       getResponses().noteResponse();
3729       if (!result) {
3730          pthrd_printf("Error async setting registers on %d\n", getLWP());
3731          return false;
3732       }
3733    }
3734
3735    regpool_lock.lock();
3736    cached_regpool = pool;
3737    cached_regpool.full = true;
3738    regpool_lock.unlock();
3739
3740    return true;
3741 }
3742
3743 bool int_thread::getRegister(Dyninst::MachRegister reg, reg_response::ptr response)
3744 {
3745    bool ret_result = false;
3746    pthrd_printf("Get register value for thread %d, register %s\n", lwp, reg.name().c_str());
3747    response->setRegThread(reg, this);
3748    response->setProcess(llproc());
3749
3750    if (!llproc()->plat_individualRegRead(reg, this))
3751    {
3752       //Convert the single get register access into a get all registers
3753       pthrd_printf("Platform does not support individual register access, "
3754                    "getting everything\n");
3755       if (!llproc()->plat_needsAsyncIO()) {
3756          int_registerPool pool;
3757          allreg_response::ptr allreg_resp = allreg_response::createAllRegResponse(&pool);
3758          bool result = getAllRegisters(allreg_resp);
3759          bool is_ready = allreg_resp->isReady();
3760          if (!result || allreg_resp->hasError()) {