source/Plugins/Process/Linux/NativeThreadLinux.cpp

   1 //===-- NativeThreadLinux.cpp --------------------------------- -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "NativeThreadLinux.h"
  11
  12 #include <signal.h>
  13 #include <sstream>
  14
  15 #include "NativeProcessLinux.h"
  16 #include "NativeRegisterContextLinux.h"
  17 #include "SingleStepCheck.h"
  18
  19 #include "lldb/Core/Log.h"
  20 #include "lldb/Core/State.h"
  21 #include "lldb/Host/HostNativeThread.h"
  22 #include "lldb/Host/linux/Ptrace.h"
  23 #include "lldb/Utility/LLDBAssert.h"
  24 #include "lldb/lldb-enumerations.h"
  25
  26 #include "llvm/ADT/SmallString.h"
  27
  28 #include "Plugins/Process/POSIX/CrashReason.h"
  29
  30 #include <sys/syscall.h>
  31 // Try to define a macro to encapsulate the tgkill syscall
  32 #define tgkill(pid, tid, sig) \
  33     syscall(SYS_tgkill, static_cast< ::pid_t>(pid), static_cast< ::pid_t>(tid), sig)
  34
  35 using namespace lldb;
  36 using namespace lldb_private;
  37 using namespace lldb_private::process_linux;
  38
  39 namespace
  40 {
  41     void LogThreadStopInfo (Log &log, const ThreadStopInfo &stop_info, const char *const header)
  42     {
  43         switch (stop_info.reason)
  44         {
  45             case eStopReasonNone:
  46                 log.Printf ("%s: %s no stop reason", __FUNCTION__, header);
  47                 return;
  48             case eStopReasonTrace:
  49                 log.Printf ("%s: %s trace, stopping signal 0x%" PRIx32, __FUNCTION__, header, stop_info.details.signal.signo);
  50                 return;
  51             case eStopReasonBreakpoint:
  52                 log.Printf ("%s: %s breakpoint, stopping signal 0x%" PRIx32, __FUNCTION__, header, stop_info.details.signal.signo);
  53                 return;
  54             case eStopReasonWatchpoint:
  55                 log.Printf ("%s: %s watchpoint, stopping signal 0x%" PRIx32, __FUNCTION__, header, stop_info.details.signal.signo);
  56                 return;
  57             case eStopReasonSignal:
  58                 log.Printf ("%s: %s signal 0x%02" PRIx32, __FUNCTION__, header, stop_info.details.signal.signo);
  59                 return;
  60             case eStopReasonException:
  61                 log.Printf ("%s: %s exception type 0x%02" PRIx64, __FUNCTION__, header, stop_info.details.exception.type);
  62                 return;
  63             case eStopReasonExec:
  64                 log.Printf ("%s: %s exec, stopping signal 0x%" PRIx32, __FUNCTION__, header, stop_info.details.signal.signo);
  65                 return;
  66             case eStopReasonPlanComplete:
  67                 log.Printf ("%s: %s plan complete", __FUNCTION__, header);
  68                 return;
  69             case eStopReasonThreadExiting:
  70                 log.Printf ("%s: %s thread exiting", __FUNCTION__, header);
  71                 return;
  72             case eStopReasonInstrumentation:
  73                 log.Printf ("%s: %s instrumentation", __FUNCTION__, header);
  74                 return;
  75             default:
  76                 log.Printf ("%s: %s invalid stop reason %" PRIu32, __FUNCTION__, header, static_cast<uint32_t> (stop_info.reason));
  77         }
  78     }
  79 }
  80
  81 NativeThreadLinux::NativeThreadLinux (NativeProcessLinux *process, lldb::tid_t tid) :
  82     NativeThreadProtocol (process, tid),
  83     m_state (StateType::eStateInvalid),
  84     m_stop_info (),
  85     m_reg_context_sp (),
  86     m_stop_description ()
  87 {
  88 }
  89
  90 std::string
  91 NativeThreadLinux::GetName()
  92 {
  93     NativeProcessProtocolSP process_sp = m_process_wp.lock ();
  94     if (!process_sp)
  95         return "<unknown: no process>";
  96
  97     // const NativeProcessLinux *const process = reinterpret_cast<NativeProcessLinux*> (process_sp->get ());
  98     llvm::SmallString<32> thread_name;
  99     HostNativeThread::GetName(GetID(), thread_name);
 100     return thread_name.c_str();
 101 }
 102
 103 lldb::StateType
 104 NativeThreadLinux::GetState ()
 105 {
 106     return m_state;
 107 }
 108
 109
 110 bool
 111 NativeThreadLinux::GetStopReason (ThreadStopInfo &stop_info, std::string& description)
 112 {
 113     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
 114
 115     description.clear();
 116
 117     switch (m_state)
 118     {
 119     case eStateStopped:
 120     case eStateCrashed:
 121     case eStateExited:
 122     case eStateSuspended:
 123     case eStateUnloaded:
 124         if (log)
 125             LogThreadStopInfo (*log, m_stop_info, "m_stop_info in thread:");
 126         stop_info = m_stop_info;
 127         description = m_stop_description;
 128         if (log)
 129             LogThreadStopInfo (*log, stop_info, "returned stop_info:");
 130
 131         return true;
 132
 133     case eStateInvalid:
 134     case eStateConnected:
 135     case eStateAttaching:
 136     case eStateLaunching:
 137     case eStateRunning:
 138     case eStateStepping:
 139     case eStateDetached:
 140         if (log)
 141         {
 142             log->Printf ("NativeThreadLinux::%s tid %" PRIu64 " in state %s cannot answer stop reason",
 143                     __FUNCTION__, GetID (), StateAsCString (m_state));
 144         }
 145         return false;
 146     }
 147     llvm_unreachable("unhandled StateType!");
 148 }
 149
 150 NativeRegisterContextSP
 151 NativeThreadLinux::GetRegisterContext ()
 152 {
 153     // Return the register context if we already created it.
 154     if (m_reg_context_sp)
 155         return m_reg_context_sp;
 156
 157     NativeProcessProtocolSP m_process_sp = m_process_wp.lock ();
 158     if (!m_process_sp)
 159         return NativeRegisterContextSP ();
 160
 161     ArchSpec target_arch;
 162     if (!m_process_sp->GetArchitecture (target_arch))
 163         return NativeRegisterContextSP ();
 164
 165     const uint32_t concrete_frame_idx = 0;
 166     m_reg_context_sp.reset (NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(target_arch,
 167                                                                                              *this,
 168                                                                                              concrete_frame_idx));
 169
 170     return m_reg_context_sp;
 171 }
 172
 173 Error
 174 NativeThreadLinux::SetWatchpoint (lldb::addr_t addr, size_t size, uint32_t watch_flags, bool hardware)
 175 {
 176     if (!hardware)
 177         return Error ("not implemented");
 178     if (m_state == eStateLaunching)
 179         return Error ();
 180     Error error = RemoveWatchpoint(addr);
 181     if (error.Fail()) return error;
 182     NativeRegisterContextSP reg_ctx = GetRegisterContext ();
 183     uint32_t wp_index =
 184         reg_ctx->SetHardwareWatchpoint (addr, size, watch_flags);
 185     if (wp_index == LLDB_INVALID_INDEX32)
 186         return Error ("Setting hardware watchpoint failed.");
 187     m_watchpoint_index_map.insert({addr, wp_index});
 188     return Error ();
 189 }
 190
 191 Error
 192 NativeThreadLinux::RemoveWatchpoint (lldb::addr_t addr)
 193 {
 194     auto wp = m_watchpoint_index_map.find(addr);
 195     if (wp == m_watchpoint_index_map.end())
 196         return Error ();
 197     uint32_t wp_index = wp->second;
 198     m_watchpoint_index_map.erase(wp);
 199     if (GetRegisterContext()->ClearHardwareWatchpoint(wp_index))
 200         return Error ();
 201     return Error ("Clearing hardware watchpoint failed.");
 202 }
 203
 204 Error
 205 NativeThreadLinux::Resume(uint32_t signo)
 206 {
 207     const StateType new_state = StateType::eStateRunning;
 208     MaybeLogStateChange (new_state);
 209     m_state = new_state;
 210
 211     m_stop_info.reason = StopReason::eStopReasonNone;
 212     m_stop_description.clear();
 213
 214     // If watchpoints have been set, but none on this thread,
 215     // then this is a new thread. So set all existing watchpoints.
 216     if (m_watchpoint_index_map.empty())
 217     {
 218         NativeProcessLinux &process = GetProcess();
 219
 220         const auto &watchpoint_map = process.GetWatchpointMap();
 221         GetRegisterContext()->ClearAllHardwareWatchpoints();
 222         for (const auto &pair : watchpoint_map)
 223         {
 224             const auto &wp = pair.second;
 225             SetWatchpoint(wp.m_addr, wp.m_size, wp.m_watch_flags, wp.m_hardware);
 226         }
 227     }
 228
 229     intptr_t data = 0;
 230
 231     if (signo != LLDB_INVALID_SIGNAL_NUMBER)
 232         data = signo;
 233
 234     return NativeProcessLinux::PtraceWrapper(PTRACE_CONT, GetID(), nullptr, reinterpret_cast<void *>(data));
 235 }
 236
 237 void
 238 NativeThreadLinux::MaybePrepareSingleStepWorkaround()
 239 {
 240     if (!SingleStepWorkaroundNeeded())
 241         return;
 242
 243     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 244
 245     if (sched_getaffinity(static_cast<::pid_t>(m_tid), sizeof m_original_cpu_set, &m_original_cpu_set) != 0)
 246     {
 247         // This should really not fail. But, just in case...
 248         if (log)
 249         {
 250             Error error(errno, eErrorTypePOSIX);
 251             log->Printf("NativeThreadLinux::%s Unable to get cpu affinity for thread %" PRIx64 ": %s", __FUNCTION__,
 252                         m_tid, error.AsCString());
 253         }
 254         return;
 255     }
 256
 257     cpu_set_t set;
 258     CPU_ZERO(&set);
 259     CPU_SET(0, &set);
 260     if (sched_setaffinity(static_cast<::pid_t>(m_tid), sizeof set, &set) != 0 && log)
 261     {
 262         // This may fail in very locked down systems, if the thread is not allowed to run on
 263         // cpu 0. If that happens, only thing we can do is it log it and continue...
 264         Error error(errno, eErrorTypePOSIX);
 265         log->Printf("NativeThreadLinux::%s Unable to set cpu affinity for thread %" PRIx64 ": %s", __FUNCTION__, m_tid,
 266                     error.AsCString());
 267     }
 268 }
 269
 270 void
 271 NativeThreadLinux::MaybeCleanupSingleStepWorkaround()
 272 {
 273     if (!SingleStepWorkaroundNeeded())
 274         return;
 275
 276     if (sched_setaffinity(static_cast<::pid_t>(m_tid), sizeof m_original_cpu_set, &m_original_cpu_set) != 0)
 277     {
 278         Error error(errno, eErrorTypePOSIX);
 279         Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 280         log->Printf("NativeThreadLinux::%s Unable to reset cpu affinity for thread %" PRIx64 ": %s", __FUNCTION__,
 281                     m_tid, error.AsCString());
 282     }
 283 }
 284
 285 Error
 286 NativeThreadLinux::SingleStep(uint32_t signo)
 287 {
 288     const StateType new_state = StateType::eStateStepping;
 289     MaybeLogStateChange (new_state);
 290     m_state = new_state;
 291     m_stop_info.reason = StopReason::eStopReasonNone;
 292
 293     MaybePrepareSingleStepWorkaround();
 294
 295     intptr_t data = 0;
 296     if (signo != LLDB_INVALID_SIGNAL_NUMBER)
 297         data = signo;
 298
 299     // If hardware single-stepping is not supported, we just do a continue. The breakpoint on the
 300     // next instruction has been setup in NativeProcessLinux::Resume.
 301     return NativeProcessLinux::PtraceWrapper(GetProcess().SupportHardwareSingleStepping() ? PTRACE_SINGLESTEP
 302                                                                                           : PTRACE_CONT,
 303                                              m_tid, nullptr, reinterpret_cast<void *>(data));
 304 }
 305
 306 void
 307 NativeThreadLinux::SetStoppedBySignal(uint32_t signo, const siginfo_t *info)
 308 {
 309     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
 310     if (log)
 311         log->Printf ("NativeThreadLinux::%s called with signal 0x%02" PRIx32, __FUNCTION__, signo);
 312
 313     SetStopped();
 314
 315     m_stop_info.reason = StopReason::eStopReasonSignal;
 316     m_stop_info.details.signal.signo = signo;
 317
 318     m_stop_description.clear();
 319     if (info)
 320     {
 321         switch (signo)
 322         {
 323         case SIGSEGV:
 324         case SIGBUS:
 325         case SIGFPE:
 326         case SIGILL:
 327              //In case of MIPS64 target, SI_KERNEL is generated for invalid 64bit address.
 328              const auto reason = (info->si_signo == SIGBUS && info->si_code == SI_KERNEL) ?
 329                                   CrashReason::eInvalidAddress : GetCrashReason(*info);
 330              m_stop_description = GetCrashReasonString(reason, reinterpret_cast<uintptr_t>(info->si_addr));
 331              break;
 332         }
 333     }
 334 }
 335
 336 bool
 337 NativeThreadLinux::IsStopped (int *signo)
 338 {
 339     if (!StateIsStoppedState (m_state, false))
 340         return false;
 341
 342     // If we are stopped by a signal, return the signo.
 343     if (signo &&
 344         m_state == StateType::eStateStopped &&
 345         m_stop_info.reason == StopReason::eStopReasonSignal)
 346     {
 347         *signo = m_stop_info.details.signal.signo;
 348     }
 349
 350     // Regardless, we are stopped.
 351     return true;
 352 }
 353
 354 void
 355 NativeThreadLinux::SetStopped()
 356 {
 357     if (m_state == StateType::eStateStepping)
 358         MaybeCleanupSingleStepWorkaround();
 359
 360     const StateType new_state = StateType::eStateStopped;
 361     MaybeLogStateChange(new_state);
 362     m_state = new_state;
 363     m_stop_description.clear();
 364 }
 365
 366 void
 367 NativeThreadLinux::SetStoppedByExec ()
 368 {
 369     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
 370     if (log)
 371         log->Printf ("NativeThreadLinux::%s()", __FUNCTION__);
 372
 373     SetStopped();
 374
 375     m_stop_info.reason = StopReason::eStopReasonExec;
 376     m_stop_info.details.signal.signo = SIGSTOP;
 377 }
 378
 379 void
 380 NativeThreadLinux::SetStoppedByBreakpoint ()
 381 {
 382     SetStopped();
 383
 384     m_stop_info.reason = StopReason::eStopReasonBreakpoint;
 385     m_stop_info.details.signal.signo = SIGTRAP;
 386     m_stop_description.clear();
 387 }
 388
 389 void
 390 NativeThreadLinux::SetStoppedByWatchpoint (uint32_t wp_index)
 391 {
 392     SetStopped();
 393
 394     lldbassert(wp_index != LLDB_INVALID_INDEX32 &&
 395                "wp_index cannot be invalid");
 396
 397     std::ostringstream ostr;
 398     ostr << GetRegisterContext()->GetWatchpointAddress(wp_index) << " ";
 399     ostr << wp_index;
 400
 401     /*
 402      * MIPS: Last 3bits of the watchpoint address are masked by the kernel. For example:
 403      * 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is set at 'm', then
 404      * watch exception is generated even when 'n' is read/written. To handle this case,
 405      * find the base address of the load/store instruction and append it in the stop-info
 406      * packet.
 407     */
 408     ostr << " " << GetRegisterContext()->GetWatchpointHitAddress(wp_index);
 409
 410     m_stop_description = ostr.str();
 411
 412     m_stop_info.reason = StopReason::eStopReasonWatchpoint;
 413     m_stop_info.details.signal.signo = SIGTRAP;
 414 }
 415
 416 bool
 417 NativeThreadLinux::IsStoppedAtBreakpoint ()
 418 {
 419     return GetState () == StateType::eStateStopped &&
 420         m_stop_info.reason == StopReason::eStopReasonBreakpoint;
 421 }
 422
 423 bool
 424 NativeThreadLinux::IsStoppedAtWatchpoint ()
 425 {
 426     return GetState () == StateType::eStateStopped &&
 427         m_stop_info.reason == StopReason::eStopReasonWatchpoint;
 428 }
 429
 430 void
 431 NativeThreadLinux::SetStoppedByTrace ()
 432 {
 433     SetStopped();
 434
 435     m_stop_info.reason = StopReason::eStopReasonTrace;
 436     m_stop_info.details.signal.signo = SIGTRAP;
 437 }
 438
 439 void
 440 NativeThreadLinux::SetStoppedWithNoReason ()
 441 {
 442     SetStopped();
 443
 444     m_stop_info.reason = StopReason::eStopReasonNone;
 445     m_stop_info.details.signal.signo = 0;
 446 }
 447
 448 void
 449 NativeThreadLinux::SetExited ()
 450 {
 451     const StateType new_state = StateType::eStateExited;
 452     MaybeLogStateChange (new_state);
 453     m_state = new_state;
 454
 455     m_stop_info.reason = StopReason::eStopReasonThreadExiting;
 456 }
 457
 458 Error
 459 NativeThreadLinux::RequestStop ()
 460 {
 461     Log* log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
 462
 463     NativeProcessLinux &process = GetProcess();
 464
 465     lldb::pid_t pid = process.GetID();
 466     lldb::tid_t tid = GetID();
 467
 468     if (log)
 469         log->Printf ("NativeThreadLinux::%s requesting thread stop(pid: %" PRIu64 ", tid: %" PRIu64 ")", __FUNCTION__, pid, tid);
 470
 471     Error err;
 472     errno = 0;
 473     if (::tgkill (pid, tid, SIGSTOP) != 0)
 474     {
 475         err.SetErrorToErrno ();
 476         if (log)
 477             log->Printf ("NativeThreadLinux::%s tgkill(%" PRIu64 ", %" PRIu64 ", SIGSTOP) failed: %s", __FUNCTION__, pid, tid, err.AsCString ());
 478     }
 479
 480     return err;
 481 }
 482
 483 void
 484 NativeThreadLinux::MaybeLogStateChange (lldb::StateType new_state)
 485 {
 486     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
 487     // If we're not logging, we're done.
 488     if (!log)
 489         return;
 490
 491     // If this is a state change to the same state, we're done.
 492     lldb::StateType old_state = m_state;
 493     if (new_state == old_state)
 494         return;
 495
 496     NativeProcessProtocolSP m_process_sp = m_process_wp.lock ();
 497     lldb::pid_t pid = m_process_sp ? m_process_sp->GetID () : LLDB_INVALID_PROCESS_ID;
 498
 499     // Log it.
 500     log->Printf ("NativeThreadLinux: thread (pid=%" PRIu64 ", tid=%" PRIu64 ") changing from state %s to %s", pid, GetID (), StateAsCString (old_state), StateAsCString (new_state));
 501 }
 502
 503 NativeProcessLinux &
 504 NativeThreadLinux::GetProcess()
 505 {
 506     auto process_sp = std::static_pointer_cast<NativeProcessLinux>(NativeThreadProtocol::GetProcess());
 507     assert(process_sp);
 508     return *process_sp;
 509 }