LLDB mainline
NativeThreadLinux.cpp
Go to the documentation of this file.
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"
16#include "SingleStepCheck.h"
17
23#include "lldb/Utility/Log.h"
24#include "lldb/Utility/State.h"
26
27#include "llvm/ADT/SmallString.h"
28
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
38using namespace lldb;
39using namespace lldb_private;
40using namespace lldb_private::process_linux;
41
42namespace {
43void 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;
50 log.Printf("%s: %s trace, stopping signal 0x%" PRIx32, __FUNCTION__, header,
51 stop_info.signo);
52 return;
54 log.Printf("%s: %s breakpoint, stopping signal 0x%" PRIx32, __FUNCTION__,
55 header, stop_info.signo);
56 return;
58 log.Printf("%s: %s watchpoint, stopping signal 0x%" PRIx32, __FUNCTION__,
59 header, stop_info.signo);
60 return;
62 log.Printf("%s: %s signal 0x%02" PRIx32, __FUNCTION__, header,
63 stop_info.signo);
64 return;
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;
74 log.Printf("%s: %s plan complete", __FUNCTION__, header);
75 return;
77 log.Printf("%s: %s thread exiting", __FUNCTION__, header);
78 return;
80 log.Printf("%s: %s instrumentation", __FUNCTION__, header);
81 return;
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
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
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
111
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
152 uint32_t watch_flags, bool hardware) {
153 if (!hardware)
154 return Status("not implemented");
156 return Status();
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
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
180 size_t size) {
182 return Status();
183
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
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
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
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.
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.
274 GetProcess().SupportHardwareSingleStepping() ? PTRACE_SINGLESTEP
275 : PTRACE_CONT,
276 m_tid, nullptr, reinterpret_cast<void *>(data));
277}
278
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:
298#ifndef SEGV_MTESERR
299#define SEGV_MTESERR 9
300#endif
301 if (info->si_signo == SIGSEGV && info->si_code == SEGV_MTESERR)
303 reinterpret_cast<lldb::addr_t>(info->si_addr));
304 break;
305 }
306 }
307}
308
310 int32_t allocation_tag_type = 0;
311 switch (GetProcess().GetArchitecture().GetMachine()) {
312 // aarch64_32 deliberately not here because there's no 32 bit MTE
313 case llvm::Triple::aarch64:
314 case llvm::Triple::aarch64_be:
316 break;
317 default:
318 return;
319 }
320
321 auto details =
322 GetRegisterContext().GetMemoryTaggingDetails(allocation_tag_type);
323 if (!details) {
324 llvm::consumeError(details.takeError());
325 return;
326 }
327
328 // We assume that the stop description is currently:
329 // signal SIGSEGV: sync tag check fault (fault address: <addr>)
330 // Remove the closing )
331 m_stop_description.pop_back();
332
333 std::stringstream ss;
334 std::unique_ptr<MemoryTagManager> manager(std::move(details->manager));
335
336 ss << " logical tag: 0x" << std::hex << manager->GetLogicalTag(fault_addr);
337
338 std::vector<uint8_t> allocation_tag_data;
339 // The fault address may not be granule aligned. ReadMemoryTags will granule
340 // align any range you give it, potentially making it larger.
341 // To prevent this set len to 1. This always results in a range that is at
342 // most 1 granule in size and includes fault_addr.
343 Status status = GetProcess().ReadMemoryTags(allocation_tag_type, fault_addr,
344 1, allocation_tag_data);
345
346 if (status.Success()) {
347 llvm::Expected<std::vector<lldb::addr_t>> allocation_tag =
348 manager->UnpackTagsData(allocation_tag_data, 1);
349 if (allocation_tag) {
350 ss << " allocation tag: 0x" << std::hex << allocation_tag->front() << ")";
351 } else {
352 llvm::consumeError(allocation_tag.takeError());
353 ss << ")";
354 }
355 } else
356 ss << ")";
357
358 m_stop_description += ss.str();
359}
360
362 if (!StateIsStoppedState(m_state, false))
363 return false;
364
365 // If we are stopped by a signal, return the signo.
366 if (signo && m_state == StateType::eStateStopped &&
367 m_stop_info.reason == StopReason::eStopReasonSignal) {
368 *signo = m_stop_info.signo;
369 }
370
371 // Regardless, we are stopped.
372 return true;
373}
374
376 if (m_state == StateType::eStateStepping)
377 m_step_workaround.reset();
378
379 // On every stop, clear any cached register data structures
381
382 const StateType new_state = StateType::eStateStopped;
383 MaybeLogStateChange(new_state);
384 m_state = new_state;
385 m_stop_description.clear();
386}
387
389 Log *log = GetLog(LLDBLog::Thread);
390 LLDB_LOGF(log, "NativeThreadLinux::%s()", __FUNCTION__);
391
392 SetStopped();
393
394 m_stop_info.reason = StopReason::eStopReasonExec;
396}
397
399 SetStopped();
400
401 m_stop_info.reason = StopReason::eStopReasonBreakpoint;
403 m_stop_description.clear();
404}
405
407 SetStopped();
408
409 lldbassert(wp_index != LLDB_INVALID_INDEX32 && "wp_index cannot be invalid");
410
411 std::ostringstream ostr;
412 ostr << m_reg_context_up->GetWatchpointAddress(wp_index) << " ";
413 ostr << wp_index;
414
415 /*
416 * MIPS: Last 3bits of the watchpoint address are masked by the kernel. For
417 * example:
418 * 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is set at
419 * 'm', then
420 * watch exception is generated even when 'n' is read/written. To handle this
421 * case,
422 * find the base address of the load/store instruction and append it in the
423 * stop-info
424 * packet.
425 */
426 ostr << " " << m_reg_context_up->GetWatchpointHitAddress(wp_index);
427
428 m_stop_description = ostr.str();
429
430 m_stop_info.reason = StopReason::eStopReasonWatchpoint;
432}
433
435 return GetState() == StateType::eStateStopped &&
436 m_stop_info.reason == StopReason::eStopReasonBreakpoint;
437}
438
440 return GetState() == StateType::eStateStopped &&
441 m_stop_info.reason == StopReason::eStopReasonWatchpoint;
442}
443
445 SetStopped();
446
447 m_stop_info.reason = StopReason::eStopReasonTrace;
449}
450
451void NativeThreadLinux::SetStoppedByFork(bool is_vfork, lldb::pid_t child_pid) {
452 SetStopped();
453
455 is_vfork ? StopReason::eStopReasonVFork : StopReason::eStopReasonFork;
457 m_stop_info.details.fork.child_pid = child_pid;
458 m_stop_info.details.fork.child_tid = child_pid;
459 m_stop_description = std::to_string(child_pid);
460 m_stop_description += " ";
461 m_stop_description += std::to_string(child_pid);
462}
463
465 SetStopped();
466
467 m_stop_info.reason = StopReason::eStopReasonVForkDone;
469}
470
472 SetStopped();
473
474 m_stop_info.reason = StopReason::eStopReasonNone;
475 m_stop_info.signo = 0;
476}
477
479 llvm::StringRef description) {
480 SetStopped();
481
482 m_stop_info.reason = StopReason::eStopReasonProcessorTrace;
483 m_stop_info.signo = 0;
484 m_stop_description = description.str();
485}
486
488 const StateType new_state = StateType::eStateExited;
489 MaybeLogStateChange(new_state);
490 m_state = new_state;
491
492 m_stop_info.reason = StopReason::eStopReasonThreadExiting;
493}
494
496 Log *log = GetLog(LLDBLog::Thread);
497
498 NativeProcessLinux &process = GetProcess();
499
500 lldb::pid_t pid = process.GetID();
501 lldb::tid_t tid = GetID();
502
503 LLDB_LOGF(log,
504 "NativeThreadLinux::%s requesting thread stop(pid: %" PRIu64
505 ", tid: %" PRIu64 ")",
506 __FUNCTION__, pid, tid);
507
508 Status err;
509 errno = 0;
510 if (::tgkill(pid, tid, SIGSTOP) != 0) {
511 err.SetErrorToErrno();
512 LLDB_LOGF(log,
513 "NativeThreadLinux::%s tgkill(%" PRIu64 ", %" PRIu64
514 ", SIGSTOP) failed: %s",
515 __FUNCTION__, pid, tid, err.AsCString());
516 }
517
518 return err;
519}
520
522 Log *log = GetLog(LLDBLog::Thread);
523 // If we're not logging, we're done.
524 if (!log)
525 return;
526
527 // If this is a state change to the same state, we're done.
528 lldb::StateType old_state = m_state;
529 if (new_state == old_state)
530 return;
531
532 LLDB_LOG(log, "pid={0}, tid={1}: changing from state {2} to {3}",
533 m_process.GetID(), GetID(), old_state, new_state);
534}
535
537 return static_cast<NativeProcessLinux &>(m_process);
538}
539
541 return static_cast<const NativeProcessLinux &>(m_process);
542}
543
544llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
546 auto siginfo_buf =
547 llvm::WritableMemoryBuffer::getNewUninitMemBuffer(sizeof(siginfo_t));
548 Status error =
549 GetProcess().GetSignalInfo(GetID(), siginfo_buf->getBufferStart());
550 if (!error.Success())
551 return error.ToError();
552 return std::move(siginfo_buf);
553}
static llvm::raw_ostream & error(Stream &strm)
std::string GetCrashReasonString(const siginfo_t &info)
Definition: CrashReason.cpp:13
#define lldbassert(x)
Definition: LLDBAssert.h:15
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:342
#define LLDB_LOGF(log,...)
Definition: Log.h:349
#define SEGV_MTESERR
#define tgkill(pid, tid, sig)
void void Printf(const char *format,...) __attribute__((format(printf
Prefer using LLDB_LOGF whenever possible.
Definition: Log.cpp:145
virtual const HardwareBreakpointMap & GetHardwareBreakpointMap() const
virtual const NativeWatchpointList::WatchpointMap & GetWatchpointMap() const
An error handling class.
Definition: Status.h:44
void SetErrorToErrno()
Set the current error to errno.
Definition: Status.cpp:215
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
bool Success() const
Test for success condition.
Definition: Status.cpp:279
Manages communication with the inferior (debugee) process.
Status GetSignalInfo(lldb::tid_t tid, void *siginfo) const
Writes a siginfo_t structure corresponding to the given thread ID to the memory region pointed to by ...
Status ReadMemoryTags(int32_t type, lldb::addr_t addr, size_t len, std::vector< uint8_t > &tags) override
static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr=nullptr, void *data=nullptr, size_t data_size=0, long *result=nullptr)
}
virtual llvm::Expected< MemoryTaggingDetails > GetMemoryTaggingDetails(int32_t type)
Return architecture specific data needed to use memory tags, if they are supported.
NativeThreadLinux(NativeProcessLinux &process, lldb::tid_t tid)
void AnnotateSyncTagCheckFault(lldb::addr_t fault_addr)
Extend m_stop_description with logical and allocation tag values.
void MaybeLogStateChange(lldb::StateType new_state)
bool GetStopReason(ThreadStopInfo &stop_info, std::string &description) override
llvm::Expected< std::unique_ptr< llvm::MemoryBuffer > > GetSiginfo() const override
void SetStoppedBySignal(uint32_t signo, const siginfo_t *info=nullptr)
Status RemoveWatchpoint(lldb::addr_t addr) override
std::unique_ptr< NativeRegisterContextLinux > m_reg_context_up
Status SingleStep(uint32_t signo)
Single steps the thread.
std::unique_ptr< SingleStepWorkaround > m_step_workaround
Status SetWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags, bool hardware) override
bool IsStopped(int *signo)
Return true if the thread is stopped.
Status RemoveHardwareBreakpoint(lldb::addr_t addr) override
Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override
void SetStoppedByProcessorTrace(llvm::StringRef description)
NativeRegisterContextLinux & GetRegisterContext() override
Status Resume(uint32_t signo)
Resumes the thread.
void SetStoppedByFork(bool is_vfork, lldb::pid_t child_pid)
static std::unique_ptr< SingleStepWorkaround > Get(::pid_t tid)
#define LLDB_INVALID_SIGNAL_NUMBER
Definition: lldb-defines.h:92
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:83
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getProcFile(::pid_t pid, ::pid_t tid, const llvm::Twine &file)
Definition: Support.cpp:15
bool StateIsStoppedState(lldb::StateType state, bool must_exist)
Check if a state represents a state where the process or thread is stopped.
Definition: State.cpp:89
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
Definition: SBAddress.h:15
StateType
Process and Thread States.
@ eStateUnloaded
Process is object is valid, but not currently loaded.
@ eStateConnected
Process is connected to remote debug services, but not launched or attached to anything yet.
@ eStateDetached
Process has been detached and can't be examined.
@ eStateStopped
Process or thread is stopped and can be examined.
@ eStateSuspended
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
@ eStateRunning
Process or thread is running and can't be examined.
@ eStateLaunching
Process is in the process of launching.
@ eStateAttaching
Process is currently trying to attach.
@ eStateExited
Process has exited and can't be examined.
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
@ eStateCrashed
Process or thread has crashed and can be examined.
uint64_t pid_t
Definition: lldb-types.h:81
uint64_t addr_t
Definition: lldb-types.h:79
@ eStopReasonInstrumentation
@ eStopReasonPlanComplete
@ eStopReasonTrace
@ eStopReasonBreakpoint
@ eStopReasonExec
Program was re-exec'ed.
@ eStopReasonProcessorTrace
@ eStopReasonThreadExiting
@ eStopReasonException
@ eStopReasonWatchpoint
@ eStopReasonSignal
uint64_t tid_t
Definition: lldb-types.h:82
struct lldb_private::ThreadStopInfo::@12::@13 exception
lldb::StopReason reason
Definition: Debug.h:132
union lldb_private::ThreadStopInfo::@12 details
struct lldb_private::ThreadStopInfo::@12::@14 fork
#define SIGSTOP
#define SIGTRAP