1 //===-- NativeThreadLinux.cpp --------------------------------- -*- C++ -*-===//
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 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   const StateType new_state = StateType::eStateStopped;
323   MaybeLogStateChange(new_state);
324   m_state = new_state;
325   m_stop_description.clear();
326 }
327 
328 void NativeThreadLinux::SetStoppedByExec() {
329   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
330   LLDB_LOGF(log, "NativeThreadLinux::%s()", __FUNCTION__);
331 
332   SetStopped();
333 
334   m_stop_info.reason = StopReason::eStopReasonExec;
335   m_stop_info.details.signal.signo = SIGSTOP;
336 }
337 
338 void NativeThreadLinux::SetStoppedByBreakpoint() {
339   SetStopped();
340 
341   m_stop_info.reason = StopReason::eStopReasonBreakpoint;
342   m_stop_info.details.signal.signo = SIGTRAP;
343   m_stop_description.clear();
344 }
345 
346 void NativeThreadLinux::SetStoppedByWatchpoint(uint32_t wp_index) {
347   SetStopped();
348 
349   lldbassert(wp_index != LLDB_INVALID_INDEX32 && "wp_index cannot be invalid");
350 
351   std::ostringstream ostr;
352   ostr << m_reg_context_up->GetWatchpointAddress(wp_index) << " ";
353   ostr << wp_index;
354 
355   /*
356    * MIPS: Last 3bits of the watchpoint address are masked by the kernel. For
357    * example:
358    * 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is set at
359    * 'm', then
360    * watch exception is generated even when 'n' is read/written. To handle this
361    * case,
362    * find the base address of the load/store instruction and append it in the
363    * stop-info
364    * packet.
365   */
366   ostr << " " << m_reg_context_up->GetWatchpointHitAddress(wp_index);
367 
368   m_stop_description = ostr.str();
369 
370   m_stop_info.reason = StopReason::eStopReasonWatchpoint;
371   m_stop_info.details.signal.signo = SIGTRAP;
372 }
373 
374 bool NativeThreadLinux::IsStoppedAtBreakpoint() {
375   return GetState() == StateType::eStateStopped &&
376          m_stop_info.reason == StopReason::eStopReasonBreakpoint;
377 }
378 
379 bool NativeThreadLinux::IsStoppedAtWatchpoint() {
380   return GetState() == StateType::eStateStopped &&
381          m_stop_info.reason == StopReason::eStopReasonWatchpoint;
382 }
383 
384 void NativeThreadLinux::SetStoppedByTrace() {
385   SetStopped();
386 
387   m_stop_info.reason = StopReason::eStopReasonTrace;
388   m_stop_info.details.signal.signo = SIGTRAP;
389 }
390 
391 void NativeThreadLinux::SetStoppedWithNoReason() {
392   SetStopped();
393 
394   m_stop_info.reason = StopReason::eStopReasonNone;
395   m_stop_info.details.signal.signo = 0;
396 }
397 
398 void NativeThreadLinux::SetExited() {
399   const StateType new_state = StateType::eStateExited;
400   MaybeLogStateChange(new_state);
401   m_state = new_state;
402 
403   m_stop_info.reason = StopReason::eStopReasonThreadExiting;
404 }
405 
406 Status NativeThreadLinux::RequestStop() {
407   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
408 
409   NativeProcessLinux &process = GetProcess();
410 
411   lldb::pid_t pid = process.GetID();
412   lldb::tid_t tid = GetID();
413 
414   LLDB_LOGF(log,
415             "NativeThreadLinux::%s requesting thread stop(pid: %" PRIu64
416             ", tid: %" PRIu64 ")",
417             __FUNCTION__, pid, tid);
418 
419   Status err;
420   errno = 0;
421   if (::tgkill(pid, tid, SIGSTOP) != 0) {
422     err.SetErrorToErrno();
423     LLDB_LOGF(log,
424               "NativeThreadLinux::%s tgkill(%" PRIu64 ", %" PRIu64
425               ", SIGSTOP) failed: %s",
426               __FUNCTION__, pid, tid, err.AsCString());
427   }
428 
429   return err;
430 }
431 
432 void NativeThreadLinux::MaybeLogStateChange(lldb::StateType new_state) {
433   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
434   // If we're not logging, we're done.
435   if (!log)
436     return;
437 
438   // If this is a state change to the same state, we're done.
439   lldb::StateType old_state = m_state;
440   if (new_state == old_state)
441     return;
442 
443   LLDB_LOG(log, "pid={0}, tid={1}: changing from state {2} to {3}",
444            m_process.GetID(), GetID(), old_state, new_state);
445 }
446 
447 NativeProcessLinux &NativeThreadLinux::GetProcess() {
448   return static_cast<NativeProcessLinux &>(m_process);
449 }
450