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 <csignal>
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/LLDBLog.h"
23 #include "lldb/Utility/Log.h"
24 #include "lldb/Utility/State.h"
25 #include "lldb/lldb-enumerations.h"
26
27 #include "llvm/ADT/SmallString.h"
28
29 #include "Plugins/Process/POSIX/CrashReason.h"
30 #include "Plugins/Process/Utility/MemoryTagManagerAArch64MTE.h"
31
32 #include <sys/syscall.h>
33 // Try to define a macro to encapsulate the tgkill syscall
34 #define tgkill(pid, tid, sig) \
35 syscall(__NR_tgkill, static_cast<::pid_t>(pid), static_cast<::pid_t>(tid), \
36 sig)
37
38 using namespace lldb;
39 using namespace lldb_private;
40 using namespace lldb_private::process_linux;
41
42 namespace {
LogThreadStopInfo(Log & log,const ThreadStopInfo & stop_info,const char * const header)43 void LogThreadStopInfo(Log &log, const ThreadStopInfo &stop_info,
44 const char *const header) {
45 switch (stop_info.reason) {
46 case eStopReasonNone:
47 log.Printf("%s: %s no stop reason", __FUNCTION__, header);
48 return;
49 case eStopReasonTrace:
50 log.Printf("%s: %s trace, stopping signal 0x%" PRIx32, __FUNCTION__, header,
51 stop_info.signo);
52 return;
53 case eStopReasonBreakpoint:
54 log.Printf("%s: %s breakpoint, stopping signal 0x%" PRIx32, __FUNCTION__,
55 header, stop_info.signo);
56 return;
57 case eStopReasonWatchpoint:
58 log.Printf("%s: %s watchpoint, stopping signal 0x%" PRIx32, __FUNCTION__,
59 header, stop_info.signo);
60 return;
61 case eStopReasonSignal:
62 log.Printf("%s: %s signal 0x%02" PRIx32, __FUNCTION__, header,
63 stop_info.signo);
64 return;
65 case eStopReasonException:
66 log.Printf("%s: %s exception type 0x%02" PRIx64, __FUNCTION__, header,
67 stop_info.details.exception.type);
68 return;
69 case eStopReasonExec:
70 log.Printf("%s: %s exec, stopping signal 0x%" PRIx32, __FUNCTION__, header,
71 stop_info.signo);
72 return;
73 case eStopReasonPlanComplete:
74 log.Printf("%s: %s plan complete", __FUNCTION__, header);
75 return;
76 case eStopReasonThreadExiting:
77 log.Printf("%s: %s thread exiting", __FUNCTION__, header);
78 return;
79 case eStopReasonInstrumentation:
80 log.Printf("%s: %s instrumentation", __FUNCTION__, header);
81 return;
82 case eStopReasonProcessorTrace:
83 log.Printf("%s: %s processor trace", __FUNCTION__, header);
84 return;
85 default:
86 log.Printf("%s: %s invalid stop reason %" PRIu32, __FUNCTION__, header,
87 static_cast<uint32_t>(stop_info.reason));
88 }
89 }
90 }
91
NativeThreadLinux(NativeProcessLinux & process,lldb::tid_t tid)92 NativeThreadLinux::NativeThreadLinux(NativeProcessLinux &process,
93 lldb::tid_t tid)
94 : NativeThreadProtocol(process, tid), m_state(StateType::eStateInvalid),
95 m_stop_info(),
96 m_reg_context_up(
97 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
98 process.GetArchitecture(), *this)),
99 m_stop_description() {}
100
GetName()101 std::string NativeThreadLinux::GetName() {
102 NativeProcessLinux &process = GetProcess();
103
104 auto BufferOrError = getProcFile(process.GetID(), GetID(), "comm");
105 if (!BufferOrError)
106 return "";
107 return std::string(BufferOrError.get()->getBuffer().rtrim('\n'));
108 }
109
GetState()110 lldb::StateType NativeThreadLinux::GetState() { return m_state; }
111
GetStopReason(ThreadStopInfo & stop_info,std::string & description)112 bool NativeThreadLinux::GetStopReason(ThreadStopInfo &stop_info,
113 std::string &description) {
114 Log *log = GetLog(LLDBLog::Thread);
115
116 description.clear();
117
118 switch (m_state) {
119 case eStateStopped:
120 case eStateCrashed:
121 case eStateExited:
122 case eStateSuspended:
123 case eStateUnloaded:
124 if (log)
125 LogThreadStopInfo(*log, m_stop_info, "m_stop_info in thread:");
126 stop_info = m_stop_info;
127 description = m_stop_description;
128 if (log)
129 LogThreadStopInfo(*log, stop_info, "returned stop_info:");
130
131 return true;
132
133 case eStateInvalid:
134 case eStateConnected:
135 case eStateAttaching:
136 case eStateLaunching:
137 case eStateRunning:
138 case eStateStepping:
139 case eStateDetached:
140 if (log) {
141 LLDB_LOGF(log,
142 "NativeThreadLinux::%s tid %" PRIu64
143 " in state %s cannot answer stop reason",
144 __FUNCTION__, GetID(), StateAsCString(m_state));
145 }
146 return false;
147 }
148 llvm_unreachable("unhandled StateType!");
149 }
150
SetWatchpoint(lldb::addr_t addr,size_t size,uint32_t watch_flags,bool hardware)151 Status NativeThreadLinux::SetWatchpoint(lldb::addr_t addr, size_t size,
152 uint32_t watch_flags, bool hardware) {
153 if (!hardware)
154 return Status("not implemented");
155 if (m_state == eStateLaunching)
156 return Status();
157 Status error = RemoveWatchpoint(addr);
158 if (error.Fail())
159 return error;
160 uint32_t wp_index =
161 m_reg_context_up->SetHardwareWatchpoint(addr, size, watch_flags);
162 if (wp_index == LLDB_INVALID_INDEX32)
163 return Status("Setting hardware watchpoint failed.");
164 m_watchpoint_index_map.insert({addr, wp_index});
165 return Status();
166 }
167
RemoveWatchpoint(lldb::addr_t addr)168 Status NativeThreadLinux::RemoveWatchpoint(lldb::addr_t addr) {
169 auto wp = m_watchpoint_index_map.find(addr);
170 if (wp == m_watchpoint_index_map.end())
171 return Status();
172 uint32_t wp_index = wp->second;
173 m_watchpoint_index_map.erase(wp);
174 if (m_reg_context_up->ClearHardwareWatchpoint(wp_index))
175 return Status();
176 return Status("Clearing hardware watchpoint failed.");
177 }
178
SetHardwareBreakpoint(lldb::addr_t addr,size_t size)179 Status NativeThreadLinux::SetHardwareBreakpoint(lldb::addr_t addr,
180 size_t size) {
181 if (m_state == eStateLaunching)
182 return Status();
183
184 Status error = RemoveHardwareBreakpoint(addr);
185 if (error.Fail())
186 return error;
187
188 uint32_t bp_index = m_reg_context_up->SetHardwareBreakpoint(addr, size);
189
190 if (bp_index == LLDB_INVALID_INDEX32)
191 return Status("Setting hardware breakpoint failed.");
192
193 m_hw_break_index_map.insert({addr, bp_index});
194 return Status();
195 }
196
RemoveHardwareBreakpoint(lldb::addr_t addr)197 Status NativeThreadLinux::RemoveHardwareBreakpoint(lldb::addr_t addr) {
198 auto bp = m_hw_break_index_map.find(addr);
199 if (bp == m_hw_break_index_map.end())
200 return Status();
201
202 uint32_t bp_index = bp->second;
203 if (m_reg_context_up->ClearHardwareBreakpoint(bp_index)) {
204 m_hw_break_index_map.erase(bp);
205 return Status();
206 }
207
208 return Status("Clearing hardware breakpoint failed.");
209 }
210
Resume(uint32_t signo)211 Status NativeThreadLinux::Resume(uint32_t signo) {
212 const StateType new_state = StateType::eStateRunning;
213 MaybeLogStateChange(new_state);
214 m_state = new_state;
215
216 m_stop_info.reason = StopReason::eStopReasonNone;
217 m_stop_description.clear();
218
219 // If watchpoints have been set, but none on this thread, then this is a new
220 // thread. So set all existing watchpoints.
221 if (m_watchpoint_index_map.empty()) {
222 NativeProcessLinux &process = GetProcess();
223
224 const auto &watchpoint_map = process.GetWatchpointMap();
225 m_reg_context_up->ClearAllHardwareWatchpoints();
226 for (const auto &pair : watchpoint_map) {
227 const auto &wp = pair.second;
228 SetWatchpoint(wp.m_addr, wp.m_size, wp.m_watch_flags, wp.m_hardware);
229 }
230 }
231
232 // Set all active hardware breakpoint on all threads.
233 if (m_hw_break_index_map.empty()) {
234 NativeProcessLinux &process = GetProcess();
235
236 const auto &hw_breakpoint_map = process.GetHardwareBreakpointMap();
237 m_reg_context_up->ClearAllHardwareBreakpoints();
238 for (const auto &pair : hw_breakpoint_map) {
239 const auto &bp = pair.second;
240 SetHardwareBreakpoint(bp.m_addr, bp.m_size);
241 }
242 }
243
244 intptr_t data = 0;
245
246 if (signo != LLDB_INVALID_SIGNAL_NUMBER)
247 data = signo;
248
249 return NativeProcessLinux::PtraceWrapper(PTRACE_CONT, GetID(), nullptr,
250 reinterpret_cast<void *>(data));
251 }
252
SingleStep(uint32_t signo)253 Status NativeThreadLinux::SingleStep(uint32_t signo) {
254 const StateType new_state = StateType::eStateStepping;
255 MaybeLogStateChange(new_state);
256 m_state = new_state;
257 m_stop_info.reason = StopReason::eStopReasonNone;
258
259 if(!m_step_workaround) {
260 // If we already hava a workaround inplace, don't reset it. Otherwise, the
261 // destructor of the existing instance will run after the new instance has
262 // fetched the cpu mask, and the thread will end up with the wrong mask.
263 m_step_workaround = SingleStepWorkaround::Get(m_tid);
264 }
265
266 intptr_t data = 0;
267 if (signo != LLDB_INVALID_SIGNAL_NUMBER)
268 data = signo;
269
270 // If hardware single-stepping is not supported, we just do a continue. The
271 // breakpoint on the next instruction has been setup in
272 // NativeProcessLinux::Resume.
273 return NativeProcessLinux::PtraceWrapper(
274 GetProcess().SupportHardwareSingleStepping() ? PTRACE_SINGLESTEP
275 : PTRACE_CONT,
276 m_tid, nullptr, reinterpret_cast<void *>(data));
277 }
278
SetStoppedBySignal(uint32_t signo,const siginfo_t * info)279 void NativeThreadLinux::SetStoppedBySignal(uint32_t signo,
280 const siginfo_t *info) {
281 Log *log = GetLog(LLDBLog::Thread);
282 LLDB_LOGF(log, "NativeThreadLinux::%s called with signal 0x%02" PRIx32,
283 __FUNCTION__, signo);
284
285 SetStopped();
286
287 m_stop_info.reason = StopReason::eStopReasonSignal;
288 m_stop_info.signo = signo;
289
290 m_stop_description.clear();
291 if (info) {
292 switch (signo) {
293 case SIGSEGV:
294 case SIGBUS:
295 case SIGFPE:
296 case SIGILL:
297 // In case of MIPS64 target, SI_KERNEL is generated for invalid 64bit
298 // address.
299 const auto reason =
300 (info->si_signo == SIGBUS && info->si_code == SI_KERNEL)
301 ? CrashReason::eInvalidAddress
302 : GetCrashReason(*info);
303 m_stop_description = GetCrashReasonString(reason, *info);
304
305 if (reason == CrashReason::eSyncTagCheckFault) {
306 AnnotateSyncTagCheckFault(info);
307 }
308
309 break;
310 }
311 }
312 }
313
AnnotateSyncTagCheckFault(const siginfo_t * info)314 void NativeThreadLinux::AnnotateSyncTagCheckFault(const siginfo_t *info) {
315 int32_t allocation_tag_type = 0;
316 switch (GetProcess().GetArchitecture().GetMachine()) {
317 // aarch64_32 deliberately not here because there's no 32 bit MTE
318 case llvm::Triple::aarch64:
319 case llvm::Triple::aarch64_be:
320 allocation_tag_type = MemoryTagManagerAArch64MTE::eMTE_allocation;
321 break;
322 default:
323 return;
324 }
325
326 auto details =
327 GetRegisterContext().GetMemoryTaggingDetails(allocation_tag_type);
328 if (!details) {
329 llvm::consumeError(details.takeError());
330 return;
331 }
332
333 // We assume that the stop description is currently:
334 // signal SIGSEGV: sync tag check fault (fault address: <addr>)
335 // Remove the closing )
336 m_stop_description.pop_back();
337
338 std::stringstream ss;
339 lldb::addr_t fault_addr = reinterpret_cast<uintptr_t>(info->si_addr);
340 std::unique_ptr<MemoryTagManager> manager(std::move(details->manager));
341
342 ss << " logical tag: 0x" << std::hex << manager->GetLogicalTag(fault_addr);
343
344 std::vector<uint8_t> allocation_tag_data;
345 // The fault address may not be granule aligned. ReadMemoryTags will granule
346 // align any range you give it, potentially making it larger.
347 // To prevent this set len to 1. This always results in a range that is at
348 // most 1 granule in size and includes fault_addr.
349 Status status = GetProcess().ReadMemoryTags(allocation_tag_type, fault_addr,
350 1, allocation_tag_data);
351
352 if (status.Success()) {
353 llvm::Expected<std::vector<lldb::addr_t>> allocation_tag =
354 manager->UnpackTagsData(allocation_tag_data, 1);
355 if (allocation_tag) {
356 ss << " allocation tag: 0x" << std::hex << allocation_tag->front() << ")";
357 } else {
358 llvm::consumeError(allocation_tag.takeError());
359 ss << ")";
360 }
361 } else
362 ss << ")";
363
364 m_stop_description += ss.str();
365 }
366
IsStopped(int * signo)367 bool NativeThreadLinux::IsStopped(int *signo) {
368 if (!StateIsStoppedState(m_state, false))
369 return false;
370
371 // If we are stopped by a signal, return the signo.
372 if (signo && m_state == StateType::eStateStopped &&
373 m_stop_info.reason == StopReason::eStopReasonSignal) {
374 *signo = m_stop_info.signo;
375 }
376
377 // Regardless, we are stopped.
378 return true;
379 }
380
SetStopped()381 void NativeThreadLinux::SetStopped() {
382 if (m_state == StateType::eStateStepping)
383 m_step_workaround.reset();
384
385 // On every stop, clear any cached register data structures
386 GetRegisterContext().InvalidateAllRegisters();
387
388 const StateType new_state = StateType::eStateStopped;
389 MaybeLogStateChange(new_state);
390 m_state = new_state;
391 m_stop_description.clear();
392 }
393
SetStoppedByExec()394 void NativeThreadLinux::SetStoppedByExec() {
395 Log *log = GetLog(LLDBLog::Thread);
396 LLDB_LOGF(log, "NativeThreadLinux::%s()", __FUNCTION__);
397
398 SetStopped();
399
400 m_stop_info.reason = StopReason::eStopReasonExec;
401 m_stop_info.signo = SIGSTOP;
402 }
403
SetStoppedByBreakpoint()404 void NativeThreadLinux::SetStoppedByBreakpoint() {
405 SetStopped();
406
407 m_stop_info.reason = StopReason::eStopReasonBreakpoint;
408 m_stop_info.signo = SIGTRAP;
409 m_stop_description.clear();
410 }
411
SetStoppedByWatchpoint(uint32_t wp_index)412 void NativeThreadLinux::SetStoppedByWatchpoint(uint32_t wp_index) {
413 SetStopped();
414
415 lldbassert(wp_index != LLDB_INVALID_INDEX32 && "wp_index cannot be invalid");
416
417 std::ostringstream ostr;
418 ostr << m_reg_context_up->GetWatchpointAddress(wp_index) << " ";
419 ostr << wp_index;
420
421 /*
422 * MIPS: Last 3bits of the watchpoint address are masked by the kernel. For
423 * example:
424 * 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is set at
425 * 'm', then
426 * watch exception is generated even when 'n' is read/written. To handle this
427 * case,
428 * find the base address of the load/store instruction and append it in the
429 * stop-info
430 * packet.
431 */
432 ostr << " " << m_reg_context_up->GetWatchpointHitAddress(wp_index);
433
434 m_stop_description = ostr.str();
435
436 m_stop_info.reason = StopReason::eStopReasonWatchpoint;
437 m_stop_info.signo = SIGTRAP;
438 }
439
IsStoppedAtBreakpoint()440 bool NativeThreadLinux::IsStoppedAtBreakpoint() {
441 return GetState() == StateType::eStateStopped &&
442 m_stop_info.reason == StopReason::eStopReasonBreakpoint;
443 }
444
IsStoppedAtWatchpoint()445 bool NativeThreadLinux::IsStoppedAtWatchpoint() {
446 return GetState() == StateType::eStateStopped &&
447 m_stop_info.reason == StopReason::eStopReasonWatchpoint;
448 }
449
SetStoppedByTrace()450 void NativeThreadLinux::SetStoppedByTrace() {
451 SetStopped();
452
453 m_stop_info.reason = StopReason::eStopReasonTrace;
454 m_stop_info.signo = SIGTRAP;
455 }
456
SetStoppedByFork(bool is_vfork,lldb::pid_t child_pid)457 void NativeThreadLinux::SetStoppedByFork(bool is_vfork, lldb::pid_t child_pid) {
458 SetStopped();
459
460 m_stop_info.reason =
461 is_vfork ? StopReason::eStopReasonVFork : StopReason::eStopReasonFork;
462 m_stop_info.signo = SIGTRAP;
463 m_stop_info.details.fork.child_pid = child_pid;
464 m_stop_info.details.fork.child_tid = child_pid;
465 }
466
SetStoppedByVForkDone()467 void NativeThreadLinux::SetStoppedByVForkDone() {
468 SetStopped();
469
470 m_stop_info.reason = StopReason::eStopReasonVForkDone;
471 m_stop_info.signo = SIGTRAP;
472 }
473
SetStoppedWithNoReason()474 void NativeThreadLinux::SetStoppedWithNoReason() {
475 SetStopped();
476
477 m_stop_info.reason = StopReason::eStopReasonNone;
478 m_stop_info.signo = 0;
479 }
480
SetStoppedByProcessorTrace(llvm::StringRef description)481 void NativeThreadLinux::SetStoppedByProcessorTrace(
482 llvm::StringRef description) {
483 SetStopped();
484
485 m_stop_info.reason = StopReason::eStopReasonProcessorTrace;
486 m_stop_info.signo = 0;
487 m_stop_description = description.str();
488 }
489
SetExited()490 void NativeThreadLinux::SetExited() {
491 const StateType new_state = StateType::eStateExited;
492 MaybeLogStateChange(new_state);
493 m_state = new_state;
494
495 m_stop_info.reason = StopReason::eStopReasonThreadExiting;
496 }
497
RequestStop()498 Status NativeThreadLinux::RequestStop() {
499 Log *log = GetLog(LLDBLog::Thread);
500
501 NativeProcessLinux &process = GetProcess();
502
503 lldb::pid_t pid = process.GetID();
504 lldb::tid_t tid = GetID();
505
506 LLDB_LOGF(log,
507 "NativeThreadLinux::%s requesting thread stop(pid: %" PRIu64
508 ", tid: %" PRIu64 ")",
509 __FUNCTION__, pid, tid);
510
511 Status err;
512 errno = 0;
513 if (::tgkill(pid, tid, SIGSTOP) != 0) {
514 err.SetErrorToErrno();
515 LLDB_LOGF(log,
516 "NativeThreadLinux::%s tgkill(%" PRIu64 ", %" PRIu64
517 ", SIGSTOP) failed: %s",
518 __FUNCTION__, pid, tid, err.AsCString());
519 }
520
521 return err;
522 }
523
MaybeLogStateChange(lldb::StateType new_state)524 void NativeThreadLinux::MaybeLogStateChange(lldb::StateType new_state) {
525 Log *log = GetLog(LLDBLog::Thread);
526 // If we're not logging, we're done.
527 if (!log)
528 return;
529
530 // If this is a state change to the same state, we're done.
531 lldb::StateType old_state = m_state;
532 if (new_state == old_state)
533 return;
534
535 LLDB_LOG(log, "pid={0}, tid={1}: changing from state {2} to {3}",
536 m_process.GetID(), GetID(), old_state, new_state);
537 }
538
GetProcess()539 NativeProcessLinux &NativeThreadLinux::GetProcess() {
540 return static_cast<NativeProcessLinux &>(m_process);
541 }
542
GetProcess() const543 const NativeProcessLinux &NativeThreadLinux::GetProcess() const {
544 return static_cast<const NativeProcessLinux &>(m_process);
545 }
546
547 llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
GetSiginfo() const548 NativeThreadLinux::GetSiginfo() const {
549 auto siginfo_buf =
550 llvm::WritableMemoryBuffer::getNewUninitMemBuffer(sizeof(siginfo_t));
551 Status error =
552 GetProcess().GetSignalInfo(GetID(), siginfo_buf->getBufferStart());
553 if (!error.Success())
554 return error.ToError();
555 return std::move(siginfo_buf);
556 }
557