mods/additions largely under the USE_STL_VECTOR and IBM_BPATCH_COMPAT flags
[dyninst.git] / dyninstAPI / src / linux.C
1 /*
2  * Copyright (c) 1996 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.64 2002/03/19 22:57:20 jaw Exp $
43
44 #include <fstream.h>
45
46 #include "dyninstAPI/src/process.h"
47
48 #include <sys/ptrace.h>
49 #include <asm/ptrace.h>
50 #include <sys/ioctl.h>
51 #include <fcntl.h>
52 #include <dlfcn.h>
53 #include <sys/user.h>
54 #include <sys/time.h>
55 #include <sys/resource.h>
56 #include <math.h> // for floor()
57 #include <unistd.h> // for sysconf()
58
59 #include "dyninstAPI/src/symtab.h"
60 #include "dyninstAPI/src/instPoint.h"
61 #include "common/h/headers.h"
62 #include "dyninstAPI/src/os.h"
63 #include "dyninstAPI/src/stats.h"
64 #include "common/h/Types.h"
65 #include "dyninstAPI/src/showerror.h"
66 #include "dyninstAPI/src/util.h" // getCurrWallTime
67 #include "common/h/pathName.h"
68 #include "dyninstAPI/src/inst-x86.h"
69 #ifndef BPATCH_LIBRARY
70 #include "common/h/Time.h"
71 #include "common/h/timing.h"
72 #include "paradynd/src/init.h"
73 #endif
74
75 #if defined(BPATCH_LIBRARY)
76 #include "dyninstAPI/src/addLibraryLinux.h"
77 #include "dyninstAPI/src/writeBackElf.h"
78 #include "saveSharedLibrary.h" 
79
80 #endif
81
82 #ifdef HRTIME
83 #include "rtinst/h/RThwtimer-linux.h"
84 #endif
85
86 #define DLOPEN_MODE (RTLD_NOW | RTLD_GLOBAL)
87
88 // The following were defined in process.C
89 extern debug_ostream attach_cerr;
90 extern debug_ostream inferiorrpc_cerr;
91 extern debug_ostream shmsample_cerr;
92 extern debug_ostream forkexec_cerr;
93 extern debug_ostream signal_cerr;
94
95 extern bool isValidAddress(process *proc, Address where);
96 extern void generateBreakPoint(instruction &insn);
97
98
99 const char DYNINST_LOAD_HIJACK_FUNCTIONS[][15] = {
100   "main",
101   "_init",
102   "_start"
103 };
104 const int N_DYNINST_LOAD_HIJACK_FUNCTIONS = 3;
105
106 const char DL_OPEN_FUNC_NAME[] = "_dl_open";
107
108 const char libc_version_symname[] = "__libc_version";
109
110
111 #if defined(PTRACEDEBUG) && !defined(PTRACEDEBUG_ALWAYS)
112 static bool debug_ptrace = false;
113 #endif
114
115 #ifndef _SYS_USER_H
116 struct user_regs_struct
117 {
118   long ebx;
119   long ecx;
120   long edx;
121   long esi;
122   long edi;
123   long ebp;
124   long eax;
125   long xds;
126   long xes;
127   long xfs;
128   long xgs;
129   long orig_eax;
130   long eip;
131   long xcs;
132   long eflags;
133   long esp;
134   long xss;
135 };
136 #endif
137
138 static int regmap[] = 
139 {
140     EBX, ECX, EDX, ESI,
141     EDI, EBP, EAX, DS,
142     ES, FS, GS, ORIG_EAX,
143     EIP, CS, EFL, UESP,
144     SS
145 /*
146   EAX, ECX, EDX, EBX,
147   UESP, EBP, ESI, EDI,
148   EIP, EFL, CS, SS,
149   DS, ES, FS, GS,
150   ORIG_EAX
151 */
152 };
153
154 #define NUM_REGS (17 /*+ NUM_FREGS*/)
155 #define NUM_FREGS 8
156 #define FP0_REGNUM NUM_REGS
157 #define FP7_REGNUM (FP0_REGNUM+7)
158 #define INTREGSIZE (sizeof(int))
159 #define FPREGSIZE 10
160 #define MAX_REGISTER_RAW_SIZE 10
161
162 #define REGISTER_RAW_SIZE(N) (((N) < FP0_REGNUM) ? INTREGSIZE : FPREGSIZE)
163 #define REGS_SIZE ( NUM_REGS * REGISTER_RAW_SIZE(0) + NUM_FREGS * REGISTER_RAW_SIZE(FP0_REGNUM) )
164 #define REGS_INTS ( REGS_SIZE / INTREGSIZE )
165
166 const int GENREGS_STRUCT_SIZE = sizeof( user_regs_struct );
167 #ifdef _SYS_USER_H 
168 const int FPREGS_STRUCT_SIZE = sizeof( user_fpregs_struct );
169 #else
170 const int FPREGS_STRUCT_SIZE = sizeof( user_i387_struct );
171 #endif
172
173 int register_addr (int regno )
174 {
175   int addr;
176
177   if ( (regno < 0 || regno >= NUM_REGS)
178        && (regno < FP0_REGNUM || regno > FP7_REGNUM) )
179     {
180       fprintf ( stderr, "Invalid register number %d.", regno);
181       assert(0);
182       return -1;
183     }
184
185   if (regno >= FP0_REGNUM && regno <= FP7_REGNUM) 
186     {
187       int fpstate;
188       struct user *u = NULL;
189       fpstate = (int)(&u->i387.st_space);
190       addr = fpstate + 10 * (regno - FP0_REGNUM);
191     }
192   else
193     addr = INTREGSIZE * regmap[regno];
194
195   return addr;
196 }
197
198 class ptraceKludge {
199 private:
200   static bool haltProcess(process *p);
201   static void continueProcess(process *p, const bool halted);
202
203 public:
204   static bool deliverPtrace(process *p, int req, int addr, int data);
205   static int deliverPtraceReturn(process *p, int req, int addr, int data);
206 };
207
208 bool ptraceKludge::haltProcess(process *p) {
209   bool wasStopped = (p->status() == stopped);
210   if (p->status() != neonatal && !wasStopped) {
211     if (!p->loopUntilStopped()) {
212       cerr << "error in loopUntilStopped\n";
213       assert(0);
214     }
215   }  return wasStopped;
216 }
217
218 void ptraceKludge::continueProcess(process *p, const bool wasStopped) {
219   // First handle the cases where we shouldn't issue a PTRACE_CONT:
220   if (p->status() == neonatal) return;
221   if (wasStopped) return;
222
223   // Choose either one of the following methods to continue a process.
224   // The choice must be consistent with that in process::continueProc_ and stop_
225
226 #ifndef PTRACE_ATTACH_DETACH
227   if (P_ptrace(PTRACE_CONT, p->pid, 1, SIGCONT) == -1) {
228 #else
229   if (P_ptrace(PTRACE_DETACH, p->pid, 1, SIGCONT) == -1) {
230 #endif
231       perror("error in continueProcess");
232       assert(0);
233   }
234 }
235
236 bool ptraceKludge::deliverPtrace(process *p, int req, int addr,
237                                  int data ) {
238   bool halted = true;
239
240 //  if (req != PTRACE_DETACH)
241      halted = haltProcess(p);
242
243   bool ret = (P_ptrace(req, p->getPid(), addr, data) != -1);
244
245 //  if (req != PTRACE_DETACH)
246      continueProcess(p, halted);
247
248   return ret;
249 }
250
251
252 // Some ptrace requests in Linux return the value rather than storing at the address in data
253 // (especially PEEK requests)
254 // - nash
255 int ptraceKludge::deliverPtraceReturn(process *p, int req, int addr,
256                                  int data ) {
257 #ifdef DETACH_ON_THE_FLY
258   bool detached = p->haveDetached;
259   if (detached) {
260        p->reattach();
261   }
262   int ret = P_ptrace(req, p->getPid(), addr, data);
263   if (detached) {
264        p->detach();
265   }
266   return ret;
267 #else
268   bool halted = true;
269
270   if (req != PTRACE_DETACH)
271      halted = haltProcess(p);
272
273   int ret = P_ptrace(req, p->getPid(), addr, data);
274
275   if (req != PTRACE_DETACH)
276      continueProcess(p, halted);
277
278   return ret;
279 #endif
280 }
281
282 /* ********************************************************************** */
283
284 void *process::getRegisters() {
285    // assumes the process is stopped (ptrace requires it)
286    assert(status_ == stopped);
287
288    // Cycle through all registers, reading each from the
289    // process user space with ptrace(PTRACE_PEEKUSER ...
290
291    char *buf = new char [ GENREGS_STRUCT_SIZE + FPREGS_STRUCT_SIZE ];
292    int error;
293    bool errorFlag = false;
294    error = P_ptrace( PTRACE_GETREGS, pid, 0, (int)(buf) );
295    if( error ) {
296        perror("process::getRegisters PTRACE_GETREGS" );
297        errorFlag = true;
298    } else {
299        error = P_ptrace( PTRACE_GETFPREGS, pid, 0, (int)(buf + GENREGS_STRUCT_SIZE) );
300        if( error ) {
301            perror("process::getRegisters PTRACE_GETFPREGS" );
302            errorFlag = true;
303        }
304    }
305
306    if( errorFlag )
307        return NULL;
308    else
309        return (void*)buf;
310 }
311
312 static bool changePC(int pid, Address loc) {
313   Address regaddr = EIP * INTREGSIZE;
314   if (0 != P_ptrace (PTRACE_POKEUSER, pid, regaddr, loc )) {
315     perror( "process::changePC - PTRACE_POKEUSER" );
316     return false;
317   }
318
319   return true;
320 }
321
322 static bool changeBP(int pid, Address loc) {
323   Address regaddr = EBP * INTREGSIZE;
324   if (0 != P_ptrace (PTRACE_POKEUSER, pid, regaddr, loc )) {
325     perror( "process::changeBP - PTRACE_POKEUSER" );
326     return false;
327   }
328
329   return true;
330 }
331
332 void printStackWalk( process *p ) {
333         Frame theFrame(p);
334         while (true) {
335                 // do we have a match?
336                 const Address framePC = theFrame.getPC();
337                 inferiorrpc_cerr << "stack frame pc @ " << (void*)framePC << endl;
338                 
339                 if (theFrame.isLastFrame())
340                         // well, we've gone as far as we can, with no match.
341                         break;
342                 
343                 // else, backtrace 1 more level
344                 theFrame = theFrame.getCallerFrame(p);
345         }
346 }
347  
348 void printRegs( void *save ) {
349         user_regs_struct *regs = (user_regs_struct*)save;
350         cerr
351                 << " eax: " << (void*)regs->eax
352                 << " ebx: " << (void*)regs->ebx
353                 << " ecx: " << (void*)regs->ecx
354                 << " edx: " << (void*)regs->edx << endl
355                 << " edi: " << (void*)regs->edi
356                 << " esi: " << (void*)regs->esi << endl
357                 << " xcs: " << (void*)regs->xcs
358                 << " xds: " << (void*)regs->xds
359                 << " xes: " << (void*)regs->xes
360                 << " xfs: " << (void*)regs->xfs
361                 << " xgs: " << (void*)regs->xgs
362                 << " xss: " << (void*)regs->xss << endl
363                 << " eip: " << (void*)regs->eip
364                 << " esp: " << (void*)regs->esp
365                 << " ebp: " << (void*)regs->ebp << endl
366                 << " orig_eax: " << (void*)regs->orig_eax
367                 << " eflags: " << (void*)regs->eflags << endl;
368 }
369
370 bool process::executingSystemCall() {
371         // From the program strace, it appears that a non-negative number
372         // in the ORIG_EAX register of the inferior process indicates
373         // that it is in a system call, and is the number of the system
374         // call. - nash
375
376         Address regaddr = ORIG_EAX * INTREGSIZE;
377         int res;
378         res = P_ptrace ( PTRACE_PEEKUSER, getPid(), regaddr, 0 );
379         if( res < 0 )
380                 return false;
381
382         inferiorrpc_cerr << "In system call #" << res << " @ " << (void*)getPC( getPid() ) << endl;
383
384         return true;
385 }
386
387 bool process::changePC(Address loc, const void * /* savedRegs */ ) {
388   assert(status_ == stopped);
389
390   return ::changePC(pid, loc);
391 }
392
393 bool process::changePC(Address loc) {
394   assert(status_ == stopped);
395
396   return ::changePC(pid, loc);
397 }
398
399
400 bool process::restoreRegisters(void *buffer) {
401    // assumes the process is stopped (ptrace requires it)
402    assert(status_ == stopped);
403
404    // Cycle through all registers, writing each from the
405    // buffer with ptrace(PTRACE_POKEUSER ...
406
407    char *buf = (char*)buffer;
408    bool retVal = true;
409
410    if( P_ptrace( PTRACE_SETREGS, pid, 0, (int)(buf) ) )
411    {
412        perror("process::restoreRegisters PTRACE_SETREGS" );
413        retVal = false;
414    }
415
416    if( P_ptrace( PTRACE_SETFPREGS, pid, 0, (int)(buf + GENREGS_STRUCT_SIZE) ) )
417    {
418        perror("process::restoreRegisters PTRACE_SETFPREGS" );
419        retVal = false;
420    }
421
422    return retVal;
423 }
424
425 // getActiveFrame(): populate Frame object using toplevel frame
426 void Frame::getActiveFrame(process *p)
427 {
428   fp_ = ptraceKludge::deliverPtraceReturn(p, PTRACE_PEEKUSER, 0 + EBP * INTREGSIZE, 0);
429   if (errno) return;
430
431   pc_ = ptraceKludge::deliverPtraceReturn(p, PTRACE_PEEKUSER, 0 + EIP * INTREGSIZE, 0);
432   if (errno) return;
433 }
434
435 // TODO: implement this
436 bool process::needToAddALeafFrame(Frame,Address &){
437     return false;
438 }
439
440 // already setup on this FD.
441 // disconnect from controlling terminal 
442 void OS::osDisconnect(void) {
443   int ttyfd = open ("/dev/tty", O_RDONLY);
444   ioctl (ttyfd, TIOCNOTTY, NULL);
445   P_close (ttyfd);
446 }
447
448 bool process::stop_() {
449 #ifdef DETACH_ON_THE_FLY
450      if (haveDetached)
451           return reattach(); /* will stop the process */
452 #endif
453      return (P_kill(getPid(), SIGSTOP) != -1); 
454 }
455
456 bool process::continueWithForwardSignal(int sig) {
457    // formerly OS::osForwardSignal
458    return (P_ptrace(PTRACE_CONT, pid, 1, sig) != -1);
459 }
460
461 void OS::osTraceMe(void) { P_ptrace(PTRACE_TRACEME, 0, 0, 0); }
462
463 process *findProcess(int);  // In process.C
464
465 Address getPC(int pid) {
466    Address regaddr = EIP * INTREGSIZE;
467    int res;
468    res = P_ptrace (PTRACE_PEEKUSER, pid, regaddr, 0);
469    if( errno ) {
470      perror( "getPC" );
471      exit(-1);
472      return 0; // Shut up the compiler
473    } else {
474      assert(res);
475      return (Address)res;
476    }   
477 }
478
479 #ifdef DETACH_ON_THE_FLY
480 /* Input P points to a buffer containing the contents of
481    /proc/PID/stat.  This buffer will be modified.  Output STATUS is
482    the status field (field 3), and output SIGPEND is the pending
483    signals field (field 31).  As of Linux 2.2, the format of this file
484    is defined in /usr/src/linux/fs/proc/array.c (get_stat). */
485 static void
486 parse_procstat(char *p, char *status, unsigned long *sigpend)
487 {
488      int i;
489
490      /* Advance past pid and program name */
491      p = strchr(p, ')');
492      assert(p);
493
494      /* Advance to status character */
495      p += 2;
496      *status = *p;
497
498      /* Advance to sigpending int */
499      p = strtok(p, " ");
500      assert(p);
501      for (i = 0; i < 28; i++) {
502           p = strtok(NULL, " ");
503           assert(p);
504      }
505      *sigpend = strtoul(p, NULL, 10);
506 }
507
508
509 /* The purpose of this is to synchronize with the sigill handler in
510    the inferior.  In this handler, the inferior signals us (SIG33),
511    and then it stops itself.  This routine does not return until the
512    inferior stop has occurred.  In some contexts, the inferior may be
513    acquire a pending SIGSTOP as or after it stops.  We clear the
514    pending the SIGSTOP here, so the process doesn't inadvertently stop
515    when we continue it later.
516
517    We don't understand how the pending SIGSTOP is acquired.  It seems
518    to have something to do with the process sending itself the SIGILL
519    (i.e., kill(getpid(),SIGILL)).  */
520 static void
521 waitForInferiorSigillStop(int pid)
522 {
523      int fd;
524      char name[32];
525      char buf[512];
526      char status;
527      unsigned long sigpend;
528
529      sprintf(name, "/proc/%d/stat", pid);
530
531      /* Keep checking the process until it is stopped */
532      while (1) {
533           /* Read current contents of /proc/pid/stat */
534           fd = open(name, O_RDONLY);
535           assert(fd >= 0);
536           assert(read(fd, buf, sizeof(buf)) > 0);
537           close(fd);
538
539           /* Parse status and pending signals */
540           parse_procstat(buf, &status, &sigpend);
541
542           /* status == T iff the process is stopped */
543           if (status != 'T')
544                continue;
545           /* This is true iff SIGSTOP is set in sigpend */
546           if (0x1 & (sigpend >> (SIGSTOP-1))) {
547                /* The process is stopped, but it has another SIGSTOP
548                   pending.  Continue the process to clear the SIGSTOP
549                   (the process will stop again immediately). */
550                P_ptrace(PTRACE_CONT, pid, 0, 0);
551                if (0 > waitpid(pid, NULL, 0))
552                     perror("waitpid");
553                continue; /* repeat to be sure we've stopped */
554           }
555
556           /* The process is stopped properly */
557           break;
558      }
559 }
560
561 /* When a detached mutatee needs us to reattach and handle an event,
562    it sends itself a SIGILL.  Its SIGILL handler in turn sends us
563    SIG33, which brings us here.  Here we reattach to the process and
564    then help it re-execute the code that caused its SIGILL.  Having
565    reattached, we receive the new SIGILL event and dispatch it as
566    usual (in handleSigChild). */
567 static void sigill_handler(int sig, siginfo_t *si, void *unused)
568 {
569      process *p;
570
571      unused = 0; /* Suppress compiler warning of unused parameter */
572
573      assert(sig == 33);
574      /* Determine the process that sent the signal.  On Linux (at
575         least upto 2.2), we can only obtain this with the real-time
576         signals, those numbered 33 or higher. */
577      p = findProcess(si->si_pid);
578      if (!p) {
579           fprintf(stderr, "Received SIGILL sent by unregistered or non-inferior process\n");
580           assert(0);
581      }
582
583      /* Synchronize with the SIGSTOP sent by inferior sigill handler */
584      waitForInferiorSigillStop(p->getPid());
585
586      /* Reattach, which will leave a pending SIGSTOP. */
587      p->reattach();
588      if (! p->isRunningRPC())
589           /* If we got this signal when the inferior was not in an RPC,
590              then we need to reattach after we handle it.
591              FIXME: Why have we released the process for RPCs anyway? */
592           p->needsDetach = true;
593
594      /* Resume the process.  We expect it to re-execute the code that
595         generated the SIGILL.  Now that we are attached, we'll get the
596         SIGILL event and handle it with handleSigChild as usual. */
597      /* clear pending stop left by reattach */
598      P_ptrace(PTRACE_CONT, p->getPid(), 0, 0);
599      if (0 > waitpid(p->getPid(), NULL, 0))
600              perror("waitpid");
601      if (!p->continueProc())
602           assert(0);
603 }
604
605 void initDetachOnTheFly()
606 {
607      struct sigaction act;
608      act.sa_handler = NULL;
609      act.sa_sigaction = sigill_handler;
610      sigemptyset(&act.sa_mask);
611      act.sa_flags = SA_SIGINFO;
612      /* We need siginfo values to determine the pid of the signal
613         sender.  Linux 2.2, bless its open-sourced little heart, does
614         not provide siginfo values for non-realtime (<= 32) signals,
615         although it will let you register a siginfo handler for them.
616         There are apparently no predefined names for the realtime
617         signals so we just use their integer value. */
618      if (0 > sigaction(33, &act, NULL)) {
619           perror("SIG33 sigaction");
620           assert(0);
621      }
622 }
623
624 /* Returns true if we are detached from process PID.  This is global
625    (not a process member) because we need to call it from P_ptrace,
626    which does not know about process objects. */
627 bool haveDetachedFromProcess(int pid)
628 {
629      /* This can be called before a process is initialized.  If we
630         don't find a process for PID, we assume it hasn't been
631         initialized yet, and thus we have not ever detached from it. */
632      process *p = findProcess(pid);
633      if (! p)
634           return false;
635      return p->haveDetached;
636 }
637
638
639 /* The following two routines block SIG33 to prevent themselves from
640    being reentered. */
641 int process::detach()
642 {
643      int res, ret;
644      sigset_t tmp, old;
645
646      ret = 0;
647      sigemptyset(&tmp);
648      sigaddset(&tmp, 33);
649      sigprocmask(SIG_BLOCK, &tmp, &old);
650
651 #if 0
652      fprintf(stderr, "DEBUG: detach ENTRY\n");
653 #endif
654
655      if (this->haveDetached) {
656           /* It is safe to call this when already detached.  Silently
657              ignore the call.  But the caller really ought to know
658              better. */
659           goto out;
660      }
661      if (this->pendingSig) {
662           res = P_ptrace(PTRACE_DETACH, pid, 0, this->pendingSig);
663           assert(res >= 0);
664           this->pendingSig = 0;
665      } else {
666           res = P_ptrace(PTRACE_DETACH, pid, 0, 0);
667           assert(res >= 0);
668      }
669      this->haveDetached = true;
670      this->juststopped = false;
671      this->needsDetach = false;
672      this->status_ = running;
673      ret = 1;
674 out:
675 #if 0
676      fprintf(stderr, "DEBUG: detach EXIT (%s)\n", ret == 1 ? "success" : "failure");
677 #endif
678      sigprocmask(SIG_SETMASK, &old, NULL);
679      return ret;
680 }
681
682 int process::reattach()
683 {
684      int res, ret;
685      sigset_t tmp, old;
686
687      ret = 0;
688      sigemptyset(&tmp);
689      sigaddset(&tmp, 33);
690      sigprocmask(SIG_BLOCK, &tmp, &old);
691
692 #if 0
693      fprintf(stderr, "DEBUG: reattach ENTRY\n");
694 #endif
695      if (! this->haveDetached) {
696           /* It is safe to call this when already attached.  Silently
697              ignore the call.  But the caller really ought to know
698              better. */
699           goto out;
700      }
701
702      /* Here we attach to the process and call waitpid to process the
703         associated stop event.  The process may be about to handle a
704         trap, in which case waitpid will indicate a SIGTRAP.  We
705         detach and reattach to clear this event, but we'll resend
706         SIGTRAP when we detach. */
707      while (1) {
708           int stat;
709           res = P_ptrace(PTRACE_ATTACH, pid, 0, 0);
710           assert(res >= 0);
711           res = waitpid(pid, &stat, 0);
712           assert(res >= 0);
713           if (WIFSTOPPED(stat) && WSTOPSIG(stat) != SIGSTOP) {
714                assert(!this->pendingSig);
715                assert(WSTOPSIG(stat) == SIGTRAP); /* We only expect traps */
716                this->pendingSig = SIGTRAP;
717                ret = P_ptrace(PTRACE_DETACH, pid, 0, 0);
718                continue;
719           }
720           break;
721      }
722
723      this->haveDetached = 0;
724      this->juststopped = true;
725      this->status_ = stopped;
726      ret = 1;
727 out:
728 #if 0
729      fprintf(stderr, "DEBUG: reattach EXIT (%s)\n", ret == 1 ? "success" : "failure");
730 #endif
731      sigprocmask(SIG_SETMASK, &old, NULL);
732      return ret;
733 }
734
735 /* This method replaces continueProc. */
736 int process::detachAndContinue()
737 {
738      int ret = false;
739
740 #ifndef BPATCH_LIBRARY
741      timeStamp notValidSentinal = timeStamp::ts1800();
742      timeStamp initialStartTime;
743 #endif
744
745      if (status_ == exited)
746           goto out;
747
748      if (status_ != stopped && status_ != neonatal) {
749           sprintf(errorLine, "Internal error: "
750                   "Unexpected process state %d in process::contineProc",
751                   (int)status_);
752           showErrorCallback(39, errorLine);
753           goto out;
754      }
755      
756 #ifndef BPATCH_LIBRARY
757      initialStartTime = getWallTime();
758 #endif
759      // Vic says continuing is a side effect of detaching
760      if (! this->detach()) {
761           showErrorCallback(38, "System error: can't continue process");
762 #ifndef BPATCH_LIBRARY
763           initialStartTime = notValidSentinal;
764 #endif
765           goto out;
766      }
767
768      ret = true;
769      status_ = running;
770 out:
771 #ifndef BPATCH_LIBRARY
772      if(callBeforeContinue != NULL && 
773         initialStartTime.isInitialized() && 
774         initialStartTime != notValidSentinal) {
775        (*callBeforeContinue)(initialStartTime);
776      }
777 #endif
778      return ret;
779 }
780
781 /* This method replaces pause. */
782 int process::reattachAndPause()
783 {
784      this->reattach();
785      return this->pause();
786 }
787 #endif /* DETACH_ON_THE_FLY */
788
789 // wait for a process to terminate or stop
790 // We only want to catch SIGSTOP and SIGILL
791 #ifdef BPATCH_LIBRARY
792 int process::waitProcs(int *status, bool block) {
793   int options = 0;
794   if( !block )
795     options |= WNOHANG;
796 #else
797 int process::waitProcs(int *status) {
798   int options = WNOHANG;
799 #endif
800   int result = 0, sig = 0;
801   bool ignore;
802
803        do {
804             ignore = false;
805             result = waitpid( -1, status, options );
806             
807             // Check for TRAP at the end of a syscall, then
808             // if the signal's not SIGSTOP or SIGILL,
809             // send the signal back and wait for another.
810             if( result > 0 && WIFSTOPPED(*status) ) {
811                  process *p = findProcess( result );
812                  sig = WSTOPSIG(*status);
813                  if( sig == SIGTRAP && ( !p->reachedVeryFirstTrap || p->inExec ) )
814                       ; // Report it
815                  else if( sig != SIGSTOP && sig != SIGILL ) {
816                         ignore = true;
817                         if( sig != SIGTRAP )
818                         {
819 //#ifdef notdef
820                              Address pc;
821                              pc = getPC( result );
822                              signal_cerr << "process::waitProcs -- Signal #" << sig << " in " << result << "@" << (void*)pc << ", resignalling the process" << endl;
823 //#endif
824                         }
825                         if( P_ptrace(PTRACE_CONT, result, 1, sig) == -1 ) {
826                              if( errno == ESRCH ) {
827                                   cerr << "WARNING -- process does not exist, constructing exit code" << endl;
828                                   *status = W_EXITCODE(0,sig);
829                                   ignore = false;
830                              } else
831                                   cerr << "ERROR -- process::waitProcs forwarding signal " << sig << " -- " << sys_errlist[errno] << endl;
832                         }
833 #ifdef notdef
834                         else
835                              signal_cerr << "Signal " << sig << " in " << result << endl;
836 #endif
837                  }
838             }
839        } while ( ignore );
840
841
842   if( result > 0 ) {
843           if( WIFSTOPPED(*status) ) {
844                   process *curr = findProcess( result );
845                   if (!curr->dyninstLibAlreadyLoaded() && curr->wasCreatedViaAttach())
846                   {
847                        /* FIXME: Is any of this code ever executed? */
848                           // make sure we are stopped in the eyes of paradynd - naim
849                           bool wasRunning = (curr->status() == running);
850                           if (curr->status() != stopped)
851                                   curr->Stopped();   
852                           if(curr->isDynamicallyLinked()) {
853                                   curr->handleIfDueToSharedObjectMapping();
854                           }
855                           if (curr->trapDueToDyninstLib()) {
856                                   // we need to load libdyninstRT.so.1 - naim
857                                   curr->handleIfDueToDyninstLib();
858                           }
859                           if (wasRunning) 
860                                   if (!curr->continueProc()) assert(0);
861                   }
862           }
863 #ifdef SIGNAL_DEBUG
864           if( WIFSIGNALED(*status) )
865           {
866                   sig = WTERMSIG(*status);
867                   signal_cerr << "process::waitProcs -- Exit on signal #" << sig << " in " << result << ", resignalling the process" << endl;
868           }
869           else if( WIFEXITED(*status) )
870           {
871                   signal_cerr << "process::waitProcs -- Exit from " << result << endl;
872           }
873 #endif
874   }// else if( errno )
875     //perror( "process::waitProcs - waitpid" );
876   return result;
877 }
878
879 // attach to an inferior process.
880 bool process::attach() {
881   char procName[128];
882   bool running = false;
883   if( createdViaAttach )
884     running = isRunning_();
885
886   proc_fd = -1;
887
888   // QUESTION: does this attach operation lead to a SIGTRAP being forwarded
889   // to paradynd in all cases?  How about when we are attaching to an
890   // already-running process?  (Seems that in the latter case, no SIGTRAP
891   // is automatically generated)
892
893   // step 1) /proc open: attach to the inferior process memory file
894   sprintf(procName,"/proc/%d/mem", (int)getPid());
895   attach_cerr << "Opening memory space for process #" << getPid() << " at " << procName << endl;
896   int fd = P_open(procName, O_RDWR, 0);
897   if (fd < 0 ) {
898     fprintf(stderr, "attach: open failed on %s: %s\n", procName, sys_errlist[errno]);
899     return false;
900   }
901
902   proc_fd = fd;
903
904   // Only if we are really attaching rather than spawning the inferior
905   // process ourselves do we need to call PTRACE_ATTACH
906   if( createdViaAttach || createdViaFork || createdViaAttachToCreated ) {
907           attach_cerr << "process::attach() doing PTRACE_ATTACH" << endl;
908       if( 0 != P_ptrace(PTRACE_ATTACH, getPid(), 0, 0) )
909         {
910                 perror( "process::attach - PTRACE_ATTACH" );
911                 return false;
912         }
913
914     if (0 > waitpid(getPid(), NULL, 0)) {
915       perror("process::attach - waitpid");
916       exit(1);
917     }
918   }
919
920   if( createdViaAttach )
921   {
922     // If the process was running, it will need to be restarted, as
923     // PTRACE_ATTACH kills it
924     // Actually, the attach process contructor assumes that the process is
925     // running.  While this is foolish, let's play along for now.
926         if( status_ != running || !isRunning_() ) {
927                 if( 0 != P_ptrace(PTRACE_CONT, getPid(), 0, 0) )
928                 {
929                         perror( "process::attach - continue 1" );
930                 }
931     }
932   }
933
934   if (createdViaAttachToCreated)
935     {
936       // This case is a special situation. The process is stopped
937       // in the exec() system call but we have not received the first 
938       // TRAP because it has been caught by another process.
939
940       /* lose race */
941       sleep(1);
942  
943
944       /* continue, clearing pending stop */
945       if (0 > ptrace(PTRACE_CONT, getPid(), 0, SIGCONT)) {
946           perror("process::attach: PTRACE_CONT 1");
947           return false;
948       }
949      
950
951       if (0 > waitpid(getPid(), NULL, 0)) {
952           perror("process::attach: WAITPID");
953           return false;
954       }
955      
956
957       /* continue, resending the TRAP to emulate the normal situation*/
958       if ( 0 > kill(getPid(), SIGTRAP)){
959           perror("process::attach: KILL");
960           return false;
961       }
962
963       if (0 > ptrace(PTRACE_CONT, getPid(), 0, SIGCONT)) {
964           perror("process::attach: PTRACE_CONT 2");
965           return false;
966       }
967
968       fprintf(stderr, "done attaching\n");
969       status_ = neonatal;
970       return true;
971
972      } // end - if createdViaAttachToCreated
973
974 #ifdef notdef
975   if( status_ != running && isRunning_() )
976   {
977           attach_cerr << "fixing status_ => running" << endl;
978           status_ = running;
979   }
980   else if( status_ == running && !isRunning_() )
981   {
982           attach_cerr << "fixing status_ => stopped" << endl;
983           status_ = stopped;
984   }
985 #endif
986
987   return true;
988 }
989
990 bool process::attach_() {
991   return false; // (P_ptrace(PTRACE_ATTACH, getPid(), 0, 0) != -1);
992 }
993
994 bool process::trapAtEntryPointOfMain()
995 {
996   // is the trap instr at main_brk_addr?
997   if( getPC(getPid()) == (Address)main_brk_addr)
998     return(true);
999   else
1000     return(false);
1001 }
1002
1003 bool process::trapDueToDyninstLib()
1004 {
1005   // is the trap instr at dyninstlib_brk_addr?
1006   if( getPC(getPid()) == (Address)dyninstlib_brk_addr)
1007     return(true);
1008   else
1009     return(false);
1010 }
1011
1012 void process::handleIfDueToDyninstLib() 
1013 {
1014   // rewrite original instructions in the text segment we use for 
1015   // the inferiorRPC - naim
1016   unsigned count = sizeof(savedCodeBuffer);
1017   //Address codeBase = getImage()->codeOffset();
1018
1019   Address codeBase = 0;
1020   int i;
1021
1022   for( i = 0; i < N_DYNINST_LOAD_HIJACK_FUNCTIONS; i++ ) {
1023           bool found = false;
1024           Symbol s;
1025           codeBase = 0;
1026           found = symbols->symbol_info(DYNINST_LOAD_HIJACK_FUNCTIONS[i], s);
1027           if( found )
1028                   codeBase = s.addr();
1029           if( codeBase )
1030                   break;
1031   }
1032   assert( codeBase );
1033
1034   writeDataSpace((void *)codeBase, count, (char *)savedCodeBuffer);
1035
1036   // restore registers
1037   restoreRegisters(savedRegs); 
1038
1039   // restore the stack frame of _start()
1040   user_regs_struct *theIntRegs = (user_regs_struct *)savedRegs;
1041   RegValue theEBP = theIntRegs->ebp;
1042
1043   if( !theEBP )
1044   {
1045           theEBP = theIntRegs->esp;
1046   }
1047
1048   assert (theEBP);
1049   // this is pretty kludge. if the stack frame of _start is not the right
1050   // size, this would break.
1051   writeDataSpace ((void*)(theEBP-6*sizeof(int)),6*sizeof(int),savedStackFrame);
1052
1053   if( isRunning_() )
1054           cerr << "WARNING -- process is running at trap from dlopenDYNINSTlib" << endl;
1055
1056   delete [] (char *) savedRegs;
1057   savedRegs = NULL;
1058 }
1059
1060 void process::handleTrapAtEntryPointOfMain()
1061 {
1062   function_base *f_main = findOneFunction("main");
1063   assert(f_main);
1064   Address addr = f_main->addr();
1065   // restore original instruction 
1066   writeDataSpace((void *)addr, 2, (char *)savedCodeBuffer);
1067 }
1068
1069 void process::insertTrapAtEntryPointOfMain()
1070 {
1071   function_base *f_main = 0;
1072   f_main = findOneFunction("main");
1073   if (!f_main) {
1074     // we can't instrument main - naim
1075     showErrorCallback(108,"main() uninstrumentable");
1076     extern void cleanUpAndExit(int);
1077     cleanUpAndExit(-1); 
1078     return;
1079   }
1080   assert(f_main);
1081   Address addr = f_main->addr();
1082
1083   // save original instruction first
1084   readDataSpace((void *)addr, 2, savedCodeBuffer, true);
1085
1086   // and now, insert trap
1087   instruction insnTrap;
1088   generateBreakPoint(insnTrap);
1089
1090   // x86. have to use SIGILL instead of SIGTRAP
1091   writeDataSpace((void *)addr, 2, insnTrap.ptr());  
1092
1093   main_brk_addr = addr;
1094 }
1095
1096 void emitCallRel32(unsigned disp32, unsigned char *&insn);
1097
1098 bool process::dlopenDYNINSTlib() {
1099 #if false && defined(PTRACEDEBUG)
1100   debug_ptrace = true;
1101 #endif
1102   // we will write the following into a buffer and copy it into the
1103   // application process's address space
1104   // [....LIBRARY's NAME...|code for DLOPEN]
1105
1106   // write to the application at codeOffset. This won't work if we
1107   // attach to a running process.
1108   //Address codeBase = this->getImage()->codeOffset();
1109   // ...let's try "_start" instead
1110   //  Address codeBase = (this->findFuncByName(DYNINST_LOAD_HIJACK_FUNCTION))->getAddress(this);
1111   Address codeBase = 0;
1112   int i;
1113
1114   for( i = 0; i < N_DYNINST_LOAD_HIJACK_FUNCTIONS; i++ ) {
1115       bool found = false;
1116       Symbol s;
1117       codeBase = 0;
1118       found = symbols->symbol_info(DYNINST_LOAD_HIJACK_FUNCTIONS[i], s);
1119       if( found )
1120           codeBase = s.addr();
1121       if( codeBase )
1122           break;
1123   }
1124
1125   if( !codeBase || i >= N_DYNINST_LOAD_HIJACK_FUNCTIONS )
1126   {
1127       attach_cerr << "Couldn't find a point to insert dlopen call" << endl;
1128       return false;
1129   }
1130
1131   attach_cerr << "Inserting dlopen call in " << DYNINST_LOAD_HIJACK_FUNCTIONS[i] << " at "
1132       << (void*)codeBase << endl;
1133   attach_cerr << "Process at " << (void*)getPC( getPid() ) << endl;
1134
1135   bool libc_21 = true; /* inferior has glibc 2.1-2.x */
1136   Symbol libc_vers;
1137   if( !getSymbolInfo( libc_version_symname, libc_vers ) ) {
1138       cerr << "Couldn't find " << libc_version_symname << ", assuming glibc_2.1.x" << endl;
1139   } else {
1140       char libc_version[ libc_vers.size() + 1 ];
1141       libc_version[ libc_vers.size() ] = '\0';
1142       readDataSpace( (void *)libc_vers.addr(), libc_vers.size(), libc_version, true );
1143       if (strncmp(libc_version, "2", 1)) {
1144           cerr << "Found " << libc_version_symname << " = \"" << libc_version
1145                << "\", which doesn't match any known glibc"
1146                << " assuming glibc 2.1." << endl;
1147       } else if (!strncmp(libc_version, "2.0", 3))
1148               libc_21 = false;
1149   }
1150   // Or should this be readText... it seems like they are identical
1151   // the remaining stuff is thanks to Marcelo's ideas - this is what 
1152   // he does in NT. The major change here is that we use AST's to 
1153   // generate code for dlopen.
1154
1155   // savedCodeBuffer[BYTES_TO_SAVE] is declared in process.h
1156
1157   readDataSpace((void *)codeBase, sizeof(savedCodeBuffer), savedCodeBuffer, true);
1158
1159   unsigned char scratchCodeBuffer[BYTES_TO_SAVE];
1160   vector<AstNode*> dlopenAstArgs( 2 );
1161
1162   unsigned count = 0;
1163   Address dyninst_count = 0;
1164
1165   AstNode *dlopenAst;
1166
1167   // deadList and deadListSize are defined in inst-sparc.C - naim
1168   extern Register deadList[];
1169   extern int deadListSize;
1170   registerSpace *dlopenRegSpace = new registerSpace(deadListSize/sizeof(int), deadList, 0, NULL);
1171   dlopenRegSpace->resetSpace();
1172
1173   // we need to make a call to dlopen to open our runtime library
1174
1175   if( !libc_21 ) {
1176       dlopenAstArgs[0] = new AstNode(AstNode::Constant, (void*)0);
1177       // library name. We use a scratch value first. We will update this parameter
1178       // later, once we determine the offset to find the string - naim
1179       dlopenAstArgs[1] = new AstNode(AstNode::Constant, (void*)DLOPEN_MODE); // mode
1180       dlopenAst = new AstNode(DL_OPEN_FUNC_NAME,dlopenAstArgs);
1181       removeAst(dlopenAstArgs[0]);
1182       removeAst(dlopenAstArgs[1]);
1183       
1184       dyninst_count = 0;
1185       dlopenAst->generateCode(this, dlopenRegSpace, (char *)scratchCodeBuffer,
1186                               dyninst_count, true, true);
1187   } else {
1188       // In glibc 2.1.x, _dl_open is optimized for being an internal wrapper function.
1189       // Instead of using the stack, it passes three parameters in EAX, EDX and ECX.
1190       // Here we simply make a call with no normal parameters, and below we change
1191       // the three registers along with EIP to execute the code.
1192       unsigned char *code_ptr = scratchCodeBuffer;
1193       Address disp;
1194       Address addr;
1195       bool err;
1196       addr = findInternalAddress(DL_OPEN_FUNC_NAME, false, err);
1197       if (err) {
1198           function_base *func = findOneFunction(DL_OPEN_FUNC_NAME);
1199           if (!func) {
1200               ostrstream os(errorLine, 1024, ios::out);
1201               os << "Internal error: unable to find addr of " << DL_OPEN_FUNC_NAME << endl;
1202               logLine(errorLine);
1203               showErrorCallback(80, (const char *) errorLine);
1204               P_abort();
1205           }
1206           addr = func->getAddress(0);
1207       }
1208
1209       disp = addr - ( codeBase + 5 );
1210       attach_cerr << DL_OPEN_FUNC_NAME << " @ " << (void*)addr << ", displacement == "
1211                   << (void*)disp << endl;
1212       emitCallRel32( disp, code_ptr );
1213       dyninst_count = 5;
1214   }
1215
1216   writeDataSpace((void *)(codeBase+count), dyninst_count, (char *)scratchCodeBuffer);
1217   count += dyninst_count;
1218
1219   instruction insnTrap;
1220   generateBreakPoint(insnTrap);
1221   writeDataSpace((void *)(codeBase + count), 2, insnTrap.ptr());
1222   dyninstlib_brk_addr = codeBase + count;
1223   count += 2;
1224
1225 #ifdef BPATCH_LIBRARY  /* dyninst API loads a different run-time library */
1226   const char DyninstEnvVar[]="DYNINSTAPI_RT_LIB";
1227 #else
1228   const char DyninstEnvVar[]="PARADYN_LIB";
1229 #endif
1230
1231   if (dyninstName.length()) {
1232     // use the library name specified on the start-up command-line
1233   } else {
1234     // check the environment variable
1235     if (getenv(DyninstEnvVar) != NULL) {
1236       dyninstName = getenv(DyninstEnvVar);
1237     } else {
1238       string msg = string("Environment variable " + string(DyninstEnvVar)
1239                    + " has not been defined for process ") + string(pid);
1240       showErrorCallback(101, msg);
1241       return false;
1242     }
1243   }
1244   if (access(dyninstName.string_of(), R_OK)) {
1245     string msg = string("Runtime library ") + dyninstName
1246         + string(" does not exist or cannot be accessed!");
1247     showErrorCallback(101, msg);
1248     return false;
1249   }
1250
1251   Address dyninstlib_addr = (Address) (codeBase + count);
1252
1253   writeDataSpace((void *)(codeBase + count), dyninstName.length()+1,
1254                  (caddr_t)const_cast<char*>(dyninstName.string_of()));
1255   count += dyninstName.length()+1;
1256   // we have now written the name of the library after the trap - naim
1257
1258   assert(count<=BYTES_TO_SAVE);
1259
1260   if( !libc_21 ) {
1261       count = 0; // reset count
1262
1263       // at this time, we know the offset for the library name, so we fix the
1264       // call to dlopen and we just write the code again! This is probably not
1265       // very elegant, but it is easy and it works - naim
1266       removeAst(dlopenAst); // to avoid leaking memory
1267       dlopenAstArgs[0] = new AstNode(AstNode::Constant, (void *)(dyninstlib_addr));
1268       dlopenAstArgs[1] = new AstNode(AstNode::Constant, (void*)DLOPEN_MODE);
1269       dlopenAst = new AstNode(DL_OPEN_FUNC_NAME,dlopenAstArgs);
1270       removeAst(dlopenAstArgs[0]);
1271       removeAst(dlopenAstArgs[1]);
1272       dyninst_count = 0; // reset count
1273       dlopenAst->generateCode(this, dlopenRegSpace, (char *)scratchCodeBuffer,
1274                               dyninst_count, true, true);
1275       writeDataSpace((void *)(codeBase+count), dyninst_count, (char *)scratchCodeBuffer);
1276       removeAst(dlopenAst);
1277   }
1278
1279   // save registers
1280   savedRegs = getRegisters();
1281   assert((savedRegs!=NULL) && (savedRegs!=(void *)-1));
1282   // save the stack frame of _start()
1283   user_regs_struct *regs = (user_regs_struct*)savedRegs;
1284   user_regs_struct new_regs = *regs;
1285   RegValue theEBP = regs->ebp;
1286
1287   // Under Linux, at the entry point to main, ebp is 0
1288   // the first thing main usually does is to push ebp and
1289   // move esp -> ebp, so we'll do that, too
1290   if( !theEBP )
1291   {
1292           theEBP = regs->esp;
1293           attach_cerr << "eBP at 0x0, creating fake stack frame with eSP == "
1294                                   << (void*)theEBP << endl;
1295           changeBP( getPid(), theEBP );
1296   }
1297
1298   assert( theEBP );
1299   // this is pretty kludge. if the stack frame of _start is not the right
1300   // size, this would break.
1301   readDataSpace((void*)(theEBP-6*sizeof(int)),6*sizeof(int), savedStackFrame, true);
1302
1303   isLoadingDyninstLib = true;
1304
1305   attach_cerr << "Changing PC to " << (void*)codeBase << endl;
1306
1307   if (!libc_21)
1308   {
1309       if (!changePC(codeBase,savedRegs))
1310       {
1311           logLine("WARNING: changePC failed in dlopenDYNINSTlib\n");
1312           assert(0);
1313       }
1314   }
1315   else
1316   {
1317       new_regs.eip = codeBase;
1318
1319       if( libc_21 ) {
1320           new_regs.eax = dyninstlib_addr;
1321           new_regs.edx = DLOPEN_MODE;
1322           new_regs.ecx = codeBase;
1323       }
1324
1325       if( !restoreRegisters( (void*)(&new_regs) ) )
1326       {
1327           logLine("WARNING: changePC failed in dlopenDYNINSTlib\n");
1328           assert(0);
1329       }
1330   }
1331
1332 #if false && defined(PTRACEDEBUG)
1333   debug_ptrace = false;
1334 #endif
1335
1336   return true;
1337 }
1338
1339 Address process::get_dlopen_addr() const {
1340   if (dyn != NULL)
1341     return(dyn->get_dlopen_addr());
1342   else 
1343     return(0);
1344 }
1345
1346 bool process::isRunning_() const {
1347    // determine if a process is running by doing low-level system checks, as
1348    // opposed to checking the 'status_' member vrble.  May assume that attach()
1349    // has run, but can't assume anything else.
1350
1351   char procName[64];
1352   char sstat[132];
1353   char *token = NULL;
1354
1355   sprintf(procName,"/proc/%d/stat", (int)pid);
1356   FILE *sfile = P_fopen(procName, "r");
1357   fread( sstat, 128, 1, sfile );
1358   fclose( sfile );
1359
1360   char status;
1361   if( !( strtok( sstat, " (" ) && strtok( NULL, " )" ) && ( token = strtok( NULL, " " ) ) ) )
1362     assert( false && "Shouldn't happen" );
1363   status = token[0];
1364
1365   if( status == 'T' )
1366     return false;
1367   else
1368     return true;
1369 }
1370
1371
1372 // TODO is this safe here ?
1373 bool process::continueProc_() {
1374   int ret;
1375
1376   if (!checkStatus()) 
1377     return false;
1378
1379   ptraceOps++; ptraceOtherOps++;
1380
1381 /* choose either one of the following ptrace calls, but not both. 
1382  * The choice must be consistent with that in stop_ and
1383  * ptraceKludge::continueProcess.
1384  */
1385   ret = P_ptrace(PTRACE_CONT, getPid(), 1, 0);
1386
1387   if (ret == -1)
1388   {
1389           /*if( isRunning_() )
1390                   ret = 0;
1391                   else*/
1392                   perror("continueProc_()");
1393   }
1394
1395   return ret != -1;
1396 }
1397
1398 #ifdef BPATCH_LIBRARY
1399 bool process::terminateProc_()
1400 {
1401   if (!checkStatus()) 
1402     return false;
1403
1404   if( kill( getPid(), SIGKILL ) != 0 )
1405     return false;
1406   else
1407     return true;
1408 }
1409 #endif
1410
1411 // TODO ??
1412 bool process::pause_() {
1413   if (!checkStatus()) 
1414     return false;
1415   ptraceOps++; ptraceOtherOps++;
1416   bool wasStopped = (status() == stopped);
1417   if (status() != neonatal && !wasStopped)
1418     return (loopUntilStopped());
1419   else
1420     return true;
1421 }
1422
1423 bool process::detach_() {
1424   if (!checkStatus())
1425     return false;
1426   ptraceOps++; ptraceOtherOps++;
1427   close( proc_fd );
1428   return (ptraceKludge::deliverPtrace(this, PTRACE_DETACH, 1, SIGCONT));
1429 }
1430
1431 #ifdef BPATCH_LIBRARY
1432 bool process::API_detach_(const bool cont) {
1433 //  assert(cont);
1434   if (!checkStatus())
1435     return false;
1436   ptraceOps++; ptraceOtherOps++;
1437   close( proc_fd );
1438   if (!cont) P_kill(pid, SIGSTOP);
1439   return (ptraceKludge::deliverPtrace(this, PTRACE_DETACH, 1, SIGCONT));
1440 }
1441 #endif
1442
1443 bool process::dumpCore_(const string/* coreFile*/) { return false; }
1444
1445 bool process::writeTextWord_(caddr_t inTraced, int data) {
1446 //  cerr << "writeTextWord @ " << (void *)inTraced << endl; cerr.flush();
1447   return writeDataSpace_(inTraced, sizeof(int), (caddr_t) &data);
1448 }
1449
1450 bool process::writeTextSpace_(void *inTraced, u_int amount, const void *inSelf) {
1451 //  cerr << "writeTextSpace pid=" << getPid() << ", @ " << (void *)inTraced << " len=" << amount << endl; cerr.flush();
1452   return writeDataSpace_(inTraced, amount, inSelf);
1453 }
1454
1455 #ifdef BPATCH_SET_MUTATIONS_ACTIVE
1456 bool process::readTextSpace_(void *inTraced, u_int amount, const void *inSelf) {
1457   return readDataSpace_( inTraced, amount, const_cast<void*>( inSelf ) );
1458 }
1459 #endif
1460
1461 bool process::writeDataSpace_(void *inTraced, u_int nbytes, const void *inSelf)
1462 {
1463      unsigned char *ap = (unsigned char*) inTraced;
1464      const unsigned char *dp = (const unsigned char*) inSelf;
1465      int pid = getPid();
1466      int w;               /* ptrace I/O buffer */
1467      unsigned len = sizeof(w); /* address alignment of ptrace I/O requests */
1468      unsigned cnt;
1469
1470 #if defined(BPATCH_LIBRARY)
1471 #if defined(i386_unknown_linux2_0)
1472         if(collectSaveWorldData &&  ((Address) inTraced) > getDyn()->getlowestSObaseaddr() ){
1473                 shared_object *sh_obj = NULL;
1474                 bool result = false;
1475                 for(unsigned int i = 0; shared_objects && !result && i<shared_objects->size();i++){
1476                         sh_obj = (*shared_objects)[i];
1477                         result = sh_obj->isinText((Address) inTraced);
1478                 }
1479                 if( result  ){
1480                         if(strcmp(findFuncByAddr((Address)inTraced)->prettyName().string_of(), 
1481                                                 "__libc_sigaction")){
1482                                 //for linux we instrument sigactiont to watch libraries
1483                                 //being loaded. dont consider libc.so mutated because of 
1484                                 //this  
1485                                 /*printf(" write at %lx in %s amount %x insn: %x \n", 
1486                                 (off_t)inTraced, sh_obj->getName().string_of(), nbytes,
1487                                  *(unsigned int*) inSelf);
1488                                  */
1489                                 sh_obj->setDirty();     
1490                         }
1491                 }
1492         }
1493 #endif
1494 #endif
1495
1496      ptraceOps++; ptraceBytes += nbytes;
1497
1498      if (0 == nbytes)
1499           return true;
1500
1501      if ((cnt = (unsigned)ap % len)) {
1502           /* Start of request is not aligned. */
1503           unsigned char *p = (unsigned char*) &w;
1504           
1505           /* Read the segment containing the unaligned portion, edit
1506              in the data from DP, and write the segment back. */
1507           errno = 0;
1508           w = P_ptrace(PTRACE_PEEKTEXT, pid, (int) (ap-cnt), 0);
1509           if (errno)
1510                return false;
1511           for (unsigned i = 0; i < len-cnt && i < nbytes; i++)
1512                p[cnt+i] = dp[i];
1513           if (0 > P_ptrace(PTRACE_POKETEXT, pid, (int) (ap-cnt), w))
1514                return false;
1515
1516           if (len-cnt >= nbytes) 
1517                return true; /* done */
1518           
1519           dp += len-cnt;
1520           ap += len-cnt;
1521           nbytes -= len-cnt;
1522      }    
1523           
1524      /* Copy aligned portion */
1525      while (nbytes >= len) {
1526           assert(0 == (unsigned)ap % len);
1527           memcpy(&w, dp, len);
1528           if (0 > P_ptrace(PTRACE_POKETEXT, pid, (int) ap, w))
1529                return false;
1530           dp += len;
1531           ap += len;
1532           nbytes -= len;
1533      }
1534
1535      if (nbytes > 0) {
1536           /* Some unaligned data remains */
1537           unsigned char *p = (unsigned char *) &w;
1538           
1539           /* Read the segment containing the unaligned portion, edit
1540              in the data from DP, and write it back. */
1541           errno = 0;
1542           w = P_ptrace(PTRACE_PEEKTEXT, pid, (int) ap, 0);
1543           if (errno)
1544                return false;
1545           for (unsigned i = 0; i < nbytes; i++)
1546                p[i] = dp[i];
1547           if (0 > P_ptrace(PTRACE_POKETEXT, pid, (int) ap, w))
1548                return false;
1549      }
1550
1551      return true;
1552 }
1553
1554 bool process::readDataSpace_(const void *inTraced, u_int nbytes, void *inSelf) {
1555      const unsigned char *ap = (const unsigned char*) inTraced;
1556      unsigned char *dp = (unsigned char*) inSelf;
1557      int pid = getPid();
1558      int w;               /* ptrace I/O buffer */
1559      unsigned len = sizeof(w); /* address alignment of ptrace I/O requests */
1560      unsigned cnt;
1561
1562      ptraceOps++; ptraceBytes += nbytes;
1563
1564      if (0 == nbytes)
1565           return true;
1566
1567      if ((cnt = (unsigned)ap % len)) {
1568           /* Start of request is not aligned. */
1569           unsigned char *p = (unsigned char*) &w;
1570
1571           /* Read the segment containing the unaligned portion, and
1572              copy what was requested to DP. */
1573           errno = 0;
1574           w = P_ptrace(PTRACE_PEEKTEXT, pid, (int) (ap-cnt), w);
1575           if (errno)
1576                return false;
1577           for (unsigned i = 0; i < len-cnt && i < nbytes; i++)
1578                dp[i] = p[cnt+i];
1579
1580           if (len-cnt >= nbytes)
1581                return true; /* done */
1582
1583           dp += len-cnt;
1584           ap += len-cnt;
1585           nbytes -= len-cnt;
1586      }
1587
1588      /* Copy aligned portion */
1589      while (nbytes >= len) {
1590           errno = 0;
1591           w = P_ptrace(PTRACE_PEEKTEXT, pid, (int) ap, 0);
1592           if (errno)
1593                return false;
1594           memcpy(dp, &w, len);
1595           dp += len;
1596           ap += len;
1597           nbytes -= len;
1598      }
1599
1600      if (nbytes > 0) {
1601           /* Some unaligned data remains */
1602           unsigned char *p = (unsigned char *) &w;
1603           
1604           /* Read the segment containing the unaligned portion, and
1605              copy what was requested to DP. */
1606           errno = 0;
1607           w = P_ptrace(PTRACE_PEEKTEXT, pid, (int) ap, 0);
1608           if (errno)
1609                return false;
1610           for (unsigned i = 0; i < nbytes; i++)
1611                dp[i] = p[i];
1612      }
1613
1614      return true;
1615 }
1616
1617 /*
1618 bool process::findCallee(instPoint &instr, function_base *&target){
1619   fprintf( stderr, "findCallee not implemented\n" );
1620   return false;
1621 }
1622 */
1623
1624 Frame Frame::getCallerFrame(process *p) const
1625 {
1626   //
1627   // for the x86, the frame-pointer (EBP) points to the previous frame-pointer,
1628   // and the saved return address is in EBP-4.
1629   //
1630   struct {
1631     int fp;
1632     int rtn;
1633   } addrs;
1634
1635   if (p->readDataSpace((caddr_t)(fp_), 2*sizeof(int),
1636                        (caddr_t) &addrs, true))
1637   {
1638     Frame ret;
1639     ret.fp_ = addrs.fp;
1640     ret.pc_ = addrs.rtn;
1641     return ret;
1642   }
1643
1644   return Frame(); // zero frame
1645 }
1646
1647 // You know, /proc/*/exe is a perfectly good link (directly to the inode) to
1648 // the executable file, who cares where the executable really is, we can open
1649 // this link. - nash
1650 string process::tryToFindExecutable(const string & /* iprogpath */, int pid) {
1651   return string("/proc/") + string(pid) + "/exe";
1652 }
1653
1654 /*
1655  * The old, ugly version that we don't need but can waste space anyhow
1656  * /
1657 string process::tryToFindExecutable(const string &iprogpath, int pid) {
1658    // returns empty string on failure.
1659    // Otherwise, returns a full-path-name for the file.  Tries every
1660    // trick to determine the full-path-name, even though "progpath" may be
1661    // unspecified (empty string).
1662    
1663    // Remember, we can always return the empty string...no need to
1664    // go nuts writing the world's most complex algorithm.
1665
1666    attach_cerr << "welcome to tryToFindExecutable; progpath=" << iprogpath << ", pid=" << pid << endl;
1667
1668    const string progpath = expand_tilde_pathname(iprogpath);
1669
1670    // Trivial case: if "progpath" is specified and the file exists then nothing needed
1671    if (exists_executable(progpath)) {
1672      attach_cerr << "tryToFindExecutable succeeded immediately, returning "
1673                  << progpath << endl;
1674      return progpath;
1675    }
1676
1677    attach_cerr << "tryToFindExecutable failed on filename " << progpath << endl;
1678
1679    string argv0, path, cwd;
1680
1681    char buffer[128];
1682    sprintf(buffer, "/proc/%d/environ", pid);
1683    int procfd = open(buffer, O_RDONLY, 0);
1684    if (procfd == -1) {
1685      attach_cerr << "tryToFindExecutable failed since open of /proc/ * /environ failed" << endl;
1686      return "";
1687    }
1688    attach_cerr << "tryToFindExecutable: opened /proc/ * /environ okay" << endl;
1689
1690    int strptr = 0;
1691    while( true ) {
1692      string env_value = extract_string( procfd, (char*)strptr );
1693      if( !env_value.length() )
1694        break;
1695
1696      if (env_value.prefixed_by("PWD=") || env_value.prefixed_by("CWD=")) {
1697        cwd = env_value.string_of() + 4; // skip past "PWD=" or "CWD="
1698        attach_cerr << "get_ps_stuff: using PWD value of: " << cwd << endl;
1699        if( path.length() )
1700          break;
1701      } else if (env_value.prefixed_by("PATH=")) {
1702        path = env_value.string_of() + 5; // skip past the "PATH="
1703        attach_cerr << "get_ps_stuff: using PATH value of: " << path << endl;
1704        if( cwd.length() )
1705          break;
1706      }
1707
1708      strptr += env_value.length() + 1;
1709    }
1710
1711    close( procfd );
1712
1713    sprintf(buffer, "/proc/%d/cmdline", pid);
1714    procfd = open(buffer, O_RDONLY, 0);
1715    if (procfd == -1) {
1716      attach_cerr << "tryToFindExecutable failed since open of /proc/ * /cmdline failed" << endl;
1717      return "";
1718    }
1719    attach_cerr << "tryToFindExecutable: opened /proc/ * /cmdline okay" << endl;
1720
1721    argv0 = extract_string( procfd, (char*)0 );
1722    close( procfd );
1723
1724    if ( argv0.length() && path.length() && cwd.length() ) {
1725      // the following routine is implemented in the util lib.
1726      string result;
1727      if (executableFromArgv0AndPathAndCwd(result, argv0, path, cwd)) {
1728        attach_cerr << "tryToFindExecutable: returning " << result << endl;
1729
1730        // I feel picky today, let's make certain that /proc agrees that
1731        // this is the executable by checking the inode number of
1732        // /proc/ * /exe against the inode number of result
1733
1734        sprintf(buffer, "/proc/%d/exe", pid);
1735        struct stat t_stat;
1736        int t_inode;
1737        if( stat( buffer, &t_stat ) ) {
1738          t_inode = t_stat.st_ino;
1739          if( stat( buffer, &t_stat ) && t_inode != t_stat.st_ino )
1740            cerr << "tryToFindExecutable: WARNING - found executable does not match /proc" << endl;
1741        }
1742
1743        return result;
1744      }
1745    }
1746
1747    attach_cerr << "tryToFindExecutable: giving up" << endl;
1748
1749    return "";
1750 }
1751 */
1752
1753 #if !defined(BPATCH_LIBRARY)
1754 rawTime64 process::getRawCpuTime_hw(int /*lwp_id*/) {
1755   rawTime64 val = 0;
1756 #ifdef HRTIME
1757   val = hrtimeGetVtime(hr_cpu_link);
1758 #endif
1759   return val;
1760 }
1761
1762 rawTime64 process::getRawCpuTime_sw(int /*lwp_id*/) /* const */ {
1763   rawTime64 now = 0;
1764   int bufsize = 150, utime, stime;
1765   char procfn[bufsize], *buf;
1766
1767   sprintf( procfn, "/proc/%d/stat", getPid() );
1768
1769   int fd;
1770
1771   // The reason for this complicated method of reading and sseekf-ing is
1772   // to ensure that we read enough of the buffer 'atomically' to make sure
1773   // the data is consistent.  Is this necessary?  I *think* so. - nash
1774   do {
1775     fd = P_open(procfn, O_RDONLY, 0);
1776     if (fd < 0) {
1777       shmsample_cerr << "getInferiorProcessCPUtime: open failed: " << sys_errlist[errno] << endl;
1778       return false;
1779     }
1780
1781     buf = new char[ bufsize ];
1782
1783     if ((int)P_read( fd, buf, bufsize-1 ) < 0) {
1784       perror("getInferiorProcessCPUtime");
1785       return false;
1786     }
1787
1788     if(2==sscanf(buf,"%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %d %d "
1789                  , &utime, &stime ) ) {
1790       // These numbers are in 'jiffies' or timeslices.
1791       // Oh, and I'm also assuming that process time includes system time
1792       now = static_cast<rawTime64>(utime) + static_cast<rawTime64>(stime);
1793       break;
1794     }
1795
1796     delete [] buf;
1797     shmsample_cerr << "Inferior CPU time buffer expansion (" << bufsize << ")" << endl;
1798     bufsize = bufsize * 2;
1799
1800     P_close( fd );
1801   } while ( true );
1802
1803   delete [] buf;
1804   P_close(fd);
1805
1806   return now;
1807 }
1808 #endif
1809
1810 bool process::loopUntilStopped() {
1811      int flags = WUNTRACED | WNOHANG;
1812      bool stopSig = false;
1813      int count = 0;
1814      /* make sure the process is stopped in the eyes of ptrace */
1815      
1816      while (true) {
1817           int waitStatus;
1818           int ret = P_waitpid( getPid(), &waitStatus, flags );
1819           if( ret == 0 ) {
1820 #ifdef DETACH_ON_THE_FLY
1821                /* This used to go between the stopSig = true and the stop_ call. */
1822                /* FIXME: Maybe we can clean up loopUntilStopped and make this go away? */
1823                if (juststopped) {
1824                     /* The process was already stopped by reattach() */
1825                     juststopped = false;
1826                     break;
1827                }
1828 #endif /* DETACH_ON_THE_FLY */
1829
1830                if( !stopSig ) {
1831                     stopSig = true;
1832                     stop_();
1833                }
1834                else if( ++count > 10 && !isRunning_() )
1835                     break;
1836           } else if ((ret == -1 && errno == ECHILD) || (WIFEXITED(waitStatus))) {
1837                // the child is gone.
1838                handleProcessExit(this, WEXITSTATUS(waitStatus));
1839                return(false);
1840           } else if (WIFSIGNALED(waitStatus)) {
1841                handleProcessExit(this, WTERMSIG(waitStatus));
1842                return false;
1843           } else if (WIFSTOPPED(waitStatus)) {
1844                int sig = WSTOPSIG(waitStatus);
1845                if ( sig == SIGSTOP ) {
1846                     break; // success
1847                } else {
1848                     extern int handleSigChild(int, int);
1849                     handleSigChild(pid, waitStatus);
1850                }
1851           }
1852           else {
1853                logLine("Problem stopping process\n");
1854                abort();
1855           }
1856      }
1857      return true;
1858 }
1859
1860 #ifdef BPATCH_LIBRARY
1861
1862 char* process::dumpPatchedImage(string imageFileName){ //ccw 7 feb 2002 
1863
1864         addLibrary addLibraryElf;
1865         void *data;
1866         unsigned int errFlag=0;
1867         char name[50];
1868         vector<imageUpdate*> compactedHighmemUpdates;
1869         Address guardFlagAddr= trampGuardAddr();
1870         unsigned int lastCompactedUpdateAddress;
1871         char *mutatedSharedObjects=0;
1872         int mutatedSharedObjectsSize = 0, mutatedSharedObjectsIndex=0;
1873         int dirNo =0;
1874         char *directoryName = 0;
1875         char *directoryNameExt = "_dyninstsaved";
1876         bool dlopenUsed = false;
1877
1878         if(!collectSaveWorldData){
1879                 BPatch_reportError(BPatchSerious,122,"dumpPatchedImage: BPatch_thread::startSaveWorld() not called.  No mutated binary saved\n");
1880                 return NULL;
1881         }
1882         directoryName = new char[strlen(( char*) getImage()->file().string_of()) +
1883                         strlen(directoryNameExt) + 3+1+1];
1884         sprintf(directoryName,"%s%s%x",(char*)getImage()->file().string_of(), directoryNameExt,dirNo);
1885         while(dirNo < 0x1000 && mkdir(directoryName, S_IRWXU) ){
1886                  if(errno == EEXIST){
1887                          dirNo ++;
1888                  }else{
1889                          BPatch_reportError(BPatchSerious, 122, "dumpPatchedImage: cannot open directory to store mutated binary. No files saved\n");
1890                          delete [] directoryName;
1891                          return NULL;
1892                  }
1893                  sprintf(directoryName, "%s%s%x",(char*)getImage()->file().string_of(),
1894                          directoryNameExt,dirNo);
1895         }
1896         if(dirNo == 0x1000){
1897                  BPatch_reportError(BPatchSerious, 122, "dumpPatchedImage: cannot open directory to store mutated binary. No files saved\n");
1898                  delete [] directoryName;
1899                  return NULL;
1900         }
1901         strcat(directoryName, "/");     
1902         char* fullName = new char[strlen(directoryName) + strlen ( (char*)imageFileName.string_of())+1];
1903         strcpy(fullName, directoryName);
1904         strcat(fullName, (char*)imageFileName.string_of());
1905
1906
1907         //In the mutated binary we need to catch the dlopen events and
1908         //adjust the instrumentation of the shared libraries (and 
1909         //jumps into the shared libraries) as the base address of the
1910         //shared libraries different for the base addresses during the
1911         //original mutator/mutatee run.
1912         //
1913         //the r_debug interface ensures that a change to the dynamic linking
1914         //information causes _dl_debug_state to be called.  This is because
1915         //dlopen is too small and odd to instrument/breakpoint.  So our code will
1916         //rely on this fact. (all these functions are contained in ld-linux.so)
1917         //
1918         //Our method:  The Procedure Linking Table (.plt) for ld-linux contains an
1919         //entry that jumps to a specified address in the .rel.plt table. To
1920         //call a function, the compiler generates a jump to the correct .plt
1921         //entry which reads its jump value out of the .rel.plt.  
1922         //
1923         //On the sly, secretly replace the entry in .rel.plt with folgers crystals
1924         //and poof, we jump to our own function in RTcommon.c (dyninst_dl_debug_state)
1925         //[actually we replace the entry in .rel.plt with the address of
1926         //dyninst_dl_debug_state].  To ensure correctness, dyninst_dl_debug_state
1927         //contains a call to the real _dl_debug_state immediately before it returns,
1928         //thus ensuring any code relying on that fact that _dl_debug_state is actually
1929         //run remains happy.
1930         //
1931         //It is very important then, that we know the location of the entry in the
1932         //.rel.plt table.  We need to record the offset of this entry with 
1933         //respect to the base address of ld-linux.so (for obvious reasons)
1934         //This offset is then sent to RTcommon.c, and here is the slick part, 
1935         //by assigning it to the 'load address' of the section 
1936         //"dyninstAPI_SharedLibraries," which contains the shared library/basei
1937         //address pairs used to fixup the saved binary. This way when checkElfFile()
1938         //reads the section the offset will be there in the section header.
1939         //
1940         //neat, eh?
1941         // this is how it will work in the future, currently this is 
1942         // not yet fully implemented and part of the cvs tree.
1943         //
1944         unsigned int dl_debug_statePltEntry = 0x00016574;//a pretty good guess
1945         unsigned int dyninst_SharedLibrariesSize = 0;
1946         shared_object *sh_obj;
1947
1948
1949         for(int i=0;shared_objects && i<(int)shared_objects->size() ; i++) {
1950                 sh_obj = (*shared_objects)[i];
1951                 if(sh_obj->isDirty()){
1952                         if(!dlopenUsed && sh_obj->isopenedWithdlopen()){
1953                                 BPatch_reportError(BPatchWarning,123,"dumpPatchedImage: dlopen used by the mutatee, this may cause the mutated binary to fail\n");
1954                                 dlopenUsed = true;
1955                         }                       
1956                         //printf(" %s is DIRTY!\n", sh_obj->getName().string_of());
1957                 
1958                         Address textAddr, textSize;
1959                         char *file, *newName = new char[strlen(sh_obj->getName().string_of()) + 
1960                                         strlen(directoryName) + 1];
1961                         memcpy(newName, directoryName, strlen(directoryName)+1);
1962                         file = strrchr( sh_obj->getName().string_of(), '/');
1963                         strcat(newName,file);
1964         
1965                         saveSharedLibrary *sharedObj = new saveSharedLibrary(
1966                                 sh_obj->getBaseAddress(), sh_obj->getName().string_of(),
1967                                 newName);
1968                         sharedObj->writeLibrary();
1969
1970                         sharedObj->getTextInfo(textAddr, textSize);
1971
1972                         char *textSection = new char[textSize];
1973                         readDataSpace((void*) (textAddr+ sh_obj->getBaseAddress()),
1974                                 textSize,(void*)textSection, true);
1975
1976                         sharedObj->saveMutations(textSection);
1977                         sharedObj->closeLibrary();
1978                         /*
1979                         //this is for the dlopen problem....
1980                         if(strstr(sh_obj->getName().string_of(), "ld-linux.so") ){
1981                                 //find the offset of _dl_debug_state in the .plt
1982                                 dl_debug_statePltEntry = 
1983                                         sh_obj->getImage()->getObject().getPltSlot("_dl_debug_state");
1984                         }
1985                         */
1986                         mutatedSharedObjectsSize += strlen(sh_obj->getName().string_of()) +1 ;
1987                         delete [] textSection;
1988                         delete [] newName;
1989                 }
1990                 //this is for the dyninst_SharedLibraries section
1991                 //we need to find out the length of the names of each of
1992                 //the shared libraries to create the data buffer for the section
1993
1994                 dyninst_SharedLibrariesSize += strlen(sh_obj->getName().string_of())+1;
1995                 //add the size of the address
1996                 dyninst_SharedLibrariesSize += sizeof(unsigned int);
1997         }
1998
1999         dyninst_SharedLibrariesSize += 1;//for the trailing '\0'
2000
2001         //the mutatedSO section contains a list of the shared objects that have been mutated
2002         if(mutatedSharedObjectsSize){
2003                 mutatedSharedObjects = new char[mutatedSharedObjectsSize];
2004                 for(int i=0;shared_objects && i<(int)shared_objects->size() ; i++) {
2005                         sh_obj = (*shared_objects)[i];
2006                         if(sh_obj->isDirty()){
2007                                 memcpy(  & ( mutatedSharedObjects[mutatedSharedObjectsIndex]),
2008                                         sh_obj->getName().string_of(),
2009                                         strlen(sh_obj->getName().string_of())+1);
2010                                 mutatedSharedObjectsIndex += strlen(
2011                                         sh_obj->getName().string_of())+1;
2012                         }
2013                 }       
2014         }
2015
2016         
2017         //dyninst_SharedLibraries
2018         //the SharedLibraries sections contains a list of all the shared libraries
2019         //that have been loaded and the base address for each one.
2020         //The format of the sections is:
2021         //
2022         //sharedlibraryName
2023         //baseAddr
2024         //...
2025         //sharedlibraryName
2026         //baseAddr
2027         //'\0'
2028         
2029         char *dyninst_SharedLibrariesData = new char[dyninst_SharedLibrariesSize];
2030         char *ptr= dyninst_SharedLibrariesData;
2031         int size = shared_objects->size();
2032         for(int i=0;shared_objects && i<size ; i++) {
2033                 sh_obj = (*shared_objects)[i];
2034
2035                 memcpy((void*) ptr, sh_obj->getName().string_of(), strlen(sh_obj->getName().string_of())+1);
2036                 //printf(" %s : ", ptr);
2037                 ptr += strlen(sh_obj->getName().string_of())+1;
2038
2039                 unsigned int baseAddr = sh_obj->getBaseAddress();
2040                 memcpy( (void*)ptr, &baseAddr, sizeof(unsigned int));
2041                 //printf(" 0x%x \n", *(unsigned int*) ptr);
2042                 ptr += sizeof(unsigned int);
2043         }
2044         memset( (void*)ptr, '\0' , 1);
2045                 
2046                 
2047         writeBackElf *newElf = new writeBackElf(( char*) getImage()->file().string_of(),
2048                                         "/tmp/dyninstMutatee",errFlag);
2049         newElf->registerProcess(this);
2050
2051 #ifdef USE_STL_VECTOR
2052         sort(highmemUpdates.begin(), highmemUpdates.end(), imageUpdateOrderingRelation());
2053 #else
2054         highmemUpdates.sort( imageUpdate::imageUpdateSort);
2055 #endif
2056         newElf->compactSections(highmemUpdates, compactedHighmemUpdates);
2057
2058         newElf->alignHighMem(compactedHighmemUpdates);
2059
2060
2061         unsigned int trampGuardValue;
2062         unsigned int pageSize = getpagesize();
2063         unsigned int startPage, stopPage;
2064         unsigned int numberUpdates=1;
2065         int startIndex, stopIndex;
2066         readDataSpace((void*) guardFlagAddr, sizeof(unsigned int),(void*) &trampGuardValue, true);
2067
2068         writeDataSpace((void*)guardFlagAddr, sizeof(unsigned int),(void*) &numberUpdates);
2069
2070         for(unsigned int j=0;j<compactedHighmemUpdates.size();j++){
2071           //the layout of dyninstAPIhighmem_%08x is:
2072           //pageData
2073           //address of update
2074           //size of update
2075           // ...
2076           //address of update
2077           //size of update
2078           //number of updates
2079
2080                 startPage =  compactedHighmemUpdates[j]->address - compactedHighmemUpdates[j]->address%pageSize;
2081                 stopPage = compactedHighmemUpdates[j]->address + compactedHighmemUpdates[j]->size-
2082                   (compactedHighmemUpdates[j]->address + compactedHighmemUpdates[j]->size )%pageSize;
2083                 numberUpdates = 0;
2084                 startIndex = -1;
2085                 stopIndex = -1;
2086
2087                         
2088                 for(unsigned index = 0;index < highmemUpdates.size(); index++){
2089                         //here we ignore anything with an address of zero.
2090                         //these can be safely deleted in writeBackElf
2091                         if( highmemUpdates[index]->address && startPage <= highmemUpdates[index]->address &&
2092                                 highmemUpdates[index]->address  < (startPage + compactedHighmemUpdates[j]->size)){
2093                                 numberUpdates ++;
2094                                 stopIndex = index;
2095                                 if(startIndex == -1){
2096                                         startIndex = index;
2097                                 }
2098                                 //printf(" HighMemUpdates address 0x%x \n", highmemUpdates[index]->address );
2099                         }
2100                 }
2101                 unsigned int dataSize = compactedHighmemUpdates[j]->size + sizeof(unsigned int) +
2102                   (2*(stopIndex - startIndex + 1) /*numberUpdates*/ * sizeof(unsigned int));
2103
2104                 (char*) data = new char[dataSize];
2105
2106                 //fill in pageData
2107                 readDataSpace((void*) compactedHighmemUpdates[j]->address, compactedHighmemUpdates[j]->size,
2108                               data, true);
2109
2110                 unsigned int *dataPtr = (unsigned int*) ( (char*) data + compactedHighmemUpdates[j]->size);
2111
2112                 //fill in address of update
2113                 //fill in size of update
2114                 for(unsigned index = startIndex; index<=stopIndex;index++){ 
2115                         memcpy(dataPtr, &highmemUpdates[index]->address ,sizeof(unsigned int));
2116                         dataPtr ++;
2117                         memcpy(dataPtr, &highmemUpdates[index]->size, sizeof(unsigned int));
2118                         dataPtr++;
2119                         //printf("%d J %d ADDRESS: 0x%x SIZE 0x%x\n",index, j,
2120                         //highmemUpdates[index]->address, highmemUpdates[index]->size);
2121                 }
2122                 //fill in number of updates
2123                 memcpy(dataPtr, &numberUpdates, sizeof(unsigned int));
2124                 //printf(" NUMBER OF UPDATES 0x%x\n\n",numberUpdates);
2125                 sprintf(name,"dyninstAPIhighmem_%08x",j);
2126
2127                 newElf->addSection(compactedHighmemUpdates[j]->address,data ,dataSize,name,false);
2128
2129                 //lastCompactedUpdateAddress = compactedHighmemUpdates[j]->address+1;
2130                 delete [] (char*) data;
2131         }
2132         writeDataSpace((void*)guardFlagAddr, sizeof(unsigned int), (void*)&trampGuardValue);
2133
2134         unsigned int k;
2135
2136         for( k=0;k<imageUpdates.size();k++){
2137           delete imageUpdates[k];
2138         }
2139
2140         for( k=0;k<highmemUpdates.size();k++){
2141           delete highmemUpdates[k];
2142         }
2143
2144         for(  k=0;k<compactedHighmemUpdates.size();k++){
2145           delete compactedHighmemUpdates[k];
2146         }
2147         if(mutatedSharedObjectsSize){
2148                 newElf->addSection(0 ,mutatedSharedObjects, 
2149                         mutatedSharedObjectsSize, "dyninstAPI_mutatedSO", false);
2150                 delete [] mutatedSharedObjects;
2151         }
2152         //the following is for the dlopen problem
2153         //newElf->addSection(dl_debug_statePltEntry, dyninst_SharedLibrariesData, 
2154         //dyninst_SharedLibrariesSize, "dyninstAPI_SharedLibraries", false);
2155         delete [] dyninst_SharedLibrariesData;
2156
2157         newElf->createElf();
2158
2159         elf_update(newElf->getElf(),ELF_C_WRITE); 
2160         addLibraryElf.driver(newElf->getElf(),fullName, "libdyninstAPI_RT.so.1");       
2161         return directoryName;   
2162
2163
2164
2165 }
2166
2167 #endif
2168
2169 #ifndef BPATCH_LIBRARY
2170 bool process::dumpImage() {return false;}
2171 #else
2172 bool process::dumpImage(string imageFileName) 
2173 {
2174     int newFd;
2175     image *im;
2176     int length = 0;
2177     string command;
2178
2179     im = getImage();
2180     string origFile = im->file();
2181
2182
2183     // first copy the entire image file
2184     command = "cp ";
2185     command += origFile;
2186     command += " ";
2187     command += imageFileName;
2188     system(command.string_of());
2189
2190     // now open the copy
2191     newFd = open(imageFileName.string_of(), O_RDWR, 0);
2192     if (newFd < 0) {
2193         // log error
2194         return false;
2195     }
2196
2197     Elf *elfp = elf_begin(newFd, ELF_C_READ, 0);
2198     Elf_Scn *scn = 0;
2199     u_int baseAddr = 0;
2200     int offset = 0;
2201
2202     Elf32_Ehdr* ehdrp;
2203     Elf_Scn* shstrscnp  = 0;
2204     Elf_Data* shstrdatap = 0;
2205     Elf32_Shdr* shdrp;
2206
2207     assert(ehdrp = elf32_getehdr(elfp));
2208     assert(((shstrscnp = elf_getscn(elfp, ehdrp->e_shstrndx)) != 0) &&
2209            ((shstrdatap = elf_getdata(shstrscnp, 0)) != 0));
2210     const char* shnames = (const char *) shstrdatap->d_buf;
2211
2212     while ((scn = elf_nextscn(elfp, scn)) != 0) {
2213         const char* name;
2214
2215         shdrp = elf32_getshdr(scn);
2216         name = (const char *) &shnames[shdrp->sh_name];
2217         if (!strcmp(name, ".text")) {
2218             offset = shdrp->sh_offset;
2219             length = shdrp->sh_size;
2220             baseAddr = shdrp->sh_addr;
2221             break;
2222         }
2223     }
2224
2225
2226     char tempCode[length];
2227
2228
2229     bool ret = readTextSpace_((void *) baseAddr, length, tempCode);
2230     if (!ret) {
2231        // log error
2232        return false;
2233     }
2234
2235     lseek(newFd, offset, SEEK_SET);
2236     write(newFd, tempCode, length);
2237     close(newFd);
2238
2239     return true;
2240 }
2241 #endif
2242
2243 #ifndef BPATCH_LIBRARY
2244
2245 float OS::compute_rusage_cpu() { return 0; }
2246
2247 float OS::compute_rusage_sys() { return 0; }
2248
2249 float OS::compute_rusage_min() { return 0; }
2250
2251 float OS::compute_rusage_maj() { return 0; }
2252
2253 float OS::compute_rusage_swap() { return 0; }
2254
2255 float OS::compute_rusage_io_in() { return 0; }
2256
2257 float OS::compute_rusage_io_out() { return 0; }
2258
2259 float OS::compute_rusage_msg_send() { return 0; }
2260
2261 float OS::compute_rusage_msg_recv() { return 0; }
2262
2263 float OS::compute_rusage_sigs() { return 0; }
2264
2265 float OS::compute_rusage_vol_cs() { return 0; }
2266
2267 float OS::compute_rusage_inv_cs() { return 0; }
2268
2269 #endif
2270
2271 int getNumberOfCPUs()
2272 {
2273   return sysconf(_SC_NPROCESSORS_ONLN);
2274 }
2275
2276 Address process::read_inferiorRPC_result_register(Register /*reg*/) {
2277    // On x86, the result is always stashed in %EAX
2278    int ret;
2279    ret = ptraceKludge::deliverPtraceReturn(this, PTRACE_PEEKUSER, EAX*4, 0);
2280    return (Address)ret;
2281 }
2282
2283 bool process::set_breakpoint_for_syscall_completion() {
2284         Address codeBase;
2285         codeBase = getPC( getPid() );
2286         readDataSpace( (void*)codeBase, 2, savedCodeBuffer, true);
2287
2288         instruction insnTrap;
2289         generateBreakPoint(insnTrap);
2290         writeDataSpace((void *)codeBase, 2, insnTrap.ptr());
2291
2292         inferiorrpc_cerr << "Set breakpoint at " << (void*)codeBase << endl;
2293
2294         return true;
2295 }
2296
2297 void process::clear_breakpoint_for_syscall_completion() {
2298         Address codeBase;
2299         codeBase = getPC( getPid() );
2300         writeDataSpace( (void*)codeBase, 2, savedCodeBuffer );
2301
2302         inferiorrpc_cerr << "Cleared breakpoint at " << (void*)codeBase << endl;
2303 }
2304
2305
2306 void print_read_error_info(const relocationEntry entry, 
2307       pd_Function *&target_pdf, Address base_addr) {
2308
2309     sprintf(errorLine, "  entry      : target_addr 0x%x\n",
2310             (unsigned)entry.target_addr());
2311     logLine(errorLine);
2312     sprintf(errorLine, "               rel_addr 0x%x\n", (unsigned)entry.rel_addr());
2313     logLine(errorLine);
2314     sprintf(errorLine, "               name %s\n", (entry.name()).string_of());
2315     logLine(errorLine);
2316
2317     sprintf(errorLine, "  target_pdf : symTabName %s\n",
2318             (target_pdf->symTabName()).string_of());
2319     logLine(errorLine);    
2320     sprintf(errorLine , "              prettyName %s\n",
2321             (target_pdf->symTabName()).string_of());
2322     logLine(errorLine);
2323     sprintf(errorLine , "              size %i\n",
2324             target_pdf->size());
2325     logLine(errorLine);
2326     sprintf(errorLine , "              addr 0x%x\n",
2327             (unsigned)target_pdf->addr());
2328     logLine(errorLine);
2329
2330     sprintf(errorLine, "  base_addr  0x%x\n", (unsigned)base_addr);
2331     logLine(errorLine);
2332 }
2333
2334 // findCallee: finds the function called by the instruction corresponding
2335 // to the instPoint "instr". If the function call has been bound to an
2336 // address, then the callee function is returned in "target" and the 
2337 // instPoint "callee" data member is set to pt to callee's function_base.  
2338 // If the function has not yet been bound, then "target" is set to the 
2339 // function_base associated with the name of the target function (this is 
2340 // obtained by the PLT and relocation entries in the image), and the instPoint
2341 // callee is not set.  If the callee function cannot be found, (ex. function
2342 // pointers, or other indirect calls), it returns false.
2343 // Returns false on error (ex. process doesn't contain this instPoint).
2344 //
2345 // The assumption here is that for all processes sharing the image containing
2346 // this instPoint they are going to bind the call target to the same function. 
2347 // For shared objects this is always true, however this may not be true for
2348 // dynamic executables.  Two a.outs can be identical except for how they are
2349 // linked, so a call to fuction foo in one version of the a.out may be bound
2350 // to function foo in libfoo.so.1, and in the other version it may be bound to 
2351 // function foo in libfoo.so.2.  We are currently not handling this case, since
2352 // it is unlikely to happen in practice.
2353 bool process::findCallee(instPoint &instr, function_base *&target){
2354     
2355     if((target = const_cast<function_base *>(instr.iPgetCallee()))) {
2356         return true; // callee already set
2357     }
2358
2359     // find the corresponding image in this process  
2360     const image *owner = instr.iPgetOwner();
2361     bool found_image = false;
2362     Address base_addr = 0;
2363     if(symbols == owner) {  found_image = true; } 
2364     else if(shared_objects){
2365         for(u_int i=0; i < shared_objects->size(); i++){
2366             if(owner == ((*shared_objects)[i])->getImage()) {
2367                 found_image = true;
2368                 base_addr = ((*shared_objects)[i])->getBaseAddress();
2369                 break;
2370             }
2371         }
2372     } 
2373     if(!found_image) {
2374         target = 0;
2375         return false; // image not found...this is bad
2376     }
2377
2378     // get the target address of this function
2379     Address target_addr = 0;
2380 //    Address insn_addr = instr.iPgetAddress(); 
2381     target_addr = instr.getTargetAddress();
2382
2383     if(!target_addr) {  
2384         // this is either not a call instruction or an indirect call instr
2385         // that we can't get the target address
2386         target = 0;
2387         return false;
2388     }
2389
2390     // see if there is a function in this image at this target address
2391     // if so return it
2392     pd_Function *pdf = 0;
2393     if( (pdf = owner->findFuncByAddr(target_addr,this)) ) {
2394         target = pdf;
2395         instr.set_callee(pdf);
2396         return true; // target found...target is in this image
2397     }
2398
2399     // else, get the relocation information for this image
2400     const Object &obj = owner->getObject();
2401     const vector<relocationEntry> *fbt;
2402     if(!obj.get_func_binding_table_ptr(fbt)) {
2403         target = 0;
2404         return false; // target cannot be found...it is an indirect call.
2405     }
2406
2407     // find the target address in the list of relocationEntries
2408     for(u_int i=0; i < fbt->size(); i++) {
2409         if((*fbt)[i].target_addr() == target_addr) {
2410             // check to see if this function has been bound yet...if the
2411             // PLT entry for this function has been modified by the runtime
2412             // linker
2413             pd_Function *target_pdf = 0;
2414             if(hasBeenBound((*fbt)[i], target_pdf, base_addr)) {
2415                 target = target_pdf;
2416                 instr.set_callee(target_pdf);
2417                 return true;  // target has been bound
2418             } 
2419             else {
2420                 // just try to find a function with the same name as entry 
2421                 target = findFuncByName((*fbt)[i].name());
2422                 if(target){
2423                     return true;
2424                 }
2425                 else {  
2426                     // KLUDGE: this is because we are not keeping more than
2427                     // one name for the same function if there is more
2428                     // than one.  This occurs when there are weak symbols
2429                     // that alias global symbols (ex. libm.so.1: "sin" 
2430                     // and "__sin").  In most cases the alias is the same as 
2431                     // the global symbol minus one or two leading underscores,
2432                     // so here we add one or two leading underscores to search
2433                     // for the name to handle the case where this string 
2434                     // is the name of the weak symbol...this will not fix 
2435                     // every case, since if the weak symbol and global symbol
2436                     // differ by more than leading underscores we won't find
2437                     // it...when we parse the image we should keep multiple
2438                     // names for pd_Functions
2439
2440                     string s = string("_");
2441                     s += (*fbt)[i].name();
2442                     target = findFuncByName(s);
2443                     if(target){
2444                         return true;
2445                     }
2446                     s = string("__");
2447                     s += (*fbt)[i].name();
2448                     target = findFuncByName(s);
2449                     if(target){
2450                         return true;
2451                     }
2452                 }
2453             }
2454             target = 0;
2455             return false;
2456         }
2457     }
2458     target = 0;
2459     return false;  
2460 }
2461
2462
2463 // hasBeenBound: returns true if the runtime linker has bound the
2464 // function symbol corresponding to the relocation entry in at the address
2465 // specified by entry and base_addr.  If it has been bound, then the callee 
2466 // function is returned in "target_pdf", else it returns false.
2467 bool process::hasBeenBound(const relocationEntry entry, 
2468                            pd_Function *&target_pdf, Address base_addr) {
2469
2470     if (status() == exited) return false;
2471
2472     // if the relocationEntry has not been bound yet, then the value
2473     // at rel_addr is the address of the instruction immediately following
2474     // the first instruction in the PLT entry (which is at the target_addr) 
2475     // The PLT entries are never modified, instead they use an indirrect 
2476     // jump to an address stored in the _GLOBAL_OFFSET_TABLE_.  When the 
2477     // function symbol is bound by the runtime linker, it changes the address
2478     // in the _GLOBAL_OFFSET_TABLE_ corresponding to the PLT entry
2479
2480     Address got_entry = entry.rel_addr() + base_addr;
2481     Address bound_addr = 0;
2482     if(!readDataSpace((const void*)got_entry, sizeof(Address), 
2483                         &bound_addr, true)){
2484         sprintf(errorLine, "read error in process::hasBeenBound addr 0x%x, pid=%d\n (readDataSpace returns 0)",(unsigned)got_entry,pid);
2485         logLine(errorLine);
2486         print_read_error_info(entry, target_pdf, base_addr);
2487         return false;
2488     }
2489
2490     if( !( bound_addr == (entry.target_addr()+6+base_addr)) ) {
2491         // the callee function has been bound by the runtime linker
2492         // find the function and return it
2493         target_pdf = findFuncByAddr(bound_addr);
2494         if(!target_pdf){
2495             return false;
2496         }
2497         return true;    
2498     }
2499     return false;
2500 }
2501
2502 #ifndef BPATCH_LIBRARY
2503
2504 timeUnit calcJiffyUnit() {
2505   // Determine the number of jiffies/sec by checking the clock idle time in
2506   // /proc/uptime against the jiffies idle time in /proc/stat
2507
2508   FILE *tmp = P_fopen( "/proc/uptime", "r" );
2509   assert( tmp );
2510   double uptimeReal;
2511   assert( 1 == fscanf( tmp, "%*f %lf", &uptimeReal ) );
2512   fclose( tmp );
2513   tmp = P_fopen( "/proc/stat", "r" );
2514   assert( tmp );
2515   int uptimeJiffies;
2516   assert( 1 == fscanf( tmp, "%*s %*d %*d %*d %d", &uptimeJiffies ) );
2517
2518   if (sysconf(_SC_NPROCESSORS_CONF) > 1) {
2519     // on SMP boxes, the first line is cumulative jiffies, the second line
2520     // is jiffies for cpu0 - on uniprocessors, this fscanf will fail as
2521     // there is only a single cpu line
2522     assert (1 == fscanf(tmp, "\ncpu0 %*d %*d %*d %d", &uptimeJiffies));
2523   }
2524
2525   fclose( tmp );
2526   int intJiffiesPerSec = static_cast<int>( static_cast<double>(uptimeJiffies) 
2527                                            / uptimeReal + 0.5 );
2528   timeUnit jiffy(fraction(1000000000LL, intJiffiesPerSec));
2529   return jiffy;
2530 }
2531
2532 bool process::isLibhrtimeAvail() {
2533 #ifdef HRTIME
2534   int result = ::isLibhrtimeAvail(&hr_cpu_link, getPid());
2535   return (result == 1);
2536 #else
2537   return false;
2538 #endif
2539 }
2540
2541 void process::free_hrtime_link() {
2542 #ifdef HRTIME
2543   int error = free_hrtime_struct(hr_cpu_link);
2544   if(error != 0) {
2545     cerr << "process::free_hrtime_link- Error in unmapping hrtime_struct for "
2546       " libhrtime\n";
2547   }
2548 #endif
2549 }
2550
2551 void process::initCpuTimeMgrPlt() {
2552   cpuTimeMgr->installLevel(cpuTimeMgr_t::LEVEL_ONE, &process::isLibhrtimeAvail,
2553                            getCyclesPerSecond(), timeBase::bNone(), 
2554                            &process::getRawCpuTime_hw, "hwCpuTimeFPtrInfo",
2555                            &process::free_hrtime_link);
2556   cpuTimeMgr->installLevel(cpuTimeMgr_t::LEVEL_TWO, &process::yesAvail, 
2557                            calcJiffyUnit(), timeBase::bNone(), 
2558                            &process::getRawCpuTime_sw, "swCpuTimeFPtrInfo");
2559 }
2560 #endif
2561
2562 fileDescriptor *getExecFileDescriptor(string filename,
2563                                      int &,
2564                                      bool)
2565 {
2566   fileDescriptor *desc = new fileDescriptor(filename);
2567   return desc;
2568 }
2569
2570 #if defined(USES_DYNAMIC_INF_HEAP)
2571 static const Address lowest_addr = 0x0;
2572 void inferiorMallocConstraints(Address near, Address &lo, Address &hi,
2573                                inferiorHeapType /* type */ )
2574 {
2575   if (near)
2576     {
2577       lo = region_lo(near);
2578       hi = region_hi(near);  
2579     }
2580 }
2581
2582 void inferiorMallocAlign(unsigned &size)
2583 {
2584      /* 32 byte alignment.  Should it be 64? */
2585   size = (size + 0x1f) & ~0x1f;
2586 }
2587 #endif
2588
2589 bool getLWPIDs(vector <unsigned> &LWPids)
2590 {
2591   LWPids.push_back(0);
2592   assert (0 && "Not implemented");
2593 }