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