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 
9 #include "NativeThreadNetBSD.h"
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 
33 using namespace lldb;
34 using namespace lldb_private;
35 using namespace lldb_private::process_netbsd;
36 
37 NativeThreadNetBSD::NativeThreadNetBSD(NativeProcessNetBSD &process,
38  lldb::tid_t tid)
39  : NativeThreadProtocol(process, tid), m_state(StateType::eStateInvalid),
40  m_stop_info(), m_reg_context_up(
41 NativeRegisterContextNetBSD::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())
64  SetStepping();
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 
84  m_stop_info.details.signal.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();
104 }
105 
107  SetStopped();
110 }
111 
113  SetStopped();
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();
131 }
132 
134  lldb::tid_t child_tid) {
135  SetStopped();
136 
138  m_stop_info.details.fork.child_pid = child_pid;
139  m_stop_info.details.fork.child_tid = child_tid;
140 }
141 
143  lldb::tid_t child_tid) {
144  SetStopped();
145 
147  m_stop_info.details.fork.child_pid = child_pid;
148  m_stop_info.details.fork.child_tid = child_tid;
149 }
150 
152  SetStopped();
153 
155 }
156 
158  SetStopped();
159 
161  m_stop_info.details.signal.signo = 0;
162 }
163 
165  const StateType new_state = StateType::eStateStopped;
166  m_state = new_state;
167  m_stop_description.clear();
168 }
169 
173 }
174 
178 }
179 
182 
183 #ifdef PT_LWPSTATUS
184  struct ptrace_lwpstatus info = {};
185  info.pl_lwpid = m_tid;
187  PT_LWPSTATUS, static_cast<int>(m_process.GetID()), &info, sizeof(info));
188  if (error.Fail()) {
189  return "";
190  }
191  return info.pl_name;
192 #else
193  std::vector<struct kinfo_lwp> infos;
194  int mib[5] = {CTL_KERN, KERN_LWP, static_cast<int>(m_process.GetID()),
195  sizeof(struct kinfo_lwp), 0};
196  size_t size;
197 
198  if (::sysctl(mib, 5, nullptr, &size, nullptr, 0) == -1 || size == 0) {
199  LLDB_LOG(log, "sysctl() for LWP info size failed: {0}",
200  llvm::sys::StrError());
201  return "";
202  }
203 
204  mib[4] = size / sizeof(size_t);
205  infos.resize(size / sizeof(struct kinfo_lwp));
206 
207  if (sysctl(mib, 5, infos.data(), &size, NULL, 0) == -1 || size == 0) {
208  LLDB_LOG(log, "sysctl() for LWP info failed: {0}", llvm::sys::StrError());
209  return "";
210  }
211 
212  size_t nlwps = size / sizeof(struct kinfo_lwp);
213  for (size_t i = 0; i < nlwps; i++) {
214  if (static_cast<lldb::tid_t>(infos[i].l_lid) == m_tid) {
215  return infos[i].l_name;
216  }
217  }
218 
219  LLDB_LOG(log, "unable to find lwp {0} in LWP infos", m_tid);
220  return "";
221 #endif
222 }
223 
225 
227  std::string &description) {
229  description.clear();
230 
231  switch (m_state) {
232  case eStateStopped:
233  case eStateCrashed:
234  case eStateExited:
235  case eStateSuspended:
236  case eStateUnloaded:
237  stop_info = m_stop_info;
238  description = m_stop_description;
239 
240  return true;
241 
242  case eStateInvalid:
243  case eStateConnected:
244  case eStateAttaching:
245  case eStateLaunching:
246  case eStateRunning:
247  case eStateStepping:
248  case eStateDetached:
249  LLDB_LOG(log, "tid = {0} in state {1} cannot answer stop reason", GetID(),
251  return false;
252  }
253  llvm_unreachable("unhandled StateType!");
254 }
255 
257  assert(m_reg_context_up);
258  return *m_reg_context_up;
259 }
260 
262  uint32_t watch_flags, bool hardware) {
263  assert(m_state == eStateStopped);
264  if (!hardware)
265  return Status("not implemented");
266  Status error = RemoveWatchpoint(addr);
267  if (error.Fail())
268  return error;
269  uint32_t wp_index =
270  GetRegisterContext().SetHardwareWatchpoint(addr, size, watch_flags);
271  if (wp_index == LLDB_INVALID_INDEX32)
272  return Status("Setting hardware watchpoint failed.");
273  m_watchpoint_index_map.insert({addr, wp_index});
274  return Status();
275 }
276 
278  auto wp = m_watchpoint_index_map.find(addr);
279  if (wp == m_watchpoint_index_map.end())
280  return Status();
281  uint32_t wp_index = wp->second;
282  m_watchpoint_index_map.erase(wp);
283  if (GetRegisterContext().ClearHardwareWatchpoint(wp_index))
284  return Status();
285  return Status("Clearing hardware watchpoint failed.");
286 }
287 
289  size_t size) {
290  assert(m_state == eStateStopped);
292  if (error.Fail())
293  return error;
294 
295  uint32_t bp_index = GetRegisterContext().SetHardwareBreakpoint(addr, size);
296 
297  if (bp_index == LLDB_INVALID_INDEX32)
298  return Status("Setting hardware breakpoint failed.");
299 
300  m_hw_break_index_map.insert({addr, bp_index});
301  return Status();
302 }
303 
305  auto bp = m_hw_break_index_map.find(addr);
306  if (bp == m_hw_break_index_map.end())
307  return Status();
308 
309  uint32_t bp_index = bp->second;
310  if (GetRegisterContext().ClearHardwareBreakpoint(bp_index)) {
311  m_hw_break_index_map.erase(bp);
312  return Status();
313  }
314 
315  return Status("Clearing hardware breakpoint failed.");
316 }
317 
321  source.GetRegisterContext());
322  if (!s) {
325  }
326  return s;
327 }
lldb_private::process_netbsd::NativeThreadNetBSD::SetStoppedByVFork
void SetStoppedByVFork(lldb::pid_t child_pid, lldb::tid_t child_tid)
Definition: NativeThreadNetBSD.cpp:142
POSIX_LOG_THREAD
#define POSIX_LOG_THREAD
Definition: ProcessPOSIXLog.h:17
lldb_private::NativeThreadProtocol
Definition: NativeThreadProtocol.h:20
lldb::eStopReasonVFork
@ eStopReasonVFork
Definition: lldb-enumerations.h:253
lldb_private::process_netbsd::NativeThreadNetBSD::RemoveHardwareBreakpoint
Status RemoveHardwareBreakpoint(lldb::addr_t addr) override
Definition: NativeThreadNetBSD.cpp:304
lldb_private::NativeRegisterContext::SetHardwareBreakpoint
virtual uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size)
Definition: NativeRegisterContext.cpp:250
lldb_private::process_netbsd::NativeThreadNetBSD::SetRunning
void SetRunning()
Definition: NativeThreadNetBSD.cpp:170
lldb::eStateAttaching
@ eStateAttaching
Process is currently trying to attach.
Definition: lldb-enumerations.h:78
lldb_private::process_netbsd::NativeThreadNetBSD::SetStepping
void SetStepping()
Definition: NativeThreadNetBSD.cpp:175
lldb_private::process_netbsd::NativeThreadNetBSD::GetStopReason
bool GetStopReason(ThreadStopInfo &stop_info, std::string &description) override
Definition: NativeThreadNetBSD.cpp:226
lldb_private::StateAsCString
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
lldb_private::ThreadStopInfo::details
union lldb_private::ThreadStopInfo::@13 details
lldb_private::process_netbsd::NativeThreadNetBSD::SetStoppedByWatchpoint
void SetStoppedByWatchpoint(uint32_t wp_index)
Definition: NativeThreadNetBSD.cpp:118
RegisterValue.h
lldb_private::process_netbsd::NativeRegisterContextNetBSD::CopyHardwareWatchpointsFrom
virtual llvm::Error CopyHardwareWatchpointsFrom(NativeRegisterContextNetBSD &source)=0
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::process_netbsd::NativeThreadNetBSD::RemoveWatchpoint
Status RemoveWatchpoint(lldb::addr_t addr) override
Definition: NativeThreadNetBSD.cpp:277
lldb::eStopReasonTrace
@ eStopReasonTrace
Definition: lldb-enumerations.h:242
lldb_private::process_netbsd::NativeProcessNetBSD
Definition: NativeProcessNetBSD.h:28
lldb_private::process_netbsd::NativeThreadNetBSD::m_hw_break_index_map
WatchpointIndexMap m_hw_break_index_map
Definition: NativeThreadNetBSD.h:79
lldb_private::process_netbsd::NativeThreadNetBSD::SetStoppedByFork
void SetStoppedByFork(lldb::pid_t child_pid, lldb::tid_t child_tid)
Definition: NativeThreadNetBSD.cpp:133
lldb::eStateExited
@ eStateExited
Process has exited and can't be examined.
Definition: lldb-enumerations.h:90
lldb_private::process_netbsd::NativeThreadNetBSD::GetRegisterContext
NativeRegisterContextNetBSD & GetRegisterContext() override
Definition: NativeThreadNetBSD.cpp:256
lldb::eStateStopped
@ eStateStopped
Process or thread is stopped and can be examined.
Definition: lldb-enumerations.h:84
lldb_private::process_netbsd::NativeThreadNetBSD::SetStoppedByTrace
void SetStoppedByTrace()
Definition: NativeThreadNetBSD.cpp:106
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::Status::Success
bool Success() const
Test for success condition.
Definition: Status.cpp:288
lldb::eStateCrashed
@ eStateCrashed
Process or thread has crashed and can be examined.
Definition: lldb-enumerations.h:88
LLDBAssert.h
lldb_private::NativeRegisterContext::GetWatchpointHitAddress
virtual lldb::addr_t GetWatchpointHitAddress(uint32_t wp_index)
Definition: NativeRegisterContext.cpp:310
lldb_private::process_netbsd::NativeThreadNetBSD::CopyWatchpointsFrom
llvm::Error CopyWatchpointsFrom(NativeThreadNetBSD &source)
Definition: NativeThreadNetBSD.cpp:319
lldb::eStopReasonWatchpoint
@ eStopReasonWatchpoint
Definition: lldb-enumerations.h:244
lldb::eStopReasonNone
@ eStopReasonNone
Definition: lldb-enumerations.h:241
lldb::eStateConnected
@ eStateConnected
Process is connected to remote debug services, but not launched or attached to anything yet.
Definition: lldb-enumerations.h:76
lldb_private::process_netbsd::NativeThreadNetBSD::SetWatchpoint
Status SetWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags, bool hardware) override
Definition: NativeThreadNetBSD.cpp:261
NativeRegisterContextNetBSD.h
lldb_private::process_netbsd::NativeThreadNetBSD::SetStoppedByVForkDone
void SetStoppedByVForkDone()
Definition: NativeThreadNetBSD.cpp:151
SIGTRAP
#define SIGTRAP
Definition: windows/PosixApi.h:30
lldb::eStateLaunching
@ eStateLaunching
Process is in the process of launching.
Definition: lldb-enumerations.h:79
NativeThreadNetBSD.h
lldb_private::process_netbsd::NativeThreadNetBSD::SetHardwareBreakpoint
Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override
Definition: NativeThreadNetBSD.cpp:288
lldb_private::ThreadStopInfo::reason
lldb::StopReason reason
Definition: Debug.h:134
lldb_private::NativeProcessProtocol::GetID
lldb::pid_t GetID() const
Definition: NativeProcessProtocol.h:172
lldb_private::process_netbsd::NativeThreadNetBSD::m_stop_description
std::string m_stop_description
Definition: NativeThreadNetBSD.h:76
lldb_private::process_netbsd::NativeRegisterContextNetBSD
Definition: NativeRegisterContextNetBSD.h:21
ProcessPOSIXLog.h
lldb::eStateDetached
@ eStateDetached
Process has been detached and can't be examined.
Definition: lldb-enumerations.h:89
lldb_private::process_netbsd::NativeThreadNetBSD::SingleStep
Status SingleStep()
Definition: NativeThreadNetBSD.cpp:56
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::ThreadStopInfo::signal
struct lldb_private::ThreadStopInfo::@13::@14 signal
lldb_private::process_netbsd
Definition: NativeProcessNetBSD.h:20
lldb::eStateUnloaded
@ eStateUnloaded
Process is object is valid, but not currently loaded.
Definition: lldb-enumerations.h:75
lldb_private::process_netbsd::NativeThreadNetBSD::Resume
Status Resume()
Definition: NativeThreadNetBSD.cpp:44
lldb_private::ThreadStopInfo
Definition: Debug.h:133
lldb_private::process_netbsd::NativeThreadNetBSD::m_reg_context_up
std::unique_ptr< NativeRegisterContextNetBSD > m_reg_context_up
Definition: NativeThreadNetBSD.h:75
lldb_private::process_netbsd::NativeThreadNetBSD
Definition: NativeThreadNetBSD.h:25
lldb_private::process_netbsd::NativeThreadNetBSD::m_watchpoint_index_map
WatchpointIndexMap m_watchpoint_index_map
Definition: NativeThreadNetBSD.h:78
lldb_private::process_netbsd::NativeThreadNetBSD::SetStopped
void SetStopped()
Definition: NativeThreadNetBSD.cpp:164
lldb::eStateStepping
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
Definition: lldb-enumerations.h:86
lldbassert
#define lldbassert(x)
Definition: LLDBAssert.h:15
lldb::eStateSuspended
@ eStateSuspended
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
Definition: lldb-enumerations.h:91
lldb::eStopReasonSignal
@ eStopReasonSignal
Definition: lldb-enumerations.h:245
GetCrashReasonString
std::string GetCrashReasonString(CrashReason reason, const siginfo_t &info)
Definition: CrashReason.cpp:144
lldb::eStopReasonExec
@ eStopReasonExec
Program was re-exec'ed.
Definition: lldb-enumerations.h:247
lldb_private::Status
Definition: Status.h:44
uint32_t
lldb_private::process_netbsd::NativeThreadNetBSD::Suspend
Status Suspend()
Definition: NativeThreadNetBSD.cpp:68
lldb_private::process_netbsd::NativeThreadNetBSD::SetStoppedWithNoReason
void SetStoppedWithNoReason()
Definition: NativeThreadNetBSD.cpp:157
lldb::pid_t
uint64_t pid_t
Definition: lldb-types.h:85
lldb_private::process_netbsd::NativeThreadNetBSD::SetStoppedBySignal
void SetStoppedBySignal(uint32_t signo, const siginfo_t *info=nullptr)
Definition: NativeThreadNetBSD.cpp:76
lldb_private::NativeThreadProtocol::GetID
lldb::tid_t GetID() const
Definition: NativeThreadProtocol.h:35
lldb_private::process_netbsd::NativeThreadNetBSD::GetState
lldb::StateType GetState() override
Definition: NativeThreadNetBSD.cpp:224
lldb_private::process_netbsd::NativeThreadNetBSD::m_stop_info
ThreadStopInfo m_stop_info
Definition: NativeThreadNetBSD.h:74
lldb_private::process_netbsd::NativeThreadNetBSD::m_state
lldb::StateType m_state
Definition: NativeThreadNetBSD.h:73
lldb::eStopReasonBreakpoint
@ eStopReasonBreakpoint
Definition: lldb-enumerations.h:243
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:242
lldb_private::ThreadStopInfo::fork
struct lldb_private::ThreadStopInfo::@13::@16 fork
lldb_private::process_netbsd::NativeProcessNetBSD::PtraceWrapper
static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr=nullptr, int data=0, int *result=nullptr)
Definition: NativeProcessNetBSD.cpp:384
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
Error
llvm::Error Error
Definition: UdtRecordCompleter.cpp:29
lldb_private::NativeThreadProtocol::m_process
NativeProcessProtocol & m_process
Definition: NativeThreadProtocol.h:51
lldb_private::process_netbsd::NativeThreadNetBSD::SetStoppedByBreakpoint
void SetStoppedByBreakpoint()
Definition: NativeThreadNetBSD.cpp:100
lldb::eStateInvalid
@ eStateInvalid
Definition: lldb-enumerations.h:74
State.h
lldb_private::process_netbsd::NativeThreadNetBSD::SetStoppedByExec
void SetStoppedByExec()
Definition: NativeThreadNetBSD.cpp:112
LLDB_INVALID_INDEX32
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:87
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:73
lldb_private::Log
Definition: Log.h:49
lldb_private::ProcessPOSIXLog::GetLogIfAllCategoriesSet
static Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: ProcessPOSIXLog.h:33
NativeProcessNetBSD.h
lldb_private::NativeRegisterContext::SetHardwareWatchpoint
virtual uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags)
Definition: NativeRegisterContext.cpp:271
lldb::eStopReasonVForkDone
@ eStopReasonVForkDone
Definition: lldb-enumerations.h:254
lldb
Definition: SBAddress.h:15
lldb::eStateRunning
@ eStateRunning
Process or thread is running and can't be examined.
Definition: lldb-enumerations.h:85
lldb::eStopReasonFork
@ eStopReasonFork
Definition: lldb-enumerations.h:252
lldb_private::NativeRegisterContext::GetWatchpointAddress
virtual lldb::addr_t GetWatchpointAddress(uint32_t wp_index)
Definition: NativeRegisterContext.cpp:306
lldb::tid_t
uint64_t tid_t
Definition: lldb-types.h:86
CrashReason.h
lldb_private::NativeThreadProtocol::m_tid
lldb::tid_t m_tid
Definition: NativeThreadProtocol.h:52
lldb_private::process_netbsd::NativeThreadNetBSD::GetName
std::string GetName() override
Definition: NativeThreadNetBSD.cpp:180
GetCrashReason
CrashReason GetCrashReason(const siginfo_t &info)
Definition: CrashReason.cpp:341