Expand SW calltree interface to allow expanding and modifying CallTree. Needed for...
[dyninst.git] / stackwalk / h / procstate.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 //TODO: isRunning(), isStopped()...
32 //TODO: Bug if trying to stop an already stopped process
33
34 #ifndef PROCSTATE_H_
35 #define PROCSTATE_H_
36
37 #include "basetypes.h"
38 #include "dyn_regs.h"
39 #include "PCProcess.h"
40
41
42 #include <vector>
43 #include <map>
44 #include <queue>
45 #include <string>
46
47 namespace Dyninst {
48 namespace Stackwalker {
49
50 class LibraryState;
51 class ThreadState;
52 class Walker;
53
54 class SW_EXPORT ProcessState {
55    friend class Walker;
56 protected:
57    Dyninst::PID pid;
58    std::string exec_path;
59    LibraryState *library_tracker;
60    Walker *walker;
61    static std::map<Dyninst::PID, ProcessState *> proc_map;
62    std::string executable_path;
63
64    ProcessState(Dyninst::PID pid_ = 0, std::string executable_path_ = std::string(""));
65    void setPid(Dyninst::PID pid_);
66 public:
67
68   //look-up Process-State by pid
69   static ProcessState* getProcessStateByPid(Dyninst::PID pid);
70
71   //Read register in thread
72   virtual bool getRegValue(Dyninst::MachRegister reg, Dyninst::THR_ID thread, Dyninst::MachRegisterVal &val) = 0;
73   
74   //Read memory in process
75   virtual bool readMem(void *dest, Dyninst::Address source, size_t size) = 0;
76
77   //Return list of available threads
78   virtual bool getThreadIds(std::vector<Dyninst::THR_ID> &threads) = 0;
79   
80   //Return the default thread
81   virtual bool getDefaultThread(Dyninst::THR_ID &default_tid) = 0;
82
83   //Return PID
84   virtual Dyninst::PID getProcessId();
85
86   //Return the size of an address in process in bytes
87   virtual unsigned getAddressWidth() = 0;
88
89   //Get Architecture, see dyn_regs.h
90   virtual Dyninst::Architecture getArchitecture() = 0;
91
92   virtual ~ProcessState();
93
94   Walker *getWalker() const;
95
96   void setLibraryTracker(LibraryState *);
97   void setDefaultLibraryTracker();
98   virtual LibraryState *getLibraryTracker();
99
100   //Allow initialization/uninitialization
101   virtual bool preStackwalk(Dyninst::THR_ID tid);
102   virtual bool postStackwalk(Dyninst::THR_ID tid);
103
104   virtual bool isFirstParty() = 0;
105
106   std::string getExecutablePath();
107 };
108
109 class ProcSelf : public ProcessState {
110  public:
111   ProcSelf(std::string exe_path = std::string(""));
112   void initialize();
113
114   virtual bool getRegValue(Dyninst::MachRegister reg, Dyninst::THR_ID thread, Dyninst::MachRegisterVal &val);
115   virtual bool readMem(void *dest, Dyninst::Address source, size_t size);
116   virtual bool getThreadIds(std::vector<Dyninst::THR_ID> &threads);
117   virtual bool getDefaultThread(Dyninst::THR_ID &default_tid);
118   virtual unsigned getAddressWidth();
119   virtual bool isFirstParty();
120   virtual Dyninst::Architecture getArchitecture();
121   virtual ~ProcSelf();
122 };
123
124 class SW_EXPORT ProcDebug : public ProcessState {
125  protected:
126    Dyninst::ProcControlAPI::Process::ptr proc;
127    ProcDebug(Dyninst::ProcControlAPI::Process::ptr p);
128
129    std::set<Dyninst::ProcControlAPI::Thread::ptr> needs_resume;
130  public:
131   
132   static ProcDebug *newProcDebug(Dyninst::PID pid, std::string executable="");
133   static ProcDebug *newProcDebug(Dyninst::ProcControlAPI::Process::ptr proc);
134   static bool newProcDebugSet(const std::vector<Dyninst::PID> &pids,
135                               std::vector<ProcDebug *> &out_set);
136   static ProcDebug *newProcDebug(std::string executable, 
137                                  const std::vector<std::string> &argv);
138   virtual ~ProcDebug();
139
140   virtual bool getRegValue(Dyninst::MachRegister reg, Dyninst::THR_ID thread, Dyninst::MachRegisterVal &val);
141   virtual bool readMem(void *dest, Dyninst::Address source, size_t size);
142   virtual bool getThreadIds(std::vector<Dyninst::THR_ID> &thrds);
143   virtual bool getDefaultThread(Dyninst::THR_ID &default_tid);
144   virtual unsigned getAddressWidth();
145
146   virtual bool preStackwalk(Dyninst::THR_ID tid);
147   virtual bool postStackwalk(Dyninst::THR_ID tid);
148
149   
150   virtual bool pause(Dyninst::THR_ID tid = NULL_THR_ID);
151   virtual bool resume(Dyninst::THR_ID tid = NULL_THR_ID);
152   virtual bool isTerminated();
153
154   virtual bool detach(bool leave_stopped = false);
155
156   Dyninst::ProcControlAPI::Process::ptr getProc();
157
158   static int getNotificationFD();
159   std::string getExecutablePath();
160
161   static bool handleDebugEvent(bool block = false);
162   virtual bool isFirstParty();
163
164   virtual Dyninst::Architecture getArchitecture();
165 };
166
167 //LibAddrPair.first = path to library, LibAddrPair.second = load address
168 typedef std::pair<std::string, Address> LibAddrPair;
169 typedef enum { library_load, library_unload } lib_change_t;
170 class LibraryState {
171  protected:
172    ProcessState *procstate;
173    std::vector<std::pair<LibAddrPair, unsigned int> > arch_libs;
174  public:
175    LibraryState(ProcessState *parent);
176    virtual bool getLibraryAtAddr(Address addr, LibAddrPair &lib) = 0;
177    virtual bool getLibraries(std::vector<LibAddrPair> &libs, bool allow_refresh = true) = 0;
178    virtual void notifyOfUpdate() = 0;
179    virtual Address getLibTrapAddress() = 0;
180    virtual bool getLibc(LibAddrPair &lc);
181    virtual bool getLibthread(LibAddrPair &lt);
182    virtual bool getAOut(LibAddrPair &ao) = 0;
183    virtual ~LibraryState();
184
185    virtual bool updateLibsArch(std::vector<std::pair<LibAddrPair, unsigned int> > &alibs);
186 };
187
188 }
189 }
190
191 #endif