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