Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / process.h
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 /* $Id: process.h,v 1.418 2008/06/19 19:53:35 legendre Exp $
33  * process.h - interface to manage a process in execution. A process is a kernel
34  *   visible unit with a seperate code and data space.  It might not be
35  *   the only unit running the code, but it is only one changed when
36  *   ptrace updates are applied to the text space.
37  */
38
39 #ifndef PROCESS_H
40 #define PROCESS_H
41
42 #include <stdio.h>
43 #include <assert.h>
44 #include <string>
45
46 #include "dyninstAPI_RT/h/dyninstAPI_RT.h"
47
48 #include "common/h/Dictionary.h"
49 #include "common/h/Types.h"
50 #include "common/h/Timer.h"
51 #include "dyninstAPI/src/os.h"
52 #include "dyninstAPI/src/inst.h" // callWhen
53 #include "dyninstAPI/src/frame.h"
54 #if defined(cap_syscall_trap)
55 #include "dyninstAPI/src/syscalltrap.h"
56 #endif
57 #include "dyninstAPI/src/codeRange.h"
58 #include "dyninstAPI/src/imageUpdate.h"
59 #include "dyninstAPI/src/infHeap.h"
60 #include "dyninstAPI/src/symtab.h"
61 #include "dyninstAPI/src/ast.h"
62 #include "dyninstAPI/src/dyn_thread.h"
63 #include "dyninstAPI/src/callbacks.h"
64
65 #include "debug.h"
66
67 // Making this an InstructionSource for InstrucIter
68 #include "dyninstAPI/src/InstructionSource.h"
69
70 #include "dyninstAPI/src/addressSpace.h"
71
72 // Annoying... Solaris has two /proc header files, one for the
73 // multiple-FD /proc and one for an ioctl-based compatibility /proc.
74 // /usr/include/procfs.h is the one we want, and /usr/include/sys/procfs.h
75 // is the ioctl one. This makes it impossible to have a single include
76 // line. 
77 #if defined(os_solaris)
78 #include <procfs.h>
79 #elif defined(os_aix) || defined(os_osf) || defined(os_irix)
80 #include <sys/procfs.h>
81 #endif
82
83
84 #if defined( cap_unwind )
85 #include <libunwind.h>
86 #include <libunwind-ptrace.h>
87 #endif /* defined( cap_unwind ) */
88
89 #if defined(os_linux)
90 #include "common/h/parseauxv.h"
91 #endif
92
93 #if defined(SHM_SAMPLING)
94 extern unsigned SHARED_SEGMENT_SIZE;
95 #endif
96
97 #define MAX_THREADS 32 //Should match MAX_THREADS in RTcommon.c
98 extern unsigned activeProcesses; // number of active processes
99    // how about just processVec.size() instead?  At least, this should be made
100    // a (static) member vrble of class process
101
102 typedef enum { unstarted_bs, 
103                attached_bs, 
104                begun_bs, 
105                libcLoaded_bs, 
106                initialized_bs, 
107                loadingRT_bs, 
108                loadedRT_bs, 
109                bootstrapped_bs} bootstrapState_t;
110
111 typedef enum { terminateFailed, terminateSucceeded, alreadyTerminated } terminateProcStatus_t;
112
113 typedef enum { vsys_unknown, vsys_unused, vsys_notfound, vsys_found } syscallStatus_t;
114
115 typedef enum { noTracing_ts, libcOpenCall_ts, libcOpenRet_ts, libcClose_ts, instrumentLibc_ts, done_ts } traceState_t;
116
117 const int LOAD_DYNINST_BUF_SIZE = 256;
118
119 using namespace Dyninst;
120 using namespace Dyninst::SymtabAPI;
121
122 class instPoint;
123 class multiTramp;
124 class baseTramp;
125 class miniTramp;
126 class generatedCodeObject;
127 class replacedFunctionCall;
128 class functionReplacement;
129
130 class dyn_thread;
131 class dyn_lwp;
132
133 class Object;
134 class fileDescriptor;
135 class image;
136 class mapped_object;
137 class mapped_module;
138 class dynamic_linking;
139 class int_variable;
140 class int_function;
141
142 class rpcMgr;
143 class syscallNotification;
144
145 class SignalGenerator;
146
147 class BPatch_thread;
148 class BPatch_function;
149 class BPatch_point;
150 namespace Dyninst {
151    namespace SymtabAPI {
152       class Symtab;
153    }
154 }
155
156 typedef void (*continueCallback)(timeStamp timeOfCont);
157
158 class process : public AddressSpace {
159     friend class ptraceKludge;
160     friend class dyn_thread;
161     friend class dyn_lwp;
162     friend Address loadDyninstDll(process *, char Buffer[]);
163     friend class multiTramp;
164     friend class SignalGenerator;
165     friend class SignalGeneratorCommon;
166
167     //  
168     //  PUBLIC MEMBERS FUNCTIONS
169     //  
170     
171  public:
172     
173     // Default constructor
174     process(SignalGenerator *sh_);
175
176     // Fork constructor
177     process(process *parentProc, SignalGenerator *sg_, int iTrace_fd);
178
179     SignalGenerator *getSG() {return sh;}
180     // Creation work
181     bool setupCreated(int iTraceLink);
182     bool setupAttached();
183     // Similar case... process execs, we need to clean everything out
184     // and reload the runtime library. This is basically creation,
185     // just without someone calling us to make sure it happens...
186     bool prepareExec(fileDescriptor &desc);
187     // Once we're sure an exec is finishing, there's all sorts of work to do.
188     bool finishExec();
189
190     // And fork...
191     bool setupFork();
192
193     // Shared creation tasks
194     bool setupGeneral();
195
196     // And parse/get the a.out
197     // Doing this post-attach allows us to one-pass parse things that need it (e.g., AIX)
198     bool setAOut(fileDescriptor &desc);
199     Address setAOutLoadAddress(fileDescriptor &desc);
200     bool setMainFunction();
201
202  protected:  
203     bool walkStackFromFrame(Frame currentFrame, // Where to start walking from
204                             pdvector<Frame> &stackWalk); // return parameter
205     Frame preStackWalkInit(Frame startFrame); //Let's the OS do any needed initialization
206  public:
207     // Preferred function: returns a stack walk (vector of frames)
208     // for each thread in the program
209     bool walkStacks(pdvector<pdvector<Frame> > &stackWalks);
210     
211     // Get a vector of the active frames of all threads in the process
212     bool getAllActiveFrames(pdvector<Frame> &activeFrames);
213
214     
215     // Is the current address "after" the given instPoint?
216     bool triggeredInStackFrame(Frame &frame,
217                                instPoint *point,
218                                callWhen when,
219                                callOrder order);
220     
221     bool isInSignalHandler(Address addr);
222     
223     void deleteThread(dynthread_t tid);
224     void deleteThread_(dyn_thread *thr);
225     bool removeThreadIndexMapping(dynthread_t tid, unsigned index);
226     
227  public:
228     // Current process state
229     processState status() const { return status_;}
230     
231     // State when we attached;
232     bool wasRunningWhenAttached() const { return stateWhenAttached_ == running; }
233     
234     // Are we in the middle of an exec?
235     bool execing() const { return inExec_; }
236     
237     // update the status on the whole process (ie. process state and all lwp
238     // states)
239     void set_status(processState st, bool global_st = true, bool overrideState = false);
240     
241     // update the status of the process and one particular lwp in the process
242     void set_lwp_status(dyn_lwp *whichLWP, processState st);
243     
244     // should only be called by dyn_lwp::continueLWP
245     void clearCachedRegister();
246     
247     Address previousSignalAddr() const { return previousSignalAddr_; }
248     void setPreviousSignalAddr(Address a) { previousSignalAddr_ = a; }
249     std::string getStatusAsString() const; // useful for debug printing etc.
250     
251     bool checkContinueAfterStop() {
252         if( continueAfterNextStop_ ) {
253             continueAfterNextStop_ = false;
254             return true;
255         }
256         return false;
257     }
258     
259     void continueAfterNextStop() { continueAfterNextStop_ = true; }
260     static process *findProcess(int pid);
261
262 #if defined (cap_save_the_world) 
263     
264 #if defined(sparc_sun_solaris2_4) \
265  || defined(i386_unknown_linux2_0) \
266  || defined(x86_64_unknown_linux2_4) /* Blind duplication - Ray */ \
267  || defined(rs6000_ibm_aix4_1)
268     char* dumpPatchedImage(std::string outFile);//ccw 28 oct 2001
269     
270 #if defined(i386_unknown_linux2_0) \
271  || defined(x86_64_unknown_linux2_4)
272     bool prelinkSharedLibrary(string originalLibNameFullPath, char* dirName, Address baseAddr);
273 #endif
274     
275 #if defined(sparc_sun_solaris2_4)  //ccw 10 mar 2004
276     bool dldumpSharedLibrary(std::string dyninstRT_name, char* directoryname);
277 #endif
278     
279 #if defined(i386_unknown_linux2_0) \
280  || defined(x86_64_unknown_linux2_4) \
281  || defined(sparc_sun_solaris2_4)
282     char *saveWorldFindNewSharedLibraryName(string originalLibNameFullPath, char* dirName);
283     void setPrelinkCommand(char *command);
284 #endif
285     
286 #endif
287
288 #else
289 #if 0
290     char* dumpPatchedImage(std::string /*outFile*/) { return NULL; } 
291 #endif
292 #endif
293
294     bool applyMutationsToTextSection(char *textSection, unsigned textAddr, unsigned textSize);
295     
296     
297     bool dumpImage(std::string outFile);
298     
299     //  SignalHandler::dumpMemory()
300     //
301     //  Dumps memory +/- nbytes around target addr, to stderr
302     //  Used in place of dumpImage() on platforms that cannot dump core
303     //  (windows, notably)
304     //  Useful for debug output?  (belongs in process class?)
305     bool dumpMemory(void *addr, unsigned nbytes);
306     
307     // Not at all sure we want to use this anymore...
308     void overwriteImage( image* /*img */) {
309         assert(0);
310     }
311     
312     // Appears to be the system pointer size. 
313     virtual unsigned getAddressWidth() const; 
314     
315     // this is only used on aix so far - naim
316     // And should really be defined in a arch-dependent place, not process.h - bernat
317     Address getTOCoffsetInfo(Address);
318     Address getTOCoffsetInfo(int_function *);
319     
320     bool dyninstLibAlreadyLoaded() { return runtime_lib != 0; }
321     
322     rpcMgr *getRpcMgr() const { return theRpcMgr; }
323     
324     bool getCurrPCVector(pdvector <Address> &currPCs);
325     
326 #if defined(os_solaris) && (defined(arch_x86) || defined(arch_x86_64))
327     bool changeIntReg(int reg, Address addr);
328 #endif
329     
330     void installInstrRequests(const pdvector<instMapping*> &requests);
331
332     // Returns false if process exited while recognizing threads
333     bool recognize_threads(process *parent = NULL);
334     // Get LWP handles from /proc (or as appropriate)
335     
336     bool determineLWPs(pdvector<unsigned> &lwp_ids);
337     
338     int getPid() const;
339     
340     /***************************************************************************
341      **** Runtime library initialization code (Dyninst)                     ****
342      ***************************************************************************/
343     
344     bool loadDyninstLib();
345     bool setDyninstLibPtr(mapped_object *libobj);
346     bool setDyninstLibInitParams();
347     bool finalizeDyninstLib();
348     
349     bool iRPCDyninstInit();
350     static int DYNINSTinitCompletionCallback(process *, unsigned /* rpc_id */,
351                                              void *data, void *ret);
352     bool initMT();
353     
354     // Get the list of inferior heaps from:
355     
356     bool getInfHeapList(pdvector<heapDescriptor> &infHeaps); // Whole process
357     bool getInfHeapList(mapped_object *theObj,
358                         pdvector<heapDescriptor> &infHeaps); // Single mapped object
359     
360     void addInferiorHeap(mapped_object *obj);
361     
362     void initInferiorHeap();
363     
364     /* Find the tramp guard addr and set it */
365     bool initTrampGuard();
366     void saveWorldData(Address address, int size, const void* src);
367     
368 #if defined(cap_save_the_world)
369     
370     char* saveWorldFindDirectory();
371     
372     unsigned int saveWorldSaveSharedLibs(int &mutatedSharedObjectsSize,
373                                          unsigned int &dyninst_SharedLibrariesSize,
374                                          char* directoryName, unsigned int &count);
375     char* saveWorldCreateSharedLibrariesSection(int dyninst_SharedLibrariesSize);
376     
377     void saveWorldCreateHighMemSections(pdvector<imageUpdate*> &compactedHighmemUpdates, 
378                                         pdvector<imageUpdate*> &highmemUpdates,
379                                         void *newElf);
380     void saveWorldCreateDataSections(void* ptr);
381     void saveWorldAddSharedLibs(void *ptr);//ccw 14 may 2002
382     void saveWorldloadLibrary(std::string tmp, void *brk_ptr) {
383         loadLibraryUpdates.push_back(tmp);
384         loadLibraryBRKs.push_back(brk_ptr);
385     };
386     
387 #if defined(os_aix)
388     void addLib(char *lname);//ccw 30 jul 2002
389 #endif // os_aix
390     
391 #endif // cap_save_the_world
392     
393     
394     void writeDebugDataSpace(void *inTracedProcess, u_int amount, 
395                              const void *inSelf);
396     bool writeDataSpace(void *inTracedProcess,
397                         u_int amount, const void *inSelf);
398     bool readDataSpace(const void *inTracedProcess, u_int amount,
399                        void *inSelf, bool displayErrMsg);
400     
401     bool writeTextSpace(void *inTracedProcess, u_int amount, const void *inSelf);
402     bool writeTextWord(caddr_t inTracedProcess, int data);
403     
404     bool readTextSpace(const void *inTracedProcess, u_int amount,
405                        const void *inSelf);
406     
407     static bool IndependentLwpControl() { return INDEPENDENT_LWP_CONTROL; }
408     void independentLwpControlInit();
409     
410     // Internal calls only; this is an asynchronous call that says "run when everyone
411     // is finished". BPatch should use the equivalent SignalGeneratorCommon call.
412     bool continueProc(int signalToContinueWith = -1);
413     
414     bool terminateProc();
415     
416     // Detach from a process, deleting data to prep for reattaching
417     // NOTE: external callers should use this function, not ::detach
418     bool detachProcess(const bool leaveRunning);
419     bool detachForDebugger(const EventRecord &crash_event);
420     bool startDebugger();
421
422     
423  private:
424     bool detach(const bool leaveRunning);
425  public:
426     
427     // Clear out all dynamically allocated process data
428     void deleteProcess();
429     ~process();
430     bool pause();
431     
432     bool dumpCore(const std::string coreFile);
433     bool attach();
434     // Set whatever OS-level process flags are needed
435     bool setProcessFlags();
436     bool unsetProcessFlags(); // Counterpart to above
437     
438     
439     //  
440     //  PUBLIC DATA MEMBERS
441     //  
442     
443   ////////////////////////////////////////////////
444   // Address to <X> mappings
445   ////////////////////////////////////////////////
446
447  public:
448   //interface call to Dyninst pass-through debugging
449   Address stepi(bool verbose, int lwp);  
450   void stepi(int lwp);  
451   void stepi();  
452
453  private:
454   void print_instrucs(unsigned char *buffer, unsigned size, 
455                  bool leave_files);
456  public:
457   void disass(Address start, Address end);
458   void disass(Address start, Address end, bool leave_files);
459
460 #if defined( os_linux )
461  public:
462   Address getVsyscallStart() { return vsyscall_start_; }
463   Address getVsyscallEnd() { return vsyscall_end_; }
464   Address getVsyscallText() { return vsyscall_text_; } 
465   syscallStatus_t getVsyscallStatus() { return vsys_status_; }
466   void setVsyscallStatus(syscallStatus_t s) { vsys_status_ = s; }
467   void setVsyscallRange(Address start, Address end) 
468     { vsyscall_start_ = start; vsyscall_end_ = end; }
469   void setVsyscallText(Address addr) { vsyscall_text_ = addr; }
470   Dyninst::SymtabAPI::Symtab *getVsyscallObject() { return vsyscall_obj; }
471   void setVsyscallObject(Dyninst::SymtabAPI::Symtab *vo) { vsyscall_obj = vo; }
472   bool readAuxvInfo(); 
473 #endif
474
475 #if defined(os_windows)
476   bool instrumentThreadInitialFunc(int_function *f);
477   pdvector<int_function *> initial_thread_functions;
478   bool setBeingDebuggedFlag(bool debuggerPresent);
479 #endif
480
481   public:
482   // True if we've reached or past a certain state
483   bool reachedBootstrapState(bootstrapState_t state) const { return bootstrapState >= state; }
484
485   std::string getBootstrapStateAsString() const;
486   bootstrapState_t getBootstrapState() {return bootstrapState;}
487
488   // Strictly increments (we never drop back down)
489   void setBootstrapState(bootstrapState_t state) {
490       // DEBUG
491       /*
492       if (bootstrapState > state)
493           cerr << "Warning: attempt to revert bootstrap state from "
494           << bootstrapState << " to " << state << endl;
495       else
496           bootstrapState = state;
497       */
498       bootstrapState = (state > bootstrapState) ? state : bootstrapState;
499       startup_printf("%s[%d]:  setting bootstrap state for process %d (0x%x) to %s\n",
500                      FILE__, __LINE__, getPid(), this, getBootstrapStateAsString().c_str());
501   }  
502
503   void resetBootstrapState(bootstrapState_t state) {
504       // Every so often we need to force this to a particular value
505       bootstrapState = state;
506   }
507
508   void suppressBPatchCallbacks(bool state) { 
509       suppress_bpatch_callbacks_ = state; 
510   }
511
512
513   void warnOfThreadDelete(dyn_thread *thr);
514  
515  public:
516
517  //Run the mutatee until exit in single-step mode, printing each instruction
518  //as it executes.  
519  void debugSuicide();
520  private:
521
522
523 /////////////////////////////////////////////////////////////////
524 //  System call trap tracking
525 /////////////////////////////////////////////////////////////////
526
527 #if defined(cap_syscall_trap)
528   public:
529   // Overloaded: Address for linux-style, syscall # for /proc
530   syscallTrap *trapSyscallExitInternal(Address syscall);
531   bool clearSyscallTrapInternal(syscallTrap *trappedSyscall);
532   
533   // Check all traps entered for a match to the syscall
534   bool checkTrappedSyscallsInternal(Address syscall);
535 #endif
536     
537   private:
538   
539   // Trampoline guard location -- actually an addr in the runtime library.
540
541   
542   //
543   //  PRIVATE MEMBER FUNCTIONS
544   // 
545
546  public:
547
548
549   bool loadDYNINSTlib();
550 #if defined(os_linux)
551   // If dlopen is present, use it. Otherwise, call a libc-internal function
552   bool loadDYNINSTlib_exported(const char *dlopen_name = NULL);
553   bool loadDYNINSTlib_hidden();
554
555   // Unprotect stack if necessary for runtime library loading
556   Address tryUnprotectStack(codeGen &buf, Address codeBase);
557 #endif
558   bool loadDYNINSTlibCleanup(dyn_lwp *trappingLWP);
559   bool trapDueToDyninstLib(dyn_lwp *trappingLWP);
560
561   // trapAddress is not set on non-NT, we discover it inline
562   bool trapAtEntryPointOfMain(dyn_lwp *checkLWP, Address trapAddress = 0);
563   bool wasCreatedViaAttach() { return creationMechanism_ == attached_cm; }
564   bool wasCreatedViaAttachToCreated() { return creationMechanism_ == attachedToCreated_cm; }
565   bool hasPassedMain();
566
567   // This is special, since it's orthogonal to the others. We're forked if
568   // the "parent process" is non-null
569   bool wasCreatedViaFork() { return parent != NULL; }
570
571
572   bool insertTrapAtEntryPointOfMain();
573   bool handleTrapAtEntryPointOfMain(dyn_lwp *trappingLWP);
574
575   bool shouldSaveFPState();
576
577   static std::string tryToFindExecutable(const std::string &progpath, int pid);
578       // os-specific implementation.  Returns empty string on failure.
579       // Otherwise, returns a full-path-name for the file.  Tries every
580       // trick to determine the full-path-name, even though "progpath" may
581       // be unspecified (empty string)
582
583   bool isDynamicallyLinked() const { return mapped_objects.size() > 1; }
584
585   bool decodeIfDueToSharedObjectMapping(EventRecord &);
586   bool handleChangeInSharedObjectMapping(EventRecord &);
587
588   private:
589
590   public:
591
592   // getSharedObjects: This routine is called before main() to get and
593   // process all shared objects that have been mapped into the process's
594   // address space
595   bool processSharedObjects();
596
597   // addASharedObject: This routine is called whenever a new shared object
598   // has been loaded by the run-time linker after the process starts running
599   // It processes the image, creates new resources
600   bool addASharedObject(mapped_object *);
601
602   // removeASharedObject: get rid of a shared object; e.g., dlclose
603   bool removeASharedObject(mapped_object *);
604
605   // getMainFunction: returns the main function for this process
606   int_function *getMainFunction() const { return main_function; }
607
608  private:
609   enum mt_cache_result { not_cached, cached_mt_true, cached_mt_false };
610   enum mt_cache_result cached_result;
611
612  public:
613
614   // If true is passed for ignore_if_mt_not_set, then an error won't be
615   // initiated if we're unable to determine if the program is multi-threaded.
616   // We are unable to determine this if the daemon hasn't yet figured out
617   // what libraries are linked against the application.  Currently, we
618   // identify an application as being multi-threaded if it is linked against
619   // a thread library (eg. libpthreads.a on AIX).  There are cases where we
620   // are querying whether the app is multi-threaded, but it can't be
621   // determined yet but it also isn't necessary to know.
622   bool multithread_capable(bool ignore_if_mt_not_set = false);
623
624   // Do we have the RT-side multithread functions available
625   bool multithread_ready(bool ignore_if_mt_not_set = false);
626     
627   dyn_thread *STdyn_thread();
628
629   // No function is pushed onto return vector if address can't be resolved
630   // to a function
631   pdvector<int_function *>pcsToFuncs(pdvector<Frame> stackWalk);
632
633   bool mappedObjIsDeleted(mapped_object *mobj);
634
635   void triggerNormalExitCallback(int exitCode);
636   void triggerSignalExitCallback(int signalnum);  
637   
638   // triggering normal exit callback and cleanup process happen at different
639   // times.  if triggerSignalExitCallback is called, this function should
640   // also be called at the same time.
641
642   // this function makes no callback to dyninst but only does cleanup work
643   bool handleProcessExit();
644
645   // Checks the mapped object for signal handlers
646   void findSignalHandler(mapped_object *obj);
647
648 #if defined(os_aix)
649   // Manually copy inferior heaps past the end of text segments
650   void copyDanglingMemory(process *parent);
651 #endif
652   bool handleForkEntry();
653   bool handleForkExit(process *child);
654   bool handleExecEntry(char *arg0);
655   bool handleExecExit(fileDescriptor &desc);
656
657   bool handleStopThread(EventRecord &ev);
658   static int getStopThreadCB_ID(const Address cb);
659
660   public:
661
662   dyn_thread *getThread(dynthread_t tid);
663   dyn_lwp *getLWP(unsigned lwp_id);
664
665   // return NULL if not found
666   dyn_lwp *lookupLWP(unsigned lwp_id);
667
668   // This is an lwp which controls the entire process.  This lwp is a
669   // fictional lwp in the sense that it isn't associated with a specific lwp
670   // in the system.  For both single-threaded and multi-threaded processes,
671   // this lwp represents the process as a whole (ie. all of the individual
672   // lwps combined).  This lwp will be NULL if no such lwp exists which is
673   // the case for multi-threaded linux processes.
674   dyn_lwp *getRepresentativeLWP() const {
675      return representativeLWP;
676   }
677
678   dyn_lwp *getInitialLwp() const;
679   dyn_thread *getInitialThread() const {
680      if(threads.size() == 0)
681         return NULL;
682
683      return threads[0];
684   }
685
686   void updateThreadIndex(dyn_thread *thread, int index);
687   dyn_thread *createInitialThread();
688   void addThread(dyn_thread *thread);
689   dyn_lwp *createRepresentativeLWP();
690
691   // fictional lwps aren't saved in the real_lwps vector
692   dyn_lwp *createFictionalLWP(unsigned lwp_id);
693   dyn_lwp *createRealLWP(unsigned lwp_id, int lwp_index);
694
695   void deleteLWP(dyn_lwp *lwp_to_delete);
696
697   int maxNumberOfThreads();
698 #if defined(os_osf)
699   int waitforRPC(int *status,bool block = false);
700 #endif
701   const process *getParent() const {return parent;}
702
703  public:
704
705    bool extractBootstrapStruct(DYNINST_bootstrapStruct *);
706    bool isBootstrappedYet() const;
707   
708 private:
709   // Since we don't define these, 'private' makes sure they're not used:
710   process &operator=(const process &); // assign oper
711
712 public:
713
714   dynamic_linking *getDyn() { return dyn; }
715
716   // Add a signal handler that wasdetected
717   void addSignalHandler(Address addr, unsigned size);
718   
719   // Used to be ifdefed, now not because of rework
720   // Goes right to the multitramp and installs/uninstalls
721   // jumps.
722    bool uninstallMutations();
723    bool reinstallMutations();
724
725 private:
726
727   bool flushInstructionCache_(void *baseAddr, size_t size); //ccw 25 june 2001
728
729   bool continueProc_(int sig);
730   
731   // terminateProcStatus_t is defined at the top of this file.
732   terminateProcStatus_t terminateProc_();
733   bool dumpCore_(const std::string coreFile);
734   bool osDumpImage(const std::string &imageFileName,  pid_t pid, Address codeOff);
735
736   dyn_lwp *query_for_stopped_lwp();
737   dyn_lwp *stop_an_lwp(bool *wasRunning);
738
739   // stops a process
740   bool stop_(bool waitForStop = true);
741   // wait until the process stops
742   bool waitUntilStopped();
743 #if defined (os_linux)
744   bool waitUntilLWPStops();
745 #endif
746   
747  public:
748
749   dyn_lwp *query_for_running_lwp();
750
751   // returns true iff ok to operate on the process (attached)
752   bool isAttached() const;
753
754   // returns true if the process is stopped (AKA we can operate on it)
755   bool isStopped() const;
756
757   // if the process has exited
758   bool hasExited() const;
759
760   // true if the process is passed main
761   bool hasPassedMain() const;
762
763   // Prolly shouldn't be public... but then we need a stack of 
764   // access methods. 
765   // This is an lwp which controls the entire process.  This lwp is a
766   // fictional lwp in the sense that it isn't associated with a specific lwp
767   // in the system.  For both single-threaded and multi-threaded processes,
768   // this lwp represents the process as a whole (ie. all of the individual
769   // lwps combined).  This lwp will be NULL if no such lwp exists which is
770   // the case for multi-threaded linux processes.
771
772   // /proc platforms
773 #if defined(cap_proc)
774   bool get_entry_syscalls(sysset_t *entry);
775   bool get_exit_syscalls(sysset_t *exit);
776   bool set_entry_syscalls(sysset_t *entry);
777   bool set_exit_syscalls(sysset_t *exit);
778 #endif  //cap_proc
779
780 #if defined(cap_proc_fd)
781     bool get_status(pstatus_t *) const;
782 #endif // cap_proc_fd
783
784  public:
785     const char *getInterpreterName();
786     Address getInterpreterBase();
787     void setInterpreterName(const char *name);
788     void setInterpreterBase(Address newbase);
789
790  public:
791     // Needed by instPoint
792     // hasBeenBound: returns true if the runtime linker has bound the
793     // function symbol corresponding to the relocation entry in at the address 
794     // specified by entry and base_addr.  If it has been bound, then the callee 
795     // function is returned in "target_pdf", else it returns false. 
796     virtual bool hasBeenBound(const relocationEntry &entry, int_function *&target_pdf, 
797                               Address base_addr) ;
798  private:
799
800   bool isRunning_() const;
801      // needed to initialize the 'wasRunningWhenAttached' member vrble. 
802      // Determines whether the process is running by doing a low-level OS
803      // check, not by checking member vrbles like status_.  May assume that
804      // process::attach() has already run, but can't assume anything else.
805      // May barf with a not-yet-implemented error on a given platform if the
806      // platform doesn't yet support attaching to a running process. But
807      // there's no reason why we shouldn't be able to implement this on any
808      // platform; after all, the output from the "ps" command can be used
809      // (T --> return false, S or R --> return true, other --> return ?)
810
811  private:
812   static int inferiorMallocCallback(process *proc, unsigned /* rpc_id */,
813                                       void *data, void *result);
814
815    void inferiorMallocDynamic(int size, Address lo, Address hi);
816
817
818  public:
819    // Handling of inferior memory management
820 #if defined(cap_dynamic_heap)
821    // platform-specific definition of "near" (i.e. close enough for one-insn jump)
822    void inferiorMallocConstraints(Address near_, Address &lo, Address &hi, inferiorHeapType type);
823 #endif
824
825    
826    Address inferiorMalloc(unsigned size, inferiorHeapType type=anyHeap,
827                           Address near_=0, bool *err=NULL);
828    virtual void inferiorFree(Address item);
829    virtual bool inferiorRealloc(Address item, unsigned newSize);
830
831    // garbage collect instrumentation
832
833    void deleteGeneratedCode(generatedCodeObject *del);
834    void gcInstrumentation();
835    void gcInstrumentation(pdvector<pdvector<Frame> >&stackWalks);
836
837    virtual bool needsPIC();
838   ///////////////////////////////////////////////////
839   // Process class members
840   ///////////////////////////////////////////////////
841   int tmp;
842   
843
844   ///////////////////////////////
845   // Core process data
846   ///////////////////////////////
847   process *parent;
848   SignalGenerator *sh;
849
850   // And deleted...
851   pdvector<mapped_object *> deleted_objects;
852
853   // We have to perform particular steps based on how we were started.
854   typedef enum { unknown_cm, 
855                  created_cm, 
856                  attached_cm, 
857                  attachedToCreated_cm } creationMechanism_t;
858
859   // Use accessor method that checks before returning...
860   creationMechanism_t creationMechanism_; 
861   // Users may want to leave a process in the same state as it was;
862   // for example, if attached.
863   processState stateWhenAttached_;
864
865   int_function *main_function; // Usually, but not always, "main"
866   int_function *thread_index_function;
867   dyn_thread *lastForkingThread;
868
869   ///////////////////////////////
870   // Shared library handling
871   ///////////////////////////////
872   dynamic_linking *dyn;
873
874   const char *interpreter_name_;
875   Address interpreter_base_;
876
877   
878   ///////////////////////////////
879   // Process control
880   ///////////////////////////////
881   dyn_lwp *representativeLWP;
882   // LWPs are index by their id
883   dictionary_hash<unsigned, dyn_lwp *> real_lwps;
884   pdvector<dyn_lwp *> lwps_to_delete;
885
886   // Threads are accessed by index.
887   int max_number_of_threads;
888   pdvector<dyn_thread *> threads;
889   Address thread_structs_base;
890
891
892   dynthread_t mapIndexToTid(int index);
893   bool deferredContinueProc;
894   Address previousSignalAddr_;
895   bool continueAfterNextStop_;
896   // Defined in os.h
897   processState status_;         /* running, stopped, etc. */
898   // And so we don't run into a _lot_ of problems in process control...
899   bool exiting_; // Post-exit callback; "we don't care any more"
900
901   //// Exec
902   // For platforms where we have to guess what the next signal is caused by.
903   // Currently: Linux/ptrace
904   bool nextTrapIsExec;
905   // More sure then looking at /proc/pid
906   std::string execPathArg;              // Argument given to exec
907   std::string execFilePath;     // Full path info
908   bool inExec_; // Used to be a status vrble, but is orthogonal to running/stopped
909
910   ///////////////////////////////
911   // RPCs
912   ///////////////////////////////
913   rpcMgr *theRpcMgr;
914
915
916   ///////////////////////////////
917   // Save The World
918   ///////////////////////////////
919   bool collectSaveWorldData;//this is set to collect data for
920                                 //save the world
921
922   pdvector<imageUpdate*> imageUpdates;//ccw 28 oct 2001
923   pdvector<imageUpdate*> highmemUpdates;//ccw 20 nov 2001
924   pdvector<dataUpdate*>  dataUpdates;//ccw 26 nov 2001
925   pdvector<std::string> loadLibraryCalls;//ccw 14 may 2002 
926   pdvector<std::string> loadLibraryUpdates;//ccw 14 may 2002
927   pdvector<void*> loadLibraryBRKs;
928   int requestTextMiniTramp; //ccw 20 jul 2002
929         void setRequestTextMiniTramp(int flag){requestTextMiniTramp=flag;};
930
931
932   // Pipe between mutator and mutatee
933   int traceLink;                /* pipe to transfer traces data over */
934
935   // the following 3 are used in perfStream.C
936   // Should migrate to process level when we get the LL tracePipe
937   char buffer[2048];
938   unsigned bufStart;
939   unsigned bufEnd;
940
941   // Signal handling!
942   codeRangeTree signalHandlerLocations_;
943
944   //////////////////
945   // Startup and initialization
946   //////////////////
947   bootstrapState_t bootstrapState;
948   bool suppress_bpatch_callbacks_;
949   unsigned char savedCodeBuffer[BYTES_TO_SAVE];
950   Address loadDyninstLibAddr;
951   dyn_saved_regs *savedRegs;
952
953   Address dyninstlib_brk_addr;
954   Address main_brk_addr;
955
956   char * systemPrelinkCommand;
957
958 #if defined(os_windows)
959   dictionary_hash<Address, unsigned char> main_breaks;
960   pdvector<unsigned> cached_lwps;
961
962   // On windows we need to temporarily keep details of process creation in
963   // order to handle their debug mechanism. We create the process, then get a message
964   // about it (instead of our "pull" mechanism on other platforms). This gives us
965   // space to stash the info.
966   // Instead of tracking what we need to peel out, we keep the whole thing for later.
967
968   handleT processHandle_;
969   handleT mainFileHandle_;
970   Address mainFileBase_;
971
972   pdvector<int> continueHandles;
973   pdvector<int> continueTypes;
974
975 #endif
976
977   ////////////////////
978   // Inferior heap
979   ////////////////////
980   bool inInferiorMallocDynamic; // The oddest recursion problem...
981
982   /////////////////////
983   // System call and signal handling
984   /////////////////////
985   // Tracing for whatever mechanism we use to notify us of syscalls made
986   // by the process (fork/exec/exit)
987   syscallNotification *tracedSyscalls_;
988
989   // A list of traps inserted at system calls
990   pdvector<syscallTrap *> syscallTraps_;
991
992   /////////////////////
993   // Instrumentation
994   /////////////////////
995   pdvector<instMapping *> tracingRequests;
996   pdvector<generatedCodeObject *> pendingGCInstrumentation;
997
998   ////////////////////////////////////////////
999   // __libc_start_main instrumentation stuff 
1000   ////////////////////////////////////////////
1001  public:
1002   bool decodeStartupSysCalls(EventRecord &ev);
1003   bool handleTrapAtLibcStartMain(dyn_lwp *trappingLWP);
1004   bool instrumentLibcStartMain();
1005   void setTraceSysCalls(bool traceSys);
1006   void setTraceState(traceState_t state);
1007   bool getTraceSysCalls() { return traceSysCalls_; }
1008   traceState_t getTraceState() { return traceState_; }
1009   Address getlibcstartmain_brk_addr() { return libcstartmain_brk_addr; }
1010
1011  private:
1012   bool getSysCallParameters(dyn_saved_regs *regs, long *params, int numparams);
1013   int getSysCallNumber(dyn_saved_regs *regs);
1014   long getSysCallReturnValue(dyn_saved_regs *regs);
1015   Address getSysCallProgramCounter(dyn_saved_regs *regs);
1016   bool isMmapSysCall(int callnum);
1017   Offset getMmapLength(int, dyn_saved_regs *regs);
1018   Address getLibcStartMainParam(dyn_lwp *trappingLWP);
1019   // regions that are added during syscall tracking phase
1020   pdvector<Address> mappedRegionStart;
1021   pdvector<Address> mappedRegionEnd;
1022   // start addrs of regions munmapped before call to findLibcStartMain
1023   pdvector<Address> munmappedRegions;
1024   bool traceSysCalls_;
1025   int libcHandle_;
1026   traceState_t traceState_;
1027   Address libcstartmain_brk_addr;
1028   static int stopThread_ID_counter;
1029   static dictionary_hash< Address, unsigned > stopThread_callbacks;
1030  public:  
1031   Address last_single_step;
1032
1033   ///////////////////////////////
1034   // Platform-specific
1035   ///////////////////////////////
1036
1037 #if defined( arch_ia64 )
1038   unw_addr_space * unwindAddressSpace;
1039   dictionary_hash< Address, void * > unwindProcessArgs;
1040   typedef dictionary_hash< Address, void * >::iterator upaIterator;
1041   
1042   bool insertAndRegisterDynamicUnwindInformation( unw_dyn_info_t * unwindInformation );
1043 #endif
1044
1045 #if defined(os_linux)
1046   //////////////////
1047   // Linux vsyscall stuff
1048   //////////////////
1049   syscallStatus_t vsys_status_; 
1050   Address vsyscall_start_;
1051   Address vsyscall_end_;
1052   Address vsyscall_text_;
1053   AuxvParser *auxv_parser;
1054   Dyninst::SymtabAPI::Symtab *vsyscall_obj;
1055
1056   bool started_stopped;
1057 #endif
1058
1059   ///////////////////
1060   // 64-32 bit mapping functions
1061   //////////////////
1062   bool readThreadStruct(Address baseAddr, dyninst_thread_t &struc);
1063
1064 };// end class process
1065
1066
1067 process *ll_createProcess(const std::string file, pdvector<std::string> *argv, 
1068                           pdvector<std::string> *envp,
1069                           const std::string dir, int stdin_fd, int stdout_fd,
1070                           int stderr_fd);
1071
1072 process *ll_attachProcess(const std::string &progpath, int pid, void *container_proc_);
1073
1074
1075 bool isInferiorAllocated(process *p, Address block);
1076
1077 #if !defined(os_linux)
1078 inline void process::independentLwpControlInit() { }
1079 #endif
1080
1081 extern pdvector<process *> processVec;
1082
1083 #define NUMBER_OF_MAIN_POSSIBILITIES 7
1084 extern char main_function_names[NUMBER_OF_MAIN_POSSIBILITIES][20];
1085
1086 #endif