lldb/source/Plugins/Process/FreeBSD/NativeThreadFreeBSD.cpp

   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
  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
  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
  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
  69 Status NativeThreadFreeBSD::Suspend() {
  70   Status ret = NativeProcessFreeBSD::PtraceWrapper(PT_SUSPEND, GetID());
  71   if (ret.Success())
  72     SetStopped();
  73   return ret;
  74 }
  75
  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       m_stop_description = GetCrashReasonString(*info);
  94       break;
  95     }
  96   }
  97 }
  98
  99 void NativeThreadFreeBSD::SetStoppedByBreakpoint() {
 100   SetStopped();
 101   m_stop_info.reason = StopReason::eStopReasonBreakpoint;
 102   m_stop_info.signo = SIGTRAP;
 103 }
 104
 105 void NativeThreadFreeBSD::SetStoppedByTrace() {
 106   SetStopped();
 107   m_stop_info.reason = StopReason::eStopReasonTrace;
 108   m_stop_info.signo = SIGTRAP;
 109 }
 110
 111 void NativeThreadFreeBSD::SetStoppedByExec() {
 112   SetStopped();
 113   m_stop_info.reason = StopReason::eStopReasonExec;
 114   m_stop_info.signo = SIGTRAP;
 115 }
 116
 117 void NativeThreadFreeBSD::SetStoppedByWatchpoint(uint32_t wp_index) {
 118   lldbassert(wp_index != LLDB_INVALID_INDEX32 && "wp_index cannot be invalid");
 119
 120   std::ostringstream ostr;
 121   ostr << GetRegisterContext().GetWatchpointAddress(wp_index) << " ";
 122   ostr << wp_index;
 123
 124   ostr << " " << GetRegisterContext().GetWatchpointHitAddress(wp_index);
 125
 126   SetStopped();
 127   m_stop_description = ostr.str();
 128   m_stop_info.reason = StopReason::eStopReasonWatchpoint;
 129   m_stop_info.signo = SIGTRAP;
 130 }
 131
 132 void NativeThreadFreeBSD::SetStoppedByFork(lldb::pid_t child_pid,
 133                                            lldb::tid_t child_tid) {
 134   SetStopped();
 135
 136   m_stop_info.reason = StopReason::eStopReasonFork;
 137   m_stop_info.signo = SIGTRAP;
 138   m_stop_info.details.fork.child_pid = child_pid;
 139   m_stop_info.details.fork.child_tid = child_tid;
 140 }
 141
 142 void NativeThreadFreeBSD::SetStoppedByVFork(lldb::pid_t child_pid,
 143                                             lldb::tid_t child_tid) {
 144   SetStopped();
 145
 146   m_stop_info.reason = StopReason::eStopReasonVFork;
 147   m_stop_info.signo = SIGTRAP;
 148   m_stop_info.details.fork.child_pid = child_pid;
 149   m_stop_info.details.fork.child_tid = child_tid;
 150 }
 151
 152 void NativeThreadFreeBSD::SetStoppedByVForkDone() {
 153   SetStopped();
 154
 155   m_stop_info.reason = StopReason::eStopReasonVForkDone;
 156   m_stop_info.signo = SIGTRAP;
 157 }
 158
 159 void NativeThreadFreeBSD::SetStoppedWithNoReason() {
 160   SetStopped();
 161
 162   m_stop_info.reason = StopReason::eStopReasonNone;
 163   m_stop_info.signo = 0;
 164 }
 165
 166 void NativeThreadFreeBSD::SetStopped() {
 167   const StateType new_state = StateType::eStateStopped;
 168   m_state = new_state;
 169   m_stop_description.clear();
 170 }
 171
 172 void NativeThreadFreeBSD::SetRunning() {
 173   m_state = StateType::eStateRunning;
 174   m_stop_info.reason = StopReason::eStopReasonNone;
 175 }
 176
 177 void NativeThreadFreeBSD::SetStepping() {
 178   m_state = StateType::eStateStepping;
 179   m_stop_info.reason = StopReason::eStopReasonNone;
 180 }
 181
 182 std::string NativeThreadFreeBSD::GetName() {
 183   Log *log = GetLog(POSIXLog::Thread);
 184
 185   std::vector<struct kinfo_proc> kp;
 186   int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD,
 187                 static_cast<int>(GetProcess().GetID())};
 188
 189   while (1) {
 190     size_t len = kp.size() * sizeof(struct kinfo_proc);
 191     void *ptr = len == 0 ? nullptr : kp.data();
 192     int error = ::sysctl(mib, 4, ptr, &len, nullptr, 0);
 193     if (ptr == nullptr || (error != 0 && errno == ENOMEM)) {
 194       kp.resize(len / sizeof(struct kinfo_proc));
 195       continue;
 196     }
 197     if (error != 0) {
 198       len = 0;
 199       LLDB_LOG(log, "tid = {0} in state {1} failed to get thread name: {2}",
 200                GetID(), m_state, strerror(errno));
 201     }
 202     kp.resize(len / sizeof(struct kinfo_proc));
 203     break;
 204   }
 205
 206   for (auto &procinfo : kp) {
 207     if (procinfo.ki_tid == static_cast<lwpid_t>(GetID()))
 208       return procinfo.ki_tdname;
 209   }
 210
 211   return "";
 212 }
 213
 214 lldb::StateType NativeThreadFreeBSD::GetState() { return m_state; }
 215
 216 bool NativeThreadFreeBSD::GetStopReason(ThreadStopInfo &stop_info,
 217                                         std::string &description) {
 218   Log *log = GetLog(POSIXLog::Thread);
 219   description.clear();
 220
 221   switch (m_state) {
 222   case eStateStopped:
 223   case eStateCrashed:
 224   case eStateExited:
 225   case eStateSuspended:
 226   case eStateUnloaded:
 227     stop_info = m_stop_info;
 228     description = m_stop_description;
 229
 230     return true;
 231
 232   case eStateInvalid:
 233   case eStateConnected:
 234   case eStateAttaching:
 235   case eStateLaunching:
 236   case eStateRunning:
 237   case eStateStepping:
 238   case eStateDetached:
 239     LLDB_LOG(log, "tid = {0} in state {1} cannot answer stop reason", GetID(),
 240              StateAsCString(m_state));
 241     return false;
 242   }
 243   llvm_unreachable("unhandled StateType!");
 244 }
 245
 246 NativeRegisterContextFreeBSD &NativeThreadFreeBSD::GetRegisterContext() {
 247   assert(m_reg_context_up);
 248   return *m_reg_context_up;
 249 }
 250
 251 Status NativeThreadFreeBSD::SetWatchpoint(lldb::addr_t addr, size_t size,
 252                                           uint32_t watch_flags, bool hardware) {
 253   assert(m_state == eStateStopped);
 254   if (!hardware)
 255     return Status("not implemented");
 256   Status error = RemoveWatchpoint(addr);
 257   if (error.Fail())
 258     return error;
 259   uint32_t wp_index =
 260       GetRegisterContext().SetHardwareWatchpoint(addr, size, watch_flags);
 261   if (wp_index == LLDB_INVALID_INDEX32)
 262     return Status("Setting hardware watchpoint failed.");
 263   m_watchpoint_index_map.insert({addr, wp_index});
 264   return Status();
 265 }
 266
 267 Status NativeThreadFreeBSD::RemoveWatchpoint(lldb::addr_t addr) {
 268   auto wp = m_watchpoint_index_map.find(addr);
 269   if (wp == m_watchpoint_index_map.end())
 270     return Status();
 271   uint32_t wp_index = wp->second;
 272   m_watchpoint_index_map.erase(wp);
 273   if (GetRegisterContext().ClearHardwareWatchpoint(wp_index))
 274     return Status();
 275   return Status("Clearing hardware watchpoint failed.");
 276 }
 277
 278 Status NativeThreadFreeBSD::SetHardwareBreakpoint(lldb::addr_t addr,
 279                                                   size_t size) {
 280   assert(m_state == eStateStopped);
 281   Status error = RemoveHardwareBreakpoint(addr);
 282   if (error.Fail())
 283     return error;
 284
 285   uint32_t bp_index = GetRegisterContext().SetHardwareBreakpoint(addr, size);
 286
 287   if (bp_index == LLDB_INVALID_INDEX32)
 288     return Status("Setting hardware breakpoint failed.");
 289
 290   m_hw_break_index_map.insert({addr, bp_index});
 291   return Status();
 292 }
 293
 294 Status NativeThreadFreeBSD::RemoveHardwareBreakpoint(lldb::addr_t addr) {
 295   auto bp = m_hw_break_index_map.find(addr);
 296   if (bp == m_hw_break_index_map.end())
 297     return Status();
 298
 299   uint32_t bp_index = bp->second;
 300   if (GetRegisterContext().ClearHardwareBreakpoint(bp_index)) {
 301     m_hw_break_index_map.erase(bp);
 302     return Status();
 303   }
 304
 305   return Status("Clearing hardware breakpoint failed.");
 306 }
 307
 308 llvm::Error
 309 NativeThreadFreeBSD::CopyWatchpointsFrom(NativeThreadFreeBSD &source) {
 310   llvm::Error s = GetRegisterContext().CopyHardwareWatchpointsFrom(
 311       source.GetRegisterContext());
 312   if (!s) {
 313     m_watchpoint_index_map = source.m_watchpoint_index_map;
 314     m_hw_break_index_map = source.m_hw_break_index_map;
 315   }
 316   return s;
 317 }
 318
 319 llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
 320 NativeThreadFreeBSD::GetSiginfo() const {
 321   Log *log = GetLog(POSIXLog::Process);
 322
 323   struct ptrace_lwpinfo info;
 324   const auto siginfo_err = NativeProcessFreeBSD::PtraceWrapper(
 325       PT_LWPINFO, GetID(), &info, sizeof(info));
 326   if (siginfo_err.Fail()) {
 327     LLDB_LOG(log, "PT_LWPINFO failed {0}", siginfo_err);
 328     return siginfo_err.ToError();
 329   }
 330
 331   if (info.pl_event != PL_EVENT_SIGNAL)
 332     return llvm::createStringError(llvm::inconvertibleErrorCode(),
 333                                    "Thread not signaled");
 334   if (!(info.pl_flags & PL_FLAG_SI))
 335     return llvm::createStringError(llvm::inconvertibleErrorCode(),
 336                                    "No siginfo for thread");
 337
 338   return llvm::MemoryBuffer::getMemBufferCopy(
 339       llvm::StringRef(reinterpret_cast<const char *>(&info.pl_siginfo),
 340                       sizeof(info.pl_siginfo)));
 341 }