BPatch functions that block are now locked (on a finer grain than the rest of the...
[dyninst.git] / dyninstAPI / src / linux.C
1 /*
2  * Copyright (c) 1996-2004 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 // $Id: linux.C,v 1.159 2005/02/25 07:04:46 jaw Exp $
43
44 #include <fstream>
45
46 #include "dyninstAPI/src/process.h"
47 #include "dyninstAPI/src/dyn_thread.h"
48 #include "dyninstAPI/src/dyn_lwp.h"
49
50 #include <sys/ptrace.h>
51 #include <asm/ptrace.h>
52 #include <sys/ioctl.h>
53 #include <fcntl.h>
54 #include <signal.h>
55 #include <dlfcn.h>
56 #include <sys/user.h>
57 #include <sys/time.h>
58 #include <sys/types.h>
59 #include <dirent.h>
60 #include <sys/resource.h>
61 #include <math.h> // for floor()
62 #include <unistd.h> // for sysconf()
63
64 #include "dyninstAPI/src/symtab.h"
65 #include "dyninstAPI/src/function.h"
66 #include "dyninstAPI/src/instPoint.h"
67 #include "dyninstAPI/src/trampTemplate.h"
68 #include "dyninstAPI/src/signalhandler.h"
69 #include "common/h/headers.h"
70 #include "dyninstAPI/src/os.h"
71 #include "dyninstAPI/src/stats.h"
72 #include "common/h/Types.h"
73 #include "dyninstAPI/src/showerror.h"
74 #include "dyninstAPI/src/util.h" // getCurrWallTime
75 #include "common/h/pathName.h"
76 #ifndef BPATCH_LIBRARY
77 #include "common/h/Time.h"
78 #include "common/h/timing.h"
79 #include "paradynd/src/init.h"
80 #endif
81
82 #include "dyninstAPI/src/addLibraryLinux.h"
83 #include "dyninstAPI/src/writeBackElf.h"
84 // #include "saveSharedLibrary.h" 
85
86 #ifdef PAPI
87 #include "papi.h"
88 #endif
89
90 static bool enable_process_control_debug = false;
91 #define DEBUG_PC_ENVNAME "DYNINSTAPI_DEBUG_PCONTROL"
92 #define pcout if (enable_process_control_debug) cerr
93
94 // The following were defined in process.C
95 // Shouldn't they be in a header, then? -- TLM
96
97 extern unsigned enable_pd_attach_detach_debug;
98
99 #if ENABLE_DEBUG_CERR == 1
100 #define attach_cerr if (enable_pd_attach_detach_debug) cerr
101 #else
102 #define attach_cerr if (0) cerr
103 #endif /* ENABLE_DEBUG_CERR == 1 */
104
105 extern unsigned enable_pd_inferior_rpc_debug;
106
107 #if ENABLE_DEBUG_CERR == 1
108 #define inferiorrpc_cerr if (enable_pd_inferior_rpc_debug) cerr
109 #else
110 #define inferiorrpc_cerr if (0) cerr
111 #endif /* ENABLE_DEBUG_CERR == 1 */
112
113 extern unsigned enable_pd_shm_sampling_debug;
114
115 #if ENABLE_DEBUG_CERR == 1
116 #define shmsample_cerr if (enable_pd_shm_sampling_debug) cerr
117 #else
118 #define shmsample_cerr if (0) cerr
119 #endif /* ENABLE_DEBUG_CERR == 1 */
120
121 extern unsigned enable_pd_fork_exec_debug;
122
123 #if ENABLE_DEBUG_CERR == 1
124 #define forkexec_cerr if (enable_pd_fork_exec_debug) cerr
125 #else
126 #define forkexec_cerr if (0) cerr
127 #endif /* ENABLE_DEBUG_CERR == 1 */
128
129 extern unsigned enable_pd_signal_debug;
130
131 #if ENABLE_DEBUG_CERR == 1
132 #define signal_cerr if (enable_pd_signal_debug) cerr
133 #else
134 #define signal_cerr if (0) cerr
135 #endif /* ENABLE_DEBUG_CERR == 1 */
136
137 extern void generateBreakPoint(instruction &insn);
138
139 #if defined(PTRACEDEBUG) && !defined(PTRACEDEBUG_ALWAYS)
140 static bool debug_ptrace = false;
141 #endif
142
143 bool dyn_lwp::deliverPtrace(int request, Address addr, Address data) {
144    bool needToCont = false;
145    int len = proc_->getAddressWidth();
146
147    if(request != PT_DETACH  &&  status() == running) {
148       cerr << "  potential performance problem with use of dyn_lwp::deliverPtrace\n";
149       if(pauseLWP() == true)
150          needToCont = true;
151    }
152
153    bool ret = (P_ptrace(request, get_lwp_id(), addr, data, len) != -1);
154    if (!ret) perror("Internal ptrace");
155    
156    if(request != PTRACE_DETACH  &&  needToCont == true)
157       continueLWP();
158    return ret;
159 }
160
161
162 // Some ptrace requests in Linux return the value rather than storing at the address in data
163 // (especially PEEK requests)
164 // - nash
165 int dyn_lwp::deliverPtraceReturn(int request, Address addr, Address data) {
166    bool needToCont = false;
167    int len = proc_->getAddressWidth();
168
169    if(request != PT_DETACH  &&  status() == running) {
170       cerr << "  potential performance problem with use of "
171            << "dyn_lwp::deliverPtraceReturn\n";
172       if(pauseLWP() == true)
173          needToCont = true;
174    }
175
176    int ret = P_ptrace(request, get_lwp_id(), addr, data, len);
177
178    if(request != PTRACE_DETACH  &&  needToCont == true)
179       continueLWP();
180    return ret;
181 }
182
183 /* ********************************************************************** */
184
185 void printStackWalk( process *p ) {
186   dyn_lwp *lwp_to_use = NULL;
187   if(process::IndependentLwpControl() && p->getRepresentativeLWP() ==NULL)
188      lwp_to_use = p->getInitialThread()->get_lwp();
189   else
190      lwp_to_use = p->getRepresentativeLWP();
191
192   Frame theFrame = lwp_to_use->getActiveFrame();
193   while (true) {
194     // do we have a match?
195     const Address framePC = theFrame.getPC();
196     inferiorrpc_cerr << "stack frame pc @ " << (void*)framePC << endl;
197     
198     if (theFrame.isLastFrame())
199       // well, we've gone as far as we can, with no match.
200       break;
201     
202     // else, backtrace 1 more level
203     theFrame = theFrame.getCallerFrame();
204   }
205 }
206  
207 // already setup on this FD.
208 // disconnect from controlling terminal 
209 void OS::osDisconnect(void) {
210   int ttyfd = open ("/dev/tty", O_RDONLY);
211   ioctl (ttyfd, TIOCNOTTY, NULL);
212   P_close (ttyfd);
213 }
214
215 // may be needed in the future
216 #if defined(DECODEANDHANDLE_EVENT_ON_LWP)
217 // returns true if it handled an event
218 bool checkForAndHandleProcessEventOnLwp(bool block, dyn_lwp *lwp) {
219    pdvector<procevent *> foundEvents;
220    getSH()->checkForProcessEvents(&foundEvents, lwp->get_lwp_id(), block);
221    getSH()->handleProcessEvents(foundEvents);
222    //assert(selectedLWP == lwp);
223    
224    return true;
225 }
226 #endif
227
228 void OS::osTraceMe(void) { P_ptrace(PTRACE_TRACEME, 0, 0, 0); }
229
230 // Wait for a process event to occur, then map it into
231 // the why/what space (a la /proc status variables)
232
233 int decodeRTSignal(process *proc,
234                    procSignalWhy_t &why,
235                    procSignalWhat_t &what,
236                    procSignalInfo_t &info)
237 {
238    // We've received a signal we believe was sent
239    // from the runtime library. Check the RT lib's
240    // status variable and return it.
241    // These should be made constants
242    if (!proc) return 0;
243
244    pdstring status_str = pdstring("DYNINST_instSyscallState");
245    pdstring arg_str = pdstring("DYNINST_instSyscallArg1");
246
247    int status;
248    Address arg;
249
250    bool err = false;
251    Address status_addr = proc->findInternalAddress(status_str, false, err);
252    if (err) {
253       // Couldn't find symbol
254       return 0;
255    }
256
257    if (!proc->readDataSpace((void *)status_addr, sizeof(int), 
258                             &status, true)) {
259       return 0;
260    }
261
262    if (status == 0) {
263       return 0; // Nothing to see here
264    }
265
266    Address arg_addr = proc->findInternalAddress(arg_str, false, err);
267    if (err) {
268       return 0;
269    }
270     
271    if (!proc->readDataSpace((void *)arg_addr, sizeof(Address),
272                             &arg, true))
273       assert(0);
274    info = (procSignalInfo_t)arg;
275    switch(status) {
276      case 1:
277         /* Entry to fork */
278         why = procSyscallEntry;
279         what = SYS_fork;
280         break;
281      case 2:
282         why = procSyscallExit;
283         what = SYS_fork;
284         break;
285      case 3:
286         /* Entry to exec */
287         why = procSyscallEntry;
288         what = SYS_exec;
289         break;
290      case 4:
291         /* Exit of exec, unused */
292         break;
293      case 5:
294         /* Entry of exit, used for the callback. We need to trap before
295            the process has actually exited as the callback may want to
296            read from the process */
297         why = procSyscallEntry;
298         what = SYS_exit;
299         break;
300      default:
301         assert(0);
302         break;
303    }
304    return 1;
305
306 }
307
308 // returns true if got event, false otherwise
309 bool checkForEventLinux(procevent *new_event, int wait_arg, 
310                         bool block, int wait_options)
311 {
312    int result = 0, status = 0;
313
314    if (!block) {
315       wait_options |= WNOHANG;
316    }
317
318    result = waitpid( wait_arg, &status, wait_options );
319    if (result < 0 && errno == ECHILD) {
320       return false; /* nothing to wait for */
321    } else if (result < 0) {
322       perror("checkForEventLinux: waitpid failure");
323    } else if(result == 0)
324       return false;
325
326    int pertinentPid = result;
327
328    // Translate the signal into a why/what combo.
329    // We can fake results here as well: translate a stop in fork
330    // to a (SYSEXIT,fork) pair. Don't do that yet.
331    process *pertinentProc = process::findProcess(pertinentPid);
332    dyn_lwp *pertinentLWP  = NULL;
333
334    if(pertinentProc) {
335       // Got a signal, process is stopped.
336       if(process::IndependentLwpControl() &&
337          pertinentProc->getRepresentativeLWP() == NULL) {
338          if (!pertinentProc->getInitialThread())
339            return false; //We must be shutting down
340          pertinentLWP = pertinentProc->getInitialThread()->get_lwp();
341       } else {
342          pertinentLWP = pertinentProc->getRepresentativeLWP();
343       }
344       pertinentProc->set_lwp_status(pertinentLWP, stopped);
345    } else {
346       extern pdvector<process*> processVec;
347       for (unsigned u = 0; u < processVec.size(); u++) {
348          process *curproc = processVec[u];
349          if(! curproc)
350             continue;
351          dyn_lwp *curlwp = NULL;
352          if( (curlwp = curproc->lookupLWP(pertinentPid)) ) {
353             pertinentProc = curproc;
354             pertinentLWP  = curlwp;
355             pertinentProc->set_lwp_status(curlwp, stopped);
356             break;
357          }
358       }
359    }
360    
361    procSignalWhy_t  why  = procUndefined;
362    procSignalWhat_t what = 0;
363    procSignalInfo_t info = 0;
364    
365    if (WIFEXITED(status)) {
366       // Process exited via signal
367       why = procExitedNormally;
368       what = WEXITSTATUS(status);
369    }
370    else if (WIFSIGNALED(status)) {
371       why = procExitedViaSignal;
372       what = WTERMSIG(status);
373    }
374    else if (WIFSTOPPED(status)) {
375       // More interesting (and common) case.  This is where return value
376       // faking would occur as well. procSignalled is a generic return.  For
377       // example, we translate SIGILL to SIGTRAP in a few cases
378       why = procSignalled;
379       what = WSTOPSIG(status);
380
381       switch(what) {
382         case SIGSTOP:
383            decodeRTSignal(pertinentProc, why, what, info);
384            break;
385         case SIGTRAP:
386         {
387            Frame sigframe = pertinentLWP->getActiveFrame();
388            if (pertinentProc->trampTrapMapping.defines(sigframe.getPC())) {
389               why = procInstPointTrap;
390               info = pertinentProc->trampTrapMapping[sigframe.getPC()];
391            }
392            // Also seen traps at PC+1
393            else if (pertinentProc->trampTrapMapping.defines(sigframe.getPC()-1)) 
394            {
395               why = procInstPointTrap;
396               info = pertinentProc->trampTrapMapping[sigframe.getPC()-1];
397            }
398            break;
399         }
400         case SIGCHLD:
401            // Linux fork() sends a SIGCHLD once the fork has been created
402            why = procForkSigChild;
403            break;
404         case SIGILL:
405            Address pc = getPC(pertinentPid);
406            
407            if(pc == pertinentProc->dyninstlib_brk_addr ||
408               pc == pertinentProc->main_brk_addr || 
409               pertinentProc->getDyn()->reachedLibHook(pc)) {
410                what = SIGTRAP;
411            }
412            break;
413       }
414    }
415
416    if(! pertinentProc)
417       return false;
418
419    (*new_event).proc = pertinentProc;
420    (*new_event).lwp  = pertinentLWP;
421    (*new_event).why  = why;
422    (*new_event).what = what;
423    (*new_event).info = info;
424
425    return true;
426 }
427
428 /**
429  * We sometimes receive an event from checkForEventLinux that we 
430  * don't want to deal with yet.  This function will insert the 
431  * event into a vector that 
432  **/
433
434 bool signalHandler::checkForProcessEvents(pdvector<procevent *> *events,
435                                           int wait_arg, int &timeout)
436 {
437    bool wait_on_initial_lwp = false;
438    bool wait_on_spawned_lwp = false;
439
440    if(wait_arg != -1) {
441       if(process::findProcess(wait_arg))
442          wait_on_initial_lwp = true;
443       else wait_on_spawned_lwp = true;
444    } else {
445       wait_on_initial_lwp = true;
446       wait_on_spawned_lwp = true;
447    }
448
449    /* If we're blocking, check to make sure we don't do so forever. */
450    if( -1 == timeout ) {
451       /* If we're waiting on just one process, only check it. */
452       if( wait_arg > 0 ) { 
453          process * proc = process::findProcess( wait_arg );
454          assert( proc != NULL );
455          
456          /* Having to enumerate everything is broken. */
457          if( proc->status() == exited 
458              || proc->status() == stopped 
459              || proc->status() == detached ) { return false; }
460       }
461       else {
462          /* Iterate over all the processes.  Prove progress because the processVec
463             may be empty. */
464          bool noneLeft = true;
465
466          for( unsigned i = 0; i < processVec.size(); i++ ) {
467             if( processVec[i] != NULL ) {
468                process * proc = processVec[i];
469                
470                /* Enumeration is broken, but I'm also wondering why we keep 
471                   processes around that are 'exited.' */
472                if( proc->status() != exited 
473                    && proc->status() != stopped 
474                    && proc->status() != detached ) { noneLeft = false;   }
475              }
476          }
477          if( noneLeft ) { return false; }
478       } /* end multiple-process wait */
479    } /* end if we're blocking */
480         
481    procevent *new_event = new procevent;
482    bool gotevent = false;
483    while(1) {
484       if(wait_on_initial_lwp) {
485          gotevent = checkForEventLinux(new_event, wait_arg, false, 0);
486          if(gotevent)
487             break;
488       }
489       if(wait_on_spawned_lwp) {
490          gotevent = checkForEventLinux(new_event, wait_arg, false, 
491                                              __WCLONE);
492          if(gotevent)
493             break;
494       }
495       if(! timeout) {
496          // no event found
497          delete new_event;
498          break;
499       } else {
500          // a slight delay to lesson impact of spinning.  this is
501          // particularly noticable when traps are hit at instrumentation
502          // points (seems to occur frequently in test1).
503          // *** important for performance ***
504
505          struct timespec slp, rem;
506          int wait_time = timeout;
507          if (timeout == -1) wait_time = 1; /*ms*/
508          if (wait_time > 1000) {
509            slp.tv_sec = wait_time / 1000;
510            slp.tv_nsec = (wait_time % 1000) /*ms*/ * 1000 /*us*/ * 1000 /*ns*/;
511          }
512          else {
513            slp.tv_sec = 0;
514            slp.tv_nsec = wait_time /*ms*/ * 1000 /*us*/ * 1000 /*ns*/;
515          }
516          if (-1 == nanosleep(&slp, &rem)) {
517            fprintf(stderr, "%s[%d]:  nanosleep: %d:%s\n", __FILE__, __LINE__,
518                   errno, strerror(errno));
519          }
520
521          //  can check remaining time to see if we have _really_ timed out
522          //  (but do we really care?)
523
524          if (timeout != -1) // if we're not blocking indefinitely
525            timeout = 0; // we have timed out
526       }
527    }
528
529    if(gotevent) {
530       (*events).push_back(new_event);
531       return true;
532    } else
533       return false;
534 }
535
536 void process::independentLwpControlInit() {
537    if(multithread_capable()) {
538       // On linux, if process found to be MT, there will be no
539       // representativeLWP since there is no lwp which controls the entire
540       // process for MT linux.
541       real_lwps[representativeLWP->get_lwp_id()] = representativeLWP;
542       representativeLWP = NULL;
543    }
544 }
545
546 dyn_lwp *process::createRepresentativeLWP() {
547    // the initial lwp has a lwp_id with the value of the pid
548
549    // if we identify this linux process as multi-threaded, then later we will
550    // adjust this lwp to be identified as a real lwp.
551    dyn_lwp *initialLWP = createFictionalLWP(getPid());
552    representativeLWP = initialLWP;
553    // Though on linux, if process found to be MT, there will be no
554    // representativeLWP since there is no lwp which controls the entire
555    // process for MT linux.
556
557    return initialLWP;
558 }
559
560 bool process::trapAtEntryPointOfMain(Address)
561 {
562   // is the trap instr at main_brk_addr?
563   if( getPC(getPid()) == (Address)main_brk_addr)
564     return(true);
565   else
566     return(false);
567 }
568
569 bool process::trapDueToDyninstLib()
570 {
571   // is the trap instr at dyninstlib_brk_addr?
572   if( getPC(getPid()) == (Address)dyninstlib_brk_addr){
573           dyninstlib_brk_addr = 0; //ccw 30 apr 2002 : SPLIT3
574           //dyninstlib_brk_addr and paradynlib_brk_addr may be the same
575           //if they are we dont want to get them mixed up. once we
576           //see this trap is due to dyninst, reset the addr so
577           //we can now catch the paradyn trap
578     return(true);
579   } else{
580     return(false);
581   }
582 }
583
584 bool process::setProcessFlags() {
585     // None that I'm aware of -- bernat, 24FEB04
586     return true;
587 }
588
589 bool process::unsetProcessFlags(){
590     // As above
591     return true;
592 }
593
594
595 void emitCallRel32(unsigned disp32, unsigned char *&insn);
596
597 static int lwp_kill(int pid, int sig)
598 {
599   int result = P_tkill(pid, sig);
600   if (result == -1 && errno == ENOSYS)
601   {
602      result = P_kill(pid, sig);
603      pcout << "Sent " << sig << " to " << pid << " via kill\n";
604   }
605   else
606      pcout << "Sent " << sig << " to " << pid << " via tkill\n";
607
608   return result;
609 }
610
611
612 /**
613  * Return the state of the process from /proc/pid/stat.
614  * File format is:
615  *   pid (executablename) state ...
616  * where state is a character.  Returns '\0' on error.
617  **/
618 static char getState(int pid)
619 {
620   char procName[64];
621   char sstat[256];
622   char *status;
623   int paren_level = 1;
624
625   sprintf(procName,"/proc/%d/stat", pid);
626   FILE *sfile = P_fopen(procName, "r");
627   if (sfile == NULL) return '\0';
628   fread( sstat, 1, 256, sfile );
629   fclose( sfile );
630   sstat[255] = '\0';
631   status = sstat;
632   
633   while (*status != '\0' && *(status++) != '(');
634   while (*status != '\0' && paren_level != 0)
635   {
636     if (*status == '(') paren_level++;
637     if (*status == ')') paren_level--;
638     status++;
639   }
640   while (*status == ' ') status++;
641   return *status;
642 }
643
644 bool process::isRunning_() const {
645   char result = getState(getpid());
646   assert(result != '\0');
647   return (result != 'T');
648 }
649
650 bool dyn_lwp::isRunning() const {
651   char result = getState(get_lwp_id());
652   assert(result != '\0');
653   return (result != 'T');
654 }
655
656 /**
657  * Reads events through a waitpid until a SIGSTOP blocks a LWP.
658  *  p - The process to work with
659  *  pid - If -1, then take a SIGSTOP from any lwp.  If non-zero then 
660  *        only take SIGSTOPs from that pid.
661  *  shouldBlock - Should we block until we get a SIGSTOP?
662  **/
663 static dyn_lwp *doWaitUntilStopped(process *p, int pid, bool shouldBlock)
664 {
665   procevent new_event;
666   bool gotevent, suppress_conts;
667   int result;
668   dyn_lwp *stopped_lwp = NULL;
669   pdvector<int> other_sigs;
670   pdvector<int> other_lwps;
671   unsigned i;
672
673   pcout << "doWaitUntilStopped called on " << pid 
674         << " (shouldBlock = " << shouldBlock << ")\n"; 
675
676   while (true)
677   {
678     gotevent = checkForEventLinux(&new_event, pid, shouldBlock, __WALL);
679     if (!gotevent)
680     {
681        pcout << "\tDidn't get an event\n";
682        break;
683     }
684
685     pcout << "\twhy = " << new_event.why 
686           << ", what = " << new_event.what 
687           << ", lwp = " << new_event.lwp->get_lwp_id() << endl;
688    
689     if (didProcReceiveSignal(new_event.why) && (new_event.what != SIGSTOP) || 
690         didProcReceiveInstTrap(new_event.why))
691     {
692       /**
693        * We caught a non-SIGTOP signal, let's throw it back.
694        **/
695        if (didProcReceiveSignal(new_event.why) && 
696            new_event.what != SIGILL && new_event.what != SIGTRAP &&
697            new_event.what != SIGFPE && new_event.what != SIGSEGV &&
698            new_event.what != SIGBUS)
699        {
700           //We don't actually throw back signals that are caused by 
701           // executing an instruction.  We can just drop these and
702           // let the continueLWP_ re-execute the instruction and cause
703           // it to be rethrown.
704           other_sigs.push_back(new_event.what);
705           other_lwps.push_back(new_event.lwp->get_lwp_id());
706           pcout << "\tpostponing " << new_event.what << endl;
707        }
708        else if (didProcReceiveInstTrap(new_event.why)) 
709        {
710           pcout << "\tReceived trap\n";
711           new_event.lwp->changePC(new_event.lwp->getActiveFrame().getPC() - 1, 
712                                   NULL);
713        }
714        else
715        {
716           pcout << "\tDropped " << new_event.what << endl;
717        }
718
719        new_event.lwp->continueLWP_(0);
720        new_event.proc->set_lwp_status(new_event.lwp, running);
721        continue;
722     }
723
724     suppress_conts =  (new_event.proc->getPid() != p->getPid() ||
725                        didProcEnterSyscall(new_event.why) ||
726                        didProcExitSyscall(new_event.why));
727     if (suppress_conts)
728     { 
729       pcout << "\tHandled, no suppression\n";
730       result = getSH()->handleProcessEvent(new_event);
731       continue;
732     }
733     else
734     {
735       p->setSuppressEventConts(true);    
736       result = getSH()->handleProcessEvent(new_event);
737       p->setSuppressEventConts(false);
738       pcout << "\tHandled, with suppression\n";
739     }
740
741     if (p->status() == exited)
742     {
743       pcout << "\tApp exited\n";
744       return NULL;
745     }
746
747     if (didProcReceiveSignal(new_event.why) && (new_event.what == SIGSTOP))
748     {
749       pcout << "\tGot my SIGSTOP\n";
750       stopped_lwp = new_event.lwp;
751       break;
752     }
753   }
754
755   assert(other_sigs.size() == other_lwps.size());
756   for (i = 0; i < other_sigs.size(); i++)
757   {
758     //Throw back the extra signals we caught.
759      pcout << "\tResending " << other_sigs[i] 
760            << "to " << other_lwps[i] << endl;
761     lwp_kill(other_lwps[i], other_sigs[i]);
762   }
763
764   if (stopped_lwp)
765     return stopped_lwp->status() == stopped ? stopped_lwp : NULL;
766   else 
767     return NULL;
768 }
769
770 bool dyn_lwp::removeSigStop()
771 {
772   return (lwp_kill(get_lwp_id(), SIGCONT) == 0);
773 }
774
775 bool dyn_lwp::continueLWP_(int signalToContinueWith) {
776    pcout << "Continuing LWP " << get_lwp_id() << " with " 
777          << signalToContinueWith << endl;
778    // we don't want to operate on the process in this state
779    int arg3 = 0;
780    int arg4 = 0;
781    if(signalToContinueWith != dyn_lwp::NoSignal) {
782       arg3 = 1;
783       arg4 = signalToContinueWith;
784    }
785
786    if (proc()->suppressEventConts())
787    {
788      return false;
789    }
790
791    ptraceOps++; 
792    ptraceOtherOps++;
793
794    int ret = P_ptrace(PTRACE_CONT, get_lwp_id(), arg3, arg4);
795    if (ret == 0)
796      return true;
797
798    /**
799     * A stopped ptrace'd process can be in two states on Linux.
800     * If it blocked on a signal, but never received a PTRACE_CONT,
801     * then it should be continued with a PTRACE_CONT.
802     *
803     * If the kernel couldn't find an awake thread to deliver the signal to,
804     * it'll grab anyone (usually the last) and wake them up for long enough
805     * to deliver the signal.  This leaves that thread is a different state
806     * than the others, and it won't actually respond to the PTRACE_CONT.  
807     **/
808
809    ret = P_kill(get_lwp_id(), SIGCONT);
810    if (ret == -1)
811      return false;
812    return true;
813 }
814
815 bool dyn_lwp::waitUntilStopped()
816 {
817   if (status() == stopped)
818   {
819     return true;
820   }
821
822   return (doWaitUntilStopped(proc(), get_lwp_id(), true) != NULL);
823 }
824
825 bool dyn_lwp::stop_() 
826 {
827   return (lwp_kill(get_lwp_id(), SIGSTOP) == 0);
828
829
830 bool process::continueProc_(int sig)
831 {
832   bool no_err = true;
833   dyn_lwp *lwp;
834   unsigned index = 0; 
835
836   //Continue all real LWPs
837   dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
838   while (lwp_iter.next(index, lwp))
839   {
840     if (lwp->status() == running)
841       continue;
842
843     bool result = lwp->continueLWP(sig);
844     if (result)
845       set_lwp_status(lwp, running);
846     else
847       no_err = false;
848   }
849
850   //Continue any representative LWP
851   if (representativeLWP && representativeLWP->status() != running)
852   {
853     bool result = representativeLWP->continueLWP(sig);
854     if (result)
855       set_lwp_status(representativeLWP, running);
856     else
857       no_err = false;
858   }
859
860   return no_err;
861 }
862
863 bool process::stop_()
864 {
865   int result;
866   static bool check_should_debug = false;
867
868   if (!check_should_debug)
869   {
870      enable_process_control_debug = (getenv(DEBUG_PC_ENVNAME) != NULL);
871      check_should_debug = true;
872   }
873   
874   //Stop the main process
875   result = P_kill(getPid(), SIGSTOP);
876   if (result == -1) 
877   {
878     perror("Couldn't send SIGSTOP\n");
879     return false;
880   }
881
882   dyn_lwp *lwp = waitUntilLWPStops();
883   if (!lwp)
884   {
885     return false;
886   }
887   if (status() == exited)
888     return false;
889
890   //Stop all other LWPs
891   dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
892   unsigned index = 0;
893   
894   while(lwp_iter.next(index, lwp))
895   {
896     lwp->pauseLWP(true);
897   }
898
899   return true;
900 }
901
902 bool process::waitUntilStopped()
903 {
904   dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
905   dyn_lwp *lwp;
906   unsigned index = 0;
907   bool result = true;
908
909   while(lwp_iter.next(index, lwp))
910   {
911     result &= lwp->waitUntilStopped();
912   }
913
914   return result;
915 }
916
917 dyn_lwp *process::waitUntilLWPStops()
918 {
919   return doWaitUntilStopped(this, -1, true);
920 }
921
922 terminateProcStatus_t process::terminateProc_()
923 {
924   if (kill( getPid(), SIGKILL )) {
925     // Kill failed... 
926     if (errno == ESRCH)
927       return alreadyTerminated;
928     else
929       return terminateFailed;
930   }
931   else
932     return terminateSucceeded;
933 }
934
935 void dyn_lwp::realLWP_detach_() {
936     if(! proc_->isAttached()) {
937       if (! proc_->hasExited())
938         cerr << "Detaching, but not attached" << endl;
939       return;
940     }
941     
942     cerr <<"Detaching..." << endl;
943     ptraceOps++;
944     ptraceOtherOps++;
945     bperr( "%d\n", deliverPtrace(PTRACE_DETACH, 1, SIGCONT));
946     
947     return;
948 }
949
950 void dyn_lwp::representativeLWP_detach_() {
951     // If the process is already exited, then don't call ptrace
952     if(! proc_->isAttached())
953         return;
954     
955     if (fd_) close(fd_);
956     
957     ptraceOps++;
958     ptraceOtherOps++;
959     deliverPtrace(PTRACE_DETACH, 1, SIGCONT);
960     return;
961 }
962
963 bool process::dumpCore_(const pdstring/* coreFile*/) { return false; }
964
965 bool dyn_lwp::writeTextWord(caddr_t inTraced, int data) {
966    //  cerr << "writeTextWord @ " << (void *)inTraced << endl; cerr.flush();
967    return writeDataSpace(inTraced, sizeof(int), (caddr_t) &data);
968 }
969
970 bool dyn_lwp::writeTextSpace(void *inTraced, u_int amount, const void *inSelf)
971 {
972   //    cerr << "writeTextSpace pid=" << getPid() << ", @ " << (void *)inTraced
973   //     << " len=" << amount << endl; cerr.flush();
974    return writeDataSpace(inTraced, amount, inSelf);
975 }
976
977 bool dyn_lwp::readTextSpace(void *inTraced, u_int amount, const void *inSelf) {
978    return readDataSpace(inTraced, amount, const_cast<void*>( inSelf ));
979 }
980
981 bool dyn_lwp::writeDataSpace(void *inTraced, u_int nbytes, const void *inSelf)
982 {
983    unsigned char *ap = (unsigned char*) inTraced;
984    const unsigned char *dp = (const unsigned char*) inSelf;
985    Address w;               /* ptrace I/O buffer */
986    int len = sizeof(Address); /* address alignment of ptrace I/O requests */
987    unsigned cnt;
988
989    //cerr << "writeDataSpace pid=" << getPid() << ", @ " << (void *)inTraced
990    //    << " len=" << nbytes << endl; cerr.flush();
991
992 #if defined(BPATCH_LIBRARY)
993 #if defined(i386_unknown_linux2_0) \
994  || defined(x86_64_unknown_linux2_4) /* Blind duplication - Ray */
995    if (proc_->collectSaveWorldData) {
996        codeRange *range = NULL;
997         proc_->codeRangesByAddr_->precessor((Address)inTraced, range); //findCodeRangeByAddress((Address)inTraced);
998         if(range){
999                 shared_object *sharedobj_ptr = range->is_shared_object();
1000                if (sharedobj_ptr) {
1001                    // If we're writing into a shared object, mark it as dirty.
1002                    // _Unless_ we're writing "__libc_sigaction"
1003                    int_function *func = range->is_function();
1004                    if ((! func) || (func->prettyName() != "__libc_sigaction")){
1005                       sharedobj_ptr->setDirty();
1006                    }
1007                }
1008         }
1009    }
1010 #endif
1011 #endif
1012
1013    ptraceOps++; ptraceBytes += nbytes;
1014
1015    if (0 == nbytes)
1016       return true;
1017
1018    if ((cnt = ((Address)ap) % len)) {
1019       /* Start of request is not aligned. */
1020       unsigned char *p = (unsigned char*) &w;     
1021
1022       /* Read the segment containing the unaligned portion, edit
1023          in the data from DP, and write the segment back. */
1024       errno = 0;
1025       w = P_ptrace(PTRACE_PEEKTEXT, get_lwp_id(), (Address) (ap-cnt), 0);
1026
1027       if (errno)
1028          return false;
1029
1030       for (unsigned i = 0; i < len-cnt && i < nbytes; i++)
1031          p[cnt+i] = dp[i];
1032
1033       if (0 > P_ptrace(PTRACE_POKETEXT, get_lwp_id(), (Address) (ap-cnt), w))
1034          return false;
1035
1036       if (len-cnt >= nbytes) 
1037          return true; /* done */
1038           
1039       dp += len-cnt;
1040       ap += len-cnt;
1041       nbytes -= len-cnt;
1042    }      
1043           
1044    /* Copy aligned portion */
1045    while (nbytes >= (u_int)len) {
1046       assert(0 == ((Address)ap) % len);
1047       memcpy(&w, dp, len);
1048       int retval =  P_ptrace(PTRACE_POKETEXT, get_lwp_id(), (Address) ap, w);
1049       if (retval < 0)
1050          return false;
1051
1052       // Check...
1053       /*
1054       Address test;
1055       fprintf(stderr, "Writing %x... ", w);
1056       test = P_ptrace(PTRACE_PEEKTEXT, get_lwp_id(), (Address) ap, 0);
1057       fprintf(stderr, "... got %x, lwp %d\n", test, get_lwp_id());
1058       */      
1059       dp += len;
1060       ap += len;
1061       nbytes -= len;
1062    }
1063
1064    if (nbytes > 0) {
1065       /* Some unaligned data remains */
1066       unsigned char *p = (unsigned char *) &w;
1067
1068       /* Read the segment containing the unaligned portion, edit
1069          in the data from DP, and write it back. */
1070       errno = 0;
1071       w = P_ptrace(PTRACE_PEEKTEXT, get_lwp_id(), (Address) ap, 0);
1072
1073       if (errno)
1074          return false;
1075
1076       for (unsigned i = 0; i < nbytes; i++)
1077          p[i] = dp[i];
1078
1079       if (0 > P_ptrace(PTRACE_POKETEXT, get_lwp_id(), (Address) ap, w))
1080          return false;
1081
1082    }
1083
1084    return true;
1085 }
1086
1087 #if 0
1088 bool dyn_lwp::writeDataSpace(void *inTraced, u_int nbytes, const void *inSelf)
1089 {
1090    unsigned char *ap = (unsigned char*) inTraced;
1091    const unsigned char *dp = (const unsigned char*) inSelf;
1092    Address w;               /* ptrace I/O buffer */
1093    int len = proc_->getAddressWidth(); /* address alignment of ptrace I/O requests */
1094    unsigned cnt;
1095
1096    //cerr << "writeDataSpace pid=" << getPid() << ", @ " << (void *)inTraced
1097    //    << " len=" << nbytes << endl; cerr.flush();
1098
1099 #if defined(BPATCH_LIBRARY)
1100 #if defined(i386_unknown_linux2_0) \
1101  || defined(x86_64_unknown_linux2_4) /* Blind duplication - Ray */
1102    if (proc_->collectSaveWorldData) {
1103        codeRange *range = NULL;
1104         proc_->codeRangesByAddr_->precessor((Address)inTraced, range); //findCodeRangeByAddress((Address)inTraced);
1105         if(range){
1106                 shared_object *sharedobj_ptr = range->is_shared_object();
1107                if (sharedobj_ptr) {
1108                    // If we're writing into a shared object, mark it as dirty.
1109                    // _Unless_ we're writing "__libc_sigaction"
1110                    int_function *func = range->is_function();
1111                    if ((! func) || (func->prettyName() != "__libc_sigaction")){
1112                       sharedobj_ptr->setDirty();
1113                    }
1114                }
1115         }
1116    }
1117 #endif
1118 #endif
1119
1120    ptraceOps++; ptraceBytes += nbytes;
1121
1122    if (0 == nbytes)
1123       return true;
1124
1125    if ((cnt = ((Address)ap) % len)) {
1126       /* Start of request is not aligned. */
1127       unsigned char *p = (unsigned char*) &w;     
1128
1129       /* Read the segment containing the unaligned portion, edit
1130          in the data from DP, and write the segment back. */
1131       errno = 0;
1132       w = P_ptrace(PTRACE_PEEKTEXT, get_lwp_id(), (Address) (ap-cnt), 0, len);
1133
1134       if (errno)
1135          return false;
1136
1137       for (unsigned i = 0; i < len-cnt && i < nbytes; i++)
1138          p[cnt+i] = dp[i];
1139
1140       if (0 > P_ptrace(PTRACE_POKETEXT, get_lwp_id(), (Address) (ap-cnt), w, len))
1141          return false;
1142
1143       if (len-cnt >= nbytes) 
1144          return true; /* done */
1145           
1146       dp += len-cnt;
1147       ap += len-cnt;
1148       nbytes -= len-cnt;
1149    }      
1150           
1151    /* Copy aligned portion */
1152    while (nbytes >= (u_int)len) {
1153       assert(0 == ((Address)ap) % len);
1154       memcpy(&w, dp, len);
1155       int retval =  P_ptrace(PTRACE_POKETEXT, get_lwp_id(), (Address) ap, w, len);
1156       if (retval < 0)
1157          return false;
1158
1159       // Check...
1160       /*
1161       Address test;
1162       fprintf(stderr, "Writing %x... ", w);
1163       test = P_ptrace(PTRACE_PEEKTEXT, get_lwp_id(), (Address) ap, 0, len);
1164       fprintf(stderr, "... got %x, lwp %d\n", test, get_lwp_id());
1165       */      
1166       dp += len;
1167       ap += len;
1168       nbytes -= len;
1169    }
1170
1171    if (nbytes > 0) {
1172       /* Some unaligned data remains */
1173       unsigned char *p = (unsigned char *) &w;
1174
1175       /* Read the segment containing the unaligned portion, edit
1176          in the data from DP, and write it back. */
1177       errno = 0;
1178       w = P_ptrace(PTRACE_PEEKTEXT, get_lwp_id(), (Address) ap, 0, len);
1179
1180       if (errno)
1181          return false;
1182
1183       for (unsigned i = 0; i < nbytes; i++)
1184          p[i] = dp[i];
1185
1186       if (0 > P_ptrace(PTRACE_POKETEXT, get_lwp_id(), (Address) ap, w, len))
1187          return false;
1188
1189    }
1190
1191    return true;
1192 }
1193 #endif
1194
1195 bool dyn_lwp::readDataSpace(const void *inTraced, u_int nbytes, void *inSelf) {
1196      const unsigned char *ap = (const unsigned char*) inTraced;
1197      unsigned char *dp = (unsigned char*) inSelf;
1198      Address w;               /* ptrace I/O buffer */
1199      int len = proc_->getAddressWidth(); /* address alignment of ptrace I/O requests */
1200      unsigned cnt;
1201
1202      ptraceOps++; ptraceBytes += nbytes;
1203
1204      if (0 == nbytes)
1205           return true;
1206
1207      if ((cnt = ((Address)ap) % len)) {
1208           /* Start of request is not aligned. */
1209           unsigned char *p = (unsigned char*) &w;
1210
1211           /* Read the segment containing the unaligned portion, and
1212              copy what was requested to DP. */
1213           errno = 0;
1214           w = P_ptrace(PTRACE_PEEKTEXT, get_lwp_id(), (Address) (ap-cnt), w, len);
1215           if (errno)
1216                return false;
1217           for (unsigned i = 0; i < len-cnt && i < nbytes; i++)
1218                dp[i] = p[cnt+i];
1219
1220           if (len-cnt >= nbytes)
1221                return true; /* done */
1222
1223           dp += len-cnt;
1224           ap += len-cnt;
1225           nbytes -= len-cnt;
1226      }
1227
1228      /* Copy aligned portion */
1229      while (nbytes >= (u_int)len) {
1230           errno = 0;
1231           w = P_ptrace(PTRACE_PEEKTEXT, get_lwp_id(), (Address) ap, 0, len);
1232           if (errno)
1233               return false;
1234           memcpy(dp, &w, len);
1235           dp += len;
1236           ap += len;
1237           nbytes -= len;
1238      }
1239
1240      if (nbytes > 0) {
1241           /* Some unaligned data remains */
1242           unsigned char *p = (unsigned char *) &w;
1243           
1244           /* Read the segment containing the unaligned portion, and
1245              copy what was requested to DP. */
1246           errno = 0;
1247           w = P_ptrace(PTRACE_PEEKTEXT, get_lwp_id(), (Address) ap, 0, len);
1248           if (errno)
1249                return false;
1250           for (unsigned i = 0; i < nbytes; i++)
1251                dp[i] = p[i];
1252      }
1253      return true;
1254 }
1255
1256 // You know, /proc/*/exe is a perfectly good link (directly to the inode) to
1257 // the executable file, who cares where the executable really is, we can open
1258 // this link. - nash
1259 pdstring process::tryToFindExecutable(const pdstring & /* iprogpath */, int pid) {
1260   // We need to dereference the /proc link.
1261   // Case 1: multiple copies of the same file opened with multiple
1262   // pids will not match (and should)
1263   // Case 2: an exec'ed program will have the same /proc path,
1264   // but different program paths
1265   pdstring procpath = pdstring("/proc/") + pdstring(pid) + pdstring("/exe");
1266   char buf[1024];
1267   int chars_read = readlink(procpath.c_str(), buf, 1024);
1268   if (chars_read == -1) {
1269     // Note: the name could be too long. Not handling yet.
1270     perror("Reading file name from /proc entry");
1271     return procpath;
1272   }
1273   buf[chars_read] = 0;
1274   return pdstring(buf);
1275 }
1276
1277
1278 void process::determineLWPs(pdvector<unsigned> *all_lwps)
1279 {
1280   char procdir[128];
1281   struct dirent *direntry;
1282   
1283   sprintf(procdir, "/proc/%d/task", getPid());
1284   DIR *dirhandle = opendir(procdir);
1285
1286   //Only works on Linux 2.6
1287   if (dirhandle)
1288   {
1289     while((direntry = readdir(dirhandle)) != NULL) {
1290       unsigned lwp_id = atoi(direntry->d_name);
1291       if (lwp_id) 
1292         all_lwps->push_back(lwp_id);
1293     }
1294     closedir(dirhandle);
1295     return;
1296   }
1297
1298
1299 #if !defined(BPATCH_LIBRARY)
1300 #ifdef PAPI
1301 papiMgr* dyn_lwp::papi() {
1302
1303   return proc()->getPapiMgr();
1304
1305 }
1306 #endif
1307 #endif
1308
1309
1310 #if !defined(BPATCH_LIBRARY)
1311
1312 rawTime64 dyn_lwp::getRawCpuTime_hw()
1313 {
1314   rawTime64 result = 0;
1315   
1316 #ifdef PAPI
1317   result = papi()->getCurrentVirtCycles();
1318 #endif
1319   
1320   if (result < hw_previous_) {
1321     logLine("********* time going backwards in paradynd **********\n");
1322     result = hw_previous_;
1323   }
1324   else 
1325     hw_previous_ = result;
1326   
1327   return result;
1328 }
1329
1330 rawTime64 dyn_lwp::getRawCpuTime_sw()
1331 {
1332   rawTime64 result = 0;
1333   int bufsize = 150;
1334   unsigned long utime, stime;
1335   char procfn[bufsize], *buf;
1336
1337   sprintf( procfn, "/proc/%d/stat", get_lwp_id());
1338
1339   int fd;
1340
1341   // The reason for this complicated method of reading and sseekf-ing is
1342   // to ensure that we read enough of the buffer 'atomically' to make sure
1343   // the data is consistent.  Is this necessary?  I *think* so. - nash
1344   do {
1345     fd = P_open(procfn, O_RDONLY, 0);
1346     if (fd < 0) {
1347       shmsample_cerr << "getInferiorProcessCPUtime: open failed: " << sys_errlist[errno] << endl;
1348       return false;
1349     }
1350
1351     buf = new char[ bufsize ];
1352
1353     if ((int)P_read( fd, buf, bufsize-1 ) < 0) {
1354       perror("getInferiorProcessCPUtime");
1355       return false;
1356     }
1357
1358         /* While I'd bet that any of the numbers preceding utime and stime could overflow 
1359            a signed int on IA-64, the compiler whines if you add length specifiers to
1360            elements whose conversion has been surpressed. */
1361     if(2==sscanf(buf,"%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %lu %lu "
1362                  , &utime, &stime ) ) {
1363       // These numbers are in 'jiffies' or timeslices.
1364       // Oh, and I'm also assuming that process time includes system time
1365       result = static_cast<rawTime64>(utime) + static_cast<rawTime64>(stime);
1366       break;
1367     }
1368
1369     delete [] buf;
1370     shmsample_cerr << "Inferior CPU time buffer expansion (" << bufsize << ")" << endl;
1371     bufsize = bufsize * 2;
1372
1373     P_close( fd );
1374   } while ( true );
1375
1376   delete [] buf;
1377   P_close(fd);
1378
1379   if (result < sw_previous_) {
1380     logLine("********* time going backwards in paradynd **********\n");
1381     result = sw_previous_;
1382   }
1383   else 
1384     sw_previous_ = result;
1385
1386   return result;
1387 }
1388 #endif
1389
1390
1391 procSyscall_t decodeSyscall(process * /*p*/, procSignalWhat_t what)
1392 {
1393    switch (what) {
1394       case SYS_fork:
1395          return procSysFork;
1396          break;
1397       case SYS_exec:
1398          return procSysExec;
1399          break;
1400       case SYS_exit:
1401          return procSysExit;
1402          break;
1403       default:
1404          return procSysOther;
1405          break;
1406    }
1407    assert(0);
1408    return procSysOther;
1409 }
1410
1411 bool process::dumpImage( pdstring imageFileName ) {
1412         /* What we do is duplicate the original file,
1413            and replace the copy's .text section with
1414            the (presumably instrumented) in-memory
1415            executable image.  Note that we don't seem
1416            to be concerned with making sure that we
1417            actually grab the instrumentation code itself... */
1418         
1419         /* Acquire the filename. */
1420         image * theImage = getImage();
1421         pdstring originalFileName = theImage->file();
1422         
1423         /* Use system() to execute the copy. */
1424         pdstring copyCommand = "cp " + originalFileName + " " + imageFileName;
1425     system( copyCommand.c_str() );
1426
1427         /* Open the copy so we can use libelf to find the .text section. */
1428         int copyFD = open( imageFileName.c_str(), O_RDWR, 0 );
1429         if( copyFD < 0 ) { return false; }
1430
1431         /* Start up the elven widgetry. */
1432         Elf * elfPointer = elf_begin( copyFD, ELF_C_READ, NULL );
1433         char * elfIdent = elf_getident( elfPointer, NULL );
1434         char elfClass = elfIdent[ EI_CLASS ];
1435         
1436         bool is64Bits;
1437         switch( elfClass ) {
1438                 case ELFCLASSNONE:
1439                         /* Shouldn't happen. */
1440                         elf_end( elfPointer );
1441                         close( copyFD );
1442                         return false;
1443
1444                 case ELFCLASS32:
1445                         is64Bits = false;
1446                         break;
1447                         
1448                 case ELFCLASS64:
1449                         is64Bits = true;
1450                         break;
1451                         
1452                 default:
1453                         /* Can't happen. */
1454                         assert( 0 );
1455                         break;
1456                 } /* end elfClass switch */
1457
1458     /* Acquire the shared names pointer. */
1459     const char * sharedNames = NULL;
1460     if( is64Bits ) {
1461         Elf64_Ehdr * elfHeader = elf64_getehdr( elfPointer );
1462         assert( elfHeader != NULL );
1463         
1464         Elf_Scn * elfSection = elf_getscn( elfPointer, elfHeader->e_shstrndx );
1465         assert( elfSection != NULL );
1466
1467         Elf_Data * elfData = elf_getdata( elfSection, 0 );
1468         assert( elfData != NULL );
1469                         
1470         sharedNames = (const char *) elfData->d_buf;
1471         }
1472     else {
1473         Elf32_Ehdr * elfHeader = elf32_getehdr( elfPointer );
1474         assert( elfHeader != NULL );
1475         
1476         Elf_Scn * elfSection = elf_getscn( elfPointer, elfHeader->e_shstrndx );
1477         assert( elfSection != NULL );
1478
1479         Elf_Data * elfData = elf_getdata( elfSection, 0 );
1480         assert( elfData != NULL );
1481                         
1482         sharedNames = (const char *) elfData->d_buf;
1483                 }   
1484     
1485         /* Iterate over the sections to find the text section's
1486            offset, length, and base address. */
1487         Address offset = 0;
1488         Address length = 0;
1489         Address baseAddr = 0;
1490            
1491         Elf_Scn * elfSection = NULL;
1492         while( (elfSection = elf_nextscn( elfPointer, elfSection )) != NULL ) {
1493                 if( is64Bits ) {
1494                         Elf64_Shdr * elfSectionHeader = elf64_getshdr( elfSection );
1495                         const char * name = (const char *) & sharedNames[ elfSectionHeader->sh_name ];
1496
1497                         if( strcmp( name, ".text" ) == 0 ) {
1498                                 offset = elfSectionHeader->sh_offset;
1499                                 length = elfSectionHeader->sh_size;
1500                                 baseAddr = elfSectionHeader->sh_addr;
1501                                 break;
1502                                 } /* end if we've found the text section */
1503                         } else {
1504                         Elf32_Shdr * elfSectionHeader = elf32_getshdr( elfSection );
1505                         const char * name = (const char *) & sharedNames[ elfSectionHeader->sh_name ];
1506
1507                         if( strcmp( name, ".text" ) == 0 ) {
1508                                 offset = elfSectionHeader->sh_offset;
1509                                 length = elfSectionHeader->sh_size;
1510                                 baseAddr = elfSectionHeader->sh_addr;
1511                                 break;
1512                                 } /* end if we've found the text section */
1513                         }
1514                 } /* end iteration over sections */
1515
1516         /* Copy the code out of the mutatee. */
1517         char * codeBuffer = (char *)malloc( length );
1518         assert( codeBuffer != NULL );
1519
1520         if( ! readTextSpace( (void *) baseAddr, length, codeBuffer ) ) {
1521                 free( codeBuffer );
1522                 elf_end( elfPointer );
1523                 close( copyFD );
1524                 return false;
1525                 }
1526
1527         /* Write that code to the image file. */
1528     lseek( copyFD, offset, SEEK_SET );
1529     write( copyFD, codeBuffer, length );
1530     
1531     /* Clean up. */
1532     free( codeBuffer );
1533     elf_end( elfPointer );
1534     close( copyFD );
1535     return true;
1536 }
1537
1538 int getNumberOfCPUs()
1539 {
1540   return sysconf(_SC_NPROCESSORS_ONLN);
1541 }
1542
1543 // findCallee: finds the function called by the instruction corresponding
1544 // to the instPoint "instr". If the function call has been bound to an
1545 // address, then the callee function is returned in "target" and the 
1546 // instPoint "callee" data member is set to pt to callee's int_function.  
1547 // If the function has not yet been bound, then "target" is set to the 
1548 // int_function associated with the name of the target function (this is 
1549 // obtained by the PLT and relocation entries in the image), and the instPoint
1550 // callee is not set.  If the callee function cannot be found, (ex. function
1551 // pointers, or other indirect calls), it returns false.
1552 // Returns false on error (ex. process doesn't contain this instPoint).
1553 //
1554 // The assumption here is that for all processes sharing the image containing
1555 // this instPoint they are going to bind the call target to the same function. 
1556 // For shared objects this is always true, however this may not be true for
1557 // dynamic executables.  Two a.outs can be identical except for how they are
1558 // linked, so a call to fuction foo in one version of the a.out may be bound
1559 // to function foo in libfoo.so.1, and in the other version it may be bound to 
1560 // function foo in libfoo.so.2.  We are currently not handling this case, since
1561 // it is unlikely to happen in practice.
1562 bool process::findCallee(instPoint &instr, int_function *&target){
1563
1564    if((target = instr.getCallee())) {
1565       return true; // callee already set
1566    }
1567    
1568    // find the corresponding image in this process  
1569    const image *owner = instr.getOwner();
1570    bool found_image = false;
1571    Address base_addr = 0;
1572    if(symbols == owner) {  found_image = true; } 
1573    else if(shared_objects){
1574       for(u_int i=0; i < shared_objects->size(); i++){
1575          if(owner == ((*shared_objects)[i])->getImage()) {
1576             found_image = true;
1577             base_addr = ((*shared_objects)[i])->getBaseAddress();
1578             break;
1579          }
1580       }
1581    } 
1582
1583    if(!found_image) {
1584       target = 0;
1585       return false; // image not found...this is bad
1586    }
1587
1588    // get the target address of this function
1589    Address target_addr = 0;
1590    //    Address insn_addr = instr.pointAddr(); 
1591    target_addr = instr.getTargetAddressAbs(this);
1592    if(!target_addr) {
1593       // this is either not a call instruction or an indirect call instr
1594       // that we can't get the target address
1595       target = 0;
1596       return false;
1597    }
1598
1599    // see if there is a function in this image at this target address
1600    // if so return it
1601    int_function *pdf = 0;
1602    if( (pdf = this->findFuncByAddr(target_addr))) {
1603        target = pdf;
1604        instr.setCallee(pdf);
1605        return true; // target found...target is in this image
1606    }
1607    
1608    // else, get the relocation information for this image
1609    const Object &obj = owner->getObject();
1610    const pdvector<relocationEntry> *fbt;
1611    if(!obj.get_func_binding_table_ptr(fbt)) {
1612       target = 0;
1613       return false; // target cannot be found...it is an indirect call.
1614    }
1615
1616    // find the target address in the list of relocationEntries
1617    for(u_int i=0; i < fbt->size(); i++) {
1618       if((*fbt)[i].target_addr() == target_addr) {
1619          // check to see if this function has been bound yet...if the
1620          // PLT entry for this function has been modified by the runtime
1621          // linker
1622          int_function *target_pdf = 0;
1623          if(hasBeenBound((*fbt)[i], target_pdf, base_addr)) {
1624             target = target_pdf;
1625             instr.setCallee(target_pdf);
1626             return true;  // target has been bound
1627          } 
1628          else {
1629             pdvector<int_function *> pdfv;
1630             bool found = findAllFuncsByName((*fbt)[i].name(), pdfv);
1631             if(found) {
1632                assert(pdfv.size());
1633 #ifdef BPATCH_LIBRARY
1634                if(pdfv.size() > 1)
1635                    cerr << __FILE__ << ":" << __LINE__ 
1636                         << ": WARNING:  findAllFuncsByName found " 
1637                         << pdfv.size() << " references to function " 
1638                         << (*fbt)[i].name() << ".  Using the first.\n";
1639 #endif
1640                target = pdfv[0];
1641                return true;
1642             }
1643             else {  
1644                // KLUDGE: this is because we are not keeping more than
1645                // one name for the same function if there is more
1646                // than one.  This occurs when there are weak symbols
1647                // that alias global symbols (ex. libm.so.1: "sin" 
1648                // and "__sin").  In most cases the alias is the same as 
1649                // the global symbol minus one or two leading underscores,
1650                // so here we add one or two leading underscores to search
1651                // for the name to handle the case where this string 
1652                // is the name of the weak symbol...this will not fix 
1653                // every case, since if the weak symbol and global symbol
1654                // differ by more than leading underscores we won't find
1655                // it...when we parse the image we should keep multiple
1656                // names for int_functions
1657
1658                pdstring s("_");
1659                s += (*fbt)[i].name();
1660                found = findAllFuncsByName(s, pdfv);
1661                if(found) {
1662                   assert(pdfv.size());
1663 #ifdef BPATCH_LIBRARY
1664                   if(pdfv.size() > 1)
1665                      cerr << __FILE__ << ":" << __LINE__ 
1666                           << ": WARNING: findAllFuncsByName found " 
1667                           << pdfv.size() << " references to function " 
1668                           << s << ".  Using the first.\n";
1669 #endif
1670                   target = pdfv[0];
1671                   return true;
1672                }
1673                     
1674                s = pdstring("__");
1675                s += (*fbt)[i].name();
1676                found = findAllFuncsByName(s, pdfv);
1677                if(found) {
1678                   assert(pdfv.size());
1679 #ifdef BPATCH_LIBRARY
1680                   if(pdfv.size() > 1)
1681                      cerr << __FILE__ << ":" << __LINE__ 
1682                           << ": WARNING: findAllFuncsByName found " 
1683                           << pdfv.size() << " references to function "
1684                           << s << ".  Using the first.\n";
1685 #endif
1686                   target = pdfv[0];
1687                   return true;
1688                }
1689 #ifdef BPATCH_LIBRARY
1690                else
1691                   cerr << __FILE__ << ":" << __LINE__
1692                        << ": WARNING: findAllFuncsByName found no "
1693                        << "matches for function " << (*fbt)[i].name() 
1694                        << " or its possible aliases\n";
1695 #endif
1696             }
1697          }
1698          target = 0;
1699          return false;
1700       }
1701    }
1702    target = 0;
1703    return false;  
1704 }
1705
1706 fileDescriptor *getExecFileDescriptor(pdstring filename,
1707                                      int &,
1708                                      bool)
1709 {
1710   fileDescriptor *desc = new fileDescriptor(filename);
1711   return desc;
1712 }
1713
1714 #if defined(USES_DYNAMIC_INF_HEAP)
1715 static const Address lowest_addr = 0x0;
1716 void process::inferiorMallocConstraints(Address near, Address &lo, Address &hi,
1717                                inferiorHeapType /* type */ )
1718 {
1719   if (near)
1720     {
1721       lo = region_lo(near);
1722       hi = region_hi(near);  
1723     }
1724 }
1725
1726 void process::inferiorMallocAlign(unsigned &size)
1727 {
1728      /* 32 byte alignment.  Should it be 64? */
1729   size = (size + 0x1f) & ~0x1f;
1730 }
1731 #endif
1732
1733
1734 bool dyn_lwp::realLWP_attach_() {
1735    char procName[128];
1736    sprintf(procName, "/proc/%d/mem", get_lwp_id());
1737    fd_ = P_open(procName, O_RDWR, 0);
1738    if (fd_ < 0) 
1739      fd_ = INVALID_HANDLE_VALUE;
1740
1741    attach_cerr << "process::attach() doing PTRACE_ATTACH" << endl;
1742    if( 0 != P_ptrace(PTRACE_ATTACH, get_lwp_id(), 0, 0) )
1743    {
1744       perror( "process::attach - PTRACE_ATTACH" );
1745       return false;
1746    }
1747    
1748    if (0 > waitpid(get_lwp_id(), NULL, __WCLONE)) {
1749       perror("process::attach - waitpid");
1750       exit(1);
1751    }
1752
1753    continueLWP();
1754    return true;
1755 }
1756
1757 bool dyn_lwp::representativeLWP_attach_() {
1758    // step 1) /proc open: attach to the inferior process memory file
1759    char procName[128];
1760    sprintf(procName, "/proc/%d/mem", (int) proc_->getPid());
1761    fd_ = P_open(procName, O_RDWR, 0);
1762    if (fd_ < 0) 
1763      fd_ = INVALID_HANDLE_VALUE;
1764    
1765    bool running = false;
1766    if( proc_->wasCreatedViaAttach() )
1767       running = proc_->isRunning_();
1768    
1769    // QUESTION: does this attach operation lead to a SIGTRAP being forwarded
1770    // to paradynd in all cases?  How about when we are attaching to an
1771    // already-running process?  (Seems that in the latter case, no SIGTRAP
1772    // is automatically generated)
1773    
1774
1775    // Only if we are really attaching rather than spawning the inferior
1776    // process ourselves do we need to call PTRACE_ATTACH
1777    if(proc_->wasCreatedViaAttach() || proc_->wasCreatedViaFork() || 
1778       proc_->wasCreatedViaAttachToCreated())
1779    {
1780       attach_cerr << "process::attach() doing PTRACE_ATTACH" << endl;
1781       if( 0 != P_ptrace(PTRACE_ATTACH, getPid(), 0, 0) )
1782       {
1783          perror( "process::attach - PTRACE_ATTACH" );
1784          return false;
1785       }
1786
1787       if (0 > waitpid(getPid(), NULL, 0)) {
1788          perror("process::attach - waitpid");
1789          exit(1);
1790       }
1791    }
1792
1793    if(proc_->wasCreatedViaAttach() )
1794    {
1795       // If the process was running, it will need to be restarted, as
1796       // PTRACE_ATTACH kills it
1797       // Actually, the attach process contructor assumes that the process is
1798       // running.  While this is foolish, let's play along for now.
1799       if( proc_->status() != running || !proc_->isRunning_() ) {
1800          if( 0 != P_ptrace(PTRACE_CONT, getPid(), 0, 0) )
1801          {
1802             perror( "process::attach - continue 1" );
1803          }
1804       }
1805    }
1806
1807    if(proc_->wasCreatedViaAttachToCreated())
1808    {
1809       // This case is a special situation. The process is stopped
1810       // in the exec() system call but we have not received the first 
1811       // TRAP because it has been caught by another process.
1812       
1813       /* lose race */
1814       sleep(1);
1815       
1816       /* continue, clearing pending stop */
1817       if (0 > P_ptrace(PTRACE_CONT, getPid(), 0, SIGCONT)) {
1818          perror("process::attach: PTRACE_CONT 1");
1819          return false;
1820       }
1821      
1822       if (0 > waitpid(getPid(), NULL, 0)) {
1823          perror("process::attach: WAITPID");
1824          return false;
1825       }
1826
1827       /* continue, resending the TRAP to emulate the normal situation*/
1828       if ( 0 > kill(getPid(), SIGTRAP)){
1829          perror("process::attach: KILL");
1830          return false;
1831       }
1832       
1833       if (0 > P_ptrace(PTRACE_CONT, getPid(), 0, SIGCONT)) {
1834          perror("process::attach: PTRACE_CONT 2");
1835          return false;
1836       }
1837
1838       proc_->set_status(neonatal);
1839    } // end - if createdViaAttachToCreated
1840
1841    return true;
1842 }
1843
1844 #if defined(arch_x86) || defined(arch_x86_64)
1845 //These constants are not defined in all versions of elf.h
1846 #ifndef AT_NULL
1847 #define AT_NULL 0
1848 #endif
1849 #ifndef AT_SYSINFO
1850 #define AT_SYSINFO 32
1851 #endif
1852 #ifndef AT_SYSINFO_EHDR
1853 #define AT_SYSINFO_EHDR 33
1854 #endif
1855
1856 bool process::readAuxvInfo()
1857 {
1858   /**
1859    * The location of the vsyscall is stored in /proc/PID/auxv in Linux 2.6
1860    * auxv consists of a list of name/value pairs, ending with the AT_NULL
1861    * name.  There isn't a direct way to get the vsyscall info on Linux 2.4
1862    **/
1863   char buffer[32];
1864   int fd;
1865   Address dso_start = 0x0, text_start = 0x0;
1866   unsigned page_size = 0x0;
1867   struct {
1868     int type;
1869     int value;
1870   } auxv_entry;
1871   
1872   sprintf(buffer, "/proc/%d/auxv", pid);
1873
1874   fd = open(buffer, O_RDONLY);
1875   if (fd == -1)
1876   {
1877     //This is expected on linux 2.4 systems
1878     return false;
1879   }
1880
1881   do {
1882     read(fd, &auxv_entry, sizeof(auxv_entry));
1883     if (auxv_entry.type == AT_SYSINFO)
1884       text_start = auxv_entry.value;
1885     else if (auxv_entry.type == AT_SYSINFO_EHDR)
1886       dso_start = auxv_entry.value;
1887     else if (auxv_entry.type == AT_PAGESZ)
1888       page_size = auxv_entry.value;
1889   } while (auxv_entry.type != AT_NULL);
1890
1891   close(fd);
1892
1893   assert(text_start != 0x0 && dso_start != 0x0);
1894   if (page_size == 0x0) page_size = getpagesize();
1895   
1896   vsyscall_start_ = dso_start;
1897   vsyscall_end_ = dso_start + page_size;
1898   vsyscall_text_ = text_start;
1899
1900   return true;
1901 }
1902 #endif
1903
1904 void loadNativeDemangler() {}
1905
1906 const unsigned int N_DYNINST_LOAD_HIJACK_FUNCTIONS = 4;
1907 const char DYNINST_LOAD_HIJACK_FUNCTIONS[][20] = {
1908   "__libc_start_main",
1909   "_init",
1910   "_start",
1911   "main"
1912 };
1913
1914 /**
1915  * Returns an address that we can use to write the code that executes
1916  * dlopen on the runtime library.
1917  *
1918  * Inserting the code into libc is a good thing, since _dl_open
1919  * will sometimes check it's caller and return with a 'invalid caller'
1920  * error if it's called from the application.
1921  **/
1922 Address findFunctionToHijack(process *p) 
1923 {
1924    Address codeBase;
1925    unsigned i;
1926    for(i = 0; i < N_DYNINST_LOAD_HIJACK_FUNCTIONS; i++ ) {
1927       bool err;
1928       const char *func_name = DYNINST_LOAD_HIJACK_FUNCTIONS[i];
1929       codeBase = p->findInternalAddress(func_name, false, err);
1930       if (err || !codeBase)
1931       {
1932          int_function *func = p->findOnlyOneFunction(func_name);
1933          codeBase = func ? func->getAddress(NULL) : 0;
1934       }
1935       if (codeBase)
1936          break;
1937    }
1938
1939   return codeBase;
1940 } /* end findFunctionToHijack() */
1941