First pass at thread_db integration for FreeBSD.
[dyninst.git] / common / src / addrtranslate-freebsd.C
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 #include "common/h/headers.h"
33 #include "common/src/addrtranslate-sysv.h"
34 #include "common/h/freebsdKludges.h"
35
36 #include <cstdio>
37
38 #include <sys/types.h>
39 #include <sys/ptrace.h>
40 #include <sys/wait.h>
41 #include <errno.h>
42 #include <unistd.h> 
43
44 using namespace Dyninst;
45
46 class ProcessReaderPtrace : public ProcessReader {
47     protected:
48         int pid;
49     public:
50         ProcessReaderPtrace(int pid_);
51         virtual bool start();
52         virtual bool ReadMem(Address inTraced, void *inSelf, unsigned amount);
53         virtual bool GetReg(MachRegister /*reg*/, MachRegisterVal &/*val*/) {
54             assert(0);
55             return false;
56         }
57         virtual bool done();
58
59         virtual ~ProcessReaderPtrace();
60 };
61
62 bool ProcessReaderPtrace::start() {
63     if( 0 != ptrace(PT_ATTACH, pid, (caddr_t)1, 0) ) {
64         translate_printf("[%s:%u] - Failed to attach to process %u: %s\n",
65                 __FILE__, __LINE__, pid, strerror(errno));
66         return false;
67     }
68
69     int status;
70     while(true) {
71         int result = (long) waitpid(pid, &status, 0);
72         if (result == -1 && errno == EINTR) {
73             continue;
74         } else if (result == -1 || WIFEXITED(status) || WIFSIGNALED(status)) {
75             translate_printf("[%s:%u] - Failed to stop process %u: %s\n",
76                     __FILE__, __LINE__, pid, strerror(errno));
77             done();
78             return false;
79         } else if (WIFSTOPPED(status) && (WSTOPSIG(status) == SIGSTOP 
80                 || WSTOPSIG(status) == SIGTRAP) ) {
81             break;
82         } else if (WIFSTOPPED(status) && WSTOPSIG(status) != SIGSTOP) {
83             if( 0 != ptrace(PT_CONTINUE, pid, (caddr_t)1, WSTOPSIG(status)) ) {
84                 translate_printf("[%s:%u] - Failed to continue process %u: %s\n"
85                         __FILE__, __LINE__, pid, strerror(errno));
86                 done();
87                 return false;
88             }
89         } else {
90             translate_printf("[%s:%u] - Unknown error encountered for process %u: %s\n",
91                     __FILE__, __LINE__, pid, strerror(errno));
92             done();
93             return false;
94         }
95     }
96
97     return true;
98 }
99
100 bool ProcessReaderPtrace::done()
101 {
102    return ( 0 != ptrace(PT_DETACH, pid, (caddr_t)1, 0) ) ? true : false;
103 }
104
105 ProcessReaderPtrace::ProcessReaderPtrace(int pid_) :
106    pid(pid_)
107 {
108 }
109
110 ProcessReaderPtrace::~ProcessReaderPtrace() 
111 {
112 }
113
114 bool ProcessReaderPtrace::ReadMem(Address inTraced, void *inSelf, unsigned amount) {
115     bool result = PtraceBulkRead(inTraced, amount, inSelf, pid);
116     if( !result ) {
117         translate_printf("[%s:%u] - Failed to read memory from process: %s\n", 
118                 __FILE__, __LINE__, strerror(errno));
119     }
120
121     return result;
122 }
123
124 /* Complete the implementation of the AddressTranslateSysV class */
125
126 ProcessReader *AddressTranslateSysV::createDefaultDebugger(int pid)
127 {
128   return new ProcessReaderPtrace(pid);
129 }
130
131
132 bool AddressTranslateSysV::setInterpreter() {
133     if( interpreter ) return true;
134
135     string l_exec = getExecName();
136     if( l_exec.empty() ) {
137         return false;
138     }
139
140     FCNode *exe = files.getNode(l_exec, symfactory);
141     if( !exe ) {
142         translate_printf("[%s:%u] - Failed to get FCNode for %s\n",
143                 __FILE__, __LINE__, l_exec.c_str());
144         return false;
145     }
146
147     if( exe->getInterpreter().empty() ) {
148         translate_printf("[%s:%u] - No interpreter found\n",
149                 __FILE__, __LINE__);
150         return true;
151     }
152
153     interpreter = files.getNode(exe->getInterpreter(), symfactory);
154     if( interpreter ) interpreter->markInterpreter();
155     else{
156         translate_printf("[%s:%u] - Failed to set interpreter for %s\n",
157                 __FILE__, __LINE__, l_exec.c_str());
158         return false;
159     }
160
161     return true;
162 }
163
164 bool AddressTranslateSysV::setAddressSize() {
165     if (address_size) return true;
166
167     if( (address_size = sysctl_computeAddrWidth(pid)) == -1 ) {
168         address_size = 0;
169         return false;
170     }
171
172     return true;
173 }
174
175 bool AddressTranslateSysV::setInterpreterBase() {
176     if( set_interp_base ) return true;
177
178     string l_exec = getExecName();
179     if( l_exec.empty() ) {
180         return false;
181     }
182
183     FCNode *exe = files.getNode(l_exec, symfactory);
184     if( !exe ) {
185         translate_printf("[%s:%u] - Failed to get FCNode for %s\n",
186                 __FILE__, __LINE__, l_exec.c_str());
187         return false;
188     }
189
190     unsigned maps_size;
191     map_entries *maps = getVMMaps(pid, maps_size);
192     if( !maps ) {
193         translate_printf("[%s:%u] - Failed to get VM maps\n",
194                 __FILE__, __LINE__);
195         return false;
196     }
197
198     string interp_name = exe->getInterpreter();
199     for(unsigned i = 0; i < maps_size; ++i) {
200         if( string(maps[i].path) == interp_name ) {
201             interpreter_base = maps[i].start;
202             set_interp_base = true;
203             break;
204         }
205     }
206     free(maps);
207
208     if( !set_interp_base ) {
209         translate_printf("[%s:%u] - Failed to get locate interpreter in memory map\n",
210                 __FILE__, __LINE__);
211         return false;
212     }
213
214     return true;
215 }
216
217 const string& AddressTranslateSysV::getExecName() {
218     if( exec_name.empty() ) {
219         char *pathname = sysctl_getExecPathname(pid);
220         if( NULL != pathname ) {
221             exec_name = std::string(pathname);
222
223             free(pathname);
224         }
225     }
226     return exec_name;
227 }
228
229 LoadedLib *AddressTranslateSysV::getAOut()
230 {
231    // TODO: shouldn't this just return exec if it's set?
232    LoadedLib *ll = new LoadedLib(getExecName(), 0);
233    ll->setFactory(symfactory);
234    return ll;
235 }