Add a procControlAPI getMemoryPageSize() by using existing function getTargetPageSize...
[dyninst.git] / proccontrol / h / PCProcess.h
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #if !defined(PROCESSPC_H_)
32 #define PROCESSPC_H_
33
34 #include <string>
35 #include <vector>
36 #include <map>
37 #include <set>
38
39 #include "dyntypes.h"
40 #include "dyn_regs.h"
41 #include "EventType.h"
42 #include "util.h"
43 #include "PCErrors.h"
44 #include "boost/checked_delete.hpp"
45 #include "boost/shared_ptr.hpp"
46 #include "boost/weak_ptr.hpp"
47 #include "boost/enable_shared_from_this.hpp"
48
49
50 class int_process;
51 class int_breakpoint;
52 class proc_exitstate;
53 class thread_exitstate;
54 class int_library;
55 class int_thread;
56 class int_threadPool;
57 class int_registerPool;
58 class rpc_wrapper;
59 class int_iRPC;
60 class int_notify;
61 class HandlerPool;
62 class MTLock;
63
64 #define PC_VERSION_8_0_0
65
66 #define pc_const_cast boost::const_pointer_cast
67
68 namespace Dyninst {
69
70 class SymbolReaderFactory;
71
72 namespace ProcControlAPI {
73
74 class Process;
75 class ThreadPool;
76 class Thread;
77 class EventDecoder;
78 class EventGenerator;
79 class EventHandler;
80 class Event;
81 class RegisterPool;
82 class Breakpoint;
83 class ProcessSet;
84 class ThreadSet;
85 class LibraryTracking;
86 class ThreadTracking;
87 class LWPTracking;
88 class CallStackUnwinding;
89 class FollowFork;
90 class SignalMask;
91
92 class ExecFileInfo;
93
94 class PC_EXPORT Breakpoint 
95 {
96    friend class ::int_breakpoint;
97    friend void boost::checked_delete<Breakpoint>(Breakpoint *);
98    friend void boost::checked_delete<const Breakpoint>(const Breakpoint *);
99  private:
100    int_breakpoint *llbreakpoint_;
101    Breakpoint();
102    ~Breakpoint();
103  public:
104    static const int BP_X = 1;
105    static const int BP_W = 2;
106    static const int BP_R = 4;
107
108    int_breakpoint *llbp() const;
109    typedef boost::shared_ptr<Breakpoint> ptr;
110    typedef boost::shared_ptr<const Breakpoint> const_ptr;
111    typedef boost::weak_ptr<Breakpoint> weak_ptr;
112
113    static Breakpoint::ptr newBreakpoint();
114    static Breakpoint::ptr newTransferBreakpoint(Dyninst::Address to);
115    static Breakpoint::ptr newTransferOffsetBreakpoint(signed long shift);
116    static Breakpoint::ptr newHardwareBreakpoint(unsigned int mode, unsigned int size);
117
118    void *getData() const;
119    void setData(void *p) const;
120
121    bool isCtrlTransfer() const;
122    Dyninst::Address getToAddress() const;
123
124    void setSuppressCallbacks(bool);
125    bool suppressCallbacks() const;
126 };
127
128 class PC_EXPORT Library
129 {
130    friend class ::int_library;
131    friend void boost::checked_delete<Library>(Library *);
132    friend void boost::checked_delete<const Library>(const Library *);
133  private:
134    int_library *lib;
135    Library();
136    ~Library();
137  public:
138    typedef boost::shared_ptr<Library> ptr;
139    typedef boost::shared_ptr<const Library> const_ptr;
140
141    std::string getName() const;
142    Dyninst::Address getLoadAddress() const;
143    Dyninst::Address getDataLoadAddress() const;
144    Dyninst::Address getDynamicAddress() const;
145    int_library *debug() const { return lib; }
146    bool isSharedLib() const;
147
148    void *getData() const;
149    void setData(void *p) const;
150 };
151
152
153 class PC_EXPORT LibraryPool
154 {
155    friend class ::int_process;
156    friend class Dyninst::ProcControlAPI::Process;
157  private:
158    int_process *proc;
159    LibraryPool();
160    ~LibraryPool();
161  public:
162   class PC_EXPORT iterator {
163       friend class Dyninst::ProcControlAPI::LibraryPool;
164    private:
165       std::set<int_library *>::iterator int_iter;
166    public:
167       iterator();
168       ~iterator();
169       Library::ptr operator*() const;
170       bool operator==(const iterator &i) const;
171       bool operator!=(const iterator &i) const;
172       LibraryPool::iterator operator++();
173       LibraryPool::iterator operator++(int);
174   };
175
176   class PC_EXPORT const_iterator {
177      friend class Dyninst::ProcControlAPI::LibraryPool;
178   private:
179      std::set<int_library *>::iterator int_iter;
180   public:
181      const_iterator();
182      ~const_iterator();
183      Library::const_ptr operator*() const;
184      bool operator==(const const_iterator &i);
185      bool operator!=(const const_iterator &i);
186      LibraryPool::const_iterator operator++();
187      LibraryPool::const_iterator operator++(int);
188   };
189
190   iterator begin();
191   iterator end();
192   const_iterator begin() const;
193   const_iterator end() const;
194
195   size_t size() const;
196
197   Library::ptr getExecutable();
198   Library::const_ptr getExecutable() const;
199
200   Library::ptr getLibraryByName(std::string s);
201   Library::const_ptr getLibraryByName(std::string s) const;
202 };
203
204 class PC_EXPORT IRPC
205 {
206    friend class ::int_iRPC;
207    friend void boost::checked_delete<IRPC>(IRPC *);
208    friend void boost::checked_delete<const IRPC>(const IRPC *);
209  private:
210    rpc_wrapper *wrapper;
211    IRPC(rpc_wrapper *wrapper_);
212    ~IRPC();
213  public:
214          typedef enum {
215           Error = 0,
216           Created = 1,
217           Posted = 2,
218           Running = 3,
219           // Callback = 4,
220           Done = 5 } State;
221
222    typedef boost::shared_ptr<IRPC> ptr;
223    typedef boost::shared_ptr<const IRPC> const_ptr;
224    typedef boost::weak_ptr<IRPC> weak_ptr;
225    
226    static IRPC::ptr createIRPC(void *binary_blob, unsigned size, 
227                                bool non_blocking = false);
228    static IRPC::ptr createIRPC(void *binary_blob, unsigned size,
229                                Dyninst::Address addr, bool non_blocking = false);
230    static IRPC::ptr createIRPC(IRPC::ptr orig);
231    static IRPC::ptr createIRPC(IRPC::ptr orig, Address addr);
232    
233    rpc_wrapper *llrpc() const;
234
235    Dyninst::Address getAddress() const;
236    void *getBinaryCode() const;
237    unsigned getBinaryCodeSize() const;
238    unsigned long getID() const;
239    void setStartOffset(unsigned long);
240    unsigned long getStartOffset() const;
241    bool isBlocking() const;
242
243    // user-defined data retrievable during a callback
244    void *getData() const;
245    void setData(void *p) const;
246
247    State state() const;
248
249    // Continues the thread this RPC is running on.
250    // Useful if you don't know the thread assigned to an IRPC
251    bool continueStoppedIRPC();
252 };
253
254 class PC_EXPORT Process : public boost::enable_shared_from_this<Process>
255 {
256  private:
257    friend class ::int_process;
258    friend class ProcessSet;
259
260    int_process *llproc_;
261    proc_exitstate *exitstate_;
262    
263    Process();
264    ~Process();
265    friend void boost::checked_delete<Process>(Process *);
266    friend void boost::checked_delete<const Process>(const Process *);
267  public:
268    typedef boost::shared_ptr<Process> ptr;
269    typedef boost::shared_ptr<const Process> const_ptr;
270    typedef boost::weak_ptr<Process> weak_ptr;
271    typedef boost::weak_ptr<const Process> const_weak_ptr;
272
273    static void version(int& major, int& minor, int& maintenance);
274
275    //These four functions are not for end-users.  
276    int_process *llproc() const { return llproc_; }
277    proc_exitstate *exitstate() const { return exitstate_; }
278    void setLastError(ProcControlAPI::err_t err_code, const char *err_str) const;
279    void clearLastError() const;
280    
281    /**
282     * Threading modes control
283     **/
284    typedef enum {
285      NoThreads,
286      GeneratorThreading,
287      HandlerThreading,
288      CallbackThreading
289    } thread_mode_t;
290    static bool setThreadingMode(thread_mode_t tm);
291    static thread_mode_t getThreadingMode();
292
293    /**
294     * Create and attach to new processes
295     **/
296    static const std::map<int,int> emptyFDs;
297    static const std::vector<std::string> emptyEnvp;
298    static Process::ptr createProcess(std::string executable,
299                                      const std::vector<std::string> &argv,
300                                      const std::vector<std::string> &envp = emptyEnvp,
301                                      const std::map<int,int> &fds = emptyFDs);
302    static Process::ptr attachProcess(Dyninst::PID pid, std::string executable = "");
303
304    /**
305     * Event Management
306     **/
307    enum cb_action_t {
308      cbDefault,
309      cbThreadContinue,
310      cbThreadStop,
311      cbProcContinue,
312      cbProcStop
313    };
314    struct cb_ret_t {
315       cb_ret_t(cb_action_t p) : parent(p), child(cbDefault) {}
316       cb_ret_t(cb_action_t p, cb_action_t c) : parent(p), child(c) {}
317       cb_action_t parent;
318       cb_action_t child;
319    };
320    
321    //cb_func_t really takes an 'Event::const_ptr' as parameter, but this declaration
322    // defines the shared_ptr declaration due to Event::const_ptr not being defined yet.
323    typedef cb_ret_t(*cb_func_t)(boost::shared_ptr<const Event>);
324
325    static bool handleEvents(bool block);
326    static bool registerEventCallback(EventType evt, cb_func_t cbfunc);
327    static bool removeEventCallback(EventType evt, cb_func_t cbfunc);
328    static bool removeEventCallback(EventType evt);
329    static bool removeEventCallback(cb_func_t cbfunc);
330
331    // user-defined data retrievable during a callback
332    void *getData() const;
333    void setData(void *p) const;
334
335    Dyninst::PID getPid() const;
336
337    /**
338     * Threads
339     **/
340    const ThreadPool &threads() const;
341    ThreadPool &threads();
342    
343    /**
344     * Test state of process
345     **/
346    bool isTerminated() const;
347    bool isExited() const;
348    bool isCrashed() const;
349    bool isDetached() const;
350    int getExitCode() const;
351    int getCrashSignal() const;
352
353    bool hasStoppedThread() const;
354    bool hasRunningThread() const;
355    bool allThreadsStopped() const;
356    bool allThreadsRunning() const;
357    bool allThreadsRunningWhenAttached() const;
358
359    /**
360     * What capabilities do we have on this process
361     **/
362    static const unsigned int pc_read      = (1<<0);
363    static const unsigned int pc_write     = (1<<1);
364    static const unsigned int pc_irpc      = (1<<2);   
365    static const unsigned int pc_control   = (1<<3);
366    unsigned int getCapabilities() const;
367    
368    /**
369     * Queries for machine info
370     **/
371    Dyninst::Architecture getArchitecture() const;
372    Dyninst::OSType getOS() const;
373
374    /**
375     * Query what kind of events this process supports
376     **/
377    bool supportsLWPEvents() const;
378    bool supportsUserThreadEvents() const;
379    bool supportsFork() const;
380    bool supportsExec() const;
381
382    /**
383     * Control process
384     **/
385    bool continueProc();
386    bool stopProc();
387    bool detach(bool leaveStopped = false);
388    bool terminate();
389    bool temporaryDetach();
390    bool reAttach();
391
392    /**
393     * Memory management
394     **/
395    class PC_EXPORT mem_perm {
396        bool read;
397        bool write;
398        bool execute;
399
400        int permVal() const;
401
402    public:
403        mem_perm() : read(false), write(false), execute(false) {} 
404        mem_perm(const mem_perm& p) : read(p.read), write(p.write),
405                                      execute(p.execute) {}
406        mem_perm(bool r, bool w, bool x) : read(r), write(w), execute(x) {} 
407
408        bool getR() const { return read;    }
409        bool getW() const { return write;   }
410        bool getX() const { return execute; }
411
412        bool isNone() const { return !read && !write && !execute; }
413        bool isR()    const { return  read && !write && !execute; }
414        bool isX()    const { return !read && !write &&  execute; }
415        bool isRW()   const { return  read &&  write && !execute; }
416        bool isRX()   const { return  read && !write &&  execute; }
417        bool isRWX()  const { return  read &&  write &&  execute; }
418
419        mem_perm& setR() { read    = true;  return *this; }
420        mem_perm& setW() { write   = true;  return *this; }
421        mem_perm& setX() { execute = true;  return *this; }
422
423        mem_perm& clrR() { read    = false; return *this; }
424        mem_perm& clrW() { write   = false; return *this; }
425        mem_perm& clrX() { execute = false; return *this; }
426
427        bool operator< (const mem_perm& p) const;
428        bool operator==(const mem_perm& p) const;
429        bool operator!=(const mem_perm& p) const;
430
431        std::string getPermName() const;
432    };
433
434    unsigned getMemoryPageSize() const;
435
436    Dyninst::Address mallocMemory(size_t size);
437    Dyninst::Address mallocMemory(size_t size, Dyninst::Address addr);
438    bool freeMemory(Dyninst::Address addr);
439    bool writeMemory(Dyninst::Address addr, const void *buffer, size_t size) const;
440    bool readMemory(void *buffer, Dyninst::Address addr, size_t size) const;
441
442    bool writeMemoryAsync(Dyninst::Address addr, const void *buffer, size_t size, void *opaque_val = NULL) const;
443    bool readMemoryAsync(void *buffer, Dyninst::Address addr, size_t size, void *opaque_val = NULL) const;
444
445    /** 
446     * Currently Windows-only, needed for the test infrastructure but possibly useful elsewhere 
447     **/
448    Dyninst::Address findFreeMemory(size_t size);
449
450    bool getMemoryAccessRights(Dyninst::Address addr, size_t size, mem_perm& rights);
451    bool setMemoryAccessRights(Dyninst::Address addr, size_t size, mem_perm rights, mem_perm& oldRights);
452
453    /**
454     * Libraries
455     **/
456    const LibraryPool &libraries() const;
457    LibraryPool &libraries();
458
459    /**
460     * Breakpoints
461     **/
462    bool addBreakpoint(Dyninst::Address addr, Breakpoint::ptr bp) const;
463    bool rmBreakpoint(Dyninst::Address addr, Breakpoint::ptr bp) const;
464    unsigned numHardwareBreakpointsAvail(unsigned mode);
465
466    /**
467     * Post IRPC.  Use continueProc/continueThread to run it,
468     * and handleEvents to wait for a blocking IRPC to complete
469     **/
470    bool postIRPC(IRPC::ptr irpc) const;
471    bool getPostedIRPCs(std::vector<IRPC::ptr> &rpcs) const;
472
473    /**
474     * Post and run an IRPC; user must wait for completion. Standard 
475     **/
476         bool runIRPCSync(IRPC::ptr irpc);
477
478    /**
479     * Post, run, and wait for an IRPC to complete
480         **/
481         bool runIRPCAsync(IRPC::ptr irpc);
482
483    /**
484     * Symbol access
485     **/
486    void setSymbolReader(SymbolReaderFactory *reader) const;
487    SymbolReaderFactory *getSymbolReader() const;
488    static SymbolReaderFactory *getDefaultSymbolReader();
489    static void setDefaultSymbolReader(SymbolReaderFactory *reader);
490
491    /**
492     * Perform specific operations.  Interface objects will only be returned
493     * on appropriately supported platforms, others will return NULL.
494     **/
495    LibraryTracking *getLibraryTracking();
496    ThreadTracking *getThreadTracking();
497    LWPTracking *getLWPTracking();
498    FollowFork *getFollowFork();
499    SignalMask *getSignalMask();
500    const LibraryTracking *getLibraryTracking() const;
501    const ThreadTracking *getThreadTracking() const;
502    const LWPTracking *getLWPTracking() const;
503    const FollowFork *getFollowFork() const;
504    const SignalMask *getSignalMask() const;
505    
506    /**
507     * Errors that occured on this process
508     **/
509    ProcControlAPI::err_t getLastError() const;
510    const char *getLastErrorMsg() const;
511
512    /**
513     * Executable info
514     **/
515         ExecFileInfo* getExecutableInfo() const;
516 };
517
518 class PC_EXPORT Thread
519 {
520  protected:
521    friend class ::int_thread;
522    int_thread *llthread_;
523    thread_exitstate *exitstate_;
524
525    Thread();
526    ~Thread();
527    friend void boost::checked_delete<Thread>(Thread *);
528    friend void boost::checked_delete<const Thread>(const Thread *);
529
530  public:
531    typedef boost::shared_ptr<Thread> ptr;
532    typedef boost::shared_ptr<const Thread> const_ptr;
533    typedef boost::weak_ptr<Thread> weak_ptr;
534    typedef boost::weak_ptr<const Thread> const_weak_ptr;
535    int_thread *llthrd() const;
536    void setLastError(err_t ec, const char *es) const;
537
538    Dyninst::LWP getLWP() const;
539    Process::ptr getProcess();
540    Process::const_ptr getProcess() const;
541
542    bool isStopped() const;
543    bool isRunning() const;
544    bool isLive() const;
545    bool isDetached() const;
546    bool isInitialThread() const;
547
548    // Added for Windows. Windows creates internal threads which are bound to 
549    // the process but are used for OS-level work. We hide these from the user,
550    // but need to represent them in ProcControlAPI. 
551    bool isUser() const; 
552
553    bool stopThread();
554    bool continueThread();
555
556    void setSingleStepMode(bool s) const;
557    bool getSingleStepMode() const;
558
559    bool getRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal &val) const;
560    bool getAllRegisters(RegisterPool &pool) const;
561    bool setRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val) const;
562    bool setAllRegisters(RegisterPool &pool) const;
563    bool getAllRegistersAsync(RegisterPool &pool, void *opaque_val = NULL) const;
564    bool setAllRegistersAsync(RegisterPool &pool, void *opaque_val = NULL) const;
565
566    /**
567     * User level thread info.  Only available after a UserThreadCreate event
568     **/
569    bool haveUserThreadInfo() const;
570    Dyninst::THR_ID getTID() const;
571    Dyninst::Address getStartFunction() const;
572    Dyninst::Address getStackBase() const;
573    unsigned long getStackSize() const;
574    Dyninst::Address getTLS() const;
575
576    /**
577     * IRPC
578     **/
579    bool postIRPC(IRPC::ptr irpc) const;
580    bool runIRPCSync(IRPC::ptr irpc);
581    bool runIRPCAsync(IRPC::ptr irpc);
582
583    bool getPostedIRPCs(std::vector<IRPC::ptr> &rpcs) const;
584    IRPC::const_ptr getRunningIRPC() const;
585
586    /**
587     * Returns a stack unwinder on supported platforms (BlueGene/Q).
588     * Returns NULL on unsupported platforms
589     **/
590    CallStackUnwinding *getCallStackUnwinding();
591
592    void *getData() const;
593    void setData(void *p) const;
594 };
595
596 class PC_EXPORT ThreadPool
597 {
598  private:
599    friend class ::int_threadPool;
600    friend class Dyninst::ProcControlAPI::Process;
601    int_threadPool *threadpool;
602    ThreadPool();
603    ~ThreadPool();
604  public:
605    /**
606     * Iterators
607     **/
608    class PC_EXPORT iterator {
609       friend class Dyninst::ProcControlAPI::ThreadPool;
610    private:
611       static const int uninitialized_val = -1;
612       static const int end_val = -2;
613       int_threadPool *curp;
614       Thread::ptr curh;
615       int curi;
616    public:
617       iterator();
618       ~iterator();
619       Thread::ptr operator*() const;
620       bool operator==(const iterator &i);
621       bool operator!=(const iterator &i);
622       ThreadPool::iterator operator++();
623       ThreadPool::iterator operator++(int);
624    };
625    iterator begin();
626    iterator end();
627    iterator find(Dyninst::LWP lwp);
628
629    class PC_EXPORT const_iterator {
630       friend class Dyninst::ProcControlAPI::ThreadPool;
631    private:
632       static const int uninitialized_val = -1;
633       static const int end_val = -2;
634       int_threadPool *curp;
635       Thread::ptr curh;
636       int curi;
637    public:
638       const_iterator();
639       ~const_iterator();
640       Thread::const_ptr operator*() const;
641       bool operator==(const const_iterator &i);
642       bool operator!=(const const_iterator &i);
643       ThreadPool::const_iterator operator++();
644       ThreadPool::const_iterator operator++(int);
645
646           typedef Thread::const_ptr value_type;
647           typedef int difference_type;
648           typedef Thread::const_ptr *pointer;
649           typedef Thread::const_ptr &reference;
650           typedef std::forward_iterator_tag iterator_category;
651    };
652    const_iterator begin() const;
653    const_iterator end() const;
654    const_iterator find(Dyninst::LWP lwp) const;
655
656    size_t size() const;
657    Process::const_ptr getProcess() const;
658    Process::ptr getProcess();
659    Thread::const_ptr getInitialThread() const;
660    Thread::ptr getInitialThread();
661 };
662
663 class PC_EXPORT RegisterPool
664
665    friend class Dyninst::ProcControlAPI::Thread;
666    friend class Dyninst::ProcControlAPI::ThreadSet;
667  private:
668    int_registerPool *llregpool;
669  public:
670    RegisterPool();
671    RegisterPool(const RegisterPool &rp);
672    ~RegisterPool();
673    
674    class PC_EXPORT iterator {
675       friend class Dyninst::ProcControlAPI::RegisterPool;
676    private:
677       typedef std::map<Dyninst::MachRegister, Dyninst::MachRegisterVal>::iterator int_iter; 
678       int_iter i;
679       iterator(int_iter i_);
680    public:
681       iterator();
682       ~iterator();
683       std::pair<Dyninst::MachRegister, Dyninst::MachRegisterVal> operator*();
684       bool operator==(const iterator &i);
685       bool operator!=(const iterator &i);
686       RegisterPool::iterator operator++();
687       RegisterPool::iterator operator++(int);
688    };
689    iterator begin();
690    iterator end();
691    iterator find(Dyninst::MachRegister r);
692
693    class PC_EXPORT const_iterator {
694       friend class Dyninst::ProcControlAPI::RegisterPool;
695    private:
696       typedef std::map<Dyninst::MachRegister, Dyninst::MachRegisterVal>::const_iterator int_iter; 
697       int_iter i;
698       const_iterator(int_iter i_);
699    public:
700       const_iterator();
701       ~const_iterator();
702       std::pair<Dyninst::MachRegister, Dyninst::MachRegisterVal> operator*() const;
703       bool operator==(const const_iterator &i);
704       bool operator!=(const const_iterator &i);
705       RegisterPool::const_iterator operator++();
706       RegisterPool::const_iterator operator++(int);
707    };
708    const_iterator begin() const;
709    const_iterator end() const;
710    const_iterator find(Dyninst::MachRegister r) const;
711
712    Dyninst::MachRegisterVal& operator[](Dyninst::MachRegister r);
713    const Dyninst::MachRegisterVal& operator[](Dyninst::MachRegister r) const;
714
715    size_t size() const;
716    Thread::const_ptr getThread() const;
717    Thread::ptr getThread();
718 };
719
720 class PC_EXPORT EventNotify
721 {
722  private:
723    friend class ::int_notify;
724    int_notify *llnotify;
725    EventNotify();
726    ~EventNotify();
727  public:
728    typedef void (*notify_cb_t)();
729
730    int getFD();
731    void registerCB(notify_cb_t cb);
732    void removeCB(notify_cb_t cb);
733 };
734 PC_EXPORT EventNotify *evNotify();
735
736 class PC_EXPORT ExecFileInfo
737 {
738   public:
739         void* fileHandle;
740         void* processHandle;
741         Address fileBase;
742 };
743
744
745 }
746 }
747
748 #endif