dyninstAPI/src/process.h

   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: process.h,v 1.344 2006/01/13 00:00:47 jodom Exp $
  43  * process.h - interface to manage a process in execution. A process is a kernel
  44  *   visible unit with a seperate code and data space.  It might not be
  45  *   the only unit running the code, but it is only one changed when
  46  *   ptrace updates are applied to the text space.
  47  */
  48
  49 #ifndef PROCESS_H
  50 #define PROCESS_H
  51
  52 #include <stdio.h>
  53 #include <assert.h>
  54
  55 #include "dyninstAPI_RT/h/dyninstAPI_RT.h"
  56
  57 #include "common/h/String.h"
  58 #include "common/h/vectorSet.h"
  59 #include "common/h/Dictionary.h"
  60 #include "common/h/Types.h"
  61 #include "common/h/Timer.h"
  62 #include "dyninstAPI/src/os.h"
  63 #include "dyninstAPI/src/inst.h" // callWhen
  64 #include "dyninstAPI/src/frame.h"
  65 #include "dyninstAPI/src/showerror.h"
  66 #include "dyninstAPI/src/syscalltrap.h"
  67 #include "dyninstAPI/src/libState.h"
  68 #include "dyninstAPI/src/signalhandler.h"
  69 #include "dyninstAPI/src/rpcMgr.h"
  70 #include "dyninstAPI/src/codeRange.h"
  71
  72 //#include "dyninstAPI/src/symtab.h"
  73 #include "dyninstAPI/src/imageUpdate.h"
  74
  75 #include "dyninstAPI/src/infHeap.h"
  76
  77 #if (! defined( BPATCH_LIBRARY )) && defined( PAPI )
  78 #include "paradynd/src/papiMgr.h"
  79 #endif
  80
  81 // Annoying... Solaris has two /proc header files, one for the
  82 // multiple-FD /proc and one for an ioctl-based compatibility /proc.
  83 // /usr/include/procfs.h is the one we want, and /usr/include/sys/procfs.h
  84 // is the ioctl one. This makes it impossible to have a single include
  85 // line.
  86 #if defined(os_solaris)
  87 #include <procfs.h>
  88 #elif defined(os_aix) || defined(os_osf) || defined(os_irix)
  89 #include <sys/procfs.h>
  90 #endif
  91
  92
  93 #if defined( cap_unwind )
  94 #include <libunwind.h>
  95 #include <libunwind-ptrace.h>
  96 #endif /* defined( cap_unwind ) */
  97
  98 #if defined(SHM_SAMPLING)
  99 extern unsigned SHARED_SEGMENT_SIZE;
 100 #endif
 101
 102 #define MAX_THREADS 32
 103 extern unsigned activeProcesses; // number of active processes
 104    // how about just processVec.size() instead?  At least, this should be made
 105    // a (static) member vrble of class process
 106
 107 typedef enum { unstarted_bs,
 108                attached_bs,
 109                begun_bs,
 110                initialized_bs,
 111                loadingRT_bs,
 112                loadedRT_bs,
 113                bootstrapped_bs } bootstrapState_t;
 114
 115 typedef enum { terminateFailed, terminateSucceeded, alreadyTerminated } terminateProcStatus_t;
 116
 117 const int LOAD_DYNINST_BUF_SIZE = 256;
 118
 119 class instPoint;
 120 class multiTramp;
 121 class baseTramp;
 122 class miniTramp;
 123 class generatedCodeObject;
 124 class replacedFunctionCall;
 125 class functionReplacement;
 126
 127 class dyn_thread;
 128 class dyn_lwp;
 129
 130 class Object;
 131 class relocationEntry;
 132 class fileDescriptor;
 133 class Symbol;
 134 class image;
 135 class mapped_object;
 136 class mapped_module;
 137 class dynamic_linking;
 138 class int_variable;
 139 class int_function;
 140
 141
 142 class rpcMgr;
 143 class syscallNotification;
 144
 145 #ifdef BPATCH_LIBRARY
 146 class BPatch_thread;
 147 class BPatch_function;
 148 #endif
 149
 150 #if 0
 151 static inline unsigned ipHash(const instPoint * const &ip)
 152 {
 153   // assume all addresses are 4-byte aligned
 154   unsigned result = (unsigned)(Address)ip;
 155   result >>= 2;
 156   return result;
 157   // how about %'ing by a huge prime number?  Nah, x % y == x when x < y
 158   // so we don't want the number to be huge.
 159 }
 160 #endif
 161
 162 typedef void (*continueCallback)(timeStamp timeOfCont);
 163
 164 class process {
 165     friend class ptraceKludge;
 166     friend class dyn_thread;
 167     friend class dyn_lwp;
 168     friend Address loadDyninstDll(process *, char Buffer[]);
 169     friend class multiTramp;
 170
 171     //
 172     //  PUBLIC MEMBERS FUNCTIONS
 173     //
 174
 175  public:
 176
 177     // Default constructor
 178     process(int pid);
 179
 180     // Fork constructor
 181     process(const process *parentProc, int iPid, int iTrace_fd);
 182
 183     // Creation work
 184     bool setupCreated(int iTraceLink);
 185     bool setupAttached();
 186     // Similar case... process execs, we need to clean everything out
 187     // and reload the runtime library. This is basically creation,
 188     // just without someone calling us to make sure it happens...
 189     bool prepareExec();
 190     // Once we're sure an exec is finishing, there's all sorts of work to do.
 191     bool finishExec();
 192
 193     // And fork...
 194     bool setupFork();
 195
 196     // Shared creation tasks
 197     bool setupGeneral();
 198
 199     // And parse/get the a.out
 200     // Doing this post-attach allows us to one-pass parse things that need it (e.g., AIX)
 201     bool setAOut(fileDescriptor &desc);
 202     bool setMainFunction();
 203
 204
 205   protected:
 206   bool walkStackFromFrame(Frame currentFrame, // Where to start walking from
 207                           pdvector<Frame> &stackWalk); // return parameter
 208   public:
 209   // Preferred function: returns a stack walk (vector of frames)
 210   // for each thread in the program
 211   bool walkStacks(pdvector<pdvector<Frame> > &stackWalks);
 212
 213   // Get a vector of the active frames of all threads in the process
 214   bool getAllActiveFrames(pdvector<Frame> &activeFrames);
 215
 216
 217   // Is the current address "after" the given instPoint?
 218   bool triggeredInStackFrame(Frame &frame,
 219                              instPoint *point,
 220                              callWhen when,
 221                              callOrder order);
 222
 223   bool isInSignalHandler(Address addr);
 224
 225   void deleteThread(dynthread_t tid);
 226
 227   // Thread index functions
 228   unsigned getIndexToThread(unsigned index);
 229   void setIndexToThread(unsigned index, unsigned value);
 230   void updateThreadIndexAddr(Address addr);
 231  public:
 232
 233   // Current process state
 234   processState status() const { return status_;}
 235
 236   // State when we attached;
 237   bool wasRunningWhenAttached() const { return stateWhenAttached_ == running; }
 238
 239   // Are we in the middle of an exec?
 240   bool execing() const { return inExec_; }
 241
 242   // update the status on the whole process (ie. process state and all lwp
 243   // states)
 244   void set_status(processState st);
 245
 246   // update the status of the process and one particular lwp in the process
 247   void set_lwp_status(dyn_lwp *whichLWP, processState st);
 248
 249   // should only be called by dyn_lwp::continueLWP
 250   void clearCachedRegister();
 251
 252   Address previousSignalAddr() const { return previousSignalAddr_; }
 253   void setPreviousSignalAddr(Address a) { previousSignalAddr_ = a; }
 254   pdstring getStatusAsString() const; // useful for debug printing etc.
 255
 256   bool checkContinueAfterStop() {
 257           if( continueAfterNextStop_ ) {
 258                   continueAfterNextStop_ = false;
 259                   return true;
 260           }
 261           return false;
 262   }
 263
 264   void continueAfterNextStop() { continueAfterNextStop_ = true; }
 265   static process *findProcess(int pid);
 266
 267 char * systemPrelinkCommand;
 268 #if defined(sparc_sun_solaris2_4) \
 269  || defined(i386_unknown_linux2_0) \
 270  || defined(x86_64_unknown_linux2_4) /* Blind duplication - Ray */ \
 271  || defined(rs6000_ibm_aix4_1)
 272   char* dumpPatchedImage(pdstring outFile);//ccw 28 oct 2001
 273
 274 #if defined(i386_unknown_linux2_0) \
 275  || defined(x86_64_unknown_linux2_4)
 276         bool prelinkSharedLibrary(pdstring originalLibNameFullPath, char* dirName, Address baseAddr);
 277 #endif
 278
 279 #if defined(sparc_sun_solaris2_4)  //ccw 10 mar 2004
 280         bool dldumpSharedLibrary(pdstring dyninstRT_name, char* directoryname);
 281 #endif
 282
 283 #if defined(i386_unknown_linux2_0) \
 284  || defined(x86_64_unknown_linux2_4) \
 285  || defined(sparc_sun_solaris2_4)
 286         char *saveWorldFindNewSharedLibraryName(pdstring originalLibNameFullPath, char* dirName);
 287         void setPrelinkCommand(char *command);
 288 #endif
 289
 290 #else
 291   char* dumpPatchedImage(pdstring /*outFile*/) { return NULL; }
 292 #endif
 293         bool applyMutationsToTextSection(char *textSection, unsigned textAddr, unsigned textSize);
 294
 295
 296   bool dumpImage(pdstring outFile);
 297
 298   // This will find the named symbol in the image or in a shared object
 299   // Necessary since some things don't show up as a function or variable.
 300   bool getSymbolInfo( const pdstring &name, Symbol &ret );
 301
 302   // Not at all sure we want to use this anymore...
 303   void overwriteImage( image* /*img */) {
 304     assert(0);
 305   }
 306
 307   // Appears to be the system pointer size.
 308   unsigned getAddressWidth();
 309
 310   // The process keeps maps of valid (i.e. allocated) address ranges
 311   bool isValidAddress(Address);
 312
 313   // And "get me a local pointer to XX" -- before we modified it.
 314   void *getPtrToInstruction(Address);
 315
 316   // this is only used on aix so far - naim
 317   // And should really be defined in a arch-dependent place, not process.h - bernat
 318   Address getTOCoffsetInfo(Address);
 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   void recognize_threads(const process *parent = NULL);
 332   // Get LWP handles from /proc (or as appropriate)
 333   bool determineLWPs(pdvector<unsigned> &lwp_ids);
 334
 335   int getPid() const { return pid;}
 336
 337   /***************************************************************************
 338    **** Runtime library initialization code (Dyninst)                     ****
 339    ***************************************************************************/
 340   bool loadDyninstLib();
 341   bool setDyninstLibPtr(mapped_object *libobj);
 342   bool setDyninstLibInitParams();
 343   bool finalizeDyninstLib();
 344
 345   bool iRPCDyninstInit();
 346   static void DYNINSTinitCompletionCallback(process *, unsigned /* rpc_id */,
 347                                             void *data, void *ret);
 348   bool initMT();
 349
 350   // Get the list of inferior heaps from:
 351
 352   bool getInfHeapList(pdvector<heapDescriptor> &infHeaps); // Whole process
 353   bool getInfHeapList(const mapped_object *theObj,
 354                       pdvector<heapDescriptor> &infHeaps); // Single mapped object
 355
 356   void addInferiorHeap(const mapped_object *obj);
 357
 358   void initInferiorHeap();
 359
 360   /* Find the tramp guard addr and set it */
 361   bool initTrampGuard();
 362   void saveWorldData(Address address, int size, const void* src);
 363
 364 #if defined(cap_save_the_world)
 365
 366   char* saveWorldFindDirectory();
 367
 368   unsigned int saveWorldSaveSharedLibs(int &mutatedSharedObjectsSize,
 369                                    unsigned int &dyninst_SharedLibrariesSize,
 370                                    char* directoryName, unsigned int &count);
 371   char* saveWorldCreateSharedLibrariesSection(int dyninst_SharedLibrariesSize);
 372
 373   void saveWorldCreateHighMemSections(pdvector<imageUpdate*> &compactedHighmemUpdates,
 374                                       pdvector<imageUpdate*> &highmemUpdates,
 375                                       void *newElf);
 376   void saveWorldCreateDataSections(void* ptr);
 377   void saveWorldAddSharedLibs(void *ptr);//ccw 14 may 2002
 378   void saveWorldloadLibrary(pdstring tmp, void *brk_ptr) {
 379      loadLibraryUpdates.push_back(tmp);
 380      loadLibraryBRKs.push_back(brk_ptr);
 381   };
 382
 383 #if defined(os_aix)
 384   void addLib(char *lname);//ccw 30 jul 2002
 385 #endif // os_aix
 386
 387 #endif // cap_save_the_world
 388
 389
 390   bool writeDataSpace(void *inTracedProcess,
 391                       u_int amount, const void *inSelf);
 392   bool readDataSpace(const void *inTracedProcess, u_int amount,
 393                      void *inSelf, bool displayErrMsg);
 394
 395   bool writeTextSpace(void *inTracedProcess, u_int amount, const void *inSelf);
 396   bool writeTextWord(caddr_t inTracedProcess, int data);
 397
 398   bool readTextSpace(const void *inTracedProcess, u_int amount,
 399                      const void *inSelf);
 400
 401   static bool IndependentLwpControl() {
 402 #if defined(os_linux)
 403      return true;
 404 #else
 405      return false;
 406 #endif
 407   }
 408   void independentLwpControlInit();
 409
 410   bool continueProc(int signalToContinueWith = -1);
 411
 412   bool terminateProc();
 413
 414   // Detach from a process, deleting data to prep for reattaching
 415   // NOTE: external callers should use this function, not ::detach
 416   bool detachProcess(const bool leaveRunning);
 417
 418   private:
 419     bool detach(const bool leaveRunning);
 420   public:
 421
 422   // Clear out all dynamically allocated process data
 423   void deleteProcess();
 424   ~process();
 425   bool pause();
 426
 427   // instPoint isn't const; it may get an updated list of
 428   // instances since we generate them lazily.
 429   bool replaceFunctionCall(instPoint *point,const int_function *newFunc);
 430
 431   bool dumpCore(const pdstring coreFile);
 432   bool attach();
 433   // Set whatever OS-level process flags are needed
 434   bool setProcessFlags();
 435   bool unsetProcessFlags(); // Counterpart to above
 436
 437   bool getDynamicCallSiteArgs(instPoint *callSite,
 438                               pdvector<AstNode *> &args);
 439
 440   // Trampoline guard get/set functions
 441   Address trampGuardBase(void) { return trampGuardBase_; }
 442   //
 443   //  PUBLIC DATA MEMBERS
 444   //
 445
 446
 447   // Need a code range of multiTramps
 448   // Look up to see if a multiTramp already covers this address.
 449   multiTramp *findMultiTramp(Address addr);
 450   // Add...
 451   void addMultiTramp(multiTramp *multi);
 452   // And remove.
 453   void removeMultiTramp(multiTramp *multi);
 454
 455   // Replaced function calls...
 456   void addModifiedCallsite(replacedFunctionCall *RFC);
 457
 458   // And replaced functions
 459   void addFunctionReplacement(functionReplacement *,
 460                               pdvector<codeRange *> &overwrittenObjs);
 461
 462   codeRange *findModifiedPointByAddr(Address addr);
 463   void removeModifiedPoint(Address addr);
 464
 465   // Did we override the address of this call?
 466   Address getReplacedCallAddr(Address origAddr) const;
 467   bool wasCallReplaced(Address origAddr) const;
 468
 469   ////////////////////////////////////////////////
 470   // Address to <X> mappings
 471   ////////////////////////////////////////////////
 472
 473  public:
 474   //interface call to Dyninst pass-through debugging
 475   Address stepi(bool verbose, int lwp);
 476   void stepi(int lwp);
 477   void stepi();
 478
 479  private:
 480   void print_instrucs(unsigned char *buffer, unsigned size,
 481                  bool leave_files);
 482  public:
 483   void disass(Address start, Address end);
 484   void disass(Address start, Address end, bool leave_files);
 485
 486 #if defined( os_linux )
 487  public:
 488   Address getVsyscallStart() { return vsyscall_start_; }
 489   Address getVsyscallEnd() { return vsyscall_end_; }
 490   Address getVsyscallText() { return vsyscall_text_; }
 491   void setVsyscallRange(Address start, Address end)
 492     { vsyscall_start_ = start; vsyscall_end_ = end; }
 493   void *getVsyscallData() { return vsyscall_data_; }
 494   void setVsyscallData(void *data) { vsyscall_data_ = data; }
 495   bool readAuxvInfo();
 496
 497
 498 #endif
 499
 500   public:
 501   // True if we've reached or past a certain state
 502   bool reachedBootstrapState(bootstrapState_t state) const { return bootstrapState >= state; }
 503   bool suppressEventConts() { return suppressCont_; }
 504   void setSuppressEventConts(bool s) { suppressCont_ = s; }
 505
 506   pdstring getBootstrapStateAsString() const;
 507   bootstrapState_t getBootstrapState() {return bootstrapState;}
 508
 509   // Strictly increments (we never drop back down)
 510   void setBootstrapState(bootstrapState_t state) {
 511       // DEBUG
 512       if (bootstrapState > state)
 513           cerr << "Warning: attempt to revert bootstrap state from "
 514                << bootstrapState << " to " << state << endl;
 515       else
 516           bootstrapState = state;
 517       startup_cerr << "(" << getPid() << ") Setting bootstrap state to "
 518                    << getBootstrapStateAsString() << endl;
 519   }
 520
 521   void resetBootstrapState(bootstrapState_t state) {
 522       // Every so often we need to force this to a particular value
 523       bootstrapState = state;
 524   }
 525
 526  // Callbacks for higher level code (like BPatch) to learn about new
 527  //  functions and InstPoints.
 528  private:
 529   BPatch_function *(*new_func_cb)(process *p, int_function *f);
 530   BPatch_point *(*new_instp_cb)(process *p, int_function *f, instPoint *ip,
 531                                 int type);
 532  public:
 533   //Trigger the callbacks from a lower level
 534   BPatch_function *newFunctionCB(int_function *f)
 535      { assert(new_func_cb); return new_func_cb(this, f); }
 536   BPatch_point *newInstPointCB(int_function *f, instPoint *pt, int type)
 537      { assert(new_instp_cb); return new_instp_cb(this, f, pt, type); }
 538
 539   //Register callbacks from the higher level
 540   void registerFunctionCallback(BPatch_function *(*f)(process *p,
 541                                                       int_function *f))
 542      { new_func_cb = f; };
 543   void registerInstPointCallback(BPatch_point *(*f)(process *p, int_function *f,
 544                                                     instPoint *ip, int type))
 545      { new_instp_cb = f; }
 546
 547   void warnOfThreadDelete(dyn_thread *thr);
 548  // inferior heap management
 549  public:
 550
 551   //
 552   //  PRIVATE DATA MEMBERS (and structure definitions)....
 553   //
 554  private:
 555
 556
 557 /////////////////////////////////////////////////////////////////
 558 //  System call trap tracking
 559 /////////////////////////////////////////////////////////////////
 560
 561   public:
 562   // Overloaded: Address for linux-style, syscall # for /proc
 563   syscallTrap *trapSyscallExitInternal(Address syscall);
 564   bool clearSyscallTrapInternal(syscallTrap *trappedSyscall);
 565
 566   // Check all traps entered for a match to the syscall
 567   bool checkTrappedSyscallsInternal(Address syscall);
 568
 569   private:
 570
 571   // Trampoline guard location -- actually an addr in the runtime library.
 572
 573
 574   //
 575   //  PRIVATE MEMBER FUNCTIONS
 576   //
 577
 578  public:
 579
 580
 581   bool getDyninstRTLibName();
 582   bool loadDYNINSTlib();
 583 #if defined(os_linux)
 584   // There are two mutually incompatible load types... split into
 585   // functions
 586   bool loadDYNINSTlib_libc20();
 587   bool loadDYNINSTlib_libc21();
 588 #endif
 589   bool loadDYNINSTlibCleanup(dyn_lwp *trappingLWP);
 590   bool trapDueToDyninstLib(dyn_lwp *trappingLWP);
 591
 592   // trapAddress is not set on non-NT, we discover it inline
 593   bool trapAtEntryPointOfMain(dyn_lwp *checkLWP, Address trapAddress = 0);
 594   bool wasCreatedViaAttach() { return creationMechanism_ == attached_cm; }
 595   bool wasCreatedViaAttachToCreated() { return creationMechanism_ == attachedToCreated_cm; }
 596
 597   // This is special, since it's orthogonal to the others. We're forked if
 598   // the "parent process" is non-null
 599   bool wasCreatedViaFork() { return parent != NULL; }
 600
 601
 602   bool insertTrapAtEntryPointOfMain();
 603   bool handleTrapAtEntryPointOfMain(dyn_lwp *trappingLWP);
 604
 605
 606
 607   pdstring getProcessStatus() const;
 608
 609   static pdstring tryToFindExecutable(const pdstring &progpath, int pid);
 610       // os-specific implementation.  Returns empty string on failure.
 611       // Otherwise, returns a full-path-name for the file.  Tries every
 612       // trick to determine the full-path-name, even though "progpath" may
 613       // be unspecified (empty string)
 614
 615   bool isDynamicallyLinked() const { return mapped_objects.size() > 1; }
 616
 617   // handleIfDueToSharedObjectMapping: if a trap instruction was caused by
 618   // a dlopen or dlclose event then return true
 619   bool handleIfDueToSharedObjectMapping();
 620
 621   private:
 622
 623   public:
 624
 625   // getSharedObjects: This routine is called before main() to get and
 626   // process all shared objects that have been mapped into the process's
 627   // address space
 628   bool processSharedObjects();
 629
 630   // addASharedObject: This routine is called whenever a new shared object
 631   // has been loaded by the run-time linker after the process starts running
 632   // It processes the image, creates new resources
 633   bool addASharedObject(mapped_object *);
 634
 635   // return the list of dynamically linked libs
 636   const pdvector<mapped_object *> &mappedObjects() { return mapped_objects;  }
 637
 638   // getMainFunction: returns the main function for this process
 639   int_function *getMainFunction() const { return main_function; }
 640
 641 #if !defined(BPATCH_LIBRARY)
 642   // findOneFunction: returns the function associated with function "func"
 643   // and module "mod".  This routine checks both the a.out image and any
 644   // shared object images for this function.
 645   // mcheyney - should return NULL if function is excluded!!!!
 646   class resource;
 647   int_function *findOnlyOneFunction(resource *func,resource *mod);
 648
 649   //this routine searches for a function in a module.  Note that res is a vector
 650   // due to gcc emitting duplicate constructors/destructors
 651   bool findAllFuncsByName(resource *func, resource *mod, pdvector<int_function *> &res);
 652 #endif
 653
 654  private:
 655   enum mt_cache_result { not_cached, cached_mt_true, cached_mt_false };
 656   enum mt_cache_result cached_result;
 657
 658  public:
 659
 660   // If true is passed for ignore_if_mt_not_set, then an error won't be
 661   // initiated if we're unable to determine if the program is multi-threaded.
 662   // We are unable to determine this if the daemon hasn't yet figured out
 663   // what libraries are linked against the application.  Currently, we
 664   // identify an application as being multi-threaded if it is linked against
 665   // a thread library (eg. libpthreads.a on AIX).  There are cases where we
 666   // are querying whether the app is multi-threaded, but it can't be
 667   // determined yet but it also isn't necessary to know.
 668   bool multithread_capable(bool ignore_if_mt_not_set = false);
 669
 670   // Do we have the RT-side multithread functions available
 671   bool multithread_ready(bool ignore_if_mt_not_set = false);
 672
 673   dyn_thread *STdyn_thread();
 674
 675   // findFuncByName: returns function associated with "func_name"
 676   // This routine checks both the a.out image and any shared object images
 677   // for this function
 678   //int_function *findFuncByName(const pdstring &func_name);
 679
 680   bool findFuncsByAll(const pdstring &funcname,
 681                       pdvector<int_function *> &res,
 682                       const pdstring &libname = "");
 683
 684   // Specific versions...
 685   bool findFuncsByPretty(const pdstring &funcname,
 686                          pdvector<int_function *> &res,
 687                          const pdstring &libname = "");
 688   bool findFuncsByMangled(const pdstring &funcname,
 689                           pdvector<int_function *> &res,
 690                           const pdstring &libname = "");
 691
 692   bool findVarsByAll(const pdstring &varname,
 693                      pdvector<int_variable *> &res,
 694                      const pdstring &libname = "");
 695
 696   void getLibAndFunc(const pdstring &name,
 697                      pdstring &func,
 698                      pdstring &lib);
 699
 700   // And we often internally want to wrap the above to return one
 701   // and only one func...
 702   int_function *findOnlyOneFunction(const pdstring &name,
 703                                     const pdstring &libname = "");
 704
 705   // Find the code sequence containing an address
 706   // Note: fix the name....
 707   codeRange *findCodeRangeByAddress(Address addr);
 708   int_function *findFuncByAddr(Address addr);
 709
 710   instPoint *findInstPByAddr(Address addr);
 711   // Should be called once per address an instPoint points to
 712   // (multiples for relocated functions)
 713   void registerInstPointAddr(Address addr, instPoint *inst);
 714   void unregisterInstPointAddr(Address addr, instPoint *inst);
 715
 716   bool addCodeRange(codeRange *codeobj);
 717   bool deleteCodeRange(Address addr);
 718
 719   // No function is pushed onto return vector if address can't be resolved
 720   // to a function
 721   pdvector<int_function *>pcsToFuncs(pdvector<Frame> stackWalk);
 722
 723   // findModule: returns the module associated with "mod_name"
 724   // this routine checks both the a.out image and any shared object
 725   // images for this module
 726   // if check_excluded is true it checks to see if the module is excluded
 727   // and if it is it returns 0.  If check_excluded is false it doesn't check
 728   //  if substring_match is true, the first module whose name contains
 729   //  the provided string is returned.
 730   // Wildcard: handles "*" and "?"
 731   mapped_module *findModule(const pdstring &mod_name, bool wildcard = false);
 732   // And the same for objects
 733   // Wildcard: handles "*" and "?"
 734   mapped_object *findObject(const pdstring &obj_name, bool wildcard = false);
 735
 736   // getAllFunctions: returns a vector of all functions defined in the
 737   // a.out and in the shared objects
 738   void getAllFunctions(pdvector<int_function *> &);
 739
 740   // getAllModules: returns a vector of all modules defined in the
 741   // a.out and in the shared objects
 742   void getAllModules(pdvector<mapped_module *> &);
 743
 744   void triggerNormalExitCallback(int exitCode);
 745   void triggerSignalExitCallback(int signalnum);
 746
 747   // triggering normal exit callback and cleanup process happen at different
 748   // times.  if triggerSignalExitCallback is called, this function should
 749   // also be called at the same time.
 750
 751   // this function makes no callback to dyninst but only does cleanup work
 752   bool handleProcessExit();
 753
 754 #ifndef BPATCH_LIBRARY
 755   bool SearchRelocationEntries(const image *owner, instPoint &instr,
 756                                int_function *&target,
 757                                Address target_addr, Address base_addr);
 758 #endif
 759
 760   // Checks the mapped object for signal handlers
 761   void findSignalHandler(mapped_object *obj);
 762
 763 #if defined(os_aix)
 764   // Manually copy inferior heaps past the end of text segments
 765   void copyDanglingMemory(process *parent);
 766 #endif
 767   bool handleForkEntry();
 768   bool handleForkExit(process *child);
 769   bool handleExecEntry(char *arg0);
 770   bool handleExecExit();
 771
 772   // Generic handler for anything else waiting on a system call
 773   // Returns true if handling was done
 774   bool handleSyscallExit(eventWhat_t syscall, dyn_lwp *lwp_with_event);
 775
 776   public:
 777
 778   dyn_thread *getThread(dynthread_t tid);
 779   dyn_lwp *getLWP(unsigned lwp_id);
 780
 781   // return NULL if not found
 782   dyn_lwp *lookupLWP(unsigned lwp_id);
 783
 784   // This is an lwp which controls the entire process.  This lwp is a
 785   // fictional lwp in the sense that it isn't associated with a specific lwp
 786   // in the system.  For both single-threaded and multi-threaded processes,
 787   // this lwp represents the process as a whole (ie. all of the individual
 788   // lwps combined).  This lwp will be NULL if no such lwp exists which is
 789   // the case for multi-threaded linux processes.
 790   dyn_lwp *getRepresentativeLWP() const {
 791      return representativeLWP;
 792   }
 793
 794   dyn_thread *getInitialThread() const {
 795      if(threads.size() == 0)
 796         return NULL;
 797
 798      return threads[0];
 799   }
 800
 801   dyn_thread *createInitialThread();
 802   void addThread(dyn_thread *thread);
 803   dyn_lwp *createRepresentativeLWP();
 804
 805   // fictional lwps aren't saved in the real_lwps vector
 806   dyn_lwp *createFictionalLWP(unsigned lwp_id);
 807   dyn_lwp *createRealLWP(unsigned lwp_id, int lwp_index);
 808
 809   void deleteLWP(dyn_lwp *lwp_to_delete);
 810
 811   int maxNumberOfThreads();
 812 #if defined(os_osf)
 813   int waitforRPC(int *status,bool block = false);
 814 #endif
 815   const process *getParent() const {return parent;}
 816
 817  public:
 818
 819   void processCost(unsigned obsCostLow, timeStamp wallTime,
 820                    timeStamp processTime);
 821
 822    bool extractBootstrapStruct(DYNINST_bootstrapStruct *);
 823    bool isBootstrappedYet() const;
 824
 825 private:
 826   // Since we don't define these, 'private' makes sure they're not used:
 827   process &operator=(const process &); // assign oper
 828
 829 public:
 830
 831   dynamic_linking *getDyn() { return dyn; }
 832
 833   Address getObservedCostAddr() const { return costAddr_; }
 834   void updateObservedCostAddr(Address addr) { costAddr_ = addr;}
 835
 836
 837   // Add a signal handler that was detected
 838   void addSignalHandler(Address addr, unsigned size);
 839
 840   // Used to be ifdefed, now not because of rework
 841   // Goes right to the multitramp and installs/uninstalls
 842   // jumps.
 843    bool uninstallMutations();
 844    bool reinstallMutations();
 845
 846 private:
 847
 848   bool flushInstructionCache_(void *baseAddr, size_t size); //ccw 25 june 2001
 849
 850   bool continueProc_(int sig);
 851
 852   // terminateProcStatus_t is defined at the top of this file.
 853   terminateProcStatus_t terminateProc_();
 854   bool dumpCore_(const pdstring coreFile);
 855   bool osDumpImage(const pdstring &imageFileName,  pid_t pid, Address codeOff);
 856
 857   dyn_lwp *query_for_stopped_lwp();
 858   dyn_lwp *stop_an_lwp(bool *wasRunning);
 859
 860   // stops a process
 861   bool stop_();
 862   // wait until the process stops
 863   bool waitUntilStopped();
 864 #if defined (os_linux)
 865   bool waitUntilLWPStops();
 866 #endif
 867
 868  public:
 869
 870   dyn_lwp *query_for_running_lwp();
 871
 872   // returns true iff ok to operate on the process (attached)
 873   bool isAttached() const;
 874
 875   // returns true if the process is stopped (AKA we can operate on it)
 876   bool isStopped() const;
 877
 878   // if the process has exited
 879   bool hasExited() const;
 880
 881
 882   // Prolly shouldn't be public... but then we need a stack of
 883   // access methods.
 884   // This is an lwp which controls the entire process.  This lwp is a
 885   // fictional lwp in the sense that it isn't associated with a specific lwp
 886   // in the system.  For both single-threaded and multi-threaded processes,
 887   // this lwp represents the process as a whole (ie. all of the individual
 888   // lwps combined).  This lwp will be NULL if no such lwp exists which is
 889   // the case for multi-threaded linux processes.
 890
 891   // /proc platforms
 892 #if defined(cap_proc)
 893   bool get_entry_syscalls(sysset_t *entry);
 894   bool get_exit_syscalls(sysset_t *exit);
 895   bool set_entry_syscalls(sysset_t *entry);
 896   bool set_exit_syscalls(sysset_t *exit);
 897 #endif  //cap_proc
 898
 899 #if defined(cap_proc_fd)
 900     bool get_status(pstatus_t *) const;
 901 #endif // cap_proc_fd
 902
 903
 904   public:
 905     static bool getExecFileDescriptor(pdstring filename,
 906                                       int pid,
 907                                       bool waitForTrap, // Should we wait for process init
 908                                       int &status,
 909                                       fileDescriptor &desc);
 910     mapped_object *getAOut() { assert(mapped_objects.size()); return mapped_objects[0];}
 911
 912  public:
 913     // Needed by instPoint
 914     // hasBeenBound: returns true if the runtime linker has bound the
 915     // function symbol corresponding to the relocation entry in at the address
 916     // specified by entry and base_addr.  If it has been bound, then the callee
 917     // function is returned in "target_pdf", else it returns false.
 918     bool hasBeenBound(const relocationEntry &entry, int_function *&target_pdf,
 919                       Address base_addr) ;
 920  private:
 921
 922   bool isRunning_() const;
 923      // needed to initialize the 'wasRunningWhenAttached' member vrble.
 924      // Determines whether the process is running by doing a low-level OS
 925      // check, not by checking member vrbles like status_.  May assume that
 926      // process::attach() has already run, but can't assume anything else.
 927      // May barf with a not-yet-implemented error on a given platform if the
 928      // platform doesn't yet support attaching to a running process. But
 929      // there's no reason why we shouldn't be able to implement this on any
 930      // platform; after all, the output from the "ps" command can be used
 931      // (T --> return false, S or R --> return true, other --> return ?)
 932
 933  private:
 934    static void inferiorMallocCallback(process *proc, unsigned /* rpc_id */,
 935                                       void *data, void *result);
 936
 937    void inferiorMallocDynamic(int size, Address lo, Address hi);
 938    void inferiorFreeCompact(inferiorHeap *hp);
 939    int findFreeIndex(unsigned size, int type, Address lo, Address hi);
 940
 941  public:
 942    // Handling of inferior memory management
 943 #if defined(USES_DYNAMIC_INF_HEAP)
 944    // platform-specific definition of "near" (i.e. close enough for one-insn jump)
 945    void inferiorMallocConstraints(Address near_, Address &lo, Address &hi, inferiorHeapType type);
 946    // platform-specific buffer size alignment
 947    void inferiorMallocAlign(unsigned &size);
 948 #endif /* USES_DYNAMIC_INF_HEAP */
 949
 950
 951    Address inferiorMalloc(unsigned size, inferiorHeapType type=anyHeap,
 952                           Address near_=0, bool *err=NULL);
 953    void inferiorFree(Address item);
 954    bool inferiorRealloc(Address item, unsigned newSize);
 955
 956
 957 /*Address inferiorMalloc(process *p, unsigned size, inferiorHeapType type=anyHeap,
 958                        Address near_=0, bool *err=NULL);
 959 void inferiorFree(process *p, Address item, const pdvector<addrVecType> &);
 960 */
 961 // garbage collect instrumentation
 962
 963    void deleteGeneratedCode(generatedCodeObject *del);
 964    void gcInstrumentation();
 965    void gcInstrumentation(pdvector<pdvector<Frame> >&stackWalks);
 966
 967   ///////////////////////////////////////////////////
 968   // Process class members
 969   ///////////////////////////////////////////////////
 970   int tmp;
 971
 972
 973   ///////////////////////////////
 974   // Core process data
 975   ///////////////////////////////
 976   int pid;
 977   const process *parent;
 978   pdvector<mapped_object *> mapped_objects;
 979   // And a shortcut pointer
 980   mapped_object *runtime_lib;
 981   // ... and keep the name around
 982   pdstring dyninstRT_name;
 983
 984   // We have to perform particular steps based on how we were started.
 985   typedef enum { unknown_cm,
 986                  created_cm,
 987                  attached_cm,
 988                  attachedToCreated_cm } creationMechanism_t;
 989
 990   // Use accessor method that checks before returning...
 991   creationMechanism_t creationMechanism_;
 992   // Users may want to leave a process in the same state as it was;
 993   // for example, if attached.
 994   processState stateWhenAttached_;
 995
 996   int_function *main_function; // Usually, but not always, "main"
 997
 998   ///////////////////////////////
 999   // Shared library handling
1000   ///////////////////////////////
1001   dynamic_linking *dyn;
1002
1003
1004   ///////////////////////////////
1005   // Process control
1006   ///////////////////////////////
1007   dyn_lwp *representativeLWP;
1008   // LWPs are index by their id
1009   dictionary_hash<unsigned, dyn_lwp *> real_lwps;
1010   // Threads are accessed by index.
1011   int max_number_of_threads;
1012   pdvector<dyn_thread *> threads;
1013
1014   dynthread_t mapIndexToTid(int index);
1015   bool deferredContinueProc;
1016   Address previousSignalAddr_;
1017   bool continueAfterNextStop_;
1018   bool suppressCont_;
1019   // Defined in os.h
1020   processState status_;         /* running, stopped, etc. */
1021
1022   //// Exec
1023   // For platforms where we have to guess what the next signal is caused by.
1024   // Currently: Linux/ptrace
1025   bool nextTrapIsExec;
1026   // More sure then looking at /proc/pid
1027   pdstring execPathArg;         // Argument given to exec
1028   pdstring execFilePath;        // Full path info
1029   bool inExec_; // Used to be a status vrble, but is orthogonal to running/stopped
1030
1031   ///////////////////////////////
1032   // RPCs
1033   ///////////////////////////////
1034   rpcMgr *theRpcMgr;
1035
1036
1037   ///////////////////////////////
1038   // Save The World
1039   ///////////////////////////////
1040   bool collectSaveWorldData;//this is set to collect data for
1041                                 //save the world
1042
1043   pdvector<imageUpdate*> imageUpdates;//ccw 28 oct 2001
1044   pdvector<imageUpdate*> highmemUpdates;//ccw 20 nov 2001
1045   pdvector<dataUpdate*>  dataUpdates;//ccw 26 nov 2001
1046   pdvector<pdstring> loadLibraryCalls;//ccw 14 may 2002
1047   pdvector<pdstring> loadLibraryUpdates;//ccw 14 may 2002
1048   pdvector<void*> loadLibraryBRKs;
1049   int requestTextMiniTramp; //ccw 20 jul 2002
1050
1051
1052   // Pipe between mutator and mutatee
1053   int traceLink;                /* pipe to transfer traces data over */
1054
1055   // the following 3 are used in perfStream.C
1056   // Should migrate to process level when we get the LL tracePipe
1057   char buffer[2048];
1058   unsigned bufStart;
1059   unsigned bufEnd;
1060
1061
1062   ///////////////////////////////
1063   // Address lookup members
1064   ///////////////////////////////
1065   // Trap address to base tramp address (for trap instrumentation)
1066   dictionary_hash<Address, Address> trampTrapMapping;
1067   // Address to instPoint mapping
1068   dictionary_hash<Address, instPoint *> instPMapping_;
1069   // There may be duplicate entries in the above.
1070
1071   // Address to executable code pieces (functions, miniTramps, baseTramps, ...) mapping
1072   codeRangeTree codeRangesByAddr_;
1073   // Get a mutator-side pointer to mutatee-side data without readDataSpace...
1074   // codeRangeTree readableSections_;
1075   // codeSections_ and dataSections_ instead...
1076   // Address -> multiTramp mapping...
1077   codeRangeTree modifiedAreas_;
1078   // And an integer->multiTramp so we can replace multis easily
1079   dictionary_hash<int, multiTramp *> multiTrampDict;
1080
1081   // Keep track of function replacements so that we can fix them
1082   // up later
1083   dictionary_hash<Address, replacedFunctionCall *> replacedFunctionCalls_;
1084
1085   // Address -> instruction pointer (with sanity checking)
1086   codeRangeTree codeSections_;
1087   codeRangeTree dataSections_;
1088
1089   // Signal handling!
1090   codeRangeTree signalHandlerLocations_;
1091
1092   //////////////////
1093   // Startup and initialization
1094   //////////////////
1095   bootstrapState_t bootstrapState;
1096   unsigned char savedCodeBuffer[BYTES_TO_SAVE];
1097 #if defined(arch_x86) || defined(arch_x86_64)
1098   unsigned char savedStackFrame[BYTES_TO_SAVE];
1099 #endif
1100   dyn_saved_regs *savedRegs;
1101
1102   Address dyninstlib_brk_addr;
1103   Address main_brk_addr;
1104
1105   bool runProcessAfterInit;
1106
1107 #if defined(os_windows)
1108   // On windows we need to temporarily keep details of process creation in
1109   // order to handle their debug mechanism. We create the process, then get a message
1110   // about it (instead of our "pull" mechanism on other platforms). This gives us
1111   // space to stash the info.
1112   // Instead of tracking what we need to peel out, we keep the whole thing for later.
1113
1114   handleT processHandle_;
1115   handleT mainFileHandle_;
1116   Address mainFileBase_;
1117 #endif
1118
1119   ////////////////////
1120   // Inferior heap
1121   ////////////////////
1122   bool splitHeaps;              /* are there separate code/data heaps? */
1123   bool heapInitialized_;
1124   inferiorHeap heap;            /* the heap */
1125   bool inInferiorMallocDynamic; // The oddest recursion problem...
1126
1127   /////////////////////
1128   // System call and signal handling
1129   /////////////////////
1130   // Tracing for whatever mechanism we use to notify us of syscalls made
1131   // by the process (fork/exec/exit)
1132   syscallNotification *tracedSyscalls_;
1133
1134   // A list of traps inserted at system calls
1135   pdvector<syscallTrap *> syscallTraps_;
1136
1137   /////////////////////
1138   // Instrumentation
1139   /////////////////////
1140   pdvector<instMapping *> tracingRequests;
1141   pdvector<generatedCodeObject *> pendingGCInstrumentation;
1142
1143   // Total observed cost. To avoid 64-bit math in the base tramps, we
1144   // use a 32-bit temporary accumulator and periodically dump it to
1145   // this variable.
1146   uint64_t cumulativeObsCost;
1147   unsigned lastObsCostLow; // Value of counter last time we checked it
1148   Address costAddr_; // Address of global cost in the mutatee
1149
1150   Address threadIndexAddr; // Thread ID->index mapping
1151   Address trampGuardBase_; // Tramp recursion index mapping
1152
1153   ///////////////////////////////
1154   // Platform-specific
1155   ///////////////////////////////
1156
1157 #if defined( arch_ia64 )
1158   unw_addr_space * unwindAddressSpace;
1159   void * unwindProcessArg;
1160
1161   bool insertAndRegisterDynamicUnwindInformation( unw_dyn_info_t * unwindInformation );
1162 #endif
1163
1164 #if defined(os_linux)
1165   //////////////////
1166   // Linux vsyscall stuff
1167   //////////////////
1168   Address vsyscall_start_;
1169   Address vsyscall_end_;
1170   Address vsyscall_text_;
1171   void *vsyscall_data_;
1172 #endif
1173
1174
1175 };
1176
1177
1178 process *ll_createProcess(const pdstring file, pdvector<pdstring> *argv,
1179                           pdvector<pdstring> *envp,
1180                           const pdstring dir, int stdin_fd, int stdout_fd,
1181                           int stderr_fd);
1182
1183 process *ll_attachProcess(const pdstring &progpath, int pid);
1184
1185 process *ll_attachToCreatedProcess(int pid, const pdstring &progpath);
1186
1187 bool isInferiorAllocated(process *p, Address block);
1188
1189 #if !defined(os_linux)
1190 inline void process::independentLwpControlInit() { }
1191 #endif
1192
1193 extern pdvector<process *> processVec;
1194
1195 #endif