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 {
LogThreadStopInfo(Log & log,const ThreadStopInfo & stop_info,const char * const header)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
NativeThreadLinux(NativeProcessLinux & process,lldb::tid_t tid)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
GetName()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
GetState()105 lldb::StateType NativeThreadLinux::GetState() { return m_state; }
106
GetStopReason(ThreadStopInfo & stop_info,std::string & description)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
SetWatchpoint(lldb::addr_t addr,size_t size,uint32_t watch_flags,bool hardware)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
RemoveWatchpoint(lldb::addr_t addr)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
SetHardwareBreakpoint(lldb::addr_t addr,size_t size)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
RemoveHardwareBreakpoint(lldb::addr_t addr)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
Resume(uint32_t signo)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
SingleStep(uint32_t signo)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
SetStoppedBySignal(uint32_t signo,const siginfo_t * info)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
IsStopped(int * signo)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
SetStopped()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
SetStoppedByExec()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
SetStoppedByBreakpoint()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
SetStoppedByWatchpoint(uint32_t wp_index)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
IsStoppedAtBreakpoint()377 bool NativeThreadLinux::IsStoppedAtBreakpoint() {
378 return GetState() == StateType::eStateStopped &&
379 m_stop_info.reason == StopReason::eStopReasonBreakpoint;
380 }
381
IsStoppedAtWatchpoint()382 bool NativeThreadLinux::IsStoppedAtWatchpoint() {
383 return GetState() == StateType::eStateStopped &&
384 m_stop_info.reason == StopReason::eStopReasonWatchpoint;
385 }
386
SetStoppedByTrace()387 void NativeThreadLinux::SetStoppedByTrace() {
388 SetStopped();
389
390 m_stop_info.reason = StopReason::eStopReasonTrace;
391 m_stop_info.details.signal.signo = SIGTRAP;
392 }
393
SetStoppedWithNoReason()394 void NativeThreadLinux::SetStoppedWithNoReason() {
395 SetStopped();
396
397 m_stop_info.reason = StopReason::eStopReasonNone;
398 m_stop_info.details.signal.signo = 0;
399 }
400
SetExited()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
RequestStop()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
MaybeLogStateChange(lldb::StateType new_state)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
GetProcess()450 NativeProcessLinux &NativeThreadLinux::GetProcess() {
451 return static_cast<NativeProcessLinux &>(m_process);
452 }
453