Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / BPatch.C
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #include <stdio.h>
33 #include <assert.h>
34 #include <signal.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #if !defined(os_windows)
38 #include <unistd.h>
39 #endif
40
41 #define BPATCH_FILE
42 #include "common/h/Pair.h"
43 #include "common/h/Vector.h"
44 #include "signalhandler.h"
45 #include "common/h/stats.h"
46 #include "BPatch.h"
47 //#include "BPatch_typePrivate.h"
48 #include "process.h"
49 #include "BPatch_libInfo.h"
50 #include "BPatch_collections.h"
51 #include "BPatch_thread.h"
52 #include "BPatch_asyncEventHandler.h"
53 #include "callbacks.h"
54 #include "common/h/timing.h"
55 #include "debug.h"
56 #include "signalgenerator.h"
57 #include "mapped_module.h"
58 #include "instPoint.h"
59
60 #if defined(i386_unknown_nt4_0) || defined(mips_unknown_ce2_11) //ccw 20 july 2000 : 28 mar 2001
61 #include "nt_signal_emul.h"
62 #endif
63
64 extern void loadNativeDemangler();
65
66 BPatch *BPatch::bpatch = NULL;
67
68 extern BPatch_asyncEventHandler *global_async_event_handler;
69 void defaultErrorFunc(BPatchErrorLevel level, int num, const char * const *params);
70
71 extern void dyninst_yield();
72
73 /*
74  * BPatch::BPatch
75  *
76  * Constructor for BPatch.  Performs one-time initialization needed by the
77  * library.
78  */
79 BPatch::BPatch()
80   : info(NULL),
81     typeCheckOn(true),
82     lastError(0),
83     debugParseOn(true),
84     baseTrampDeletionOn(false),
85     trampRecursiveOn(false),
86     forceRelocation_NP(false),
87     autoRelocation_NP(true),
88     saveFloatingPointsOn(true),
89     livenessAnalysisOn_(true),
90     livenessAnalysisDepth_(3),
91     asyncActive(false),
92     delayedParsing_(false),
93     instrFrames(false),
94     systemPrelinkCommand(NULL),
95     mutateeStatusChange(false),
96     waitingForStatusChange(false),
97     notificationFDOutput_(-1),
98     notificationFDInput_(-1),
99     FDneedsPolling_(false),
100     builtInTypes(NULL),
101     stdTypes(NULL),
102     type_Error(NULL),
103     type_Untyped(NULL)
104 {
105     if (!global_mutex) {
106       global_mutex = new eventLock();
107       extern bool mutex_created;
108       mutex_created = true;
109     }
110
111     global_mutex->_Lock(FILE__, __LINE__);
112     init_debug();
113     init_stats();
114
115     memset(&stats, 0, sizeof(BPatch_stats));
116     extern bool init();
117
118     // Save a pointer to the one-and-only bpatch object.
119     if (bpatch == NULL){
120        bpatch = this;
121     }
122     
123     BPatch::bpatch->registerErrorCallback(defaultErrorFunc);
124     bpinfo("installed default error reporting function");
125     initCyclesPerSecond();
126     
127     /*
128      * Create the list of processes.
129      */
130     info = new BPatch_libInfo();
131
132     /*
133      * Create the "error" and "untyped" types.
134      */
135     type_Error   = BPatch_type::createFake("<error>");
136     type_Untyped = BPatch_type::createFake("<no type>");
137     
138     /*
139      * Initialize hash table of API types.
140      */
141     APITypes = BPatch_typeCollection::getGlobalTypeCollection();
142
143     stdTypes = BPatch_typeCollection::getGlobalTypeCollection();
144     vector<Type *> *sTypes = Symtab::getAllstdTypes();
145     for(unsigned i=0; i< sTypes->size(); i++)
146         stdTypes->addType(new BPatch_type((*sTypes)[i]));
147
148     builtInTypes = new BPatch_builtInTypeCollection;
149     sTypes = Symtab::getAllbuiltInTypes();
150     for(unsigned i=0; i< sTypes->size(); i++)
151         builtInTypes->addBuiltInType(new BPatch_type((*sTypes)[i]));
152
153     loadNativeDemangler();
154
155     global_async_event_handler = new BPatch_asyncEventHandler();
156 #if defined(cap_async_events)
157     if (!global_async_event_handler->initialize()) {
158       //  not much else we can do in the ctor, except complain (should we abort?)
159       bperr("%s[%d]:  failed to initialize asyncEventHandler, possibly fatal\n",
160             __FILE__, __LINE__);
161     }
162 #endif
163     global_mutex->_Unlock(FILE__, __LINE__);
164 }
165
166
167 /*
168  * BPatch::~BPatch
169  *
170  * Destructor for BPatch.  Free allocated memory.
171  */
172 void BPatch::BPatch_dtor()
173 {
174     delete info;
175
176     type_Error->decrRefCount();
177     type_Untyped->decrRefCount();
178
179     if (stdTypes)
180         BPatch_typeCollection::freeTypeCollection(stdTypes);
181     if (APITypes)
182         BPatch_typeCollection::freeTypeCollection(APITypes);
183
184
185     if(systemPrelinkCommand){
186         delete [] systemPrelinkCommand;
187     }
188     bpatch = NULL;
189 }
190
191 BPatch *BPatch::getBPatch() {
192         return bpatch;
193 }
194
195 char * BPatch::getPrelinkCommandInt(){
196         return systemPrelinkCommand;
197 }
198
199 void BPatch::setPrelinkCommandInt(char *command){
200
201         if(systemPrelinkCommand){
202                 delete [] systemPrelinkCommand;
203         }
204         systemPrelinkCommand = new char[strlen(command)+1];
205         memcpy(systemPrelinkCommand, command, strlen(command)+1);
206 }
207
208 bool BPatch::isTypeCheckedInt()
209 {
210   return typeCheckOn;
211 }
212 void BPatch::setTypeCheckingInt(bool x)
213 {
214   typeCheckOn = x;
215 }
216 bool BPatch::parseDebugInfoInt()
217 {
218   return debugParseOn;
219 }
220 bool BPatch::delayedParsingOnInt()
221 {
222   return delayedParsing_;
223 }
224 void BPatch::setDebugParsingInt(bool x)
225 {
226   debugParseOn = x;
227 }
228 bool BPatch::baseTrampDeletionInt()
229 {
230   return baseTrampDeletionOn;
231 }
232 void BPatch::setBaseTrampDeletionInt(bool x)
233 {
234   baseTrampDeletionOn = x;
235 }
236 bool BPatch::isTrampRecursiveInt()
237 {
238   return trampRecursiveOn;
239 }
240 void BPatch::setTrampRecursiveInt(bool x)
241 {
242   trampRecursiveOn = x;
243 }
244 void BPatch::setLivenessAnalysisInt(bool x)
245 {
246     livenessAnalysisOn_ = x;
247 }
248 bool BPatch::livenessAnalysisOnInt() {
249     return livenessAnalysisOn_;
250 }
251
252 void BPatch::setLivenessAnalysisDepthInt(int x)
253 {
254     livenessAnalysisDepth_ = x;
255 }
256 int BPatch::livenessAnalysisDepthInt() {
257     return livenessAnalysisDepth_;
258 }
259
260 bool BPatch::hasForcedRelocation_NPInt()
261 {
262   return forceRelocation_NP;
263 }
264 void BPatch::setForcedRelocation_NPInt(bool x)
265 {
266   forceRelocation_NP = x;
267 }
268 bool BPatch::autoRelocationOnInt()
269 {
270   return autoRelocation_NP;
271 }
272 void BPatch::setAutoRelocation_NPInt(bool x)
273 {
274   autoRelocation_NP = x;
275 }
276 void BPatch::setDelayedParsingInt(bool x)
277 {
278   delayedParsing_ = x;
279 }
280 bool BPatch::isMergeTrampInt()
281 {
282   return true;
283 }
284 void BPatch::setMergeTrampInt(bool)
285 {
286 }
287
288 bool BPatch::isSaveFPROnInt()
289 {
290   return saveFloatingPointsOn;
291 }
292 void BPatch::setSaveFPRInt(bool x)
293 {
294   saveFloatingPointsOn = x;
295 }
296
297
298
299
300 /*
301  * BPatch::registerErrorCallbackInt
302  *
303  * Registers a function that is to be called by the library when an error
304  * occurs or when there is status to report.  Returns the address of the
305  * previously registered error callback function.
306  *
307  * function     The function to be called.
308  */
309
310
311 BPatchErrorCallback BPatch::registerErrorCallbackInt(BPatchErrorCallback function)
312 {
313     BPatchErrorCallback ret = NULL;
314
315     pdvector<CallbackBase *> cbs;
316     getCBManager()->removeCallbacks(evtError, cbs);
317
318     if (cbs.size()) {
319       mailbox_printf("%s[%d]:  removed %d error cbs\n", FILE__, __LINE__, cbs.size());
320       ErrorCallback *ercb = (ErrorCallback *) cbs[0];
321       ret = ercb->getFunc();
322     }
323
324     if (function != 0) {
325         ErrorCallback *cb = new ErrorCallback(function);
326         getCBManager()->registerCallback(evtError, cb);
327     }
328     // If function is zero, we treat it as a remove-callback request
329
330     return ret;
331 }
332
333
334 /*
335  * BPatch::registerPostForkCallback
336  *
337  * Registers a function that is to be called by the library when a new
338  * process has been forked off by an mutatee process.
339  *
340  * function     The function to be called.
341  */
342 BPatchForkCallback BPatch::registerPostForkCallbackInt(BPatchForkCallback func)
343 {
344 #if defined(i386_unknown_nt4_0) 
345   reportError(BPatchWarning, 0,
346               "postfork callbacks not implemented on this platform\n");
347   return NULL;
348 #else
349     BPatchForkCallback ret = NULL;
350
351     pdvector<CallbackBase *> cbs;
352     getCBManager()->removeCallbacks(evtPostFork, cbs);
353
354     if (cbs.size()) {
355       ForkCallback *fcb = (ForkCallback *) cbs[0];
356       ret =  fcb->getFunc();
357     }
358
359     if (func != 0) {
360         ForkCallback *cb = new ForkCallback(func);
361         getCBManager()->registerCallback(evtPostFork, cb);
362     }
363     // If func is zero, we assume it is a remove-callback request
364
365     return ret;
366 #endif
367 }
368
369 /*
370  * BPatch::registerPreForkCallback
371  *
372  * Registers a function that is to be called by the library when a process
373  * is about to fork a new process
374  *
375  * function     The function to be called.
376  */
377 BPatchForkCallback BPatch::registerPreForkCallbackInt(BPatchForkCallback func)
378 {
379 #if defined(i386_unknown_nt4_0)
380     reportError(BPatchWarning, 0,
381         "prefork callbacks not implemented on this platform\n");
382     return NULL;
383 #else
384     BPatchForkCallback ret = NULL;
385
386     pdvector<CallbackBase *> cbs;
387     getCBManager()->removeCallbacks(evtPreFork, cbs);
388
389     if (cbs.size()) {
390       ForkCallback *fcb = (ForkCallback *) cbs[0];
391       ret =  fcb->getFunc();
392     }
393
394     if (func != 0) {
395         ForkCallback *cb = new ForkCallback(func);
396         getCBManager()->registerCallback(evtPreFork, cb);
397     }
398     // If func is zero, we assume it is a remove-callback request
399         
400     return ret;
401 #endif
402 }
403
404 /*
405  * BPatch::registerExecCallback
406  *
407  * Registers a function that is to be called by the library when a 
408  * process has just completed an exec* call
409  *
410  * func The function to be called.
411  */
412 BPatchExecCallback BPatch::registerExecCallbackInt(BPatchExecCallback func)
413 {
414
415 #if defined(i386_unknown_nt4_0) 
416     reportError(BPatchWarning, 0,
417         "exec callbacks not implemented on this platform\n");
418     return NULL;
419 #else
420     BPatchExecCallback ret = NULL;
421
422     pdvector<CallbackBase *> cbs;
423     getCBManager()->removeCallbacks(evtExec, cbs);
424     if (cbs.size()) {
425       ExecCallback *fcb = (ExecCallback *) cbs[0];
426       ret =  fcb->getFunc();
427     }
428
429     if (func != 0) {
430         ExecCallback *cb = new ExecCallback(func);
431         getCBManager()->registerCallback(evtExec, cb);
432     }
433     // If func is zero, we assume it is a remove-callback request
434
435     return ret;
436
437 #endif
438 }
439
440 /*
441  * BPatch::registerExitCallback
442  *
443  * Registers a function that is to be called by the library when a 
444  * process has just called the exit system call
445  *
446  * func The function to be called.
447  */
448 BPatchExitCallback BPatch::registerExitCallbackInt(BPatchExitCallback func)
449 {
450     pdvector<CallbackBase *> cbs;
451     getCBManager()->removeCallbacks(evtProcessExit, cbs);
452
453     BPatchExitCallback ret = NULL;
454     if (cbs.size()) {
455         ExitCallback *fcb = (ExitCallback *) cbs[0];
456         ret =  fcb->getFunc();
457     }
458
459     if (func != 0) {
460         ExitCallback *cb = new ExitCallback(func);
461         getCBManager()->registerCallback(evtProcessExit, cb);
462     }
463     // If func is zero, we assume it is a remove-callback request
464
465     return ret;
466 }
467
468 /*
469  * BPatch::registerOneTimeCodeCallback
470  *
471  * Registers a function that is to be called by the library when a 
472  * oneTimeCode (inferior RPC) is completed.
473  *
474  * func The function to be called.
475  */
476 BPatchOneTimeCodeCallback BPatch::registerOneTimeCodeCallbackInt(BPatchOneTimeCodeCallback func)
477 {
478     BPatchOneTimeCodeCallback ret = NULL;
479
480     pdvector<CallbackBase *> cbs;
481     getCBManager()->removeCallbacks(evtOneTimeCode, cbs);
482     if (cbs.size()) {
483       OneTimeCodeCallback *fcb = (OneTimeCodeCallback *) cbs[0];
484       ret =  fcb->getFunc();
485     }
486
487     if (func != 0) {
488         OneTimeCodeCallback *cb = new OneTimeCodeCallback(func);
489         getCBManager()->registerCallback(evtOneTimeCode, cb);
490     }
491     // If func is zero, we assume it is a remove-callback request
492
493     return ret;
494 }
495
496
497 /*
498  * BPatch::registerDynLibraryCallback
499  *
500  * Registers a function that is to be called by the library when a dynamically
501  * loaded library is loaded or unloaded by a process under the API's control.
502  * Returns the address of the previously registered callback function.
503  *
504  * function     The function to be called.
505  */
506 BPatchDynLibraryCallback
507 BPatch::registerDynLibraryCallbackInt(BPatchDynLibraryCallback function)
508 {
509
510     BPatchDynLibraryCallback ret = NULL;
511
512     pdvector<CallbackBase *> cbs;
513     getCBManager()->removeCallbacks(evtLoadLibrary, cbs);
514     if (cbs.size()) {
515       DynLibraryCallback *fcb = (DynLibraryCallback *) cbs[0];
516       ret =  fcb->getFunc();
517     }
518
519     if (function != 0) {
520         DynLibraryCallback *cb = new DynLibraryCallback(function);
521         getCBManager()->registerCallback(evtLoadLibrary, cb);
522     }
523     // If function is zero, we assume it is a remove-callback request
524
525     return ret;
526 }
527
528
529 /*
530  * BPatch::getEnglishErrorString
531  *
532  * Returns the descriptive error string for the passed error number.
533  *
534  * number       The number that identifies the error.
535  */
536 const char *BPatch::getEnglishErrorString(int /* number */)
537 {
538     return "%s";
539 }
540
541
542 /*
543  * BPatch::reportError
544  *
545  * Report an error using the callback mechanism.
546  *
547  * severity     The severity level of the error.
548  * number       Identifies the error.
549  * str          A string to pass as the first element of the list of strings
550  *              given to the callback function.
551  */
552 void BPatch::reportError(BPatchErrorLevel severity, int number, const char *str)
553 {
554     assert(bpatch != NULL);
555     assert(global_mutex);
556     //assert(global_mutex->depth());
557
558     bool do_unlock = false;
559     if (!global_mutex->depth()) {
560       fprintf(stderr, "%s[%d]:  WARN:  reportError called w/0 lock\n", FILE__, __LINE__);
561       global_mutex->_Lock(FILE__, __LINE__);
562       do_unlock = true;
563     }
564
565     // don't log BPatchWarning or BPatchInfo messages as "errors"
566     if ((severity == BPatchFatal) || (severity == BPatchSerious))
567         bpatch->lastError = number;
568
569     pdvector<CallbackBase *> cbs;
570     if (! getCBManager()->dispenseCallbacksMatching(evtError, cbs)) {
571         fprintf(stdout, "%s[%d]:  DYNINST ERROR:\n %s\n", FILE__, __LINE__, str);
572         fflush(stdout);
573         if (do_unlock) 
574           global_mutex->_Unlock(FILE__, __LINE__);
575         return; 
576     }
577     
578     for (unsigned int i = 0; i < cbs.size(); ++i) {
579         ErrorCallback *cb = dynamic_cast<ErrorCallback *>(cbs[i]);
580         if (cb)
581             (*cb)(severity, number, str); 
582     }
583
584     if (do_unlock) 
585        global_mutex->_Unlock(FILE__, __LINE__);
586 }
587
588
589 /*
590  * BPatch::formatErrorString
591  *
592  * Takes a format string with an error message (obtained from
593  * getEnglishErrorString) and an array of parameters that were passed to an
594  * error callback function, and creates a string with the parameters
595  * substituted into it.
596  *
597  * dst          The address into which the formatted string should be copied.
598  * size         If the formatted string is equal to or longer than this number
599  *              of characters, then it will be truncated to size-1 characters
600  *              and terminated with a nul ('\0').
601  * fmt          The format string (returned by a function such as
602  *              getEnglishErrorString).
603  * params       The array of parameters that were passed to an error callback
604  *              function.
605  */
606 void BPatch::formatErrorString(char *dst, int size,
607                                const char *fmt, const char * const *params)
608 {
609     int cur_param = 0;
610
611     while (size > 1 && *fmt) {
612         if (*fmt == '%') {
613             if (fmt[1] == '\0') {
614                 break;
615             } else if (fmt[1] == '%') {
616                 *dst++ = '%';
617                 size--;
618             } else if (fmt[1] == 's') {
619                 char *p = const_cast<char *>(params[cur_param++]);
620                 while (size > 1 && *p) {
621                     *dst++ = *p++;
622                     size--;
623                 }
624             } else {
625                 // Illegal specifier
626                 *dst++ = fmt[0];
627                 *dst++ = fmt[1];
628                 size -= 2;
629             }
630             fmt += 2;
631         } else {
632             *dst++ = *fmt++;
633             size--;
634         }
635     }
636     if (size > 0)
637         *dst = '\0';
638 }
639
640 static const char *lvl_str(BPatchErrorLevel lvl)
641 {
642   switch(lvl) {
643     case BPatchFatal: return "--FATAL--";
644     case BPatchSerious: return "--SERIOUS--";
645     case BPatchWarning: return "--WARN--";
646     case BPatchInfo: return "--INFO--";
647   };
648   return "BAD ERR CODE";
649 }
650
651 void defaultErrorFunc(BPatchErrorLevel level, int num, const char * const *params)
652 {
653     char line[256];
654
655     if ((level == BPatchWarning) || (level == BPatchInfo)) {
656          // ignore low level errors/warnings in the default reporter
657          return;
658     }
659
660     const char *msg = BPatch::bpatch->getEnglishErrorString(num);
661     BPatch::bpatch->formatErrorString(line, sizeof(line), msg, params);
662
663     if (num != -1) {
664        fprintf(stderr,"%s #%d: %s\n", lvl_str(level),num, line);
665     }
666 }
667
668
669 /*
670  * BPatch::getThreadByPid
671  *
672  * Given a process ID, this function returns a pointer to the associated
673  * BPatch_thread object (or NULL if there is none).  Since a process may be
674  * registered provisionally with a thread object pointer of NULL, the boolean
675  * pointed to by the parameter "exists" is set to true if the pid exists in
676  * the table of processes, and false if it does not.
677  *
678  * pid          The pid to look up.
679  * exists       A pointer to a boolean to fill in with true if the pid exists
680  *              in the table and false if it does not.  NULL may be passed in
681  *              if this information is not required.
682  */
683 BPatch_process *BPatch::getProcessByPid(int pid, bool *exists)
684 {
685     if (info->procsByPid.defines(pid)) {
686         if (exists) *exists = true;
687         BPatch_process *proc = info->procsByPid[pid];
688         return proc;
689     } else {
690         if (exists) *exists = false;
691         return NULL;
692     }
693 }
694
695 BPatch_thread *BPatch::getThreadByPid(int pid, bool *exists)
696 {
697    BPatch_process *p = getProcessByPid(pid, exists);
698    if (!exists)
699       return NULL;
700    assert(p->threads.size() > 0);
701    return p->threads[0];
702 }
703
704
705 /*
706  * BPatch::getThreads
707  *
708  * Returns a vector of all threads that are currently defined.  Includes
709  * threads created directly using the library and those created with UNIX fork
710  * or Windows NT spawn system calls.  The caller is responsible for deleting
711  * the vector when it is no longer needed.
712  */
713 BPatch_Vector<BPatch_thread *> *BPatch::getThreadsInt()
714 {
715     BPatch_Vector<BPatch_thread *> *result = new BPatch_Vector<BPatch_thread *>;
716
717     dictionary_hash_iter<int, BPatch_process *> ti(info->procsByPid);
718
719     int pid;
720     BPatch_process *proc;
721
722     while (ti.next(pid, proc))
723     {
724        assert(proc);
725        assert(proc->threads.size() > 0);
726        result->push_back(proc->threads[0]);
727     }
728
729     return result;
730 }
731
732 /*
733  * BPatch::getProcs
734  *
735  * Returns a vector of all threads that are currently defined.  Includes
736  * threads created directly using the library and those created with UNIX fork
737  * or Windows NT spawn system calls.  The caller is responsible for deleting
738  * the vector when it is no longer needed.
739  */
740 BPatch_Vector<BPatch_process *> *BPatch::getProcessesInt()
741 {
742    BPatch_Vector<BPatch_process *> *result = new BPatch_Vector<BPatch_process *>;
743    dictionary_hash_iter<int, BPatch_process *> ti(info->procsByPid);
744
745    int pid;
746    BPatch_process *proc;
747    
748    while (ti.next(pid, proc))
749    {
750       assert(proc);
751       result->push_back(proc);
752    }
753    
754    return result;
755 }
756
757
758 /*
759  * BPatch::registerProvisionalThread
760  *
761  * Register a new process that is not yet associated with a thread.
762  * (this function is called only by createProcess).
763  *
764  * pid          The pid of the process to register.
765  */
766 void BPatch::registerProvisionalThread(int pid)
767 {
768     assert(!info->procsByPid.defines(pid));
769     info->procsByPid[pid] = NULL;
770 }
771
772
773 /*
774  * BPatch::registerForkedProcess
775  *
776  * Register a new process that is not yet associated with a thread.
777  * (this function is an upcall when a new process is created).
778  *
779  * parentPid            the pid of the parent process.
780  * childPid             The pid of the process to register.
781  * proc                 lower lever handle to process specific stuff
782  *
783  */
784 void BPatch::registerForkedProcess(process *parentProc, process *childProc)
785 {
786     int parentPid = parentProc->getPid();
787     int childPid = childProc->getPid();
788
789     forkexec_printf("BPatch: registering fork, parent %d, child %d\n",
790                     parentPid, childPid);
791     assert(getProcessByPid(childPid) == NULL);
792     
793     BPatch_process *parent = getProcessByPid(parentPid);
794     assert(parent);
795
796     BPatch_process *child = new BPatch_process(childProc);
797
798 #if defined(cap_async_events)
799     // We're already attached to the parent... let's see if the
800     // simple way works.
801     if (!getAsync()->mutateeDetach(child->lowlevel_process())) {
802         bperr("%s[%d]:  asyncEventHandler->mutateeDetach failed\n", __FILE__, __LINE__);
803     }
804    // if (!getAsync()->detachFromProcess(child)) {
805     //    bperr("%s[%d]:  asyncEventHandler->mutateeDetach failed\n", __FILE__, __LINE__);
806     //}
807     if (!getAsync()->connectToProcess(child->lowlevel_process())) {
808         bperr("%s[%d]:  asyncEventHandler->connectToProcess failed\n", __FILE__, __LINE__);
809     }
810     else 
811         asyncActive = true;
812 #endif
813     forkexec_printf("Successfully connected socket to child\n");
814     
815     pdvector<CallbackBase *> cbs;
816     getCBManager()->dispenseCallbacksMatching(evtPostFork,cbs);
817     
818     signalNotificationFD();
819     
820     for (unsigned int i = 0; i < cbs.size(); ++i) {
821
822         ForkCallback *cb = dynamic_cast<ForkCallback *>(cbs[i]);
823         if (cb) {
824             (*cb)(parent->threads[0], child->threads[0]);
825         }
826     }
827
828     child->isVisiblyStopped = false;
829     forkexec_printf("BPatch: finished registering fork, parent %d, child %d\n",
830                     parentPid, childPid);
831 }
832
833 /*
834  * BPatch::registerForkingThread
835  *
836  * Perform whatever processing is necessary when a thread enters
837  * a fork system call. Previously the preForkCallback was made directly.
838  *
839  * forkingPid   pid of the forking process
840  * proc                 lower lever handle to process specific stuff
841  *
842  */
843 void BPatch::registerForkingProcess(int forkingPid, process * /*proc*/)
844 {
845     BPatch_process *forking = getProcessByPid(forkingPid);
846     assert(forking);
847
848     signalNotificationFD();
849
850     pdvector<CallbackBase *> cbs;
851     getCBManager()->dispenseCallbacksMatching(evtPreFork,cbs);
852
853     for (unsigned int i = 0; i < cbs.size(); ++i) {
854
855         assert(cbs[i]);
856         ForkCallback *cb = dynamic_cast<ForkCallback *>(cbs[i]);
857         if (cb)
858             (*cb)(forking->threads[0], NULL);
859     }
860 }
861
862
863 /*
864  * BPatch::registerExecCleanup
865  *
866  * Register a process that has just entered exec
867  *
868  * Gives us some cleanup time
869  */
870
871 void BPatch::registerExecCleanup(process *p, char *) 
872 {
873     BPatch_process *execing = getProcessByPid(p->getPid());
874     assert(execing);
875
876     for (unsigned i=0; i<execing->threads.size(); i++)
877        registerThreadExit(p, execing->threads[i]->getTid(), false);
878
879     // tell the async that the process went away
880     getAsync()->cleanupProc(p);
881 }    
882
883 /*
884  * BPatch::registerExecExit
885  *
886  * Register a process that has just done an exec call.
887  *
888  * thread       thread that has just performed the exec
889  *
890  */
891
892 void BPatch::registerExecExit(process *proc)
893 {
894     int execPid = proc->getPid();
895     BPatch_process *process = getProcessByPid(execPid);
896     assert(process);
897
898    // build a new BPatch_image for this one
899    if (process->image)
900       process->image->removeAllModules();
901
902    process->image = new BPatch_image(process);
903
904    // The async pipe should be gone... handled in registerExecCleanup
905
906    signalNotificationFD();
907
908    //   for (unsigned i=0; i<process->threads.size(); i++)
909    //   process->deleteBPThread(process->threads[i]);
910
911 #if defined(cap_async_events)
912    //  I think in the case of exec that we do not need to re-initiate a async connection
913    //  to the process that exec'd 
914 #if 1 
915     if (!getAsync()->mutateeDetach(proc)) {
916         bperr("%s[%d]:  asyncEventHandler->mutateeDetach failed\n", __FILE__, __LINE__);
917     }
918
919    async_printf("%s[%d]:  about to connect to exec process\n", FILE__, __LINE__);
920
921    if (!getAsync()->connectToProcess(proc)) 
922    {
923       bperr("%s[%d]:  asyncEventHandler->connectToProcess failed\n", __FILE__, __LINE__);
924           async_printf("%s[%d]:  connect to exec process failed\n", FILE__, __LINE__);
925    } 
926    else
927    {
928       asyncActive = true;
929           async_printf("%s[%d]:  connect to exec process success\n", FILE__, __LINE__);
930    }
931
932 #else
933
934       asyncActive = true;
935           async_printf("%s[%d]:  connect to exec process skipped\n", FILE__, __LINE__);
936
937 #endif
938 #endif
939
940    if (!process->updateThreadInfo()) 
941    {
942            fprintf(stderr, "%s[%d]:  failed to updateThreadInfo after exec\n", FILE__, __LINE__);
943            return;
944    }
945
946     pdvector<CallbackBase *> cbs;
947     getCBManager()->dispenseCallbacksMatching(evtExec,cbs);
948     for (unsigned int i = 0; i < cbs.size(); ++i) {
949         ExecCallback *cb = dynamic_cast<ExecCallback *>(cbs[i]);
950         if (cb)
951             (*cb)(process->threads[0]);
952     }
953 }
954
955 void BPatch::registerNormalExit(process *proc, int exitcode)
956 {
957    if (!proc)
958       return;
959
960
961    int pid = proc->getPid();
962
963    BPatch_process *process = getProcessByPid(pid);
964
965    if (!process) return;
966
967    process->terminated = true;
968
969
970    BPatch_thread *thrd = process->getThreadByIndex(0);
971
972    process->setExitCode(exitcode);
973    process->setExitedNormally();
974    process->setUnreportedTermination(true);
975
976    signalNotificationFD();
977
978    pdvector<CallbackBase *> cbs;
979
980    if (thrd) {
981       getCBManager()->dispenseCallbacksMatching(evtThreadExit,cbs);
982       for (unsigned int i = 0; i < cbs.size(); ++i) {
983          AsyncThreadEventCallback *cb = dynamic_cast<AsyncThreadEventCallback *>(cbs[i]);
984          if (cb)
985             (*cb)(process, thrd);
986       }
987    }
988    cbs.clear();
989    getCBManager()->dispenseCallbacksMatching(evtProcessExit,cbs);
990    for (unsigned int i = 0; i < cbs.size(); ++i) {
991        ExitCallback *cb = dynamic_cast<ExitCallback *>(cbs[i]);
992        if (cb) {
993            signal_printf("%s[%d]:  about to register/wait for exit callback\n", FILE__, __LINE__);
994            (*cb)(process->threads[0], ExitedNormally);
995            signal_printf("%s[%d]:  exit callback done\n", FILE__, __LINE__);
996        }
997    }
998
999
1000    // We now run the process out; set its state to terminated. Really, the user shouldn't
1001    // try to do anything else with this, but we can get that happening.
1002    BPatch_process *stillAround = getProcessByPid(pid);
1003    if (stillAround) {
1004       stillAround->reportedExit = true;
1005       stillAround->terminated = true;
1006    }
1007 }
1008
1009 void BPatch::registerSignalExit(process *proc, int signalnum)
1010 {
1011    if (!proc)
1012       return;
1013
1014    int pid = proc->getPid();
1015
1016    BPatch_process *bpprocess = getProcessByPid(pid);
1017    if (!bpprocess) {
1018        // Error during startup can cause this -- we have a partially
1019        // constructed process object, but it was never registered with
1020        // bpatch
1021        return;
1022    }
1023    BPatch_thread *thrd = bpprocess->getThreadByIndex(0);
1024
1025    bpprocess->setExitedViaSignal(signalnum);
1026    bpprocess->setUnreportedTermination(true);
1027    bpprocess->terminated = true;
1028
1029    signalNotificationFD();
1030
1031    pdvector<CallbackBase *> cbs;
1032    if (thrd) {
1033       getCBManager()->dispenseCallbacksMatching(evtThreadExit,cbs);
1034       for (unsigned int i = 0; i < cbs.size(); ++i) {
1035          
1036          AsyncThreadEventCallback *cb = dynamic_cast<AsyncThreadEventCallback *>(cbs[i]);
1037          if (cb) 
1038             (*cb)(bpprocess, thrd);
1039       }
1040       cbs.clear();
1041       getCBManager()->dispenseCallbacksMatching(evtProcessExit,cbs);
1042       for (unsigned int i = 0; i < cbs.size(); ++i) {
1043          
1044          ExitCallback *cb = dynamic_cast<ExitCallback *>(cbs[i]);
1045          if (cb) {
1046             (*cb)(bpprocess->threads[0], ExitedViaSignal);
1047          }
1048       }
1049    }
1050    
1051    // We now run the process out; set its state to terminated. Really, the user shouldn't
1052    // try to do anything else with this, but we can get that happening.
1053    BPatch_process *stillAround = getProcessByPid(pid);
1054    if (stillAround) {
1055       stillAround->reportedExit = true;
1056       stillAround->terminated = true;
1057    }
1058
1059    // We need to clean this up... but the user still has pointers
1060    // into this code. Ugh.
1061    // Do not continue at this point; process is already gone.
1062
1063 }
1064
1065 bool BPatch::registerThreadCreate(BPatch_process *proc, BPatch_thread *newthr)
1066 {
1067    if (newthr->reported_to_user) {
1068       async_printf("%s[%d]:  NOT ISSUING CALLBACK:  thread %lu exists\n", 
1069                    FILE__, __LINE__, (long) newthr->getTid());
1070       return false;
1071    }
1072
1073    signalNotificationFD();
1074
1075    pdvector<CallbackBase *> cbs;
1076    getCBManager()->dispenseCallbacksMatching(evtThreadCreate, cbs);
1077   
1078    for (unsigned int i = 0; i < cbs.size(); ++i) {
1079       
1080       AsyncThreadEventCallback &cb = * ((AsyncThreadEventCallback *) cbs[i]);
1081       async_printf("%s[%d]:  before issuing thread create callback: tid %lu\n", 
1082                    FILE__, __LINE__, newthr->getTid());
1083       cb(proc, newthr);
1084    }
1085
1086    newthr->reported_to_user = true;
1087    BPatch::bpatch->mutateeStatusChange = true;
1088    proc->llproc->sh->signalEvent(evtThreadCreate);
1089
1090    return true;
1091 }
1092
1093
1094 void BPatch::registerThreadExit(process *proc, long tid, bool exiting)
1095 {
1096     if (!proc)
1097         return;
1098     
1099     int pid = proc->getPid();
1100     
1101     BPatch_process *bpprocess = getProcessByPid(pid);
1102     
1103     if (!bpprocess) {
1104         // Error during startup can cause this -- we have a partially
1105         // constructed process object, but it was never registered with
1106         // bpatch
1107         return;
1108     }
1109     BPatch_thread *thrd = bpprocess->getThread(tid);
1110     if (!thrd) {
1111         //If we don't have an BPatch thread, then it might have been an internal
1112         // thread that we decided not to report to the user (happens during 
1113         //  windows attach).  Just trigger the lower level clean up in this case.
1114         if (tid == 0) {
1115           fprintf(stderr, "%s[%d]:  about to deleteThread(0)\n", FILE__, __LINE__);
1116         }
1117         if (!exiting) proc->deleteThread(tid);        
1118         return;
1119     }
1120
1121     if (thrd->deleted_callback_made) { 
1122         // Thread exits; we make the callback, then the process exits and
1123         // tries to nuke it as well. This guards against that.
1124         return;
1125     }
1126
1127     signalNotificationFD();
1128
1129     thrd->deleted_callback_made = true;
1130     pdvector<CallbackBase *> cbs;
1131     getCBManager()->dispenseCallbacksMatching(evtThreadExit, cbs);
1132
1133     for (unsigned int i = 0; i < cbs.size(); ++i) {
1134
1135         AsyncThreadEventCallback *cb = dynamic_cast<AsyncThreadEventCallback *>(cbs[i]);
1136         mailbox_printf("%s[%d]:  executing thread exit callback\n", FILE__, __LINE__);
1137         if (cb) {
1138             cb->set_synchronous(true);
1139             (*cb)(bpprocess, thrd);
1140             cb->set_synchronous(false);
1141         }
1142     }
1143     if (exiting) 
1144        return;
1145     if (proc->execing())
1146        thrd->deleteThread(false);
1147     else
1148        thrd->deleteThread();
1149 }
1150
1151
1152
1153 /*
1154  * BPatch::registerLoadedModule
1155  *
1156  * Register a new module loaded by a process (e.g., dlopen)
1157  */
1158
1159 void BPatch::registerLoadedModule(process *process, mapped_module *mod) {
1160
1161     BPatch_process *bProc = BPatch::bpatch->getProcessByPid(process->getPid());
1162     if (!bProc) return; // Done
1163     BPatch_image *bImage = bProc->getImage();
1164     assert(bImage); // This we can assert to be true
1165     
1166     BPatch_module *bpmod = bImage->findOrCreateModule(mod);
1167
1168     signalNotificationFD();
1169     
1170     pdvector<CallbackBase *> cbs;
1171     
1172     if (! getCBManager()->dispenseCallbacksMatching(evtLoadLibrary, cbs)) {
1173         return;
1174     }
1175     for (unsigned int i = 0; i < cbs.size(); ++i) {
1176         DynLibraryCallback *cb = dynamic_cast<DynLibraryCallback *>(cbs[i]);
1177         if (cb)
1178             (*cb)(bProc->threads[0], bpmod, true);
1179     }
1180 }
1181
1182 /*
1183  * BPatch::registerUnloadedModule
1184  *
1185  * Register a new module loaded by a process (e.g., dlopen)
1186  */
1187
1188 void BPatch::registerUnloadedModule(process *process, mapped_module *mod) {
1189
1190     BPatch_process *bProc = BPatch::bpatch->getProcessByPid(process->getPid());
1191     if (!bProc) return; // Done
1192     BPatch_image *bImage = bProc->getImage();
1193     assert(bImage); // This we can assert to be true
1194     
1195     BPatch_module *bpmod = bImage->findModule(mod);
1196     if (bpmod == NULL) return;
1197
1198     signalNotificationFD();
1199     
1200     pdvector<CallbackBase *> cbs;
1201     
1202     // For now we use the same callback for load and unload of library....
1203     if (! getCBManager()->dispenseCallbacksMatching(evtLoadLibrary, cbs)) {
1204         return;
1205     }
1206     for (unsigned int i = 0; i < cbs.size(); ++i) {
1207         DynLibraryCallback *cb = dynamic_cast<DynLibraryCallback *>(cbs[i]);
1208         if (cb)
1209             (*cb)(bProc->threads[0], bpmod, false);
1210     }
1211
1212     bImage->removeModule(bpmod);
1213 }
1214
1215
1216 /*
1217  * BPatch::registerProcess
1218  *
1219  * Register a new BPatch_process object with the BPatch library (this function
1220  * is called only by the constructor for BPatch_process).
1221  *
1222  * process      A pointer to the process to register.
1223  */ 
1224 void BPatch::registerProcess(BPatch_process *process, int pid)
1225 {
1226    if (!pid)
1227       pid = process->getPid();
1228
1229    assert(!info->procsByPid.defines(pid) || !info->procsByPid[pid]);
1230    info->procsByPid[pid] = process;
1231 }
1232
1233
1234 /*
1235  * BPatch::unRegisterProcess
1236  *
1237  * Remove the BPatch_thread associated with a given pid from the list of
1238  * threads being managed by the library.
1239  *
1240  * pid          The pid of the thread to be removed.
1241  */
1242 void BPatch::unRegisterProcess(int pid, BPatch_process *proc)
1243 {
1244    if (pid == -1 || !info->procsByPid.defines(pid)) {
1245       // Deleting an exited process; search and nuke
1246       dictionary_hash_iter<int, BPatch_process *> procsIter(info->procsByPid);
1247       BPatch_process *p;
1248       int pid2;
1249       while (procsIter.next(pid2, p)) {
1250          if (p == proc) {
1251             info->procsByPid.undef(pid2);
1252             return;
1253          }
1254       }
1255    }
1256
1257    if (!info->procsByPid.defines(pid)) {
1258       char ebuf[256];
1259       sprintf(ebuf, "%s[%d]: no process %d defined in procsByPid\n", FILE__, __LINE__, pid);
1260       reportError(BPatchFatal, 68, ebuf);
1261       //fprintf(stderr, "%s[%d]:  ERROR, no process %d defined in procsByPid\n", FILE__,  __LINE__, pid);
1262       //dictionary_hash_iter<int, BPatch_process *> iter(info->procsByPid);
1263       //BPatch_process *p;
1264       //int pid;
1265       //while (iter.next(pid, p)) {
1266       //   fprintf(stderr, "%s[%d]:  have process %d\n", FILE__, __LINE__, pid);
1267       //}
1268       return;
1269    }
1270    assert(info->procsByPid.defines(pid));
1271    info->procsByPid.undef(pid); 
1272    assert(!info->procsByPid.defines(pid));
1273 }
1274
1275
1276 /*
1277  * BPatch::processCreateInt
1278  *
1279  * Create a process and return a BPatch_process representing it.
1280  * Returns NULL upon failure.
1281  *
1282  * path         The pathname of the executable for the new process.
1283  * argv         A list of the arguments for the new process, terminated by a
1284  *              NULL.
1285  * envp         A list of values that make up the environment for the new
1286  *              process, terminated by a NULL.  If envp is NULL, the new
1287  *              new process will inherit the environemnt of the parent.
1288  * stdin_fd     file descriptor to use for stdin for the application
1289  * stdout_fd    file descriptor to use for stdout for the application
1290  * stderr_fd    file descriptor to use for stderr for the application
1291
1292  */
1293 BPatch_process *BPatch::processCreateInt(const char *path, const char *argv[], 
1294                                          const char **envp, int stdin_fd, 
1295                                          int stdout_fd, int stderr_fd)
1296 {
1297    clearError();
1298
1299    if ( path == NULL ) { return NULL; }
1300
1301 #if !defined (os_windows)
1302    //  This might be ok on windows...  not 100%sure and it takes to long to build for
1303    //  the moment.
1304
1305    //  just a sanity check for the exitence of <path>
1306    struct stat statbuf;
1307    if (-1 == stat(path, &statbuf)) {
1308       char ebuf[2048];
1309       sprintf(ebuf, "createProcess(%s,...):  file does not exist\n", path);
1310       reportError(BPatchFatal, 68, ebuf);
1311       return NULL;
1312    }
1313
1314    //  and ensure its a regular file:
1315    if (!S_ISREG(statbuf.st_mode)) {
1316       char ebuf[2048];
1317       sprintf(ebuf, "createProcess(%s,...):  not a regular file \n", path);
1318       reportError(BPatchFatal, 68, ebuf);
1319       return NULL;
1320    }
1321
1322    //  and ensure its executable (does not check permissions):
1323    if (! ( (statbuf.st_mode & S_IXUSR)
1324             || (statbuf.st_mode & S_IXGRP)
1325             || (statbuf.st_mode & S_IXOTH) )) {
1326       char ebuf[2048];
1327       sprintf(ebuf, "createProcess(%s,...):  not an executable  \n", path);
1328       reportError(BPatchFatal, 68, ebuf);
1329       return NULL;
1330    }
1331 #endif
1332
1333    BPatch_process *ret = 
1334       new BPatch_process(path, argv, 
1335             envp, 
1336             stdin_fd, stdout_fd, stderr_fd);
1337
1338    if (!ret->llproc 
1339          ||  ret->llproc->status() != stopped 
1340          ||  !ret->llproc->isBootstrappedYet()) {
1341       ret->BPatch_process_dtor();  
1342       delete ret;
1343       reportError(BPatchFatal, 68, "create process failed bootstrap");
1344       return NULL;
1345    }
1346
1347 #if defined(cap_async_events)
1348    async_printf("%s[%d]:  about to connect to process\n", FILE__, __LINE__);
1349    if (!getAsync()->connectToProcess(ret->llproc)) {
1350       bpfatal("%s[%d]: asyncEventHandler->connectToProcess failed\n", __FILE__, __LINE__);
1351       fprintf(stderr,"%s[%d]: asyncEventHandler->connectToProcess failed\n", __FILE__, __LINE__);
1352       return NULL;
1353    }
1354    asyncActive = true;
1355 #endif
1356
1357    if (!ret->updateThreadInfo()) return NULL;
1358
1359    return ret;
1360 }
1361
1362 /*
1363  * BPatch::createProcess
1364  * This function is deprecated, see processCreate
1365  */
1366 BPatch_thread *BPatch::createProcessInt(const char *path, const char *argv[], 
1367                                          const char **envp, int stdin_fd, 
1368                                          int stdout_fd, int stderr_fd)
1369 {
1370    BPatch_process *ret = processCreateInt(path, argv, envp, stdin_fd, 
1371                                           stdout_fd, stderr_fd);
1372    if (!ret)
1373       return NULL;
1374
1375    assert(ret->threads.size() > 0);
1376    return ret->threads[0];
1377 }
1378
1379 /*
1380  * BPatch::processAttach
1381  *
1382  * Attach to a running process and return a BPatch_thread representing it.
1383  * Returns NULL upon failure.
1384  *
1385  * path         The pathname of the executable for the process.
1386  * pid          The id of the process to attach to.
1387  */
1388 BPatch_process *BPatch::processAttachInt(const char *path, int pid)
1389 {
1390    clearError();
1391    
1392    if (info->procsByPid.defines(pid)) {
1393       char msg[256];
1394       sprintf(msg, "attachProcess failed.  Dyninst is already attached to %d.",
1395               pid);
1396       reportError(BPatchWarning, 26, msg);      
1397       return NULL;
1398    }
1399
1400    BPatch_process *ret = new BPatch_process(path, pid);
1401
1402    if (!ret->llproc ||
1403        ret->llproc->status() != stopped ||
1404        !ret->llproc->isBootstrappedYet()) {
1405        ret->BPatch_process_dtor();  
1406        char msg[256];
1407        sprintf(msg,"attachProcess failed: process %d may now be killed!",pid);
1408        reportError(BPatchWarning, 26, msg);
1409        delete ret;
1410        return NULL;
1411    }
1412
1413 #if defined(cap_async_events)
1414    if (!getAsync()->connectToProcess(ret->llproc)) {
1415       bperr("%s[%d]:  asyncEventHandler->connectToProcess failed\n", __FILE__, __LINE__);
1416       return NULL;
1417    } 
1418    asyncActive = true;
1419 #endif
1420    if (!ret->updateThreadInfo()) return false;
1421
1422    return ret;
1423 }
1424
1425 /*
1426  * BPatch::attachProcess
1427  * This function is deprecated, see processAttach
1428  */
1429 BPatch_thread *BPatch::attachProcessInt(const char *path, int pid)
1430 {
1431    BPatch_process *proc = processAttachInt(path, pid);
1432    if (!proc)
1433       return NULL;
1434    
1435    assert(proc->threads.size() > 0);
1436    return proc->threads[0];
1437 }
1438
1439 /*
1440  * pollForStatusChange
1441  *
1442  * Checks for unreported changes to the status of any child process, and
1443  * returns true if any are detected.  Returns false otherwise.
1444  *
1445  * This function is declared as a friend of BPatch_thread so that it can use
1446  * the BPatch_thread::getThreadEvent call to check for status changes.
1447  */
1448 bool BPatch::pollForStatusChangeInt()
1449 {
1450     getMailbox()->executeCallbacks(FILE__, __LINE__);
1451
1452     clearNotificationFD();
1453     
1454     if (mutateeStatusChange) {
1455         mutateeStatusChange = false;
1456         return true;
1457     }
1458 #if defined(os_linux)
1459    //  This might only be needed on linux 2.4, but we need to manually check
1460    //  to see if any threads exited here, and, if they have...  kick the 
1461    //  appropriate signal generator to wake up
1462    dictionary_hash_iter<int, BPatch_process *> ti(info->procsByPid);
1463
1464    int pid;
1465    BPatch_process *proc;
1466    
1467    while (ti.next(pid, proc))
1468    {
1469       assert(proc);
1470       process *p = proc->llproc;
1471       assert(p);
1472       //  if the process has a rep lwp, it is not mt
1473       dyn_lwp *replwp = p->getRepresentativeLWP();
1474       if (replwp) continue;
1475       SignalGenerator *sg = p->getSG();
1476       // This guy exited, but we haven't deleted the procsByPid map
1477       if (!sg) continue;
1478
1479       if (sg->exists_dead_lwp()) {
1480         if (sg->isWaitingForOS()) {
1481           //  the signal generator is inside a waitpid, kick the mutatee to wake
1482           //  it up.
1483           sg->forceWaitpidReturn();
1484         }
1485       }
1486    }
1487 #endif
1488     return false;
1489 }
1490
1491
1492 /*
1493  * waitForStatusChange
1494  *
1495  * Blocks waiting for a change to occur in the running status of a child
1496  * process.  Returns true upon success, false upon failure.
1497  *
1498  * This function is declared as a friend of BPatch_thread so that it can use
1499  * the BPatch_thread::getThreadEvent call to check for status changes.
1500  */
1501 bool BPatch::waitForStatusChangeInt()
1502 {
1503
1504   getMailbox()->executeCallbacks(FILE__, __LINE__);
1505
1506   if (mutateeStatusChange) {
1507     mutateeStatusChange = false;
1508     clearNotificationFD();
1509     signal_printf("[%s:%u] - Returning due to immediate mutateeStatusChange\n", FILE__, __LINE__);
1510     return true;
1511   }
1512
1513   SignalGenerator *sh = NULL;
1514
1515   //  find a signal handler (in an active process)
1516   extern pdvector<process *> processVec;
1517   if (!processVec.size()) {
1518       clearNotificationFD();
1519       return false;
1520   }
1521
1522   for (unsigned int i = 0; i < processVec.size(); ++i) {
1523     if (processVec[i] && processVec[i]->status() != deleted) {
1524       sh = processVec[i]->sh;
1525       break;
1526     }
1527   } 
1528   if (!sh) {
1529     clearNotificationFD();
1530     return false;
1531   }
1532   eventType evt = evtUndefined;
1533   do {
1534    pdvector<eventType> evts;
1535    //evts.push_back(evtProcessStop);
1536    //evts.push_back(evtProcessExit);
1537    //evts.push_back(evtThreadCreate);
1538    //evts.push_back(evtThreadExit);
1539
1540    // I'm kinda confused... what about fork or exec? The above wouldn't wake us
1541    // up...
1542    //evts.push_back(evtSyscallExit);
1543    // Or a library load for that matter.
1544
1545    // We need to wait for anything; non-exits may cause a callback to be made
1546    // (without hitting an evtProcessStop)
1547    evts.push_back(evtAnyEvent);
1548
1549    waitingForStatusChange = true;
1550    getMailbox()->executeCallbacks(FILE__, __LINE__);
1551    if (mutateeStatusChange) break;
1552    signal_printf("Blocking in waitForStatusChange\n");
1553    evt = SignalGeneratorCommon::globalWaitForOneOf(evts);
1554   } while ((    evt != evtProcessStop ) 
1555             && (evt != evtProcessExit)
1556             && (evt != evtThreadExit)
1557            && (evt != evtThreadCreate));
1558
1559   signal_printf("Returning from waitForStatusChange, evt = %s, mutateeStatusChange = %d\n", eventType2str(evt), (int) mutateeStatusChange);
1560   waitingForStatusChange = false;
1561
1562   clearNotificationFD();
1563
1564   if (mutateeStatusChange) {
1565     mutateeStatusChange = false;
1566     return true;
1567   }
1568   //  we waited for a change, but didn't get it
1569   signal_printf("%s[%d]:  Error in status change reporting\n", FILE__, __LINE__);
1570   return false;
1571 }
1572
1573 /*
1574  * createEnum
1575  *
1576  * This function is a wrapper for the BPatch_type constructors for API/User
1577  * created types.
1578  *
1579  * It returns a pointer to a BPatch_type that was added to the APITypes
1580  * collection.
1581  */
1582 BPatch_type * BPatch::createEnumInt( const char * name, 
1583                                      BPatch_Vector<char *> &elementNames,
1584                                      BPatch_Vector<int> &elementIds)
1585 {
1586     if (elementNames.size() != elementIds.size()) {
1587       return NULL;
1588     }
1589     string typeName = name;
1590     vector<pair<string, int> *>elements;
1591     for (unsigned int i=0; i < elementNames.size(); i++) 
1592         elements.push_back(new pair<string, int>(elementNames[i], elementIds[i]));
1593     
1594     Type *typ = typeEnum::create( typeName, elements);
1595     if (!typ) return NULL;
1596     
1597     BPatch_type *newType = new BPatch_type(typ);
1598     if (!newType) return NULL;
1599     
1600     APITypes->addType(newType);
1601
1602     return(newType);
1603 }
1604
1605
1606 /*
1607  * createEnum
1608  *
1609  * This function is a wrapper for the BPatch_type constructors for API/User
1610  * created types.  The user has left element id specification to us
1611  *
1612  * It returns a pointer to a BPatch_type that was added to the APITypes
1613  * collection.
1614  */
1615 BPatch_type * BPatch::createEnumAutoId( const char * name, 
1616                                         BPatch_Vector<char *> &elementNames)
1617 {
1618     string typeName = name;
1619     vector<pair<string, int> *>elements;
1620     for (unsigned int i=0; i < elementNames.size(); i++) 
1621         elements.push_back(new pair<string, int>(elementNames[i], i));
1622     
1623     Type *typ = typeEnum::create( typeName, elements);
1624     if (!typ) return NULL;
1625     
1626     BPatch_type *newType = new BPatch_type(typ);
1627     if (!newType) return NULL;
1628     
1629     APITypes->addType(newType);
1630
1631     return(newType);
1632 }
1633
1634 /*
1635  * createStructs
1636  *
1637  * This function is a wrapper for the BPatch_type constructors for API/User
1638  * created types.
1639  *
1640  * It returns a pointer to a BPatch_type that was added to the APITypes
1641  * collection.
1642  */
1643
1644 BPatch_type * BPatch::createStructInt( const char * name,
1645                                        BPatch_Vector<char *> &fieldNames,
1646                                        BPatch_Vector<BPatch_type *> &fieldTypes)
1647 {
1648    unsigned int i;
1649    
1650    if (fieldNames.size() != fieldTypes.size()) {
1651       return NULL;
1652    }
1653    
1654    string typeName = name;
1655    vector<pair<string, Type *> *> fields;
1656    for(i=0; i<fieldNames.size(); i++)
1657    {
1658       if(!fieldTypes[i])
1659          return NULL;
1660       fields.push_back(new pair<string, Type *> (fieldNames[i], fieldTypes[i]->getSymtabType()));
1661    }    
1662    
1663    Type *typ = typeStruct::create(typeName, fields);
1664    if (!typ) return NULL;
1665    
1666    BPatch_type *newType = new BPatch_type(typ);
1667    if (!newType) return NULL;
1668    
1669    APITypes->addType(newType);
1670    
1671    return(newType);
1672 }
1673
1674 /*
1675  * createUnions
1676  *
1677  * This function is a wrapper for the BPatch_type constructors for API/User
1678  * created types.
1679  *
1680  * It returns a pointer to a BPatch_type that was added to the APITypes
1681  * collection.
1682  */
1683
1684 BPatch_type * BPatch::createUnionInt( const char * name, 
1685                                       BPatch_Vector<char *> &fieldNames,
1686                                       BPatch_Vector<BPatch_type *> &fieldTypes)
1687 {
1688     unsigned int i;
1689     
1690     if (fieldNames.size() != fieldTypes.size()) {
1691       return NULL;
1692     }
1693
1694     string typeName = name;
1695     vector<pair<string, Type *> *> fields;
1696     for(i=0; i<fieldNames.size(); i++)
1697     {
1698         if(!fieldTypes[i])
1699             return NULL;
1700         fields.push_back(new pair<string, Type *> (fieldNames[i], fieldTypes[i]->getSymtabType()));
1701     }   
1702     
1703     Type *typ = typeUnion::create(typeName, fields);
1704     if (!typ) return NULL;
1705     
1706     BPatch_type *newType = new BPatch_type(typ);
1707     if (!newType) return NULL;
1708
1709     APITypes->addType(newType);
1710
1711     return(newType);
1712 }    
1713
1714 /*
1715  * createArray for Arrays and SymTypeRanges
1716  *
1717  * This function is a wrapper for the BPatch_type constructors for API/User
1718  * created types.
1719  *
1720  * It returns a pointer to a BPatch_type that was added to the APITypes
1721  * collection.
1722  */
1723 BPatch_type * BPatch::createArrayInt( const char * name, BPatch_type * ptr,
1724                                       unsigned int low, unsigned int hi)
1725 {
1726
1727     BPatch_type * newType;
1728     if (!ptr) 
1729         return NULL;
1730         
1731     string typeName = name;
1732     Type *typ = typeArray::create(typeName, ptr->getSymtabType(), low, hi);
1733     if (!typ) return NULL;
1734     
1735     newType = new BPatch_type(typ);
1736     if (!newType) return NULL;
1737
1738     APITypes->addType(newType);
1739     return newType;
1740 }
1741
1742 /*
1743  * createPointer for BPatch_pointers
1744  *
1745  * This function is a wrapper for the BPatch_type constructors for API/User
1746  * created types.
1747  *
1748  * It returns a pointer to a BPatch_type that was added to the APITypes
1749  * collection.
1750  */
1751 BPatch_type * BPatch::createPointerInt(const char * name, BPatch_type * ptr,
1752                                        int /*size*/)
1753 {
1754     BPatch_type * newType;
1755     if(!ptr)
1756         return NULL;
1757     
1758     string typeName = name;
1759     Type *typ = typePointer::create(typeName, ptr->getSymtabType());
1760     if (!typ) return NULL;
1761     
1762     newType = new BPatch_type(typ);
1763     if (!newType) return NULL;
1764
1765     APITypes->addType(newType);
1766     return newType;
1767 }
1768
1769 /*
1770  * createScalar for scalars with a size and no range
1771  *
1772  * This function is a wrapper for the BPatch_type constructors for API/User
1773  * created types.
1774  *
1775  * It returns a pointer to a BPatch_type that was added to the APITypes
1776  * collection.
1777  */
1778
1779 BPatch_type * BPatch::createScalarInt( const char * name, int size)
1780 {
1781     BPatch_type * newType;
1782     
1783     string typeName = name;
1784     Type *typ = typeScalar::create(typeName, size);
1785     if (!typ) return NULL;
1786     
1787     newType = new BPatch_type(typ);
1788     if (!newType) return NULL;
1789
1790     APITypes->addType(newType);
1791     return newType;
1792 }
1793
1794 /*
1795  * createType for typedefs
1796  *
1797  * This function is a wrapper for the BPatch_type constructors for API/User
1798  * created types.
1799  *
1800  * It returns a pointer to a BPatch_type that was added to the APITypes
1801  * collection.
1802  */
1803 BPatch_type * BPatch::createTypedefInt( const char * name, BPatch_type * ptr)
1804 {
1805     BPatch_type * newType;
1806     if(!ptr)
1807         return NULL;
1808     
1809     string typeName = name;
1810     Type *typ = typeTypedef::create(typeName, ptr->getSymtabType());
1811     if (!typ) return NULL;
1812     
1813     newType = new BPatch_type(typ);
1814     if (!newType) return NULL;
1815
1816     APITypes->addType(newType);
1817     return newType;
1818 }
1819
1820 bool BPatch::waitUntilStoppedInt(BPatch_thread *appThread){
1821
1822    bool ret = false;
1823
1824    while (1) {
1825      __LOCK;
1826      if (!appThread->isStopped() && !appThread->isTerminated()) {
1827        __UNLOCK;
1828        this->waitForStatusChange();
1829      }
1830      else {
1831        __UNLOCK;
1832        break;
1833      }
1834    }
1835
1836    __LOCK;
1837
1838         if (!appThread->isStopped())
1839         {
1840                 cerr << "ERROR : process did not signal mutator via stop"
1841                      << endl;
1842                 ret = false;
1843                 goto done;
1844         }
1845 #if defined(i386_unknown_nt4_0) || \
1846     defined(mips_unknown_ce2_11)
1847         else if((appThread->stopSignal() != EXCEPTION_BREAKPOINT) && 
1848                 (appThread->stopSignal() != -1))
1849         {
1850                 cerr << "ERROR : process stopped on signal different"
1851                      << " than SIGTRAP" << endl;
1852                 ret =  false;
1853                 goto done;
1854         }
1855 #else
1856         else if ((appThread->stopSignal() != SIGSTOP) &&
1857 #if defined(bug_irix_broken_sigstop)
1858                  (appThread->stopSignal() != SIGEMT) &&
1859 #endif 
1860                  (appThread->stopSignal() != SIGHUP)) {
1861                 cerr << "ERROR :  process stopped on signal "
1862                      << "different than SIGSTOP" << endl;
1863                 ret =  false;
1864                 goto done;
1865         }
1866 #endif
1867
1868   done:
1869    __UNLOCK;
1870
1871   return ret;
1872 }
1873
1874 BPatch_stats &BPatch::getBPatchStatisticsInt()
1875 {
1876   updateStats();
1877   return stats;
1878 }
1879 //  updateStats() -- an internal function called before returning
1880 //  statistics buffer to caller of BPatch_getStatistics(),
1881 //  -- just copies global variable statistics counters into 
1882 //  the buffer which is returned to the user.
1883 void BPatch::updateStats() 
1884 {
1885   stats.pointsUsed = pointsUsed.value();
1886   stats.totalMiniTramps = totalMiniTramps.value();
1887   stats.trampBytes = trampBytes.value();
1888   stats.ptraceOtherOps = ptraceOtherOps.value();
1889   stats.ptraceOps = ptraceOps.value();
1890   stats.ptraceBytes = ptraceBytes.value();
1891   stats.insnGenerated = insnGenerated.value();
1892 }
1893
1894 bool BPatch::registerThreadEventCallbackInt(BPatch_asyncEventType type,
1895                                             BPatchAsyncThreadEventCallback func)
1896 {
1897     
1898     eventType evt;
1899     switch (type) {
1900       case BPatch_threadCreateEvent: evt = evtThreadCreate; break;
1901       case BPatch_threadDestroyEvent: evt = evtThreadExit; break;
1902       default:
1903         fprintf(stderr, "%s[%d]:  Cannot register callback for type %s\n",
1904                FILE__, __LINE__, asyncEventType2Str(type));
1905         return false; 
1906     };
1907
1908     pdvector<CallbackBase *> cbs;
1909     getCBManager()->removeCallbacks(evt, cbs);
1910     
1911     bool ret;
1912     if (func != 0) {
1913         AsyncThreadEventCallback *cb = new AsyncThreadEventCallback(func);
1914         ret = getCBManager()->registerCallback(evt, cb);
1915     }
1916     else {
1917         // For consistency with fork, exit, ... callbacks, treat
1918         // func == 0 as a remove-all-callbacks-of-type-x request
1919         ret = true;
1920     }
1921     return ret;
1922 }
1923
1924 bool BPatch::removeThreadEventCallbackInt(BPatch_asyncEventType type,
1925                                           BPatchAsyncThreadEventCallback cb)
1926 {
1927     eventType evt;
1928     switch (type) {
1929       case BPatch_threadCreateEvent: evt = evtThreadCreate; break;
1930       case BPatch_threadDestroyEvent: evt = evtThreadExit; break;
1931       default:
1932         fprintf(stderr, "%s[%d]:  Cannot remove callback for type %s\n",
1933                FILE__, __LINE__, asyncEventType2Str(type));
1934         return false; 
1935     };
1936
1937     pdvector<CallbackBase *> cbs;
1938     if (!getCBManager()->removeCallbacks(evt, cbs)) {
1939         fprintf(stderr, "%s[%d]:  Cannot remove callback for type %s, not found\n",
1940                FILE__, __LINE__, asyncEventType2Str(type));
1941         return false;
1942     }
1943
1944     //  See if supplied function was in the set of removed functions
1945     bool ret = false;
1946     for (int i = cbs.size() -1; i >= 0; i--) {
1947       AsyncThreadEventCallback *test = (AsyncThreadEventCallback *)cbs[i];
1948       if (test->getFunc() == cb) {
1949         //  found it, destroy it
1950         VECTOR_ERASE(cbs,i,i);
1951         ret = true;
1952         delete test;
1953       } 
1954     }
1955
1956     //  we deleted any found target functions, put the others back.
1957     for (unsigned int i = 0; i < cbs.size(); ++i) 
1958        if (!getCBManager()->registerCallback(evt, cbs[i]))
1959           ret = false;
1960
1961     return ret;
1962 }
1963
1964 bool BPatch::registerDynamicCallCallbackInt(BPatchDynamicCallSiteCallback func)
1965 {
1966     pdvector<CallbackBase *> cbs;
1967     DynamicCallsiteCallback *cb = new DynamicCallsiteCallback(func);
1968     getCBManager()->removeCallbacks(evtDynamicCall, cbs);
1969     bool ret = getCBManager()->registerCallback(evtDynamicCall, cb);
1970
1971     return ret;
1972 }
1973
1974 bool BPatch::removeDynamicCallCallbackInt(BPatchDynamicCallSiteCallback func)
1975 {
1976
1977     pdvector<CallbackBase *> cbs;
1978     if (!getCBManager()->removeCallbacks(evtDynamicCall, cbs)) {
1979         fprintf(stderr, "%s[%d]:  Cannot remove callback for type evtDynamicCall, not found\n",
1980                FILE__, __LINE__);
1981         return false;
1982     }
1983
1984     //  See if supplied function was in the set of removed functions
1985     bool ret = false;
1986     for (int i = cbs.size() -1; i >= 0; i--) {
1987       DynamicCallsiteCallback *test = (DynamicCallsiteCallback *)cbs[i];
1988       if (test->getFunc() == func) {
1989         //  found it, destroy it
1990         VECTOR_ERASE(cbs,i,i);
1991         ret = true;
1992         delete test;
1993       } 
1994     }
1995
1996     //  we deleted any found target functions, put the others back.
1997     for (unsigned int i = 0; i < cbs.size(); ++i) 
1998        if (!getCBManager()->registerCallback(evtDynamicCall, cbs[i]))
1999           ret = false;
2000
2001     return ret;
2002 }
2003
2004 bool BPatch::registerUserEventCallbackInt(BPatchUserEventCallback func)
2005 {
2006   pdvector<CallbackBase *> cbs;
2007   UserEventCallback *cb = new UserEventCallback(func);
2008   bool ret = getCBManager()->registerCallback(evtUserEvent, cb);
2009
2010   return ret;
2011 }
2012
2013 bool BPatch::removeUserEventCallbackInt(BPatchUserEventCallback cb)
2014 {
2015     bool ret = false;
2016     pdvector<CallbackBase *> cbs;
2017     if (!getCBManager()->removeCallbacks(evtUserEvent, cbs)) {
2018         fprintf(stderr, "%s[%d]:  Cannot remove callback evtUserEvent, not found\n",
2019                FILE__, __LINE__);
2020         return false;
2021     }
2022
2023     //  See if supplied function was in the set of removed functions
2024     for (int i = cbs.size() -1; i >= 0; i--) {
2025       UserEventCallback *test = (UserEventCallback *)cbs[i];
2026       if (test->getFunc() == cb) {
2027         //  found it, destroy it
2028         VECTOR_ERASE(cbs,i,i);
2029         ret = true;
2030         delete test;
2031       } 
2032     }
2033
2034     //  we deleted any found target functions, put the others back.
2035     for (unsigned int i = 0; i < cbs.size(); ++i) 
2036        if (!getCBManager()->registerCallback(evtUserEvent, cbs[i]))
2037           ret = false;
2038
2039     return ret;
2040 }
2041
2042 bool BPatch::registerSignalHandlerCallbackInt(BPatchSignalHandlerCallback func,
2043                                               BPatch_Set<long> *signums)
2044 {
2045     pdvector<CallbackBase *> cbs;
2046     getCBManager()->removeCallbacks(evtSignalHandlerCB, cbs);
2047     SignalHandlerCallback *cb = new SignalHandlerCallback(func, signums);
2048     bool ret = getCBManager()->registerCallback(evtSignalHandlerCB, cb);
2049     return ret;
2050 }
2051
2052 bool BPatch::removeSignalHandlerCallbackInt(BPatchSignalHandlerCallback cb)
2053 {
2054     bool ret = false;
2055     pdvector<CallbackBase *> cbs;
2056     if (!getCBManager()->removeCallbacks(evtSignalHandlerCB, cbs)) {
2057         fprintf(stderr, "%s[%d]:  Cannot remove callback for evtSignalHandlerCB,"
2058                 " not found\n", FILE__, __LINE__);
2059         return false;
2060     }
2061
2062     //  See if supplied function was in the set of removed functions
2063     for (int i = cbs.size() -1; i >= 0; i--) {
2064         SignalHandlerCallback *test = (SignalHandlerCallback *)cbs[i];
2065         if (test->getFunc() == cb) {
2066             //  found it, destroy it
2067             VECTOR_ERASE(cbs,i,i);
2068             ret = true;
2069             delete test;
2070         } 
2071     }
2072
2073     //  we deleted any found target functions, put the others back.
2074     for (unsigned int i = 0; i < cbs.size(); ++i) 
2075         if (!getCBManager()->registerCallback(evtSignalHandlerCB, cbs[i]))
2076             ret = false;
2077
2078     return ret;
2079 }
2080
2081
2082 void BPatch::continueIfExists(int pid) 
2083 {
2084     BPatch_process *proc = getProcessByPid(pid);
2085     if (!proc) return;
2086
2087     // Set everything back to the way it was...
2088     // We use async continue here to _be sure_ that the SH
2089     // that we're in runs to completion, instead of blocking
2090     // on someone else.
2091
2092     if (proc->isAttemptingAStop) {
2093         return;
2094     }
2095
2096     proc->isVisiblyStopped = false;
2097
2098     proc->llproc->sh->overrideSyncContinueState(runRequest);
2099
2100     proc->llproc->sh->continueProcessAsync();
2101 }
2102
2103 ////////////// Signal FD functions
2104
2105 void BPatch::signalNotificationFD() {
2106 #if !defined(os_windows)
2107     // If the FDs are set up, write a byte to the input side.
2108     createNotificationFD();
2109
2110     if (notificationFDInput_ == -1) return;
2111     if (FDneedsPolling_) return;
2112
2113     char f = (char) 42;
2114
2115     int ret = write(notificationFDInput_, &f, sizeof(char));
2116
2117     if (ret == -1)
2118         perror("Notification write");
2119     else 
2120         FDneedsPolling_ = true;
2121 #endif
2122     return;
2123 }
2124
2125 void BPatch::clearNotificationFD() {
2126 #if !defined(os_windows)
2127     if (notificationFDOutput_ == -1) return;
2128     if (!FDneedsPolling_) return;
2129     char buf;
2130
2131     read(notificationFDOutput_, &buf, sizeof(char));
2132     FDneedsPolling_ = false;
2133 #endif
2134     return;
2135 }
2136
2137 void BPatch::createNotificationFD() {
2138 #if !defined(os_windows)
2139     if (notificationFDOutput_ == -1) {
2140         assert(notificationFDInput_ == -1);
2141         int pipeFDs[2];
2142         pipeFDs[0] = pipeFDs[1] = -1;
2143         int ret = pipe(pipeFDs);
2144         if (ret == 0) {
2145             notificationFDOutput_ = pipeFDs[0];
2146             notificationFDInput_ = pipeFDs[1];
2147         }
2148     }
2149 #endif
2150 }
2151
2152 int BPatch::getNotificationFDInt() {
2153 #if !defined(os_windows)
2154     createNotificationFD();
2155     return notificationFDOutput_;
2156 #else
2157     return -1;
2158 #endif
2159 }
2160
2161 /* If true, we return just filenames when the user asks for line info
2162    otherwise, we return filename plus path information. */
2163 void BPatch::truncateLineInfoFilenamesInt(bool newval) {
2164    mapped_module::truncateLineFilenames = newval;
2165 }
2166
2167 void BPatch::getBPatchVersionInt(int &major, int &minor, int &subminor) 
2168 {
2169    major = DYNINST_MAJOR;
2170    minor = DYNINST_MINOR;
2171    subminor = DYNINST_SUBMINOR;
2172 }
2173
2174 BPatch_binaryEdit *BPatch::openBinaryInt(const char *path, bool openDependencies /* = false */) {
2175    BPatch_binaryEdit *editor = new BPatch_binaryEdit(path, openDependencies);
2176    if (!editor)
2177       return NULL;
2178    if (editor->creation_error) {
2179       delete editor;
2180       return NULL;
2181    }
2182    return editor;
2183 }
2184
2185 void BPatch::setInstrStackFramesInt(bool r)
2186 {
2187    instrFrames = r;
2188 }
2189
2190 bool BPatch::getInstrStackFramesInt()
2191 {
2192    return instrFrames;
2193 }