LLDB mainline
NativeProcessLinux.cpp
Go to the documentation of this file.
1//===-- NativeProcessLinux.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
10
11#include <cerrno>
12#include <cstdint>
13#include <cstring>
14#include <unistd.h>
15
16#include <fstream>
17#include <mutex>
18#include <optional>
19#include <sstream>
20#include <string>
21#include <unordered_map>
22
23#include "NativeThreadLinux.h"
26#include "Procfs.h"
28#include "lldb/Host/Host.h"
36#include "lldb/Host/linux/Uio.h"
39#include "lldb/Target/Process.h"
40#include "lldb/Target/Target.h"
43#include "lldb/Utility/State.h"
44#include "lldb/Utility/Status.h"
46#include "llvm/ADT/ScopeExit.h"
47#include "llvm/Support/Errno.h"
48#include "llvm/Support/Error.h"
49#include "llvm/Support/FileSystem.h"
50#include "llvm/Support/Threading.h"
51
52#include <linux/unistd.h>
53#include <sys/socket.h>
54#include <sys/syscall.h>
55#include <sys/types.h>
56#include <sys/user.h>
57#include <sys/wait.h>
58
59#ifdef __aarch64__
60#include <asm/hwcap.h>
61#include <sys/auxv.h>
62#endif
63
64// Support hardware breakpoints in case it has not been defined
65#ifndef TRAP_HWBKPT
66#define TRAP_HWBKPT 4
67#endif
68
69#ifndef HWCAP2_MTE
70#define HWCAP2_MTE (1 << 18)
71#endif
72
73using namespace lldb;
74using namespace lldb_private;
75using namespace lldb_private::process_linux;
76using namespace llvm;
77
78// Private bits we only need internally.
79
81 static bool is_supported;
82 static llvm::once_flag flag;
83
84 llvm::call_once(flag, [] {
86
87 uint32_t source = 0x47424742;
88 uint32_t dest = 0;
89
90 struct iovec local, remote;
91 remote.iov_base = &source;
92 local.iov_base = &dest;
93 remote.iov_len = local.iov_len = sizeof source;
94
95 // We shall try if cross-process-memory reads work by attempting to read a
96 // value from our own process.
97 ssize_t res = process_vm_readv(getpid(), &local, 1, &remote, 1, 0);
98 is_supported = (res == sizeof(source) && source == dest);
99 if (is_supported)
100 LLDB_LOG(log,
101 "Detected kernel support for process_vm_readv syscall. "
102 "Fast memory reads enabled.");
103 else
104 LLDB_LOG(log,
105 "syscall process_vm_readv failed (error: {0}). Fast memory "
106 "reads disabled.",
107 llvm::sys::StrError());
108 });
109
110 return is_supported;
111}
112
113static void MaybeLogLaunchInfo(const ProcessLaunchInfo &info) {
115 if (!log)
116 return;
117
118 if (const FileAction *action = info.GetFileActionForFD(STDIN_FILENO))
119 LLDB_LOG(log, "setting STDIN to '{0}'", action->GetFileSpec());
120 else
121 LLDB_LOG(log, "leaving STDIN as is");
122
123 if (const FileAction *action = info.GetFileActionForFD(STDOUT_FILENO))
124 LLDB_LOG(log, "setting STDOUT to '{0}'", action->GetFileSpec());
125 else
126 LLDB_LOG(log, "leaving STDOUT as is");
127
128 if (const FileAction *action = info.GetFileActionForFD(STDERR_FILENO))
129 LLDB_LOG(log, "setting STDERR to '{0}'", action->GetFileSpec());
130 else
131 LLDB_LOG(log, "leaving STDERR as is");
132
133 int i = 0;
134 for (const char **args = info.GetArguments().GetConstArgumentVector(); *args;
135 ++args, ++i)
136 LLDB_LOG(log, "arg {0}: '{1}'", i, *args);
137}
138
139static void DisplayBytes(StreamString &s, void *bytes, uint32_t count) {
140 uint8_t *ptr = (uint8_t *)bytes;
141 const uint32_t loop_count = std::min<uint32_t>(DEBUG_PTRACE_MAXBYTES, count);
142 for (uint32_t i = 0; i < loop_count; i++) {
143 s.Printf("[%x]", *ptr);
144 ptr++;
145 }
146}
147
148static void PtraceDisplayBytes(int &req, void *data, size_t data_size) {
150 if (!log)
151 return;
152 StreamString buf;
153
154 switch (req) {
155 case PTRACE_POKETEXT: {
156 DisplayBytes(buf, &data, 8);
157 LLDB_LOGV(log, "PTRACE_POKETEXT {0}", buf.GetData());
158 break;
159 }
160 case PTRACE_POKEDATA: {
161 DisplayBytes(buf, &data, 8);
162 LLDB_LOGV(log, "PTRACE_POKEDATA {0}", buf.GetData());
163 break;
164 }
165 case PTRACE_POKEUSER: {
166 DisplayBytes(buf, &data, 8);
167 LLDB_LOGV(log, "PTRACE_POKEUSER {0}", buf.GetData());
168 break;
169 }
170 case PTRACE_SETREGS: {
171 DisplayBytes(buf, data, data_size);
172 LLDB_LOGV(log, "PTRACE_SETREGS {0}", buf.GetData());
173 break;
174 }
175 case PTRACE_SETFPREGS: {
176 DisplayBytes(buf, data, data_size);
177 LLDB_LOGV(log, "PTRACE_SETFPREGS {0}", buf.GetData());
178 break;
179 }
180 case PTRACE_SETSIGINFO: {
181 DisplayBytes(buf, data, sizeof(siginfo_t));
182 LLDB_LOGV(log, "PTRACE_SETSIGINFO {0}", buf.GetData());
183 break;
184 }
185 case PTRACE_SETREGSET: {
186 // Extract iov_base from data, which is a pointer to the struct iovec
187 DisplayBytes(buf, *(void **)data, data_size);
188 LLDB_LOGV(log, "PTRACE_SETREGSET {0}", buf.GetData());
189 break;
190 }
191 default: {}
192 }
193}
194
195static constexpr unsigned k_ptrace_word_size = sizeof(void *);
196static_assert(sizeof(long) >= k_ptrace_word_size,
197 "Size of long must be larger than ptrace word size");
198
199// Simple helper function to ensure flags are enabled on the given file
200// descriptor.
201static Status EnsureFDFlags(int fd, int flags) {
203
204 int status = fcntl(fd, F_GETFL);
205 if (status == -1) {
207 return error;
208 }
209
210 if (fcntl(fd, F_SETFL, status | flags) == -1) {
212 return error;
213 }
214
215 return error;
216}
217
218static llvm::Error AddPtraceScopeNote(llvm::Error original_error) {
219 Expected<int> ptrace_scope = GetPtraceScope();
220 if (auto E = ptrace_scope.takeError()) {
222 "error reading value of ptrace_scope: {0}");
223
224 // The original error is probably more interesting than not being able to
225 // read or interpret ptrace_scope.
226 return original_error;
227 }
228
229 // We only have suggestions to provide for 1-3.
230 switch (*ptrace_scope) {
231 case 1:
232 case 2:
233 llvm::consumeError(std::move(original_error));
234 return llvm::createStringError(
235 std::error_code(errno, std::generic_category()),
236 "The current value of ptrace_scope is %d, which can cause ptrace to "
237 "fail to attach to a running process. To fix this, run:\n"
238 "\tsudo sysctl -w kernel.yama.ptrace_scope=0\n"
239 "For more information, see: "
240 "https://www.kernel.org/doc/Documentation/security/Yama.txt.",
241 *ptrace_scope);
242 case 3:
243 llvm::consumeError(std::move(original_error));
244 return llvm::createStringError(
245 std::error_code(errno, std::generic_category()),
246 "The current value of ptrace_scope is 3, which will cause ptrace to "
247 "fail to attach to a running process. This value cannot be changed "
248 "without rebooting.\n"
249 "For more information, see: "
250 "https://www.kernel.org/doc/Documentation/security/Yama.txt.");
251 case 0:
252 default:
253 return original_error;
254 }
255}
256
258 : NativeProcessProtocol::Manager(mainloop) {
259 Status status;
261 SIGCHLD, [this](MainLoopBase &) { SigchldHandler(); }, status);
262 assert(m_sigchld_handle && status.Success());
263}
264
265llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
267 NativeDelegate &native_delegate) {
269
270 MaybeLogLaunchInfo(launch_info);
271
272 Status status;
274 .LaunchProcess(launch_info, status)
275 .GetProcessId();
276 LLDB_LOG(log, "pid = {0:x}", pid);
277 if (status.Fail()) {
278 LLDB_LOG(log, "failed to launch process: {0}", status);
279 return status.ToError();
280 }
281
282 // Wait for the child process to trap on its call to execve.
283 int wstatus = 0;
284 ::pid_t wpid = llvm::sys::RetryAfterSignal(-1, ::waitpid, pid, &wstatus, 0);
285 assert(wpid == pid);
287 if (!WIFSTOPPED(wstatus)) {
288 LLDB_LOG(log, "Could not sync with inferior process: wstatus={1}",
289 WaitStatus::Decode(wstatus));
290 return llvm::make_error<StringError>("Could not sync with inferior process",
291 llvm::inconvertibleErrorCode());
292 }
293 LLDB_LOG(log, "inferior started, now in stopped state");
294
295 status = SetDefaultPtraceOpts(pid);
296 if (status.Fail()) {
297 LLDB_LOG(log, "failed to set default ptrace options: {0}", status);
298 return status.ToError();
299 }
300
301 llvm::Expected<ArchSpec> arch_or =
303 if (!arch_or)
304 return arch_or.takeError();
305
306 return std::unique_ptr<NativeProcessLinux>(new NativeProcessLinux(
307 pid, launch_info.GetPTY().ReleasePrimaryFileDescriptor(), native_delegate,
308 *arch_or, *this, {pid}));
309}
310
311llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
315 LLDB_LOG(log, "pid = {0:x}", pid);
316
317 auto tids_or = NativeProcessLinux::Attach(pid);
318 if (!tids_or)
319 return tids_or.takeError();
320 ArrayRef<::pid_t> tids = *tids_or;
321 llvm::Expected<ArchSpec> arch_or =
323 if (!arch_or)
324 return arch_or.takeError();
325
326 return std::unique_ptr<NativeProcessLinux>(
327 new NativeProcessLinux(pid, -1, native_delegate, *arch_or, *this, tids));
328}
329
336
337#ifdef __aarch64__
338 // At this point we do not have a process so read auxv directly.
339 if ((getauxval(AT_HWCAP2) & HWCAP2_MTE))
340 supported |= Extension::memory_tagging;
341#endif
342
343 return supported;
344}
345
346static std::optional<std::pair<lldb::pid_t, WaitStatus>> WaitPid() {
348
349 int status;
350 ::pid_t wait_pid = llvm::sys::RetryAfterSignal(
351 -1, ::waitpid, -1, &status, __WALL | __WNOTHREAD | WNOHANG);
352
353 if (wait_pid == 0)
354 return std::nullopt;
355
356 if (wait_pid == -1) {
358 LLDB_LOG(log, "waitpid(-1, &status, _) failed: {0}", error);
359 return std::nullopt;
360 }
361
362 WaitStatus wait_status = WaitStatus::Decode(status);
363
364 LLDB_LOG(log, "waitpid(-1, &status, _) = {0}, status = {1}", wait_pid,
365 wait_status);
366 return std::make_pair(wait_pid, wait_status);
367}
368
371 while (true) {
372 auto wait_result = WaitPid();
373 if (!wait_result)
374 return;
375 lldb::pid_t pid = wait_result->first;
376 WaitStatus status = wait_result->second;
377
378 // Ask each process whether it wants to handle the event. Each event should
379 // be handled by exactly one process, but thread creation events require
380 // special handling.
381 // Thread creation consists of two events (one on the parent and one on the
382 // child thread) and they can arrive in any order nondeterministically. The
383 // parent event carries the information about the child thread, but not
384 // vice-versa. This means that if the child event arrives first, it may not
385 // be handled by any process (because it doesn't know the thread belongs to
386 // it).
387 bool handled = llvm::any_of(m_processes, [&](NativeProcessLinux *process) {
388 return process->TryHandleWaitStatus(pid, status);
389 });
390 if (!handled) {
391 if (status.type == WaitStatus::Stop && status.status == SIGSTOP) {
392 // Store the thread creation event for later collection.
393 m_unowned_threads.insert(pid);
394 } else {
395 LLDB_LOG(log, "Ignoring waitpid event {0} for pid {1}", status, pid);
396 }
397 }
398 }
399}
400
403
404 if (m_unowned_threads.erase(tid))
405 return; // We've encountered this thread already.
406
407 // The TID is not tracked yet, let's wait for it to appear.
408 int status = -1;
409 LLDB_LOG(log,
410 "received clone event for tid {0}. tid not tracked yet, "
411 "waiting for it to appear...",
412 tid);
413 ::pid_t wait_pid =
414 llvm::sys::RetryAfterSignal(-1, ::waitpid, tid, &status, __WALL);
415
416 // It's theoretically possible to get other events if the entire process was
417 // SIGKILLed before we got a chance to check this. In that case, we'll just
418 // clean everything up when we get the process exit event.
419
420 LLDB_LOG(log,
421 "waitpid({0}, &status, __WALL) => {1} (errno: {2}, status = {3})",
422 tid, wait_pid, errno, WaitStatus::Decode(status));
423}
424
425// Public Instance Methods
426
428 NativeDelegate &delegate,
429 const ArchSpec &arch, Manager &manager,
430 llvm::ArrayRef<::pid_t> tids)
431 : NativeProcessELF(pid, terminal_fd, delegate), m_manager(manager),
432 m_arch(arch), m_intel_pt_collector(*this) {
433 manager.AddProcess(*this);
434 if (m_terminal_fd != -1) {
436 assert(status.Success());
437 }
438
439 for (const auto &tid : tids) {
440 NativeThreadLinux &thread = AddThread(tid, /*resume*/ false);
441 ThreadWasCreated(thread);
442 }
443
444 // Let our process instance know the thread has stopped.
445 SetCurrentThreadID(tids[0]);
447}
448
449llvm::Expected<std::vector<::pid_t>> NativeProcessLinux::Attach(::pid_t pid) {
451
452 Status status;
453 // Use a map to keep track of the threads which we have attached/need to
454 // attach.
455 Host::TidMap tids_to_attach;
456 while (Host::FindProcessThreads(pid, tids_to_attach)) {
457 for (Host::TidMap::iterator it = tids_to_attach.begin();
458 it != tids_to_attach.end();) {
459 if (it->second == false) {
460 lldb::tid_t tid = it->first;
461
462 // Attach to the requested process.
463 // An attach will cause the thread to stop with a SIGSTOP.
464 if ((status = PtraceWrapper(PTRACE_ATTACH, tid)).Fail()) {
465 // No such thread. The thread may have exited. More error handling
466 // may be needed.
467 if (status.GetError() == ESRCH) {
468 it = tids_to_attach.erase(it);
469 continue;
470 }
471 if (status.GetError() == EPERM) {
472 // Depending on the value of ptrace_scope, we can return a different
473 // error that suggests how to fix it.
474 return AddPtraceScopeNote(status.ToError());
475 }
476 return status.ToError();
477 }
478
479 int wpid =
480 llvm::sys::RetryAfterSignal(-1, ::waitpid, tid, nullptr, __WALL);
481 // Need to use __WALL otherwise we receive an error with errno=ECHLD At
482 // this point we should have a thread stopped if waitpid succeeds.
483 if (wpid < 0) {
484 // No such thread. The thread may have exited. More error handling
485 // may be needed.
486 if (errno == ESRCH) {
487 it = tids_to_attach.erase(it);
488 continue;
489 }
490 return llvm::errorCodeToError(
491 std::error_code(errno, std::generic_category()));
492 }
493
494 if ((status = SetDefaultPtraceOpts(tid)).Fail())
495 return status.ToError();
496
497 LLDB_LOG(log, "adding tid = {0}", tid);
498 it->second = true;
499 }
500
501 // move the loop forward
502 ++it;
503 }
504 }
505
506 size_t tid_count = tids_to_attach.size();
507 if (tid_count == 0)
508 return llvm::make_error<StringError>("No such process",
509 llvm::inconvertibleErrorCode());
510
511 std::vector<::pid_t> tids;
512 tids.reserve(tid_count);
513 for (const auto &p : tids_to_attach)
514 tids.push_back(p.first);
515 return std::move(tids);
516}
517
519 long ptrace_opts = 0;
520
521 // Have the child raise an event on exit. This is used to keep the child in
522 // limbo until it is destroyed.
523 ptrace_opts |= PTRACE_O_TRACEEXIT;
524
525 // Have the tracer trace threads which spawn in the inferior process.
526 ptrace_opts |= PTRACE_O_TRACECLONE;
527
528 // Have the tracer notify us before execve returns (needed to disable legacy
529 // SIGTRAP generation)
530 ptrace_opts |= PTRACE_O_TRACEEXEC;
531
532 // Have the tracer trace forked children.
533 ptrace_opts |= PTRACE_O_TRACEFORK;
534
535 // Have the tracer trace vforks.
536 ptrace_opts |= PTRACE_O_TRACEVFORK;
537
538 // Have the tracer trace vfork-done in order to restore breakpoints after
539 // the child finishes sharing memory.
540 ptrace_opts |= PTRACE_O_TRACEVFORKDONE;
541
542 return PtraceWrapper(PTRACE_SETOPTIONS, pid, nullptr, (void *)ptrace_opts);
543}
544
546 WaitStatus status) {
547 if (pid == GetID() &&
548 (status.type == WaitStatus::Exit || status.type == WaitStatus::Signal)) {
549 // The process exited. We're done monitoring. Report to delegate.
550 SetExitStatus(status, true);
551 return true;
552 }
553 if (NativeThreadLinux *thread = GetThreadByID(pid)) {
554 MonitorCallback(*thread, status);
555 return true;
556 }
557 return false;
558}
559
561 WaitStatus status) {
563
564 // Certain activities differ based on whether the pid is the tid of the main
565 // thread.
566 const bool is_main_thread = (thread.GetID() == GetID());
567
568 // Handle when the thread exits.
569 if (status.type == WaitStatus::Exit || status.type == WaitStatus::Signal) {
570 LLDB_LOG(log,
571 "got exit status({0}) , tid = {1} ({2} main thread), process "
572 "state = {3}",
573 status, thread.GetID(), is_main_thread ? "is" : "is not",
574 GetState());
575
576 // This is a thread that exited. Ensure we're not tracking it anymore.
577 StopTrackingThread(thread);
578
579 assert(!is_main_thread && "Main thread exits handled elsewhere");
580 return;
581 }
582
583 siginfo_t info;
584 const auto info_err = GetSignalInfo(thread.GetID(), &info);
585
586 // Get details on the signal raised.
587 if (info_err.Success()) {
588 // We have retrieved the signal info. Dispatch appropriately.
589 if (info.si_signo == SIGTRAP)
590 MonitorSIGTRAP(info, thread);
591 else
592 MonitorSignal(info, thread);
593 } else {
594 if (info_err.GetError() == EINVAL) {
595 // This is a group stop reception for this tid. We can reach here if we
596 // reinject SIGSTOP, SIGSTP, SIGTTIN or SIGTTOU into the tracee,
597 // triggering the group-stop mechanism. Normally receiving these would
598 // stop the process, pending a SIGCONT. Simulating this state in a
599 // debugger is hard and is generally not needed (one use case is
600 // debugging background task being managed by a shell). For general use,
601 // it is sufficient to stop the process in a signal-delivery stop which
602 // happens before the group stop. This done by MonitorSignal and works
603 // correctly for all signals.
604 LLDB_LOG(log,
605 "received a group stop for pid {0} tid {1}. Transparent "
606 "handling of group stops not supported, resuming the "
607 "thread.",
608 GetID(), thread.GetID());
609 ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER);
610 } else {
611 // ptrace(GETSIGINFO) failed (but not due to group-stop).
612
613 // A return value of ESRCH means the thread/process has died in the mean
614 // time. This can (e.g.) happen when another thread does an exit_group(2)
615 // or the entire process get SIGKILLed.
616 // We can't do anything with this thread anymore, but we keep it around
617 // until we get the WIFEXITED event.
618
619 LLDB_LOG(log,
620 "GetSignalInfo({0}) failed: {1}, status = {2}, main_thread = "
621 "{3}. Expecting WIFEXITED soon.",
622 thread.GetID(), info_err, status, is_main_thread);
623 }
624 }
625}
626
627void NativeProcessLinux::MonitorSIGTRAP(const siginfo_t &info,
628 NativeThreadLinux &thread) {
630 const bool is_main_thread = (thread.GetID() == GetID());
631
632 assert(info.si_signo == SIGTRAP && "Unexpected child signal!");
633
634 switch (info.si_code) {
635 case (SIGTRAP | (PTRACE_EVENT_FORK << 8)):
636 case (SIGTRAP | (PTRACE_EVENT_VFORK << 8)):
637 case (SIGTRAP | (PTRACE_EVENT_CLONE << 8)): {
638 // This can either mean a new thread or a new process spawned via
639 // clone(2) without SIGCHLD or CLONE_VFORK flag. Note that clone(2)
640 // can also cause PTRACE_EVENT_FORK and PTRACE_EVENT_VFORK if one
641 // of these flags are passed.
642
643 unsigned long event_message = 0;
644 if (GetEventMessage(thread.GetID(), &event_message).Fail()) {
645 LLDB_LOG(log,
646 "pid {0} received clone() event but GetEventMessage failed "
647 "so we don't know the new pid/tid",
648 thread.GetID());
649 ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER);
650 } else {
651 MonitorClone(thread, event_message, info.si_code >> 8);
652 }
653
654 break;
655 }
656
657 case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)): {
658 LLDB_LOG(log, "received exec event, code = {0}", info.si_code ^ SIGTRAP);
659
660 // Exec clears any pending notifications.
662
663 // Remove all but the main thread here. Linux fork creates a new process
664 // which only copies the main thread.
665 LLDB_LOG(log, "exec received, stop tracking all but main thread");
666
667 llvm::erase_if(m_threads, [&](std::unique_ptr<NativeThreadProtocol> &t) {
668 return t->GetID() != GetID();
669 });
670 assert(m_threads.size() == 1);
671 auto *main_thread = static_cast<NativeThreadLinux *>(m_threads[0].get());
672
673 SetCurrentThreadID(main_thread->GetID());
674 main_thread->SetStoppedByExec();
675
676 // Tell coordinator about the "new" (since exec) stopped main thread.
677 ThreadWasCreated(*main_thread);
678
679 // Let our delegate know we have just exec'd.
681
682 // Let the process know we're stopped.
683 StopRunningThreads(main_thread->GetID());
684
685 break;
686 }
687
688 case (SIGTRAP | (PTRACE_EVENT_EXIT << 8)): {
689 // The inferior process or one of its threads is about to exit. We don't
690 // want to do anything with the thread so we just resume it. In case we
691 // want to implement "break on thread exit" functionality, we would need to
692 // stop here.
693
694 unsigned long data = 0;
695 if (GetEventMessage(thread.GetID(), &data).Fail())
696 data = -1;
697
698 LLDB_LOG(log,
699 "received PTRACE_EVENT_EXIT, data = {0:x}, WIFEXITED={1}, "
700 "WIFSIGNALED={2}, pid = {3}, main_thread = {4}",
701 data, WIFEXITED(data), WIFSIGNALED(data), thread.GetID(),
702 is_main_thread);
703
704
705 StateType state = thread.GetState();
706 if (!StateIsRunningState(state)) {
707 // Due to a kernel bug, we may sometimes get this stop after the inferior
708 // gets a SIGKILL. This confuses our state tracking logic in
709 // ResumeThread(), since normally, we should not be receiving any ptrace
710 // events while the inferior is stopped. This makes sure that the
711 // inferior is resumed and exits normally.
712 state = eStateRunning;
713 }
715
716 if (is_main_thread) {
717 // Main thread report the read (WIFEXITED) event only after all threads in
718 // the process exit, so we need to stop tracking it here instead of in
719 // MonitorCallback
720 StopTrackingThread(thread);
721 }
722
723 break;
724 }
725
726 case (SIGTRAP | (PTRACE_EVENT_VFORK_DONE << 8)): {
728 thread.SetStoppedByVForkDone();
729 StopRunningThreads(thread.GetID());
730 }
731 else
732 ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER);
733 break;
734 }
735
736 case 0:
737 case TRAP_TRACE: // We receive this on single stepping.
738 case TRAP_HWBKPT: // We receive this on watchpoint hit
739 {
740 // If a watchpoint was hit, report it
741 uint32_t wp_index;
742 Status error = thread.GetRegisterContext().GetWatchpointHitIndex(
743 wp_index, (uintptr_t)info.si_addr);
744 if (error.Fail())
745 LLDB_LOG(log,
746 "received error while checking for watchpoint hits, pid = "
747 "{0}, error = {1}",
748 thread.GetID(), error);
749 if (wp_index != LLDB_INVALID_INDEX32) {
750 MonitorWatchpoint(thread, wp_index);
751 break;
752 }
753
754 // If a breakpoint was hit, report it
755 uint32_t bp_index;
756 error = thread.GetRegisterContext().GetHardwareBreakHitIndex(
757 bp_index, (uintptr_t)info.si_addr);
758 if (error.Fail())
759 LLDB_LOG(log, "received error while checking for hardware "
760 "breakpoint hits, pid = {0}, error = {1}",
761 thread.GetID(), error);
762 if (bp_index != LLDB_INVALID_INDEX32) {
763 MonitorBreakpoint(thread);
764 break;
765 }
766
767 // Otherwise, report step over
768 MonitorTrace(thread);
769 break;
770 }
771
772 case SI_KERNEL:
773#if defined __mips__
774 // For mips there is no special signal for watchpoint So we check for
775 // watchpoint in kernel trap
776 {
777 // If a watchpoint was hit, report it
778 uint32_t wp_index;
779 Status error = thread.GetRegisterContext().GetWatchpointHitIndex(
780 wp_index, LLDB_INVALID_ADDRESS);
781 if (error.Fail())
782 LLDB_LOG(log,
783 "received error while checking for watchpoint hits, pid = "
784 "{0}, error = {1}",
785 thread.GetID(), error);
786 if (wp_index != LLDB_INVALID_INDEX32) {
787 MonitorWatchpoint(thread, wp_index);
788 break;
789 }
790 }
791// NO BREAK
792#endif
793 case TRAP_BRKPT:
794 MonitorBreakpoint(thread);
795 break;
796
797 case SIGTRAP:
798 case (SIGTRAP | 0x80):
799 LLDB_LOG(
800 log,
801 "received unknown SIGTRAP stop event ({0}, pid {1} tid {2}, resuming",
802 info.si_code, GetID(), thread.GetID());
803
804 // Ignore these signals until we know more about them.
805 ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER);
806 break;
807
808 default:
809 LLDB_LOG(log, "received unknown SIGTRAP stop event ({0}, pid {1} tid {2}",
810 info.si_code, GetID(), thread.GetID());
811 MonitorSignal(info, thread);
812 break;
813 }
814}
815
818 LLDB_LOG(log, "received trace event, pid = {0}", thread.GetID());
819
820 // This thread is currently stopped.
821 thread.SetStoppedByTrace();
822
823 StopRunningThreads(thread.GetID());
824}
825
828 LLDB_LOG(log, "received breakpoint event, pid = {0}", thread.GetID());
829
830 // Mark the thread as stopped at breakpoint.
831 thread.SetStoppedByBreakpoint();
833
834 NativeRegisterContextLinux &reg_ctx = thread.GetRegisterContext();
835 auto stepping_with_bp_it =
836 m_threads_stepping_with_breakpoint.find(thread.GetID());
837 if (stepping_with_bp_it != m_threads_stepping_with_breakpoint.end() &&
838 llvm::is_contained(stepping_with_bp_it->second, reg_ctx.GetPC()))
839 thread.SetStoppedByTrace();
840
841 StopRunningThreads(thread.GetID());
842}
843
845 uint32_t wp_index) {
847 LLDB_LOG(log, "received watchpoint event, pid = {0}, wp_index = {1}",
848 thread.GetID(), wp_index);
849
850 // Mark the thread as stopped at watchpoint. The address is at
851 // (lldb::addr_t)info->si_addr if we need it.
852 thread.SetStoppedByWatchpoint(wp_index);
853
854 // We need to tell all other running threads before we notify the delegate
855 // about this stop.
856 StopRunningThreads(thread.GetID());
857}
858
859void NativeProcessLinux::MonitorSignal(const siginfo_t &info,
860 NativeThreadLinux &thread) {
861 const int signo = info.si_signo;
862 const bool is_from_llgs = info.si_pid == getpid();
863
865
866 // POSIX says that process behaviour is undefined after it ignores a SIGFPE,
867 // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a kill(2)
868 // or raise(3). Similarly for tgkill(2) on Linux.
869 //
870 // IOW, user generated signals never generate what we consider to be a
871 // "crash".
872 //
873 // Similarly, ACK signals generated by this monitor.
874
875 // Handle the signal.
876 LLDB_LOG(log,
877 "received signal {0} ({1}) with code {2}, (siginfo pid = {3}, "
878 "waitpid pid = {4})",
879 Host::GetSignalAsCString(signo), signo, info.si_code, info.si_pid,
880 thread.GetID());
881
882 // Check for thread stop notification.
883 if (is_from_llgs && (info.si_code == SI_TKILL) && (signo == SIGSTOP)) {
884 // This is a tgkill()-based stop.
885 LLDB_LOG(log, "pid {0} tid {1}, thread stopped", GetID(), thread.GetID());
886
887 // Check that we're not already marked with a stop reason. Note this thread
888 // really shouldn't already be marked as stopped - if we were, that would
889 // imply that the kernel signaled us with the thread stopping which we
890 // handled and marked as stopped, and that, without an intervening resume,
891 // we received another stop. It is more likely that we are missing the
892 // marking of a run state somewhere if we find that the thread was marked
893 // as stopped.
894 const StateType thread_state = thread.GetState();
895 if (!StateIsStoppedState(thread_state, false)) {
896 // An inferior thread has stopped because of a SIGSTOP we have sent it.
897 // Generally, these are not important stops and we don't want to report
898 // them as they are just used to stop other threads when one thread (the
899 // one with the *real* stop reason) hits a breakpoint (watchpoint,
900 // etc...). However, in the case of an asynchronous Interrupt(), this
901 // *is* the real stop reason, so we leave the signal intact if this is
902 // the thread that was chosen as the triggering thread.
904 if (m_pending_notification_tid == thread.GetID())
905 thread.SetStoppedBySignal(SIGSTOP, &info);
906 else
907 thread.SetStoppedWithNoReason();
908
909 SetCurrentThreadID(thread.GetID());
911 } else {
912 // We can end up here if stop was initiated by LLGS but by this time a
913 // thread stop has occurred - maybe initiated by another event.
914 Status error = ResumeThread(thread, thread.GetState(), 0);
915 if (error.Fail())
916 LLDB_LOG(log, "failed to resume thread {0}: {1}", thread.GetID(),
917 error);
918 }
919 } else {
920 LLDB_LOG(log,
921 "pid {0} tid {1}, thread was already marked as a stopped "
922 "state (state={2}), leaving stop signal as is",
923 GetID(), thread.GetID(), thread_state);
925 }
926
927 // Done handling.
928 return;
929 }
930
931 // Check if debugger should stop at this signal or just ignore it and resume
932 // the inferior.
933 if (m_signals_to_ignore.contains(signo)) {
934 ResumeThread(thread, thread.GetState(), signo);
935 return;
936 }
937
938 // This thread is stopped.
939 LLDB_LOG(log, "received signal {0}", Host::GetSignalAsCString(signo));
940 thread.SetStoppedBySignal(signo, &info);
941
942 // Send a stop to the debugger after we get all other threads to stop.
943 StopRunningThreads(thread.GetID());
944}
945
947 lldb::pid_t child_pid, int event) {
949 LLDB_LOG(log, "parent_tid={0}, child_pid={1}, event={2}", parent.GetID(),
950 child_pid, event);
951
952 m_manager.CollectThread(child_pid);
953
954 switch (event) {
955 case PTRACE_EVENT_CLONE: {
956 // PTRACE_EVENT_CLONE can either mean a new thread or a new process.
957 // Try to grab the new process' PGID to figure out which one it is.
958 // If PGID is the same as the PID, then it's a new process. Otherwise,
959 // it's a thread.
960 auto tgid_ret = getPIDForTID(child_pid);
961 if (tgid_ret != child_pid) {
962 // A new thread should have PGID matching our process' PID.
963 assert(!tgid_ret || *tgid_ret == GetID());
964
965 NativeThreadLinux &child_thread = AddThread(child_pid, /*resume*/ true);
966 ThreadWasCreated(child_thread);
967
968 // Resume the parent.
970 break;
971 }
972 }
973 [[fallthrough]];
974 case PTRACE_EVENT_FORK:
975 case PTRACE_EVENT_VFORK: {
976 bool is_vfork = event == PTRACE_EVENT_VFORK;
977 std::unique_ptr<NativeProcessLinux> child_process{new NativeProcessLinux(
978 static_cast<::pid_t>(child_pid), m_terminal_fd, m_delegate, m_arch,
979 m_manager, {static_cast<::pid_t>(child_pid)})};
980 if (!is_vfork)
981 child_process->m_software_breakpoints = m_software_breakpoints;
982
983 Extension expected_ext = is_vfork ? Extension::vfork : Extension::fork;
984 if (bool(m_enabled_extensions & expected_ext)) {
985 m_delegate.NewSubprocess(this, std::move(child_process));
986 // NB: non-vfork clone() is reported as fork
987 parent.SetStoppedByFork(is_vfork, child_pid);
988 StopRunningThreads(parent.GetID());
989 } else {
990 child_process->Detach();
992 }
993 break;
994 }
995 default:
996 llvm_unreachable("unknown clone_info.event");
997 }
998
999 return true;
1000}
1001
1003 if (m_arch.IsMIPS() || m_arch.GetMachine() == llvm::Triple::arm ||
1004 m_arch.GetTriple().isRISCV() || m_arch.GetTriple().isLoongArch())
1005 return false;
1006 return true;
1007}
1008
1011 LLDB_LOG(log, "pid {0}", GetID());
1012
1014
1015 bool software_single_step = !SupportHardwareSingleStepping();
1016
1017 if (software_single_step) {
1018 for (const auto &thread : m_threads) {
1019 assert(thread && "thread list should not contain NULL threads");
1020
1021 const ResumeAction *const action =
1022 resume_actions.GetActionForThread(thread->GetID(), true);
1023 if (action == nullptr)
1024 continue;
1025
1026 if (action->state == eStateStepping) {
1028 static_cast<NativeThreadLinux &>(*thread));
1029 if (error.Fail())
1030 return error;
1031 }
1032 }
1033 }
1034
1035 for (const auto &thread : m_threads) {
1036 assert(thread && "thread list should not contain NULL threads");
1037
1038 const ResumeAction *const action =
1039 resume_actions.GetActionForThread(thread->GetID(), true);
1040
1041 if (action == nullptr) {
1042 LLDB_LOG(log, "no action specified for pid {0} tid {1}", GetID(),
1043 thread->GetID());
1044 continue;
1045 }
1046
1047 LLDB_LOG(log, "processing resume action state {0} for pid {1} tid {2}",
1048 action->state, GetID(), thread->GetID());
1049
1050 switch (action->state) {
1051 case eStateRunning:
1052 case eStateStepping: {
1053 // Run the thread, possibly feeding it the signal.
1054 const int signo = action->signal;
1055 Status error = ResumeThread(static_cast<NativeThreadLinux &>(*thread),
1056 action->state, signo);
1057 if (error.Fail())
1059 "NativeProcessLinux::%s: failed to resume thread "
1060 "for pid %" PRIu64 ", tid %" PRIu64 ", error = %s",
1061 __FUNCTION__, GetID(), thread->GetID(), error.AsCString());
1062
1063 break;
1064 }
1065
1066 case eStateSuspended:
1067 case eStateStopped:
1068 break;
1069
1070 default:
1072 "NativeProcessLinux::%s (): unexpected state %s specified "
1073 "for pid %" PRIu64 ", tid %" PRIu64,
1074 __FUNCTION__, StateAsCString(action->state), GetID(),
1075 thread->GetID());
1076 }
1077 }
1078
1079 return Status();
1080}
1081
1083 Status error;
1084
1085 if (kill(GetID(), SIGSTOP) != 0)
1087
1088 return error;
1089}
1090
1092 Status error;
1093
1094 // Tell ptrace to detach from the process.
1096 return error;
1097
1098 // Cancel out any SIGSTOPs we may have sent while stopping the process.
1099 // Otherwise, the process may stop as soon as we detach from it.
1100 kill(GetID(), SIGCONT);
1101
1102 for (const auto &thread : m_threads) {
1103 Status e = Detach(thread->GetID());
1104 // Save the error, but still attempt to detach from other threads.
1105 if (e.Fail())
1106 error = e.Clone();
1107 }
1108
1109 m_intel_pt_collector.Clear();
1110
1111 return error;
1112}
1113
1115 Status error;
1116
1118 LLDB_LOG(log, "sending signal {0} ({1}) to pid {1}", signo,
1120
1121 if (kill(GetID(), signo))
1123
1124 return error;
1125}
1126
1128 // Pick a running thread (or if none, a not-dead stopped thread) as the
1129 // chosen thread that will be the stop-reason thread.
1131
1132 NativeThreadProtocol *running_thread = nullptr;
1133 NativeThreadProtocol *stopped_thread = nullptr;
1134
1135 LLDB_LOG(log, "selecting running thread for interrupt target");
1136 for (const auto &thread : m_threads) {
1137 // If we have a running or stepping thread, we'll call that the target of
1138 // the interrupt.
1139 const auto thread_state = thread->GetState();
1140 if (thread_state == eStateRunning || thread_state == eStateStepping) {
1141 running_thread = thread.get();
1142 break;
1143 } else if (!stopped_thread && StateIsStoppedState(thread_state, true)) {
1144 // Remember the first non-dead stopped thread. We'll use that as a
1145 // backup if there are no running threads.
1146 stopped_thread = thread.get();
1147 }
1148 }
1149
1150 if (!running_thread && !stopped_thread) {
1151 Status error("found no running/stepping or live stopped threads as target "
1152 "for interrupt");
1153 LLDB_LOG(log, "skipping due to error: {0}", error);
1154
1155 return error;
1156 }
1157
1158 NativeThreadProtocol *deferred_signal_thread =
1159 running_thread ? running_thread : stopped_thread;
1160
1161 LLDB_LOG(log, "pid {0} {1} tid {2} chosen for interrupt target", GetID(),
1162 running_thread ? "running" : "stopped",
1163 deferred_signal_thread->GetID());
1164
1165 StopRunningThreads(deferred_signal_thread->GetID());
1166
1167 return Status();
1168}
1169
1172 LLDB_LOG(log, "pid {0}", GetID());
1173
1174 Status error;
1175
1176 switch (m_state) {
1182 // Nothing to do - the process is already dead.
1183 LLDB_LOG(log, "ignored for PID {0} due to current state: {1}", GetID(),
1184 m_state);
1185 return error;
1186
1194 // We can try to kill a process in these states.
1195 break;
1196 }
1197
1198 if (kill(GetID(), SIGKILL) != 0) {
1200 return error;
1201 }
1202
1203 return error;
1204}
1205
1207 MemoryRegionInfo &range_info) {
1208 // FIXME review that the final memory region returned extends to the end of
1209 // the virtual address space,
1210 // with no perms if it is not mapped.
1211
1212 // Use an approach that reads memory regions from /proc/{pid}/maps. Assume
1213 // proc maps entries are in ascending order.
1214 // FIXME assert if we find differently.
1215
1217 // We're done.
1218 return Status::FromErrorString("unsupported");
1219 }
1220
1222 if (error.Fail()) {
1223 return error;
1224 }
1225
1226 lldb::addr_t prev_base_address = 0;
1227
1228 // FIXME start by finding the last region that is <= target address using
1229 // binary search. Data is sorted.
1230 // There can be a ton of regions on pthreads apps with lots of threads.
1231 for (auto it = m_mem_region_cache.begin(); it != m_mem_region_cache.end();
1232 ++it) {
1233 MemoryRegionInfo &proc_entry_info = it->first;
1234
1235 // Sanity check assumption that /proc/{pid}/maps entries are ascending.
1236 assert((proc_entry_info.GetRange().GetRangeBase() >= prev_base_address) &&
1237 "descending /proc/pid/maps entries detected, unexpected");
1238 prev_base_address = proc_entry_info.GetRange().GetRangeBase();
1239 UNUSED_IF_ASSERT_DISABLED(prev_base_address);
1240
1241 // If the target address comes before this entry, indicate distance to next
1242 // region.
1243 if (load_addr < proc_entry_info.GetRange().GetRangeBase()) {
1244 range_info.GetRange().SetRangeBase(load_addr);
1245 range_info.GetRange().SetByteSize(
1246 proc_entry_info.GetRange().GetRangeBase() - load_addr);
1251
1252 return error;
1253 } else if (proc_entry_info.GetRange().Contains(load_addr)) {
1254 // The target address is within the memory region we're processing here.
1255 range_info = proc_entry_info;
1256 return error;
1257 }
1258
1259 // The target memory address comes somewhere after the region we just
1260 // parsed.
1261 }
1262
1263 // If we made it here, we didn't find an entry that contained the given
1264 // address. Return the load_addr as start and the amount of bytes betwwen
1265 // load address and the end of the memory as size.
1266 range_info.GetRange().SetRangeBase(load_addr);
1272 return error;
1273}
1274
1277
1278 // If our cache is empty, pull the latest. There should always be at least
1279 // one memory region if memory region handling is supported.
1280 if (!m_mem_region_cache.empty()) {
1281 LLDB_LOG(log, "reusing {0} cached memory region entries",
1282 m_mem_region_cache.size());
1283 return Status();
1284 }
1285
1286 Status Result;
1287 LinuxMapCallback callback = [&](llvm::Expected<MemoryRegionInfo> Info) {
1288 if (Info) {
1289 FileSpec file_spec(Info->GetName().GetCString());
1290 FileSystem::Instance().Resolve(file_spec);
1291 m_mem_region_cache.emplace_back(*Info, file_spec);
1292 return true;
1293 }
1294
1295 Result = Status::FromError(Info.takeError());
1297 LLDB_LOG(log, "failed to parse proc maps: {0}", Result);
1298 return false;
1299 };
1300
1301 // Linux kernel since 2.6.14 has /proc/{pid}/smaps
1302 // if CONFIG_PROC_PAGE_MONITOR is enabled
1303 auto BufferOrError = getProcFile(GetID(), GetCurrentThreadID(), "smaps");
1304 if (BufferOrError)
1305 ParseLinuxSMapRegions(BufferOrError.get()->getBuffer(), callback);
1306 else {
1307 BufferOrError = getProcFile(GetID(), GetCurrentThreadID(), "maps");
1308 if (!BufferOrError) {
1310 return BufferOrError.getError();
1311 }
1312
1313 ParseLinuxMapRegions(BufferOrError.get()->getBuffer(), callback);
1314 }
1315
1316 if (Result.Fail())
1317 return Result;
1318
1319 if (m_mem_region_cache.empty()) {
1320 // No entries after attempting to read them. This shouldn't happen if
1321 // /proc/{pid}/maps is supported. Assume we don't support map entries via
1322 // procfs.
1324 LLDB_LOG(log,
1325 "failed to find any procfs maps entries, assuming no support "
1326 "for memory region metadata retrieval");
1327 return Status::FromErrorString("not supported");
1328 }
1329
1330 LLDB_LOG(log, "read {0} memory region entries from /proc/{1}/maps",
1331 m_mem_region_cache.size(), GetID());
1332
1333 // We support memory retrieval, remember that.
1335 return Status();
1336}
1337
1338void NativeProcessLinux::DoStopIDBumped(uint32_t newBumpId) {
1340 LLDB_LOG(log, "newBumpId={0}", newBumpId);
1341 LLDB_LOG(log, "clearing {0} entries from memory region cache",
1342 m_mem_region_cache.size());
1343 m_mem_region_cache.clear();
1344}
1345
1346llvm::Expected<uint64_t>
1347NativeProcessLinux::Syscall(llvm::ArrayRef<uint64_t> args) {
1349 auto region_it = llvm::find_if(m_mem_region_cache, [](const auto &pair) {
1350 return pair.first.GetExecutable() == MemoryRegionInfo::eYes &&
1351 pair.first.GetShared() != MemoryRegionInfo::eYes;
1352 });
1353 if (region_it == m_mem_region_cache.end())
1354 return llvm::createStringError(llvm::inconvertibleErrorCode(),
1355 "No executable memory region found!");
1356
1357 addr_t exe_addr = region_it->first.GetRange().GetRangeBase();
1358
1360 assert(thread.GetState() == eStateStopped);
1361 NativeRegisterContextLinux &reg_ctx = thread.GetRegisterContext();
1362
1364 *reg_ctx.GetSyscallData();
1365
1366 WritableDataBufferSP registers_sp;
1367 if (llvm::Error Err = reg_ctx.ReadAllRegisterValues(registers_sp).ToError())
1368 return std::move(Err);
1369 auto restore_regs = llvm::make_scope_exit(
1370 [&] { reg_ctx.WriteAllRegisterValues(registers_sp); });
1371
1372 llvm::SmallVector<uint8_t, 8> memory(syscall_data.Insn.size());
1373 size_t bytes_read;
1374 if (llvm::Error Err =
1375 ReadMemory(exe_addr, memory.data(), memory.size(), bytes_read)
1376 .ToError()) {
1377 return std::move(Err);
1378 }
1379
1380 auto restore_mem = llvm::make_scope_exit(
1381 [&] { WriteMemory(exe_addr, memory.data(), memory.size(), bytes_read); });
1382
1383 if (llvm::Error Err = reg_ctx.SetPC(exe_addr).ToError())
1384 return std::move(Err);
1385
1386 for (const auto &zip : llvm::zip_first(args, syscall_data.Args)) {
1387 if (llvm::Error Err =
1388 reg_ctx
1389 .WriteRegisterFromUnsigned(std::get<1>(zip), std::get<0>(zip))
1390 .ToError()) {
1391 return std::move(Err);
1392 }
1393 }
1394 if (llvm::Error Err = WriteMemory(exe_addr, syscall_data.Insn.data(),
1395 syscall_data.Insn.size(), bytes_read)
1396 .ToError())
1397 return std::move(Err);
1398
1399 m_mem_region_cache.clear();
1400
1401 // With software single stepping the syscall insn buffer must also include a
1402 // trap instruction to stop the process.
1403 int req = SupportHardwareSingleStepping() ? PTRACE_SINGLESTEP : PTRACE_CONT;
1404 if (llvm::Error Err =
1405 PtraceWrapper(req, thread.GetID(), nullptr, nullptr).ToError())
1406 return std::move(Err);
1407
1408 int status;
1409 ::pid_t wait_pid = llvm::sys::RetryAfterSignal(-1, ::waitpid, thread.GetID(),
1410 &status, __WALL);
1411 if (wait_pid == -1) {
1412 return llvm::errorCodeToError(
1413 std::error_code(errno, std::generic_category()));
1414 }
1415 assert((unsigned)wait_pid == thread.GetID());
1416
1417 uint64_t result = reg_ctx.ReadRegisterAsUnsigned(syscall_data.Result, -ESRCH);
1418
1419 // Values larger than this are actually negative errno numbers.
1420 uint64_t errno_threshold =
1421 (uint64_t(-1) >> (64 - 8 * m_arch.GetAddressByteSize())) - 0x1000;
1422 if (result > errno_threshold) {
1423 return llvm::errorCodeToError(
1424 std::error_code(-result & 0xfff, std::generic_category()));
1425 }
1426
1427 return result;
1428}
1429
1430llvm::Expected<addr_t>
1431NativeProcessLinux::AllocateMemory(size_t size, uint32_t permissions) {
1432
1433 std::optional<NativeRegisterContextLinux::MmapData> mmap_data =
1435 if (!mmap_data)
1436 return llvm::make_error<UnimplementedError>();
1437
1438 unsigned prot = PROT_NONE;
1439 assert((permissions & (ePermissionsReadable | ePermissionsWritable |
1440 ePermissionsExecutable)) == permissions &&
1441 "Unknown permission!");
1442 if (permissions & ePermissionsReadable)
1443 prot |= PROT_READ;
1444 if (permissions & ePermissionsWritable)
1445 prot |= PROT_WRITE;
1446 if (permissions & ePermissionsExecutable)
1447 prot |= PROT_EXEC;
1448
1449 llvm::Expected<uint64_t> Result =
1450 Syscall({mmap_data->SysMmap, 0, size, prot, MAP_ANONYMOUS | MAP_PRIVATE,
1451 uint64_t(-1), 0});
1452 if (Result)
1453 m_allocated_memory.try_emplace(*Result, size);
1454 return Result;
1455}
1456
1458 std::optional<NativeRegisterContextLinux::MmapData> mmap_data =
1460 if (!mmap_data)
1461 return llvm::make_error<UnimplementedError>();
1462
1463 auto it = m_allocated_memory.find(addr);
1464 if (it == m_allocated_memory.end())
1465 return llvm::createStringError(llvm::errc::invalid_argument,
1466 "Memory not allocated by the debugger.");
1467
1468 llvm::Expected<uint64_t> Result =
1469 Syscall({mmap_data->SysMunmap, addr, it->second});
1470 if (!Result)
1471 return Result.takeError();
1472
1473 m_allocated_memory.erase(it);
1474 return llvm::Error::success();
1475}
1476
1478 size_t len,
1479 std::vector<uint8_t> &tags) {
1480 llvm::Expected<NativeRegisterContextLinux::MemoryTaggingDetails> details =
1482 if (!details)
1483 return Status::FromError(details.takeError());
1484
1485 // Ignore 0 length read
1486 if (!len)
1487 return Status();
1488
1489 // lldb will align the range it requests but it is not required to by
1490 // the protocol so we'll do it again just in case.
1491 // Remove tag bits too. Ptrace calls may work regardless but that
1492 // is not a guarantee.
1493 MemoryTagManager::TagRange range(details->manager->RemoveTagBits(addr), len);
1494 range = details->manager->ExpandToGranule(range);
1495
1496 // Allocate enough space for all tags to be read
1497 size_t num_tags = range.GetByteSize() / details->manager->GetGranuleSize();
1498 tags.resize(num_tags * details->manager->GetTagSizeInBytes());
1499
1500 struct iovec tags_iovec;
1501 uint8_t *dest = tags.data();
1502 lldb::addr_t read_addr = range.GetRangeBase();
1503
1504 // This call can return partial data so loop until we error or
1505 // get all tags back.
1506 while (num_tags) {
1507 tags_iovec.iov_base = dest;
1508 tags_iovec.iov_len = num_tags;
1509
1511 details->ptrace_read_req, GetCurrentThreadID(),
1512 reinterpret_cast<void *>(read_addr), static_cast<void *>(&tags_iovec),
1513 0, nullptr);
1514
1515 if (error.Fail()) {
1516 // Discard partial reads
1517 tags.resize(0);
1518 return error;
1519 }
1520
1521 size_t tags_read = tags_iovec.iov_len;
1522 assert(tags_read && (tags_read <= num_tags));
1523
1524 dest += tags_read * details->manager->GetTagSizeInBytes();
1525 read_addr += details->manager->GetGranuleSize() * tags_read;
1526 num_tags -= tags_read;
1527 }
1528
1529 return Status();
1530}
1531
1533 size_t len,
1534 const std::vector<uint8_t> &tags) {
1535 llvm::Expected<NativeRegisterContextLinux::MemoryTaggingDetails> details =
1537 if (!details)
1538 return Status::FromError(details.takeError());
1539
1540 // Ignore 0 length write
1541 if (!len)
1542 return Status();
1543
1544 // lldb will align the range it requests but it is not required to by
1545 // the protocol so we'll do it again just in case.
1546 // Remove tag bits too. Ptrace calls may work regardless but that
1547 // is not a guarantee.
1548 MemoryTagManager::TagRange range(details->manager->RemoveTagBits(addr), len);
1549 range = details->manager->ExpandToGranule(range);
1550
1551 // Not checking number of tags here, we may repeat them below
1552 llvm::Expected<std::vector<lldb::addr_t>> unpacked_tags_or_err =
1553 details->manager->UnpackTagsData(tags);
1554 if (!unpacked_tags_or_err)
1555 return Status::FromError(unpacked_tags_or_err.takeError());
1556
1557 llvm::Expected<std::vector<lldb::addr_t>> repeated_tags_or_err =
1558 details->manager->RepeatTagsForRange(*unpacked_tags_or_err, range);
1559 if (!repeated_tags_or_err)
1560 return Status::FromError(repeated_tags_or_err.takeError());
1561
1562 // Repack them for ptrace to use
1563 llvm::Expected<std::vector<uint8_t>> final_tag_data =
1564 details->manager->PackTags(*repeated_tags_or_err);
1565 if (!final_tag_data)
1566 return Status::FromError(final_tag_data.takeError());
1567
1568 struct iovec tags_vec;
1569 uint8_t *src = final_tag_data->data();
1570 lldb::addr_t write_addr = range.GetRangeBase();
1571 // unpacked tags size because the number of bytes per tag might not be 1
1572 size_t num_tags = repeated_tags_or_err->size();
1573
1574 // This call can partially write tags, so we loop until we
1575 // error or all tags have been written.
1576 while (num_tags > 0) {
1577 tags_vec.iov_base = src;
1578 tags_vec.iov_len = num_tags;
1579
1581 details->ptrace_write_req, GetCurrentThreadID(),
1582 reinterpret_cast<void *>(write_addr), static_cast<void *>(&tags_vec), 0,
1583 nullptr);
1584
1585 if (error.Fail()) {
1586 // Don't attempt to restore the original values in the case of a partial
1587 // write
1588 return error;
1589 }
1590
1591 size_t tags_written = tags_vec.iov_len;
1592 assert(tags_written && (tags_written <= num_tags));
1593
1594 src += tags_written * details->manager->GetTagSizeInBytes();
1595 write_addr += details->manager->GetGranuleSize() * tags_written;
1596 num_tags -= tags_written;
1597 }
1598
1599 return Status();
1600}
1601
1603 // The NativeProcessLinux monitoring threads are always up to date with
1604 // respect to thread state and they keep the thread list populated properly.
1605 // All this method needs to do is return the thread count.
1606 return m_threads.size();
1607}
1608
1610 bool hardware) {
1611 if (hardware)
1612 return SetHardwareBreakpoint(addr, size);
1613 else
1614 return SetSoftwareBreakpoint(addr, size);
1615}
1616
1618 if (hardware)
1619 return RemoveHardwareBreakpoint(addr);
1620 else
1622}
1623
1624llvm::Expected<llvm::ArrayRef<uint8_t>>
1626 // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but the
1627 // linux kernel does otherwise.
1628 static const uint8_t g_arm_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
1629 static const uint8_t g_thumb_opcode[] = {0x01, 0xde};
1630
1631 switch (GetArchitecture().GetMachine()) {
1632 case llvm::Triple::arm:
1633 switch (size_hint) {
1634 case 2:
1635 return llvm::ArrayRef(g_thumb_opcode);
1636 case 4:
1637 return llvm::ArrayRef(g_arm_opcode);
1638 default:
1639 return llvm::createStringError(llvm::inconvertibleErrorCode(),
1640 "Unrecognised trap opcode size hint!");
1641 }
1642 default:
1644 }
1645}
1646
1648 size_t &bytes_read) {
1649 Log *log = GetLog(POSIXLog::Memory);
1650 LLDB_LOG(log, "addr = {0}, buf = {1}, size = {2}", addr, buf, size);
1651
1652 bytes_read = 0;
1654 // The process_vm_readv path is about 50 times faster than ptrace api. We
1655 // want to use this syscall if it is supported.
1656
1657 struct iovec local_iov, remote_iov;
1658 local_iov.iov_base = buf;
1659 local_iov.iov_len = size;
1660 remote_iov.iov_base = reinterpret_cast<void *>(addr);
1661 remote_iov.iov_len = size;
1662
1663 ssize_t read_result = process_vm_readv(GetCurrentThreadID(), &local_iov, 1,
1664 &remote_iov, 1, 0);
1665 int error = 0;
1666 if (read_result < 0)
1667 error = errno;
1668 else
1669 bytes_read = read_result;
1670
1671 LLDB_LOG(log,
1672 "process_vm_readv({0}, [iovec({1}, {2})], [iovec({3:x}, {2})], 1, "
1673 "0) => {4} ({5})",
1674 GetCurrentThreadID(), buf, size, addr, read_result,
1675 error > 0 ? llvm::sys::StrError(errno) : "sucesss");
1676 }
1677
1678 unsigned char *dst = static_cast<unsigned char *>(buf);
1679 size_t remainder;
1680 long data;
1681
1682 for (; bytes_read < size; bytes_read += remainder) {
1684 PTRACE_PEEKDATA, GetCurrentThreadID(),
1685 reinterpret_cast<void *>(addr + bytes_read), nullptr, 0, &data);
1686 if (error.Fail())
1687 return error;
1688
1689 remainder = size - bytes_read;
1690 remainder = remainder > k_ptrace_word_size ? k_ptrace_word_size : remainder;
1691
1692 // Copy the data into our buffer
1693 memcpy(dst + bytes_read, &data, remainder);
1694 }
1695 return Status();
1696}
1697
1699 size_t size, size_t &bytes_written) {
1700 const unsigned char *src = static_cast<const unsigned char *>(buf);
1701 size_t remainder;
1702 Status error;
1703
1704 Log *log = GetLog(POSIXLog::Memory);
1705 LLDB_LOG(log, "addr = {0}, buf = {1}, size = {2}", addr, buf, size);
1706
1707 for (bytes_written = 0; bytes_written < size; bytes_written += remainder) {
1708 remainder = size - bytes_written;
1709 remainder = remainder > k_ptrace_word_size ? k_ptrace_word_size : remainder;
1710
1711 if (remainder == k_ptrace_word_size) {
1712 unsigned long data = 0;
1713 memcpy(&data, src, k_ptrace_word_size);
1714
1715 LLDB_LOG(log, "[{0:x}]:{1:x}", addr, data);
1717 PTRACE_POKEDATA, GetCurrentThreadID(), (void *)addr, (void *)data);
1718 if (error.Fail())
1719 return error;
1720 } else {
1721 unsigned char buff[8];
1722 size_t bytes_read;
1723 error = ReadMemory(addr, buff, k_ptrace_word_size, bytes_read);
1724 if (error.Fail())
1725 return error;
1726
1727 memcpy(buff, src, remainder);
1728
1729 size_t bytes_written_rec;
1730 error = WriteMemory(addr, buff, k_ptrace_word_size, bytes_written_rec);
1731 if (error.Fail())
1732 return error;
1733
1734 LLDB_LOG(log, "[{0:x}]:{1:x} ({2:x})", addr, *(const unsigned long *)src,
1735 *(unsigned long *)buff);
1736 }
1737
1738 addr += k_ptrace_word_size;
1739 src += k_ptrace_word_size;
1740 }
1741 return error;
1742}
1743
1745 return PtraceWrapper(PTRACE_GETSIGINFO, tid, nullptr, siginfo);
1746}
1747
1749 unsigned long *message) {
1750 return PtraceWrapper(PTRACE_GETEVENTMSG, tid, nullptr, message);
1751}
1752
1754 if (tid == LLDB_INVALID_THREAD_ID)
1755 return Status();
1756
1757 return PtraceWrapper(PTRACE_DETACH, tid);
1758}
1759
1761 for (const auto &thread : m_threads) {
1762 assert(thread && "thread list should not contain NULL threads");
1763 if (thread->GetID() == thread_id) {
1764 // We have this thread.
1765 return true;
1766 }
1767 }
1768
1769 // We don't have this thread.
1770 return false;
1771}
1772
1774 Log *const log = GetLog(POSIXLog::Thread);
1775 lldb::tid_t thread_id = thread.GetID();
1776 LLDB_LOG(log, "tid: {0}", thread_id);
1777
1778 auto it = llvm::find_if(m_threads, [&](const auto &thread_up) {
1779 return thread_up.get() == &thread;
1780 });
1781 assert(it != m_threads.end());
1782 m_threads.erase(it);
1783
1786}
1787
1791
1795
1797 Log *log = GetLog(POSIXLog::Thread);
1798 Status error = Status::FromError(m_intel_pt_collector.OnThreadCreated(tid));
1799 if (error.Fail())
1800 LLDB_LOG(log, "Failed to trace a new thread with intel-pt, tid = {0}. {1}",
1801 tid, error.AsCString());
1802 return error;
1803}
1804
1806 Log *log = GetLog(POSIXLog::Thread);
1807 Status error = Status::FromError(m_intel_pt_collector.OnThreadDestroyed(tid));
1808 if (error.Fail())
1809 LLDB_LOG(log,
1810 "Failed to stop a destroyed thread with intel-pt, tid = {0}. {1}",
1811 tid, error.AsCString());
1812 return error;
1813}
1814
1816 bool resume) {
1817 Log *log = GetLog(POSIXLog::Thread);
1818 LLDB_LOG(log, "pid {0} adding thread with tid {1}", GetID(), thread_id);
1819
1820 assert(!HasThreadNoLock(thread_id) &&
1821 "attempted to add a thread by id that already exists");
1822
1823 // If this is the first thread, save it as the current thread
1824 if (m_threads.empty())
1825 SetCurrentThreadID(thread_id);
1826
1827 m_threads.push_back(std::make_unique<NativeThreadLinux>(*this, thread_id));
1828 NativeThreadLinux &thread =
1829 static_cast<NativeThreadLinux &>(*m_threads.back());
1830
1831 Status tracing_error = NotifyTracersOfNewThread(thread.GetID());
1832 if (tracing_error.Fail()) {
1833 thread.SetStoppedByProcessorTrace(tracing_error.AsCString());
1834 StopRunningThreads(thread.GetID());
1835 } else if (resume)
1837 else
1838 thread.SetStoppedBySignal(SIGSTOP);
1839
1840 return thread;
1841}
1842
1844 FileSpec &file_spec) {
1846 if (error.Fail())
1847 return error;
1848
1849 FileSpec module_file_spec(module_path);
1850 FileSystem::Instance().Resolve(module_file_spec);
1851
1852 file_spec.Clear();
1853 for (const auto &it : m_mem_region_cache) {
1854 if (it.second.GetFilename() == module_file_spec.GetFilename()) {
1855 file_spec = it.second;
1856 return Status();
1857 }
1858 }
1860 "Module file (%s) not found in /proc/%" PRIu64 "/maps file!",
1861 module_file_spec.GetFilename().AsCString(), GetID());
1862}
1863
1864Status NativeProcessLinux::GetFileLoadAddress(const llvm::StringRef &file_name,
1865 lldb::addr_t &load_addr) {
1866 load_addr = LLDB_INVALID_ADDRESS;
1868 if (error.Fail())
1869 return error;
1870
1871 FileSpec file(file_name);
1872 for (const auto &it : m_mem_region_cache) {
1873 if (it.second == file) {
1874 load_addr = it.first.GetRange().GetRangeBase();
1875 return Status();
1876 }
1877 }
1878 return Status::FromErrorString("No load address found for specified file.");
1879}
1880
1885
1890
1892 lldb::StateType state, int signo) {
1893 Log *const log = GetLog(POSIXLog::Thread);
1894 LLDB_LOG(log, "tid: {0}", thread.GetID());
1895
1896 // Before we do the resume below, first check if we have a pending stop
1897 // notification that is currently waiting for all threads to stop. This is
1898 // potentially a buggy situation since we're ostensibly waiting for threads
1899 // to stop before we send out the pending notification, and here we are
1900 // resuming one before we send out the pending stop notification.
1902 LLDB_LOG(log,
1903 "about to resume tid {0} per explicit request but we have a "
1904 "pending stop notification (tid {1}) that is actively "
1905 "waiting for this thread to stop. Valid sequence of events?",
1906 thread.GetID(), m_pending_notification_tid);
1907 }
1908
1909 // Request a resume. We expect this to be synchronous and the system to
1910 // reflect it is running after this completes.
1911 switch (state) {
1912 case eStateRunning: {
1913 Status resume_result = thread.Resume(signo);
1914 if (resume_result.Success())
1915 SetState(eStateRunning, true);
1916 return resume_result;
1917 }
1918 case eStateStepping: {
1919 Status step_result = thread.SingleStep(signo);
1920 if (step_result.Success())
1921 SetState(eStateRunning, true);
1922 return step_result;
1923 }
1924 default:
1925 LLDB_LOG(log, "Unhandled state {0}.", state);
1926 llvm_unreachable("Unhandled state for resume");
1927 }
1928}
1929
1930//===----------------------------------------------------------------------===//
1931
1933 Log *const log = GetLog(POSIXLog::Thread);
1934 LLDB_LOG(log, "about to process event: (triggering_tid: {0})",
1935 triggering_tid);
1936
1937 m_pending_notification_tid = triggering_tid;
1938
1939 // Request a stop for all the thread stops that need to be stopped and are
1940 // not already known to be stopped.
1941 for (const auto &thread : m_threads) {
1942 if (StateIsRunningState(thread->GetState()))
1943 static_cast<NativeThreadLinux *>(thread.get())->RequestStop();
1944 }
1945
1947 LLDB_LOG(log, "event processing done");
1948}
1949
1952 return; // No pending notification. Nothing to do.
1953
1954 for (const auto &thread_sp : m_threads) {
1955 if (StateIsRunningState(thread_sp->GetState()))
1956 return; // Some threads are still running. Don't signal yet.
1957 }
1958
1959 // We have a pending notification and all threads have stopped.
1961
1962 // Clear any temporary breakpoints we used to implement software single
1963 // stepping.
1964 for (const auto &thread_info : m_threads_stepping_with_breakpoint) {
1965 for (auto &&bp_addr : thread_info.second) {
1966 Status error = RemoveBreakpoint(bp_addr);
1967 if (error.Fail())
1968 LLDB_LOG(log, "pid = {0} remove stepping breakpoint: {1}",
1969 thread_info.first, error);
1970 }
1971 }
1973
1974 // Notify the delegate about the stop
1978}
1979
1981 Log *const log = GetLog(POSIXLog::Thread);
1982 LLDB_LOG(log, "tid: {0}", thread.GetID());
1983
1985 StateIsRunningState(thread.GetState())) {
1986 // We will need to wait for this new thread to stop as well before firing
1987 // the notification.
1988 thread.RequestStop();
1989 }
1990}
1991
1992// Wrapper for ptrace to catch errors and log calls. Note that ptrace sets
1993// errno on error because -1 can be a valid result (i.e. for PTRACE_PEEK*)
1995 void *data, size_t data_size,
1996 long *result) {
1997 Status error;
1998 long int ret;
1999
2000 Log *log = GetLog(POSIXLog::Ptrace);
2001
2002 PtraceDisplayBytes(req, data, data_size);
2003
2004 errno = 0;
2005 if (req == PTRACE_GETREGSET || req == PTRACE_SETREGSET)
2006 ret = ptrace(static_cast<__ptrace_request>(req), static_cast<::pid_t>(pid),
2007 *(unsigned int *)addr, data);
2008 else
2009 ret = ptrace(static_cast<__ptrace_request>(req), static_cast<::pid_t>(pid),
2010 addr, data);
2011
2012 if (ret == -1)
2014
2015 if (result)
2016 *result = ret;
2017
2018 LLDB_LOG(log, "ptrace({0}, {1}, {2}, {3}, {4})={5:x}", req, pid, addr, data,
2019 data_size, ret);
2020
2021 PtraceDisplayBytes(req, data, data_size);
2022
2023 if (error.Fail())
2024 LLDB_LOG(log, "ptrace() failed: {0}", error);
2025
2026 return error;
2027}
2028
2029llvm::Expected<TraceSupportedResponse> NativeProcessLinux::TraceSupported() {
2031 return TraceSupportedResponse{"intel-pt", "Intel Processor Trace"};
2033}
2034
2035Error NativeProcessLinux::TraceStart(StringRef json_request, StringRef type) {
2036 if (type == "intel-pt") {
2037 if (Expected<TraceIntelPTStartRequest> request =
2038 json::parse<TraceIntelPTStartRequest>(json_request,
2039 "TraceIntelPTStartRequest")) {
2040 return m_intel_pt_collector.TraceStart(*request);
2041 } else
2042 return request.takeError();
2043 }
2044
2045 return NativeProcessProtocol::TraceStart(json_request, type);
2046}
2047
2049 if (request.type == "intel-pt")
2050 return m_intel_pt_collector.TraceStop(request);
2051 return NativeProcessProtocol::TraceStop(request);
2052}
2053
2054Expected<json::Value> NativeProcessLinux::TraceGetState(StringRef type) {
2055 if (type == "intel-pt")
2056 return m_intel_pt_collector.GetState();
2058}
2059
2060Expected<std::vector<uint8_t>> NativeProcessLinux::TraceGetBinaryData(
2061 const TraceGetBinaryDataRequest &request) {
2062 if (request.type == "intel-pt")
2063 return m_intel_pt_collector.GetBinaryData(request);
2065}
static llvm::raw_ostream & error(Stream &strm)
#define PROT_READ
#define PROT_WRITE
#define PROT_NONE
#define PROT_EXEC
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition Log.h:369
#define LLDB_LOG_ERROR(log, error,...)
Definition Log.h:392
#define LLDB_LOGV(log,...)
Definition Log.h:383
static std::optional< std::pair< lldb::pid_t, WaitStatus > > WaitPid()
static constexpr unsigned k_ptrace_word_size
static Status EnsureFDFlags(int fd, int flags)
static void MaybeLogLaunchInfo(const ProcessLaunchInfo &info)
#define TRAP_HWBKPT
static void PtraceDisplayBytes(int &req, void *data, size_t data_size)
static Status EnsureFDFlags(int fd, int flags)
static llvm::Error AddPtraceScopeNote(llvm::Error original_error)
#define HWCAP2_MTE
static void DisplayBytes(StreamString &s, void *bytes, uint32_t count)
static bool ProcessVmReadvSupported()
#define MAP_PRIVATE
int __ptrace_request
Definition Ptrace.h:17
#define DEBUG_PTRACE_MAXBYTES
Definition Ptrace.h:20
#define PTRACE_SETREGSET
Definition Ptrace.h:39
#define PTRACE_SETREGS
Definition Ptrace.h:27
#define PTRACE_SETFPREGS
Definition Ptrace.h:33
#define PTRACE_GETREGSET
Definition Ptrace.h:36
ssize_t process_vm_readv(::pid_t pid, const struct iovec *local_iov, unsigned long liovcnt, const struct iovec *remote_iov, unsigned long riovcnt, unsigned long flags)
Definition LibcGlue.cpp:18
An architecture specification class.
Definition ArchSpec.h:31
const char ** GetConstArgumentVector() const
Gets the argument vector.
Definition Args.cpp:289
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
A file utility class.
Definition FileSpec.h:57
const ConstString & GetFilename() const
Filename string const get accessor.
Definition FileSpec.h:251
void Clear()
Clears the object state.
Definition FileSpec.cpp:259
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
static FileSystem & Instance()
lldb::pid_t GetProcessId() const
static bool FindProcessThreads(const lldb::pid_t pid, TidMap &tids_to_attach)
std::map< lldb::pid_t, bool > TidMap
Definition Host.h:179
static const char * GetSignalAsCString(int signo)
SignalHandleUP RegisterSignal(int signo, const Callback &callback, Status &error)
void SetMapped(OptionalBool val)
void SetReadable(OptionalBool val)
void SetExecutable(OptionalBool val)
void SetWritable(OptionalBool val)
Range< lldb::addr_t, lldb::addr_t > TagRange
Abstract class that extends NativeProcessProtocol with ELF specific logic.
NativeProcessProtocol(lldb::pid_t pid, int terminal_fd, NativeDelegate &delegate)
void NotifyDidExec() override
Notify the delegate that an exec occurred.
virtual llvm::Expected< TraceSupportedResponse > TraceSupported()
Get the processor tracing type supported for this process.
virtual llvm::Expected< std::vector< uint8_t > > TraceGetBinaryData(const TraceGetBinaryDataRequest &request)
Get binary data given a trace technology and a data identifier.
virtual llvm::Error TraceStop(const TraceStopRequest &request)
Stop tracing a live process or its threads.
Status SetSoftwareBreakpoint(lldb::addr_t addr, uint32_t size_hint)
virtual llvm::Expected< llvm::json::Value > TraceGetState(llvm::StringRef type)
Get the current tracing state of the process and its threads.
void SetState(lldb::StateType state, bool notify_delegates=true)
NativeThreadProtocol * GetThreadByID(lldb::tid_t tid)
std::vector< std::unique_ptr< NativeThreadProtocol > > m_threads
virtual bool SetExitStatus(WaitStatus status, bool bNotifyStateChange)
virtual Status RemoveBreakpoint(lldb::addr_t addr, bool hardware=false)
void FixupBreakpointPCAsNeeded(NativeThreadProtocol &thread)
Extension
Extension flag constants, returned by Manager::GetSupportedExtensions() and passed to SetEnabledExten...
virtual Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size)
virtual llvm::Expected< llvm::ArrayRef< uint8_t > > GetSoftwareBreakpointTrapOpcode(size_t size_hint)
virtual llvm::Error TraceStart(llvm::StringRef json_params, llvm::StringRef type)
Start tracing a process or its threads.
virtual Status RemoveHardwareBreakpoint(lldb::addr_t addr)
std::unordered_map< lldb::addr_t, SoftwareBreakpoint > m_software_breakpoints
std::map< lldb::tid_t, std::vector< lldb::addr_t > > m_threads_stepping_with_breakpoint
lldb::addr_t ReadRegisterAsUnsigned(uint32_t reg, lldb::addr_t fail_value)
virtual Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)=0
lldb::addr_t GetPC(lldb::addr_t fail_value=LLDB_INVALID_ADDRESS)
virtual Status ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp)=0
const FileAction * GetFileActionForFD(int fd) const
HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info, Status &error) override
int ReleasePrimaryFileDescriptor()
Release the primary file descriptor.
const ResumeAction * GetActionForThread(lldb::tid_t tid, bool default_ok) const
Definition Debug.h:74
An error handling class.
Definition Status.h:118
static Status FromErrno()
Set the current error to errno.
Definition Status.cpp:300
Status Clone() const
Don't call this function in new code.
Definition Status.h:174
ValueType GetError() const
Access the error value.
Definition Status.cpp:222
llvm::Error ToError() const
FIXME: Replace all uses with takeError() instead.
Definition Status.cpp:139
static Status FromErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Definition Status.cpp:106
static Status FromErrorString(const char *str)
Definition Status.h:141
bool Fail() const
Test for error condition.
Definition Status.cpp:294
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition Status.cpp:195
static Status FromError(llvm::Error error)
Avoid using this in new code. Migrate APIs to llvm::Expected instead.
Definition Status.cpp:137
bool Success() const
Test for success condition.
Definition Status.cpp:304
const char * GetData() const
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition Stream.cpp:134
llvm::Expected< std::unique_ptr< NativeProcessProtocol > > Attach(lldb::pid_t pid, NativeDelegate &native_delegate) override
Attach to an existing process.
llvm::SmallPtrSet< NativeProcessLinux *, 2 > m_processes
Extension GetSupportedExtensions() const override
Get the bitmask of extensions supported by this process plugin.
llvm::Expected< std::unique_ptr< NativeProcessProtocol > > Launch(ProcessLaunchInfo &launch_info, NativeDelegate &native_delegate) override
Launch a process for debugging.
llvm::Expected< lldb::addr_t > AllocateMemory(size_t size, uint32_t permissions) override
llvm::Expected< std::vector< uint8_t > > TraceGetBinaryData(const TraceGetBinaryDataRequest &request) override
Get binary data given a trace technology and a data identifier.
NativeThreadLinux * GetThreadByID(lldb::tid_t id)
llvm::Error DeallocateMemory(lldb::addr_t addr) override
Status GetFileLoadAddress(const llvm::StringRef &file_name, lldb::addr_t &load_addr) override
Status NotifyTracersOfNewThread(lldb::tid_t tid)
Start tracing a new thread if process tracing is enabled.
const ArchSpec & GetArchitecture() const override
Status GetEventMessage(lldb::tid_t tid, unsigned long *message)
Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG) corresponding to the given thread ID...
IntelPTCollector m_intel_pt_collector
Manages Intel PT process and thread traces.
llvm::Error TraceStart(llvm::StringRef json_request, llvm::StringRef type) override
Tracing These methods implement the jLLDBTrace packets.
bool MonitorClone(NativeThreadLinux &parent, lldb::pid_t child_pid, int event)
llvm::DenseMap< lldb::addr_t, lldb::addr_t > m_allocated_memory
Inferior memory (allocated by us) and its size.
Status Interrupt() override
Tells a process to interrupt all operations as if by a Ctrl-C.
std::vector< std::pair< MemoryRegionInfo, FileSpec > > m_mem_region_cache
llvm::Expected< llvm::ArrayRef< uint8_t > > GetSoftwareBreakpointTrapOpcode(size_t size_hint) override
void NotifyTracersProcessWillResume() override
Notify tracers that the target process will resume.
void MonitorSIGTRAP(const siginfo_t &info, NativeThreadLinux &thread)
Status SetBreakpoint(lldb::addr_t addr, uint32_t size, bool hardware) override
llvm::Expected< TraceSupportedResponse > TraceSupported() override
Get the processor tracing type supported for this process.
void MonitorWatchpoint(NativeThreadLinux &thread, uint32_t wp_index)
bool TryHandleWaitStatus(lldb::pid_t pid, WaitStatus status)
llvm::Error TraceStop(const TraceStopRequest &request) override
Stop tracing a live process or its threads.
Status ReadMemory(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read) override
Status Resume(const ResumeActionList &resume_actions) override
llvm::Expected< llvm::json::Value > TraceGetState(llvm::StringRef type) override
Get the current tracing state of the process and its threads.
Status RemoveBreakpoint(lldb::addr_t addr, bool hardware=false) override
NativeProcessLinux(::pid_t pid, int terminal_fd, NativeDelegate &delegate, const ArchSpec &arch, Manager &manager, llvm::ArrayRef<::pid_t > tids)
Status NotifyTracersOfThreadDestroyed(lldb::tid_t tid)
Stop tracing threads upon a destroy event.
void NotifyTracersProcessDidStop() override
Notify tracers that the target process just stopped.
Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size, size_t &bytes_written) override
static Status SetDefaultPtraceOpts(const lldb::pid_t)
void MonitorSignal(const siginfo_t &info, NativeThreadLinux &thread)
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 WriteMemoryTags(int32_t type, lldb::addr_t addr, size_t len, const std::vector< uint8_t > &tags) override
Status ReadMemoryTags(int32_t type, lldb::addr_t addr, size_t len, std::vector< uint8_t > &tags) override
Status ResumeThread(NativeThreadLinux &thread, lldb::StateType state, int signo)
Status GetMemoryRegionInfo(lldb::addr_t load_addr, MemoryRegionInfo &range_info) override
NativeThreadLinux & AddThread(lldb::tid_t thread_id, bool resume)
Create a new thread.
static llvm::Expected< std::vector<::pid_t > > Attach(::pid_t pid)
llvm::Expected< uint64_t > Syscall(llvm::ArrayRef< uint64_t > args)
Status Signal(int signo) override
Sends a process a UNIX signal signal.
Status GetLoadedModuleFileSpec(const char *module_path, FileSpec &file_spec) override
void MonitorCallback(NativeThreadLinux &thread, WaitStatus status)
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.
virtual std::optional< MmapData > GetMmapData()
Return the architecture-specific data needed to make mmap syscalls, if they are supported.
static llvm::Expected< ArchSpec > DetermineArchitecture(lldb::tid_t tid)
virtual std::optional< SyscallData > GetSyscallData()
Return architecture-specific data needed to make inferior syscalls, if they are supported.
NativeRegisterContextLinux & GetRegisterContext() override
void SetStoppedByFork(bool is_vfork, lldb::pid_t child_pid)
#define LLDB_INVALID_SIGNAL_NUMBER
#define LLDB_INVALID_THREAD_ID
#define LLDB_INVALID_INDEX32
#define UNUSED_IF_ASSERT_DISABLED(x)
#define LLDB_INVALID_ADDRESS
#define LLDB_INVALID_PROCESS_ID
llvm::Expected< int > GetPtraceScope()
Definition Procfs.cpp:74
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition Log.h:332
std::optional< lldb::pid_t > getPIDForTID(lldb::pid_t tid)
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getProcFile(::pid_t pid, ::pid_t tid, const llvm::Twine &file)
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
bool StateIsRunningState(lldb::StateType state)
Check if a state represents a state where the process or thread is running.
Definition State.cpp:68
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition State.cpp:14
MainLoopPosix MainLoop
Definition MainLoop.h:20
std::function< bool(llvm::Expected< MemoryRegionInfo >)> LinuxMapCallback
void ParseLinuxMapRegions(llvm::StringRef linux_map, LinuxMapCallback const &callback)
void ParseLinuxSMapRegions(llvm::StringRef linux_smap, LinuxMapCallback const &callback)
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.
@ eErrorTypePOSIX
POSIX error codes.
uint64_t pid_t
Definition lldb-types.h:83
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
uint64_t addr_t
Definition lldb-types.h:80
uint64_t tid_t
Definition lldb-types.h:84
bool Contains(BaseType r) const
Definition RangeMap.h:93
BaseType GetRangeBase() const
Definition RangeMap.h:45
void SetRangeEnd(BaseType end)
Definition RangeMap.h:80
SizeType GetByteSize() const
Definition RangeMap.h:87
void SetRangeBase(BaseType b)
Set the start value for the range, and keep the same size.
Definition RangeMap.h:48
void SetByteSize(SizeType s)
Definition RangeMap.h:89
lldb::StateType state
Definition Debug.h:23
jLLDBTraceGetBinaryData gdb-remote packet
std::string type
Tracing technology name, e.g. intel-pt, arm-coresight.
jLLDBTraceStop gdb-remote packet
std::string type
Tracing technology name, e.g. intel-pt, arm-coresight.
jLLDBTraceSupported gdb-remote packet
static WaitStatus Decode(int wstatus)
llvm::ArrayRef< uint32_t > Args
Registers used for syscall arguments.
#define SIGSTOP
#define O_NONBLOCK
#define SIGTRAP
#define SIGKILL