Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / callbacks.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 #ifndef __CALLBACKS_H__
32 #define __CALLBACKS_H__
33 #include "dyninstAPI/h/BPatch_Vector.h"
34 #include "dyninstAPI/h/BPatch_Set.h"
35 #include "mailbox.h"
36 #include "rpcMgr.h"
37 #include "util.h"
38
39 inline unsigned eventTypeHash(const eventType &val) 
40 {
41   return (unsigned int) val;
42 }   
43
44 ///////////////////////////////////////////////////////////
45 /////  Callback Manager:  a container for callbacks
46 ///////////////////////////////////////////////////////////
47
48 class CallbackManager {
49
50   public:
51     CallbackManager() : cbs(eventTypeHash) {}
52     ~CallbackManager() {}
53
54     bool registerCallback(eventType evt, CallbackBase *cb);
55     bool removeCallbacks(eventType evt, pdvector<CallbackBase *> &_cbs);
56
57     //  CallbackManager::dispenseCallbacksMatching
58     //
59     //  Makes a copy of any callbacks matching specified event type and
60     //  returns them in a vector.  
61     bool dispenseCallbacksMatching(eventType evt, pdvector<CallbackBase *> &cbs);
62
63   private:
64    dictionary_hash<eventType, pdvector<CallbackBase *> > cbs;
65 };
66
67 extern eventLock *global_mutex;
68
69 CallbackManager *getCBManager();
70 class SignalHandler;
71 class SyncCallback : public CallbackBase
72 {
73   public:
74
75   SyncCallback(bool is_synchronous = true, eventLock *l = global_mutex,
76                unsigned long target_thread_id_ = TARGET_UI_THREAD,
77                CallbackCompletionCallback completion_cb = signalCompletion) :
78     CallbackBase(target_thread_id_, completion_cb), synchronous(is_synchronous),
79     lock(l), completion_signalled(false), sh(NULL) {}
80   SyncCallback(SyncCallback &src) :
81     CallbackBase(src.targetThread(), src.getCleanupCallback()),  
82     synchronous(src.synchronous), lock(global_mutex/*src.lock*/), completion_signalled(false), sh(NULL) {}
83   virtual ~SyncCallback() {}
84
85    void setSynchronous(bool flag = true) {synchronous = flag;}
86    static void signalCompletion(CallbackBase *cb); 
87    virtual bool execute(void); 
88   protected:
89    virtual bool execute_real(void) = 0;
90    virtual bool waitForCompletion(); 
91    bool do_it();
92    bool synchronous;
93    eventLock *lock;
94    bool completion_signalled;
95  public:
96    SignalHandler *sh;
97 };
98
99 ///////////////////////////////////////////////////////////
100 /////  Callback classes,  type-safe and know how to call themselves
101 ///////////////////////////////////////////////////////////
102
103 // BPatchErrorCallback
104 #include "BPatch_callbacks.h"
105
106 class ErrorCallback : public SyncCallback 
107 {  
108   public:
109    ErrorCallback(BPatchErrorCallback callback): SyncCallback(false /*synchronous*/),
110                                                 cb(callback), str(NULL) {}
111    ErrorCallback(ErrorCallback &src) : SyncCallback(false),
112                                        cb(src.cb), num(-1), str(NULL) {}
113    ~ErrorCallback();
114
115    CallbackBase *copy() { return new ErrorCallback(*this);}
116    bool execute_real(void); 
117    bool operator()(BPatchErrorLevel severity,
118                    int number,
119                    const char *error_str);  
120    BPatchErrorCallback getFunc() {return cb;}
121   private:    
122    BPatchErrorCallback cb;    
123    BPatchErrorLevel sev;    
124    int num;    
125    char *str;
126 };
127
128 class ForkCallback : public SyncCallback 
129 {  
130   public:
131    ForkCallback(BPatchForkCallback callback) : SyncCallback(),
132       cb(callback), par(NULL), chld(NULL) {}
133    ForkCallback(ForkCallback &src) : SyncCallback(),
134       cb(src.cb), par(NULL), chld(NULL) {}
135    ~ForkCallback() {}
136
137    CallbackBase *copy() { return new ForkCallback(*this);}
138    bool execute_real(void); 
139    bool operator()(BPatch_thread *parent,
140                    BPatch_thread *child);
141    BPatchForkCallback getFunc() {return cb;}
142   private:    
143    BPatchForkCallback cb;    
144    BPatch_thread *par;
145    BPatch_thread *chld;
146 };
147
148 class ExecCallback : public SyncCallback 
149 {  
150   public:
151    ExecCallback(BPatchExecCallback callback) : SyncCallback(),
152       cb(callback), thread(NULL) {}
153    ExecCallback(ExecCallback &src) : SyncCallback(),
154       cb(src.cb), thread(NULL) {}
155    ~ExecCallback() {}
156
157    CallbackBase *copy() { return new ExecCallback(*this);}
158    bool execute_real(void); 
159    bool operator()(BPatch_thread *thread);
160    BPatchExecCallback getFunc() {return cb;}
161   private:    
162    BPatchExecCallback cb;    
163    BPatch_thread *thread;
164 };
165
166 class ExitCallback : public SyncCallback 
167 {  
168   public:
169    ExitCallback(BPatchExitCallback callback) : SyncCallback(),
170       cb(callback), thread(NULL) {}
171    ExitCallback(ExitCallback &src) : SyncCallback(),
172       cb(src.cb), thread(NULL) {}
173    ~ExitCallback() {}
174
175    CallbackBase *copy() { return new ExitCallback(*this);}
176    bool execute_real(void); 
177    bool operator()(BPatch_thread *thread, BPatch_exitType exit_type);
178    BPatchExitCallback getFunc() {return cb;}
179   private:    
180    BPatchExitCallback cb;    
181    BPatch_thread *thread;
182    BPatch_exitType type;
183 };
184
185 class SignalCallback : public SyncCallback 
186 {  
187   public:
188    SignalCallback(BPatchSignalCallback callback) : SyncCallback(),
189        cb(callback), thread(NULL) {}
190    SignalCallback(SignalCallback &src) : SyncCallback(),
191       cb(src.cb), thread(NULL) {}
192    ~SignalCallback() {}
193
194    CallbackBase *copy() { return new SignalCallback(*this);}
195    bool execute_real(void); 
196    bool operator()(BPatch_thread *thread, int sigNum);
197    BPatchSignalCallback getFunc() {return cb;}
198   private:    
199    BPatchSignalCallback cb;    
200    BPatch_thread *thread;
201    int num;
202 };
203
204 class OneTimeCodeCallback : public SyncCallback 
205 {  
206   public:
207    OneTimeCodeCallback(BPatchOneTimeCodeCallback callback) : SyncCallback(),
208       cb(callback), thread(NULL) {}
209    OneTimeCodeCallback(OneTimeCodeCallback &src) : SyncCallback(),
210       cb(src.cb), thread(NULL), user_data(NULL), return_value(NULL) {}
211    ~OneTimeCodeCallback() {}
212
213    CallbackBase *copy() { return new OneTimeCodeCallback(*this);}
214    bool execute_real(void); 
215    bool operator()(BPatch_thread *thread, void *userData, void *returnValue);
216    BPatchOneTimeCodeCallback getFunc() {return cb;}
217   private:    
218    BPatchOneTimeCodeCallback cb;    
219    BPatch_thread *thread;
220    void *user_data;
221    void *return_value;
222 };
223
224 class DynLibraryCallback : public SyncCallback 
225 {  
226   public:
227    DynLibraryCallback(BPatchDynLibraryCallback callback) : SyncCallback(),
228       cb(callback), thread(NULL) {}
229    DynLibraryCallback(DynLibraryCallback &src) : SyncCallback(),
230        cb(src.cb), thread(NULL), mod(NULL) {}
231    ~DynLibraryCallback() {}
232
233    CallbackBase *copy() { return new DynLibraryCallback(*this);}
234    bool execute_real(void); 
235    bool operator()(BPatch_thread *thread, BPatch_module *module, bool load);
236    BPatchDynLibraryCallback getFunc() {return cb;}
237   private:    
238    BPatchDynLibraryCallback cb;    
239    BPatch_thread *thread;
240    BPatch_module *mod;
241    bool load_param;
242 };
243
244 class DynamicCallsiteCallback : public SyncCallback 
245 {  
246   public:
247    DynamicCallsiteCallback(BPatchDynamicCallSiteCallback c) : SyncCallback(),
248       cb(c), pt(NULL), func(NULL) {}
249    DynamicCallsiteCallback(DynamicCallsiteCallback &src) : SyncCallback(),
250       cb(src.cb), pt(NULL), func(NULL) {}
251    ~DynamicCallsiteCallback() {}
252
253    CallbackBase *copy() { return new DynamicCallsiteCallback(*this);}
254    bool execute_real(void); 
255    bool operator()(BPatch_point *at_point, BPatch_function *called_function);
256    BPatchDynamicCallSiteCallback getFunc() {return cb;}
257   private:    
258    BPatchDynamicCallSiteCallback cb;    
259    BPatch_point *pt;
260    BPatch_function *func;
261 };
262
263 class UserEventCallback : public SyncCallback 
264 {  
265   public:
266    UserEventCallback(BPatchUserEventCallback callback) : SyncCallback(),
267       cb(callback), proc(NULL), buf(NULL) {}
268    UserEventCallback(UserEventCallback &src) : SyncCallback(),
269        cb(src.cb), proc(NULL), buf(NULL), bufsize(-1) {}
270    ~UserEventCallback();
271
272    CallbackBase *copy() { return new UserEventCallback(*this);}
273    bool execute_real(void); 
274    bool operator()(BPatch_process *process, void *buffer, int buffersize);
275    BPatchUserEventCallback getFunc() {return cb;}
276   private:    
277    BPatchUserEventCallback cb;    
278    BPatch_process *proc;
279    void *buf;
280    int bufsize;
281 };
282
283 class StopThreadCallback : public SyncCallback
284 {
285  public:
286     StopThreadCallback(BPatchStopThreadCallback callback) : SyncCallback(),
287         cb(callback), point(NULL), return_value(NULL) {}
288     StopThreadCallback(StopThreadCallback &src) : SyncCallback(),
289         cb(src.cb), point(NULL), return_value(NULL) {}
290     ~StopThreadCallback() {}
291
292     CallbackBase *copy() { return new StopThreadCallback(*this); }
293     bool execute_real(void);
294     bool operator()(BPatch_point *atPoint, void *returnValue);
295     BPatchStopThreadCallback getFunc() {return cb;}
296  private:
297     BPatchStopThreadCallback cb;
298     BPatch_point *point;
299     void *return_value;
300 };
301
302 class SignalHandlerCallback : public SyncCallback
303 {
304  public:
305     SignalHandlerCallback(BPatchSignalHandlerCallback callback, 
306                           BPatch_Set<long> *signums) :
307         SyncCallback(), 
308         cb(callback), 
309         point(NULL), 
310         signum(0), 
311         handlers(NULL),
312         signals(signums),
313         lastSigAddr(0)
314         {}
315     SignalHandlerCallback(SignalHandlerCallback &src) : SyncCallback(),
316         cb(src.cb), point(NULL), signum(0), handlers(NULL), signals(src.signals), 
317         lastSigAddr(lastSigAddr) {}
318     ~SignalHandlerCallback() {}
319     CallbackBase *copy() { return new SignalHandlerCallback(*this); }
320     bool execute_real(void);
321     bool operator()(BPatch_point *at_point, long signum, 
322                     BPatch_Vector<Dyninst::Address> *handlerVec);
323     BPatchSignalHandlerCallback getFunc() {return cb;}
324     Address getLastSigAddr() { return lastSigAddr; }
325     bool handlesSignal(long signum);
326  private:
327     BPatchSignalHandlerCallback cb;
328     BPatch_point *point;
329     long signum;
330     BPatch_Vector<Dyninst::Address> *handlers;
331     BPatch_Set<long> *signals;
332     Address lastSigAddr; // address of instruction that caused the previous signal 
333 };
334
335
336 class AsyncThreadEventCallback : public SyncCallback 
337 {  
338   public:
339    AsyncThreadEventCallback(BPatchAsyncThreadEventCallback callback) : 
340       SyncCallback(), 
341       cb(callback), proc(NULL), thr(NULL), override_to_sync(false) {}
342    AsyncThreadEventCallback(AsyncThreadEventCallback &src) : SyncCallback(),
343       cb(src.cb), proc(NULL), thr(NULL), override_to_sync(false) {}
344    ~AsyncThreadEventCallback() {}
345
346    CallbackBase *copy() { return new AsyncThreadEventCallback(*this);}
347    bool execute_real(void); 
348    bool operator()(BPatch_process *process, BPatch_thread *thread);
349    BPatchAsyncThreadEventCallback getFunc() {return cb;}
350    void set_synchronous(bool b) { override_to_sync = b; }
351   private:    
352    BPatchAsyncThreadEventCallback cb;    
353    BPatch_process *proc;
354    BPatch_thread *thr;
355    bool override_to_sync;
356 };
357
358 typedef void (*internalThreadExitCallback)(BPatch_process *, BPatch_thread *,
359                                            pdvector<AsyncThreadEventCallback *> *);
360
361 class InternalThreadExitCallback : public SyncCallback 
362 {  
363   public:
364    InternalThreadExitCallback(internalThreadExitCallback callback) : 
365       SyncCallback(), 
366       cb(callback), proc(NULL) {}
367    InternalThreadExitCallback(InternalThreadExitCallback &src) : 
368       SyncCallback(), 
369       cb(src.cb), proc(NULL), thr(NULL), cbs(NULL) {}
370    ~InternalThreadExitCallback();
371
372    CallbackBase *copy() { return new InternalThreadExitCallback(*this);}
373    bool execute_real(void); 
374    bool operator()(BPatch_process *p, BPatch_thread *t, 
375                    pdvector<AsyncThreadEventCallback *> *callbacks);
376   private:    
377    internalThreadExitCallback cb;
378    BPatch_process *proc;
379    BPatch_thread *thr;
380    pdvector<AsyncThreadEventCallback *> *cbs;
381 };
382
383 #endif