proccontrol/src/int_process.h

   1 #if !defined(INT_PROCESS_H_)
   2 #define INT_PROCESS_H_
   3
   4 #include "proccontrol/h/Process.h"
   5 #include "proccontrol/h/PCErrors.h"
   6 #include "proccontrol/h/Event.h"
   7
   8 #include "dynutil/h/dyn_regs.h"
   9 #include "common/h/dthread.h"
  10
  11 #include <vector>
  12 #include <map>
  13 #include <list>
  14 #include <set>
  15 #include <utility>
  16 #include <queue>
  17
  18 using namespace Dyninst;
  19 using namespace ProcControlAPI;
  20
  21 class int_thread;
  22 class int_threadPool;
  23 class handlerpool;
  24 class int_iRPC;
  25
  26 typedef dyn_detail::boost::shared_ptr<int_iRPC> int_iRPC_ptr;
  27 typedef std::map<Dyninst::MachRegister, std::pair<unsigned int, unsigned int> > dynreg_to_user_t;
  28
  29 typedef std::list<int_iRPC_ptr> rpc_list_t;
  30
  31 class installed_breakpoint;
  32 class int_library;
  33 class int_process;
  34
  35 class mem_state
  36 {
  37   public:
  38    typedef mem_state* ptr;
  39    mem_state(int_process *proc);
  40    mem_state(mem_state &m, int_process *proc);
  41    ~mem_state();
  42
  43    void addProc(int_process *p);
  44    void rmProc(int_process *p, bool &should_clean);
  45
  46    std::set<int_process *> procs;
  47    std::set<int_library *> libs;
  48    std::map<Dyninst::Address, installed_breakpoint *> breakpoints;
  49    std::map<Dyninst::Address, unsigned long> inf_malloced_memory;
  50 };
  51
  52 class int_process
  53 {
  54    friend class Dyninst::ProcControlAPI::Process;
  55  protected:
  56    int_process(Dyninst::PID p, std::string e, std::vector<std::string> a);
  57    int_process(Dyninst::PID pid_, int_process *p);
  58  public:
  59    static int_process *createProcess(Dyninst::PID p, std::string e);
  60    static int_process *createProcess(std::string e, std::vector<std::string> a);
  61    static int_process *createProcess(Dyninst::PID pid_, int_process *p);
  62    virtual ~int_process();
  63  protected:
  64    bool create();
  65    virtual bool plat_create() = 0;
  66    virtual bool post_create();
  67
  68    bool attach();
  69    virtual bool plat_attach() = 0;
  70    bool attachThreads();
  71    virtual bool post_attach();
  72
  73   public:
  74    bool forked();
  75   protected:
  76    virtual bool plat_forked() = 0;
  77    virtual bool post_forked();
  78
  79   public:
  80    bool execed();
  81   protected:
  82    virtual bool plat_execed() = 0;
  83    virtual bool plat_detach() = 0;
  84    virtual bool plat_terminate(bool &needs_sync) = 0;
  85
  86    virtual bool needIndividualThreadAttach() = 0;
  87    virtual bool getThreadLWPs(std::vector<Dyninst::LWP> &lwps);
  88
  89    static bool multi_attach(std::vector<int_process *> &pids);
  90    bool waitfor_startup();
  91
  92    void setPid(Dyninst::PID pid);
  93    int_thread *findStoppedThread();
  94
  95   public:
  96    typedef enum {
  97       neonatal = 0,
  98       neonatal_intermediate,
  99       running,
 100       exited,
 101       errorstate
 102    } State;
 103    State getState() const;
 104    void setState(State s);
 105
 106    Dyninst::PID getPid() const;
 107    int_threadPool *threadPool() const;
 108
 109    Process::ptr proc() const;
 110    mem_state::ptr memory() const;
 111
 112    bool detach(bool &should_clean);
 113    bool terminate(bool &needs_sync);
 114    void updateSyncState(Event::ptr ev, bool gen);
 115    virtual Dyninst::Architecture getTargetArch() = 0;
 116    virtual unsigned getTargetPageSize() = 0;
 117    virtual Dyninst::Address mallocExecMemory(unsigned size);
 118    virtual Dyninst::Address plat_mallocExecMemory(Dyninst::Address min, unsigned size) = 0;
 119    virtual void freeExecMemory(Dyninst::Address addr);
 120
 121    static bool waitAndHandleEvents(bool block);
 122    static bool waitAndHandleForProc(bool block, int_process *proc, bool &proc_exited);
 123    static const char *stateName(State s);
 124    void initializeProcess(Process::ptr p);
 125
 126    void setExitCode(int c);
 127    void setCrashSignal(int s);
 128    bool getExitCode(int &c);
 129    bool getCrashSignal(int &s);
 130
 131    virtual bool plat_individualRegAccess() = 0;
 132
 133    void addProcStopper(Event::ptr ev);
 134    Event::ptr removeProcStopper();
 135    bool hasQueuedProcStoppers() const;
 136
 137    int getAddressWidth();
 138    HandlerPool *handlerPool() const;
 139
 140    bool addBreakpoint(Dyninst::Address addr, int_breakpoint *bp);
 141    bool rmBreakpoint(Dyninst::Address addr, int_breakpoint *bp);
 142    installed_breakpoint *getBreakpoint(Dyninst::Address addr);
 143
 144    Dyninst::Address infMalloc(unsigned long size, bool use_addr = false, Dyninst::Address addr = 0x0);
 145    bool infFree(Dyninst::Address addr);
 146
 147    bool readMem(void *local, Dyninst::Address remote, size_t size);
 148    bool writeMem(void *local, Dyninst::Address remote, size_t size);
 149    virtual bool plat_readMem(int_thread *thr, void *local,
 150                              Dyninst::Address remote, size_t size) = 0;
 151    virtual bool plat_writeMem(int_thread *thr, void *local,
 152                               Dyninst::Address remote, size_t size) = 0;
 153
 154    virtual bool independentLWPControl() = 0;
 155    static bool isInCB();
 156    static void setInCB(bool b);
 157
 158    int_library *getLibraryByName(std::string s) const;
 159    size_t numLibs() const;
 160    virtual bool refresh_libraries(std::set<int_library *> &added_libs,
 161                                   std::set<int_library *> &rmd_libs) = 0;
 162    virtual bool initLibraryMechanism() = 0;
 163
 164    bool forceGeneratorBlock() const;
 165    void setForceGeneratorBlock(bool b);
 166
 167    std::string getExecutable() const;
 168    static bool isInCallback();
 169
 170    static int_process *in_waitHandleProc;
 171  protected:
 172    State state;
 173    Dyninst::PID pid;
 174    std::string executable;
 175    std::vector<std::string> argv;
 176    Dyninst::Architecture arch;
 177    int_threadPool *threadpool;
 178    Process::ptr up_proc;
 179    HandlerPool *handlerpool;
 180    LibraryPool libpool;
 181    bool hasCrashSignal;
 182    int crashSignal;
 183    bool hasExitCode;
 184    bool forceGenerator;
 185    int exitCode;
 186    static bool in_callback;
 187    mem_state::ptr mem;
 188    std::map<Dyninst::Address, unsigned> exec_mem_cache;
 189    std::queue<Event::ptr> proc_stoppers;
 190 };
 191
 192 class int_registerPool
 193 {
 194  public:
 195    int_registerPool();
 196    int_registerPool(const int_registerPool &c);
 197    ~int_registerPool();
 198
 199    typedef std::map<Dyninst::MachRegister, Dyninst::MachRegisterVal> reg_map_t;
 200    reg_map_t regs;
 201    bool full;
 202    int_thread *thread;
 203
 204    typedef reg_map_t::iterator iterator;
 205    typedef reg_map_t::const_iterator const_iterator;
 206 };
 207
 208 class thread_exitstate
 209 {
 210   public:
 211    Dyninst::LWP lwp;
 212    Dyninst::THR_ID thr_id;
 213    Process::ptr proc_ptr;
 214 };
 215
 216 class proc_exitstate
 217 {
 218   public:
 219    Dyninst::PID pid;
 220    bool exited;
 221    bool crashed;
 222    int crash_signal;
 223    int exit_code;
 224 };
 225
 226 /**
 227  * ON THREADING STATES:
 228  *
 229  * Each thread has four different states, which mostly monitor running/stopped
 230  * status:
 231  *   GeneratorState - Thread state as seen by the generator object
 232  *   HandlerState - Thread state as seen by the handler object
 233  *   InternalState - Target thread state desired by int_* layer
 234  *   UserState - Target Thread state as desired by the user
 235  *
 236  * The GeneratorState and HandlerState represent an event as it moves through the
 237  * system.  For example, an event that stops the thread may first appear
 238  * in the Generator object, and move the GeneratorState to 'stopped'.  It is then
 239  * seen by the handler, which moves the HandlerState to 'stopped'.  If the thread is
 240  * then continued, the HandlerState and GeneratorStates will go back to 'running'.
 241  * These are primarily seperated to prevent race conditions with the handler and
 242  * generators modifying the same variable, since they run in seperate threads.
 243  *
 244  * The InternalState and UserState are used to make policy decisions about whether
 245  * a thread should be running or stopped.  For example, after handling an event
 246  * we may check the UserState to see if the user wants us to run/stop a thread.
 247  * The InternalState usually matches the UserState, but may override it for
 248  * stop/run decisions in a few scenarios.  For example, if the user posts a iRPC
 249  * to a running process (UserState = running) we may have to temporarily stop the
 250  * process to install the iRPC.  We don't want to change the UserState, since the user
 251  * still wants the process running, so we set the InternalState to stopped while we
 252  * set up the iRPC, and then return it to the UserState value when the iRPC is ready.
 253  *
 254  * There are a couple of important assertions about the relationship between these thread
 255  * states:
 256  *  (GeneratorState == running) implies (HandlerState == running)
 257  *  (HandlerState == running)  implies (InternalState == running)
 258  *  (InternalState == stopped)  implies (HandlerState == stopped)
 259  *  (HandlerState == stopped)  implies (GeneratorState == stopped)
 260  **/
 261 class int_thread
 262 {
 263    friend class int_threadPool;
 264  protected:
 265    int_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l);
 266    static int_thread *createThreadPlat(int_process *proc,
 267                                        Dyninst::THR_ID thr_id,
 268                                        Dyninst::LWP lwp_id,
 269                                        bool initial_thrd);
 270  public:
 271    static int_thread *createThread(int_process *proc,
 272                                    Dyninst::THR_ID thr_id,
 273                                    Dyninst::LWP lwp_id,
 274                                    bool initial_thrd);
 275    Process::ptr proc() const;
 276    int_process *llproc() const;
 277
 278    Dyninst::THR_ID getTid() const;
 279    Dyninst::LWP getLWP() const;
 280
 281    typedef enum {
 282       neonatal,
 283       neonatal_intermediate,
 284       running,
 285       stopped,
 286       exited,
 287       errorstate
 288    } State;
 289
 290    //State management, see above comment on states
 291    State getHandlerState() const;
 292    State getUserState() const;
 293    State getGeneratorState() const;
 294    State getInternalState() const;
 295    bool setHandlerState(State s);
 296    bool setUserState(State s);
 297    bool setGeneratorState(State s);
 298    bool setInternalState(State s);
 299    void restoreInternalState(bool sync = true);
 300    void desyncInternalState();
 301
 302    //Process control
 303    bool userCont();
 304    bool userStop();
 305    bool intStop(bool sync = true);
 306    bool intCont();
 307
 308    void setContSignal(int sig);
 309    bool contWithSignal(int sigOverride = -1);
 310    virtual bool plat_cont() = 0;
 311    virtual bool plat_stop() = 0;
 312    void setPendingUserStop(bool b);
 313    bool hasPendingUserStop() const;
 314    void setPendingStop(bool b);
 315    bool hasPendingStop() const;
 316
 317    //Single-step
 318    bool singleStepMode() const;
 319    void setSingleStepMode(bool s);
 320    bool singleStepUserMode() const;
 321    void setSingleStepUserMode(bool s);
 322    bool singleStep() const;
 323    void markClearingBreakpoint(installed_breakpoint *bp);
 324    installed_breakpoint *isClearingBreakpoint();
 325
 326    //RPC Management
 327    void addPostedRPC(int_iRPC_ptr rpc_);
 328    rpc_list_t *getPostedRPCs();
 329    bool hasPostedRPCs();
 330    void setRunningRPC(int_iRPC_ptr rpc_);
 331    void clearRunningRPC();
 332    int_iRPC_ptr runningRPC() const;
 333    bool saveRegsForRPC();
 334    bool restoreRegsForRPC(bool clear);
 335    bool hasSavedRPCRegs();
 336    bool runningInternalRPC() const;
 337    void incSyncRPCCount();
 338    void decSyncRPCCount();
 339    bool hasSyncRPC();
 340    int_iRPC_ptr nextPostedIRPC() const;
 341    bool handleNextPostedIRPC(bool block);
 342    int_iRPC_ptr hasRunningProcStopperRPC() const;
 343
 344    //Register Management
 345    bool getAllRegisters(int_registerPool &pool);
 346    bool getRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal &val);
 347    bool setAllRegisters(int_registerPool &pool);
 348    bool setRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val);
 349    virtual bool plat_getAllRegisters(int_registerPool &pool) = 0;
 350    virtual bool plat_getRegister(Dyninst::MachRegister reg,
 351                                  Dyninst::MachRegisterVal &val) = 0;
 352    virtual bool plat_setAllRegisters(int_registerPool &pool) = 0;
 353    virtual bool plat_setRegister(Dyninst::MachRegister reg,
 354                                  Dyninst::MachRegisterVal val) = 0;
 355
 356    //Misc
 357    virtual bool attach() = 0;
 358    Thread::ptr thread();
 359
 360    virtual ~int_thread();
 361    static const char *stateStr(int_thread::State s);
 362  protected:
 363    Dyninst::THR_ID tid;
 364    Dyninst::LWP lwp;
 365    int_process *proc_;
 366    Thread::ptr up_thread;
 367    int continueSig_;
 368    State handler_state;
 369    State user_state;
 370    State generator_state;
 371    State internal_state;
 372
 373    int_registerPool cached_regpool;
 374    Mutex regpool_lock;
 375    int_iRPC_ptr running_rpc;
 376    rpc_list_t posted_rpcs;
 377    int_registerPool rpc_regs;
 378    unsigned sync_rpc_count;
 379    bool pending_user_stop;
 380    bool pending_stop;
 381    int num_locked_stops;
 382    bool user_single_step;
 383    bool single_step;
 384    installed_breakpoint *clearing_breakpoint;
 385
 386    bool setAnyState(int_thread::State *from, int_thread::State to);
 387
 388    //Stop/Continue
 389    typedef enum {
 390       sc_error,
 391       sc_success,
 392       sc_success_pending,
 393       sc_skip
 394    } stopcont_ret_t;
 395    bool stop(bool user_stop, bool sync);
 396    bool cont(bool user_cont);
 397    stopcont_ret_t stop(bool user_stop);
 398    stopcont_ret_t cont(bool user_cont, bool has_proc_lock);
 399 };
 400
 401 class int_threadPool {
 402    friend class Dyninst::ProcControlAPI::ThreadPool;
 403    friend class Dyninst::ProcControlAPI::ThreadPool::iterator;
 404  private:
 405    std::vector<int_thread *> threads;
 406    std::vector<Thread::ptr> hl_threads;
 407    std::map<Dyninst::LWP, int_thread *> thrds_by_lwp;
 408
 409    int_thread *initial_thread;
 410    int_process *proc_;
 411    ThreadPool *up_pool;
 412  public:
 413    int_threadPool(int_process *p);
 414    ~int_threadPool();
 415
 416    void setInitialThread(int_thread *thrd);
 417    void addThread(int_thread *thrd);
 418    void rmThread(int_thread *thrd);
 419    void restoreInternalState(bool sync);
 420    void desyncInternalState();
 421    void clear();
 422
 423    typedef std::vector<int_thread *>::iterator iterator;
 424    iterator begin() { return threads.begin(); }
 425    iterator end() { return threads.end(); }
 426
 427    unsigned size() const;
 428
 429    int_process *proc() const;
 430    ThreadPool *pool() const;
 431
 432    int_thread *findThreadByLWP(Dyninst::LWP lwp);
 433    int_thread *initialThread() const;
 434    bool allStopped();
 435
 436    bool userCont();
 437    bool userStop();
 438    bool intStop(bool sync = true);
 439    bool intCont();
 440  private:
 441    bool cont(bool user_cont);
 442    bool stop(bool user_stop, bool sync);
 443 };
 444
 445 class int_library
 446 {
 447    friend class Dyninst::ProcControlAPI::LibraryPool;
 448    friend class Dyninst::ProcControlAPI::LibraryPool::iterator;
 449    friend class Dyninst::ProcControlAPI::LibraryPool::const_iterator;
 450   private:
 451    std::string name;
 452    Dyninst::Address load_address;
 453    Dyninst::Address data_load_address;
 454    bool has_data_load;
 455    bool marked;
 456    Library::ptr up_lib;
 457   public:
 458    int_library(std::string n, Dyninst::Address load_addr);
 459    int_library(std::string n, Dyninst::Address load_addr,
 460                Dyninst::Address data_load_addr);
 461    int_library(int_library *l);
 462    ~int_library();
 463    std::string getName();
 464    Dyninst::Address getAddr();
 465    Dyninst::Address getDataAddr();
 466    bool hasDataAddr();
 467
 468    void setMark(bool b);
 469    bool isMarked() const;
 470
 471    Library::ptr getUpPtr() const;
 472 };
 473
 474 class int_breakpoint
 475 {
 476    friend class installed_breakpoint;
 477  private:
 478    Breakpoint::weak_ptr up_bp;
 479    Dyninst::Address to;
 480    bool isCtrlTransfer_;
 481    void *data;
 482  public:
 483    int_breakpoint(Breakpoint::ptr up);
 484    int_breakpoint(Dyninst::Address to, Breakpoint::ptr up);
 485    ~int_breakpoint();
 486
 487    bool isCtrlTransfer() const;
 488    Dyninst::Address toAddr() const;
 489    Dyninst::Address getAddress(int_process *p) const;
 490    void *getData() const;
 491    void setData(void *v);
 492    Breakpoint::weak_ptr upBreakpoint() const;
 493 };
 494
 495 class installed_breakpoint
 496 {
 497    friend class Dyninst::ProcControlAPI::EventBreakpoint;
 498  private:
 499    mem_state::ptr memory;
 500    std::set<int_breakpoint *> bps;
 501    std::set<Breakpoint::ptr> hl_bps;
 502
 503    unsigned char buffer[4]; //At least as large as any arch's trap instruction
 504    int buffer_size;
 505    bool installed;
 506    int suspend_count;
 507    Dyninst::Address addr;
 508  public:
 509    installed_breakpoint(mem_state::ptr memory_, Dyninst::Address addr_);
 510    installed_breakpoint(mem_state::ptr memory_, const installed_breakpoint *ip);
 511    ~installed_breakpoint();
 512
 513    bool addBreakpoint(int_process *proc, int_breakpoint *bp);
 514    bool rmBreakpoint(int_process *proc, int_breakpoint *bp, bool &empty);
 515    bool install(int_process *proc);
 516    bool uninstall(int_process *proc);
 517    bool plat_install(int_process *proc, bool should_save);
 518
 519    bool suspend(int_process *proc);
 520    bool resume(int_process *proc);
 521
 522    bool isInstalled() const;
 523    Dyninst::Address getAddr() const;
 524 };
 525
 526 class int_notify {
 527    friend int_notify *notify();
 528    friend EventNotify *Dyninst::ProcControlAPI::evNotify();
 529  private:
 530    static int_notify *the_notify;
 531    EventNotify *up_notify;
 532    std::set<EventNotify::notify_cb_t> cbs;
 533    int pipe_in;
 534    int pipe_out;
 535    int pipe_count;
 536    int events_noted;
 537    void writeToPipe();
 538    void readFromPipe();
 539    bool createPipe();
 540  public:
 541    int_notify();
 542
 543    void noteEvent();
 544    void clearEvent();
 545    void registerCB(EventNotify::notify_cb_t cb);
 546    void removeCB(EventNotify::notify_cb_t cb);
 547    bool hasEvents();
 548    int getPipeIn();
 549 };
 550 int_notify *notify();
 551
 552 extern void setGeneratorThread(long t);
 553 void setHandlerThread(long t);
 554 bool isGeneratorThread();
 555 bool isHandlerThread();
 556 HandlerPool *createDefaultHandlerPool();
 557 HandlerPool *plat_createDefaultHandlerPool(HandlerPool *hpool);
 558
 559 class MTManager {
 560   friend MTManager *mt();
 561   friend class MTLock;
 562 private:
 563   static MTManager *mt_;
 564   DThread evhandler_thread;
 565   CondVar pending_event_lock;
 566   Mutex work_lock;
 567   bool have_queued_events;
 568   bool is_running;
 569   bool should_exit;
 570   Process::thread_mode_t threadMode;
 571
 572   void evhandler_main();
 573   static void evhandler_main_wrapper(void *);
 574   void eventqueue_cb();
 575   static void eventqueue_cb_wrapper();
 576
 577 public:
 578   static const Process::thread_mode_t default_thread_mode = Process::HandlerThreading;
 579   MTManager();
 580   ~MTManager();
 581
 582   void run();
 583   void stop();
 584
 585   void startWork();
 586   void endWork();
 587
 588   bool handlerThreading();
 589   Process::thread_mode_t getThreadMode();
 590   bool setThreadMode(Process::thread_mode_t tm, bool init = false);
 591 };
 592
 593 inline MTManager *mt() {
 594    return MTManager::mt_;
 595 };
 596
 597 class MTLock
 598 {
 599  private:
 600    bool should_unlock;
 601  public:
 602    typedef enum {allow_init} initialize;
 603    typedef enum {allow_generator} generator;
 604    typedef enum {nocb, deliver_callbacks} callbacks;
 605    MTLock(initialize, callbacks c = nocb)
 606    {
 607       should_unlock = true;
 608       if (!MTManager::mt_) {
 609          MTManager::mt_ = new MTManager();
 610          if (MTManager::default_thread_mode == Process::HandlerThreading ||
 611              MTManager::default_thread_mode == Process::CallbackThreading) {
 612             mt()->startWork();
 613          }
 614          mt()->setThreadMode(MTManager::default_thread_mode, true);
 615       }
 616       else if (mt()->handlerThreading()) {
 617          mt()->startWork();
 618          if (c == deliver_callbacks &&
 619              MTManager::default_thread_mode == Process::HandlerThreading &&
 620              notify()->hasEvents())
 621          {
 622             pthrd_printf("MTLock triggered event handling\n");
 623             int_process::waitAndHandleEvents(false);
 624             pthrd_printf("MTLock triggered event handling finished\n");
 625          }
 626       }
 627    }
 628
 629    MTLock(generator)
 630    {
 631       if (isGeneratorThread()) {
 632          should_unlock = false;
 633          return;
 634       }
 635       should_unlock = true;
 636       if (mt()->handlerThreading()) {
 637          mt()->startWork();
 638       }
 639    }
 640
 641    MTLock(callbacks)
 642    {
 643       assert(!isGeneratorThread());
 644       should_unlock = true;
 645       if (mt()->handlerThreading()) {
 646          mt()->startWork();
 647          if (notify()->hasEvents() &&
 648              MTManager::default_thread_mode == Process::HandlerThreading)
 649          {
 650             pthrd_printf("MTLock triggered event handling\n");
 651             int_process::waitAndHandleEvents(false);
 652             pthrd_printf("MTLock triggered event handling finished\n");
 653          }
 654       }
 655    }
 656
 657    MTLock()
 658    {
 659       assert(!isGeneratorThread());
 660       should_unlock = true;
 661       if (mt()->handlerThreading())
 662          mt()->startWork();
 663    }
 664
 665    ~MTLock() {
 666       if (should_unlock && mt()->handlerThreading())
 667          mt()->endWork();
 668    }
 669 };
 670
 671 #endif