1 //===-- NativeThreadFreeBSD.cpp -------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "NativeThreadFreeBSD.h"
10 #include "NativeRegisterContextFreeBSD.h"
11
12 #include "NativeProcessFreeBSD.h"
13
14 #include "Plugins/Process/POSIX/CrashReason.h"
15 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
16 #include "lldb/Utility/LLDBAssert.h"
17 #include "lldb/Utility/RegisterValue.h"
18 #include "lldb/Utility/State.h"
19 #include "llvm/Support/Errno.h"
20
21 // clang-format off
22 #include <sys/types.h>
23 #include <sys/ptrace.h>
24 #include <sys/sysctl.h>
25 #include <sys/user.h>
26 // clang-format on
27
28 #include <sstream>
29 #include <vector>
30
31 using namespace lldb;
32 using namespace lldb_private;
33 using namespace lldb_private::process_freebsd;
34
NativeThreadFreeBSD(NativeProcessFreeBSD & process,lldb::tid_t tid)35 NativeThreadFreeBSD::NativeThreadFreeBSD(NativeProcessFreeBSD &process,
36 lldb::tid_t tid)
37 : NativeThreadProtocol(process, tid), m_state(StateType::eStateInvalid),
38 m_stop_info(),
39 m_reg_context_up(
40 NativeRegisterContextFreeBSD::CreateHostNativeRegisterContextFreeBSD(
41 process.GetArchitecture(), *this)),
42 m_stop_description() {}
43
Resume()44 Status NativeThreadFreeBSD::Resume() {
45 Status ret = NativeProcessFreeBSD::PtraceWrapper(PT_RESUME, GetID());
46 if (!ret.Success())
47 return ret;
48 ret = NativeProcessFreeBSD::PtraceWrapper(PT_CLEARSTEP, GetID());
49 // we can get EINVAL if the architecture in question does not support
50 // hardware single-stepping -- that's fine, we have nothing to clear
51 // then
52 if (ret.GetError() == EINVAL)
53 ret.Clear();
54 if (ret.Success())
55 SetRunning();
56 return ret;
57 }
58
SingleStep()59 Status NativeThreadFreeBSD::SingleStep() {
60 Status ret = NativeProcessFreeBSD::PtraceWrapper(PT_RESUME, GetID());
61 if (!ret.Success())
62 return ret;
63 ret = NativeProcessFreeBSD::PtraceWrapper(PT_SETSTEP, GetID());
64 if (ret.Success())
65 SetStepping();
66 return ret;
67 }
68
Suspend()69 Status NativeThreadFreeBSD::Suspend() {
70 Status ret = NativeProcessFreeBSD::PtraceWrapper(PT_SUSPEND, GetID());
71 if (ret.Success())
72 SetStopped();
73 return ret;
74 }
75
SetStoppedBySignal(uint32_t signo,const siginfo_t * info)76 void NativeThreadFreeBSD::SetStoppedBySignal(uint32_t signo,
77 const siginfo_t *info) {
78 Log *log = GetLog(POSIXLog::Thread);
79 LLDB_LOG(log, "tid = {0} in called with signal {1}", GetID(), signo);
80
81 SetStopped();
82
83 m_stop_info.reason = StopReason::eStopReasonSignal;
84 m_stop_info.signo = signo;
85
86 m_stop_description.clear();
87 if (info) {
88 switch (signo) {
89 case SIGSEGV:
90 case SIGBUS:
91 case SIGFPE:
92 case SIGILL:
93 const auto reason = GetCrashReason(*info);
94 m_stop_description = GetCrashReasonString(reason, *info);
95 break;
96 }
97 }
98 }
99
SetStoppedByBreakpoint()100 void NativeThreadFreeBSD::SetStoppedByBreakpoint() {
101 SetStopped();
102 m_stop_info.reason = StopReason::eStopReasonBreakpoint;
103 m_stop_info.signo = SIGTRAP;
104 }
105
SetStoppedByTrace()106 void NativeThreadFreeBSD::SetStoppedByTrace() {
107 SetStopped();
108 m_stop_info.reason = StopReason::eStopReasonTrace;
109 m_stop_info.signo = SIGTRAP;
110 }
111
SetStoppedByExec()112 void NativeThreadFreeBSD::SetStoppedByExec() {
113 SetStopped();
114 m_stop_info.reason = StopReason::eStopReasonExec;
115 m_stop_info.signo = SIGTRAP;
116 }
117
SetStoppedByWatchpoint(uint32_t wp_index)118 void NativeThreadFreeBSD::SetStoppedByWatchpoint(uint32_t wp_index) {
119 lldbassert(wp_index != LLDB_INVALID_INDEX32 && "wp_index cannot be invalid");
120
121 std::ostringstream ostr;
122 ostr << GetRegisterContext().GetWatchpointAddress(wp_index) << " ";
123 ostr << wp_index;
124
125 ostr << " " << GetRegisterContext().GetWatchpointHitAddress(wp_index);
126
127 SetStopped();
128 m_stop_description = ostr.str();
129 m_stop_info.reason = StopReason::eStopReasonWatchpoint;
130 m_stop_info.signo = SIGTRAP;
131 }
132
SetStoppedByFork(lldb::pid_t child_pid,lldb::tid_t child_tid)133 void NativeThreadFreeBSD::SetStoppedByFork(lldb::pid_t child_pid,
134 lldb::tid_t child_tid) {
135 SetStopped();
136
137 m_stop_info.reason = StopReason::eStopReasonFork;
138 m_stop_info.signo = SIGTRAP;
139 m_stop_info.details.fork.child_pid = child_pid;
140 m_stop_info.details.fork.child_tid = child_tid;
141 }
142
SetStoppedByVFork(lldb::pid_t child_pid,lldb::tid_t child_tid)143 void NativeThreadFreeBSD::SetStoppedByVFork(lldb::pid_t child_pid,
144 lldb::tid_t child_tid) {
145 SetStopped();
146
147 m_stop_info.reason = StopReason::eStopReasonVFork;
148 m_stop_info.signo = SIGTRAP;
149 m_stop_info.details.fork.child_pid = child_pid;
150 m_stop_info.details.fork.child_tid = child_tid;
151 }
152
SetStoppedByVForkDone()153 void NativeThreadFreeBSD::SetStoppedByVForkDone() {
154 SetStopped();
155
156 m_stop_info.reason = StopReason::eStopReasonVForkDone;
157 m_stop_info.signo = SIGTRAP;
158 }
159
SetStoppedWithNoReason()160 void NativeThreadFreeBSD::SetStoppedWithNoReason() {
161 SetStopped();
162
163 m_stop_info.reason = StopReason::eStopReasonNone;
164 m_stop_info.signo = 0;
165 }
166
SetStopped()167 void NativeThreadFreeBSD::SetStopped() {
168 const StateType new_state = StateType::eStateStopped;
169 m_state = new_state;
170 m_stop_description.clear();
171 }
172
SetRunning()173 void NativeThreadFreeBSD::SetRunning() {
174 m_state = StateType::eStateRunning;
175 m_stop_info.reason = StopReason::eStopReasonNone;
176 }
177
SetStepping()178 void NativeThreadFreeBSD::SetStepping() {
179 m_state = StateType::eStateStepping;
180 m_stop_info.reason = StopReason::eStopReasonNone;
181 }
182
GetName()183 std::string NativeThreadFreeBSD::GetName() {
184 Log *log = GetLog(POSIXLog::Thread);
185
186 std::vector<struct kinfo_proc> kp;
187 int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD,
188 static_cast<int>(GetProcess().GetID())};
189
190 while (1) {
191 size_t len = kp.size() * sizeof(struct kinfo_proc);
192 void *ptr = len == 0 ? nullptr : kp.data();
193 int error = ::sysctl(mib, 4, ptr, &len, nullptr, 0);
194 if (ptr == nullptr || (error != 0 && errno == ENOMEM)) {
195 kp.resize(len / sizeof(struct kinfo_proc));
196 continue;
197 }
198 if (error != 0) {
199 len = 0;
200 LLDB_LOG(log, "tid = {0} in state {1} failed to get thread name: {2}",
201 GetID(), m_state, strerror(errno));
202 }
203 kp.resize(len / sizeof(struct kinfo_proc));
204 break;
205 }
206
207 for (auto &procinfo : kp) {
208 if (procinfo.ki_tid == static_cast<lwpid_t>(GetID()))
209 return procinfo.ki_tdname;
210 }
211
212 return "";
213 }
214
GetState()215 lldb::StateType NativeThreadFreeBSD::GetState() { return m_state; }
216
GetStopReason(ThreadStopInfo & stop_info,std::string & description)217 bool NativeThreadFreeBSD::GetStopReason(ThreadStopInfo &stop_info,
218 std::string &description) {
219 Log *log = GetLog(POSIXLog::Thread);
220 description.clear();
221
222 switch (m_state) {
223 case eStateStopped:
224 case eStateCrashed:
225 case eStateExited:
226 case eStateSuspended:
227 case eStateUnloaded:
228 stop_info = m_stop_info;
229 description = m_stop_description;
230
231 return true;
232
233 case eStateInvalid:
234 case eStateConnected:
235 case eStateAttaching:
236 case eStateLaunching:
237 case eStateRunning:
238 case eStateStepping:
239 case eStateDetached:
240 LLDB_LOG(log, "tid = {0} in state {1} cannot answer stop reason", GetID(),
241 StateAsCString(m_state));
242 return false;
243 }
244 llvm_unreachable("unhandled StateType!");
245 }
246
GetRegisterContext()247 NativeRegisterContextFreeBSD &NativeThreadFreeBSD::GetRegisterContext() {
248 assert(m_reg_context_up);
249 return *m_reg_context_up;
250 }
251
SetWatchpoint(lldb::addr_t addr,size_t size,uint32_t watch_flags,bool hardware)252 Status NativeThreadFreeBSD::SetWatchpoint(lldb::addr_t addr, size_t size,
253 uint32_t watch_flags, bool hardware) {
254 assert(m_state == eStateStopped);
255 if (!hardware)
256 return Status("not implemented");
257 Status error = RemoveWatchpoint(addr);
258 if (error.Fail())
259 return error;
260 uint32_t wp_index =
261 GetRegisterContext().SetHardwareWatchpoint(addr, size, watch_flags);
262 if (wp_index == LLDB_INVALID_INDEX32)
263 return Status("Setting hardware watchpoint failed.");
264 m_watchpoint_index_map.insert({addr, wp_index});
265 return Status();
266 }
267
RemoveWatchpoint(lldb::addr_t addr)268 Status NativeThreadFreeBSD::RemoveWatchpoint(lldb::addr_t addr) {
269 auto wp = m_watchpoint_index_map.find(addr);
270 if (wp == m_watchpoint_index_map.end())
271 return Status();
272 uint32_t wp_index = wp->second;
273 m_watchpoint_index_map.erase(wp);
274 if (GetRegisterContext().ClearHardwareWatchpoint(wp_index))
275 return Status();
276 return Status("Clearing hardware watchpoint failed.");
277 }
278
SetHardwareBreakpoint(lldb::addr_t addr,size_t size)279 Status NativeThreadFreeBSD::SetHardwareBreakpoint(lldb::addr_t addr,
280 size_t size) {
281 assert(m_state == eStateStopped);
282 Status error = RemoveHardwareBreakpoint(addr);
283 if (error.Fail())
284 return error;
285
286 uint32_t bp_index = GetRegisterContext().SetHardwareBreakpoint(addr, size);
287
288 if (bp_index == LLDB_INVALID_INDEX32)
289 return Status("Setting hardware breakpoint failed.");
290
291 m_hw_break_index_map.insert({addr, bp_index});
292 return Status();
293 }
294
RemoveHardwareBreakpoint(lldb::addr_t addr)295 Status NativeThreadFreeBSD::RemoveHardwareBreakpoint(lldb::addr_t addr) {
296 auto bp = m_hw_break_index_map.find(addr);
297 if (bp == m_hw_break_index_map.end())
298 return Status();
299
300 uint32_t bp_index = bp->second;
301 if (GetRegisterContext().ClearHardwareBreakpoint(bp_index)) {
302 m_hw_break_index_map.erase(bp);
303 return Status();
304 }
305
306 return Status("Clearing hardware breakpoint failed.");
307 }
308
309 llvm::Error
CopyWatchpointsFrom(NativeThreadFreeBSD & source)310 NativeThreadFreeBSD::CopyWatchpointsFrom(NativeThreadFreeBSD &source) {
311 llvm::Error s = GetRegisterContext().CopyHardwareWatchpointsFrom(
312 source.GetRegisterContext());
313 if (!s) {
314 m_watchpoint_index_map = source.m_watchpoint_index_map;
315 m_hw_break_index_map = source.m_hw_break_index_map;
316 }
317 return s;
318 }
319
320 llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
GetSiginfo() const321 NativeThreadFreeBSD::GetSiginfo() const {
322 Log *log = GetLog(POSIXLog::Process);
323
324 struct ptrace_lwpinfo info;
325 const auto siginfo_err = NativeProcessFreeBSD::PtraceWrapper(
326 PT_LWPINFO, GetID(), &info, sizeof(info));
327 if (siginfo_err.Fail()) {
328 LLDB_LOG(log, "PT_LWPINFO failed {0}", siginfo_err);
329 return siginfo_err.ToError();
330 }
331
332 if (info.pl_event != PL_EVENT_SIGNAL)
333 return llvm::createStringError(llvm::inconvertibleErrorCode(),
334 "Thread not signaled");
335 if (!(info.pl_flags & PL_FLAG_SI))
336 return llvm::createStringError(llvm::inconvertibleErrorCode(),
337 "No siginfo for thread");
338
339 return llvm::MemoryBuffer::getMemBufferCopy(
340 llvm::StringRef(reinterpret_cast<const char *>(&info.pl_siginfo),
341 sizeof(info.pl_siginfo)));
342 }
343