Problem 1:
[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.192 2006/02/14 23:50:15 jaw Exp $
43
44 #include <fstream>
45
46 #include "dyninstAPI/src/process.h"
47 #include "dyninstAPI/src/dyn_thread.h"
48 #include "dyninstAPI/src/dyn_lwp.h"
49
50 #include <sys/ptrace.h>
51 #include <sys/ioctl.h>
52 #include <fcntl.h>
53 #include <signal.h>
54 #include <dlfcn.h>
55 #include <sys/user.h>
56 #include <sys/time.h>
57 #include <sys/types.h>
58 #include <sys/stat.h>
59 #include <linux/wait.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
66 #include "dyninstAPI/src/symtab.h"
67 #include "dyninstAPI/src/function.h"
68 #include "dyninstAPI/src/instPoint.h"
69 #include "dyninstAPI/src/baseTramp.h"
70 #include "dyninstAPI/src/signalhandler.h"
71 #include "dyninstAPI/src/mailbox.h"
72 #include "dyninstAPI/src/debuggerinterface.h"
73 #include "common/h/headers.h"
74 #include "dyninstAPI/src/os.h"
75 #include "dyninstAPI/src/stats.h"
76 #include "common/h/Types.h"
77 #include "dyninstAPI/src/showerror.h"
78 #include "dyninstAPI/src/util.h" // getCurrWallTime
79 #include "common/h/pathName.h"
80 #include "mapped_object.h"
81 #include "mapped_module.h"
82
83 #include "dynamiclinking.h"
84
85 #ifndef BPATCH_LIBRARY
86 #include "common/h/Time.h"
87 #include "common/h/timing.h"
88 #include "paradynd/src/init.h"
89 #endif
90
91 #include "Elf_X.h"
92 #include "dyninstAPI/src/addLibraryLinux.h"
93 #include "dyninstAPI/src/writeBackElf.h"
94 // #include "saveSharedLibrary.h" 
95
96 #ifdef PAPI
97 #include "papi.h"
98 #endif
99
100 //These values can be different on different platforms, and don't seem to be
101 //consistently defined in the system's include files.
102 #if !defined(PTRACE_SETOPTIONS)
103 #if defined(arch_x86)
104 #define PTRACE_SETOPTIONS 21
105 #elif defined(arch_ia64)
106 #define PTRACE_SETOPTIONS 0x4200
107 #endif
108 #endif
109
110 #if !defined(PT_TRACE_EXIT)
111 #define PTRACE_O_TRACEEXIT 0x40
112 #endif
113
114 #if defined(PTRACEDEBUG) && !defined(PTRACEDEBUG_ALWAYS)
115 static bool debug_ptrace = false;
116 #endif
117
118
119
120 /* ********************************************************************** */
121
122 void printStackWalk( process *p ) {
123   dyn_lwp *lwp_to_use = NULL;
124   if(process::IndependentLwpControl() && p->getRepresentativeLWP() ==NULL)
125      lwp_to_use = p->getInitialThread()->get_lwp();
126   else
127      lwp_to_use = p->getRepresentativeLWP();
128
129   Frame theFrame = lwp_to_use->getActiveFrame();
130   while (true) {
131     // do we have a match?
132     const Address framePC = theFrame.getPC();
133     inferiorrpc_cerr << "stack frame pc @ " << (void*)framePC << endl;
134     
135     if (theFrame.isLastFrame())
136       // well, we've gone as far as we can, with no match.
137       break;
138     
139     // else, backtrace 1 more level
140     theFrame = theFrame.getCallerFrame();
141   }
142 }
143  
144 // already setup on this FD.
145 // disconnect from controlling terminal 
146 void OS::osDisconnect(void) 
147 {
148   int ttyfd = open ("/dev/tty", O_RDONLY);
149   ioctl (ttyfd, TIOCNOTTY, NULL);
150   P_close (ttyfd);
151 }
152
153
154 void OS::osTraceMe(void) 
155
156   int result = P_kill(getpid(), SIGSTOP);
157   if (0 != result) {
158     fprintf(stderr, "%s[%d]:  failed to stop child\n", FILE__, __LINE__);
159     abort();
160   }
161 }
162
163 bool SignalGenerator::attachToChild(int pid)
164 {
165    //  wait for child process to stop itself, attach to it, and continue
166      int wait_options = __WALL | WUNTRACED;
167      int status = 0;
168      int res = waitpid(pid, &status, wait_options);
169      if (res <= 0) {
170         fprintf(stderr, "%s[%d]:  waitpid failed\n", FILE__, __LINE__);
171         abort();
172      }
173
174      if (!WIFSTOPPED(status)) {
175        fprintf(stderr, "%s[%d]:  status is not stopped\n", FILE__, __LINE__);
176      }
177      if ( SIGSTOP != WSTOPSIG(status)) {
178        fprintf(stderr, "%s[%d]:  signal is not SIGILL: stopsig = %d\n", FILE__, __LINE__, WSTOPSIG(status));
179      }
180
181      if (0 != getDBI()->ptrace(PTRACE_ATTACH, pid, 0, 0, 4 )) {
182        fprintf(stderr, "%s[%d]:  ptrace (ATTACH) failed\n", FILE__, __LINE__);
183        abort();
184     }
185
186     if (0 != getDBI()->ptrace(PTRACE_CONT, pid, 0, SIGCONT, 4 ) )  {
187        perror("ptrace(CONT)");
188        fprintf(stderr, "%s[%d]:  ptrace (CONT) failed\n", FILE__, __LINE__);
189        abort();
190     }
191
192     if (0 > waitpid(pid, NULL, 0)) {
193        perror("process::attach - waitpid");
194        exit(1);
195     }
196
197     if (0 != getDBI()->ptrace(PTRACE_CONT, pid, 0, SIGCONT, 4 ) )  {
198        perror("ptrace(CONT)");
199        fprintf(stderr, "%s[%d]:  ptrace (CONT) failed\n", FILE__, __LINE__);
200        abort();
201     }
202
203     return true;
204 }
205
206 bool SignalGenerator::decodeEvent(EventRecord &ev)
207 {
208   //  ev.info has the status result from waitpid
209
210    if (ev.type == evtUndefined) {
211       if (!decodeWaitPidStatus(ev.info, ev)) 
212           fprintf(stderr, "%s[%d][%s]:  failed to decode status for event\n", 
213           FILE__, __LINE__, getThreadStr(getExecThreadID()));
214    }
215
216    errno = 0;
217    if (ev.type == evtSignalled) {
218       if (waiting_for_stop) {
219         if (suppressSignalWhenStopping(ev)) {
220           //  we suppress this signal, just send a null event
221           char buf[128];
222           fprintf(stderr, "%s[%d]:  suppressing signal %s\n", FILE__, __LINE__, ev.sprint_event(buf));
223           ev.type = evtNullEvent;
224           return true;
225         }
226       }
227       decodeSignal(ev);
228    }
229
230    if (/*ev.type == evtSignalled ||*/ ev.type == evtUndefined) {
231      //  if we still have evtSignalled, then it must not be a signal that
232      //  we care about internally.  Still, send it along to the handler
233      //  to be forwarded back to the process.
234      char buf[512];
235      fprintf(stderr, "%s[%d]:  got event %s, should have been set by now\n", FILE__, __LINE__, ev.sprint_event(buf));
236      return true;
237    }
238
239
240    return true;
241 }
242
243 bool get_linux_version(int &major, int &minor, int &subvers)
244 {
245    static int maj = 0, min = 0, sub = 0;
246    int result;
247    FILE *f;
248    if (maj)
249    {
250       major = maj;
251       minor = min;
252       subvers = sub;
253       return true;
254    }
255    f = fopen("/proc/version", "r");
256    if (!f) goto error;
257    result = fscanf(f, "Linux version %d.%d.%d", &major, &minor, &subvers);
258    fclose(f);
259    if (result != 3) goto error;
260
261    maj = major;
262    min = minor;
263    sub = subvers;
264    return true;
265
266  error:
267    //Assume 2.4, which is the earliest version we support
268    major = maj = 2;
269    minor = min = 4;
270    subvers = sub = 0;
271    return false;
272 }
273
274 bool SignalGenerator::add_lwp_to_poll_list(dyn_lwp *lwp)
275 {
276    char filename[64];
277    int lwpid, major, minor, sub;
278    struct stat buf;
279
280    get_linux_version(major, minor, sub);   
281    if ((major == 2 && minor > 4) || (major >= 3))
282       return true;
283    if (!lwp->proc()->multithread_capable(true))
284       return true;
285    
286    lwpid = lwp->get_lwp_id();
287    snprintf(filename, 64, "/proc/%d", lwpid);
288    if (stat(filename, &buf) == 0)
289    {
290       attached_lwp_ids.push_back(pdstring(lwpid));
291       return true;
292    }
293
294    snprintf(filename, 64, "/proc/.%d", lwpid);
295    if (stat(filename, &buf) == 0)
296    {
297       attached_lwp_ids.push_back(pdstring(".") + pdstring(lwpid));
298       return true;
299    }
300    
301    fprintf(stderr, "[%s:%u] - Internal Error.  Could not find new process %d"
302            " in /proc area.  Thread deletion callbacks may not work\n", 
303            __FILE__, __LINE__, lwpid);
304    return false;
305 }
306
307 bool SignalGenerator:: remove_lwp_from_poll_list(int lwp_id)
308 {
309    bool found = false;
310    for (unsigned i=0; i<attached_lwp_ids.size(); i++)
311    {
312       const char *lname = attached_lwp_ids[i].c_str();
313       if (*lname == '.') lname++;
314       if (atoi(lname) == lwp_id)
315       {
316          attached_lwp_ids.erase(i, i);
317          found = true;
318       }
319    }
320    return found;
321 }
322
323 int SignalGenerator::find_dead_lwp()
324 {
325    struct stat buf;
326    char filename[64];
327    int lwpid;
328
329    for (unsigned i=0; i<attached_lwp_ids.size(); i++)
330    {
331       snprintf(filename, 64, "/proc/.%s", attached_lwp_ids[i].c_str());
332       if (stat(filename, &buf) != 0)
333       {
334          const char *s = attached_lwp_ids[i].c_str();
335          if (*s == '.') s++;
336          lwpid = atoi(s);
337          remove_lwp_from_poll_list(lwpid);
338          return lwpid;
339       }
340    }
341    return 0;
342 }
343
344 pid_t SignalGenerator::waitpid_kludge(pid_t pid_arg, int *status, int options, int *dead_lwp)
345 {
346   pid_t ret = 0;
347   int wait_options = options | WNOHANG;
348
349   do {
350    *dead_lwp = find_dead_lwp();
351    if (*dead_lwp) {
352        // This is a bad hack.  On Linux 2.4 waitpid doesn't return for dead threads,
353        // so we poll for any dead threads before calling waitpid, and if they exist
354        // we simulate the result as if waitpid had returned the desired value.
355        status = 0;
356        ret = *dead_lwp;
357        break;
358     }
359
360     ret = waitpid(pid_arg, status, wait_options); 
361     struct timeval slp;
362     slp.tv_sec = 0;
363     slp.tv_usec = 10 /*ms*/ *1000;
364     select(0, NULL, NULL, NULL, &slp);
365   } while (ret == 0);
366
367   return ret; 
368 }
369
370 bool SignalGenerator::waitNextEventLocked(EventRecord &ev) 
371 {
372   signal_printf("%s[%d]:  welcome to waitNextEventLocked\n", FILE__, __LINE__);
373
374   assert(proc);
375
376   int waitpid_pid = 0;
377   int status = 0;
378   int dead_lwp = 0;
379
380   //  If we have a rep lwp, the process is not multithreaded, so just wait for 
381   //  the pid.  If the process is MT, wait for (-pid), which waits for all process
382   //  with thread group <pid>
383
384   int pid_to_wait_for = proc->getRepresentativeLWP() ? pid : -1 * pid;
385
386    //  wait for process events, on linux __WALL signifies that both normal children
387    //  and cloned children (lwps) should be listened for.
388    //  Right now, we are blocking.  To make this nonblocking, or this val with WNOHANG.
389
390    //  __WNOTHREAD signifies that children of other threads (other signal handlers)
391    //  should not be listened for.
392
393    int wait_options = proc->getRepresentativeLWP() ? 0 : __WNOTHREAD; 
394    //int wait_options =  __WNOTHREAD;
395
396    waiting_for_event = true;
397     __UNLOCK;
398     waitpid_pid = waitpid_kludge( pid_to_wait_for /** pid*/ /* -1 for any child*/, 
399                                   &status, wait_options, &dead_lwp );
400     __LOCK;
401    waiting_for_event = false;
402     
403    if (waitpid_pid < 0 && errno == ECHILD) {
404         fprintf(stderr, "%s[%d]:  waitpid failed with ECHILD\n", __FILE__, __LINE__);
405         //assert(0);
406         return false; /* nothing to wait for */
407     } else if (waitpid_pid < 0) {
408         perror("checkForEventLinux: waitpid failure");
409     } else if(waitpid_pid == 0) {
410         fprintf(stderr, "%s[%d]:  waitpid \n", __FILE__, __LINE__);
411         return false;
412     }
413
414    //  If the UI thread wants to initiate a shutdown, it might set a flag and 
415    //  then send a SIGTRAP to the mutatee process, so as to wake up the
416    //  event handling system.  A shutdown event trumps all others, so we handle it
417    //  first.
418
419    if (stop_request) {
420      ev.type = evtShutDown;
421      ev.proc = proc;
422      return true;
423    }
424
425    //   sanity check, make sure we got the right pid
426    if (pid != waitpid_pid) {
427       fprintf(stderr, "%s[%d]:  awful...  got event for wrong process: %d not %d\n", 
428               FILE__, __LINE__, waitpid_pid, pid);
429       return false;
430    }
431
432    ev.proc = proc;
433    ev.lwp = ev.proc->getRepresentativeLWP();
434    ev.type = evtUndefined;
435
436    if (!ev.lwp) {
437       fprintf(stderr, "%s[%d]:  no representative lwp\n", FILE__, __LINE__);
438       //  MT Linux apps will have a NULL representative LWP
439       if ((ev.lwp = ev.proc->lookupLWP(pid))) {
440             if (!ev.lwp->is_attached()) {
441               //  Hijack thread detection events here (very platform specific)
442               //  -- XXX ugly
443               ev.type = evtThreadDetect;
444               return true;
445             }
446       }
447       else if (!ev.proc->getInitialThread() 
448                || !(ev.lwp = ev.proc->getInitialThread()->get_lwp())) {
449            fprintf(stderr, "%s[%d]:  no initial thread \n", FILE__, __LINE__);
450            //  return true here so that we enter the waitpid loop again, which 
451            //  will catch the process exit signal
452            return true; //We must be shutting down
453       }
454       else {
455         assert(0);
456       }
457    }
458
459    assert(ev.lwp);
460    ev.proc->set_lwp_status(ev.lwp, stopped);
461    ev.type = evtUndefined;
462    ev.info = status;
463    
464    bool process_exited = WIFEXITED(status) || dead_lwp;
465    if ((process_exited) && (pid != ev.proc->getPid())) {
466       proccontrol_printf("%s[%d]: Received a thread deletion event for %d\n", 
467                         FILE__, __LINE__, ev.lwp->get_lwp_id());
468       signal_printf("%s[%d]: Received a thread deletion event for %d\n", 
469                         FILE__, __LINE__, ev.lwp->get_lwp_id());
470       // Thread exited via signal
471       ev.type = evtSyscallEntry;      
472       ev.what = SYS_lwp_exit;
473       decodeSyscall(ev);
474    }
475
476    if (!decodeEvent(ev)) {
477      char buf[128];
478      fprintf(stderr, "%s[%d]:  FIXME: %s\n", __FILE__, __LINE__, ev.sprint_event(buf));
479      return false;
480    }
481
482    return true;
483
484 }
485
486 void process::independentLwpControlInit() 
487 {
488    if(multithread_capable()) {
489       // On linux, if process found to be MT, there will be no
490       // representativeLWP since there is no lwp which controls the entire
491       // process for MT linux.
492       real_lwps[representativeLWP->get_lwp_id()] = representativeLWP;
493       representativeLWP = NULL;
494    }
495 }
496
497 dyn_lwp *process::createRepresentativeLWP() 
498 {
499    // the initial lwp has a lwp_id with the value of the pid
500
501    // if we identify this linux process as multi-threaded, then later we will
502    // adjust this lwp to be identified as a real lwp.
503    dyn_lwp *initialLWP = createFictionalLWP(getPid());
504    representativeLWP = initialLWP;
505    // Though on linux, if process found to be MT, there will be no
506    // representativeLWP since there is no lwp which controls the entire
507    // process for MT linux.
508
509    return initialLWP;
510 }
511
512 bool process::trapAtEntryPointOfMain(dyn_lwp *trappingLWP, Address)
513 {
514     if (main_brk_addr == 0x0) return false;
515     assert(trappingLWP);
516     Frame active = trappingLWP->getActiveFrame();
517     if (active.getPC() == main_brk_addr ||
518         (active.getPC()-1) == main_brk_addr)
519         return true;
520     else {
521       fprintf(stderr, "%s[%d]:  pc =  %lx\n",
522             FILE__, __LINE__, active.getPC());
523     }
524     return false;
525 }
526
527 bool process::trapDueToDyninstLib(dyn_lwp *trappingLWP)
528 {
529     // is the trap instr at dyninstlib_brk_addr?
530     if (dyninstlib_brk_addr == 0) return false;
531     assert(trappingLWP);
532     Frame active = trappingLWP->getActiveFrame();
533     if (active.getPC() == dyninstlib_brk_addr ||
534         (active.getPC()-1) == dyninstlib_brk_addr)
535         return true;
536     return false;
537 }
538
539 bool process::setProcessFlags() {
540     // None that I'm aware of -- bernat, 24FEB04
541     return true;
542 }
543
544 bool process::unsetProcessFlags(){
545     // As above
546     return true;
547 }
548
549
550 void emitCallRel32(unsigned disp32, unsigned char *&insn);
551
552 static int lwp_kill(int pid, int sig)
553 {
554   int result = P_tkill(pid, sig);
555   if (result == -1 && errno == ENOSYS)
556   {
557      result = P_kill(pid, sig);
558      proccontrol_printf("%s[%d]: Sent %d to %d via kill\n", FILE__, __LINE__, sig, pid);
559   }
560   else
561      proccontrol_printf("%s[%d]: Sent %d to %d via tkill\n", FILE__, __LINE__, sig, pid);
562
563   return result;
564 }
565
566
567 /**
568  * Return the state of the process from /proc/pid/stat.
569  * File format is:
570  *   pid (executablename) state ...
571  * where state is a character.  Returns '\0' on error.
572  **/
573 static char getState(int pid)
574 {
575   char procName[64];
576   char sstat[256];
577   char *status;
578   int paren_level = 1;
579
580   sprintf(procName,"/proc/%d/stat", pid);
581   FILE *sfile = P_fopen(procName, "r");
582   if (sfile == NULL) return '\0';
583   fread( sstat, 1, 256, sfile );
584   fclose( sfile );
585   sstat[255] = '\0';
586   status = sstat;
587   
588   while (*status != '\0' && *(status++) != '(');
589   while (*status != '\0' && paren_level != 0)
590   {
591     if (*status == '(') paren_level++;
592     if (*status == ')') paren_level--;
593     status++;
594   }
595   while (*status == ' ') status++;
596   return *status;
597 }
598
599 bool process::isRunning_() const 
600 {
601   char result = getState(getPid());
602 //  assert(result != '\0');
603   if (result == '\0') {
604     fprintf(stderr, "%s[%d]:  WARN:  removed assert here\n", FILE__, __LINE__);
605     return false;
606   }
607   return (result != 'T');
608 }
609
610 bool dyn_lwp::isRunning() const 
611 {
612   char result = getState(get_lwp_id());
613   assert(result != '\0');
614   return (result != 'T');
615 }
616
617 bool SignalGenerator::suppressSignalWhenStopping(EventRecord &ev)
618 {
619  
620   bool suppressed_something = false;
621
622   //  signals that we do not suppress
623   //  SIGTRAP here should rewind the pc by one...  check this
624   if (   ev.what == SIGILL
625       || ev.what == SIGTRAP
626       || ev.what == SIGSTOP
627       || ev.what == SIGFPE
628       || ev.what == SIGSEGV
629       || ev.what == SIGBUS )
630     return suppressed_something;
631
632   suppressed_sigs.push_back(ev.what);
633   suppressed_lwps.push_back(ev.lwp);
634   suppressed_something = true;
635
636   return suppressed_something;
637 }
638
639 bool SignalGenerator::resendSuppressedSignals()
640 {
641   assert(suppressed_sigs.size() == suppressed_lwps.size());
642   for (unsigned int i = 0; i < suppressed_sigs.size(); ++i)
643   {
644     fprintf(stderr, "%s[%d]:  resending %d to %d via lwp_kill\n", FILE__, __LINE__,
645             suppressed_sigs[i], suppressed_lwps[i]->get_lwp_id());
646     //Throw back the extra signals we caught.
647     lwp_kill(suppressed_lwps[i]->get_lwp_id(), suppressed_sigs[i]);
648   }
649   suppressed_lwps.clear();
650   suppressed_sigs.clear();
651   return true;
652 }
653
654 bool dyn_lwp::removeSigStop()
655 {
656   //fprintf(stderr, "%s[%d][%s]:  welcome to removeSigStop, about to lwp_kill(%d, %d)\n",
657    //       FILE__, __LINE__, getThreadStr(getExecThreadID()), get_lwp_id(), SIGCONT);
658   return (lwp_kill(get_lwp_id(), SIGCONT) == 0);
659 }
660
661 bool dyn_lwp::continueLWP_(int signalToContinueWith) 
662 {
663    proccontrol_printf("%s[%d]:  ContinuingLWP_ %d with %d\n", FILE__, __LINE__,
664           get_lwp_id(), signalToContinueWith);
665
666    // we don't want to operate on the process in this state
667    int arg3 = 0;
668    int arg4 = 0;
669    if(signalToContinueWith != dyn_lwp::NoSignal) {
670       arg3 = 1;
671       arg4 = signalToContinueWith;
672    }
673
674    if (proc()->sh->waitingForStop())
675    {
676      fprintf(stderr, "%s[%d]:  suppressing continue\n", FILE__, __LINE__);
677      return false;
678    }
679
680    if (status() == exited)
681    {
682       return true;
683    }
684
685    ptraceOps++; 
686    ptraceOtherOps++;
687
688    int ptrace_errno = 0;
689    int ret = DBI_ptrace(PTRACE_CONT, get_lwp_id(), arg3, arg4, &ptrace_errno, proc_->getAddressWidth(),  FILE__, __LINE__);
690    if (ret == 0)
691      return true;
692
693    /**
694     * A stopped ptrace'd process can be in two states on Linux.
695     * If it blocked on a signal, but never received a PTRACE_CONT,
696     * then it should be continued with a PTRACE_CONT.
697     *
698     * If the kernel couldn't find an awake thread to deliver the signal to,
699     * it'll grab anyone (usually the last) and wake them up for long enough
700     * to deliver the signal.  This leaves that thread is a different state
701     * than the others, and it won't actually respond to the PTRACE_CONT.  
702     **/
703    ret = P_kill(get_lwp_id(), SIGCONT);
704    if (ret == -1)
705      return false;
706    return true;
707 }
708
709 bool dyn_lwp::waitUntilStopped()
710 {
711   if (status() == stopped)
712   {
713     return true;
714   }
715
716   //return (doWaitUntilStopped(proc(), get_lwp_id(), true) != NULL);
717   SignalGenerator *sh = (SignalGenerator *) proc()->sh;
718   sh->setWaitingForStop(true);
719   while ( status() != stopped) {
720     signal_printf("%s[%d]:  before waitForEvent(evtProcessStop): status is %s\n",
721             FILE__, __LINE__, getStatusAsString().c_str());
722     sh->waitForEvent(evtProcessStop);
723   }
724   sh->setWaitingForStop(false);
725   sh->resendSuppressedSignals();
726   return true;
727 }
728
729 bool dyn_lwp::stop_() 
730 {
731   proccontrol_printf("%s[%d][%s]:  welcome to stop_, about to lwp_kill(%d, %d)\n",
732           FILE__, __LINE__, getThreadStr(getExecThreadID()), get_lwp_id(), SIGCONT);
733   return (lwp_kill(get_lwp_id(), SIGSTOP) == 0);
734
735
736 bool process::continueProc_(int sig)
737 {
738   bool no_err = true;
739   dyn_lwp *lwp;
740   unsigned index = 0; 
741
742   //Continue all real LWPs
743   dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
744   while (lwp_iter.next(index, lwp))
745   {
746     if (lwp->status() == running || lwp->status() == exited)
747       continue;
748     bool result = lwp->continueLWP(sig);
749     if (result)
750       set_lwp_status(lwp, running);
751     else
752       no_err = false;
753   }
754
755   //Continue any representative LWP
756   if (representativeLWP && representativeLWP->status() != running)
757   {
758     bool result = representativeLWP->continueLWP(sig);
759     if (result)
760       set_lwp_status(representativeLWP, running);
761     else
762       no_err = false;
763   }
764
765   return no_err;
766 }
767
768 bool SignalGenerator::waitForStopInline()
769 {
770
771    while (proc->isRunning_()) {
772        if (0 > waitpid(getPid(), NULL, 0)) {
773          //  should do some better checking here....
774          perror("waitpid");
775          return false;
776        }
777    }
778    
779    return true;
780 }
781
782 bool process::stop_(bool waitUntilStop)
783 {
784   int result;
785   
786   //Stop the main process
787   result = P_kill(getPid(), SIGSTOP);
788   if (result == -1) 
789   {
790     perror("Couldn't send SIGSTOP\n");
791     return false;
792   }
793
794   if (waitUntilStop) {
795     if (!waitUntilLWPStops()) 
796        return false;
797     if (status() == exited)
798        return false;
799   }
800
801   //Stop all other LWPs
802   dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
803   unsigned index = 0;
804   dyn_lwp *lwp;
805   
806   while(lwp_iter.next(index, lwp))
807   {
808     lwp->pauseLWP(waitUntilStop);
809   }
810
811   return true;
812 }
813
814 bool process::waitUntilStopped()
815 {
816   dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
817   dyn_lwp *lwp;
818   unsigned index = 0;
819   bool result = true;
820
821   while(lwp_iter.next(index, lwp))
822   {
823     result &= lwp->waitUntilStopped();
824   }
825
826   return result;
827 }
828
829 bool process::waitUntilLWPStops()
830 {
831
832   fprintf(stderr, "%s[%d]:  welcome to waitUntilLWPStops\n", FILE__, __LINE__);
833   ((SignalGenerator *)sh)->setWaitingForStop(true);
834   while ( status() != stopped) {
835     if (status() == exited) {
836       fprintf(stderr, "%s[%d]:  process exited\n", __FILE__, __LINE__);
837       return false;
838     }
839     signal_printf("%s[%d][%s]:  before waitForEvent(evtProcessStop)\n", 
840             FILE__, __LINE__, getThreadStr(getExecThreadID()));
841     sh->waitForEvent(evtProcessStop);
842   }
843
844   ((SignalGenerator *)sh)->setWaitingForStop(false);
845   ((SignalGenerator *)sh)->resendSuppressedSignals();
846
847   return true;
848
849 }
850
851 terminateProcStatus_t process::terminateProc_()
852 {
853   if (kill( getPid(), SIGKILL )) {
854     // Kill failed... 
855     if (errno == ESRCH)
856       return alreadyTerminated;
857     else
858       return terminateFailed;
859   }
860   else
861     return terminateSucceeded;
862 }
863
864 void dyn_lwp::realLWP_detach_() 
865 {
866    if(! proc_->isAttached()) {
867       if (! proc_->hasExited())
868          cerr << "Detaching, but not attached" << endl;
869       return;
870    }
871     
872     cerr <<"Detaching..." << endl;
873     ptraceOps++;
874     ptraceOtherOps++;
875     int ptrace_errno = 0;
876     int ptrace_ret = DBI_ptrace(PTRACE_DETACH, get_lwp_id(),1, SIGCONT, &ptrace_errno, proc_->getAddressWidth(),  __FILE__, __LINE__); 
877     if (ptrace_ret < 0) {
878       fprintf(stderr, "%s[%d]:  ptrace failed: %s\n", __FILE__, __LINE__, strerror(ptrace_errno));
879     }
880     proc()->sh->remove_lwp_from_poll_list(get_lwp_id());
881     return;
882 }
883
884 void dyn_lwp::representativeLWP_detach_() {
885     // If the process is already exited, then don't call ptrace
886     if(! proc_->isAttached())
887         return;
888     
889     if (fd_) close(fd_);
890     
891     ptraceOps++;
892     ptraceOtherOps++;
893    int ptrace_errno = 0;
894     DBI_ptrace(PTRACE_DETACH, get_lwp_id(),1, SIGCONT, &ptrace_errno, proc_->getAddressWidth(),  __FILE__, __LINE__); 
895     proc()->sh->remove_lwp_from_poll_list(get_lwp_id());
896     return;
897 }
898
899 bool process::dumpCore_(const pdstring/* coreFile*/) { return false; }
900
901 bool dyn_lwp::writeTextWord(caddr_t inTraced, int data) {
902    //  cerr << "writeTextWord @ " << (void *)inTraced << endl; cerr.flush();
903    return writeDataSpace(inTraced, sizeof(int), (caddr_t) &data);
904 }
905
906 bool dyn_lwp::writeTextSpace(void *inTraced, u_int amount, const void *inSelf)
907 {
908   //    cerr << "writeTextSpace pid=" << getPid() << ", @ " << (void *)inTraced
909   //     << " len=" << amount << endl; cerr.flush();
910    return writeDataSpace(inTraced, amount, inSelf);
911 }
912
913 bool dyn_lwp::readTextSpace(void *inTraced, u_int amount, const void *inSelf) {
914    return readDataSpace(inTraced, amount, const_cast<void*>( inSelf ));
915 }
916
917 bool DebuggerInterface::bulkPtraceWrite(void *inTraced, u_int nbytes, void *inSelf, int pid, int /*address_width*/)
918 {
919    unsigned char *ap = (unsigned char*) inTraced;
920    const unsigned char *dp = (const unsigned char*) inSelf;
921    Address w = 0x0;               /* ptrace I/O buffer */
922    int len = sizeof(Address); /* address alignment of ptrace I/O requests */
923    unsigned cnt;
924
925    //cerr << "writeDataSpace pid=" << getPid() << ", @ " << (void *)inTraced
926    //    << " len=" << nbytes << endl; cerr.flush();
927
928    ptraceOps++; ptraceBytes += nbytes;
929
930    if (0 == nbytes)
931       return true;
932
933    if ((cnt = ((Address)ap) % len)) {
934       /* Start of request is not aligned. */
935       unsigned char *p = (unsigned char*) &w;
936
937       /* Read the segment containing the unaligned portion, edit
938          in the data from DP, and write the segment back. */
939       errno = 0;
940       w = P_ptrace(PTRACE_PEEKTEXT, pid, (Address) (ap-cnt), 0);
941
942       if (errno) {
943          fprintf(stderr, "%s[%d]:  write data space failing, pid %d\n", __FILE__, __LINE__, pid);
944          return false;
945       }
946
947       for (unsigned i = 0; i < len-cnt && i < nbytes; i++)
948          p[cnt+i] = dp[i];
949
950       if (0 > P_ptrace(PTRACE_POKETEXT, pid, (Address) (ap-cnt), w)) {
951          fprintf(stderr, "%s[%d]:  write data space failing\n", __FILE__, __LINE__);
952          return false;
953       }
954
955       if (len-cnt >= nbytes)
956          return true; /* done */
957
958       dp += len-cnt;
959       ap += len-cnt;
960       nbytes -= len-cnt;
961    }
962
963    /* Copy aligned portion */
964    while (nbytes >= (u_int)len) {
965       assert(0 == ((Address)ap) % len);
966       memcpy(&w, dp, len);
967       int retval =  P_ptrace(PTRACE_POKETEXT, pid, (Address) ap, w);
968       if (retval < 0) {
969          fprintf(stderr, "%s[%d]:  write data space failing, pid %d\n", __FILE__, __LINE__, pid);
970          fprintf(stderr, "%s[%d][%s]:  tried to write %lx in address %p\n", FILE__, __LINE__, getThreadStr(getExecThreadID()),w, ap);
971          perror("ptrace");
972          return false;
973       }
974
975       // Check...
976       /*
977       Address test;
978       fprintf(stderr, "Writing %x... ", w);
979       test = P_ptrace(PTRACE_PEEKTEXT, get_lwp_id(), (Address) ap, 0);
980       fprintf(stderr, "... got %x, lwp %d\n", test, get_lwp_id());
981       */
982       dp += len;
983       ap += len;
984       nbytes -= len;
985    }
986
987    if (nbytes > 0) {
988       /* Some unaligned data remains */
989       unsigned char *p = (unsigned char *) &w;
990
991       /* Read the segment containing the unaligned portion, edit
992          in the data from DP, and write it back. */
993       errno = 0;
994       w = P_ptrace(PTRACE_PEEKTEXT, pid, (Address) ap, 0);
995
996       if (errno) {
997          fprintf(stderr, "%s[%d]:  write data space failing\n", __FILE__, __LINE__);
998          return false;
999       }
1000
1001
1002       for (unsigned i = 0; i < nbytes; i++)
1003          p[i] = dp[i];
1004
1005       if (0 > P_ptrace(PTRACE_POKETEXT, pid, (Address) ap, w)) {
1006          fprintf(stderr, "%s[%d]:  write data space failing\n", __FILE__, __LINE__);
1007          return false;
1008       }
1009
1010    }
1011
1012    return true;
1013
1014 }
1015
1016 bool dyn_lwp::writeDataSpace(void *inTraced, u_int nbytes, const void *inSelf)
1017 {
1018    unsigned char *ap = (unsigned char*) inTraced;
1019    const unsigned char *dp = (const unsigned char*) inSelf;
1020
1021    //fprintf(stderr, "%s[%d]:  welcome to dyn_lwp::writeDataSpace(%d bytes)\n", __FILE__, __LINE__, nbytes);
1022    //cerr << "writeDataSpace pid=" << getPid() << ", @ " << (void *)inTraced
1023    //    << " len=" << nbytes << endl; cerr.flush();
1024
1025 #if defined(BPATCH_LIBRARY)
1026 #if defined(i386_unknown_linux2_0) \
1027  || defined(x86_64_unknown_linux2_4) /* Blind duplication - Ray */
1028    if (proc_->collectSaveWorldData) {
1029        codeRange *range = NULL;
1030         proc_->codeRangesByAddr_.precessor((Address)inTraced, range); //findCodeRangeByAddress((Address)inTraced);
1031         if(range){
1032                 mapped_object *mappedobj_ptr = range->is_mapped_object();
1033                if (mappedobj_ptr) {
1034                    // If we're writing into a shared object, mark it as dirty.
1035                    // _Unless_ we're writing "__libc_sigaction"
1036                    int_function *func = range->is_function();
1037                    if ((! func) || (func->prettyName() != "__libc_sigaction")){
1038                       mappedobj_ptr->setDirty();
1039                    }
1040                }
1041         }
1042    }
1043 #endif
1044 #endif
1045
1046    ptraceOps++; ptraceBytes += nbytes;
1047
1048    if (!DBI_writeDataSpace(get_lwp_id(), (Address) ap, nbytes, (Address) dp, sizeof(Address), __FILE__, __LINE__)) {
1049      fprintf(stderr, "%s[%d]:  bulk ptrace failed\n", __FILE__, __LINE__);
1050      return false;
1051    }
1052    return true;
1053 }
1054
1055
1056 bool DebuggerInterface::bulkPtraceRead(void *inTraced, u_int nelem, void *inSelf, int pid, int address_width) 
1057 {
1058
1059      u_int nbytes = nelem;
1060      const unsigned char *ap = (const unsigned char*) inTraced; 
1061      unsigned char *dp = (unsigned char*) inSelf;
1062      Address w = 0x0;               /* ptrace I/O buffer */
1063      int len = address_width; /* address alignment of ptrace I/O requests */
1064      unsigned cnt;
1065          
1066      ptraceOps++; ptraceBytes += nbytes;
1067       
1068      if (0 == nbytes)
1069           return true;
1070       
1071      if ((cnt = ((Address)ap) % len)) {
1072           /* Start of request is not aligned. */
1073           unsigned char *p = (unsigned char*) &w;
1074    
1075           /* Read the segment containing the unaligned portion, and
1076              copy what was requested to DP. */
1077           errno = 0;
1078           w = P_ptrace(PTRACE_PEEKTEXT, pid, (Address) (ap-cnt), w, len);
1079           if (errno) {
1080                fprintf(stderr, "%s[%d]:  ptrace failed: for pid %d%s\n", FILE__, __LINE__, pid, strerror(errno));
1081                return false;
1082           }
1083           for (unsigned i = 0; i < len-cnt && i < nbytes; i++)
1084                dp[i] = p[cnt+i];
1085
1086           if (len-cnt >= nbytes)
1087                return true; /* done */
1088
1089           dp += len-cnt;
1090           ap += len-cnt;
1091           nbytes -= len-cnt;
1092      }
1093    /* Copy aligned portion */
1094      while (nbytes >= (u_int)len) {
1095           errno = 0;
1096           w = P_ptrace(PTRACE_PEEKTEXT, pid, (Address) ap, 0, len);
1097           if (errno) {
1098                fprintf(stderr, "%s[%d]:  ptrace(PEEK, pid %d, %p, 0, len %d) failed: %s\n", FILE__, __LINE__, pid, (void *) ( (Address) ap), len,strerror(errno));
1099               return false;
1100           }
1101           memcpy(dp, &w, len);
1102           dp += len;
1103           ap += len;
1104           nbytes -= len;
1105      }
1106
1107      if (nbytes > 0) {
1108           /* Some unaligned data remains */
1109           unsigned char *p = (unsigned char *) &w;
1110
1111           /* Read the segment containing the unaligned portion, and
1112              copy what was requested to DP. */
1113           errno = 0;
1114           w = P_ptrace(PTRACE_PEEKTEXT, pid, (Address) ap, 0, len);
1115           if (errno) {
1116                fprintf(stderr, "%s[%d]:  ptrace failed: %s\n", FILE__, __LINE__, strerror(errno));
1117                return false;
1118           }
1119           for (unsigned i = 0; i < nbytes; i++)
1120                dp[i] = p[i];
1121      }
1122      return true;
1123
1124
1125
1126 }
1127
1128 bool dyn_lwp::readDataSpace(const void *inTraced, u_int nbytes, void *inSelf) {
1129      const unsigned char *ap = (const unsigned char*) inTraced;
1130      unsigned char *dp = (unsigned char*) inSelf;
1131      int len = proc_->getAddressWidth(); /* address alignment of ptrace I/O requests */
1132
1133      ptraceOps++; ptraceBytes += nbytes;
1134
1135      bool ret = false;
1136      if (! (ret = DBI_readDataSpace(get_lwp_id(), (Address) ap, nbytes,(Address) dp, /*sizeof(Address)*/ len,__FILE__, __LINE__))) {
1137        fprintf(stderr, "%s[%d]:  bulk ptrace read failed for lwp id %d\n", __FILE__, __LINE__, get_lwp_id());
1138        return false;
1139      }
1140      return true;
1141 }
1142
1143 // You know, /proc/*/exe is a perfectly good link (directly to the inode) to
1144 // the executable file, who cares where the executable really is, we can open
1145 // this link. - nash
1146 pdstring process::tryToFindExecutable(const pdstring & /* iprogpath */, int pid) {
1147   // We need to dereference the /proc link.
1148   // Case 1: multiple copies of the same file opened with multiple
1149   // pids will not match (and should)
1150   // Case 2: an exec'ed program will have the same /proc path,
1151   // but different program paths
1152   pdstring procpath = pdstring("/proc/") + pdstring(pid) + pdstring("/exe");
1153   char buf[1024];
1154   int chars_read = readlink(procpath.c_str(), buf, 1024);
1155   if (chars_read == -1) {
1156     // Note: the name could be too long. Not handling yet.
1157     return procpath;
1158   }
1159   buf[chars_read] = 0;
1160   return pdstring(buf);
1161 }
1162
1163
1164 bool process::determineLWPs(pdvector<unsigned> &lwp_ids)
1165 {
1166   char name[128];
1167   struct dirent *direntry;
1168   
1169   /**
1170    * Linux 2.6:
1171    **/
1172   sprintf(name, "/proc/%d/task", getPid());
1173   DIR *dirhandle = opendir(name);
1174   if (dirhandle)
1175   {
1176      //Only works on Linux 2.6
1177      while((direntry = readdir(dirhandle)) != NULL) {
1178         unsigned lwp_id = atoi(direntry->d_name);
1179         if (lwp_id) 
1180            lwp_ids.push_back(lwp_id);
1181      }
1182      closedir(dirhandle);
1183      return true;
1184   }
1185   /**
1186    * Linux 2.4:
1187    *
1188    * PIDs that are created by pthreads have a '.' prepending their name
1189    * in /proc.  We'll check all of those for the ones that have this lwp
1190    * as a parent pid.
1191    **/
1192   dirhandle = opendir("/proc");
1193   if (!dirhandle)
1194   {
1195      //No /proc directory.  I give up.  No threads for you.
1196      return false;
1197   } 
1198   while ((direntry = readdir(dirhandle)) != NULL)
1199   {
1200      if (direntry->d_name[0] != '.')
1201         continue;
1202      unsigned lwp_id = atoi(direntry->d_name+1);
1203      int lwp_ppid;
1204      if (!lwp_id) 
1205         continue;
1206      sprintf(name, "/proc/%d/stat", lwp_id);
1207      FILE *fd = fopen(name, "r");
1208      if (!fd)
1209         continue;
1210      fscanf(fd, "%*d %*s %*c %d", &lwp_ppid);
1211      fclose(fd);
1212      if (lwp_ppid != getPid())
1213         continue;
1214      lwp_ids.push_back(lwp_id);
1215   }
1216   closedir(dirhandle);
1217   lwp_ids.push_back(getPid());
1218   
1219   return true;
1220 }
1221
1222 #if !defined(BPATCH_LIBRARY)
1223 #ifdef PAPI
1224 papiMgr* dyn_lwp::papi() {
1225
1226   return proc()->getPapiMgr();
1227
1228 }
1229 #endif
1230 #endif
1231
1232
1233 #ifdef NOTDEF // PDSEP
1234 #if !defined(BPATCH_LIBRARY)
1235
1236 rawTime64 dyn_lwp::getRawCpuTime_hw()
1237 {
1238   rawTime64 result = 0;
1239   
1240 #ifdef PAPI
1241   result = papi()->getCurrentVirtCycles();
1242 #endif
1243   
1244   if (result < hw_previous_) {
1245     logLine("********* time going backwards in paradynd **********\n");
1246     result = hw_previous_;
1247   }
1248   else 
1249     hw_previous_ = result;
1250   
1251   return result;
1252 }
1253
1254 rawTime64 dyn_lwp::getRawCpuTime_sw()
1255 {
1256   rawTime64 result = 0;
1257   int bufsize = 150;
1258   unsigned long utime, stime;
1259   char procfn[bufsize], *buf;
1260
1261   sprintf( procfn, "/proc/%d/stat", get_lwp_id());
1262
1263   int fd;
1264
1265   // The reason for this complicated method of reading and sseekf-ing is
1266   // to ensure that we read enough of the buffer 'atomically' to make sure
1267   // the data is consistent.  Is this necessary?  I *think* so. - nash
1268   do {
1269     fd = P_open(procfn, O_RDONLY, 0);
1270     if (fd < 0) {
1271       perror("getInferiorProcessCPUtime (open)");
1272       return false;
1273     }
1274
1275     buf = new char[ bufsize ];
1276
1277     if ((int)P_read( fd, buf, bufsize-1 ) < 0) {
1278       perror("getInferiorProcessCPUtime");
1279       return false;
1280     }
1281
1282         /* While I'd bet that any of the numbers preceding utime and stime could overflow 
1283            a signed int on IA-64, the compiler whines if you add length specifiers to
1284            elements whose conversion has been surpressed. */
1285     if(2==sscanf(buf,"%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %lu %lu "
1286                  , &utime, &stime ) ) {
1287       // These numbers are in 'jiffies' or timeslices.
1288       // Oh, and I'm also assuming that process time includes system time
1289       result = static_cast<rawTime64>(utime) + static_cast<rawTime64>(stime);
1290       break;
1291     }
1292
1293     delete [] buf;
1294     bufsize = bufsize * 2;
1295
1296     P_close( fd );
1297   } while ( true );
1298
1299   delete [] buf;
1300   P_close(fd);
1301
1302   if (result < sw_previous_) {
1303     logLine("********* time going backwards in paradynd **********\n");
1304     result = sw_previous_;
1305   }
1306   else 
1307     sw_previous_ = result;
1308
1309   return result;
1310 }
1311 #endif
1312
1313 #endif // NOTDEF // PDSEP
1314
1315 bool process::dumpImage( pdstring imageFileName ) {
1316         /* What we do is duplicate the original file,
1317            and replace the copy's .text section with
1318            the (presumably instrumented) in-memory
1319            executable image.  Note that we don't seem
1320            to be concerned with making sure that we
1321            actually grab the instrumentation code itself... */
1322         
1323         /* Acquire the filename. */
1324    if (!mapped_objects.size()) {
1325       return false;
1326    }
1327
1328    pdstring originalFileName = mapped_objects[0]->fullName();
1329         
1330         /* Use system() to execute the copy. */
1331         pdstring copyCommand = "cp " + originalFileName + " " + imageFileName;
1332    system( copyCommand.c_str() );
1333
1334    /* Open the copy so we can use libelf to find the .text section. */
1335    int copyFD = open( imageFileName.c_str(), O_RDWR, 0 );
1336    if( copyFD < 0 ) { return false; }
1337    
1338    /* Start up the elven widgetry. */
1339    Elf_X elf( copyFD, ELF_C_READ );
1340    if (!elf.isValid()) return false;
1341    
1342    /* Acquire the shared names pointer. */
1343    Elf_X_Shdr elfSection = elf.get_shdr( elf.e_shstrndx() );
1344    Elf_X_Data elfData = elfSection.get_data();
1345    const char *sharedNames = elfData.get_string();
1346
1347    /* Iterate over the sections to find the text section's
1348       offset, length, and base address. */
1349    Address offset = 0;
1350    Address length = 0;
1351    Address baseAddr = 0;
1352    
1353    for( int i = 0; i < elf.e_shnum(); ++i ) {
1354       elfSection = elf.get_shdr( i );
1355       const char * name = (const char *) &sharedNames[ elfSection.sh_name() ];
1356       
1357       if( P_strcmp( name, ".text" ) == 0 ) {
1358          offset = elfSection.sh_offset();
1359          length = elfSection.sh_size();
1360          baseAddr = elfSection.sh_addr();
1361          break;
1362       } /* end if we've found the text section */
1363    } /* end iteration over sections */
1364
1365    /* Copy the code out of the mutatee. */
1366    char * codeBuffer = (char *)malloc( length );
1367    assert( codeBuffer != NULL );
1368    
1369    if( ! readTextSpace( (void *) baseAddr, length, codeBuffer ) ) {
1370       free( codeBuffer );
1371       elf.end();
1372       P_close( copyFD );
1373       return false;
1374    }
1375
1376    /* Write that code to the image file. */
1377    lseek( copyFD, offset, SEEK_SET );
1378    write( copyFD, codeBuffer, length );
1379
1380    /* Clean up. */
1381    free( codeBuffer );
1382    elf.end();
1383    P_close( copyFD );
1384    return true;
1385 }
1386
1387 int getNumberOfCPUs()
1388 {
1389   return sysconf(_SC_NPROCESSORS_ONLN);
1390 }
1391
1392 //Returns true if the function is part of the PLT table
1393 bool isPLT(int_function *f)
1394 {
1395     const Object &obj = f->mod()->obj()->parse_img()->getObject();
1396     return obj.is_offset_in_plt(f->ifunc()->getOffset());
1397 }
1398
1399 // findCallee: finds the function called by the instruction corresponding
1400 // to the instPoint "instr". If the function call has been bound to an
1401 // address, then the callee function is returned in "target" and the 
1402 // instPoint "callee" data member is set to pt to callee's int_function.  
1403 // If the function has not yet been bound, then "target" is set to the 
1404 // int_function associated with the name of the target function (this is 
1405 // obtained by the PLT and relocation entries in the image), and the instPoint
1406 // callee is not set.  If the callee function cannot be found, (ex. function
1407 // pointers, or other indirect calls), it returns false.
1408 // Returns false on error (ex. process doesn't contain this instPoint).
1409
1410 int_function *instPoint::findCallee() {
1411
1412    // Already been bound
1413    if (callee_) {
1414       return callee_;
1415    }  
1416    if (ipType_ != callSite) {
1417       // Assert?
1418       return NULL; 
1419    }
1420    if (isDynamicCall()) {
1421       return NULL;
1422    }
1423
1424    assert(img_p_);
1425    image_func *icallee = img_p_->getCallee(); 
1426    if (icallee) {
1427       // Now we have to look up our specialized version
1428       // Can't do module lookup because of DEFAULT_MODULE...
1429       const pdvector<int_function *> *possibles = func()->obj()->findFuncVectorByMangled(icallee->symTabName());
1430       if (!possibles) {
1431          return NULL;
1432       }
1433       for (unsigned i = 0; i < possibles->size(); i++) {
1434          if ((*possibles)[i]->ifunc() == icallee) {
1435             callee_ = (*possibles)[i];
1436             return callee_;
1437          }
1438       }
1439       // No match... very odd
1440       assert(0);
1441       return NULL;
1442    }
1443    // Do this the hard way - an inter-module jump
1444    // get the target address of this function
1445    Address target_addr = img_p_->callTarget();
1446    if(!target_addr) {
1447       // this is either not a call instruction or an indirect call instr
1448       // that we can't get the target address
1449       return NULL;
1450    }
1451
1452    // get the relocation information for this image
1453    const Object &obj = func()->obj()->parse_img()->getObject();
1454    const pdvector<relocationEntry> *fbt;
1455    if(!obj.get_func_binding_table_ptr(fbt)) {
1456       return NULL; // target cannot be found...it is an indirect call.
1457    }
1458   
1459    Address base_addr = func()->obj()->codeBase();
1460    // find the target address in the list of relocationEntries
1461    for(u_int i=0; i < fbt->size(); i++) {
1462       if((*fbt)[i].target_addr() == target_addr) {
1463          // check to see if this function has been bound yet...if the
1464          // PLT entry for this function has been modified by the runtime
1465          // linker
1466          int_function *target_pdf = 0;
1467          if(proc()->hasBeenBound((*fbt)[i], target_pdf, base_addr)) {
1468             callee_ = target_pdf;
1469             return callee_;  // target has been bound
1470          } 
1471          else {
1472             pdvector<int_function *> pdfv;
1473             bool found = proc()->findFuncsByMangled((*fbt)[i].name(), pdfv);
1474             if(found) {
1475                assert(pdfv.size());
1476                callee_ = pdfv[0];
1477                return callee_;
1478             }
1479          }
1480          break;
1481       }
1482    }
1483    return NULL;
1484 }
1485
1486 bool SignalGeneratorCommon::getExecFileDescriptor(pdstring filename,
1487                                     int /*pid*/,
1488                                     bool /*whocares*/,
1489                                     int &,
1490                                     fileDescriptor &desc)
1491 {
1492     desc = fileDescriptor(filename, 
1493                           0, // code
1494                           0, // data
1495                           false); // a.out
1496     return true;
1497 }
1498
1499 #if defined(USES_DYNAMIC_INF_HEAP)
1500 static const Address lowest_addr = 0x0;
1501 void process::inferiorMallocConstraints(Address near, Address &lo, Address &hi,
1502                                inferiorHeapType /* type */ )
1503 {
1504   if (near)
1505     {
1506 #if !defined(arch_x86_64)
1507       lo = region_lo(near);
1508       hi = region_hi(near);  
1509 #else
1510       if (getAddressWidth() == 8) {
1511           lo = region_lo_64(near);
1512           hi = region_hi_64(near);
1513       }
1514       else {
1515           lo = region_lo(near);
1516           hi = region_hi(near);  
1517       }
1518 #endif
1519     }
1520 }
1521
1522 void process::inferiorMallocAlign(unsigned &size)
1523 {
1524      /* 32 byte alignment.  Should it be 64? */
1525   size = (size + 0x1f) & ~0x1f;
1526 }
1527 #endif
1528
1529 bool dyn_lwp::realLWP_attach_() {
1530    char procName[128];
1531    sprintf(procName, "/proc/%d/mem", get_lwp_id());
1532    fd_ = P_open(procName, O_RDWR, 0);
1533    if (fd_ < 0) 
1534      fd_ = INVALID_HANDLE_VALUE;
1535
1536    startup_printf("%s[%d]:  realLWP_attach doing PTRACE_ATTACH to %lu\n", 
1537                   FILE__, __LINE__, get_lwp_id());
1538    int ptrace_errno = 0;
1539    if( 0 != DBI_ptrace(PTRACE_ATTACH, get_lwp_id(), 0, 0, &ptrace_errno, 
1540                        proc_->getAddressWidth(),  __FILE__, __LINE__) )
1541    {
1542       fprintf(stderr, "%s[%d]:  ptrace attach to pid %d failing\n", FILE__, __LINE__, get_lwp_id());
1543       perror( "process::attach - PTRACE_ATTACH" );
1544       return false;
1545    }
1546    
1547    proc()->sh->add_lwp_to_poll_list(this);
1548    eventType evt;
1549    if (evtThreadDetect != (evt = proc()->sh->waitForEvent(evtThreadDetect, proc_, this))) {
1550      fprintf(stderr, "%s[%d]:  received unexpected event %s\n", FILE__, __LINE__, eventType2str(evt));
1551      abort();
1552    }
1553
1554    if (proc_->status() == running)
1555       continueLWP();
1556    return true;
1557 }
1558
1559 bool dyn_lwp::representativeLWP_attach_() {
1560
1561    // step 1) /proc open: attach to the inferior process memory file
1562    char procName[128];
1563    sprintf(procName, "/proc/%d/mem", (int) proc_->getPid());
1564    fd_ = P_open(procName, O_RDWR, 0);
1565    if (fd_ < 0) 
1566      fd_ = INVALID_HANDLE_VALUE;
1567    
1568    bool running = false;
1569    if( proc_->wasCreatedViaAttach() )
1570       running = proc_->isRunning_();
1571    
1572    // QUESTION: does this attach operation lead to a SIGTRAP being forwarded
1573    // to paradynd in all cases?  How about when we are attaching to an
1574    // already-running process?  (Seems that in the latter case, no SIGTRAP
1575    // is automatically generated)
1576    
1577    // Only if we are really attaching rather than spawning the inferior
1578    // process ourselves do we need to call PTRACE_ATTACH
1579
1580    if(proc_->wasCreatedViaAttach() || 
1581       proc_->wasCreatedViaFork() || 
1582       proc_->wasCreatedViaAttachToCreated())
1583    {
1584       startup_cerr << "process::attach() doing PTRACE_ATTACH to " <<get_lwp_id() << endl;
1585       int ptrace_errno = 0;
1586       int address_width = sizeof(Address);
1587       assert(address_width);
1588
1589       if( 0 != DBI_ptrace(PTRACE_ATTACH, getPid(), 0, 0, &ptrace_errno, address_width, __FILE__, __LINE__) )
1590       {
1591          fprintf(stderr, "%s[%d]:  ptrace attach to pid %d failing\n", FILE__, __LINE__, getPid());
1592          perror( "process::attach - PTRACE_ATTACH" );
1593          return false;
1594       }
1595       proc_->sh->add_lwp_to_poll_list(this);
1596
1597 #if defined (arch_ia64)
1598       if (0 > getDBI()->waitpid(getPid(), NULL, 0)) {
1599          perror("process::attach - waitpid");
1600          exit(1);
1601       }
1602 #else
1603       if (0 > waitpid(getPid(), NULL, 0)) {
1604          perror("process::attach - waitpid");
1605          exit(1);
1606       }
1607 #endif
1608    }
1609
1610    if(proc_->wasCreatedViaAttach() )
1611    {
1612       // If the process was running, it will need to be restarted, as
1613       // PTRACE_ATTACH kills it
1614       // Actually, the attach process contructor assumes that the process is
1615       // running.  While this is foolish, let's play along for now.
1616       if( proc_->status() != running || !proc_->isRunning_() ) {
1617          int ptrace_errno = 0;
1618          int address_width = sizeof(Address); //proc_->getAddressWidth();
1619          if( 0 != DBI_ptrace(PTRACE_CONT, getPid(), 0, 0, &ptrace_errno, address_width,  __FILE__, __LINE__) )
1620          {
1621             perror( "process::attach - continue 1" );
1622          }
1623       }
1624    }
1625
1626    if(proc_->wasCreatedViaAttachToCreated())
1627    {
1628       // This case is a special situation. The process is stopped
1629       // in the exec() system call but we have not received the first 
1630       // TRAP because it has been caught by another process.
1631       
1632       /* lose race */
1633       sleep(1);
1634       int ptrace_errno = 0; 
1635       /* continue, clearing pending stop */
1636       if (0 > DBI_ptrace(PTRACE_CONT, getPid(), 0, SIGCONT, &ptrace_errno, proc_->getAddressWidth(),  __FILE__, __LINE__)) {
1637          perror("process::attach: PTRACE_CONT 1");
1638          return false;
1639       }
1640      
1641       if (0 > waitpid(getPid(), NULL, 0)) {
1642          perror("process::attach: WAITPID");
1643          return false;
1644       }
1645
1646       /* continue, resending the TRAP to emulate the normal situation*/
1647       if ( 0 > kill(getPid(), SIGTRAP)){
1648          perror("process::attach: KILL");
1649          return false;
1650       }
1651       
1652       if (0 > DBI_ptrace(PTRACE_CONT, getPid(), 0, SIGCONT, &ptrace_errno, proc_->getAddressWidth(),  __FILE__, __LINE__)) {
1653          perror("process::attach: PTRACE_CONT 2");
1654          return false;
1655       }
1656
1657       proc_->set_status(neonatal);
1658    } // end - if createdViaAttachToCreated
1659
1660    return true;
1661 }
1662
1663 #define PREMS_PRIVATE (1 << 4)
1664 #define PREMS_SHARED  (1 << 3)
1665 #define PREMS_READ    (1 << 2)
1666 #define PREMS_WRITE   (1 << 1)
1667 #define PREMS_EXEC    (1 << 0)
1668
1669 typedef struct maps_entries {
1670    Address start;
1671    Address end;
1672    unsigned prems;
1673    Address offset;
1674    int dev_major;
1675    int dev_minor;
1676    int inode;
1677    char path[512];
1678 } map_entries;
1679
1680 #define LINE_LEN 1024
1681 struct maps_entries *getLinuxMaps(int pid, unsigned &maps_size) {
1682    char line[LINE_LEN], prems[16], *s;
1683    int result;
1684    FILE *f;
1685    map_entries *maps;
1686    unsigned i, no_lines = 0;
1687    
1688   
1689    sprintf(line, "/proc/%d/maps", pid);
1690    f = fopen(line, "r");
1691    if (!f)
1692       return NULL;
1693    
1694    //Calc num of entries needed and allocate the buffer.  Assume the 
1695    //process is stopped.
1696    while (!feof(f)) {
1697       fgets(line, LINE_LEN, f);
1698       no_lines++;
1699    }
1700    maps = (map_entries *) malloc(sizeof(map_entries) * (no_lines+1));
1701    if (!maps)
1702       return NULL;
1703    result = fseek(f, 0, SEEK_SET);
1704    if (result == -1)
1705       return NULL;
1706
1707    //Read all of the maps entries
1708    for (i = 0; i < no_lines; i++) {
1709       if (!fgets(line, LINE_LEN, f))
1710          break;
1711       line[LINE_LEN - 1] = '\0';
1712       sscanf(line, "%lx-%lx %16s %lx %x:%x %u %512s\n", 
1713              (Address *) &maps[i].start, (Address *) &maps[i].end, prems, 
1714              (Address *) &maps[i].offset, &maps[i].dev_major,
1715              &maps[i].dev_minor, &maps[i].inode, maps[i].path);
1716       maps[i].prems = 0;
1717       for (s = prems; *s != '\0'; s++) {
1718          switch (*s) {
1719             case 'r':
1720                maps[i].prems |= PREMS_READ;
1721                break;
1722             case 'w':
1723                maps[i].prems |= PREMS_WRITE;
1724                break;
1725             case 'x':
1726                maps[i].prems |= PREMS_EXEC;
1727                break;
1728             case 'p':
1729                maps[i].prems |= PREMS_PRIVATE;
1730                break;
1731             case 's':
1732                maps[i].prems |= PREMS_EXEC;
1733                break;
1734          }
1735       }
1736    }
1737    //Zero out the last entry
1738    memset(&(maps[i]), 0, sizeof(maps_entries));
1739    maps_size = i;
1740    
1741    return maps;
1742 }
1743
1744 // These constants are not defined in all versions of elf.h
1745 #ifndef AT_NULL
1746 #define AT_NULL 0
1747 #endif
1748 #ifndef AT_SYSINFO
1749 #define AT_SYSINFO 32
1750 #endif
1751 #ifndef AT_SYSINFO_EHDR
1752 #define AT_SYSINFO_EHDR 33
1753 #endif
1754 #ifndef PTRACE_GET_THREAD_AREA
1755 #define PTRACE_GET_THREAD_AREA 25
1756 #endif 
1757
1758 static bool couldBeVsyscallPage(map_entries *entry, bool strict, Address pagesize) {
1759    if (strict) {
1760        if (entry->prems != PREMS_PRIVATE)
1761          return false;
1762       if (entry->path[0] != '\0')
1763          return false;
1764       if (((entry->end - entry->start) / pagesize) > 0xf)
1765          return false;
1766    }
1767    if (entry->offset != 0)
1768       return false;
1769    if (entry->dev_major != 0 || entry->dev_minor != 0)
1770       return false;
1771    if (entry->inode != 0)
1772       return false;
1773
1774    return true;
1775 }
1776
1777
1778 bool process::readAuxvInfo()
1779 {
1780   /**
1781    * The location of the vsyscall is stored in /proc/PID/auxv in Linux 2.6.
1782    * auxv consists of a list of name/value pairs, ending with the AT_NULL
1783    * name.  There isn't a direct way to get the vsyscall info on Linux 2.4
1784    **/
1785   char buffer[32];
1786   int fd;
1787   Address dso_start = 0x0, text_start = 0x0;
1788   unsigned page_size = 0x0;
1789   struct {
1790     int type;
1791     Address value;
1792   } auxv_entry;
1793
1794   if (vsys_status_ != vsys_unknown) {
1795      // If we've already found the vsyscall page, just return.
1796      // True if it's used, false if it's not.
1797      return !(vsys_status_ == vsys_unused);
1798   }
1799   
1800   /**
1801    * Try to read from /proc/%d/auxv.  On Linux 2.4 systems auxv
1802    * doesn't exist, which is okay because vsyscall isn't used.
1803    * On latter 2.6 kernels the AT_SYSINFO field isn't present,
1804    * so we have to resort to more "extreme" measures.
1805    **/
1806   sprintf(buffer, "/proc/%d/auxv", getPid());
1807   fd = open(buffer, O_RDONLY);
1808   if (fd != -1) {
1809      //Try to read the location out of /proc/pid/auxv
1810      do {
1811         read(fd, &auxv_entry, sizeof(auxv_entry));
1812         if (auxv_entry.type == AT_SYSINFO)
1813            text_start = auxv_entry.value;
1814         else if (auxv_entry.type == AT_SYSINFO_EHDR)
1815            dso_start = auxv_entry.value;
1816         else if (auxv_entry.type == AT_PAGESZ)
1817            page_size = auxv_entry.value;
1818      } while (auxv_entry.type != AT_NULL);
1819      P_close(fd);
1820   }
1821
1822  /**
1823    * Even if we found dso_start in /proc/pid/auxv, the vsyscall 'page'
1824    * can be larger than a single page.  Thus we look through /proc/pid/maps
1825    * for known, default, or guessed start address(es).
1826    **/
1827   pdvector<Address> guessed_addrs;
1828   
1829   /* The first thing to check is the auxvinfo, if we have any. */
1830   if( dso_start != 0x0 ) { guessed_addrs.push_back( dso_start ); }
1831     
1832  /**
1833    * We'll make several educated attempts at guessing an address
1834    * for the vsyscall page.  After deciding on a guess, we'll try to
1835    * verify that using /proc/pid/maps.
1836    **/
1837
1838 #if defined(arch_x86)
1839   // On x86 we can try to read the vsyscall's entry point out of
1840   // %gs:0x10.  We can use that address to map into /proc/pid/maps
1841   // and find the vsyscall dso.  This seems to work at the moment,
1842   // but I wouldn't be surprised if it breaks some day.
1843   if (!reachedBootstrapState(loadedRT_bs) && dso_start == 0x0) {
1844      //We haven't initialized yet, leave the status set to unknown, 
1845      // so we'll try again latter.
1846      vsys_status_ = vsys_unknown;
1847      return false;
1848   }
1849   pdvector<int_variable *> vars;
1850   Address g_addr;
1851   if (findVarsByAll("DYNINST_sysEntry", vars) && vars.size() > 0) {
1852      readDataSpace((void *) vars[0]->getAddress(), sizeof(Address), 
1853                    &g_addr, false);
1854      if (g_addr)
1855         guessed_addrs.push_back(g_addr);
1856   }
1857 #endif
1858
1859   /**
1860    * Guess some constants that we've seen before.
1861    **/
1862 #if defined(arch_x86) 
1863   guessed_addrs.push_back(0xffffe000); //Many early 2.6 systems
1864   guessed_addrs.push_back(0xffffd000); //RHEL4
1865 #elif defined(arch_ia64)
1866   guessed_addrs.push_back(0xa000000000000000); 
1867   guessed_addrs.push_back(0xa000000000010000); 
1868   guessed_addrs.push_back(0xa000000000020000); //Juniper & Hogan
1869 #endif
1870
1871   /**
1872    * Look through every entry in /proc/maps, and compare it to every 
1873    * entry in guessed_addrs.  If a guessed_addr looks like the right
1874    * thing, then we'll go ahead and call it the vsyscall page.
1875    **/
1876   unsigned num_maps;
1877   maps_entries *secondary_match = NULL;
1878   maps_entries *maps = getLinuxMaps(getPid(), num_maps);
1879   for (unsigned i=0; i<guessed_addrs.size(); i++) {
1880      Address addr = guessed_addrs[i];
1881      for (unsigned j=0; j<num_maps; j++) {
1882         map_entries *entry = &(maps[j]);
1883         if (addr < entry->start || addr >= entry->end)
1884            continue;
1885
1886         if (couldBeVsyscallPage(entry, true, page_size)) {
1887            //We found a possible page using a strict check. 
1888            // This is really likely to be it.
1889            vsyscall_start_ = entry->start;
1890            vsyscall_end_ = entry->end;
1891            vsyscall_text_ = 0x0;
1892            vsys_status_ = vsys_found;
1893            free(maps);
1894            return true;
1895         }
1896
1897         if (!couldBeVsyscallPage(entry, false, page_size)) {
1898            //We found an entry that loosely looks like the
1899            // vsyscall page.  Let's hang onto this and return 
1900            // it if we find nothing else.
1901            secondary_match = entry;
1902         }
1903      }  
1904   }
1905
1906   /**
1907    * There were no hits using our guessed_addrs scheme.  Let's
1908    * try to look at every entry in the maps table (not just the 
1909    * guessed addresses), and see if any of those look like a vsyscall page.
1910    **/
1911   for (unsigned i=0; i<num_maps; i++) {
1912      if (couldBeVsyscallPage(&(maps[i]), true, page_size)) {
1913         vsyscall_start_ = maps[i].start;
1914         vsyscall_end_ = maps[i].end;
1915         vsyscall_text_ = 0x0;
1916         vsys_status_ = vsys_found;
1917         free(maps);
1918         return true;
1919      }
1920   }
1921
1922   /**
1923    * Return any secondary possiblitiy pages we found in our earlier search.
1924    **/
1925   if (secondary_match) {
1926      vsyscall_start_ = secondary_match->start;
1927      vsyscall_end_ = secondary_match->end;
1928      vsyscall_text_ = 0x0;
1929      vsys_status_ = vsys_found;
1930      free(maps);
1931      return true;
1932   }
1933
1934   /**
1935    * Time to give up.  Sigh.
1936    **/
1937   vsys_status_ = vsys_notfound;
1938   free(maps);
1939   return false;
1940 }
1941
1942 void loadNativeDemangler() {}
1943
1944 const unsigned int N_DYNINST_LOAD_HIJACK_FUNCTIONS = 4;
1945 const char DYNINST_LOAD_HIJACK_FUNCTIONS[][20] = {
1946   "__libc_start_main",
1947   "_init",
1948   "_start",
1949   "main"
1950 };
1951
1952 /**
1953  * Returns an address that we can use to write the code that executes
1954  * dlopen on the runtime library.
1955  *
1956  * Inserting the code into libc is a good thing, since _dl_open
1957  * will sometimes check it's caller and return with a 'invalid caller'
1958  * error if it's called from the application.
1959  **/
1960 Address findFunctionToHijack(process *p) 
1961 {
1962    Address codeBase;
1963    unsigned i;
1964    for(i = 0; i < N_DYNINST_LOAD_HIJACK_FUNCTIONS; i++ ) {
1965       const char *func_name = DYNINST_LOAD_HIJACK_FUNCTIONS[i];
1966
1967       pdvector<int_function *> hijacks;
1968       if (!p->findFuncsByAll(func_name, hijacks))
1969           return 0;
1970       codeBase = hijacks[0]->getAddress();
1971
1972       if (codeBase)
1973           break;
1974    }
1975    
1976   return codeBase;
1977 } /* end findFunctionToHijack() */
1978
1979 /**
1980  * Searches for function in order, with preference given first 
1981  * to libpthread, then to libc, then to the process.
1982  **/
1983 static void findThreadFuncs(process *p, pdstring func, 
1984                             pdvector<int_function *> &result)
1985 {
1986    bool found = false;
1987    mapped_module *lpthread = p->findModule("libpthread*", true);
1988    if (lpthread)
1989       found = lpthread->findFuncVectorByPretty(func, result);
1990    if (found)
1991       return;
1992
1993    mapped_module *lc = p->findModule("libc.so*", true);
1994    if (lc)
1995       found = lc->findFuncVectorByPretty(func, result);
1996    if (found)
1997       return;
1998    
1999    p->findFuncsByPretty(func, result);
2000 }
2001
2002 bool process::initMT()
2003 {
2004    unsigned i;
2005    bool res;
2006
2007 #if !defined(cap_threads)
2008    return true;
2009 #endif
2010
2011    /**
2012     * Instrument thread_create with calls to DYNINST_dummy_create
2013     **/
2014    //Find create_thread
2015    pdvector<int_function *> thread_init_funcs;
2016    findThreadFuncs(this, "create_thread", thread_init_funcs);
2017    findThreadFuncs(this, "start_thread", thread_init_funcs);
2018    if (thread_init_funcs.size() < 1)
2019    {
2020       fprintf(stderr, "[%s:%d] - Found no copies of create_thread, expected 1\n",
2021               __FILE__, __LINE__);
2022       return false;
2023    }
2024    //Find DYNINST_dummy_create
2025    int_function *dummy_create = findOnlyOneFunction("DYNINST_dummy_create");
2026    if (!dummy_create)
2027    {
2028      fprintf(stderr, "[%s:%d] - Couldn't find DYNINST_dummy_create",
2029              __FILE__, __LINE__);
2030       return false;
2031    }
2032    //Instrument
2033    for (i=0; i<thread_init_funcs.size(); i++)
2034    {
2035       pdvector<AstNode *> args;
2036       AstNode call_dummy_create(dummy_create, args);
2037       AstNode *ast = &call_dummy_create;
2038       const pdvector<instPoint *> &ips = thread_init_funcs[i]->funcEntries();
2039       for (unsigned j=0; j<ips.size(); j++)
2040       {
2041          miniTramp *mt;
2042          mt = ips[j]->instrument(ast, callPreInsn, orderFirstAtPoint, false, 
2043                                  false);
2044          if (!mt)
2045          {
2046             fprintf(stderr, "[%s:%d] - Couldn't instrument thread_create\n",
2047                     __FILE__, __LINE__);
2048          }
2049          //TODO: Save the mt objects for detach
2050       }
2051    }
2052 #if 0
2053       /*
2054    //Find functions that are run on pthread exit
2055    pdvector<int_function *> thread_dest_funcs;
2056    findThreadFuncs(this, "__pthread_do_exit", &thread_dest_funcs);
2057    findThreadFuncs(this, "pthread_exit", &thread_dest_funcs);
2058    findThreadFuncs(this, "deallocate_tsd", &thread_dest_funcs);
2059    if (!thread_dest_funcs.size())
2060    {
2061       fprintf(stderr,"[%s:%d] - Found 0 copies of pthread_exit, expected 1\n",
2062               __FILE__, __LINE__);
2063       return false;
2064    }
2065    //Find DYNINSTthreadDestroy
2066    int_function *threadDestroy = findOnlyOneFunction("DYNINSTthreadDestroy");
2067    if (!threadDestroy)
2068    {
2069       fprintf(stderr, "[%s:%d] - Couldn't find DYNINSTthreadDestroy",
2070               __FILE__, __LINE__);
2071       return false;
2072    }
2073    //Instrument
2074    for (i=0; i<thread_dest_funcs.size(); i++)
2075    {
2076       pdvector<AstNode *> args;
2077       AstNode call_thread_destroy(threadDestroy, args);
2078       AstNode *ast = &call_thread_destroy;
2079       miniTrampHandle *mthandle;
2080       instPoint *ip = thread_dest_funcs[i]->funcEntry(this);
2081
2082       result = addInstFunc(this, mthandle, ip, ast, callPostInsn, 
2083                            orderFirstAtPoint, true, true, true);
2084       if (result != success_res)
2085       {
2086          fprintf(stderr, "[%s:%d] - Couldn't instrument thread_destroy\n",
2087                  __FILE__, __LINE__);
2088       }
2089    }
2090       */
2091 #endif
2092    /**
2093     * Have dyn_pthread_self call the actual pthread_self
2094     **/
2095    //Find dyn_pthread_self
2096    pdvector<int_variable *> ptself_syms;
2097    res = findVarsByAll("DYNINST_pthread_self", ptself_syms);
2098    if (!res)
2099    {
2100       fprintf(stderr, "[%s:%d] - Couldn't find any dyn_pthread_self, expected 1\n",
2101               __FILE__, __LINE__);
2102    }
2103    assert(ptself_syms.size() == 1);
2104    Address dyn_pthread_self = ptself_syms[0]->getAddress();
2105    //Find pthread_self
2106    pdvector<int_function *> pthread_self_funcs;
2107    findThreadFuncs(this, "pthread_self", pthread_self_funcs);   
2108    if (pthread_self_funcs.size() != 1)
2109    {
2110       fprintf(stderr, "[%s:%d] - Found %d pthread_self functions, expected 1\n",
2111               __FILE__, __LINE__, pthread_self_funcs.size());
2112       for (unsigned j=0; j<pthread_self_funcs.size(); j++)
2113       {
2114          int_function *ps = pthread_self_funcs[j];
2115          fprintf(stderr, "[%s:%u] - %s in module %s at %lx\n", __FILE__, __LINE__,
2116                  ps->prettyName().c_str(), ps->mod()->fullName().c_str(), 
2117                  ps->getAddress());
2118       }
2119       return false;
2120    }   
2121    //Replace
2122    res = writeFunctionPtr(this, dyn_pthread_self, pthread_self_funcs[0]);
2123    if (!res)
2124    {
2125       fprintf(stderr, "[%s:%d] - Couldn't update dyn_pthread_self\n",
2126               __FILE__, __LINE__);
2127       return false;
2128    }
2129    return true;
2130 }
2131
2132 void dyninst_yield()
2133 {
2134    pthread_yield();
2135 }
2136
2137 Address dyn_lwp::step_next_insn() {
2138    int result;
2139    if (status() != stopped) {
2140       fprintf(stderr, "[%s:%u] - Internal Error.  lwp wasn't stopped\n",
2141               __FILE__, __LINE__);
2142       return (Address) -1;
2143    }
2144    
2145    singleStepping = true;
2146    proc()->set_lwp_status(this, running);
2147    result = DBI_ptrace(PTRACE_SINGLESTEP, get_lwp_id(), 0x0, 0x0);
2148    if (result == -1) {
2149       perror("Couldn't PTRACE_SINGLESTEP");
2150       return (Address) -1;
2151    }
2152
2153    do {
2154       if(proc()->hasExited()) 
2155          return (Address) -1;
2156       proc()->sh->waitForEvent(evtDebugStep);
2157    } while (singleStepping);
2158
2159    return getActiveFrame().getPC();
2160 }