LLDB mainline
NativeThreadNetBSD.cpp
Go to the documentation of this file.
1//===-- NativeThreadNetBSD.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
11
12#include "NativeProcessNetBSD.h"
13
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// clang-format on
25
26#include <sstream>
27
28// clang-format off
29#include <sys/types.h>
30#include <sys/sysctl.h>
31// clang-format on
32
33using namespace lldb;
34using namespace lldb_private;
35using namespace lldb_private::process_netbsd;
36
38 lldb::tid_t tid)
39 : NativeThreadProtocol(process, tid), m_state(StateType::eStateInvalid),
40 m_stop_info(), m_reg_context_up(
41NativeRegisterContextNetBSD::CreateHostNativeRegisterContextNetBSD(process.GetArchitecture(), *this)
42), m_stop_description() {}
43
46 nullptr, GetID());
47 if (!ret.Success())
48 return ret;
50 nullptr, GetID());
51 if (ret.Success())
52 SetRunning();
53 return ret;
54}
55
58 nullptr, GetID());
59 if (!ret.Success())
60 return ret;
62 nullptr, GetID());
63 if (ret.Success())
65 return ret;
66}
67
70 nullptr, GetID());
71 if (ret.Success())
72 SetStopped();
73 return ret;
74}
75
77 const siginfo_t *info) {
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);
95 break;
96 }
97 }
98}
99
101 SetStopped();
102 m_stop_info.reason = StopReason::eStopReasonBreakpoint;
104}
105
107 SetStopped();
108 m_stop_info.reason = StopReason::eStopReasonTrace;
110}
111
113 SetStopped();
114 m_stop_info.reason = StopReason::eStopReasonExec;
116}
117
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;
131}
132
134 lldb::tid_t child_tid) {
135 SetStopped();
136
137 m_stop_info.reason = StopReason::eStopReasonFork;
139 m_stop_info.details.fork.child_pid = child_pid;
140 m_stop_info.details.fork.child_tid = child_tid;
141}
142
144 lldb::tid_t child_tid) {
145 SetStopped();
146
147 m_stop_info.reason = StopReason::eStopReasonVFork;
149 m_stop_info.details.fork.child_pid = child_pid;
150 m_stop_info.details.fork.child_tid = child_tid;
151}
152
154 SetStopped();
155
156 m_stop_info.reason = StopReason::eStopReasonVForkDone;
158}
159
161 SetStopped();
162
163 m_stop_info.reason = StopReason::eStopReasonNone;
164 m_stop_info.signo = 0;
165}
166
168 const StateType new_state = StateType::eStateStopped;
169 m_state = new_state;
170 m_stop_description.clear();
171}
172
174 m_state = StateType::eStateRunning;
175 m_stop_info.reason = StopReason::eStopReasonNone;
176}
177
179 m_state = StateType::eStateStepping;
180 m_stop_info.reason = StopReason::eStopReasonNone;
181}
182
185
186#ifdef PT_LWPSTATUS
187 struct ptrace_lwpstatus info = {};
188 info.pl_lwpid = m_tid;
190 PT_LWPSTATUS, static_cast<int>(m_process.GetID()), &info, sizeof(info));
191 if (error.Fail()) {
192 return "";
193 }
194 return info.pl_name;
195#else
196 std::vector<struct kinfo_lwp> infos;
197 int mib[5] = {CTL_KERN, KERN_LWP, static_cast<int>(m_process.GetID()),
198 sizeof(struct kinfo_lwp), 0};
199 size_t size;
200
201 if (::sysctl(mib, 5, nullptr, &size, nullptr, 0) == -1 || size == 0) {
202 LLDB_LOG(log, "sysctl() for LWP info size failed: {0}",
203 llvm::sys::StrError());
204 return "";
205 }
206
207 mib[4] = size / sizeof(size_t);
208 infos.resize(size / sizeof(struct kinfo_lwp));
209
210 if (sysctl(mib, 5, infos.data(), &size, NULL, 0) == -1 || size == 0) {
211 LLDB_LOG(log, "sysctl() for LWP info failed: {0}", llvm::sys::StrError());
212 return "";
213 }
214
215 size_t nlwps = size / sizeof(struct kinfo_lwp);
216 for (size_t i = 0; i < nlwps; i++) {
217 if (static_cast<lldb::tid_t>(infos[i].l_lid) == m_tid) {
218 return infos[i].l_name;
219 }
220 }
221
222 LLDB_LOG(log, "unable to find lwp {0} in LWP infos", m_tid);
223 return "";
224#endif
225}
226
228
230 std::string &description) {
232 description.clear();
233
234 switch (m_state) {
235 case eStateStopped:
236 case eStateCrashed:
237 case eStateExited:
238 case eStateSuspended:
239 case eStateUnloaded:
240 stop_info = m_stop_info;
241 description = m_stop_description;
242
243 return true;
244
245 case eStateInvalid:
246 case eStateConnected:
247 case eStateAttaching:
248 case eStateLaunching:
249 case eStateRunning:
250 case eStateStepping:
251 case eStateDetached:
252 LLDB_LOG(log, "tid = {0} in state {1} cannot answer stop reason", GetID(),
254 return false;
255 }
256 llvm_unreachable("unhandled StateType!");
257}
258
260 assert(m_reg_context_up);
261 return *m_reg_context_up;
262}
263
265 uint32_t watch_flags, bool hardware) {
266 assert(m_state == eStateStopped);
267 if (!hardware)
268 return Status("not implemented");
270 if (error.Fail())
271 return error;
272 uint32_t wp_index =
273 GetRegisterContext().SetHardwareWatchpoint(addr, size, watch_flags);
274 if (wp_index == LLDB_INVALID_INDEX32)
275 return Status("Setting hardware watchpoint failed.");
276 m_watchpoint_index_map.insert({addr, wp_index});
277 return Status();
278}
279
281 auto wp = m_watchpoint_index_map.find(addr);
282 if (wp == m_watchpoint_index_map.end())
283 return Status();
284 uint32_t wp_index = wp->second;
285 m_watchpoint_index_map.erase(wp);
286 if (GetRegisterContext().ClearHardwareWatchpoint(wp_index))
287 return Status();
288 return Status("Clearing hardware watchpoint failed.");
289}
290
292 size_t size) {
293 assert(m_state == eStateStopped);
295 if (error.Fail())
296 return error;
297
298 uint32_t bp_index = GetRegisterContext().SetHardwareBreakpoint(addr, size);
299
300 if (bp_index == LLDB_INVALID_INDEX32)
301 return Status("Setting hardware breakpoint failed.");
302
303 m_hw_break_index_map.insert({addr, bp_index});
304 return Status();
305}
306
308 auto bp = m_hw_break_index_map.find(addr);
309 if (bp == m_hw_break_index_map.end())
310 return Status();
311
312 uint32_t bp_index = bp->second;
313 if (GetRegisterContext().ClearHardwareBreakpoint(bp_index)) {
314 m_hw_break_index_map.erase(bp);
315 return Status();
316 }
317
318 return Status("Clearing hardware breakpoint failed.");
319}
320
321llvm::Error
324 source.GetRegisterContext());
325 if (!s) {
328 }
329 return s;
330}
static llvm::raw_ostream & error(Stream &strm)
std::string GetCrashReasonString(CrashReason reason, const siginfo_t &info)
CrashReason GetCrashReason(const siginfo_t &info)
#define lldbassert(x)
Definition: LLDBAssert.h:15
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:337
virtual lldb::addr_t GetWatchpointAddress(uint32_t wp_index)
virtual lldb::addr_t GetWatchpointHitAddress(uint32_t wp_index)
virtual uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags)
virtual uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size)
An error handling class.
Definition: Status.h:44
bool Success() const
Test for success condition.
Definition: Status.cpp:287
Manages communication with the inferior (debugee) process.
static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr=nullptr, int data=0, int *result=nullptr)
virtual llvm::Error CopyHardwareWatchpointsFrom(NativeRegisterContextNetBSD &source)=0
void SetStoppedByFork(lldb::pid_t child_pid, lldb::tid_t child_tid)
void SetStoppedBySignal(uint32_t signo, const siginfo_t *info=nullptr)
bool GetStopReason(ThreadStopInfo &stop_info, std::string &description) override
Status SetWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags, bool hardware) override
Status RemoveHardwareBreakpoint(lldb::addr_t addr) override
std::unique_ptr< NativeRegisterContextNetBSD > m_reg_context_up
Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override
NativeRegisterContextNetBSD & GetRegisterContext() override
void SetStoppedByVFork(lldb::pid_t child_pid, lldb::tid_t child_tid)
NativeThreadNetBSD(NativeProcessNetBSD &process, lldb::tid_t tid)
Status RemoveWatchpoint(lldb::addr_t addr) override
llvm::Error CopyWatchpointsFrom(NativeThreadNetBSD &source)
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:75
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:309
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
Definition: SBAddress.h:15
StateType
Process and Thread States.
@ eStateUnloaded
Process is object is valid, but not currently loaded.
@ eStateConnected
Process is connected to remote debug services, but not launched or attached to anything yet.
@ eStateDetached
Process has been detached and can't be examined.
@ eStateStopped
Process or thread is stopped and can be examined.
@ eStateSuspended
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
@ eStateRunning
Process or thread is running and can't be examined.
@ eStateLaunching
Process is in the process of launching.
@ eStateAttaching
Process is currently trying to attach.
@ eStateExited
Process has exited and can't be examined.
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
@ eStateCrashed
Process or thread has crashed and can be examined.
uint64_t pid_t
Definition: lldb-types.h:85
uint64_t addr_t
Definition: lldb-types.h:83
uint64_t tid_t
Definition: lldb-types.h:86
lldb::StopReason reason
Definition: Debug.h:132
union lldb_private::ThreadStopInfo::@12 details
struct lldb_private::ThreadStopInfo::@12::@14 fork
#define SIGTRAP