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