Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / signalgenerator.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 // $Id: signalhandler.C,v 
33
34 #include <string>
35 #include "process.h"
36 #include "dyn_lwp.h"
37 #include "dyn_thread.h"
38 #include "callbacks.h"
39 #include "function.h"
40 #include "common/h/stats.h"
41 #include "signalhandler.h"
42 #include "signalgenerator.h"
43 #include "mapped_object.h"
44 #include "eventgate.h"
45 //  signal_generator_counter is used to generate identifier strings
46 //  for signal generator threads.  eg SYNC1, SYNC2, SYNC3
47
48 unsigned signal_generator_counter = 0;
49 eventLock *SignalGeneratorCommon::global_wait_list_lock;
50 pdvector<EventGate *> *SignalGeneratorCommon::global_wait_list;
51 global_wait_list_init_t SignalGeneratorCommon::wlinit;
52
53 global_wait_list_init_t::global_wait_list_init_t()
54 {
55   SignalGeneratorCommon::global_wait_list = new pdvector<EventGate *>();
56   SignalGeneratorCommon::global_wait_list_lock = new eventLock();
57 }
58
59 const char *processRunStateStr(processRunState_t runState) {
60     switch (runState) {
61     case unsetRequest: return "unset";
62     case stopRequest: return "stopped";
63     case runRequest: return "run";
64     case ignoreRequest: return "ignoring";
65     default: assert(0); return "<ASSERT FAILURE>";
66     }
67     return "<IMPOSSIBLE CASE";
68 }
69
70
71 /*
72  * So here's the deal. We want to basically use this structure:
73  *
74  * TOP
75  *   if process is paused:
76  *     wait until it runs.
77  *     goto TOP
78  *   if process is not paused:
79  *     wait for an OS event
80  *       ... set process state to paused
81  *     decode the event (lowlevel data -> high level representation)
82  *     dispatch the event to a signal handler
83  *     goto TOP
84  *
85  * So basically we sit there looping. There are some complications, though. 
86  * The structure (with locking) looks like so: (( is taking the global lock, ))
87  * releasing it.
88  *
89  *
90  * TOP
91  *  ((
92  *   if process is paused:
93  *     ))
94  *     wait until it runs.
95  *     goto TOP
96  *   if process is not paused:
97  *     ))
98  *     wait for an OS event
99  *     ((
100  *     set process state to paused
101  *     decode the event (lowlevel data -> high level representation)
102  *     dispatch the event to a signal handler
103  *     ))
104  *     goto TOP
105  *
106  * But what of UI thread interaction? We don't have a way of handing off
107  * control between the signal generator and the signal handler, so the UI
108  * thread may try and get in between those. We avoid that by considering the
109  * signalgenerator "active" from the decode stage until there are no running
110  * signal handlers. Also, the UI thread may race with the return from poll/waitpid
111  * (as those are unlocked). To avoid the second, we recheck the process status
112  * when poll/waitpid returns, leading to:
113  *
114  * TOP
115  *  ((
116  *   if process is paused:
117  *     Collect continue events; when neither the UI thread nor any
118  *       handler thread is executing, continue the process.
119  *     ))
120  *     wait until it runs.
121  *     goto TOP
122  *   if process is not paused:
123  *     ))
124  *     wait for an OS event
125  *     ((
126  *     if process is pausing:
127  *        signal return of poll to pausing thread
128  *     set process state to paused
129  *     decode the event (lowlevel data -> high level representation)
130  *     dispatch the event to a signal handler
131  *     ))
132  *     goto TOP
133  *
134  * Confused yet?
135  */
136
137 void SignalGeneratorCommon::main() {
138     MONITOR_ENTRY();
139
140     addToThreadMap();
141     
142     startupLock->_Lock(FILE__, __LINE__);
143     signal_printf("%s[%d]:  about to do init for %s\n", FILE__, __LINE__, idstr);
144     if (!initialize_event_handler()) {
145         signal_printf("%s[%d]: initialize event handler failed, %s returning\n", FILE__, __LINE__, idstr);
146         _isRunning = false;
147         init_ok = false; 
148         // For anyone who asks later
149         stop_request = true; 
150
151         removeFromThreadMap();
152
153         startupLock->_Broadcast(FILE__, __LINE__);
154         startupLock->_Unlock(FILE__, __LINE__);
155         return;
156     }
157     
158     init_ok = true;
159     signal_printf("%s[%d]:  init success for %s\n", FILE__, __LINE__, idstr);
160     
161     _isRunning = true;
162     startupLock->_Broadcast(FILE__, __LINE__);
163     startupLock->_Unlock(FILE__, __LINE__);
164     
165     signal_printf("%s[%d]:  before main loop for %s\n", __FILE__, __LINE__, idstr);
166
167     eventlock->_Lock(FILE__, __LINE__);
168     pdvector<EventRecord> events;
169     while (1) {
170         // TOP
171         signal_printf("%s[%d]: signal generator at top of loop\n", FILE__, __LINE__);
172         assert(haveLock());
173         
174         if (exitRequested() && !requested_wait_until_active) {
175             signal_printf("%s[%d]: exit request (loop top)\n", FILE__, __LINE__);
176             break;
177         }
178
179         // If there is an event to handle, then keep going. 
180         if (processIsPaused() || requested_wait_until_active) {
181             signal_printf("%s[%d]: process is paused, waiting (loop top)\n", FILE__, __LINE__);
182             // waitForActive... used to unlock/relock the global mutex. 
183             waitForActivation();
184
185             // Check for process detach/exit...
186             signal_printf("%s[%d]: post-activation, process status %s\n",
187                           FILE__, __LINE__, 
188                           proc ? proc->getStatusAsString().c_str() : "NULL");
189
190             // We blocked; therefore, check to see if the process is gone
191             if( exitRequested() ) {
192                 signal_printf("%s[%d]: exit request (post-waitForActivation)\n", FILE__, __LINE__);
193                 break;
194             }            
195
196             // waitForActiveProcess will return when everyone agrees that the process should
197             // run. This means:
198             // 1) All signal handlers are either done or waiting in a callback;
199             // 2) If there was a pause request from BPatch, then there has been a run request.
200             if (continueRequired())  {
201                 continueProcessInternal();
202             }
203             // Post cleanup
204             // Cleanup...
205
206             asyncRunWhenFinished_ = unsetRequest;
207             // Commented out; set by BPatch layer
208             //syncRunWhenFinished_ = unsetRequest;
209         }
210
211         postSignalHandler();
212
213         // Process not paused
214         signal_printf("%s[%d]: Grabbing event\n", FILE__, __LINE__);
215
216         getEvents(events);
217
218         checkActiveProcess();
219
220         if (exitRequested()) {
221             signal_printf("%s[%d]: exit request (post-getEvent)\n", FILE__, __LINE__);
222             break;
223         }
224
225         signal_printf("%s[%d]: decoding event\n", FILE__, __LINE__);
226         decodingEvent_ = true;
227         // Translate everything in the events_to_handle vector from low-level
228         // (OS return) to high-level (Dyninst event)
229
230         decodeEvents(events);
231
232         // Overlapping control areas...
233         dispatchingEvent_ = true; decodingEvent_ = false;
234         
235         for (unsigned i = 0; i < events.size(); i++) {
236             signal_printf("%s[%d]: dispatching event %d\n", FILE__, __LINE__, i);
237             dispatchEvent(events[i]);
238         }
239         events.clear();
240         dispatchingEvent_ = false;
241     }        
242
243     // We're going down...
244     signalEvent(evtShutDown);
245
246
247     while(numBlockedForContinue) {
248         waitForContinueLock->_Lock(FILE__, __LINE__);
249         eventlock->_Unlock(FILE__, __LINE__);
250         waitForContinueLock->_Broadcast(FILE__, __LINE__);
251         waitForContinueLock->_Unlock(FILE__, __LINE__);
252         eventlock->_Lock(FILE__, __LINE__);
253     }
254
255     // Grab exit lock...
256     signal_printf("%s[%d]: SG grabbing exit lock\n", FILE__, __LINE__);
257     waitForHandlerExitLock->_Lock(FILE__, __LINE__);
258
259     signal_printf("%s[%d]: SG releasing global mutex...\n", FILE__, __LINE__);
260     eventlock->_Unlock(FILE__, __LINE__);
261
262     // And set all handlers to exit
263     for (unsigned i = 0; i < handlers.size(); i++) {
264         // Force exit of signal handler
265         handlers[i]->stop_request = true;
266         if (handlers[i]->waitingForWakeup_) {
267             handlers[i]->waitLock->_Broadcast(FILE__, __LINE__);
268         }
269     }
270
271     signal_printf("%s[%d]: SG waiting for handlers to exit\n", FILE__, __LINE__);
272     while(handlers.size()) {
273         waitForHandlerExitLock->_WaitForSignal(FILE__, __LINE__);
274     }
275
276     eventlock->_Lock(FILE__, __LINE__);
277             
278
279     waitForHandlerExitLock->_Unlock(FILE__, __LINE__);
280
281     // The pointer is owned by the BPatch_process, since it can
282     // be deleted by the BPatch user. So we can't delete it; 
283     // however, we can (and should) call deleteProcess so that it
284     // gets cleaned up
285     // Proc may be null if initialization failed; in this case,
286     // don't try to clean up.
287     if (proc) {
288         proc->deleteProcess();
289         // Set our process pointer to NULL; DO NOT DELETE!!!
290         // DO NOT DELETE
291         proc->sh = NULL;
292         proc = NULL;
293     }
294
295     thread_printf("%s[%d]: removing from thread map\n", FILE__, __LINE__);
296     removeFromThreadMap();
297     
298     _isRunning = false;
299     if (eventlock->depth() != 1) {
300         fprintf(stderr, "%s[%d]:  WARNING:  global_mutex->depth() is %d, leaving thread %s\n",
301                 FILE__, __LINE__, global_mutex->depth(),idstr);
302         global_mutex->printLockStack();
303     }
304     global_mutex->_Broadcast(FILE__, __LINE__);
305     global_mutex->_Unlock(FILE__, __LINE__);
306     
307     thread_printf("%s[%d][%s]:  SignalGenerator::main exiting\n", FILE__, __LINE__, idstr);
308
309     MONITOR_EXIT();
310 }
311
312 bool SignalGeneratorCommon::exitRequested() 
313 {
314     // Commented out for reference: we handle this at
315     // dispatch time. 
316     //    if (ev.type == evtShutdown) return true;
317
318     if (stop_request)
319         return true;
320
321     if (!proc) {
322         // This can be called if there is no process; failed fork, for instance.
323         return false;
324     }
325
326     if (proc->status() == deleted)
327         return true;
328     if (proc->status() == exited)
329         return true;
330     if (proc->status() == detached)
331         return true;
332
333     return false;
334 }
335
336
337 void SignalGeneratorCommon::waitForActivation() {
338
339     assert(eventlock->depth() == 1);
340
341     assert(processIsPaused() || requested_wait_until_active);
342
343     while (1) {
344         
345         // Now, do we want to return or wait for more people?
346         
347         // bool syncRunWhenFinished_ -- member vrble, set to true if BPatch
348         // has requested a run (and false when they stop...)
349         
350         bool activeHandler = false;
351         
352         for (unsigned i = 0; i < handlers.size(); i++) {
353             if (handlers[i]->processing()) {
354                 signal_printf("%s[%d]: waitForActivation: handler %s active, returning true\n",
355                               FILE__, __LINE__, getThreadStr(handlers[i]->getThreadID()));
356                 activeHandler = true;
357             }
358         }
359
360         // bool asyncRunWhenFinished_ - member vrble, set to true if any signal handler
361         // requested us to run when it finished up (aka executed process->continueProc)
362         
363         signal_printf("%s[%d]: waitForActivation loop top: activeProcessSignalled_ %d, syncRun %s, activeHandler %d, asyncRun %s\n",
364                       FILE__, __LINE__,
365                       activeProcessSignalled_, processRunStateStr(syncRunWhenFinished_),
366                       activeHandler, processRunStateStr(asyncRunWhenFinished_));
367
368         // Ordering... activeProcessSignalled activeHandler beats
369         // syncRunWhenFinished beats asyncRunWhenFinished.
370         if (activeProcessSignalled_) {
371             signal_printf("%s[%d]: active process signalled, breaking out of wait loop;\n", 
372                           FILE__, __LINE__);
373             break;
374         }
375         else if (activeHandler) {
376             signal_printf("%s[%d]: active handler, continuing around;\n", 
377                           FILE__, __LINE__);
378         }
379         else if (syncRunWhenFinished_ == stopRequest) {
380             signal_printf("%s[%d]: syncRunWhenFinished is stay stopped, continuing around;\n", 
381                           FILE__, __LINE__);
382         }
383         else if (syncRunWhenFinished_ == runRequest) {
384             signal_printf("%s[%d]: syncRunWhenFinished is run, breaking out of wait loop;\n", 
385                           FILE__, __LINE__);
386             break;
387         }
388         else if (asyncRunWhenFinished_ == stopRequest) {
389             signal_printf("%s[%d]: asyncRunWhenFinished is stay stopped, waiting;\n", 
390                           FILE__, __LINE__);
391         }
392         else if (asyncRunWhenFinished_ == runRequest) {
393             signal_printf("%s[%d]: asyncRunWhenFinished is run, breaking;\n", 
394                           FILE__, __LINE__);
395             break;
396         }
397         else 
398             signal_printf("%s[%d]: default case, waiting.\n", 
399                           FILE__, __LINE__);
400
401         // Otherwise, wait for someone to get a round tuit.
402         assert(activationLock);
403         
404         signal_printf("%s[%d]: Grabbing the activationLock...\n", FILE__, __LINE__);
405         activationLock->_Lock(FILE__, __LINE__);
406
407         assert(eventlock->depth() == 1);
408         eventlock->_Unlock(FILE__, __LINE__);
409         
410         signal_printf("%s[%d]: released global lock in waitForActivation\n", FILE__, __LINE__);
411         
412         waitingForActivation_ = true;
413         signal_printf("[%s:%d]: waiting for process to be active\n", FILE__, __LINE__);
414         activationLock->_WaitForSignal(FILE__, __LINE__);
415         signal_printf("[%s:%d]: process received activation request\n", FILE__, __LINE__);
416         waitingForActivation_ = false;
417         activationLock->_Unlock(FILE__, __LINE__);
418         
419         // Left in here and disabled - if we say "continue, pause"
420         // on the UI thread the generator will be woken up but not 
421         // (necessarily) paused. In this case we'll get the lock, 
422         // find out that we're paused, and go through it again.
423         //assert(!processIsPaused());   
424         
425         signal_printf("%s[%d]: reacquiring global lock\n", FILE__, __LINE__);
426         eventlock->_Lock(FILE__, __LINE__);
427
428         assert(eventlock->depth() == 1);
429     }
430 }
431
432 bool SignalGeneratorCommon::continueProcessAsync(int signalToContinueWith, dyn_lwp *lwp) {
433     if (exitRequested()) {
434         //fprintf(stderr, "%s[%d]:  continueProcessAsync: exit requested, ignoring\n", FILE__, __LINE__);
435         // We're going away... so don't do anything
436         return true;
437     }
438
439     // Fixes an odd case when we receive multiple fork exit events; as soon as
440     // we've handled one skip the rest.
441     childForkStopAlreadyReceived_ = true;
442
443     // First, let see if there was a signal to continue with. Only one person can send
444     // a signal; complain if there are multiples. 
445
446     // Technically, this is one per LWP... but we're not there yet.
447     setContinueSig(signalToContinueWith);
448
449     // Grab the activation lock, set asyncRun... and signal the SG if necessary
450     assert(activationLock);
451     signal_printf("%s[%d]: async continue grabbing activation lock\n", FILE__, __LINE__);
452     activationLock->_Lock(FILE__, __LINE__);
453     
454     if (lwp) {
455         signal_printf("%s[%d]: adding lwp %d to continue list...\n",
456                       FILE__, __LINE__, lwp->get_lwp_id());
457         lwpsToContinue_.push_back(lwp);
458     }
459     else {
460         // Someone wants us to run the whole nine yards
461         continueWholeProcess_ = true;
462     }
463
464     if (waitingForOS_ && !independentLwpStop_) {
465         // We managed to get into waitpid (prolly signalActiveProcess) without
466         // continuing the process...
467         signal_printf("%s[%d]: Raced with SG %s, in waitpid, going to continue...\n",
468                       FILE__, __LINE__, getThreadStr(getThreadID()));
469         // Okay, we must be in a "lwps are partially running" situation. Feed in
470         // the LWP we were given in continue.
471         // If we're in a stop situation we can't continue the process; someone else needs
472         // the stop as well.
473
474         bool other_handler = false;
475         for (unsigned i = 0; i < handlers.size(); i++) {
476                 signal_printf("%s[%d]: checking handler %d for activity\n",
477                         FILE__, __LINE__, i);
478                 if (getExecThreadID() == handlers[i]->getThreadID()) {
479                         signal_printf("%s[%d]: checked self\n", 
480                         FILE__, __LINE__);
481                         continue;
482                 }
483                 if (!handlers[i]->processing()) {
484                         signal_printf("%s[%d]: handler is not processing\n",
485                         FILE__, __LINE__);
486                         continue;
487                 }
488                 if (!handlers[i]->events_to_handle.size()) {
489                         signal_printf("%s[%d]: handler has no events to handle\n",
490                         FILE__, __LINE__);
491                         continue;
492                 }
493                 if (handlers[i]->events_to_handle[0].lwp == lwp) {
494                         signal_printf("%s[%d]: handler is waiting for current LWP!\n",
495                                         FILE__, __LINE__);
496                         other_handler = true;
497                         continue;
498                 }
499                 signal_printf("%s[%d]: handler does not match\n", FILE__, __LINE__);
500         }
501         
502         if (!other_handler) {
503                 signal_printf("%s[%d]: continuing process from non-SG thread\n",
504                               FILE__, __LINE__);
505                 continueProcessInternal();
506         }
507         else {
508                 signal_printf("%s[%d]: other handler waiting, skipping continue\n",
509                         FILE__, __LINE__);
510         }
511         signal_printf("%s[%d]: async continue broadcasting...\n", FILE__, __LINE__);
512         activationLock->_Broadcast(FILE__, __LINE__);
513         activationLock->_Unlock(FILE__, __LINE__);
514         return true;
515     }
516
517     asyncRunWhenFinished_ = runRequest;
518
519     signal_printf("%s[%d]: async continue broadcasting...\n", FILE__, __LINE__);
520     activationLock->_Broadcast(FILE__, __LINE__);
521     signal_printf("%s[%d]: async continue releasing activation lock\n", FILE__, __LINE__);
522     activationLock->_Unlock(FILE__, __LINE__);
523
524     // Note: this can wake up the SG before the SH is done handling. However, the global
525     // lock is still held, and the SG re-acquires that before checking state again. So the 
526     // order of events *should* be:
527     // SH signals run
528     // SH finishes
529     // SH releases lock
530     // SG acquires lock
531     // SG checks and discovers all SHs are done
532
533     return true;
534 }
535
536 // This is a logical, not physical, call. The process is "paused" if one of the
537 // following is true:
538 // 
539 // 1) There has been a BPatch_process pause (stopExecution) without a 
540 //   more recent continue (continueExecution).
541 // 2) There is an active signal handler. A signal handler is active if all of the
542 //   following are true:
543 //    a) There is an event in the SH queue.
544 //    b) The SH is not blocked in a callback.
545
546 bool SignalGeneratorCommon::processIsPaused() { 
547
548     if (stop_request) return false;
549
550     assert(proc);
551
552     if (!proc->reachedBootstrapState(attached_bs)) {
553         signal_printf("[%s:%d]: override processIsPaused; process not attached\n",
554                       FILE__, __LINE__);
555         return false;
556     }
557
558     // Return true if: global process status is paused, and there
559     // are _no_ LWPs that are running.                  
560     
561     dyn_lwp *lwp = proc->query_for_running_lwp();
562     
563     signal_printf("%s[%d]: process state %s, running lwp %d\n",
564                   FILE__, __LINE__,
565                   proc->getStatusAsString().c_str(),
566                   (lwp != NULL) ? lwp->get_lwp_id() : (unsigned) -1);
567
568     bool isPaused = false;
569     if (proc->status() == neonatal) isPaused = false;
570     else if (independentLwpStop_ && proc->query_for_running_lwp()) isPaused = false;
571     else if (proc->query_for_stopped_lwp() == NULL) isPaused = false;
572     else if (proc->status() != running) isPaused = true;
573
574     signal_printf("%s[%d]: decision is %s\n", FILE__, __LINE__, isPaused ? "paused" : "running");
575
576     return isPaused;
577 }
578
579 // True if: the signal generator is decoding (we'd have a lock,
580 // but hey...) or if there is a running signal handler. Under the
581 // current design the generation and handling phases are decoupled,
582 // and it's possible for someone else (say, the UI thread) to nip
583 // in between dispatch (in the generator) and handling (in the 
584 // handler). We 'cover' that gap with this function - it basically
585 // says 'back off' to the UI thread.
586
587 bool SignalGeneratorCommon::isActivelyProcessing() {
588     if (decodingEvent_) {
589         signal_printf("%s[%d]: decoding event, returning active\n",
590                       FILE__, __LINE__);
591         return true;
592     }
593     if (dispatchingEvent_) {
594         signal_printf("%s[%d]: dispatching event, returning active\n",
595                       FILE__, __LINE__);
596         return true;
597     }
598
599     // Signal handlers have three states: idle (waiting
600     // for an event), processing (handling an event), 
601     // or waiting (waiting for a callback to complete). 
602     // If the handler is processing, we consider it active.
603     
604     for (unsigned i = 0; i < handlers.size(); i++) {
605         if (handlers[i]->processing()) {
606             // If we're the same thread (inquiring about ourselves),
607             // override...
608             if (getExecThreadID() == handlers[i]->getThreadID()) {
609                 signal_printf("%s[%d]: handler %s processing, same thread, skipping\n",
610                               FILE__, __LINE__, getThreadStr(handlers[i]->getThreadID()));
611                 continue;
612             }
613             else {
614                 signal_printf("%s[%d]: handler %s processing, returning active\n",
615                               FILE__, __LINE__, getThreadStr(handlers[i]->getThreadID()));
616                 return true;
617             }
618         }
619     }
620     return false;
621 }
622         
623 // When we're blocked on the OS we release the lock (as 
624 // we have to), and this means that pretty much anything
625 // can happen with the process state. Frex, the UI thread
626 // can come in and attempt a pause on the process. If
627 // we jump out of the poll/waitpid and start going, this
628 // can confuse the heck out of the UI thread. So we need to know
629 // if someone tried to pause the process while we were waiting;
630 // in this case, we back off and wait for the process to run.
631
632 bool SignalGeneratorCommon::pauseAttemptedOnProcess() {
633         // Simple approach: if process state is paused (and
634         // it wasn't when we went into waitpid), back off.
635         return (processPausedDuringOSWait_);
636 }
637
638
639 // Either returns an event from the pending queue,
640 // or waits for a new one from the OS.
641
642 bool SignalGeneratorCommon::getEvents(pdvector<EventRecord> &events) 
643 {
644     assert(eventlock->depth() > 0);
645
646     // should be empty; we dispatch simultaneously
647     assert(events.size() == 0);
648     
649     if (stop_request) return false;
650     assert(proc);
651     
652     return waitForEventsInternal(events);
653 }
654
655
656 bool SignalGeneratorCommon::dispatchEvent(EventRecord &ev)
657 {
658     assert(eventlock->depth() > 0);
659     
660     char buf[128];
661     signal_printf("%s[%d]:  dispatching event %s\n", FILE__, __LINE__,
662                   ev.sprint_event(buf));
663
664     // Special-case handling...
665     switch (ev.type) {
666     case evtUndefined:
667         fprintf(stderr, "%s[%d]:  CHECK THIS, undefined event\n", FILE__, __LINE__); 
668         return false;
669         break;
670     case evtShutDown:
671         // Don't propagate to signal handlers
672         stop_request = true;
673         // We signal because the UI thread could be waiting for us.
674         // fallthrough...
675     case evtIgnore:
676     case evtRequestedStop:
677         signalEvent(ev);
678         return true;
679         break;
680     case evtProcessExit:
681         signal_printf("%s[%d]:  preparing to shut down signal gen for process %d\n", FILE__, __LINE__, getPid());
682         stop_request = true;
683 #if defined(os_linux)
684         // Set process status to exited so we don't try to poke at it
685         ev.proc->exiting_ = true;
686 #endif
687         // Do not return - still dispatch
688         break;
689     default:
690         // Do nothing.. handled below.
691         break;
692     }
693
694     bool ret = assignOrCreateSignalHandler(ev);
695
696     if (ret == false) return false;
697
698     //  special case:  if this event is a process exit event, we want to shut down
699     //  the SignalGenerator (there are not going to be any more events to listen for).
700     //  The exit event has been passed off to a handler presumably, which will take
701     //  care of user notifications, callbacks, etc.    
702     
703     return ret;
704 }
705
706 bool SignalGeneratorCommon::assignOrCreateSignalHandler(EventRecord &ev) {
707
708     SignalHandler *sh = NULL;
709     for (unsigned int i = 0; i < handlers.size(); ++i) {
710         if (handlers[i]->assignEvent(ev)) {
711             sh = handlers[i];
712             break;
713         }
714     }
715         
716     bool ret = true;
717     if (!sh) {
718         int shid = handlers.size();
719         char shname[64];
720         sprintf(shname, "SH-%d-%d", getPid(), shid);
721         signal_printf("%s[%d]:  about to create event handler %s\n", 
722                       FILE__, __LINE__, shname);
723         sh = newSignalHandler(shname, shid);
724         sh->createThread();
725         handlers.push_back(sh);
726         ret = sh->assignEvent(ev);
727         if (!ret)  {
728             char buf[128];
729             fprintf(stderr, "%s[%d]:  failed to assign event %s to handler\n", 
730                     FILE__, __LINE__, ev.sprint_event(buf));
731         }
732     }
733
734     return ret;
735 }
736
737
738 bool SignalGeneratorCommon::signalActiveProcess()
739 {         
740   bool ret = true;
741   assert(activationLock);
742   
743   if (waitingForOS_) return true;
744
745   signal_printf("%s[%d]: ************************************************** signalActiveProcess for pid %d\n", FILE__, __LINE__, proc->getPid());
746   activationLock->_Lock(FILE__, __LINE__);
747
748   activeProcessSignalled_ = true;
749   signal_printf("%s[%d]: signalActiveProcess waking up SignalGenerator\n", FILE__, __LINE__);
750   activationLock->_Broadcast(FILE__, __LINE__);
751   
752   signal_printf("%s[%d]: signalActiveProcess exit, processIsPaused %d\n",
753                 FILE__, __LINE__, processIsPaused());
754   activationLock->_Unlock(FILE__, __LINE__);
755
756   return ret;
757 }   
758
759 bool SignalGeneratorCommon::belayActiveProcess()  {
760     activationLock->_Lock(FILE__, __LINE__);
761     signal_printf("%s[%d]: belayActiveProcess\n", FILE__, __LINE__);
762     activeProcessSignalled_ = false;
763     activationLock->_Unlock(FILE__, __LINE__);
764     return true;
765 }
766
767 SignalHandler *SignalGenerator::newSignalHandler(char *name, int id)
768 {
769   SignalHandler *sh;
770   sh  = new SignalHandler(name, id, this);
771   return (SignalHandler *)sh;
772 }
773
774
775
776 bool SignalGeneratorCommon::signalEvent(EventRecord &ev)
777 {
778
779   if (ev.type != evtError) {
780     char buf[128];
781     signal_printf("%s[%d]:  signalEvent(%s)\n", FILE__, __LINE__, 
782                   ev.sprint_event(buf));
783   }
784   assert(global_mutex->depth());
785
786   signal_printf("%s[%d]: executing callbacks\n", FILE__, __LINE__);
787   getMailbox()->executeCallbacks(FILE__, __LINE__);
788
789   if (ev.type == evtProcessStop || ev.type == evtProcessExit) {
790      //fprintf(stderr, "%s[%d]:  flagging BPatch status change\n", FILE__, __LINE__);
791      SignalHandler::flagBPatchStatusChange();
792   }
793
794   signal_printf("%s[%d]: signalling wait list\n", FILE__, __LINE__);
795   bool ret = false;
796   for (unsigned int i = 0; i <wait_list.size(); ++i) {
797       if (wait_list[i]->signalIfMatch(ev)) {
798           signal_printf("%s[%d]: signalled the guy at position %d\n", FILE__, __LINE__, i);
799           ret = true;
800       }
801   }
802
803   signal_printf("%s[%d]: signalling global wait list\n", FILE__, __LINE__);
804   global_wait_list_lock->_Lock(__FILE__, __LINE__);
805   for (unsigned int i = 0; i < global_wait_list->size(); ++i) {
806     if ((*global_wait_list)[i]->signalIfMatch(ev)) {
807           ret = true;
808       }
809   }
810   global_wait_list_lock->_Unlock(FILE__, __LINE__);
811
812
813   signal_printf("%s[%d]: acquiring activation lock in signalEvent...\n", FILE__, __LINE__);
814   activationLock->_Lock(FILE__, __LINE__);
815   if (waitingForActivation_) {
816       signal_printf("%s[%d]: generator sleeping, waking up...\n", FILE__, __LINE__);
817       activationLock->_Broadcast(FILE__, __LINE__);
818   }
819   signal_printf("%s[%d]: releasing activation lock in signalEvent...\n", FILE__, __LINE__);
820   activationLock->_Unlock(FILE__, __LINE__);
821   
822 #if 0
823   if (!ret) 
824     signal_printf("%s[%d][%s]:  signalEvent(%s): nobody waiting\n", FILE__, __LINE__, 
825                   getThreadStr(getExecThreadID()), eventType2str(ev.type));
826 #endif
827   signal_printf("%s[%d]: signalEvent returning\n", FILE__, __LINE__);
828   return ret;
829 }
830
831 bool SignalGeneratorCommon::signalEvent(eventType t)
832 {
833   EventRecord ev;
834   ev.type = t;
835   ev.proc = proc;
836   return signalEvent(ev);
837 }
838
839 eventType SignalGeneratorCommon::waitForOneOf(pdvector<eventType> &evts, dyn_lwp *lwp /* = NULL */)
840 {
841   assert(global_mutex->depth());
842   MONITOR_ENTRY();
843
844   if (getExecThreadID() == getThreadID()) {
845     fprintf(stderr, "%s[%d][%s]:   ILLEGAL:  SYNC THREAD waiting on for a signal\n", 
846             FILE__, __LINE__, getThreadStr(getExecThreadID()));
847     assert(0);
848   }
849
850   signal_printf("%s[%d]: waitForOneOf... \n", FILE__, __LINE__);
851
852   //  When to set wait_flag ??
853   //    (1)  If we are running on an event handler thread
854   //    (2)  If we are currently running inside a callback AND an 
855   //         event handler is waiting for the completion of this callback
856   SignalHandler *sh = findSHWithThreadID(getExecThreadID());
857   if (sh) {
858       signal_printf("%s[%d]: signal handler waiting, setting wait_flag\n", FILE__, __LINE__);
859       sh->wait_flag = true;
860   }
861   else {
862       CallbackBase *cb = NULL;
863       if (NULL != (cb = getMailbox()->runningInsideCallback())) {
864           signal_printf("%s[%d]: running inside callback... \n",
865                         FILE__, __LINE__);
866           sh = findSHWaitingForCallback(cb);
867           if (sh) {
868               signal_printf("%s[%d]: signal handler %s waiting on callback, setting wait_flag\n",
869                             FILE__, __LINE__, getThreadStr(sh->getThreadID()));
870               sh->wait_flag = true;
871           }
872       }
873   }
874   
875   EventGate *eg = new EventGate(global_mutex,evts[0], NULL, lwp);
876   for (unsigned int i = 1; i < evts.size(); ++i) {
877     eg->addEvent(evts[i]);
878   }
879   wait_list.push_back(eg);
880
881   if (global_mutex->depth() > 1)
882     signal_printf("%s[%d]:  about to EventGate::wait(), lock depth %d\n", 
883                   FILE__, __LINE__, global_mutex->depth());
884
885   EventRecord result = eg->wait();
886   
887   bool found = false;
888   for (int i = wait_list.size() -1; i >= 0; i--) {
889     if (wait_list[i] == eg) {
890        found = true;
891        VECTOR_ERASE(wait_list,i,i);
892        delete eg;
893        break;
894     } 
895   }
896
897   if (!found) {
898      fprintf(stderr, "%s[%d]:  BAD NEWS, somehow lost a pointer to eg\n", 
899              FILE__, __LINE__);
900   }
901
902   if (sh)
903     sh->wait_flag = false;
904
905   // Poink the signal generator?
906
907   MONITOR_EXIT();
908   return result.type;
909 }
910
911
912 // Global version of the one above this: only called by threads external to
913 // the entire signal process (e.g., UI thread) who need to wait cross-process.
914
915 // Static method.
916 eventType SignalGeneratorCommon::globalWaitForOneOf(pdvector<eventType> &evts)
917 {
918   assert(global_mutex->depth());
919
920   EventGate *eg = new EventGate(global_mutex,evts[0]);
921   for (unsigned int i = 1; i < evts.size(); ++i) {
922       eg->addEvent(evts[i]);
923   }
924
925   global_wait_list_lock->_Lock(FILE__, __LINE__);
926   global_wait_list->push_back(eg);
927   global_wait_list_lock->_Unlock(FILE__, __LINE__);
928
929   if (global_mutex->depth() > 1)
930      signal_printf("%s[%d]:  about to EventGate::wait(), lock depth %d\n", 
931                    FILE__, __LINE__, global_mutex->depth());
932
933   EventRecord result = eg->wait();
934   
935   global_wait_list_lock->_Lock(FILE__, __LINE__);
936   bool found = false;
937   for (int i = global_wait_list->size() -1; i >= 0; i--) {
938     if ((*global_wait_list)[i] == eg) {
939        found = true;
940        VECTOR_ERASE((*global_wait_list),i,i);
941        delete eg;
942        break;
943     } 
944   }
945   global_wait_list_lock->_Unlock(FILE__, __LINE__);
946   
947   if (!found) {
948      fprintf(stderr, "%s[%d]:  BAD NEWS, somehow lost a pointer to eg\n", 
949              FILE__, __LINE__);
950   }
951
952   return result.type;
953 }
954
955 eventType SignalGeneratorCommon::waitForEvent(eventType evt, 
956                                               process *p, dyn_lwp *lwp,
957                                               eventStatusCode_t status,
958                                               bool executeCallbacks /* = true */)
959 {
960     MONITOR_ENTRY();
961
962   if (getExecThreadID() == getThreadID()) {
963     fprintf(stderr, "%s[%d][%s]:   ILLEGAL:  SYNC THREAD waiting on for a signal: %s\n", 
964             FILE__, __LINE__, getThreadStr(getExecThreadID()), eventType2str(evt));
965     assert(0);
966   }
967
968   signal_printf("%s[%d]:  welcome to waitForEvent(%s)\n", FILE__, __LINE__, eventType2str(evt));
969
970
971   //  When to set wait_flag ??
972   //    (1)  If we are running on an event handler thread
973   //    (2)  If we are currently running inside a callback AND a 
974   //         signal handler is waiting for the completion of this callback
975   SignalHandler *sh = findSHWithThreadID(getExecThreadID());
976   if (sh) {
977       signal_printf("%s[%d]: signal handler waiting, setting wait_flag\n", FILE__, __LINE__);
978       sh->wait_flag = true;
979   }
980   else {
981       CallbackBase *cb = NULL;
982       if (NULL != (cb = getMailbox()->runningInsideCallback())) {
983           signal_printf("%s[%d]: running inside callback... \n",
984                         FILE__, __LINE__);
985           sh = findSHWaitingForCallback(cb);
986           if (sh) {
987               signal_printf("%s[%d]: signal handler %s waiting on callback, setting wait_flag\n",
988                             FILE__, __LINE__, getThreadStr(sh->getThreadID()));
989               sh->wait_flag = true;
990           }
991       }
992   }
993
994   EventGate *eg = new EventGate(global_mutex,evt,p, lwp, status);
995   wait_list.push_back(eg);
996   
997   if (global_mutex->depth() > 1)
998     signal_printf("%s[%d]:  about to EventGate::wait(%s), lock depth %d\n", 
999                   FILE__, __LINE__, 
1000                   eventType2str(evt), global_mutex->depth());
1001   EventRecord result = eg->wait(executeCallbacks);
1002   
1003   bool found = false;
1004   for (int i = wait_list.size() -1; i >= 0; i--) {
1005     if (wait_list[i] == eg) {
1006        found = true;
1007        VECTOR_ERASE(wait_list,i,i);
1008        delete eg;
1009        break;
1010     } 
1011   }
1012
1013   if (!found) {
1014       fprintf(stderr, "%s[%d]:  BAD NEWS, somehow lost a pointer to eg\n", 
1015               FILE__, __LINE__);
1016   }
1017
1018   if (sh)
1019     sh->wait_flag = false;
1020
1021   MONITOR_EXIT();
1022   return result.type;
1023 }
1024
1025 SignalHandler *SignalGeneratorCommon::findSHWithThreadID(unsigned long tid)
1026 {
1027   for (unsigned int i = 0; i < handlers.size(); ++i) {
1028     if (handlers[i]->getThreadID() == tid)
1029       return handlers[i];
1030   }
1031   return NULL;
1032 }
1033
1034 SignalHandler *SignalGeneratorCommon::findSHWaitingForCallback(CallbackBase *cb)
1035 {
1036   for (unsigned int i = 0; i < handlers.size(); ++i) {
1037       signal_printf("%s[%d]: comparing handler wait_cb %p with given %p\n",
1038                     FILE__, __LINE__, handlers[i]->wait_cb, cb);
1039     if (handlers[i]->wait_cb == cb)
1040       return handlers[i];
1041   }
1042   return NULL;
1043 }
1044
1045 bool SignalGeneratorCommon::decodeIfDueToProcessStartup(EventRecord &ev)
1046 {
1047   bool ret = false;
1048   char buf[128];
1049   process *proc = ev.proc;
1050   bootstrapState_t bootstrapState = proc->getBootstrapState();
1051
1052   startup_printf("%s[%d]:  decodeIfDueToProcessStartup: state: %s\n", 
1053                  FILE__, __LINE__, proc->getBootstrapStateAsString().c_str());
1054
1055   switch(bootstrapState) {
1056     case bootstrapped_bs:  
1057         break;
1058     case unstarted_bs:     
1059     case attached_bs:
1060        if (proc->wasCreatedViaAttach())
1061           ev.type = evtProcessAttach;
1062         else 
1063           ev.type = evtProcessCreate; 
1064         ret = true;
1065         break;
1066     case begun_bs:
1067     case libcLoaded_bs:
1068        if (proc->getTraceSysCalls()) {
1069            ret = proc->decodeStartupSysCalls(ev);
1070        }
1071        else if (proc->trapAtEntryPointOfMain(ev.lwp, 
1072                             (Address) INFO_TO_ADDRESS(ev.info))) {
1073           ev.type = evtProcessInit; 
1074           ret = true;
1075        }
1076        else {
1077          fprintf(stderr, "%s[%d]:  begun_bs, but no trap!!!!!\n", FILE__, __LINE__);
1078        }
1079        break;
1080     case loadingRT_bs:
1081         if (proc->trapDueToDyninstLib(ev.lwp)) {
1082           ev.type = evtProcessLoadedRT;
1083           ret = true;
1084         }
1085 #if 0
1086   //  windows has more info available here, not just from getActiveFrame -- we
1087   //  used to use it, but it may not be necessary anymore...
1088         
1089         if (proc->dyninstlib_brk_addr &&
1090             (proc->dyninstlib_brk_addr == (Address)ev.info.u.Exception.ExceptionRecord.ExceptionAddress)) {
1091             ev.type = evtProcessLoadedRT;
1092             ret = true;
1093         }
1094
1095 #endif
1096         break;
1097     case initialized_bs:
1098     case loadedRT_bs:
1099     default:
1100         break;
1101   };
1102   
1103   if (ret) 
1104      startup_printf("%s[%d]:  decodeIfDueToProcessStartup got %s, status = %s\n",
1105                    FILE__, __LINE__, ev.sprint_event(buf), 
1106                    proc->getBootstrapStateAsString().c_str());
1107
1108   return ret;
1109 }
1110
1111 void SignalGeneratorCommon::clearCachedLocations()  {
1112     sync_event_id_addr = 0;
1113     sync_event_arg1_addr = 0;
1114     sync_event_arg2_addr = 0;
1115     sync_event_arg3_addr = 0;
1116     sync_event_breakpoint_addr = 0;
1117 }
1118
1119 bool SignalGeneratorCommon::decodeRTSignal(EventRecord &ev)
1120 {
1121    // We've received a signal we believe was sent
1122    // from the runtime library. Check the RT lib's
1123    // status variable and return it.
1124    // These should be made constants
1125    process *proc = ev.proc;
1126    if (!proc) return false;
1127
1128    int breakpoint;
1129    int status;
1130    Address arg1 = 0x0;
1131    int zero = 0;
1132
1133    // First, check breakpoint...
1134    if (sync_event_breakpoint_addr == 0) {
1135        std::string status_str ("DYNINST_break_point_event");
1136        
1137        pdvector<int_variable *> vars;
1138        if (!proc->findVarsByAll(status_str, vars)) {
1139            return false;
1140        }
1141        
1142        if (vars.size() != 1) {
1143            fprintf(stderr, "%s[%d]:  ERROR, found %ld copies of var %s\n", 
1144                    FILE__, __LINE__, (long) vars.size(), status_str.c_str());
1145            return false;
1146        }
1147
1148        sync_event_breakpoint_addr = vars[0]->getAddress();
1149    }
1150
1151    if (!proc->readDataSpace((void *)sync_event_breakpoint_addr, 
1152                             sizeof(int),
1153                             &breakpoint, true)) {
1154        fprintf(stderr, "%s[%d]:  readDataSpace failed (ev.proc %d, ev.lwp %d)\n", 
1155                FILE__, __LINE__, ev.proc->getPid(), ev.lwp->get_lwp_id());
1156        return false;
1157    }
1158
1159    switch (breakpoint) {
1160    case 0:
1161        return false;
1162    case 1:
1163 #if ! defined (os_windows)
1164        // We SIGNUMed it
1165        if (ev.what != DYNINST_BREAKPOINT_SIGNUM) {
1166            // False alarm...
1167            return false;
1168        }
1169        break;
1170    case 2:
1171        if (ev.what != SIGSTOP) {
1172            // Again, false alarm...
1173            return false;
1174        }
1175 #endif
1176        break;
1177    default:
1178        assert(0);
1179    }
1180
1181    // Definitely a breakpoint... set that up and clear the flag
1182    ev.type = evtProcessStop;
1183
1184    // Further processing may narrow this down some more.
1185
1186    // Make sure we don't get this event twice....
1187    if (!proc->writeDataSpace((void *)sync_event_breakpoint_addr, sizeof(int), &zero)) {
1188        fprintf(stderr, "%s[%d]:  writeDataSpace failed\n", FILE__, __LINE__);
1189    }
1190
1191    if (sync_event_id_addr == 0) {
1192        std::string status_str ("DYNINST_synch_event_id");
1193        
1194        
1195        pdvector<int_variable *> vars;
1196        if (!proc->findVarsByAll(status_str, vars)) {
1197            fprintf(stderr, "%s[%d]:  cannot find var %s\n", 
1198                    FILE__, __LINE__, status_str.c_str());
1199            return false;
1200        }
1201        
1202        if (vars.size() != 1) {
1203            fprintf(stderr, "%s[%d]:  ERROR:  %ld vars matching %s, not 1\n", 
1204                    FILE__, __LINE__, (long) vars.size(), status_str.c_str());
1205            return false;
1206        }
1207
1208        sync_event_id_addr = vars[0]->getAddress();
1209    }
1210
1211    if (!proc->readDataSpace((void *)sync_event_id_addr, sizeof(int),
1212                             &status, true)) {
1213        fprintf(stderr, "%s[%d]:  readDataSpace failed\n", FILE__, __LINE__);
1214        return false;
1215    }
1216    
1217    if (status == DSE_undefined) {
1218        return false; // Nothing to see here
1219    }
1220
1221    // Make sure we don't get this event twice....
1222    if (!proc->writeDataSpace((void *)sync_event_id_addr, sizeof(int), &zero)) {
1223        fprintf(stderr, "%s[%d]:  writeDataSpace failed\n", FILE__, __LINE__);
1224        return false;
1225    }
1226
1227    // get runtime library arg1 address
1228    if (sync_event_arg1_addr == 0) {
1229        std::string arg_str ("DYNINST_synch_event_arg1");
1230        
1231        pdvector<int_variable *> vars;
1232        if (!proc->findVarsByAll(arg_str, vars)) {
1233            fprintf(stderr, "%s[%d]:  cannot find var %s\n", 
1234                    FILE__, __LINE__, arg_str.c_str());
1235            return false;
1236        }
1237        
1238        if (vars.size() != 1) {
1239            fprintf(stderr, "%s[%d]:  ERROR:  %ld vars matching %s, not 1\n", 
1240                    FILE__, __LINE__, (long) vars.size(), arg_str.c_str());
1241            return false;
1242        }
1243        sync_event_arg1_addr = vars[0]->getAddress();
1244    }
1245    //read arg1
1246    if (!proc->readDataSpace((void *)sync_event_arg1_addr, 
1247                             proc->getAddressWidth(), &arg1, true)) {
1248        fprintf(stderr, "%s[%d]:  readDataSpace failed\n", FILE__, __LINE__);
1249        return false;
1250    }
1251
1252    // Do platform dependent decoding, sets ev.type and ev.what, adds
1253    // arg1 to EventRecord
1254    return decodeRTSignal_NP(ev, arg1, status);
1255
1256 }
1257
1258
1259 bool SignalGenerator::attachProcess()
1260 {
1261   assert(proc);
1262   
1263     proc->creationMechanism_ = process::attached_cm;
1264
1265     proc->stateWhenAttached_ = stopped;
1266     if (proc->isRunning_()) {
1267        //Checks the state in /proc (at least on Linux)
1268       proc->stateWhenAttached_ = running;
1269     }
1270
1271 #if defined (os_linux)
1272    waitpid_mux.registerProcess(this);
1273 #endif
1274    if (!proc->attach()) 
1275    {
1276       proc->set_status(detached);      
1277       startup_printf("%s[%d] attach failing here: thread %s\n", 
1278                      FILE__, __LINE__, getThreadStr(getExecThreadID()));
1279       std::string msg = std::string("Warning: unable to attach to specified process:")
1280          + utos(getPid());
1281       showErrorCallback(26, msg.c_str());
1282       return false;
1283    }
1284
1285     // Record what the process was doing when we attached, for possible
1286     // use later.
1287     proc->set_status(stopped);
1288     
1289     startup_printf("%s[%d]: returning from attachProcess\n", FILE__, __LINE__);
1290     return true;
1291 }
1292
1293
1294 std::string SignalGeneratorCommon::createExecPath(std::string &file, std::string &dir)
1295 {
1296   std::string ret = file;
1297 #if defined (os_windows)
1298   if (dir.length() > 0) {
1299       if ( (file.length() < 2)      // file is too short to be a drive specifier
1300          || !isalpha( file[0] )     // first character in file is not a letter
1301          || (file[1] != ':') )      // second character in file is not a colon
1302             ret = dir + "\\" + file;
1303   }
1304 #else
1305   if (dir.length() > 0) {
1306      if (!(file[0] == ('/'))) {
1307          // file does not start  with a '/', so it is a relative pathname
1308          // we modify it to prepend the given directory
1309          if (dir[dir.length()-1 ] == ('/') ) {
1310              // the dir already has a trailing '/', so we can
1311              // just concatenate them to get an absolute path
1312              ret =  dir + file;
1313           }
1314           else {
1315              // the dir does not have a trailing '/', so we must
1316              // add a '/' to get the absolute path
1317              ret =  dir + "/" + file;
1318           }
1319       }
1320       else {
1321          // file starts with a '/', so it is an absolute pathname
1322          // DO NOT prepend the directory, regardless of what the
1323          // directory variable holds.
1324          // nothing to do in this case
1325       }
1326
1327   }
1328 #endif
1329   return ret;
1330 }
1331 SignalGenerator *SignalGeneratorCommon::newSignalGenerator(std::string file, std::string dir,
1332                                                          pdvector<std::string> *argv,
1333                                                          pdvector<std::string> *envp,
1334                                                          std::string inputFile,
1335                                                          std::string outputFile,
1336                                                          int stdin_fd, int stdout_fd,
1337                                                          int stderr_fd)
1338 {
1339   char idstr[16];
1340   sprintf(idstr, "SYNC%d", signal_generator_counter++);
1341   return new SignalGenerator(idstr, 
1342                              file, dir, 
1343                              argv, envp, inputFile, outputFile,
1344                              stdin_fd, stdout_fd, stderr_fd);
1345 }
1346
1347 SignalGenerator *SignalGeneratorCommon::newSignalGenerator(std::string file, int pid)
1348 {
1349   char idstr[32];
1350   sprintf(idstr, "SG-%d", pid);
1351   return new SignalGenerator(idstr, file, pid);
1352 }
1353
1354 process *SignalGeneratorCommon::newProcess(std::string file_, std::string dir, 
1355                                                      pdvector<std::string> *argv,
1356                                                      pdvector<std::string> *envp,
1357                                                      int stdin_fd, int stdout_fd, 
1358                                                      int stderr_fd)
1359 {
1360    // Verify existence of exec file
1361    std::string file = createExecPath(file_, dir);
1362
1363    if (!OS::executableExists(file)) {
1364       startup_printf("%s[%d]:  failed to read file %s\n", FILE__, __LINE__, file.c_str());
1365       std::string msg = std::string("Can't read executable file ") + file + (": ") + strerror(errno);
1366       showErrorCallback(68, msg.c_str());
1367       return NULL;
1368    }
1369
1370    
1371
1372    // check for I/O redirection in arg list.
1373    std::string inputFile;
1374    std::string outputFile;
1375    // TODO -- this assumes no more than 1 of each "<", ">"
1376    // also, do we want this behavior in general, or should there be a switch to enable/disable?
1377    for (unsigned i1=0; i1<argv->size(); i1++) {
1378      if ((*argv)[i1] == "\\<") {
1379         (*argv)[i1] = "<";
1380      }
1381      else if ((*argv)[i1] == "<") {
1382        inputFile = (*argv)[i1+1];
1383        for (unsigned j=i1+2, k=i1; j<argv->size(); j++, k++)
1384          (*argv)[k] = (*argv)[j];
1385        argv->resize(argv->size()-2);
1386      }
1387    }
1388    for (unsigned i2=0; i2<argv->size(); i2++) {
1389      if ((*argv)[i2] == "\\>") {
1390         (*argv)[i2] = ">";
1391      }
1392      else if ((*argv)[i2] == ">") {
1393        outputFile = (*argv)[i2+1];
1394        for (unsigned j=i2+2, k=i2; j<argv->size(); j++, k++)
1395          (*argv)[k] = (*argv)[j];
1396        argv->resize(argv->size()-2);
1397      }
1398    }
1399
1400
1401   SignalGenerator *sg = newSignalGenerator(file, dir, argv, envp, inputFile, outputFile,
1402                                            stdin_fd, stdout_fd, stderr_fd);
1403
1404   if (!sg) {
1405      fprintf(stderr, "%s[%d]:  failed to create event handler thread for %s\n", 
1406              FILE__, __LINE__, getThreadStr(getExecThreadID()));
1407      getMailbox()->executeCallbacks(FILE__, __LINE__);
1408      return NULL;
1409   }
1410
1411
1412   process *theProc = new process(sg);
1413   assert(theProc);
1414   sg->setProcess(theProc);
1415   //  finally, create the signal handler thread -- this creates the process
1416   //  from the event handling thread.  We want to do it there because on some platforms
1417   //  (windows, linux-with-linuxThreads) the only thread that can properly listen for
1418   //  debug events is the thread that spawned the process. 
1419
1420   if (!sg->createThread()) {
1421      delete sg;
1422      //delete theProc;
1423      getMailbox()->executeCallbacks(FILE__, __LINE__);
1424      startup_printf("%s[%d]: failed to create signal generator thread, returning NULL\n",
1425                     FILE__, __LINE__);
1426      return NULL;
1427   }
1428
1429   assert(-1 != sg->getPid());
1430
1431   signal_printf("%s[%d]:  started signal listener for new process %d -- %s\n",
1432                 FILE__, __LINE__, sg->getPid(), file.c_str());
1433
1434   return theProc;
1435 }
1436
1437 void SignalGeneratorCommon::stopSignalGenerator(SignalGenerator *sg)
1438 {
1439    
1440   int dur = 0;
1441   signal_printf("%s[%d]:  waiting for thread to terminate\n", FILE__, __LINE__);
1442
1443   sg->stopThreadNextIter();
1444   sg->wakeUpThreadForShutDown();
1445
1446   while (sg->isRunning() && (dur < 5)) {
1447     sg->__UNLOCK;
1448     //  If we wait more than 5 iters here, something is defnitely wrong and
1449     //  this should be reexamined.
1450     if (dur++ > 5) {
1451         fprintf(stderr, "%s[%d]:  sg still running\n", FILE__, __LINE__);
1452     }
1453     sleep(1);
1454     
1455     sg->__LOCK;
1456   }
1457
1458   for (unsigned i = 0; i < sg->handlers.size(); i++) {
1459       sg->deleteSignalHandler(sg->handlers[i]);
1460   }
1461
1462   signal_printf("%s[%d]:  sg has stopped\n", FILE__, __LINE__);
1463 }
1464
1465 void SignalGeneratorCommon::deleteSignalGenerator(SignalGenerator *sg)
1466 {
1467    
1468   if (sg->isRunning())
1469     stopSignalGenerator(sg);
1470  
1471    delete (sg);
1472 }
1473
1474
1475 process *SignalGeneratorCommon::newProcess(std::string &progpath, int pid)
1476 {
1477   SignalGenerator *sg = newSignalGenerator(progpath, pid);
1478
1479   if (!sg) {
1480      fprintf(stderr, "%s[%d]:  failed to create event handler thread for %s\n", 
1481              FILE__, __LINE__, getThreadStr(getExecThreadID()));
1482      getMailbox()->executeCallbacks(FILE__, __LINE__);
1483      return NULL;
1484   }
1485
1486
1487   process *theProc = new process(sg);
1488   assert(theProc);
1489   sg->setProcess(theProc);
1490   //  finally, create the signal handler thread -- this creates the process
1491   //  from the event handling thread.  We want to do it there because on some platforms
1492   //  (windows, linux-with-linuxThreads) the only thread that can properly listen for
1493   //  debug events is the thread that spawned the process. 
1494
1495   if (!sg->createThread()) {
1496      signal_printf("%s[%d]:  failed to create event handler thread %s\n", 
1497                    FILE__, __LINE__, getThreadStr(getExecThreadID()));
1498      delete sg;
1499      getMailbox()->executeCallbacks(FILE__, __LINE__);
1500      return NULL;
1501   }
1502
1503   assert(-1 != sg->getPid());
1504   signal_printf("%s[%d]:  started signal listener for new process %d -- %s\n",
1505                 FILE__, __LINE__, sg->getPid(), progpath.c_str());
1506
1507   
1508
1509   return theProc;
1510 }
1511
1512 process * SignalGeneratorCommon::newProcess(process *parent, int pid_, int traceLink)
1513 {
1514   char *progpath = const_cast<char *>(parent->getAOut()->fullName().c_str());
1515   assert(progpath);
1516   SignalGenerator *sg = newSignalGenerator(progpath, pid_);
1517
1518   if (!sg) {
1519      fprintf(stderr, "%s[%d]:  failed to create event handler thread for %s\n", 
1520              FILE__, __LINE__, getThreadStr(getExecThreadID()));
1521      getMailbox()->executeCallbacks(FILE__, __LINE__);
1522      return NULL;
1523   }
1524
1525   process *theChild = new process(parent, sg, traceLink);
1526   assert(theChild);
1527   sg->setProcess(theChild);
1528   
1529   if (!sg->createThread()) {
1530      delete sg;
1531      getMailbox()->executeCallbacks(FILE__, __LINE__);
1532      return NULL;
1533   }
1534
1535   assert(-1 != sg->getPid());
1536
1537
1538   return theChild;
1539 }
1540
1541 SignalGeneratorCommon::SignalGeneratorCommon(char *idstr) :
1542     EventHandler<EventRecord>(BPatch_eventLock::getLock(),
1543                               idstr,/*start thread?*/ false),
1544     file_(""),
1545     dir_(""),
1546     inputFile_(""),
1547     outputFile_(""),
1548     stdin_fd_(-1),
1549     stdout_fd_(-1),
1550     stderr_fd_(-1),
1551     argv_(NULL),
1552     envp_(NULL),
1553     pid_(-1),
1554     traceLink_(-1),
1555     requested_wait_until_active(false),
1556     waitingForActivation_(false),
1557     processPausedDuringOSWait_(false),
1558     pendingDecode_(false),
1559     decodingEvent_(false),
1560     dispatchingEvent_(false),
1561     waitingForOS_(false),
1562     continueDesired_(false),
1563     shuttingDown_(false),
1564     continueSig_(-1),
1565     continueWholeProcess_(false),
1566     continueCompleted_(false),
1567     numBlockedForContinue(0),
1568     syncRunWhenFinished_(unsetRequest),
1569     asyncRunWhenFinished_(unsetRequest),
1570     activeProcessSignalled_(false),
1571     independentLwpStop_(0),
1572     childForkStopAlreadyReceived_(false),
1573     sync_event_id_addr(0),
1574     sync_event_arg1_addr(0),
1575     sync_event_arg2_addr(0),
1576     sync_event_arg3_addr(0),
1577     sync_event_breakpoint_addr(0),
1578     usage_count(0)
1579 {
1580     signal_printf("%s[%d]:  new SignalGenerator\n", FILE__, __LINE__);
1581     assert(eventlock == global_mutex);
1582
1583     waitlock = new eventLock;
1584     activationLock = new eventLock;
1585     waitForContinueLock = new eventLock;
1586     waitForHandlerExitLock = new eventLock;
1587 }
1588
1589 bool SignalGeneratorCommon::setupCreated(std::string file,
1590                                          std::string dir,
1591                                          pdvector <std::string> *argv,
1592                                          pdvector <std::string> *envp,
1593                                          std::string inputFile,
1594                                          std::string outputFile,
1595                                          int stdin_fd,
1596                                          int stdout_fd,
1597                                          int stderr_fd) 
1598 {
1599     file_ = file;
1600     dir_ = dir;
1601     argv_ = argv;
1602     envp_ = envp;
1603     inputFile_ = inputFile;
1604     outputFile_ = outputFile;
1605     stdin_fd_ = stdin_fd;
1606     stdout_fd_ = stdout_fd;
1607     stderr_fd_ = stderr_fd;
1608     return true;
1609 }
1610
1611 bool SignalGeneratorCommon::setupAttached(std::string file,
1612                                           int pid) {
1613     file_ = file;
1614     pid_ = pid;
1615     return true;
1616 }
1617
1618 bool SignalGeneratorCommon::wakeUpThreadForShutDown()
1619 {
1620     shuttingDown_ = true;
1621 #if defined (os_windows)
1622 //  DebugBreakProcess(this->proc->processHandle_);
1623   if (waiting_for_active_process) {
1624     __BROADCAST;
1625     return true;
1626   }
1627 #else
1628   int sig_to_send = SIGTRAP;
1629    assert(global_mutex->depth());
1630
1631   if (waitingForOS_) {
1632     signal_printf("%s[%d]:  sending SIGTRAP to wake up signal handler\n", FILE__, __LINE__);
1633     P_kill (getPid(), sig_to_send);
1634     waitForEvent(evtShutDown, proc);
1635     signal_printf("%s[%d][%s]:  got shutdown event\n", FILE__, __LINE__, getThreadStr(getExecThreadID()));
1636   }
1637   else if (waiting_for_active_process) {
1638     __BROADCAST;
1639   }
1640 #endif
1641   return true;
1642 }
1643
1644 extern void dyninst_yield();
1645
1646 SignalGeneratorCommon::~SignalGeneratorCommon() 
1647 {
1648   //killThread();
1649     signal_printf("%s[%d]: Deleting SignalGeneratorCommon, %p\n", FILE__, __LINE__, this);
1650     
1651     // Don't delete signal handlers; they get deleted in their own threads
1652     
1653     delete waitlock;
1654     delete activationLock;
1655     delete waitForContinueLock;
1656     delete waitForHandlerExitLock;
1657
1658     while (wait_list.size()) {
1659         signal_printf("%s[%d]: Waiting for %d wait list to go to 0\n", FILE__, __LINE__, wait_list.size());
1660         dyninst_yield();
1661     }
1662     
1663 }
1664
1665 void SignalGeneratorCommon::deleteSignalHandler(SignalHandler *sh)
1666 {
1667     EventRecord ev;
1668     ev.type = evtShutDown;
1669     sh->stopThreadNextIter();
1670     sh->assignEvent(ev);
1671     
1672     if (getExecThreadID() == getThreadID()) {
1673       // We're trying to delete ourselves... don't block ;)
1674       return;
1675     }
1676
1677 #if 0
1678     // Don't wait anymore... consider the following:
1679     // Process exits
1680     //   SignalGenerator picks this up.
1681     //   signalHandler gets assigned event
1682     //   signalHandler registers callback and blocks
1683     //   UI thread starts running
1684     //   UI thread deletes the process
1685     //   ... which gets here
1686     // 
1687     // Note that the signalHandler is running (and will be, since it is
1688     // waiting for the callback to complete). Don't delete it. 
1689     while (sh->isRunning()) {
1690       waitForEvent(evtAnyEvent);
1691     }
1692 #endif
1693
1694 }
1695
1696 bool SignalGeneratorCommon::initialize_event_handler()
1697 {
1698   assert(proc);
1699
1700   //  This is the init function for the event handler.  It is called before the main
1701   //  event handing loop.  
1702
1703   //  In the case of the signal handler, here we call either forkNewProcess() or
1704   //  attachProcess() if the process already exists.
1705
1706   if (getPid() == -1) {
1707       if (!forkNewProcess()) {
1708           return false;
1709       }
1710
1711       // We have a PID, override the name of this thread
1712       char newIdStr[32];
1713       sprintf(newIdStr, "SG-%d", getPid());
1714       setName(newIdStr);
1715       
1716       proc->createRepresentativeLWP();
1717       
1718       if (!proc->setupCreated(traceLink_)) {
1719           signal_printf("%s[%d]: Failed to do basic process setup\n", FILE__, __LINE__);
1720           fprintf(stderr,"%s[%d]: Failed to do basic process setup\n", FILE__, __LINE__);
1721 #if !defined(os_windows)
1722           P_kill(getPid(), SIGKILL);
1723 #endif
1724           delete proc;
1725           proc = NULL;
1726           return false;
1727       }
1728
1729       int status;
1730       fileDescriptor desc;
1731       startup_printf("%s[%d]:  about to getExecFileDescriptor\n", FILE__, __LINE__);
1732       if (!getExecFileDescriptor(file_, getPid(), true, status, desc)) {
1733           signal_printf("%s[%d]: Failed to find exec descriptor\n", FILE__, __LINE__);
1734           fprintf(stderr,"%s[%d]: Failed to find exec descriptor\n", FILE__, __LINE__);
1735 #if !defined(os_windows)
1736           P_kill(getPid(), SIGKILL);
1737 #endif
1738           ///    cleanupBPatchHandle(theProc->sh->getPid());
1739           //  processVec.pop_back();
1740           delete proc;
1741           proc = NULL;
1742           return false;
1743       }
1744
1745       startup_printf("%s[%d]:  about to setAOut\n", FILE__, __LINE__);
1746       if (!proc->setAOut(desc)) {
1747           fprintf(stderr, "%s[%d] - Couldn't setAOut\n", FILE__, __LINE__);
1748           sleep(1);
1749           startup_printf("%s[%d] - Couldn't setAOut\n", FILE__, __LINE__);
1750 #if !defined(os_windows)
1751           P_kill(getPid(), SIGKILL);
1752 #if defined (os_linux)
1753           int waitpid_status = 0;
1754           waitpid(getPid(), &waitpid_status, 0);
1755 #endif
1756 #endif
1757           // cleanupBPatchHandle(theProc->sh->getPid());
1758           // processVec.pop_back();
1759           delete proc;
1760           proc = NULL;
1761           return false;
1762       }
1763       startup_printf("%s[%d]:  after setAOut\n", FILE__, __LINE__);
1764       //HACKSTATUS = status;      
1765   }
1766   else if (!proc->getParent()){
1767       //  attach case (pid != -1 && proc->parent == NULL)
1768       proc->createRepresentativeLWP();
1769       
1770       startup_printf("%s[%d]:  about to attachProcess\n", FILE__, __LINE__);
1771       if (!attachProcess()) {
1772           delete proc;
1773           proc = NULL;
1774           return false;
1775       }
1776       
1777 #if defined(os_windows)
1778     int status = (int)INVALID_HANDLE_VALUE;    // indicates we need to obtain a valid handle
1779 #else
1780     int status = getPid();
1781 #endif // defined(i386_unknown_nt4_0)
1782
1783     fileDescriptor desc;
1784       startup_printf("%s[%d]:  about to getExecFileDesc\n", FILE__, __LINE__);
1785     if (!getExecFileDescriptor(file_, getPid(), false, status, desc)) 
1786     {
1787         delete proc;
1788         proc = NULL;
1789         return false;
1790     }
1791
1792       startup_printf("%s[%d]:  about to setAOut\n", FILE__, __LINE__);
1793     if (!proc->setAOut(desc)) {
1794        delete proc;
1795        proc = NULL;
1796        return false;
1797     }
1798
1799 #if !defined(os_windows)
1800     if (proc->hasPassedMain()) {
1801        proc->setBootstrapState(initialized_bs);
1802     }
1803 #endif
1804   }
1805   else { // proc->getParent() is non-NULL, fork case
1806       signal_printf("%s[%d]: attaching to forked child, creating representative LWP\n",
1807                     FILE__, __LINE__);
1808
1809      proc->createRepresentativeLWP();
1810      // Set the status to stopped - it's stopped at the exit of fork() and we may
1811      // want to do things to it.
1812      proc->set_lwp_status(proc->getRepresentativeLWP(), stopped);
1813
1814      
1815      if (!attachProcess()) {
1816          delete proc;
1817          proc = NULL;
1818          return false;
1819      }
1820      
1821      if (!proc->setupFork()) {
1822          fprintf(stderr, "%s[%d]:  failed to setupFork\n", FILE__, __LINE__);
1823          delete proc;
1824          proc = NULL;
1825          return false;
1826      }
1827
1828
1829   }
1830
1831   return true;
1832 }
1833
1834
1835 ////////////////////////////////////////////
1836 // Unused functions
1837 ////////////////////////////////////////////
1838
1839 bool SignalGeneratorCommon::waitNextEvent(EventRecord &) {
1840     assert(0);
1841     return true;
1842 }
1843
1844 bool SignalGeneratorCommon::handleEvent(EventRecord &) {
1845     assert(0);
1846     return true;
1847 }
1848
1849 // The signalGenerator is waiting for waitForContinueLock to get signalled.
1850 // We'll bounce it, then wait on requestContinueLock... 
1851
1852 bool SignalGeneratorCommon::continueProcessBlocking(int requestedSignal, dyn_lwp *lwp /* = NULL */) 
1853 {
1854     if (exitRequested()) {
1855         // We're going away... so don't do anything
1856         return true;
1857     }
1858
1859     // Fixes an odd case when we receive multiple fork exit events; as soon as
1860     // we've handled one skip the rest.
1861     childForkStopAlreadyReceived_ = true;
1862     // Ask (politely) the signal generator to continue us...
1863
1864     signal_printf("%s[%d]: requestContinue entry, locking...\n", FILE__, __LINE__);
1865     activationLock->_Lock(FILE__, __LINE__);
1866
1867     setContinueSig(requestedSignal);
1868
1869     // We could be in waitpid for a particular thread (yay IndependentLwpControl...),
1870     // in which case we just kick _everyone_ up.
1871
1872     // Set runRequest to true
1873     syncRunWhenFinished_ = runRequest;
1874     
1875     // We can run this from a signal handler thread, which deadlocks - the sig handler
1876     // is waiting for the generator to run the process, and the generator thinks the handler
1877     // is active. One specific case of this is exec; we call proc->finishExec from the handler
1878     // and that calls loadDyninstLib. 
1879     // So if we're in a handler, then set the wait_flag.
1880     int waitingHandler = -1; // 0 or positive if we match...
1881     for (unsigned i = 0; i < handlers.size(); i++) {
1882         if (handlers[i]->getThreadID() == getExecThreadID()) {
1883             signal_printf("%s[%d]: continueProcessBlocking called on handler, setting wait_flag\n",
1884                           FILE__, __LINE__);
1885             waitingHandler = i;
1886             assert(handlers[i]->wait_flag == false);
1887             handlers[i]->wait_flag = true;
1888             break;
1889         }
1890     }
1891
1892
1893     if (lwp) {
1894         signal_printf("%s[%d]: adding lwp %d to continue list...\n",
1895                       FILE__, __LINE__, lwp->get_lwp_id());
1896         lwpsToContinue_.push_back(lwp);
1897     }
1898     else {
1899         // Someone wants us to run the whole nine yards
1900         continueWholeProcess_ = true;
1901     }
1902
1903
1904     if (waitingForOS_ && !independentLwpStop_) {
1905         // Make sure that all active signal handlers kick off...
1906         while (isActivelyProcessing()) {
1907             signal_printf("%s[%d]: continueProcessBlocking waiting for signal handlers\n",
1908                           FILE__, __LINE__);
1909             activationLock->_Unlock(FILE__, __LINE__);
1910             waitForEvent(evtAnyEvent);
1911             activationLock->_Lock(FILE__, __LINE__);
1912         }
1913             
1914         signal_printf("%s[%d]: Blocking continue and already in waitpid; overriding and continuing\n",
1915                       FILE__, __LINE__);
1916         // Just continue ze sucker
1917         continueProcessInternal();
1918         assert(activationLock->depth() == 1);
1919         activationLock->_Unlock(FILE__, __LINE__);
1920
1921         if (waitingHandler != -1) {
1922             signal_printf("%s[%d]: continueProcessBlocking on handler returning, resetting wait_flag\n",
1923                           FILE__, __LINE__);
1924             handlers[waitingHandler]->wait_flag = false;
1925         }
1926         return true;
1927     }
1928
1929     signal_printf("%s[%d]: grabbed requestContinueLock...\n", FILE__, __LINE__);
1930
1931     int lock_depth = eventlock->depth();
1932     assert(lock_depth > 0);
1933     
1934     // We can't iterate over eventlock->depth(); we unlock, someone else locks...
1935     // TODO: make this an eventLock method: "completely release"
1936     for (int i = 0; i < lock_depth; i++) {
1937         eventlock->_Unlock(FILE__, __LINE__);
1938     }
1939
1940     signal_printf("%s[%d]: continueProcessBlocking: gave up global mutex\n", FILE__, __LINE__);
1941
1942     signal_printf("%s[%d]: continueProcessBlocking, signalling SG\n", FILE__, __LINE__);
1943     activationLock->_Broadcast(FILE__, __LINE__);
1944
1945     signal_printf("%s[%d]: continueProcessBlocking, locking waitForContinue\n", FILE__, __LINE__);
1946     waitForContinueLock->_Lock(FILE__, __LINE__);
1947     signal_printf("%s[%d]: continueProcessBlocking, unlocking activationLock\n", FILE__, __LINE__);
1948
1949     assert(activationLock->depth() == 1);
1950     activationLock->_Unlock(FILE__, __LINE__);
1951
1952     numBlockedForContinue++;
1953     do {
1954         signal_printf("%s[%d]: continueProcessBlocking, waiting...\n", FILE__, __LINE__);
1955         //getMailbox()->executeCallbacks(FILE__, __LINE__);
1956         waitForContinueLock->_WaitForSignal(FILE__, __LINE__);
1957     } while (!continueCompleted_);
1958     
1959     numBlockedForContinue--;
1960     if (!numBlockedForContinue) {
1961         //Everyone's excepted the continue.  Reset the continueCompleted flag
1962         continueCompleted_ = false;
1963     }
1964     
1965     signal_printf("%s[%d]: continueProcessBlocking, woken up and releasing waitForContinue lock.\n", FILE__, __LINE__);
1966
1967     assert(waitForContinueLock->depth() == 1);
1968     waitForContinueLock->_Unlock(FILE__, __LINE__);
1969
1970     signal_printf("%s[%d]: continueProcessBlocking, process continued, grabbing %d global mutexes\n",
1971                   FILE__, __LINE__, lock_depth);
1972
1973     while (lock_depth > 0) {
1974         eventlock->_Lock(FILE__, __LINE__);
1975         lock_depth--;
1976     }
1977
1978     signal_printf("%s[%d]: continueProcessBlocking, returning\n",
1979                   FILE__, __LINE__);
1980
1981     if (waitingHandler != -1) {
1982         signal_printf("%s[%d]: continueProcessBlocking on handler returning, resetting wait_flag\n",
1983                       FILE__, __LINE__);
1984         handlers[waitingHandler]->wait_flag = false;
1985     }
1986     
1987     return true;
1988 }
1989
1990 bool SignalGeneratorCommon::continueRequired() 
1991 {
1992     // Do we need to continue the process or just check waitpid/poll?
1993
1994   if (independentLwpStop_) {
1995     // We're trying to stop an LWP, impolite to continue...
1996       signal_printf("%s[%d]: independent LWP stop on, not continuing...\n",
1997                     FILE__, __LINE__);
1998     return false;
1999   }
2000
2001   for (unsigned i = 0; i < handlers.size(); i++) {
2002       if (handlers[i]->processing()) {
2003           signal_printf("%s[%d]: continueRequired: handler %s active, returning false\n",
2004                         FILE__, __LINE__, getThreadStr(handlers[i]->getThreadID()));
2005           // Active handler == no run-y.
2006           return false;
2007       }
2008   }
2009
2010     // sync run gets priority...
2011   if (syncRunWhenFinished_ == stopRequest) {
2012       signal_printf("%s[%d]: syncRunWhenFinished = stop, not continuing...\n",
2013                     FILE__, __LINE__);
2014       return false;
2015   }
2016
2017     if (syncRunWhenFinished_ == runRequest) {
2018         if (asyncRunWhenFinished_ == stopRequest) {
2019             fprintf(stderr, "Odd case: BPatch requests run, internals request stop\n");
2020             return false;
2021         }
2022         signal_printf("%s[%d]: syncRunWhenFinished = run, continuing...\n",
2023                     FILE__, __LINE__);
2024         return true;
2025     }
2026
2027     // We're unset or purposefully ignoring. 
2028
2029     if (asyncRunWhenFinished_ == runRequest) {
2030       signal_printf("%s[%d]: asyncRunWhenFinished = run, continuing...\n",
2031                     FILE__, __LINE__);
2032         return true;
2033     }
2034     else if (asyncRunWhenFinished_ == stopRequest) {
2035         return false;
2036     }
2037     assert(asyncRunWhenFinished_ == unsetRequest);
2038
2039     // Both are unset... this might be an assert case.
2040     return false;
2041 }
2042
2043
2044 bool SignalGeneratorCommon::continueProcessInternal() {
2045     signal_printf("%s[%d]: continuing process...\n", FILE__, __LINE__);
2046
2047     bool res = true;
2048
2049     // We can get the following sequence of events:
2050     // UI: grab activationLock
2051     // UI: release eventLock
2052     // SG: grab eventLock
2053     // SG: continue process
2054     // SG: signal waitForContinueLock
2055     // SG: release eventLock
2056     // UI: wait for waitForContinueLock
2057     // ... so signal happens before wait. To prevent this,
2058     // we acquire the activationLock here. 
2059
2060     activationLock->_Lock(FILE__, __LINE__);
2061
2062     if ((lwpsToContinue_.size() != 0) &&
2063         process::IndependentLwpControl() &&
2064         !continueWholeProcess_) {
2065         for (unsigned i = 0; i < lwpsToContinue_.size(); i++) {
2066             signal_printf("%s[%d]: Continuing lwp %d\n", FILE__, __LINE__, lwpsToContinue_[i]->get_lwp_id());
2067             if (!lwpsToContinue_[i]->continueLWP(continueSig_))
2068                 res = false;
2069         }
2070     }
2071     else  {
2072         signal_printf("%s[%d]: Process continue: %d lwps, %d independent, %d continueWholeProcess\n", FILE__, __LINE__,
2073                       lwpsToContinue_.size(), process::IndependentLwpControl(), continueWholeProcess_);
2074         res = proc->continueProc_(continueSig_);
2075         if (res && proc->status() != exited) {
2076             proc->set_status(running);
2077         }
2078     }
2079
2080     lwpsToContinue_.clear();
2081     continueWholeProcess_ = false;
2082     
2083     continueSig_ = -1;
2084
2085     signal_printf("%s[%d]: setting global process state to running\n", FILE__, __LINE__);
2086         
2087     // Now wake up everyone who was waiting for me...
2088     signal_printf("%s[%d]: waking up everyone who was waiting for continue, locking...\n",
2089                   FILE__, __LINE__);
2090     waitForContinueLock->_Lock(FILE__, __LINE__);
2091     activationLock->_Unlock(FILE__, __LINE__);
2092     signal_printf("%s[%d]: waking up everyone who was waiting for continue, broadcasting...\n",
2093                   FILE__, __LINE__);
2094     continueCompleted_ = true;
2095     waitForContinueLock->_Broadcast(FILE__, __LINE__);
2096     signal_printf("%s[%d]: waking up everyone who was waiting for continue, unlocking\n",
2097                   FILE__, __LINE__);
2098     waitForContinueLock->_Unlock(FILE__, __LINE__);
2099
2100     if (!res)  {
2101         fprintf(stderr, "%s[%d]:  continueProc_ failed\n", FILE__, __LINE__);
2102         showErrorCallback(38, "System error: can't continue process");
2103         return false;
2104     }
2105
2106
2107     return true;
2108 }
2109
2110
2111 void SignalGeneratorCommon::setContinueSig(int signalToContinueWith) 
2112 {
2113     if ((continueSig_ != -1) &&
2114         (signalToContinueWith != continueSig_)) {
2115        signal_printf("%s[%d]: WARNING: conflict in signal to continue with: previous %d, new %d\n",
2116                 FILE__, __LINE__, continueSig_,  signalToContinueWith);
2117     }
2118
2119     continueSig_ = signalToContinueWith;
2120 }
2121
2122 bool SignalGeneratorCommon::pauseProcessBlocking() 
2123 {
2124     if (exitRequested()) {
2125         // We're going away... so don't do anything
2126         return true;
2127     }
2128
2129     signal_printf("%s[%d]: pauseProcessBlocking...\n", FILE__, __LINE__);
2130     syncRunWhenFinished_ = stopRequest;
2131
2132     return proc->pause();
2133 }
2134
2135 processRunState_t SignalGeneratorCommon::overrideSyncContinueState(processRunState_t newState) {
2136     signal_printf("%s[%d]: Overriding sync continue state, old %s, new %s\n",
2137                   FILE__, __LINE__, processRunStateStr(syncRunWhenFinished_),
2138                   processRunStateStr(newState));
2139
2140     processRunState_t current = syncRunWhenFinished_;
2141     syncRunWhenFinished_ = newState;
2142     return current;
2143 }
2144
2145 processRunState_t SignalGeneratorCommon::overrideAsyncContinueState(processRunState_t newState) {
2146     signal_printf("%s[%d]: Overriding async continue state, old %s, new %s\n",
2147                   FILE__, __LINE__, processRunStateStr(syncRunWhenFinished_),
2148                   processRunStateStr(newState));
2149
2150     processRunState_t current = asyncRunWhenFinished_;
2151     asyncRunWhenFinished_ = newState;
2152     return current;
2153 }
2154
2155 SignalGenerator::SignalGenerator(char *idstr, std::string file, std::string dir,
2156                                  pdvector<std::string> *argv,
2157                                  pdvector<std::string> *envp,
2158                                  std::string inputFile,
2159                                  std::string outputFile,
2160                                  int stdin_fd, int stdout_fd,
2161                                  int stderr_fd) :
2162    SignalGeneratorCommon(idstr),
2163    waiting_for_stop(false)
2164 {
2165     setupCreated(file, dir, 
2166                  argv, envp, 
2167                  inputFile, outputFile,
2168                  stdin_fd, stdout_fd, stderr_fd);
2169 }
2170
2171 void SignalGeneratorCommon::markProcessStop() { 
2172     independentLwpStop_++; 
2173     signal_printf("%s[%d]: markProcessStop => %d\n", FILE__, __LINE__, independentLwpStop_);
2174 }
2175
2176 void SignalGeneratorCommon::unmarkProcessStop() { 
2177     independentLwpStop_--; 
2178     assert(independentLwpStop_ >= 0); 
2179     signal_printf("%s[%d]: unmarkProcessStop => %d\n", FILE__, __LINE__, independentLwpStop_);
2180 }
2181
2182 void SignalGeneratorCommon::pingIfContinueBlocked() {
2183    waitForContinueLock->_Lock(FILE__, __LINE__);
2184    if (numBlockedForContinue) {
2185       waitForContinueLock->_Broadcast(FILE__, __LINE__);     
2186    }
2187    waitForContinueLock->_Unlock(FILE__, __LINE__);
2188 }
2189
2190 void SignalGeneratorCommon::MONITOR_ENTRY() {
2191     // Should we lock?
2192
2193     usage_count++;
2194 }
2195
2196 void SignalGeneratorCommon::MONITOR_EXIT() {
2197     assert(usage_count > 0);
2198     
2199     usage_count--;
2200
2201     if (usage_count == 0) {
2202         signal_printf("%s[%d]: Last user of signalGenerator exiting, cleaning up...\n",
2203                       FILE__, __LINE__);
2204         
2205         delete this;
2206     }
2207 }
2208
2209 bool SignalGeneratorCommon::checkActiveProcess()
2210 {
2211    if (!activeProcessSignalled_)
2212       return true;
2213 #if !defined(os_linux)
2214    // independent lwp control... going into waitpid too often is okay on linux,
2215    // but really a bad idea on AIX and Solaris (as you'll get the last thing again, and
2216    // again, and again, and again...)
2217    activeProcessSignalled_ = false;
2218    return true;
2219 #endif
2220
2221    bool found_running_sh = false;
2222    for (unsigned i=0; i<handlers.size(); i++) {
2223       SignalHandler *sh = handlers[i];
2224       if (!sh->idle()) {
2225          signal_printf("[%s]%u: checkActiveProcess - %s is not idle\n",
2226                        FILE__, __LINE__, sh->getName());
2227          found_running_sh = true;
2228          break;
2229       }
2230       else {
2231          signal_printf("[%s]%u: checkActiveProcess - %s is idle\n", 
2232                        FILE__, __LINE__, sh->getName());
2233       }
2234    }
2235    if (!found_running_sh) {
2236       signal_printf("[%s]%u: All SH are idle, belaying\n", FILE__, __LINE__);
2237       belayActiveProcess();
2238       return true;
2239    }
2240    
2241    if (proc->threads.size() == 1) {
2242       signal_printf("[%s]%u: Only one thread in mutatee, belaying.\n",
2243                     FILE__, __LINE__);
2244       belayActiveProcess();
2245       return true;
2246    }
2247    /*   
2248    bool all_stopped = true;
2249    for (unsigned i=0; i<proc->threads.size(); i++) {
2250       if (proc->threads[i]->get_lwp()->status() != stopped) {
2251          all_stopped = false;
2252          break;
2253       }
2254    }
2255    if (all_stopped) {
2256       signal_printf("[%s]%u: All threads are stopped, belaying.\n",
2257                     FILE__, __LINE__);
2258       belayActiveProcess();
2259       return true;
2260    }
2261 */
2262    return true;
2263 }