First pass at thread_db integration for FreeBSD.
[dyninst.git] / 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