Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / EventHandler.h
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #ifndef __EVENT_HANDLER__H__
33 #define __EVENT_HANDLER__H__
34
35 #ifdef DYNINST_CLASS_NAME
36 #undef DYNINST_CLASS_NAME
37 #endif
38 #define DYNINST_CLASS_NAME EVENT_HANDLER
39
40 #include "common/h/Types.h" /*for Address */
41 #include "common/h/Pair.h" /*for pdpair */
42 #include "common/h/Vector.h" /*for pdvector */
43 #include "common/h/headers.h" /*for DEBUG_EVENT */
44 #include "common/h/Dictionary.h" /* threadmap */
45 #include "os.h"
46 #include "BPatch_eventLock.h"
47 #include "mailbox.h"
48
49 #define NULL_STATUS_INITIALIZER statusUnknown
50 typedef int eventFileDesc_t;
51
52 class process;
53 class dyn_lwp;
54
55 typedef enum {
56   evtUndefined,   /* undefined event -- usually indicates error */
57   evtNullEvent,   /* null event, nothing (important) happened, but no error */
58   evtIgnore, /* Throw this away when decode is done */
59   evtAnyEvent,
60   evtNewConnection,
61   evtTimeout,
62   evtSignalled,
63   evtException,
64   evtCritical,
65   evtProcessCreate,
66   evtProcessAttach,
67   evtLwpAttach,
68   evtProcessExit, /* used to have exited normally, or via signal, now in status */
69   evtProcessStop,
70   evtProcessSelfTermination,
71   evtThreadCreate,
72   evtThreadExit,
73   evtThreadContextStart,
74   evtThreadContextStop,
75   evtLoadLibrary,
76   evtUnloadLibrary,
77   evtSyscallEntry,
78   evtSyscallExit,
79   evtSuspended, 
80   evtRequestedStop, // For platforms where "stop" can generate a signal
81   evtInstPointTrap,
82   evtDebugStep,
83   evtDynamicCall,
84   evtRPCSignal,
85   evtError,
86   evtPreFork,
87   evtPostFork,
88   evtExec,
89   evtOneTimeCode,
90   evtUserEvent,
91   evtShutDown,
92   evtLibcLoaded, /* libc has been loaded */
93   evtLibcTrap, /* reached trap in __libc_start_main, handle the trap */
94   evtStopThread, /* executed stop thread code snippet */
95   evtSignalHandlerCB, /* invoke SignalHandlerCallback in response to signal */
96   evtProcessInit, /*aka "initialized" */
97   evtProcessLoadedRT, /* dyninst RTlib has been loaded */
98   evtProcessInitDone, /* aka bootstrapped */
99   evtThreadDetect, /* only for linux waitpid loop */
100   //  If you are adding to this list, please augment the function eventType2str(),
101   //  to reflect your changes.
102   evtLastEvent /* placeholder for the end of the list*/
103 } eventType;
104
105 const char *eventType2str(eventType x); 
106
107 typedef Address eventAddress_t;
108
109 typedef enum {
110   statusUnknown,
111   statusNormal,
112   statusSignalled,
113   statusRPCDone,
114   statusRPCAtReturn,
115   statusError
116 } eventStatusCode_t;
117
118
119 class EventRecord {
120   public:
121    EventRecord(); 
122    process *proc;
123    dyn_lwp *lwp;  // the lwps causing the event (not the representative lwp)
124    eventType type;
125    eventWhat_t what;
126    eventStatusCode_t status;
127    eventInfo_t info;
128    eventMoreInfo_t info2;
129    eventAddress_t address;
130    eventFileDesc_t fd; /* only used in async events -- wasteful for clarity*/
131    char *sprint_event(char *buf); 
132    bool isTemplateOf(EventRecord &src);
133
134    void clear();
135 }; 
136
137 class InternalThread {
138   public:
139   //  InternalThread::getThreadID(), return thread id
140   //  returns tid (unsigned) -1 if thread not created yet
141   unsigned long getThreadID() { return tid;}
142   bool isRunning() {return _isRunning;}
143   const char *getName() {return idstr;}
144
145   internal_thread_t handler_thread;
146
147   protected:
148   InternalThread(const char *id);
149   virtual ~InternalThread();
150   bool createThread();
151   bool killThread();
152
153   virtual void main() = 0;
154
155   bool _isRunning;
156   unsigned long tid;
157   char *idstr;
158   eventLock *startupLock;
159   
160   bool init_ok;
161
162   private:
163   
164 };
165
166 #ifdef DYNINST_CLASS_NAME
167 #undef DYNINST_CLASS_NAME
168 #endif
169 #define DYNINST_CLASS_NAME EventHandler
170
171 template <class T>
172 class EventHandler : public InternalThread {
173   friend THREAD_RETURN eventHandlerWrapper(void *);
174   friend THREAD_RETURN asyncHandlerWrapper(void *);
175
176   public:
177   void stopThreadNextIter() {stop_request = true;}
178   bool stopRequested() {return stop_request;}
179   protected:
180
181   //  initialize_event_handler is called before the main event handling
182   //  loop begins on the event handling thread.  When overloaded, allows 
183   //  derived classes to do some initialization on the created thread.
184   //  Returns false on failure to initialize.  Upon failure, the event loop
185   //  is not entered at all and the created thread exits.
186   virtual bool initialize_event_handler() {return true;}
187
188   EventHandler(eventLock *_lock, const char *id, bool create_thread);
189   virtual ~EventHandler();
190
191   virtual bool waitNextEvent(T &ev) = 0; 
192   virtual bool handleEvent(T &ev) = 0;
193   
194   bool _Lock(const char *__file__, unsigned int __line__); 
195   bool _Unlock(const char *__file__, unsigned int __line__); 
196   bool _WaitForSignal(const char *__file__, unsigned int __line__); 
197   bool _Broadcast(const char *__file__, unsigned int __line__); 
198
199   void addToThreadMap();
200   void removeFromThreadMap();
201   void setName(char *idstr);
202
203   eventLock *eventlock;
204   bool stop_request;
205   private:
206   void main();
207
208   // Monitor-equivalent functions; call before entering or leaving
209   // a blocking function. This allows us to delete the object after
210   // the last thread has left. 
211   virtual void MONITOR_ENTRY();
212   virtual void MONITOR_EXIT();
213
214   unsigned usage_count;
215 };
216
217 typedef struct {
218     char *name;
219     bool active;
220 } threadmap_t;
221
222 const char *getThreadStr(unsigned long tid);
223 unsigned long getExecThreadID();
224
225 #endif