* Correctly open the first dependency that matches the ABI of its parent.
[dyninst.git] / dyninstAPI / src / linux.C
1 /*
2  * Copyright (c) 1996-2004 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  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 // $Id: linux.C,v 1.279 2008/09/03 06:08:44 jaw Exp $
43
44 #include <fstream>
45 #include <string>
46
47 #include "dyninstAPI/src/process.h"
48 #include "dyninstAPI/src/dyn_thread.h"
49 #include "dyninstAPI/src/dyn_lwp.h"
50
51 #include <sys/ptrace.h>
52 #include <sys/ioctl.h>
53 #include <fcntl.h>
54 #include <signal.h>
55 #include <dlfcn.h>
56 #include <sys/user.h>
57 #include <sys/time.h>
58 #include <sys/types.h>
59 #include <sys/stat.h>
60 #include <sys/wait.h>
61 #include <dirent.h>
62 #include <sys/resource.h>
63 #include <math.h> // for floor()
64 #include <unistd.h>
65 #include <string>
66
67 #include "dyninstAPI/src/binaryEdit.h"
68 #include "dyninstAPI/src/symtab.h"
69 #include "dyninstAPI/src/function.h"
70 #include "dyninstAPI/src/instPoint.h"
71 #include "dyninstAPI/src/baseTramp.h"
72 #include "dyninstAPI/src/signalhandler.h"
73 #include "dyninstAPI/src/signalgenerator.h"
74 #include "dyninstAPI/src/eventgate.h"
75 #include "dyninstAPI/src/mailbox.h"
76 #include "dyninstAPI/src/debuggerinterface.h"
77 #include "common/h/headers.h"
78 #include "common/h/linuxKludges.h"
79 #include "dyninstAPI/src/os.h"
80 #include "common/h/stats.h"
81 #include "common/h/Types.h"
82 #include "dyninstAPI/src/debug.h"
83 #include "dyninstAPI/src/util.h" // getCurrWallTime
84 #include "common/h/pathName.h"
85 #include "mapped_object.h"
86 #include "mapped_module.h"
87 #include "linux.h"
88
89 #include "ast.h" // instrumentation for MT
90
91 #include "dynamiclinking.h"
92
93 #if defined (cap_save_the_world)
94 #include "dyninstAPI/src/addLibraryLinux.h"
95 #include "dyninstAPI/src/writeBackElf.h"
96 // #include "saveSharedLibrary.h" 
97 #endif
98 #include "symtabAPI/h/Symtab.h"
99
100 //TODO: Remove the writeBack functions and get rid of this include
101 #ifdef PAPI
102 #include "papi.h"
103 #endif
104
105 //These values can be different on different platforms, and don't seem to be
106 //consistently defined in the system's include files.
107 #if !defined(PTRACE_SETOPTIONS)
108 #if defined(arch_x86)
109 #define PTRACE_SETOPTIONS 21
110 #elif defined(arch_ia64)
111 #define PTRACE_SETOPTIONS 0x4200
112 #endif
113 #endif
114
115 #if !defined(PT_TRACE_EXIT)
116 #define PTRACE_O_TRACEEXIT 0x40
117 #endif
118
119 #if defined(PTRACEDEBUG) && !defined(PTRACEDEBUG_ALWAYS)
120 static bool debug_ptrace = false;
121 #endif
122
123 WaitpidMux SignalGenerator::waitpid_mux;
124
125 /* ********************************************************************** */
126
127 void printStackWalk( process *p ) {
128   dyn_lwp *lwp_to_use = NULL;
129   if(process::IndependentLwpControl() && p->getRepresentativeLWP() ==NULL)
130      lwp_to_use = p->getInitialThread()->get_lwp();
131   else
132      lwp_to_use = p->getRepresentativeLWP();
133
134   Frame theFrame = lwp_to_use->getActiveFrame();
135   while (true) {
136     // do we have a match?
137     const Address framePC = theFrame.getPC();
138     inferiorrpc_cerr << "stack frame pc @ " << (void*)framePC << endl;
139     
140     if (theFrame.isLastFrame())
141       // well, we've gone as far as we can, with no match.
142       break;
143     
144     // else, backtrace 1 more level
145     theFrame = theFrame.getCallerFrame();
146   }
147 }
148  
149 // already setup on this FD.
150 // disconnect from controlling terminal 
151 void OS::osDisconnect(void) 
152 {
153   int ttyfd = open ("/dev/tty", O_RDONLY);
154   ioctl (ttyfd, TIOCNOTTY, NULL);
155   P_close (ttyfd);
156 }
157
158
159 void OS::osTraceMe(void) 
160
161    int result = P_ptrace(PTRACE_TRACEME, 0, 0, 0);
162    if (result == -1) {
163       perror("Couldn't ptrace(PTRACE_TRACEME)\n");
164    }
165 }
166
167 bool SignalGenerator::attachToChild(int pid)
168 {
169    //  wait for child process to stop itself, attach to it, and continue
170    int status = 0, res;
171    
172    waitpid_mux.registerProcess(this);
173    
174    /**
175     * Recieve the SIGSTOP event associated with a PTRACE_TRACEME/exec
176     * pair here.  We'll then add it back to the signalgenerator so that it
177     * can be found again latter when we're waiting for a process create event.
178     **/
179    do {
180       res = waitpid_mux.waitpid(this, &status);
181       if ((res == -1 && errno == EINTR) || (res == 0))
182          continue; //waitpid returned without a value
183       if (res == -1) {
184          perror("Couldn't successfully waitpid on starting process");
185          break;
186       }
187       if (WIFSIGNALED(status) || WIFEXITED(status)) {
188           startup_printf("[%s:%u] - Process terminated during attach\n", 
189                  FILE__, __LINE__);
190          return false;
191       }
192       if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) {
193          startup_printf("[%s:%u] - Recieved notice of successful exec after "
194                         "fork.\n", FILE__, __LINE__);
195          //Normal case, we got the sigtrap
196          break;
197       }
198       if (WIFSTOPPED(status)) {
199          startup_printf("[%s:%u] - Recieved unexpected signal %d, "
200                         "throwing back\n", FILE__, __LINE__, WSTOPSIG(status));
201          P_ptrace(PTRACE_CONT, pid, (Address) NULL, WSTOPSIG(status));
202       }
203    } while (!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGTRAP));
204
205    waitpid_ret_pair ev;
206    ev.status = status;
207    ev.pid = pid;
208    waitpid_mux.enqueueWaitpidValue(ev, this);
209
210    return true;
211 }
212
213 bool SignalGenerator::decodeEvents(pdvector<EventRecord> &events)
214 {
215   //  ev.info has the status result from waitpid
216     for (unsigned i = 0; i < events.size(); i++) {
217         EventRecord &ev = events[i];
218
219         if (ev.type == evtUndefined) {
220             if (!decodeWaitPidStatus(ev.info, ev)) 
221                 fprintf(stderr, "%s[%d][%s]:  failed to decode status for event\n", 
222                         FILE__, __LINE__, getThreadStr(getExecThreadID()));
223         }
224         
225         errno = 0;
226         if (ev.type == evtSignalled) {
227            /* There's a process-wide waiting for stop we need to worry about;
228               we could be asking the process to stop but any of the independent
229               LWPs to, yet.  (If the SIGSTOP is delayed, by, say, an iRPC completion,
230               then we don't know which LWP will receive the STOP.) */
231            if( waiting_for_stop || (ev.lwp && ev.lwp->isWaitingForStop()) ) {
232               signal_printf("%s[%d]: independentLwpStop_ %d (lwp %d %s), checking for suppression...\n",
233                             FILE__, __LINE__,
234                             independentLwpStop_,
235                             ev.lwp ? ev.lwp->get_lwp_id() : (unsigned)-1,
236                             ev.lwp ? (ev.lwp->isWaitingForStop() ? "waiting for stop" : "not waiting for stop") : "no LWP");
237               
238               if (suppressSignalWhenStopping(ev)) {
239                  signal_printf("%s[%d]: suppressing signal... \n", FILE__, __LINE__);
240                  //  we suppress this signal, just send a null event
241                  ev.type = evtIgnore;
242                  signal_printf("%s[%d]: suppressing signal during wait for stop\n", FILE__, __LINE__);
243                  return true;
244               }
245            }
246            signal_printf("%s[%d]: decoding signal \n", FILE__, __LINE__);
247            decodeSignal(ev);
248         }
249         
250         if (ev.type == evtUndefined) {
251             //  if we still have evtSignalled, then it must not be a signal that
252             //  we care about internally.  Still, send it along to the handler
253             //  to be forwarded back to the process.
254             char buf[512];
255             fprintf(stderr, "%s[%d]:  got event %s, should have been set by now\n", FILE__, __LINE__, ev.sprint_event(buf));
256         }
257     }
258     
259     return true;
260 }
261
262 bool get_linux_version(int &major, int &minor, int &subvers)
263 {
264     int subsub;
265     return get_linux_version(major,minor,subvers,subsub); 
266 }
267
268 bool get_linux_version(int &major, int &minor, int &subvers, int &subsubvers)
269 {
270    static int maj = 0, min = 0, sub = 0, subsub = 0;
271    int result;
272    FILE *f;
273    if (maj)
274    {
275       major = maj;
276       minor = min;
277       subvers = sub;
278       subsubvers = subsub;
279       return true;
280    }
281    f = P_fopen("/proc/version", "r");
282    if (!f) goto error;
283    result = fscanf(f, "Linux version %d.%d.%d.%d", &major, &minor, &subvers,
284                     &subsubvers);
285    fclose(f);
286    if (result != 3 && result != 4) goto error;
287
288    maj = major;
289    min = minor;
290    sub = subvers;
291    subsub = subsubvers;
292    return true;
293
294  error:
295    //Assume 2.4, which is the earliest version we support
296    major = maj = 2;
297    minor = min = 4;
298    subvers = sub = 0;
299    subsubvers = subsub = 0;
300    return false;
301 }
302
303 bool SignalGenerator::add_lwp_to_poll_list(dyn_lwp *lwp)
304 {
305    char filename[64];
306    int lwpid, major, minor, sub;
307    struct stat buf;
308
309    get_linux_version(major, minor, sub);   
310    if ((major == 2 && minor > 4) || (major >= 3))
311       return true;
312    if (!lwp->proc()->multithread_capable(true))
313       return true;
314
315    /**
316     * Store pids that can be found as /proc/pid as pid 
317     * Store pids that can be found as /proc/.pid as -1*pid
318     **/
319    lwpid = lwp->get_lwp_id();
320    snprintf(filename, 64, "/proc/%d", lwpid);
321    if (stat(filename, &buf) == 0)
322    {
323       attached_lwp_ids.push_back(lwpid);
324       return true;
325    }
326
327    snprintf(filename, 64, "/proc/.%d", lwpid);
328    if (stat(filename, &buf) == 0)
329    {
330       attached_lwp_ids.push_back(-1 * lwpid);
331       return true;
332    }
333    
334    fprintf(stderr, "[%s:%u] - Internal Error.  Could not find new process %d"
335            " in /proc area.  Thread deletion callbacks may not work\n", 
336            __FILE__, __LINE__, lwpid);
337    return false;
338 }
339
340 bool SignalGenerator:: remove_lwp_from_poll_list(int lwp_id)
341 {
342    bool found = false;
343    for (int i=attached_lwp_ids.size()-1; i>=0; i--)
344    {
345       int lcur = abs(attached_lwp_ids[i]);
346       if (lcur == lwp_id)
347       {
348          VECTOR_ERASE(attached_lwp_ids,i, i);
349          found = true;
350       }
351    }
352    return found;
353 }
354
355 bool SignalGenerator::exists_dead_lwp()
356 {
357    struct stat buf;
358    char filename[64];
359    int lwpid;
360
361    for (unsigned i=0; i<attached_lwp_ids.size(); i++)
362    {
363       lwpid = attached_lwp_ids[i];
364       if (lwpid >= 0)
365          snprintf(filename, 64, "/proc/%d", lwpid);
366       else
367          snprintf(filename, 64, "/proc/.%d", -1 * lwpid);
368       if (stat(filename, &buf) != 0)
369       {
370          return true;
371       }
372    }
373    return false;
374 }
375
376 int SignalGenerator::find_dead_lwp()
377 {
378    struct stat buf;
379    char filename[64];
380    int lwpid;
381
382    for (unsigned i=0; i<attached_lwp_ids.size(); i++)
383    {
384       lwpid = attached_lwp_ids[i];
385       if (lwpid >= 0)
386          snprintf(filename, 64, "/proc/%d", lwpid);
387       else
388          snprintf(filename, 64, "/proc/.%d", -1 * lwpid);
389       if (stat(filename, &buf) != 0)
390       {
391          remove_lwp_from_poll_list(lwpid);
392          return lwpid;
393       }
394    }
395    return 0;
396 }
397
398 pid_t SignalGenerator::waitpid_kludge(pid_t /*pid_arg*/, 
399                                       int *status, 
400                                       int /*options*/, 
401                                       int *dead_lwp)
402 {
403   pid_t ret = 0;
404
405   do {
406    *dead_lwp = find_dead_lwp();
407    if (*dead_lwp) {
408        // This is a bad hack.  On Linux 2.4 waitpid doesn't return for dead threads,
409        // so we poll for any dead threads before calling waitpid, and if they exist
410        // we simulate the result as if waitpid had returned the desired value.
411        status = 0;
412        ret = *dead_lwp;
413        break;
414     }
415
416    errno = 0;
417    ret = waitpid_mux.waitpid(this, status);
418   } while (ret == 0 || (ret == -1 && errno == EINTR));
419
420   if (ret == -1)
421      signal_printf("%s[%d]: waitpid_kludge got -1\n", FILE__, __LINE__);
422   return ret; 
423 }
424
425 bool SignalGenerator::waitForEventsInternal(pdvector<EventRecord> &events) 
426 {
427   signal_printf("%s[%d]:  welcome to waitNextEventLocked\n", FILE__, __LINE__);
428
429   assert(proc);
430
431   int waitpid_pid = 0;
432   int status = 0;
433   int dead_lwp = 0;
434
435   //  If we have a rep lwp, the process is not multithreaded, so just wait for 
436   //  the pid.  If the process is MT, wait for the process group of the first
437   //  mutatee thread (-1 * pgid)
438
439   int pid_to_wait_for = (proc->getRepresentativeLWP() ? getPid() : -1*getpgid(getPid()));
440
441   //  wait for process events, on linux __WALL signifies that both normal children
442   //  and cloned children (lwps) should be listened for.
443   //  Right now, we are blocking.  To make this nonblocking, or this val with WNOHANG.
444   
445   //  __WNOTHREAD signifies that children of other threads (other signal handlers)
446   //  should not be listened for.
447
448   int wait_options = __WALL;
449
450   waitingForOS_ = true;
451   __UNLOCK;
452   waitpid_pid = waitpid_kludge( pid_to_wait_for, &status, wait_options, &dead_lwp );
453   __LOCK;
454   waitingForOS_ = false;
455   if (WIFSTOPPED(status))
456      proccontrol_printf("waitpid - %d stopped with %d\n", waitpid_pid, 
457                         WSTOPSIG(status));
458
459   /* If we were in waitpid() when we detach from/deleted the process, Funky
460      Stuff may happen.  You may want to check if this is the case before
461      and return false, before doing anything that uses the 'proc' variable. */
462
463   if (waitpid_pid < 0 && errno == ECHILD) {
464      /* I am told that this can spontaneously and transiently occur while running under
465         Valgrind, and that the proper thing to do is just go back and try again.  I'm
466         leaving the fprintf() in because while this condition is thus not always erroneous,
467         we should be worried about it when it shows up otherwise. */
468      signal_printf("%s[%d]:  waitpid(%d) failed with ECHILD\n", 
469                    __FILE__, __LINE__, pid_to_wait_for );
470      return false; /* nothing to wait for */
471   } else if (waitpid_pid < 0) {
472      perror("checkForEventLinux: waitpid failure");
473   } else if(waitpid_pid == 0) {
474      fprintf(stderr, "%s[%d]:  waitpid \n", __FILE__, __LINE__);
475      return false;
476   }
477
478   //  If the UI thread wants to initiate a shutdown, it might set a flag and 
479   //  then send a SIGTRAP to the mutatee process, so as to wake up the
480   //  event handling system.  A shutdown event trumps all others, so we handle it
481   //  first.
482  
483   EventRecord ev;
484
485   if (!proc) {
486      //We're exiting
487      return false;
488   }
489
490   ev.proc = proc;
491   ev.lwp = proc->lookupLWP(waitpid_pid);
492
493   if (!ev.lwp || stop_request) {
494       // Process was deleted? Run away in any case...
495       ev.type = evtShutDown;
496       return true;
497   }
498   
499   /* For clarity during debugging, fully initialize the event. */
500   ev.type = evtUndefined;
501   ev.what = 0;
502   ev.status = statusUnknown;
503   ev.info = status;
504   ev.address = 0;      
505   ev.fd = -1;
506
507   ev.proc->set_lwp_status(ev.lwp, stopped);
508     
509   bool process_exited = WIFEXITED(status) || dead_lwp;
510   if ((process_exited) && (waitpid_pid != ev.proc->getPid())) {
511      proccontrol_printf("%s[%d]: Received a thread deletion event for %d\n", 
512                         FILE__, __LINE__, ev.lwp->get_lwp_id());
513      signal_printf("%s[%d]: Received a thread deletion event for %d\n", 
514                    FILE__, __LINE__, ev.lwp->get_lwp_id());
515      // Thread exited via signal
516      ev.type = evtSyscallEntry;      
517      ev.what = SYS_lwp_exit;
518      decodeSyscall(ev);
519   }
520
521   events.push_back(ev);
522   return true;
523 }
524
525 void process::independentLwpControlInit() 
526 {
527    if(multithread_capable()) {
528       // On linux, if process found to be MT, there will be no
529       // representativeLWP since there is no lwp which controls the entire
530       // process for MT linux.
531       real_lwps[representativeLWP->get_lwp_id()] = representativeLWP;
532       representativeLWP = NULL;
533    }
534 }
535
536 dyn_lwp *process::createRepresentativeLWP() 
537 {
538    // the initial lwp has a lwp_id with the value of the pid
539
540    // if we identify this linux process as multi-threaded, then later we will
541    // adjust this lwp to be identified as a real lwp.
542    dyn_lwp *initialLWP = createFictionalLWP(getPid());
543    representativeLWP = initialLWP;
544    // Though on linux, if process found to be MT, there will be no
545    // representativeLWP since there is no lwp which controls the entire
546    // process for MT linux.
547
548    return initialLWP;
549 }
550
551 bool process::trapAtEntryPointOfMain(dyn_lwp *trappingLWP, Address)
552 {
553     if (main_brk_addr == 0x0) return false;
554     assert(trappingLWP);
555     Frame active = trappingLWP->getActiveFrame();
556     if (active.getPC() == main_brk_addr ||
557         (active.getPC()-1) == main_brk_addr)
558         return true;
559     else {
560       fprintf(stderr, "%s[%d]:  pc =  %lx\n",
561             FILE__, __LINE__, active.getPC());
562     }
563     return false;
564 }
565
566 bool process::trapDueToDyninstLib(dyn_lwp *trappingLWP)
567 {
568     // is the trap instr at dyninstlib_brk_addr?
569     if (dyninstlib_brk_addr == 0) return false;
570     assert(trappingLWP);
571     Frame active = trappingLWP->getActiveFrame();
572     if (active.getPC() == dyninstlib_brk_addr ||
573         (active.getPC()-1) == dyninstlib_brk_addr)
574         return true;
575     return false;
576 }
577
578 bool process::setProcessFlags() {
579     // None that I'm aware of -- bernat, 24FEB04
580     return true;
581 }
582
583 bool process::unsetProcessFlags(){
584     // As above
585     return true;
586 }
587
588
589 void emitCallRel32(unsigned disp32, unsigned char *&insn);
590
591 static int lwp_kill(int pid, int sig)
592 {
593   int result = P_tkill(pid, sig);
594   if (result == -1 && errno == ENOSYS)
595   {
596      result = P_kill(pid, sig);
597      proccontrol_printf("%s[%d]: Sent %d to %d via kill\n", FILE__, __LINE__, 
598                         sig, pid);
599   }
600   else if ( result == -1 )
601   {
602   fprintf( stderr, "%s[%d]: failed to tkill( %d, %d ): ", FILE__, __LINE__, pid, sig );
603   perror( "" );
604   }
605   else
606      proccontrol_printf("%s[%d]: Sent %d to %d via tkill\n", FILE__, __LINE__, 
607                         sig, pid);
608
609   return result;
610 }
611
612
613 /**
614  * Return the state of the process from /proc/pid/stat.
615  * File format is:
616  *   pid (executablename) state ...
617  * where state is a character.  Returns '\0' on error.
618  **/
619 static char getState(int pid)
620 {
621   char procName[64];
622   char sstat[256];
623   char *status;
624   int paren_level = 1;
625
626   sprintf(procName,"/proc/%d/stat", pid);
627   FILE *sfile = P_fopen(procName, "r");
628   if (sfile == NULL) return '\0';
629   fread( sstat, 1, 256, sfile );
630   fclose( sfile );
631   sstat[255] = '\0';
632   status = sstat;
633   
634   while (*status != '\0' && *(status++) != '(') ;
635   while (*status != '\0' && paren_level != 0)
636   {
637     if (*status == '(') paren_level++;
638     if (*status == ')') paren_level--;
639     status++;
640   }
641   while (*status == ' ') status++;
642   return *status;
643 }
644  
645 bool process::isRunning_() const 
646 {
647   char result = getState(getPid());
648 //  assert(result != '\0');
649   if (result == '\0') {
650     return false;
651   }
652   return (result != 'T');
653 }
654
655 bool dyn_lwp::isRunning() const 
656 {
657   char result = getState(get_lwp_id());
658   assert(result != '\0');
659   return (result != 'T');
660 }
661
662 bool dyn_lwp::isWaitingForStop() const
663 {
664     signal_printf("%s[%d]: checking LWP %d waiting_for_stop: %d\n",
665                   FILE__, __LINE__, get_lwp_id(), waiting_for_stop);
666    return waiting_for_stop;
667 }
668
669 bool SignalGenerator::suppressSignalWhenStopping(EventRecord &ev)
670 {
671  
672   if ( ev.what == SIGSTOP )
673      return false;
674
675   /* If we're suppressing signals, regenerate them at the end of the
676      queue to avoid race conditions. */
677   if( ev.what == SIGTRAP ) {
678 #if defined(arch_x86) || defined(arch_x86_64)
679      Address trap_pc = ev.lwp->getActiveFrame().getPC();
680      ev.lwp->changePC(trap_pc - 1, NULL);
681 #endif /* defined( arch_ia64 ) */
682   }
683
684   ev.lwp->continueLWP_(0, true);
685   ev.proc->set_lwp_status(ev.lwp, running);
686
687   if ( ev.what == SIGILL  || 
688        //ev.what == SIGTRAP || 
689        ev.what == SIGFPE  || 
690        ev.what == SIGSEGV || 
691        ev.what == SIGBUS ) {
692      // We don't actually throw back signals that are caused by 
693      // executing an instruction.  We can just drop these and
694      // let the continueLWP_ re-execute the instruction and cause
695      // it to be rethrown.
696      return true;
697   }
698
699   if ( ev.what != SIGTRAP ) {
700      suppressed_sigs.push_back(ev.what);
701      suppressed_lwps.push_back(ev.lwp);
702   }
703
704   return true;
705 }
706
707 bool SignalGenerator::resendSuppressedSignals()
708 {
709   assert(suppressed_sigs.size() == suppressed_lwps.size());
710   for (unsigned int i = 0; i < suppressed_sigs.size(); ++i)
711   {
712     //Throw back the extra signals we caught.
713     lwp_kill(suppressed_lwps[i]->get_lwp_id(), suppressed_sigs[i]);
714   }
715   suppressed_lwps.clear();
716   suppressed_sigs.clear();
717   return true;
718 }
719
720 bool dyn_lwp::removeSigStop()
721 {
722   //fprintf(stderr, "%s[%d][%s]:  welcome to removeSigStop, about to lwp_kill(%d, %d)\n",
723    //       FILE__, __LINE__, getThreadStr(getExecThreadID()), get_lwp_id(), SIGCONT);
724   return (lwp_kill(get_lwp_id(), SIGCONT) == 0);
725 }
726
727 bool dyn_lwp::continueLWP_(int signalToContinueWith, bool ignore_suppress) 
728 {
729    proccontrol_printf("%s[%d]:  ContinuingLWP_ %d with %d\n", FILE__, __LINE__,
730           get_lwp_id(), signalToContinueWith);
731
732    // we don't want to operate on the process in this state
733    int arg3 = 0;
734    int arg4 = 0;
735    if(signalToContinueWith != NoSignal) {
736       arg3 = 1;
737       arg4 = signalToContinueWith;
738    }
739
740    if (! ignore_suppress) {
741       if (proc()->sh->waitingForStop())
742       {
743          return false;
744       }
745    }
746
747    if (status() == exited) {
748        proccontrol_printf("%s[%d]: lwp %d status is exited, not continuing...\n", FILE__, __LINE__, get_lwp_id());
749       return true;
750    }
751
752    proccontrol_printf("%s[%d]: lwp %d getting PTRACE_CONT with signal %d\n",
753                       FILE__, __LINE__, get_lwp_id(), arg4);
754    ptraceOps++; 
755    ptraceOtherOps++;
756
757    int ptrace_errno = 0;
758    int ret;
759    if (proc()->getTraceSysCalls()) {
760        ret = DBI_ptrace(PTRACE_SYSCALL, get_lwp_id(), arg3, arg4,
761                        &ptrace_errno, proc_->getAddressWidth(),
762                        FILE__, __LINE__);
763    }
764    else {
765       ret = DBI_ptrace(PTRACE_CONT, get_lwp_id(), arg3, arg4,
766                        &ptrace_errno, proc_->getAddressWidth(),
767                        FILE__, __LINE__);
768    }
769
770    if (ret == 0)
771       return true;
772
773    if(ptrace_errno == ESRCH) // lwp terminated
774       return true;
775
776    /**
777     * A stopped ptrace'd process can be in two states on Linux.
778     * If it blocked on a signal, but never received a PTRACE_CONT,
779     * then it should be continued with a PTRACE_CONT.
780     *
781     * If the kernel couldn't find an awake thread to deliver the signal to,
782     * it'll grab anyone (usually the last) and wake them up for long enough
783     * to deliver the signal.  This leaves that thread is a different state
784     * than the others, and it won't actually respond to the PTRACE_CONT.  
785     **/
786    ret = P_kill(get_lwp_id(), SIGCONT);
787    if (ret == -1)
788       return false;
789    return true;
790 }
791
792 bool dyn_lwp::waitUntilStopped()
793 {
794    if ((status() == stopped) || (status() == exited))
795    {
796       return true;
797    }
798    
799    SignalGenerator *sh = (SignalGenerator *) proc()->sh;
800    waiting_for_stop = true;
801    
802    // Wake up the signal generator...
803    signal_printf("%s[%d]: waitUntilStopped for lwp %u\n",
804                  FILE__, __LINE__, get_lwp_id());
805    
806    // Continue suppression technique...
807    sh->markProcessStop();
808    while (status() != stopped) {
809       if( status() == exited ) break;
810       
811       // and make sure the signal generator is woken up and in waitpid...
812       sh->signalActiveProcess();
813       
814       signal_printf("%s[%d]:  before waitForEvent(evtProcessStop) for lwp %d: status is %s\n",
815                     FILE__, __LINE__, get_lwp_id(), getStatusAsString().c_str());
816       sh->waitForEvent(evtProcessStop, NULL, NULL, NULL_STATUS_INITIALIZER, false);
817    }
818  
819    waiting_for_stop = false;
820    
821    sh->belayActiveProcess();
822    sh->unmarkProcessStop();
823    sh->resendSuppressedSignals();
824    
825    return true;
826 }
827
828 bool dyn_lwp::stop_() 
829 {
830     if (waiting_for_stop) {
831         return true;
832     }
833
834     proccontrol_printf("%s[%d][%s]:  welcome to stop_, about to lwp_kill(%d, %d)\n",
835                        FILE__, __LINE__, getThreadStr(getExecThreadID()), get_lwp_id(), SIGSTOP);
836     return (lwp_kill(get_lwp_id(), SIGSTOP) == 0);
837
838
839 bool process::continueProc_(int sig)
840 {
841   bool no_err = true;
842   dyn_lwp *lwp;
843   unsigned index = 0; 
844
845    //Continue all real LWPs
846   dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
847   while (lwp_iter.next(index, lwp))
848   {
849      if (lwp->status() == running || lwp->status() == exited)
850         continue;
851
852      bool result = lwp->continueLWP(sig);
853      if (result)
854         set_lwp_status(lwp, running);
855      else
856         no_err = false;
857   }
858
859   //Continue any representative LWP
860   if (representativeLWP && representativeLWP->status() != running)
861   {
862      bool result = representativeLWP->continueLWP(sig);
863      if (result)
864         set_lwp_status(representativeLWP, running);
865      else
866         no_err = false;
867   }
868
869   return no_err;
870 }
871
872 bool SignalGenerator::waitForStopInline()
873 {
874     int retval = 0;
875     int status = 0;
876     
877     retval = waitpid_mux.waitpid(this, &status);
878     if (retval < 0) {
879         //  should do some better checking here....
880         perror("waitpid");
881         return false;
882     }
883     
884     signal_printf("%s[%d]: waitForStopInline with retval %d, sig %d/%d\n", 
885                   FILE__, __LINE__, retval, WIFSTOPPED(status), WSTOPSIG(status));
886     
887     return true;
888 }
889
890 bool process::stop_(bool waitUntilStop)
891 {
892   int result;
893   bool retval = false;
894   dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
895   unsigned index = 0;
896   dyn_lwp *lwp;
897   
898   
899   if (status_ == stopped) {
900      return true;
901   }
902
903   sh->setWaitingForStop(true);
904   
905   //Stop the main process
906   result = P_kill(getPid(), SIGSTOP);
907   if (result == -1) 
908   {
909     perror("Couldn't send SIGSTOP\n");
910     goto done;
911   }
912
913
914   if (waitUntilStop) {
915     if (!waitUntilLWPStops()) 
916        goto done;
917     if (status() == exited)
918        goto done;
919   }
920
921   //Stop all other LWPs
922   while(lwp_iter.next(index, lwp))
923   {
924      lwp->pauseLWP(waitUntilStop);
925   }
926
927   retval = true;
928  done:
929   sh->setWaitingForStop(false);
930   ((SignalGenerator *)sh)->resendSuppressedSignals();
931
932   return retval;
933 }
934
935 bool process::waitUntilStopped()
936 {
937     signal_printf("%s[%d]: process waitUntilStopped...\n", FILE__, __LINE__);
938     dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
939     dyn_lwp *lwp;
940     unsigned index = 0;
941     bool result = true;
942     
943     while(lwp_iter.next(index, lwp))
944         {
945             
946             result &= lwp->waitUntilStopped();
947         }
948     
949     return result;
950 }
951
952 bool process::waitUntilLWPStops()
953 {
954    sh->markProcessStop();
955
956    while ( status() != stopped) {
957       if (status() == exited) {
958          sh->unmarkProcessStop();
959          return false;
960       }
961       signal_printf("%s[%d][%s]:  before waitForEvent(evtProcessStop)\n", 
962                     FILE__, __LINE__, getThreadStr(getExecThreadID()));
963       sh->waitForEvent(evtProcessStop);
964    }
965    sh->unmarkProcessStop();
966
967    return true;
968 }
969
970 terminateProcStatus_t process::terminateProc_()
971 {
972   if (kill( getPid(), SIGKILL )) {
973     // Kill failed... 
974     if (errno == ESRCH)
975       return alreadyTerminated;
976     else
977       return terminateFailed;
978   }
979
980   if (status() == stopped)
981      continueProc(SIGCONT);
982
983     return terminateSucceeded;
984 }
985
986 void dyn_lwp::realLWP_detach_() 
987 {
988    if(! proc_->isAttached()) {
989       if (! proc_->hasExited())
990          cerr << "Detaching, but not attached" << endl;
991       return;
992    }
993     
994     ptraceOps++;
995     ptraceOtherOps++;
996     int ptrace_errno = 0;
997     int ptrace_ret = DBI_ptrace(PTRACE_DETACH, get_lwp_id(),1, SIGCONT, &ptrace_errno, proc_->getAddressWidth(),  __FILE__, __LINE__); 
998     if (ptrace_ret < 0) {
999       fprintf(stderr, "%s[%d]:  ptrace failed: %s\n", __FILE__, __LINE__, strerror(ptrace_errno));
1000     }
1001     proc()->sh->remove_lwp_from_poll_list(get_lwp_id());
1002     proc()->sh->unregisterLWP(get_lwp_id());
1003
1004     if (fd_ != INVALID_HANDLE_VALUE) {
1005         close(fd_);
1006         fd_ = INVALID_HANDLE_VALUE;
1007     }
1008
1009     return;
1010 }
1011
1012 void dyn_lwp::representativeLWP_detach_() {
1013     // If the process is already exited, then don't call ptrace
1014     if(! proc_->isAttached())
1015         return;
1016     
1017     if (fd_) close(fd_);
1018     
1019     ptraceOps++;
1020     ptraceOtherOps++;
1021    int ptrace_errno = 0;
1022     DBI_ptrace(PTRACE_DETACH, get_lwp_id(),1, SIGCONT, &ptrace_errno, proc_->getAddressWidth(),  __FILE__, __LINE__); 
1023     proc()->sh->remove_lwp_from_poll_list(get_lwp_id());
1024     proc()->sh->unregisterLWP(get_lwp_id());
1025
1026     return;
1027 }
1028
1029 bool process::dumpCore_(const std::string/* coreFile*/) { return false; }
1030
1031 bool dyn_lwp::writeTextWord(caddr_t inTraced, int data) {
1032    //  cerr << "writeTextWord @ " << (void *)inTraced << endl; cerr.flush();
1033    return writeDataSpace(inTraced, sizeof(int), (caddr_t) &data);
1034 }
1035
1036 bool dyn_lwp::writeTextSpace(void *inTraced, u_int amount, const void *inSelf)
1037 {
1038   //    cerr << "writeTextSpace pid=" << getPid() << ", @ " << (void *)inTraced
1039   //     << " len=" << amount << endl; cerr.flush();
1040    return writeDataSpace(inTraced, amount, inSelf);
1041 }
1042
1043 bool dyn_lwp::readTextSpace(void *inTraced, u_int amount, const void *inSelf) {
1044    return readDataSpace(inTraced, amount, const_cast<void*>( inSelf ));
1045 }
1046
1047 bool DebuggerInterface::bulkPtraceWrite(void *inTraced, u_int nbytes, void *inSelf, int pid, int /*address_width*/)
1048 {
1049    unsigned char *ap = (unsigned char*) inTraced;
1050    const unsigned char *dp = (const unsigned char*) inSelf;
1051    Address w = 0x0;               /* ptrace I/O buffer */
1052    int len = sizeof(Address); /* address alignment of ptrace I/O requests */
1053    unsigned cnt;
1054
1055    //cerr << "writeDataSpace pid=" << getPid() << ", @ " << (void *)inTraced
1056    //    << " len=" << nbytes << endl; cerr.flush();
1057
1058    ptraceOps++; ptraceBytes += nbytes;
1059    stats_ptrace.incrementCounter(PTRACE_WRITE_COUNTER);
1060    stats_ptrace.addCounter(PTRACE_WRITE_AMOUNT, nbytes);
1061    stats_ptrace.startTimer(PTRACE_WRITE_TIMER);
1062
1063    if (0 == nbytes) {
1064        stats_ptrace.stopTimer(PTRACE_WRITE_TIMER);
1065        return true;
1066    }
1067
1068    if ((cnt = ((Address)ap) % len)) {
1069       /* Start of request is not aligned. */
1070       unsigned char *p = (unsigned char*) &w;
1071
1072       /* Read the segment containing the unaligned portion, edit
1073          in the data from DP, and write the segment back. */
1074       errno = 0;
1075       w = P_ptrace(PTRACE_PEEKTEXT, pid, (Address) (ap-cnt), 0);
1076
1077       if (errno) {
1078          fprintf(stderr, "%s[%d]:  write data space failing, pid %d\n", __FILE__, __LINE__, pid);
1079        stats_ptrace.stopTimer(PTRACE_WRITE_TIMER);
1080          return false;
1081       }
1082
1083       for (unsigned i = 0; i < len-cnt && i < nbytes; i++)
1084          p[cnt+i] = dp[i];
1085
1086       if (0 > P_ptrace(PTRACE_POKETEXT, pid, (Address) (ap-cnt), w)) {
1087          fprintf(stderr, "%s[%d]:  write data space failing\n", __FILE__, __LINE__);
1088        stats_ptrace.stopTimer(PTRACE_WRITE_TIMER);
1089          return false;
1090       }
1091
1092       if (len-cnt >= nbytes) {
1093        stats_ptrace.stopTimer(PTRACE_WRITE_TIMER);
1094
1095          return true; /* done */
1096       }
1097
1098       dp += len-cnt;
1099       ap += len-cnt;
1100       nbytes -= len-cnt;
1101    }
1102
1103    /* Copy aligned portion */
1104    while (nbytes >= (u_int)len) {
1105       assert(0 == ((Address)ap) % len);
1106       memcpy(&w, dp, len);
1107       int retval =  P_ptrace(PTRACE_POKETEXT, pid, (Address) ap, w);
1108       if (retval < 0) {
1109          fprintf(stderr, "%s[%d]:  write data space failing, pid %d\n", __FILE__, __LINE__, pid);
1110          fprintf(stderr, "%s[%d][%s]:  tried to write %lx in address %p\n", FILE__, __LINE__, getThreadStr(getExecThreadID()),w, ap);
1111          perror("ptrace");
1112        stats_ptrace.stopTimer(PTRACE_WRITE_TIMER);
1113          return false;
1114       }
1115
1116       // Check...
1117       /*
1118       Address test;
1119       fprintf(stderr, "Writing %x... ", w);
1120       test = P_ptrace(PTRACE_PEEKTEXT, get_lwp_id(), (Address) ap, 0);
1121       fprintf(stderr, "... got %x, lwp %d\n", test, get_lwp_id());
1122       */
1123       dp += len;
1124       ap += len;
1125       nbytes -= len;
1126    }
1127
1128    if (nbytes > 0) {
1129       /* Some unaligned data remains */
1130       unsigned char *p = (unsigned char *) &w;
1131
1132       /* Read the segment containing the unaligned portion, edit
1133          in the data from DP, and write it back. */
1134       errno = 0;
1135       w = P_ptrace(PTRACE_PEEKTEXT, pid, (Address) ap, 0);
1136
1137       if (errno) {
1138          fprintf(stderr, "%s[%d]:  write data space failing\n", __FILE__, __LINE__);
1139        stats_ptrace.stopTimer(PTRACE_WRITE_TIMER);
1140          return false;
1141       }
1142
1143
1144       for (unsigned i = 0; i < nbytes; i++)
1145          p[i] = dp[i];
1146
1147       if (0 > P_ptrace(PTRACE_POKETEXT, pid, (Address) ap, w)) {
1148          fprintf(stderr, "%s[%d]:  write data space failing\n", __FILE__, __LINE__);
1149        stats_ptrace.stopTimer(PTRACE_WRITE_TIMER);
1150          return false;
1151       }
1152
1153    }
1154
1155        stats_ptrace.stopTimer(PTRACE_WRITE_TIMER);
1156    return true;
1157
1158 }
1159
1160 bool dyn_lwp::writeDataSpace(void *inTraced, u_int nbytes, const void *inSelf)
1161 {
1162    unsigned char *ap = (unsigned char*) inTraced;
1163    const unsigned char *dp = (const unsigned char*) inSelf;
1164
1165    //fprintf(stderr, "%s[%d]:  welcome to dyn_lwp::writeDataSpace(%d bytes)\n", __FILE__, __LINE__, nbytes);
1166    //cerr << "writeDataSpace pid=" << getPid() << ", @ " << (void *)inTraced
1167    //    << " len=" << nbytes << endl; cerr.flush();
1168
1169    ptraceOps++; ptraceBytes += nbytes;
1170
1171    if (!DBI_writeDataSpace(get_lwp_id(), (Address) ap, nbytes, (Address) dp, sizeof(Address), __FILE__, __LINE__)) {
1172      fprintf(stderr, "%s[%d]:  bulk ptrace failed\n", __FILE__, __LINE__);
1173      return false;
1174    }
1175    return true;
1176 }
1177
1178
1179 bool DebuggerInterface::bulkPtraceRead(void *inTraced, u_int nelem, void *inSelf, 
1180                                        int pid, int /*address_width*/) 
1181 {
1182    bool result;
1183          
1184    ptraceOps++; 
1185    ptraceBytes += nelem;
1186    stats_ptrace.incrementCounter(PTRACE_READ_COUNTER);
1187    stats_ptrace.addCounter(PTRACE_READ_AMOUNT, nelem);
1188    stats_ptrace.startTimer(PTRACE_READ_TIMER);
1189    
1190    result = PtraceBulkRead((Address) inTraced, nelem, inSelf, pid);
1191    if (!result)
1192       signal_printf("%s[%d]:  ptrace failed: %s\n", FILE__, __LINE__, 
1193                     strerror(errno));
1194
1195    stats_ptrace.stopTimer(PTRACE_READ_TIMER);
1196
1197    return result;
1198 }
1199
1200
1201 bool dyn_lwp::readDataSpace(const void *inTraced, u_int nbytes, void *inSelf) {
1202      const unsigned char *ap = (const unsigned char*) inTraced;
1203      unsigned char *dp = (unsigned char*) inSelf;
1204      int len = proc_->getAddressWidth(); /* address alignment of ptrace I/O requests */
1205
1206      ptraceOps++; ptraceBytes += nbytes;
1207
1208      bool ret = false;
1209      if (! (ret = DBI_readDataSpace(get_lwp_id(), (Address) ap, nbytes,
1210                                     (Address) dp, /*sizeof(Address)*/ len,
1211                                     FILE__, __LINE__))) {
1212         signal_printf("%s[%d]:  bulk ptrace read failed for lwp id %d\n",
1213                       FILE__, __LINE__, get_lwp_id());
1214         return false;
1215      }
1216      return true;
1217 }
1218
1219
1220
1221 static std::string getNextLine(int fd)
1222 {
1223    std::string line = "";
1224    while(true) {
1225       int buf = 0;
1226       char *byte = (char *)& buf;
1227       byte[0] = '\0';
1228       size_t retval = P_read(fd, (char *)&buf, 1);
1229       byte[1] = '\0';
1230       if ((retval > 0) && (byte[0] > 0))
1231          line = line + std::string(byte, 1);
1232       else
1233          break;
1234    }
1235    return line;
1236 }
1237
1238 std::string process::tryToFindExecutable(const std::string& /* progpath */, int pid)
1239 {
1240    char buffer[PATH_MAX];
1241    int fd, length;
1242    char pidstr[16];
1243    sprintf(pidstr, "%d", pid);
1244
1245    //
1246    // Simply dereferencing the symbolic link at /proc/<pid>/exe will give the
1247    // full path of the executable 99% of the time on Linux. Check there first.
1248    // The funky business with memset() and strlen() here is to deal with early
1249    // Linux kernels that returned incorrect length values from readlink().
1250    //
1251    memset(buffer, 0, sizeof(buffer));
1252    readlink((std::string("/proc/") + std::string(pidstr) + std::string("/exe")).c_str(),
1253          buffer, sizeof(buffer) - 1);
1254    length = strlen(buffer);
1255    if ((length > 0) && (buffer[length-1] == '*'))
1256       buffer[length-1] = 0;
1257    if (strlen(buffer) > 0)
1258       return buffer;
1259
1260    //
1261    // Currently the only known case where the above fails is on the back-end
1262    // nodes of a bproc (http://bproc.sourceforge.net/) system. On these systems
1263    // /proc/<pid>/exe is simply a zero-sized file and the /proc/<pid>/maps
1264    // table has an empty name for the executable's mappings. So we have to get
1265    // a little more creative.
1266    //
1267
1268    // Obtain the command name from /proc/<pid>/cmdline
1269    std::string cmdname = "";
1270    fd = P_open((std::string("/proc/") + std::string(pidstr) +
1271             std::string("/cmdline")).c_str(), O_RDONLY, 0);
1272    if (fd >= 0) {
1273       cmdname = getNextLine(fd);
1274       P_close(fd);
1275    }
1276
1277    // Obtain the path from /proc/<pid>/environ
1278    std::string path = "";
1279    fd = P_open((std::string("/proc/") + std::string(pidstr) +
1280             std::string("/environ")).c_str(), O_RDONLY, 0);
1281    if (fd >= 0) {
1282       while(true) {
1283          path = getNextLine(fd);
1284          //if (path.prefixed_by("PATH=")) {
1285          if (!strncmp(path.c_str(), "PATH=", strlen("PATH="))) {
1286             path = path.substr(5, path.length() - 5);
1287             break;
1288          }
1289          else if(path.length() == 0)
1290             break;
1291       }
1292       P_close(fd);
1293    }
1294
1295    // Obtain the current working directory from /proc/<pid>/cwd
1296    std::string cwd = "";
1297    memset(buffer, 0, sizeof(buffer));
1298    readlink((std::string("/proc/") + std::string(pidstr) +
1299             std::string("/cwd")).c_str(), buffer, sizeof(buffer) - 1);
1300    length = strlen(buffer);
1301    if (length > 0)
1302       cwd = buffer;
1303
1304    // Now try to find the executable using these three items
1305    std::string executable = "";
1306    if (executableFromArgv0AndPathAndCwd(executable, cmdname, path, cwd))
1307       return executable;
1308
1309    // Indicate an error if none of the above methods succeeded
1310    return "";
1311 }
1312
1313
1314 bool process::determineLWPs(pdvector<unsigned> &lwp_ids)
1315 {
1316    char name[128];
1317    struct dirent *direntry;
1318
1319    /**
1320     * Linux 2.6:
1321     **/
1322    sprintf(name, "/proc/%d/task", getPid());
1323    DIR *dirhandle = opendir(name);
1324    if (dirhandle)
1325    {
1326       //Only works on Linux 2.6
1327       while((direntry = readdir(dirhandle)) != NULL) {
1328          unsigned lwp_id = atoi(direntry->d_name);
1329          if (lwp_id) 
1330             lwp_ids.push_back(lwp_id);
1331       }
1332       closedir(dirhandle);
1333       return true;
1334    }
1335    /**
1336     * Linux 2.4:
1337     *
1338     * PIDs that are created by pthreads have a '.' prepending their name
1339     * in /proc.  We'll check all of those for the ones that have this lwp
1340     * as a parent pid.
1341     **/
1342    dirhandle = opendir("/proc");
1343    if (!dirhandle)
1344    {
1345       //No /proc directory.  I give up.  No threads for you.
1346       return false;
1347    } 
1348    while ((direntry = readdir(dirhandle)) != NULL)
1349    {
1350       if (direntry->d_name[0] != '.') {
1351          //fprintf(stderr, "%s[%d]: Skipping entry %s\n", FILE__, __LINE__, direntry->d_name);
1352          continue;
1353       }
1354       unsigned lwp_id = atoi(direntry->d_name+1);
1355       int lwp_ppid;
1356       if (!lwp_id) 
1357          continue;
1358       sprintf(name, "/proc/%d/status", lwp_id);
1359       FILE *fd = P_fopen(name, "r");
1360       if (!fd) {
1361          continue;
1362      }
1363      char buffer[1024];
1364      while (fgets(buffer, 1024, fd)) {
1365          if (strncmp(buffer, "Tgid", 4) == 0) {
1366              sscanf(buffer, "%*s %d", &lwp_ppid);
1367              break;
1368          }
1369      }
1370
1371      fclose(fd);
1372
1373      if (lwp_ppid != getPid()) {
1374          continue;
1375      }
1376      lwp_ids.push_back(lwp_id);
1377   }
1378   closedir(dirhandle);
1379   lwp_ids.push_back(getPid());
1380   
1381   return true;
1382 }
1383
1384
1385 bool process::dumpImage( std::string ) 
1386 {
1387    return false;
1388 }
1389
1390 //Returns true if the function is part of the PLT table
1391 bool isPLT(int_function *f)
1392 {
1393     Symtab *obj = f->mod()->obj()->parse_img()->getObject();
1394     Region *sec;
1395     if(obj->findRegion(sec, ".plt"))
1396         return sec->isOffsetInRegion(f->ifunc()->getOffset());
1397     return false;       
1398 }
1399
1400 // findCallee: finds the function called by the instruction corresponding
1401 // to the instPoint "instr". If the function call has been bound to an
1402 // address, then the callee function is returned in "target" and the 
1403 // instPoint "callee" data member is set to pt to callee's int_function.  
1404 // If the function has not yet been bound, then "target" is set to the 
1405 // int_function associated with the name of the target function (this is 
1406 // obtained by the PLT and relocation entries in the image), and the instPoint
1407 // callee is not set.  If the callee function cannot be found, (ex. function
1408 // pointers, or other indirect calls), it returns false.
1409 // Returns false on error (ex. process doesn't contain this instPoint).
1410
1411 int_function *instPoint::findCallee() 
1412 {
1413
1414    // Already been bound
1415    if (callee_) {
1416       return callee_;
1417    }  
1418
1419    if (ipType_ != callSite) {
1420       // Assert?
1421       return NULL; 
1422    }
1423    if (isDynamic()) {
1424       return NULL;
1425    }
1426
1427    assert(img_p_);
1428    image_func *icallee = img_p_->getCallee(); 
1429    if (icallee && !icallee->isPLTFunction()) {
1430      callee_ = proc()->findFuncByInternalFunc(icallee);
1431      //callee_ may be NULL if the function is unloaded
1432
1433        //fprintf(stderr, "%s[%d]:  returning %p\n", FILE__, __LINE__, callee_);
1434      return callee_;
1435    }
1436
1437    // Do this the hard way - an inter-module jump
1438    // get the target address of this function
1439    Address target_addr = img_p_->callTarget();
1440    if(!target_addr) {
1441       // this is either not a call instruction or an indirect call instr
1442       // that we can't get the target address
1443        //fprintf(stderr, "%s[%d]:  returning NULL\n", FILE__, __LINE__);
1444       return NULL;
1445    }
1446
1447    // get the relocation information for this image
1448    Symtab *obj = func()->obj()->parse_img()->getObject();
1449    pdvector<relocationEntry> fbt;
1450    vector <relocationEntry> fbtvector;
1451    if (!obj->getFuncBindingTable(fbtvector)) {
1452
1453        //fprintf(stderr, "%s[%d]:  returning NULL\n", FILE__, __LINE__);
1454         return NULL;
1455         }
1456
1457    if (!fbtvector.size())
1458       fprintf(stderr, "%s[%d]:  WARN:  zero func bindings\n", FILE__, __LINE__);
1459
1460    for (unsigned index=0; index< fbtvector.size();index++)
1461         fbt.push_back(fbtvector[index]);
1462   
1463    Address base_addr = func()->obj()->codeBase();
1464
1465    // find the target address in the list of relocationEntries
1466    for (u_int i=0; i < fbt.size(); i++) {
1467       if (fbt[i].target_addr() == target_addr) 
1468       {
1469          // check to see if this function has been bound yet...if the
1470          // PLT entry for this function has been modified by the runtime
1471          // linker
1472          int_function *target_pdf = 0;
1473          if (proc()->hasBeenBound(fbt[i], target_pdf, base_addr)) {
1474             callee_ = target_pdf;
1475             img_p_->setCalleeName(target_pdf->symTabName());
1476             //fprintf(stderr, "%s[%d]:  returning %p\n", FILE__, __LINE__, callee_);
1477             return callee_;  // target has been bound
1478          } 
1479
1480          const char *target_name = fbt[i].name().c_str();
1481          process *dproc = dynamic_cast<process *>(proc());
1482          BinaryEdit *bedit = dynamic_cast<BinaryEdit *>(proc());
1483          img_p_->setCalleeName(std::string(target_name));
1484          pdvector<int_function *> pdfv;
1485          if (dproc) {
1486             bool found = proc()->findFuncsByMangled(target_name, pdfv);
1487             if (found) {
1488                return pdfv[0];
1489             }
1490          }
1491          else if (bedit) {
1492             std::vector<BinaryEdit *>::iterator i;
1493             for (i = bedit->getSiblings().begin(); i != bedit->getSiblings().end(); i++)
1494             {
1495                bool found = (*i)->findFuncsByMangled(target_name, pdfv);
1496                if (found) {
1497                   return pdfv[0];
1498                }
1499             }
1500          }
1501          else 
1502             assert(0);
1503          break;
1504       }
1505    }
1506        //fprintf(stderr, "%s[%d]:  returning NULL: target addr = %p\n", FILE__, __LINE__, (void *)target_addr);
1507    return NULL;
1508 }
1509
1510 bool SignalGeneratorCommon::getExecFileDescriptor(std::string filename,
1511                                                   int /*pid*/,
1512                                                   bool /*whocares*/,
1513                                                   int &,
1514                                                   fileDescriptor &desc)
1515 {
1516     desc = fileDescriptor(filename.c_str(), 
1517                           0, // code
1518                           0, // data
1519                           false); // a.out
1520     return true;
1521 }
1522
1523 static const Address lowest_addr = 0x0;
1524 void process::inferiorMallocConstraints(Address near, Address &lo, Address &hi,
1525                                inferiorHeapType /* type */ )
1526 {
1527   if (near)
1528     {
1529 #if !defined(arch_x86_64) && !defined(arch_power)
1530       lo = region_lo(near);
1531       hi = region_hi(near);  
1532 #else
1533       if (getAddressWidth() == 8) {
1534           lo = region_lo_64(near);
1535           hi = region_hi_64(near);
1536       }
1537       else {
1538           lo = region_lo(near);
1539           hi = region_hi(near);  
1540       }
1541 #endif
1542     }
1543 }
1544
1545 bool dyn_lwp::realLWP_attach_() {
1546    char procName[128];
1547    sprintf(procName, "/proc/%d/mem", get_lwp_id());
1548    fd_ = P_open(procName, O_RDWR, 0);
1549
1550    if (fd_ < 0)
1551      fd_ = INVALID_HANDLE_VALUE;
1552
1553    if (!proc()->sh->registerLWP(get_lwp_id())) {
1554       fprintf(stderr, "%s[%d]:  failed to register lwp %d here\n", FILE__, __LINE__, get_lwp_id());
1555    }
1556
1557    isDoingAttach_ = true;
1558
1559    startup_printf("%s[%d]:  realLWP_attach doing PTRACE_ATTACH to %lu\n", 
1560                   FILE__, __LINE__, get_lwp_id());
1561    int ptrace_errno = 0;
1562    if( 0 != DBI_ptrace(PTRACE_ATTACH, get_lwp_id(), 0, 0, &ptrace_errno, 
1563                        proc_->getAddressWidth(),  __FILE__, __LINE__) )
1564    {
1565       //Any thread could have exited before we attached to it.
1566       isDoingAttach_ = false;
1567       return false;
1568    }
1569    
1570    proc()->sh->add_lwp_to_poll_list(this);
1571
1572    eventType evt;
1573
1574    pdvector<eventType> evts;   
1575    evts.push_back(evtLwpAttach);
1576    evts.push_back(evtThreadExit);
1577    
1578    proc()->sh->signalActiveProcess();
1579    do {
1580
1581      evt = proc()->sh->waitForOneOf(evts, this);
1582      //evt = proc()->sh->waitForEvent(evtLwpAttach, proc_, this);
1583      if (evt == evtProcessExit) {
1584        isDoingAttach_ = false;
1585        return false;
1586      }
1587      if (evt == evtThreadExit && status_ == exited) {
1588        isDoingAttach_ = false;
1589        proc()->sh->remove_lwp_from_poll_list(get_lwp_id());       
1590        return false;
1591      }
1592    } while (!is_attached());
1593    
1594    isDoingAttach_ = false;
1595
1596    // Make sure nobody has mucked with our process state.
1597    status_ = stopped;
1598
1599    if (proc_->sh->syncRunWhenFinished_ == runRequest) {
1600        continueLWP();
1601    }
1602
1603    return true;
1604 }
1605
1606 static bool is_control_stopped(int lwp)
1607 {
1608  FILE *f = NULL;
1609  char line[128];
1610  char filename[32];
1611  bool result = false;
1612  char *sresult = NULL;
1613  
1614  snprintf(filename, 32, "/proc/%d/status", lwp);
1615  filename[31] = '\0';
1616  
1617  f = fopen(filename, "r");
1618  if (!f)
1619  {
1620     if (dyn_debug_startup) {
1621        startup_printf("Error opening %s", filename);
1622        perror("ERROR: Couldn't open file");
1623     }
1624     goto done;
1625  }
1626
1627  while (!feof(f)) {
1628     sresult = fgets(line, 128, f);
1629     if (!sresult) {
1630        if (dyn_debug_startup) {
1631           startup_printf("Error reading from %s", filename);
1632           perror("ERROR: Couldn't read from file");
1633        }
1634        goto done;
1635     }
1636     if (strncmp(line, "State:", 6) == 0) {
1637        if (strstr(line, "T (stopped)"))
1638           result = true;
1639        goto done;
1640     }
1641  }
1642
1643
1644  done:
1645  if (f)
1646     fclose(f);
1647  return result;
1648 }
1649
1650 bool dyn_lwp::representativeLWP_attach_() 
1651 {
1652    bool running = false;
1653    int result;
1654
1655    if( proc_->wasCreatedViaAttach() )
1656       running = proc_->isRunning_();
1657    
1658    startup_printf("%s[%d]: in representative lwp attach, isRunning %d\n",
1659                   FILE__, __LINE__, running);
1660
1661
1662    // QUESTION: does this attach operation lead to a SIGTRAP being forwarded
1663    // to paradynd in all cases?  How about when we are attaching to an
1664    // already-running process?  (Seems that in the latter case, no SIGTRAP
1665    // is automatically generated)
1666    
1667    // Only if we are really attaching rather than spawning the inferior
1668    // process ourselves do we need to call PTRACE_ATTACH
1669    if(proc_->wasCreatedViaAttach() || 
1670       proc_->wasCreatedViaFork() || 
1671       proc_->wasCreatedViaAttachToCreated())
1672    {
1673       int ptrace_errno = 0;
1674       int address_width = sizeof(Address);
1675       assert(address_width);
1676       startup_printf("%s[%d]: process attach doing PT_ATTACH to %d\n",
1677                      FILE__, __LINE__, get_lwp_id());
1678       if( 0 != DBI_ptrace(PTRACE_ATTACH, getPid(), 0, 0, &ptrace_errno, 
1679                           address_width, __FILE__, __LINE__) )
1680       {
1681          startup_printf("%s[%d]:  ptrace attach to pid %d failing: %s\n", 
1682                         FILE__, __LINE__, getPid(), strerror(ptrace_errno));
1683          return false;
1684       }
1685       startup_printf("%s[%d]: attached via DBI\n", FILE__, __LINE__);
1686       proc_->sh->add_lwp_to_poll_list(this);
1687
1688       /**
1689        * The following code is trying to deal with a bug on recent utrace 
1690        * kernels (first appeared in Fedora Core 8, 9, and RHEL 5.2).  When 
1691        * attaching to a process that is already control stopped, wait() will
1692        * stop blocking and keep returning notice that 'signal 0' has been 
1693        * delivered. 
1694        *
1695        * As per RedHat's suggestion, we're detecting when a process is control 
1696        * stopped, then moving it into a tracing stop state by sending it a SIGSTOP
1697        * and then moving it out of the control stop state with a PTRACE_CONT.
1698        *
1699        * The PTRACE_CONT will destroy the normal SIGSTOP you recieve after attaching
1700        * to a process, but we've just put another SIGSTOP into the signal queue to 
1701        * replace it.  
1702        **/
1703       if (is_control_stopped(get_lwp_id()))
1704       {
1705          startup_printf("[%s:%u] - Attached to already STOP'd process, %d.  Handling.\n",
1706                         FILE__, __LINE__, get_lwp_id());
1707          
1708          result = lwp_kill(get_lwp_id(), SIGSTOP);
1709          if (result == -1) {
1710             startup_printf("[%s:%u] - ERROR.  Could not lwp_kill %d: %s\n", 
1711                            FILE__, __LINE__, get_lwp_id(), strerror(errno));
1712          }
1713          else {
1714             result = DBI_ptrace(PTRACE_CONT, get_lwp_id(), 0, 0, &ptrace_errno,
1715                                 address_width, FILE__, __LINE__);
1716             if (result == -1) {
1717                startup_printf("[%s:%u] - ERROR. Could not PTRACE_CONT: %s\n", 
1718                               FILE__, __LINE__, strerror(ptrace_errno));
1719             }
1720          }
1721       }
1722
1723       int status = 0;
1724       int retval = 0;
1725       int dead_lwp = 0;
1726       retval = proc_->sh->waitpid_kludge(getPid(), &status, 0, &dead_lwp);
1727       if (retval < 0) {
1728           fprintf(stderr, "%s[%d]:  waitpid failed\n", FILE__, __LINE__);
1729           perror("process::attach - waitpid");
1730           exit(1);
1731       }
1732       startup_printf("%s[%d]: waitpid return from %d of %d/%d\n",
1733                      FILE__, __LINE__, retval, WIFSTOPPED(status), WSTOPSIG(status));
1734       proc_->set_status(stopped);
1735    }
1736
1737    return true;
1738 }
1739
1740 void loadNativeDemangler() {}
1741
1742 const unsigned int N_DYNINST_LOAD_HIJACK_FUNCTIONS = 4;
1743 const char DYNINST_LOAD_HIJACK_FUNCTIONS[][20] = {
1744   "__libc_start_main",
1745   "_init",
1746   "_start",
1747   "main"
1748 };
1749
1750 /**
1751  * Returns an address that we can use to write the code that executes
1752  * dlopen on the runtime library.
1753  *
1754  * Inserting the code into libc is a good thing, since _dl_open
1755  * will sometimes check it's caller and return with a 'invalid caller'
1756  * error if it's called from the application.
1757  **/
1758 Address findFunctionToHijack(process *p) 
1759 {
1760    Address codeBase = 0;
1761    unsigned i;
1762    for(i = 0; i < N_DYNINST_LOAD_HIJACK_FUNCTIONS; i++ ) {
1763       const char *func_name = DYNINST_LOAD_HIJACK_FUNCTIONS[i];
1764
1765       pdvector<int_function *> hijacks;
1766       if (!p->findFuncsByAll(func_name, hijacks))
1767           return 0;
1768       codeBase = hijacks[0]->getAddress();
1769
1770       if (codeBase)
1771           break;
1772    }
1773    
1774   return codeBase;
1775 } /* end findFunctionToHijack() */
1776
1777 /**
1778  * Searches for function in order, with preference given first 
1779  * to libpthread, then to libc, then to the process.
1780  **/
1781 static void findThreadFuncs(process *p, std::string func, 
1782                             pdvector<int_function *> &result)
1783 {
1784    bool found = false;
1785    mapped_module *lpthread = p->findModule("libpthread*", true);
1786    if (lpthread)
1787       found = lpthread->findFuncVectorByPretty(func, result);
1788    if (found)
1789       return;
1790
1791    mapped_module *lc = p->findModule("libc.so*", true);
1792    if (lc)
1793       found = lc->findFuncVectorByPretty(func, result);
1794    if (found)
1795       return;
1796    
1797    p->findFuncsByPretty(func, result);
1798 }
1799
1800 bool process::initMT()
1801 {
1802    unsigned i;
1803    bool res;
1804
1805 #if !defined(cap_threads)
1806    return true;
1807 #endif
1808
1809    /**
1810     * Instrument thread_create with calls to DYNINST_dummy_create
1811     **/
1812    //Find create_thread
1813    pdvector<int_function *> thread_init_funcs;
1814    findThreadFuncs(this, "create_thread", thread_init_funcs);
1815    findThreadFuncs(this, "start_thread", thread_init_funcs);
1816    if (thread_init_funcs.size() < 1)
1817    {
1818       fprintf(stderr, "[%s:%d] - Found no copies of create_thread, expected 1\n",
1819               __FILE__, __LINE__);
1820       return false;
1821    }
1822    //Find DYNINST_dummy_create
1823    int_function *dummy_create = findOnlyOneFunction("DYNINST_dummy_create");
1824    if (!dummy_create)
1825    {
1826      fprintf(stderr, "[%s:%d] - Couldn't find DYNINST_dummy_create",
1827              __FILE__, __LINE__);
1828       return false;
1829    }
1830    //Instrument
1831    for (i=0; i<thread_init_funcs.size(); i++)
1832    {
1833       pdvector<AstNodePtr> args;
1834       AstNodePtr ast = AstNode::funcCallNode(dummy_create, args);
1835       const pdvector<instPoint *> &ips = thread_init_funcs[i]->funcEntries();
1836       for (unsigned j=0; j<ips.size(); j++)
1837       {
1838          miniTramp *mt;
1839          mt = ips[j]->instrument(ast, callPreInsn, orderFirstAtPoint, false, 
1840                                  false);
1841          if (!mt)
1842          {
1843             fprintf(stderr, "[%s:%d] - Couldn't instrument thread_create\n",
1844                     __FILE__, __LINE__);
1845          }
1846          //TODO: Save the mt objects for detach
1847       }
1848    }
1849       
1850    //Find functions that are run on pthread exit
1851    pdvector<int_function *> thread_dest_funcs;
1852    findThreadFuncs(this, "__pthread_do_exit", thread_dest_funcs);
1853    findThreadFuncs(this, "pthread_exit", thread_dest_funcs);
1854    findThreadFuncs(this, "deallocate_tsd", thread_dest_funcs);
1855    if (!thread_dest_funcs.size())
1856    {
1857       fprintf(stderr,"[%s:%d] - Found 0 copies of pthread_exit, expected 1\n",
1858               __FILE__, __LINE__);
1859       return false;
1860    }
1861    //Find DYNINSTthreadDestroy
1862    int_function *threadDestroy = findOnlyOneFunction("DYNINSTthreadDestroy");
1863    if (!threadDestroy)
1864    {
1865       fprintf(stderr, "[%s:%d] - Couldn't find DYNINSTthreadDestroy",
1866               __FILE__, __LINE__);
1867       return false;
1868    }
1869
1870    for (i=0; i<thread_dest_funcs.size(); i++)
1871    {
1872       pdvector<AstNodePtr> args;
1873       AstNodePtr ast = AstNode::funcCallNode(threadDestroy, args);
1874       const pdvector<instPoint *> &ips = thread_dest_funcs[i]->funcExits();
1875       for (unsigned j=0; j<ips.size(); j++)
1876       {
1877          miniTramp *mt;
1878          mt = ips[j]->instrument(ast, callPreInsn, orderFirstAtPoint, false, 
1879                                  false);
1880          if (!mt)
1881          {
1882             fprintf(stderr, "[%s:%d] - Couldn't instrument thread_exit\n",
1883                     __FILE__, __LINE__);
1884          }
1885          //TODO: Save the mt objects for detach
1886       }
1887    }
1888
1889 #if 0
1890    //Instrument
1891    for (i=0; i<thread_dest_funcs.size(); i++)
1892    {
1893       pdvector<AstNodePtr > args;
1894       AstNode call_thread_destroy(threadDestroy, args);
1895       AstNodePtr ast = &call_thread_destroy;
1896       miniTrampHandle *mthandle;
1897       instPoint *ip = thread_dest_funcs[i]->funcEntry(this);
1898
1899       result = addInstFunc(this, mthandle, ip, ast, callPostInsn, 
1900                            orderFirstAtPoint, true, true, true);
1901       if (result != success_res)
1902       {
1903          fprintf(stderr, "[%s:%d] - Couldn't instrument thread_destroy\n",
1904                  __FILE__, __LINE__);
1905       }
1906    }
1907 #endif
1908      
1909    /**
1910     * Have dyn_pthread_self call the actual pthread_self
1911     **/
1912    //Find dyn_pthread_self
1913    pdvector<int_variable *> ptself_syms;
1914    res = findVarsByAll("DYNINST_pthread_self", ptself_syms);
1915    if (!res)
1916    {
1917       fprintf(stderr, "[%s:%d] - Couldn't find any dyn_pthread_self, expected 1\n",
1918               __FILE__, __LINE__);
1919    }
1920    assert(ptself_syms.size() == 1);
1921    Address dyn_pthread_self = ptself_syms[0]->getAddress();
1922    //Find pthread_self
1923    pdvector<int_function *> pthread_self_funcs;
1924    findThreadFuncs(this, "pthread_self", pthread_self_funcs);   
1925    if (pthread_self_funcs.size() != 1)
1926    {
1927       fprintf(stderr, "[%s:%d] - Found %ld pthread_self functions, expected 1\n",
1928               __FILE__, __LINE__, (long) pthread_self_funcs.size());
1929       for (unsigned j=0; j<pthread_self_funcs.size(); j++)
1930       {
1931          int_function *ps = pthread_self_funcs[j];
1932          fprintf(stderr, "[%s:%u] - %s in module %s at %lx\n", __FILE__, __LINE__,
1933                  ps->prettyName().c_str(), ps->mod()->fullName().c_str(), 
1934                  ps->getAddress());
1935       }
1936       return false;
1937    }   
1938    //Replace
1939    res = writeFunctionPtr(this, dyn_pthread_self, pthread_self_funcs[0]);
1940    if (!res)
1941    {
1942       fprintf(stderr, "[%s:%d] - Couldn't update dyn_pthread_self\n",
1943               __FILE__, __LINE__);
1944       return false;
1945    }
1946
1947    return true;
1948 }
1949
1950 void dyninst_yield()
1951 {
1952    pthread_yield();
1953 }
1954
1955 Address dyn_lwp::step_next_insn() {
1956    int result;
1957    if (status() != stopped) {
1958       fprintf(stderr, "[%s:%u] - Internal Error.  lwp wasn't stopped\n",
1959               __FILE__, __LINE__);
1960       return (Address) -1;
1961    }
1962    
1963    singleStepping = true;
1964    proc()->set_lwp_status(this, running);
1965    result = DBI_ptrace(PTRACE_SINGLESTEP, get_lwp_id(), 0x0, 0x0);
1966    if (result == -1) {
1967       perror("Couldn't PTRACE_SINGLESTEP");
1968       return (Address) -1;
1969    }
1970
1971    proc()->getSG()->signalActiveProcess();
1972    while (singleStepping) {
1973       if(proc()->hasExited()) 
1974          return (Address) -1;
1975       proc()->sh->waitForEvent(evtDebugStep);
1976    }
1977
1978    return getActiveFrame().getPC();
1979 }
1980
1981 // ****** Support linux-specific forkNewProcess DBI callbacks ***** //
1982
1983 bool ForkNewProcessCallback::operator()(std::string file, 
1984                     std::string dir, pdvector<std::string> *argv,
1985                     pdvector<std::string> *envp,
1986                     std::string inputFile, std::string outputFile, int &traceLink,
1987                     pid_t &pid, int stdin_fd, int stdout_fd, int stderr_fd,
1988                     SignalGenerator *sg)
1989 {
1990   lock->_Lock(FILE__, __LINE__);
1991    
1992   file_ = &file;
1993   dir_ = &dir;
1994   argv_ = argv;
1995   envp_ = envp;
1996   inputFile_ = &inputFile;
1997   outputFile_ = &outputFile;
1998   traceLink_ = &traceLink;
1999   pid_ = &pid;
2000   sg_ = sg;
2001   stdin_fd_ = stdin_fd;
2002   stdout_fd_ = stdout_fd;
2003   stderr_fd_ = stderr_fd;
2004   bool result = true;
2005   
2006   startup_printf("%s[%d]:  ForkNewProcessCallback, target thread is %lu(%s)\n", 
2007                   __FILE__, __LINE__, targetThread(), 
2008                  getThreadStr(targetThread()));
2009   getMailbox()->executeOrRegisterCallback(this);
2010
2011   if (synchronous) 
2012   {
2013      dbi_printf("%s[%d]:  waiting for completion of callback\n", FILE__, __LINE__);
2014      waitForCompletion();
2015   }
2016
2017   lock->_Unlock(FILE__, __LINE__);
2018   return result;
2019 }
2020
2021 bool ForkNewProcessCallback::execute_real()
2022 {
2023     // call the actual forking routine in unix.C
2024     ret = forkNewProcess_real(*file_,*dir_,argv_,envp_,*inputFile_,
2025             *outputFile_,*traceLink_,*pid_,stdin_fd_,stdout_fd_,
2026             stderr_fd_); 
2027     if (ret)
2028        ret = sg_->attachToChild(*pid_);
2029     return ret;
2030 }
2031
2032 bool DebuggerInterface::forkNewProcess(std::string file, 
2033                     std::string dir, pdvector<std::string> *argv,
2034                     pdvector<std::string> *envp,
2035                     std::string inputFile, std::string outputFile, int &traceLink,
2036                     pid_t &pid, int stdin_fd, int stdout_fd, int stderr_fd,
2037                     SignalGenerator *sg)
2038 {
2039     dbi_printf("%s[%d][%s]:  welcome to DebuggerInterface::forkNewProcess()\n",
2040           FILE__, __LINE__, getThreadStr(getExecThreadID()));
2041     getBusy();
2042
2043     bool ret;
2044     ForkNewProcessCallback *fnpp = new ForkNewProcessCallback(&dbilock);
2045     ForkNewProcessCallback &fnp = *fnpp;
2046
2047     fnp.enableDelete(false);
2048     fnp(file, dir, argv, envp, inputFile, outputFile, traceLink, pid,
2049         stdin_fd, stdout_fd, stderr_fd, sg);
2050
2051     ret = fnp.getReturnValue();
2052     fnp.enableDelete();
2053     releaseBusy();
2054
2055     return ret;  
2056 }
2057
2058 bool SignalHandler::handleProcessExitPlat(EventRecord & /*ev*/, 
2059                                           bool & /*continueHint */) 
2060 {
2061    sg->waitpid_mux.unregisterProcess(sg);
2062    return true;
2063 }
2064
2065 static int P_gettid()
2066 {
2067    static int gettid_not_valid = 0;
2068    int result;
2069
2070    if (gettid_not_valid)
2071       return getpid();
2072
2073    result = syscall((long int) SYS_gettid);
2074    if (result == -1 && errno == ENOSYS)
2075    {
2076       gettid_not_valid = 1;
2077       return getpid();
2078    }
2079    return result;  
2080 }
2081
2082 void chld_handler(int) {
2083 }
2084
2085 void chld_handler2(int, siginfo_t *, void *) {
2086 }
2087
2088 static void kickWaitpider(int pid) {
2089    struct sigaction handler;
2090
2091    //   handler.sa_handler = chld_handler;
2092    sigfillset(& handler.sa_mask);
2093    handler.sa_sigaction = chld_handler2;
2094    handler.sa_flags = 0; 
2095    sigaction(SIGCHLD, &handler, NULL);
2096
2097    proccontrol_printf("[%s:%u] - kicking %d for wakeup\n",
2098                       FILE__, __LINE__, pid);
2099    lwp_kill(pid, SIGCHLD);
2100 }
2101
2102 //Force the SignalGenerator to return -1, EINTR from waitpid
2103 bool WaitpidMux::registerProcess(SignalGenerator *me) 
2104 {
2105
2106   pthread_mutex_lock(&waiter_mutex);
2107   
2108   for (unsigned i=0; i<unassigned_events.size(); i++)
2109      if (unassigned_events[i].pid == me->getPid()) {
2110         proccontrol_printf("[%s:%u] - Found early event for %d, restoring\n",
2111                            FILE__, __LINE__, me->getPid());
2112         me->event_queue.push_back(unassigned_events[i]);
2113         VECTOR_ERASE(unassigned_events,i, i);
2114         i--;
2115      }
2116   addPidGen(me->getPid(), me);
2117
2118   pthread_mutex_unlock(&waiter_mutex);
2119
2120   return true;
2121 }
2122
2123 bool WaitpidMux::registerLWP(unsigned lwpid, SignalGenerator *me) 
2124 {
2125    pthread_mutex_lock(&waiter_mutex);
2126
2127    for (unsigned i=0; i<unassigned_events.size(); i++)
2128       if (unassigned_events[i].pid == me->getPid()) {
2129          proccontrol_printf("[%s:%u] - Found early event for %d, restoring\n",
2130                             FILE__, __LINE__, me->getPid());
2131          me->event_queue.push_back(unassigned_events[i]);
2132          VECTOR_ERASE(unassigned_events,i, i);
2133          i--;
2134       }
2135    
2136    addPidGen(lwpid, me);
2137    
2138    pthread_mutex_unlock(&waiter_mutex);
2139    return true;
2140 }
2141
2142 bool WaitpidMux::unregisterLWP(unsigned lwpid, SignalGenerator *me) 
2143 {
2144   pthread_mutex_lock(&waiter_mutex);
2145   removePidGen(lwpid, me);
2146   pthread_mutex_unlock(&waiter_mutex);
2147   return true;
2148 }
2149
2150 bool WaitpidMux::unregisterProcess(SignalGenerator *me) 
2151 {
2152   pthread_mutex_lock(&waiter_mutex);
2153   removePidGen(me);
2154
2155   if (waitpid_thread_id == me->getThreadID()) {
2156     forceWaitpidReturn();
2157   }
2158
2159   pthread_mutex_unlock(&waiter_mutex);
2160   return true;
2161 }
2162
2163 void WaitpidMux::forceWaitpidReturn() 
2164 {
2165   pthread_mutex_lock(&waiter_mutex);
2166   if (isInWaitpid) {
2167      kickWaitpider(waiter_exists);
2168   }
2169   else if (isInWaitLock) {
2170      forcedExit = true;
2171      pthread_cond_broadcast(&waiter_condvar);
2172   }
2173   pthread_mutex_unlock(&waiter_mutex);
2174 }
2175
2176 bool WaitpidMux::suppressWaitpidActivity()
2177 {     
2178    pthread_mutex_lock(&waiter_mutex);
2179    pause_flag = true;
2180    if (waiter_exists) {
2181       kickWaitpider(waiter_exists);
2182    }
2183    pthread_mutex_unlock(&waiter_mutex);
2184    return true;           
2185 }
2186
2187 bool WaitpidMux::resumeWaitpidActivity()
2188 {  
2189    pthread_mutex_lock(&waiter_mutex);
2190    pause_flag = false;
2191    pthread_cond_broadcast(&waiter_condvar);
2192    pthread_mutex_unlock(&waiter_mutex);
2193    return true;
2194 }        
2195
2196 int WaitpidMux::waitpid(SignalGenerator *me, int *status)
2197 {   
2198    int result;
2199    int options = __WALL;
2200    SignalGenerator *event_owner;
2201
2202    pthread_mutex_lock(&waiter_mutex);
2203    
2204    proccontrol_printf("[%s:%u] waitpid_demultiplex called for %d\n", 
2205                       FILE__, __LINE__, me->getPid());
2206    for (;;) {
2207       //  Find the queue for this signalgenerator
2208       if (me->event_queue.size()) {
2209          //Someone put an event into our queue (thank you), we'll
2210          //go ahead and dequeue and return it.
2211          waitpid_ret_pair ret = me->event_queue[0];
2212          VECTOR_ERASE(me->event_queue,0, 0);
2213          *status = ret.status;
2214          proccontrol_printf("[%s:%u] %d found an event %d in my queue\n",
2215                             FILE__, __LINE__, me->getPid(), *status);
2216          pthread_mutex_unlock(&waiter_mutex);
2217          return ret.pid;
2218       }
2219
2220       if (forcedExit) {
2221          //Someone wants to force us out of waitpid.  Go along with it.
2222          // In most cases, we'll just return to the waitpid_kludge function
2223          // and then re-enter this one.
2224          proccontrol_printf("[%s:%u] %d forced out of waitpid\n",
2225                             FILE__, __LINE__, me->getPid());
2226          forcedExit = false;
2227          pthread_mutex_unlock(&waiter_mutex);         
2228          return 0;
2229       }
2230
2231       if (!waiter_exists) {
2232          // There's no events for us and no one is doing the waitpid.
2233          // Let's break out of this foolish loop and do
2234          // a waitpid.  We've still got the mutex, so we'll be the
2235          // only ones who can get out and set waiter_exists to true.
2236          proccontrol_printf("[%s:%u] %d becoming new waitpider\n",
2237                             FILE__, __LINE__, me->getPid());
2238          break;
2239       }
2240
2241       if (hasFirstTimer(me)) {
2242          //Darn Linux annoyances.  If a thread is blocked in waitpid, and
2243          // someone else PTRACE_ATTACH's to a new thread, then we won't get
2244          // any events until waitpid is re-entered.  We'll send a SIGILL
2245          // to a mutatee to force waitPid to return, then drop the signal.
2246          kickWaitpider(waiter_exists);
2247       }
2248       // Someone else is currently doing a waitpid for us.  Block until
2249       // they either put an event into our event queue, or we find that they've
2250       // left and we need to become the new waitpider.
2251       isInWaitLock = true;
2252       pthread_cond_wait(&waiter_condvar, &waiter_mutex);
2253       isInWaitLock = false;
2254    }
2255
2256    assert(!waiter_exists);
2257    waiter_exists = P_gettid();
2258    for (;;) {
2259       if (me->stopRequested()) {
2260          fprintf(stderr, "%s[%d]:  got request to stop doing waitpid()\n", FILE__, __LINE__);
2261          return -1;
2262       }
2263       //If we're in this loop, then we are the process doing a waitpid.
2264       // It's up to us to recieve events for all SignalGenerators, and put 
2265       // them on the event queue until we get one that belongs to us.
2266       // Once we get an event that belongs to us, we'll set a waiter_exists
2267       // to false (which will let someone else become the new waitpid'er)
2268       // and return the waitpid result.
2269
2270       //A first-timer is someone who was created while we were are 
2271       // waitpid.  Since no one is in waitpid right now (we're 
2272       // about to enter) there are no first-timers.
2273       first_timers.clear();
2274
2275       isInWaitpid = true;
2276       waitpid_thread_id = me->getThreadID();
2277
2278       // Now everyone thinks we're doing waitpid, that's good because it means they
2279       // won't try...  but before we really do waitpid(), need to make sure that 
2280       // some other part of the system doesn't want us to:
2281       while (pause_flag) {
2282          pthread_cond_wait(&waiter_condvar, &waiter_mutex);        
2283       }
2284
2285       pthread_mutex_unlock(&waiter_mutex);
2286       result = ::waitpid(-1, status, options);
2287       pthread_mutex_lock(&waiter_mutex);
2288
2289       isInWaitpid = false;
2290       waitpid_thread_id = 0;
2291
2292       proccontrol_printf("[%s:%u] waitpid by %d returned status %d for %d\n",
2293                          FILE__, __LINE__, me->getPid(), *status, result);
2294
2295       //We got an event.  Map that back to the signal generator that it
2296       // belongs to.
2297       event_owner = NULL;
2298       for (unsigned i=0; i<pidgens.size(); i++) {
2299          if (pidgens[i].pid == result) {
2300             event_owner = pidgens[i].sg;
2301             break;
2302          }
2303       }
2304
2305       if (WIFSTOPPED(status) && WSTOPSIG(status) == 0 && !event_owner) {
2306         /**
2307          * Kernel bug.  See the comment in dyn_lwp::representativeLWP_attach_()
2308          * The code that handles this in attach will notice that the process
2309          * is in a SIGSTOP'd state and try to clear that state, but we may
2310          * be attached for a brief amount of time before we manage to clear
2311          * that state.  In the meantime, we may recieve 'signal 0' notices.
2312          * These aren't real signals, so we'll just drop them on the ground.
2313          **/
2314          startup_printf("[%s:%u] - Got a signal 0 from waitpid on %d\n",
2315                         FILE__, __LINE__, result);
2316          continue;
2317       }
2318
2319
2320       if (me == event_owner || result == -1) {
2321          //We got an event for ourselves, Yea!  Let's go ahead and return it.
2322          //We broadcast here to let other people know that someone else needs
2323          //to take over as a the guy on the waitpid.
2324          proccontrol_printf("[%s:%u] Got event for ourself (%d), result = %d\n",
2325                             FILE__, __LINE__, me->getPid(), result);
2326          waiter_exists = 0;
2327          pthread_cond_broadcast(&waiter_condvar);
2328          pthread_mutex_unlock(&waiter_mutex);
2329          return result;
2330       }
2331
2332       waitpid_ret_pair ev;
2333       ev.status = *status;
2334       ev.pid = result;
2335       
2336       if (event_owner) {
2337          //This event belongs to someone else.  Let's put it into
2338          // their queue so that they can get it next time they call
2339          // this function.
2340          int res = enqueueWaitpidValue(ev, event_owner);
2341          if (res == -1) {
2342             pthread_cond_broadcast(&waiter_condvar);
2343             pthread_mutex_unlock(&waiter_mutex);
2344             return -1;
2345          }
2346          pthread_cond_broadcast(&waiter_condvar);
2347       }
2348       else {
2349          //Race condition happened here.  We can start getting events
2350          // for a process the moment we fork it off, and before we
2351          // ever know it's PID.  In this case we'll just cache the event
2352          // and add it to the event's queue when it calls addPidGen.
2353          proccontrol_printf("[%s:%u] - Caching event for %d\n",
2354                             FILE__, __LINE__, result);
2355          unassigned_events.push_back(ev);
2356       }
2357    }
2358    assert(0);
2359    return -1;
2360 }
2361
2362 bool WaitpidMux::hasFirstTimer(SignalGenerator *me) 
2363 {
2364    for (unsigned i=0; i<first_timers.size(); i++) 
2365       if (first_timers[i] == me)
2366          return true;
2367    return false;
2368 }
2369
2370 void WaitpidMux::addPidGen(int pid, SignalGenerator *sg) 
2371 {
2372    proccontrol_printf("[%s:%u] Adding pidgen %d for sg %d\n",
2373                       FILE__, __LINE__, pid, sg->getPid());
2374
2375    first_timers.push_back(sg);
2376    for (unsigned i=0; i<pidgens.size(); i++) 
2377       assert (pidgens[i].pid != pid);
2378    
2379
2380    pid_generator_pair_t new_pidgen;
2381    new_pidgen.pid = pid;
2382    new_pidgen.sg = sg;
2383    pidgens.push_back(new_pidgen);
2384 }
2385
2386 void WaitpidMux::removePidGen(int pid, SignalGenerator *sg) 
2387 {
2388    bool found = false;
2389
2390    proccontrol_printf("[%s:%u] Removing pidgen %d for sg %d\n",
2391                       FILE__, __LINE__, pid, sg->getPid());
2392
2393    for (unsigned i=0; i<pidgens.size(); i++) {
2394       if (pidgens[i].pid == pid) {
2395          assert(pidgens[i].sg == sg);
2396          assert(!found);
2397          VECTOR_ERASE(pidgens,i, i);
2398          found = true;
2399       }
2400    }
2401 }
2402
2403 void WaitpidMux::removePidGen(SignalGenerator *sg) 
2404 {
2405    proccontrol_printf("[%s:%u] Removing all pidgens for sg %d\n",
2406                       FILE__, __LINE__, sg->getPid());
2407
2408    for (unsigned i=0; i<pidgens.size(); i++) {
2409       if (pidgens[i].sg == sg) {
2410          proccontrol_printf("\t[%s:%u] Removing pidgen %d for sg %d\n",
2411                             FILE__, __LINE__, pidgens[i].pid, sg->getPid());
2412          VECTOR_ERASE(pidgens,i, i);
2413          i--;
2414       }
2415    }
2416 }
2417
2418 int WaitpidMux::enqueueWaitpidValue(waitpid_ret_pair ev, 
2419                                     SignalGenerator *event_owner) 
2420 {
2421    proccontrol_printf("[%s:%u] Giving event to %d\n",
2422                       FILE__, __LINE__, event_owner->getPid());
2423    event_owner->event_queue.push_back(ev);
2424    return 0;
2425 }
2426
2427 /**
2428  * Strategy:  The program entry point is in /lib/ld-2.x.x at the 
2429  * _start function.  Get the current PC, parse /lib/ld-2.x.x, and 
2430  * compare the two points.
2431  **/
2432 bool process::hasPassedMain() 
2433 {
2434    if (reachedBootstrapState(initialized_bs))
2435       return true;
2436
2437    // We only need to parse /lib/ld-2.x.x once for any process,
2438    // so just do it once for any process.  We'll cache the result
2439    // in lib_to_addr.
2440    static dictionary_hash<std::string, Address> lib_to_addr(::Dyninst::stringhash);
2441    Symtab *ld_file = NULL;
2442    bool result, tresult;
2443    std::string name;
2444    Address entry_addr, ldso_start_addr;
2445
2446    //Get current PC
2447    Frame active_frame = getRepresentativeLWP()->getActiveFrame();
2448    Address current_pc = active_frame.getPC();
2449
2450    //Get the current version of /lib/ld-2.x.x
2451    const char *path = getInterpreterName();
2452    ldso_start_addr = getInterpreterBase();
2453
2454    if (!path) {
2455       //Strange... This shouldn't happen on a normal linux system
2456       startup_printf("[%s:%u] - Couldn't find /lib/ld-x.x.x in hasPassedMain\n",
2457                      FILE__, __LINE__);
2458       result = true;
2459       goto cleanup;
2460    }
2461
2462    if (lib_to_addr.defines(path)) {
2463       //We've already parsed this library.  Use those results.
2464       Address start_in_ld = lib_to_addr[path];
2465       result = (start_in_ld != current_pc);
2466       goto cleanup;
2467    }
2468
2469    //Open /lib/ld-x.x.x and find the entry point
2470    name = path;
2471    tresult = Symtab::openFile(ld_file, name);
2472    if (!tresult) {
2473       startup_printf("[%s:%u] - Unable to open %s in hasPassedMain\n", 
2474                      FILE__, __LINE__, path);
2475       result = true;
2476       goto cleanup;
2477    }
2478    
2479
2480    entry_addr = ld_file->getEntryOffset();
2481    if (!entry_addr) {
2482       startup_printf("[%s:%u] - No entry addr for %s\n", 
2483                      FILE__, __LINE__, path);
2484       result = true;
2485       goto cleanup;
2486    }
2487    entry_addr += ldso_start_addr;
2488    
2489    lib_to_addr[path] = entry_addr;
2490    result = (entry_addr != current_pc);
2491    startup_printf("[%s:%u] - hasPassedMain returning %d (%lx %lx)\n",
2492                   FILE__, __LINE__, (int) result, entry_addr, current_pc);
2493
2494    cleanup:
2495
2496    return result;
2497 }
2498
2499 Address process::setAOutLoadAddress(fileDescriptor &desc) {
2500    //The load address of the a.out isn't correct.  We can't read a
2501    // correct one out of ld-x.x.x.so because it may not be initialized yet,
2502    // and it won't be initialized until we reach main.  But we need the load
2503    // address to find main.  Darn.
2504    //
2505    //Instead we'll read the entry out of /proc/pid/maps, and try to make a good
2506    // effort to correctly match the fileDescriptor to an entry.  Unfortunately,
2507    // symlinks can complicate this, so we'll stat the files and compare inodes
2508
2509    struct stat aout, maps_entry;
2510    map_entries *maps = NULL;
2511    unsigned maps_size = 0, i;
2512    char proc_path[128];
2513    int result;
2514
2515    //Get the inode for the a.out
2516    startup_printf("[%s:%u] - a.out is a shared library, computing load addr\n",
2517                   FILE__, __LINE__);
2518    memset(&aout, 0, sizeof(aout));
2519    proc_path[127] = '\0';
2520    snprintf(proc_path, 127, "/proc/%d/exe", getPid());
2521    result = stat(proc_path, &aout);
2522    if (result == -1) {
2523       startup_printf("[%s:%u] - setAOutLoadAddress couldn't stat %s: %s\n",
2524                      FILE__, __LINE__, proc_path, strerror(errno));
2525       goto done;
2526    }
2527                     
2528    //Get the maps
2529    maps = getLinuxMaps(getPid(), maps_size);
2530    if (!maps) {
2531       startup_printf("[%s:%u] - setAOutLoadAddress, getLinuxMaps return NULL\n",
2532                      FILE__, __LINE__);
2533       goto done;
2534    }
2535    
2536    //Compare the inode of each map entry to the a.out's
2537    for (i=0; i<maps_size; i++) {
2538       memset(&maps_entry, 0, sizeof(maps_entry));
2539       result = stat(maps[i].path, &maps_entry);
2540       if (result == -1) {
2541          startup_printf("[%s:%u] - setAOutLoadAddress couldn't stat %s: %s\n",
2542                         FILE__, __LINE__, maps[i].path, strerror(errno));
2543          continue;
2544       }
2545       if (maps_entry.st_dev == aout.st_dev && maps_entry.st_ino == aout.st_ino)
2546       {
2547          //We have a match
2548          desc.setLoadAddr(maps[i].start);
2549          goto done;
2550       }
2551    }
2552         
2553  done:
2554    if (maps)
2555       free(maps);
2556
2557    return desc.loadAddr();
2558 }
2559
2560 bool process::readAuxvInfo()
2561 {
2562    if (auxv_parser)
2563       return false;
2564
2565    auxv_parser = AuxvParser::createAuxvParser(getPid(), getAddressWidth());
2566    if (!auxv_parser) {
2567       startup_printf("%s[%u]: - ERROR, failed to parse Auxv\n", FILE__, __LINE__);
2568       vsys_status_ = vsys_notfound;
2569       return false;
2570    }
2571    
2572    vsyscall_start_ = auxv_parser->getVsyscallBase();
2573    vsyscall_end_ = auxv_parser->getVsyscallEnd();
2574    vsyscall_text_ = auxv_parser->getVsyscallText();
2575    vsys_status_ = vsys_found;
2576    
2577    setInterpreterBase(auxv_parser->getInterpreterBase());
2578    
2579    return true;
2580    
2581    
2582 }
2583 #if defined(cap_binary_rewriter)
2584
2585 std::pair<std::string, BinaryEdit*> BinaryEdit::openResolvedLibraryName(std::string filename)
2586 {
2587    char *libPathStr, *libPath;
2588    std::vector<std::string> libPaths;
2589    struct stat dummy;
2590    FILE *ldconfig;
2591    char buffer[512];
2592    char *pos, *key, *val;
2593     
2594    // prefer qualified file paths
2595    if (stat(filename.c_str(), &dummy) == 0) {
2596         BinaryEdit* temp = BinaryEdit::openFile(filename);
2597         startup_printf("[%s:%u] - Opening dependant file %s\n", 
2598                        FILE__, __LINE__, filename.c_str());
2599         if(temp && temp->getAddressWidth() == getAddressWidth())
2600           return std::make_pair(filename, temp);
2601         startup_printf("[%s:%u] - Creation error opening %s\n", 
2602                   FILE__, __LINE__, filename.c_str());
2603         delete temp;
2604    }
2605
2606    // search paths from environment variables
2607    libPathStr = strdup(getenv("LD_LIBRARY_PATH"));
2608    libPath = strtok(libPathStr, ":");
2609    while (libPath != NULL) {
2610       libPaths.push_back(std::string(libPath));
2611       libPath = strtok(NULL, ":");
2612    }
2613    free(libPathStr);
2614    //libPaths.push_back(std::string(getenv("PWD")));
2615    for (unsigned int i = 0; i < libPaths.size(); i++) {
2616       std::string str = libPaths[i] + "/" + filename;
2617       if (stat(str.c_str(), &dummy) == 0) {
2618         BinaryEdit* temp = BinaryEdit::openFile(str);
2619         startup_printf("[%s:%u] - Opening dependant file %s\n", 
2620                        FILE__, __LINE__, str.c_str());
2621         if(temp && temp->getAddressWidth() == getAddressWidth())
2622           return std::make_pair(str, temp);
2623         startup_printf("[%s:%u] - Creation error opening %s\n", 
2624                   FILE__, __LINE__, str.c_str());
2625         delete temp;
2626         
2627       }
2628    }
2629
2630    // search ld.so.cache
2631    ldconfig = popen("/sbin/ldconfig -p", "r");
2632    if (ldconfig) {
2633       fgets(buffer, 512, ldconfig); // ignore first line
2634       while (fgets(buffer, 512, ldconfig) != NULL) {
2635          pos = buffer;
2636          while (*pos == ' ' || *pos == '\t') pos++;
2637          key = pos;
2638          while (*pos != ' ') pos++;
2639          *pos = '\0';
2640          while (*pos != '=' && *(pos+1) != '>') pos++;
2641          pos += 2;
2642          while (*pos == ' ' || *pos == '\t') pos++;
2643          val = pos;
2644          while (*pos != '\n' && *pos != '\0') pos++;
2645          *pos = '\0';
2646          if (strcmp(key, filename.c_str()) == 0) {
2647            startup_printf("[%s:%u] - Opening dependant file %s\n", 
2648                        FILE__, __LINE__, val);
2649            BinaryEdit* temp = BinaryEdit::openFile(val);
2650            if(temp->getAddressWidth() == getAddressWidth()) {
2651              pclose(ldconfig);
2652              return std::make_pair(std::string(val), temp);
2653            }
2654            
2655            startup_printf("[%s:%u] - Creation error opening %s\n", 
2656                   FILE__, __LINE__, val);
2657            delete temp;
2658          }
2659       }
2660       pclose(ldconfig);
2661    }
2662  
2663    // search hard-coded system paths
2664    libPaths.clear();
2665    libPaths.push_back("/usr/local/lib");
2666    libPaths.push_back("/usr/share/lib");
2667    libPaths.push_back("/usr/lib");
2668    libPaths.push_back("/lib");
2669    for (unsigned int i = 0; i < libPaths.size(); i++) {
2670       std::string str = libPaths[i] + "/" + filename;
2671       if (stat(str.c_str(), &dummy) == 0) {
2672         startup_printf("[%s:%u] - Opening dependant file %s\n", 
2673                        FILE__, __LINE__, str.c_str());
2674         BinaryEdit* temp = BinaryEdit::openFile(str);
2675         if(temp && temp->getAddressWidth() == getAddressWidth())
2676           return std::make_pair(str, temp);
2677         startup_printf("[%s:%u] - Creation error opening %s\n", 
2678                   FILE__, __LINE__, str.c_str());
2679         delete temp;
2680       }
2681    }
2682    startup_printf("[%s:%u] - Creation error opening %s\n", 
2683                   FILE__, __LINE__, filename.c_str());
2684    return std::make_pair("", static_cast<BinaryEdit*>(NULL));
2685 }
2686
2687 #endif
2688
2689 bool process::detachForDebugger(const EventRecord &/*crash_event*/) {
2690    long ret;
2691    int ptrace_errno;
2692    if (strcmp(dyn_debug_crash_debugger, "core") == 0)
2693       return true;
2694    kill(getPid(), SIGSTOP);
2695    ret = DBI_ptrace(PTRACE_DETACH, getPid(), 0x0, 0x0, &ptrace_errno,
2696                     getAddressWidth(), __FILE__, __LINE__);
2697    if (ret == -1) {
2698       fprintf(stderr, "PTrace detach failed: %s\n", strerror(ptrace_errno));
2699    }
2700    return (ret != -1);
2701 }
2702