Build fix for AIX
[dyninst.git] / proccontrol / src / int_thread_db.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 #if !defined(INT_THREAD_DB_H_)
32 #define INT_THREAD_DB_H
33
34 #include "proccontrol/h/Generator.h"
35 #include "proccontrol/h/Event.h"
36 #include "proccontrol/h/Decoder.h"
37 #include "proccontrol/h/Handler.h"
38 #include "proccontrol/src/int_process.h"
39 #include "proccontrol/src/sysv.h"
40 #include "proccontrol/src/int_handler.h"
41
42 #include <thread_db.h>
43 #include <proc_service.h>
44
45 #include <map>
46 using std::map;
47 using std::pair;
48
49 #include <vector>
50 using std::vector;
51
52 #include <string>
53 using std::string;
54
55 using namespace Dyninst;
56 using namespace ProcControlAPI;
57
58 class thread_db_thread;
59
60 class thread_db_process : virtual public int_process
61 {
62 public:
63     thread_db_process(Dyninst::PID p, std::string e, std::vector<std::string> a, std::map<int, int> f);
64     thread_db_process(Dyninst::PID pid_, int_process *p);
65     virtual ~thread_db_process();
66
67     bool getEventsAtAddr(Dyninst::Address addr, thread_db_thread *eventThread,
68             vector<Event::ptr> &threadEvents);
69
70     /* helper functions for thread_db interactions */
71
72     td_thragent_t *getThreadDBAgent();
73     ps_err_e getSymbolAddr(const char *objName, const char *symName, 
74             psaddr_t *symbolAddr);
75     virtual bool initThreadDB();
76     virtual void freeThreadDBAgent();
77     virtual bool getPostDestroyEvents(vector<Event::ptr> &events);
78     static void addThreadDBHandlers(HandlerPool *hpool);
79
80     /*
81      * When creating a static executable or attaching to a new process,
82      * thread_db initialization needs to occur immediately after
83      * attach or create.
84      *
85      * When creating dynamic executables, initialization needs to happen
86      * when the thread library is loaded.
87      */
88     virtual bool post_attach();
89     virtual bool post_create();
90
91     virtual bool plat_readProcMem(void *local,
92             Dyninst::Address remote, size_t size) = 0;
93     virtual bool plat_writeProcMem(void *local,
94             Dyninst::Address remote, size_t size) = 0;
95     virtual bool plat_getLWPInfo(lwpid_t lwp, void *lwpInfo) = 0;
96     virtual bool plat_contThread(lwpid_t lwp) = 0;
97     virtual bool plat_stopThread(lwpid_t lwp) = 0;
98     virtual string getThreadLibName(const char *symName) = 0;
99     virtual bool isSupportedThreadLib(const string &libName) = 0;
100
101 protected:
102     static volatile bool thread_db_initialized;
103     static Mutex thread_db_init_lock;
104
105     map<Dyninst::Address, pair<int_breakpoint *, EventType> > addr2Event;
106     td_thragent_t *threadAgent;
107
108     struct ps_prochandle *self;
109 };
110
111 /*
112  * libthread_db defines this as opaque. We need to implement it.
113  */
114 struct ps_prochandle {
115     thread_db_process *thread_db_proc;
116 };
117
118 class thread_db_thread : public int_thread
119 {
120 public:
121     thread_db_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l);
122
123     thread_db_thread();
124     virtual ~thread_db_thread();
125
126     Event::ptr getThreadEvent();
127     bool setEventReporting(bool on);
128
129     bool plat_resume();
130     bool plat_suspend();
131     void markDestroyed();
132     bool isDestroyed();
133
134 protected:
135     // Initialization of the thread handle cannot be performed until 
136     // thread_db is loaded and initialized. When creating a process,
137     // we need to be able to create an instance of thread_db_thread
138     // before thread_db is initialized so we lazily initialize the
139     // thread handle
140     bool initThreadHandle();
141
142     td_thrhandle_t *threadHandle;
143
144     // Since a thread destroy event happens at a breakpoint, the 
145     // breakpoint needs to be cleaned up before the thread can be 
146     // removed from the threadPool and deleted.
147     bool destroyed;
148 };
149
150 class ThreadDBCreateHandler : public Handler
151 {
152 public:
153     ThreadDBCreateHandler();
154     virtual ~ThreadDBCreateHandler();
155     virtual Handler::handler_ret_t handleEvent(Event::ptr ev);
156     virtual int getPriority() const;
157     void getEventTypesHandled(vector<EventType> &etypes);
158 };
159
160 class ThreadDBLibHandler : public Handler
161 {
162 public:
163     ThreadDBLibHandler();
164     virtual ~ThreadDBLibHandler();
165     virtual Handler::handler_ret_t handleEvent(Event::ptr ev);
166     virtual int getPriority() const;
167     void getEventTypesHandled(std::vector<EventType> &etypes);
168 };
169
170 class ThreadDBDestroyHandler : public Handler
171 {
172 public:
173     ThreadDBDestroyHandler();
174     virtual ~ThreadDBDestroyHandler();
175     virtual Handler::handler_ret_t handleEvent(Event::ptr ev);
176     virtual int getPriority() const;
177     void getEventTypesHandled(std::vector<EventType> &etypes);
178 };
179
180 #endif