Bug Summary

File:lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp
Warning:line 140, column 5
2nd function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name NativeProcessLinux.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -isystem /usr/include/libxml2 -D HAVE_ROUND -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/lldb/source/Plugins/Process/Linux -I /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/lldb/source/Plugins/Process/Linux -I /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/lldb/include -I tools/lldb/include -I include -I /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/llvm/include -I /usr/include/python3.9 -I /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/clang/include -I tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/lldb/source -I tools/lldb/source -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-01-19-134126-35450-1 -x c++ /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp
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
9#include "NativeProcessLinux.h"
10
11#include <cerrno>
12#include <cstdint>
13#include <cstring>
14#include <unistd.h>
15
16#include <fstream>
17#include <mutex>
18#include <sstream>
19#include <string>
20#include <unordered_map>
21
22#include "NativeThreadLinux.h"
23#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
24#include "Plugins/Process/Utility/LinuxProcMaps.h"
25#include "Procfs.h"
26#include "lldb/Core/ModuleSpec.h"
27#include "lldb/Host/Host.h"
28#include "lldb/Host/HostProcess.h"
29#include "lldb/Host/ProcessLaunchInfo.h"
30#include "lldb/Host/PseudoTerminal.h"
31#include "lldb/Host/ThreadLauncher.h"
32#include "lldb/Host/common/NativeRegisterContext.h"
33#include "lldb/Host/linux/Host.h"
34#include "lldb/Host/linux/Ptrace.h"
35#include "lldb/Host/linux/Uio.h"
36#include "lldb/Host/posix/ProcessLauncherPosixFork.h"
37#include "lldb/Symbol/ObjectFile.h"
38#include "lldb/Target/Process.h"
39#include "lldb/Target/Target.h"
40#include "lldb/Utility/LLDBAssert.h"
41#include "lldb/Utility/State.h"
42#include "lldb/Utility/Status.h"
43#include "lldb/Utility/StringExtractor.h"
44#include "llvm/ADT/ScopeExit.h"
45#include "llvm/Support/Errno.h"
46#include "llvm/Support/FileSystem.h"
47#include "llvm/Support/Threading.h"
48
49#include <linux/unistd.h>
50#include <sys/socket.h>
51#include <sys/syscall.h>
52#include <sys/types.h>
53#include <sys/user.h>
54#include <sys/wait.h>
55
56#ifdef __aarch64__
57#include <asm/hwcap.h>
58#include <sys/auxv.h>
59#endif
60
61// Support hardware breakpoints in case it has not been defined
62#ifndef TRAP_HWBKPTTRAP_HWBKPT
63#define TRAP_HWBKPTTRAP_HWBKPT 4
64#endif
65
66#ifndef HWCAP2_MTE(1 << 18)
67#define HWCAP2_MTE(1 << 18) (1 << 18)
68#endif
69
70using namespace lldb;
71using namespace lldb_private;
72using namespace lldb_private::process_linux;
73using namespace llvm;
74
75// Private bits we only need internally.
76
77static bool ProcessVmReadvSupported() {
78 static bool is_supported;
79 static llvm::once_flag flag;
80
81 llvm::call_once(flag, [] {
82 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
83
84 uint32_t source = 0x47424742;
85 uint32_t dest = 0;
86
87 struct iovec local, remote;
88 remote.iov_base = &source;
89 local.iov_base = &dest;
90 remote.iov_len = local.iov_len = sizeof source;
91
92 // We shall try if cross-process-memory reads work by attempting to read a
93 // value from our own process.
94 ssize_t res = process_vm_readv(getpid(), &local, 1, &remote, 1, 0);
95 is_supported = (res == sizeof(source) && source == dest);
96 if (is_supported)
97 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "Detected kernel support for process_vm_readv syscall. "
"Fast memory reads enabled."); } while (0)
98 "Detected kernel support for process_vm_readv syscall. "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "Detected kernel support for process_vm_readv syscall. "
"Fast memory reads enabled."); } while (0)
99 "Fast memory reads enabled.")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "Detected kernel support for process_vm_readv syscall. "
"Fast memory reads enabled."); } while (0);
100 else
101 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "syscall process_vm_readv failed (error: {0}). Fast memory "
"reads disabled.", llvm::sys::StrError()); } while (0)
102 "syscall process_vm_readv failed (error: {0}). Fast memory "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "syscall process_vm_readv failed (error: {0}). Fast memory "
"reads disabled.", llvm::sys::StrError()); } while (0)
103 "reads disabled.",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "syscall process_vm_readv failed (error: {0}). Fast memory "
"reads disabled.", llvm::sys::StrError()); } while (0)
104 llvm::sys::StrError())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "syscall process_vm_readv failed (error: {0}). Fast memory "
"reads disabled.", llvm::sys::StrError()); } while (0);
105 });
106
107 return is_supported;
108}
109
110static void MaybeLogLaunchInfo(const ProcessLaunchInfo &info) {
111 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
112 if (!log)
113 return;
114
115 if (const FileAction *action = info.GetFileActionForFD(STDIN_FILENO0))
116 LLDB_LOG(log, "setting STDIN to '{0}'", action->GetFileSpec())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "setting STDIN to '{0}'", action->GetFileSpec(
)); } while (0);
117 else
118 LLDB_LOG(log, "leaving STDIN as is")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "leaving STDIN as is"); } while (0);
119
120 if (const FileAction *action = info.GetFileActionForFD(STDOUT_FILENO1))
121 LLDB_LOG(log, "setting STDOUT to '{0}'", action->GetFileSpec())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "setting STDOUT to '{0}'", action->GetFileSpec
()); } while (0);
122 else
123 LLDB_LOG(log, "leaving STDOUT as is")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "leaving STDOUT as is"); } while (0);
124
125 if (const FileAction *action = info.GetFileActionForFD(STDERR_FILENO2))
126 LLDB_LOG(log, "setting STDERR to '{0}'", action->GetFileSpec())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "setting STDERR to '{0}'", action->GetFileSpec
()); } while (0);
127 else
128 LLDB_LOG(log, "leaving STDERR as is")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "leaving STDERR as is"); } while (0);
129
130 int i = 0;
131 for (const char **args = info.GetArguments().GetConstArgumentVector(); *args;
132 ++args, ++i)
133 LLDB_LOG(log, "arg {0}: '{1}'", i, *args)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "arg {0}: '{1}'", i, *args); } while (0);
134}
135
136static void DisplayBytes(StreamString &s, void *bytes, uint32_t count) {
137 uint8_t *ptr = (uint8_t *)bytes;
138 const uint32_t loop_count = std::min<uint32_t>(DEBUG_PTRACE_MAXBYTES20, count);
139 for (uint32_t i = 0; i < loop_count; i++) {
14
←
Loop condition is true. Entering loop body
→
15
←
Loop condition is true. Entering loop body
→
140 s.Printf("[%x]", *ptr);
16
←
2nd function call argument is an uninitialized value
141 ptr++;
142 }
143}
144
145static void PtraceDisplayBytes(int &req, void *data, size_t data_size) {
146 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE(1u << 5)));
147 if (!log
10.1
'log' is non-null
)
11
←
Taking false branch
→
148 return;
149 StreamString buf;
150
151 switch (req) {
12
←
Control jumps to 'case PTRACE_SETSIGINFO:' at line 177
→
152 case PTRACE_POKETEXT: {
153 DisplayBytes(buf, &data, 8);
154 LLDB_LOGV(log, "PTRACE_POKETEXT {0}", buf.GetData())do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp", __func__
, "PTRACE_POKETEXT {0}", buf.GetData()); } while (0);
155 break;
156 }
157 case PTRACE_POKEDATA: {
158 DisplayBytes(buf, &data, 8);
159 LLDB_LOGV(log, "PTRACE_POKEDATA {0}", buf.GetData())do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp", __func__
, "PTRACE_POKEDATA {0}", buf.GetData()); } while (0);
160 break;
161 }
162 case PTRACE_POKEUSER: {
163 DisplayBytes(buf, &data, 8);
164 LLDB_LOGV(log, "PTRACE_POKEUSER {0}", buf.GetData())do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp", __func__
, "PTRACE_POKEUSER {0}", buf.GetData()); } while (0);
165 break;
166 }
167 case PTRACE_SETREGS13: {
168 DisplayBytes(buf, data, data_size);
169 LLDB_LOGV(log, "PTRACE_SETREGS {0}", buf.GetData())do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp", __func__
, "PTRACE_SETREGS {0}", buf.GetData()); } while (0);
170 break;
171 }
172 case PTRACE_SETFPREGS15: {
173 DisplayBytes(buf, data, data_size);
174 LLDB_LOGV(log, "PTRACE_SETFPREGS {0}", buf.GetData())do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp", __func__
, "PTRACE_SETFPREGS {0}", buf.GetData()); } while (0);
175 break;
176 }
177 case PTRACE_SETSIGINFO: {
178 DisplayBytes(buf, data, sizeof(siginfo_t));
13
←
Calling 'DisplayBytes'
→
179 LLDB_LOGV(log, "PTRACE_SETSIGINFO {0}", buf.GetData())do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp", __func__
, "PTRACE_SETSIGINFO {0}", buf.GetData()); } while (0);
180 break;
181 }
182 case PTRACE_SETREGSETPTRACE_SETREGSET: {
183 // Extract iov_base from data, which is a pointer to the struct iovec
184 DisplayBytes(buf, *(void **)data, data_size);
185 LLDB_LOGV(log, "PTRACE_SETREGSET {0}", buf.GetData())do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp", __func__
, "PTRACE_SETREGSET {0}", buf.GetData()); } while (0);
186 break;
187 }
188 default: {}
189 }
190}
191
192static constexpr unsigned k_ptrace_word_size = sizeof(void *);
193static_assert(sizeof(long) >= k_ptrace_word_size,
194 "Size of long must be larger than ptrace word size");
195
196// Simple helper function to ensure flags are enabled on the given file
197// descriptor.
198static Status EnsureFDFlags(int fd, int flags) {
199 Status error;
200
201 int status = fcntl(fd, F_GETFL3);
202 if (status == -1) {
203 error.SetErrorToErrno();
204 return error;
205 }
206
207 if (fcntl(fd, F_SETFL4, status | flags) == -1) {
208 error.SetErrorToErrno();
209 return error;
210 }
211
212 return error;
213}
214
215// Public Static Methods
216
217llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
218NativeProcessLinux::Factory::Launch(ProcessLaunchInfo &launch_info,
219 NativeDelegate &native_delegate,
220 MainLoop &mainloop) const {
221 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
222
223 MaybeLogLaunchInfo(launch_info);
224
225 Status status;
226 ::pid_t pid = ProcessLauncherPosixFork()
227 .LaunchProcess(launch_info, status)
228 .GetProcessId();
229 LLDB_LOG(log, "pid = {0:x}", pid)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid = {0:x}", pid); } while (0);
230 if (status.Fail()) {
231 LLDB_LOG(log, "failed to launch process: {0}", status)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "failed to launch process: {0}", status); } while
(0);
232 return status.ToError();
233 }
234
235 // Wait for the child process to trap on its call to execve.
236 int wstatus;
237 ::pid_t wpid = llvm::sys::RetryAfterSignal(-1, ::waitpid, pid, &wstatus, 0);
238 assert(wpid == pid)(static_cast <bool> (wpid == pid) ? void (0) : __assert_fail
("wpid == pid", "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, 238, __extension__ __PRETTY_FUNCTION__));
239 (void)wpid;
240 if (!WIFSTOPPED(wstatus)(((wstatus) & 0xff) == 0x7f)) {
241 LLDB_LOG(log, "Could not sync with inferior process: wstatus={1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "Could not sync with inferior process: wstatus={1}"
, WaitStatus::Decode(wstatus)); } while (0)
242 WaitStatus::Decode(wstatus))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "Could not sync with inferior process: wstatus={1}"
, WaitStatus::Decode(wstatus)); } while (0);
243 return llvm::make_error<StringError>("Could not sync with inferior process",
244 llvm::inconvertibleErrorCode());
245 }
246 LLDB_LOG(log, "inferior started, now in stopped state")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "inferior started, now in stopped state"); } while
(0);
247
248 ProcessInstanceInfo Info;
249 if (!Host::GetProcessInfo(pid, Info)) {
250 return llvm::make_error<StringError>("Cannot get process architecture",
251 llvm::inconvertibleErrorCode());
252 }
253
254 // Set the architecture to the exe architecture.
255 LLDB_LOG(log, "pid = {0:x}, detected architecture {1}", pid,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid = {0:x}, detected architecture {1}", pid, Info
.GetArchitecture().GetArchitectureName()); } while (0)
256 Info.GetArchitecture().GetArchitectureName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid = {0:x}, detected architecture {1}", pid, Info
.GetArchitecture().GetArchitectureName()); } while (0);
257
258 status = SetDefaultPtraceOpts(pid);
259 if (status.Fail()) {
260 LLDB_LOG(log, "failed to set default ptrace options: {0}", status)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "failed to set default ptrace options: {0}", status
); } while (0);
261 return status.ToError();
262 }
263
264 return std::unique_ptr<NativeProcessLinux>(new NativeProcessLinux(
265 pid, launch_info.GetPTY().ReleasePrimaryFileDescriptor(), native_delegate,
266 Info.GetArchitecture(), mainloop, {pid}));
267}
268
269llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
270NativeProcessLinux::Factory::Attach(
271 lldb::pid_t pid, NativeProcessProtocol::NativeDelegate &native_delegate,
272 MainLoop &mainloop) const {
273 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
274 LLDB_LOG(log, "pid = {0:x}", pid)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid = {0:x}", pid); } while (0);
275
276 // Retrieve the architecture for the running process.
277 ProcessInstanceInfo Info;
278 if (!Host::GetProcessInfo(pid, Info)) {
279 return llvm::make_error<StringError>("Cannot get process architecture",
280 llvm::inconvertibleErrorCode());
281 }
282
283 auto tids_or = NativeProcessLinux::Attach(pid);
284 if (!tids_or)
285 return tids_or.takeError();
286
287 return std::unique_ptr<NativeProcessLinux>(new NativeProcessLinux(
288 pid, -1, native_delegate, Info.GetArchitecture(), mainloop, *tids_or));
289}
290
291NativeProcessLinux::Extension
292NativeProcessLinux::Factory::GetSupportedExtensions() const {
293 NativeProcessLinux::Extension supported =
294 Extension::multiprocess | Extension::fork | Extension::vfork |
295 Extension::pass_signals | Extension::auxv | Extension::libraries_svr4 |
296 Extension::siginfo_read;
297
298#ifdef __aarch64__
299 // At this point we do not have a process so read auxv directly.
300 if ((getauxval(AT_HWCAP2) & HWCAP2_MTE(1 << 18)))
301 supported |= Extension::memory_tagging;
302#endif
303
304 return supported;
305}
306
307// Public Instance Methods
308
309NativeProcessLinux::NativeProcessLinux(::pid_t pid, int terminal_fd,
310 NativeDelegate &delegate,
311 const ArchSpec &arch, MainLoop &mainloop,
312 llvm::ArrayRef<::pid_t> tids)
313 : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch),
314 m_main_loop(mainloop), m_intel_pt_manager(pid) {
315 if (m_terminal_fd != -1) {
316 Status status = EnsureFDFlags(m_terminal_fd, O_NONBLOCK04000);
317 assert(status.Success())(static_cast <bool> (status.Success()) ? void (0) : __assert_fail
("status.Success()", "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, 317, __extension__ __PRETTY_FUNCTION__));
318 }
319
320 Status status;
321 m_sigchld_handle = mainloop.RegisterSignal(
322 SIGCHLD17, [this](MainLoopBase &) { SigchldHandler(); }, status);
323 assert(m_sigchld_handle && status.Success())(static_cast <bool> (m_sigchld_handle && status
.Success()) ? void (0) : __assert_fail ("m_sigchld_handle && status.Success()"
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
323, __extension__ __PRETTY_FUNCTION__));
324
325 for (const auto &tid : tids) {
326 NativeThreadLinux &thread = AddThread(tid, /*resume*/ false);
327 ThreadWasCreated(thread);
328 }
329
330 // Let our process instance know the thread has stopped.
331 SetCurrentThreadID(tids[0]);
332 SetState(StateType::eStateStopped, false);
333
334 // Proccess any signals we received before installing our handler
335 SigchldHandler();
336}
337
338llvm::Expected<std::vector<::pid_t>> NativeProcessLinux::Attach(::pid_t pid) {
339 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
340
341 Status status;
342 // Use a map to keep track of the threads which we have attached/need to
343 // attach.
344 Host::TidMap tids_to_attach;
345 while (Host::FindProcessThreads(pid, tids_to_attach)) {
346 for (Host::TidMap::iterator it = tids_to_attach.begin();
347 it != tids_to_attach.end();) {
348 if (it->second == false) {
349 lldb::tid_t tid = it->first;
350
351 // Attach to the requested process.
352 // An attach will cause the thread to stop with a SIGSTOP.
353 if ((status = PtraceWrapper(PTRACE_ATTACH, tid)).Fail()) {
354 // No such thread. The thread may have exited. More error handling
355 // may be needed.
356 if (status.GetError() == ESRCH3) {
357 it = tids_to_attach.erase(it);
358 continue;
359 }
360 return status.ToError();
361 }
362
363 int wpid =
364 llvm::sys::RetryAfterSignal(-1, ::waitpid, tid, nullptr, __WALL0x40000000);
365 // Need to use __WALL otherwise we receive an error with errno=ECHLD At
366 // this point we should have a thread stopped if waitpid succeeds.
367 if (wpid < 0) {
368 // No such thread. The thread may have exited. More error handling
369 // may be needed.
370 if (errno(*__errno_location ()) == ESRCH3) {
371 it = tids_to_attach.erase(it);
372 continue;
373 }
374 return llvm::errorCodeToError(
375 std::error_code(errno(*__errno_location ()), std::generic_category()));
376 }
377
378 if ((status = SetDefaultPtraceOpts(tid)).Fail())
379 return status.ToError();
380
381 LLDB_LOG(log, "adding tid = {0}", tid)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "adding tid = {0}", tid); } while (0);
382 it->second = true;
383 }
384
385 // move the loop forward
386 ++it;
387 }
388 }
389
390 size_t tid_count = tids_to_attach.size();
391 if (tid_count == 0)
392 return llvm::make_error<StringError>("No such process",
393 llvm::inconvertibleErrorCode());
394
395 std::vector<::pid_t> tids;
396 tids.reserve(tid_count);
397 for (const auto &p : tids_to_attach)
398 tids.push_back(p.first);
399 return std::move(tids);
400}
401
402Status NativeProcessLinux::SetDefaultPtraceOpts(lldb::pid_t pid) {
403 long ptrace_opts = 0;
404
405 // Have the child raise an event on exit. This is used to keep the child in
406 // limbo until it is destroyed.
407 ptrace_opts |= PTRACE_O_TRACEEXIT;
408
409 // Have the tracer trace threads which spawn in the inferior process.
410 ptrace_opts |= PTRACE_O_TRACECLONE;
411
412 // Have the tracer notify us before execve returns (needed to disable legacy
413 // SIGTRAP generation)
414 ptrace_opts |= PTRACE_O_TRACEEXEC;
415
416 // Have the tracer trace forked children.
417 ptrace_opts |= PTRACE_O_TRACEFORK;
418
419 // Have the tracer trace vforks.
420 ptrace_opts |= PTRACE_O_TRACEVFORK;
421
422 // Have the tracer trace vfork-done in order to restore breakpoints after
423 // the child finishes sharing memory.
424 ptrace_opts |= PTRACE_O_TRACEVFORKDONE;
425
426 return PtraceWrapper(PTRACE_SETOPTIONS, pid, nullptr, (void *)ptrace_opts);
427}
428
429// Handles all waitpid events from the inferior process.
430void NativeProcessLinux::MonitorCallback(NativeThreadLinux &thread,
431 WaitStatus status) {
432 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
433
434 // Certain activities differ based on whether the pid is the tid of the main
435 // thread.
436 const bool is_main_thread = (thread.GetID() == GetID());
437
438 // Handle when the thread exits.
439 if (status.type == WaitStatus::Exit || status.type == WaitStatus::Signal) {
440 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "got exit status({0}) , tid = {1} ({2} main thread), process "
"state = {3}", status, thread.GetID(), is_main_thread ? "is"
: "is not", GetState()); } while (0)
441 "got exit status({0}) , tid = {1} ({2} main thread), process "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "got exit status({0}) , tid = {1} ({2} main thread), process "
"state = {3}", status, thread.GetID(), is_main_thread ? "is"
: "is not", GetState()); } while (0)
442 "state = {3}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "got exit status({0}) , tid = {1} ({2} main thread), process "
"state = {3}", status, thread.GetID(), is_main_thread ? "is"
: "is not", GetState()); } while (0)
443 status, thread.GetID(), is_main_thread ? "is" : "is not",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "got exit status({0}) , tid = {1} ({2} main thread), process "
"state = {3}", status, thread.GetID(), is_main_thread ? "is"
: "is not", GetState()); } while (0)
444 GetState())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "got exit status({0}) , tid = {1} ({2} main thread), process "
"state = {3}", status, thread.GetID(), is_main_thread ? "is"
: "is not", GetState()); } while (0);
445
446 // This is a thread that exited. Ensure we're not tracking it anymore.
447 StopTrackingThread(thread);
448
449 if (is_main_thread) {
450 // The main thread exited. We're done monitoring. Report to delegate.
451 SetExitStatus(status, true);
452
453 // Notify delegate that our process has exited.
454 SetState(StateType::eStateExited, true);
455 }
456 return;
457 }
458
459 siginfo_t info;
460 const auto info_err = GetSignalInfo(thread.GetID(), &info);
461
462 // Get details on the signal raised.
463 if (info_err.Success()) {
464 // We have retrieved the signal info. Dispatch appropriately.
465 if (info.si_signo == SIGTRAP5)
466 MonitorSIGTRAP(info, thread);
467 else
468 MonitorSignal(info, thread);
469 } else {
470 if (info_err.GetError() == EINVAL22) {
471 // This is a group stop reception for this tid. We can reach here if we
472 // reinject SIGSTOP, SIGSTP, SIGTTIN or SIGTTOU into the tracee,
473 // triggering the group-stop mechanism. Normally receiving these would
474 // stop the process, pending a SIGCONT. Simulating this state in a
475 // debugger is hard and is generally not needed (one use case is
476 // debugging background task being managed by a shell). For general use,
477 // it is sufficient to stop the process in a signal-delivery stop which
478 // happens before the group stop. This done by MonitorSignal and works
479 // correctly for all signals.
480 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received a group stop for pid {0} tid {1}. Transparent "
"handling of group stops not supported, resuming the " "thread."
, GetID(), thread.GetID()); } while (0)
481 "received a group stop for pid {0} tid {1}. Transparent "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received a group stop for pid {0} tid {1}. Transparent "
"handling of group stops not supported, resuming the " "thread."
, GetID(), thread.GetID()); } while (0)
482 "handling of group stops not supported, resuming the "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received a group stop for pid {0} tid {1}. Transparent "
"handling of group stops not supported, resuming the " "thread."
, GetID(), thread.GetID()); } while (0)
483 "thread.",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received a group stop for pid {0} tid {1}. Transparent "
"handling of group stops not supported, resuming the " "thread."
, GetID(), thread.GetID()); } while (0)
484 GetID(), thread.GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received a group stop for pid {0} tid {1}. Transparent "
"handling of group stops not supported, resuming the " "thread."
, GetID(), thread.GetID()); } while (0);
485 ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER(2147483647));
486 } else {
487 // ptrace(GETSIGINFO) failed (but not due to group-stop).
488
489 // A return value of ESRCH means the thread/process has died in the mean
490 // time. This can (e.g.) happen when another thread does an exit_group(2)
491 // or the entire process get SIGKILLed.
492 // We can't do anything with this thread anymore, but we keep it around
493 // until we get the WIFEXITED event.
494
495 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "GetSignalInfo({0}) failed: {1}, status = {2}, main_thread = "
"{3}. Expecting WIFEXITED soon.", thread.GetID(), info_err, status
, is_main_thread); } while (0)
496 "GetSignalInfo({0}) failed: {1}, status = {2}, main_thread = "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "GetSignalInfo({0}) failed: {1}, status = {2}, main_thread = "
"{3}. Expecting WIFEXITED soon.", thread.GetID(), info_err, status
, is_main_thread); } while (0)
497 "{3}. Expecting WIFEXITED soon.",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "GetSignalInfo({0}) failed: {1}, status = {2}, main_thread = "
"{3}. Expecting WIFEXITED soon.", thread.GetID(), info_err, status
, is_main_thread); } while (0)
498 thread.GetID(), info_err, status, is_main_thread)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "GetSignalInfo({0}) failed: {1}, status = {2}, main_thread = "
"{3}. Expecting WIFEXITED soon.", thread.GetID(), info_err, status
, is_main_thread); } while (0);
499 }
500 }
501}
502
503void NativeProcessLinux::WaitForCloneNotification(::pid_t pid) {
504 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
505
506 // The PID is not tracked yet, let's wait for it to appear.
507 int status = -1;
508 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received clone event for pid {0}. pid not tracked yet, "
"waiting for it to appear...", pid); } while (0)
509 "received clone event for pid {0}. pid not tracked yet, "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received clone event for pid {0}. pid not tracked yet, "
"waiting for it to appear...", pid); } while (0)
510 "waiting for it to appear...",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received clone event for pid {0}. pid not tracked yet, "
"waiting for it to appear...", pid); } while (0)
511 pid)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received clone event for pid {0}. pid not tracked yet, "
"waiting for it to appear...", pid); } while (0);
512 ::pid_t wait_pid =
513 llvm::sys::RetryAfterSignal(-1, ::waitpid, pid, &status, __WALL0x40000000);
514
515 // It's theoretically possible to get other events if the entire process was
516 // SIGKILLed before we got a chance to check this. In that case, we'll just
517 // clean everything up when we get the process exit event.
518
519 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "waitpid({0}, &status, __WALL) => {1} (errno: {2}, status = {3})"
, pid, wait_pid, (*__errno_location ()), WaitStatus::Decode(status
)); } while (0)
520 "waitpid({0}, &status, __WALL) => {1} (errno: {2}, status = {3})",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "waitpid({0}, &status, __WALL) => {1} (errno: {2}, status = {3})"
, pid, wait_pid, (*__errno_location ()), WaitStatus::Decode(status
)); } while (0)
521 pid, wait_pid, errno, WaitStatus::Decode(status))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "waitpid({0}, &status, __WALL) => {1} (errno: {2}, status = {3})"
, pid, wait_pid, (*__errno_location ()), WaitStatus::Decode(status
)); } while (0);
522}
523
524void NativeProcessLinux::MonitorSIGTRAP(const siginfo_t &info,
525 NativeThreadLinux &thread) {
526 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
527 const bool is_main_thread = (thread.GetID() == GetID());
528
529 assert(info.si_signo == SIGTRAP && "Unexpected child signal!")(static_cast <bool> (info.si_signo == 5 && "Unexpected child signal!"
) ? void (0) : __assert_fail ("info.si_signo == SIGTRAP && \"Unexpected child signal!\""
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
529, __extension__ __PRETTY_FUNCTION__));
530
531 switch (info.si_code) {
532 case (SIGTRAP5 | (PTRACE_EVENT_FORK << 8)):
533 case (SIGTRAP5 | (PTRACE_EVENT_VFORK << 8)):
534 case (SIGTRAP5 | (PTRACE_EVENT_CLONE << 8)): {
535 // This can either mean a new thread or a new process spawned via
536 // clone(2) without SIGCHLD or CLONE_VFORK flag. Note that clone(2)
537 // can also cause PTRACE_EVENT_FORK and PTRACE_EVENT_VFORK if one
538 // of these flags are passed.
539
540 unsigned long event_message = 0;
541 if (GetEventMessage(thread.GetID(), &event_message).Fail()) {
542 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} received clone() event but GetEventMessage failed "
"so we don't know the new pid/tid", thread.GetID()); } while
(0)
543 "pid {0} received clone() event but GetEventMessage failed "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} received clone() event but GetEventMessage failed "
"so we don't know the new pid/tid", thread.GetID()); } while
(0)
544 "so we don't know the new pid/tid",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} received clone() event but GetEventMessage failed "
"so we don't know the new pid/tid", thread.GetID()); } while
(0)
545 thread.GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} received clone() event but GetEventMessage failed "
"so we don't know the new pid/tid", thread.GetID()); } while
(0);
546 ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER(2147483647));
547 } else {
548 MonitorClone(thread, event_message, info.si_code >> 8);
549 }
550
551 break;
552 }
553
554 case (SIGTRAP5 | (PTRACE_EVENT_EXEC << 8)): {
555 LLDB_LOG(log, "received exec event, code = {0}", info.si_code ^ SIGTRAP)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received exec event, code = {0}", info.si_code ^
5); } while (0);
556
557 // Exec clears any pending notifications.
558 m_pending_notification_tid = LLDB_INVALID_THREAD_ID0;
559
560 // Remove all but the main thread here. Linux fork creates a new process
561 // which only copies the main thread.
562 LLDB_LOG(log, "exec received, stop tracking all but main thread")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "exec received, stop tracking all but main thread"
); } while (0);
563
564 llvm::erase_if(m_threads, [&](std::unique_ptr<NativeThreadProtocol> &t) {
565 return t->GetID() != GetID();
566 });
567 assert(m_threads.size() == 1)(static_cast <bool> (m_threads.size() == 1) ? void (0) :
__assert_fail ("m_threads.size() == 1", "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, 567, __extension__ __PRETTY_FUNCTION__));
568 auto *main_thread = static_cast<NativeThreadLinux *>(m_threads[0].get());
569
570 SetCurrentThreadID(main_thread->GetID());
571 main_thread->SetStoppedByExec();
572
573 // Tell coordinator about about the "new" (since exec) stopped main thread.
574 ThreadWasCreated(*main_thread);
575
576 // Let our delegate know we have just exec'd.
577 NotifyDidExec();
578
579 // Let the process know we're stopped.
580 StopRunningThreads(main_thread->GetID());
581
582 break;
583 }
584
585 case (SIGTRAP5 | (PTRACE_EVENT_EXIT << 8)): {
586 // The inferior process or one of its threads is about to exit. We don't
587 // want to do anything with the thread so we just resume it. In case we
588 // want to implement "break on thread exit" functionality, we would need to
589 // stop here.
590
591 unsigned long data = 0;
592 if (GetEventMessage(thread.GetID(), &data).Fail())
593 data = -1;
594
595 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received PTRACE_EVENT_EXIT, data = {0:x}, WIFEXITED={1}, "
"WIFSIGNALED={2}, pid = {3}, main_thread = {4}", data, (((data
) & 0x7f) == 0), (((signed char) (((data) & 0x7f) + 1
) >> 1) > 0), thread.GetID(), is_main_thread); } while
(0)
596 "received PTRACE_EVENT_EXIT, data = {0:x}, WIFEXITED={1}, "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received PTRACE_EVENT_EXIT, data = {0:x}, WIFEXITED={1}, "
"WIFSIGNALED={2}, pid = {3}, main_thread = {4}", data, (((data
) & 0x7f) == 0), (((signed char) (((data) & 0x7f) + 1
) >> 1) > 0), thread.GetID(), is_main_thread); } while
(0)
597 "WIFSIGNALED={2}, pid = {3}, main_thread = {4}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received PTRACE_EVENT_EXIT, data = {0:x}, WIFEXITED={1}, "
"WIFSIGNALED={2}, pid = {3}, main_thread = {4}", data, (((data
) & 0x7f) == 0), (((signed char) (((data) & 0x7f) + 1
) >> 1) > 0), thread.GetID(), is_main_thread); } while
(0)
598 data, WIFEXITED(data), WIFSIGNALED(data), thread.GetID(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received PTRACE_EVENT_EXIT, data = {0:x}, WIFEXITED={1}, "
"WIFSIGNALED={2}, pid = {3}, main_thread = {4}", data, (((data
) & 0x7f) == 0), (((signed char) (((data) & 0x7f) + 1
) >> 1) > 0), thread.GetID(), is_main_thread); } while
(0)
599 is_main_thread)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received PTRACE_EVENT_EXIT, data = {0:x}, WIFEXITED={1}, "
"WIFSIGNALED={2}, pid = {3}, main_thread = {4}", data, (((data
) & 0x7f) == 0), (((signed char) (((data) & 0x7f) + 1
) >> 1) > 0), thread.GetID(), is_main_thread); } while
(0);
600
601
602 StateType state = thread.GetState();
603 if (!StateIsRunningState(state)) {
604 // Due to a kernel bug, we may sometimes get this stop after the inferior
605 // gets a SIGKILL. This confuses our state tracking logic in
606 // ResumeThread(), since normally, we should not be receiving any ptrace
607 // events while the inferior is stopped. This makes sure that the
608 // inferior is resumed and exits normally.
609 state = eStateRunning;
610 }
611 ResumeThread(thread, state, LLDB_INVALID_SIGNAL_NUMBER(2147483647));
612
613 break;
614 }
615
616 case (SIGTRAP5 | (PTRACE_EVENT_VFORK_DONE << 8)): {
617 if (bool(m_enabled_extensions & Extension::vfork)) {
618 thread.SetStoppedByVForkDone();
619 StopRunningThreads(thread.GetID());
620 }
621 else
622 ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER(2147483647));
623 break;
624 }
625
626 case 0:
627 case TRAP_TRACETRAP_TRACE: // We receive this on single stepping.
628 case TRAP_HWBKPTTRAP_HWBKPT: // We receive this on watchpoint hit
629 {
630 // If a watchpoint was hit, report it
631 uint32_t wp_index;
632 Status error = thread.GetRegisterContext().GetWatchpointHitIndex(
633 wp_index, (uintptr_t)info.si_addr_sifields._sigfault.si_addr);
634 if (error.Fail())
635 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received error while checking for watchpoint hits, pid = "
"{0}, error = {1}", thread.GetID(), error); } while (0)
636 "received error while checking for watchpoint hits, pid = "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received error while checking for watchpoint hits, pid = "
"{0}, error = {1}", thread.GetID(), error); } while (0)
637 "{0}, error = {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received error while checking for watchpoint hits, pid = "
"{0}, error = {1}", thread.GetID(), error); } while (0)
638 thread.GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received error while checking for watchpoint hits, pid = "
"{0}, error = {1}", thread.GetID(), error); } while (0);
639 if (wp_index != LLDB_INVALID_INDEX32(4294967295U)) {
640 MonitorWatchpoint(thread, wp_index);
641 break;
642 }
643
644 // If a breakpoint was hit, report it
645 uint32_t bp_index;
646 error = thread.GetRegisterContext().GetHardwareBreakHitIndex(
647 bp_index, (uintptr_t)info.si_addr_sifields._sigfault.si_addr);
648 if (error.Fail())
649 LLDB_LOG(log, "received error while checking for hardware "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received error while checking for hardware " "breakpoint hits, pid = {0}, error = {1}"
, thread.GetID(), error); } while (0)
650 "breakpoint hits, pid = {0}, error = {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received error while checking for hardware " "breakpoint hits, pid = {0}, error = {1}"
, thread.GetID(), error); } while (0)
651 thread.GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received error while checking for hardware " "breakpoint hits, pid = {0}, error = {1}"
, thread.GetID(), error); } while (0);
652 if (bp_index != LLDB_INVALID_INDEX32(4294967295U)) {
653 MonitorBreakpoint(thread);
654 break;
655 }
656
657 // Otherwise, report step over
658 MonitorTrace(thread);
659 break;
660 }
661
662 case SI_KERNELSI_KERNEL:
663#if defined __mips__
664 // For mips there is no special signal for watchpoint So we check for
665 // watchpoint in kernel trap
666 {
667 // If a watchpoint was hit, report it
668 uint32_t wp_index;
669 Status error = thread.GetRegisterContext().GetWatchpointHitIndex(
670 wp_index, LLDB_INVALID_ADDRESS(18446744073709551615UL));
671 if (error.Fail())
672 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received error while checking for watchpoint hits, pid = "
"{0}, error = {1}", thread.GetID(), error); } while (0)
673 "received error while checking for watchpoint hits, pid = "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received error while checking for watchpoint hits, pid = "
"{0}, error = {1}", thread.GetID(), error); } while (0)
674 "{0}, error = {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received error while checking for watchpoint hits, pid = "
"{0}, error = {1}", thread.GetID(), error); } while (0)
675 thread.GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received error while checking for watchpoint hits, pid = "
"{0}, error = {1}", thread.GetID(), error); } while (0);
676 if (wp_index != LLDB_INVALID_INDEX32(4294967295U)) {
677 MonitorWatchpoint(thread, wp_index);
678 break;
679 }
680 }
681// NO BREAK
682#endif
683 case TRAP_BRKPTTRAP_BRKPT:
684 MonitorBreakpoint(thread);
685 break;
686
687 case SIGTRAP5:
688 case (SIGTRAP5 | 0x80):
689 LLDB_LOG(do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received unknown SIGTRAP stop event ({0}, pid {1} tid {2}, resuming"
, info.si_code, GetID(), thread.GetID()); } while (0)
690 log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received unknown SIGTRAP stop event ({0}, pid {1} tid {2}, resuming"
, info.si_code, GetID(), thread.GetID()); } while (0)
691 "received unknown SIGTRAP stop event ({0}, pid {1} tid {2}, resuming",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received unknown SIGTRAP stop event ({0}, pid {1} tid {2}, resuming"
, info.si_code, GetID(), thread.GetID()); } while (0)
692 info.si_code, GetID(), thread.GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received unknown SIGTRAP stop event ({0}, pid {1} tid {2}, resuming"
, info.si_code, GetID(), thread.GetID()); } while (0);
693
694 // Ignore these signals until we know more about them.
695 ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER(2147483647));
696 break;
697
698 default:
699 LLDB_LOG(log, "received unknown SIGTRAP stop event ({0}, pid {1} tid {2}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received unknown SIGTRAP stop event ({0}, pid {1} tid {2}"
, info.si_code, GetID(), thread.GetID()); } while (0)
700 info.si_code, GetID(), thread.GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received unknown SIGTRAP stop event ({0}, pid {1} tid {2}"
, info.si_code, GetID(), thread.GetID()); } while (0);
701 MonitorSignal(info, thread);
702 break;
703 }
704}
705
706void NativeProcessLinux::MonitorTrace(NativeThreadLinux &thread) {
707 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
708 LLDB_LOG(log, "received trace event, pid = {0}", thread.GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received trace event, pid = {0}", thread.GetID()
); } while (0);
709
710 // This thread is currently stopped.
711 thread.SetStoppedByTrace();
712
713 StopRunningThreads(thread.GetID());
714}
715
716void NativeProcessLinux::MonitorBreakpoint(NativeThreadLinux &thread) {
717 Log *log(
718 GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1) | LIBLLDB_LOG_BREAKPOINTS(1u << 5)));
719 LLDB_LOG(log, "received breakpoint event, pid = {0}", thread.GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received breakpoint event, pid = {0}", thread.GetID
()); } while (0);
720
721 // Mark the thread as stopped at breakpoint.
722 thread.SetStoppedByBreakpoint();
723 FixupBreakpointPCAsNeeded(thread);
724
725 if (m_threads_stepping_with_breakpoint.find(thread.GetID()) !=
726 m_threads_stepping_with_breakpoint.end())
727 thread.SetStoppedByTrace();
728
729 StopRunningThreads(thread.GetID());
730}
731
732void NativeProcessLinux::MonitorWatchpoint(NativeThreadLinux &thread,
733 uint32_t wp_index) {
734 Log *log(
735 GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1) | LIBLLDB_LOG_WATCHPOINTS(1u << 6)));
736 LLDB_LOG(log, "received watchpoint event, pid = {0}, wp_index = {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received watchpoint event, pid = {0}, wp_index = {1}"
, thread.GetID(), wp_index); } while (0)
737 thread.GetID(), wp_index)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received watchpoint event, pid = {0}, wp_index = {1}"
, thread.GetID(), wp_index); } while (0);
738
739 // Mark the thread as stopped at watchpoint. The address is at
740 // (lldb::addr_t)info->si_addr if we need it.
741 thread.SetStoppedByWatchpoint(wp_index);
742
743 // We need to tell all other running threads before we notify the delegate
744 // about this stop.
745 StopRunningThreads(thread.GetID());
746}
747
748void NativeProcessLinux::MonitorSignal(const siginfo_t &info,
749 NativeThreadLinux &thread) {
750 const int signo = info.si_signo;
751 const bool is_from_llgs = info.si_pid_sifields._kill.si_pid == getpid();
752
753 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
754
755 // POSIX says that process behaviour is undefined after it ignores a SIGFPE,
756 // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a kill(2)
757 // or raise(3). Similarly for tgkill(2) on Linux.
758 //
759 // IOW, user generated signals never generate what we consider to be a
760 // "crash".
761 //
762 // Similarly, ACK signals generated by this monitor.
763
764 // Handle the signal.
765 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received signal {0} ({1}) with code {2}, (siginfo pid = {3}, "
"waitpid pid = {4})", Host::GetSignalAsCString(signo), signo
, info.si_code, thread.GetID()); } while (0)
766 "received signal {0} ({1}) with code {2}, (siginfo pid = {3}, "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received signal {0} ({1}) with code {2}, (siginfo pid = {3}, "
"waitpid pid = {4})", Host::GetSignalAsCString(signo), signo
, info.si_code, thread.GetID()); } while (0)
767 "waitpid pid = {4})",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received signal {0} ({1}) with code {2}, (siginfo pid = {3}, "
"waitpid pid = {4})", Host::GetSignalAsCString(signo), signo
, info.si_code, thread.GetID()); } while (0)
768 Host::GetSignalAsCString(signo), signo, info.si_code,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received signal {0} ({1}) with code {2}, (siginfo pid = {3}, "
"waitpid pid = {4})", Host::GetSignalAsCString(signo), signo
, info.si_code, thread.GetID()); } while (0)
769 thread.GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received signal {0} ({1}) with code {2}, (siginfo pid = {3}, "
"waitpid pid = {4})", Host::GetSignalAsCString(signo), signo
, info.si_code, thread.GetID()); } while (0);
770
771 // Check for thread stop notification.
772 if (is_from_llgs && (info.si_code == SI_TKILLSI_TKILL) && (signo == SIGSTOP19)) {
773 // This is a tgkill()-based stop.
774 LLDB_LOG(log, "pid {0} tid {1}, thread stopped", GetID(), thread.GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} tid {1}, thread stopped", GetID(), thread
.GetID()); } while (0);
775
776 // Check that we're not already marked with a stop reason. Note this thread
777 // really shouldn't already be marked as stopped - if we were, that would
778 // imply that the kernel signaled us with the thread stopping which we
779 // handled and marked as stopped, and that, without an intervening resume,
780 // we received another stop. It is more likely that we are missing the
781 // marking of a run state somewhere if we find that the thread was marked
782 // as stopped.
783 const StateType thread_state = thread.GetState();
784 if (!StateIsStoppedState(thread_state, false)) {
785 // An inferior thread has stopped because of a SIGSTOP we have sent it.
786 // Generally, these are not important stops and we don't want to report
787 // them as they are just used to stop other threads when one thread (the
788 // one with the *real* stop reason) hits a breakpoint (watchpoint,
789 // etc...). However, in the case of an asynchronous Interrupt(), this
790 // *is* the real stop reason, so we leave the signal intact if this is
791 // the thread that was chosen as the triggering thread.
792 if (m_pending_notification_tid != LLDB_INVALID_THREAD_ID0) {
793 if (m_pending_notification_tid == thread.GetID())
794 thread.SetStoppedBySignal(SIGSTOP19, &info);
795 else
796 thread.SetStoppedWithNoReason();
797
798 SetCurrentThreadID(thread.GetID());
799 SignalIfAllThreadsStopped();
800 } else {
801 // We can end up here if stop was initiated by LLGS but by this time a
802 // thread stop has occurred - maybe initiated by another event.
803 Status error = ResumeThread(thread, thread.GetState(), 0);
804 if (error.Fail())
805 LLDB_LOG(log, "failed to resume thread {0}: {1}", thread.GetID(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "failed to resume thread {0}: {1}", thread.GetID(
), error); } while (0)
806 error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "failed to resume thread {0}: {1}", thread.GetID(
), error); } while (0);
807 }
808 } else {
809 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} tid {1}, thread was already marked as a stopped "
"state (state={2}), leaving stop signal as is", GetID(), thread
.GetID(), thread_state); } while (0)
810 "pid {0} tid {1}, thread was already marked as a stopped "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} tid {1}, thread was already marked as a stopped "
"state (state={2}), leaving stop signal as is", GetID(), thread
.GetID(), thread_state); } while (0)
811 "state (state={2}), leaving stop signal as is",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} tid {1}, thread was already marked as a stopped "
"state (state={2}), leaving stop signal as is", GetID(), thread
.GetID(), thread_state); } while (0)
812 GetID(), thread.GetID(), thread_state)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} tid {1}, thread was already marked as a stopped "
"state (state={2}), leaving stop signal as is", GetID(), thread
.GetID(), thread_state); } while (0);
813 SignalIfAllThreadsStopped();
814 }
815
816 // Done handling.
817 return;
818 }
819
820 // Check if debugger should stop at this signal or just ignore it and resume
821 // the inferior.
822 if (m_signals_to_ignore.contains(signo)) {
823 ResumeThread(thread, thread.GetState(), signo);
824 return;
825 }
826
827 // This thread is stopped.
828 LLDB_LOG(log, "received signal {0}", Host::GetSignalAsCString(signo))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "received signal {0}", Host::GetSignalAsCString(signo
)); } while (0);
829 thread.SetStoppedBySignal(signo, &info);
830
831 // Send a stop to the debugger after we get all other threads to stop.
832 StopRunningThreads(thread.GetID());
833}
834
835bool NativeProcessLinux::MonitorClone(NativeThreadLinux &parent,
836 lldb::pid_t child_pid, int event) {
837 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
838 LLDB_LOG(log, "parent_tid={0}, child_pid={1}, event={2}", parent.GetID(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "parent_tid={0}, child_pid={1}, event={2}", parent
.GetID(), child_pid, event); } while (0)
839 child_pid, event)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "parent_tid={0}, child_pid={1}, event={2}", parent
.GetID(), child_pid, event); } while (0);
840
841 WaitForCloneNotification(child_pid);
842
843 switch (event) {
844 case PTRACE_EVENT_CLONE: {
845 // PTRACE_EVENT_CLONE can either mean a new thread or a new process.
846 // Try to grab the new process' PGID to figure out which one it is.
847 // If PGID is the same as the PID, then it's a new process. Otherwise,
848 // it's a thread.
849 auto tgid_ret = getPIDForTID(child_pid);
850 if (tgid_ret != child_pid) {
851 // A new thread should have PGID matching our process' PID.
852 assert(!tgid_ret || tgid_ret.getValue() == GetID())(static_cast <bool> (!tgid_ret || tgid_ret.getValue() ==
GetID()) ? void (0) : __assert_fail ("!tgid_ret || tgid_ret.getValue() == GetID()"
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
852, __extension__ __PRETTY_FUNCTION__));
853
854 NativeThreadLinux &child_thread = AddThread(child_pid, /*resume*/ true);
855 ThreadWasCreated(child_thread);
856
857 // Resume the parent.
858 ResumeThread(parent, parent.GetState(), LLDB_INVALID_SIGNAL_NUMBER(2147483647));
859 break;
860 }
861 }
862 LLVM_FALLTHROUGH[[gnu::fallthrough]];
863 case PTRACE_EVENT_FORK:
864 case PTRACE_EVENT_VFORK: {
865 bool is_vfork = event == PTRACE_EVENT_VFORK;
866 std::unique_ptr<NativeProcessLinux> child_process{new NativeProcessLinux(
867 static_cast<::pid_t>(child_pid), m_terminal_fd, m_delegate, m_arch,
868 m_main_loop, {static_cast<::pid_t>(child_pid)})};
869 if (!is_vfork)
870 child_process->m_software_breakpoints = m_software_breakpoints;
871
872 Extension expected_ext = is_vfork ? Extension::vfork : Extension::fork;
873 if (bool(m_enabled_extensions & expected_ext)) {
874 m_delegate.NewSubprocess(this, std::move(child_process));
875 // NB: non-vfork clone() is reported as fork
876 parent.SetStoppedByFork(is_vfork, child_pid);
877 StopRunningThreads(parent.GetID());
878 } else {
879 child_process->Detach();
880 ResumeThread(parent, parent.GetState(), LLDB_INVALID_SIGNAL_NUMBER(2147483647));
881 }
882 break;
883 }
884 default:
885 llvm_unreachable("unknown clone_info.event")::llvm::llvm_unreachable_internal("unknown clone_info.event",
"lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp", 885
);
886 }
887
888 return true;
889}
890
891bool NativeProcessLinux::SupportHardwareSingleStepping() const {
892 if (m_arch.GetMachine() == llvm::Triple::arm || m_arch.IsMIPS())
893 return false;
894 return true;
895}
896
897Status NativeProcessLinux::Resume(const ResumeActionList &resume_actions) {
898 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
899 LLDB_LOG(log, "pid {0}", GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0}", GetID()); } while (0);
900
901 bool software_single_step = !SupportHardwareSingleStepping();
902
903 if (software_single_step) {
904 for (const auto &thread : m_threads) {
905 assert(thread && "thread list should not contain NULL threads")(static_cast <bool> (thread && "thread list should not contain NULL threads"
) ? void (0) : __assert_fail ("thread && \"thread list should not contain NULL threads\""
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
905, __extension__ __PRETTY_FUNCTION__));
906
907 const ResumeAction *const action =
908 resume_actions.GetActionForThread(thread->GetID(), true);
909 if (action == nullptr)
910 continue;
911
912 if (action->state == eStateStepping) {
913 Status error = SetupSoftwareSingleStepping(
914 static_cast<NativeThreadLinux &>(*thread));
915 if (error.Fail())
916 return error;
917 }
918 }
919 }
920
921 for (const auto &thread : m_threads) {
922 assert(thread && "thread list should not contain NULL threads")(static_cast <bool> (thread && "thread list should not contain NULL threads"
) ? void (0) : __assert_fail ("thread && \"thread list should not contain NULL threads\""
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
922, __extension__ __PRETTY_FUNCTION__));
923
924 const ResumeAction *const action =
925 resume_actions.GetActionForThread(thread->GetID(), true);
926
927 if (action == nullptr) {
928 LLDB_LOG(log, "no action specified for pid {0} tid {1}", GetID(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "no action specified for pid {0} tid {1}", GetID(
), thread->GetID()); } while (0)
929 thread->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "no action specified for pid {0} tid {1}", GetID(
), thread->GetID()); } while (0);
930 continue;
931 }
932
933 LLDB_LOG(log, "processing resume action state {0} for pid {1} tid {2}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "processing resume action state {0} for pid {1} tid {2}"
, action->state, GetID(), thread->GetID()); } while (0)
934 action->state, GetID(), thread->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "processing resume action state {0} for pid {1} tid {2}"
, action->state, GetID(), thread->GetID()); } while (0);
935
936 switch (action->state) {
937 case eStateRunning:
938 case eStateStepping: {
939 // Run the thread, possibly feeding it the signal.
940 const int signo = action->signal;
941 ResumeThread(static_cast<NativeThreadLinux &>(*thread), action->state,
942 signo);
943 break;
944 }
945
946 case eStateSuspended:
947 case eStateStopped:
948 llvm_unreachable("Unexpected state")::llvm::llvm_unreachable_internal("Unexpected state", "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, 948);
949
950 default:
951 return Status("NativeProcessLinux::%s (): unexpected state %s specified "
952 "for pid %" PRIu64"l" "u" ", tid %" PRIu64"l" "u",
953 __FUNCTION__, StateAsCString(action->state), GetID(),
954 thread->GetID());
955 }
956 }
957
958 return Status();
959}
960
961Status NativeProcessLinux::Halt() {
962 Status error;
963
964 if (kill(GetID(), SIGSTOP19) != 0)
965 error.SetErrorToErrno();
966
967 return error;
968}
969
970Status NativeProcessLinux::Detach() {
971 Status error;
972
973 // Stop monitoring the inferior.
974 m_sigchld_handle.reset();
975
976 // Tell ptrace to detach from the process.
977 if (GetID() == LLDB_INVALID_PROCESS_ID0)
978 return error;
979
980 for (const auto &thread : m_threads) {
981 Status e = Detach(thread->GetID());
982 if (e.Fail())
983 error =
984 e; // Save the error, but still attempt to detach from other threads.
985 }
986
987 m_intel_pt_manager.Clear();
988
989 return error;
990}
991
992Status NativeProcessLinux::Signal(int signo) {
993 Status error;
994
995 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
996 LLDB_LOG(log, "sending signal {0} ({1}) to pid {1}", signo,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "sending signal {0} ({1}) to pid {1}", signo, Host
::GetSignalAsCString(signo), GetID()); } while (0)
997 Host::GetSignalAsCString(signo), GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "sending signal {0} ({1}) to pid {1}", signo, Host
::GetSignalAsCString(signo), GetID()); } while (0);
998
999 if (kill(GetID(), signo))
1000 error.SetErrorToErrno();
1001
1002 return error;
1003}
1004
1005Status NativeProcessLinux::Interrupt() {
1006 // Pick a running thread (or if none, a not-dead stopped thread) as the
1007 // chosen thread that will be the stop-reason thread.
1008 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
1009
1010 NativeThreadProtocol *running_thread = nullptr;
1011 NativeThreadProtocol *stopped_thread = nullptr;
1012
1013 LLDB_LOG(log, "selecting running thread for interrupt target")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "selecting running thread for interrupt target");
} while (0);
1014 for (const auto &thread : m_threads) {
1015 // If we have a running or stepping thread, we'll call that the target of
1016 // the interrupt.
1017 const auto thread_state = thread->GetState();
1018 if (thread_state == eStateRunning || thread_state == eStateStepping) {
1019 running_thread = thread.get();
1020 break;
1021 } else if (!stopped_thread && StateIsStoppedState(thread_state, true)) {
1022 // Remember the first non-dead stopped thread. We'll use that as a
1023 // backup if there are no running threads.
1024 stopped_thread = thread.get();
1025 }
1026 }
1027
1028 if (!running_thread && !stopped_thread) {
1029 Status error("found no running/stepping or live stopped threads as target "
1030 "for interrupt");
1031 LLDB_LOG(log, "skipping due to error: {0}", error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "skipping due to error: {0}", error); } while (0);
1032
1033 return error;
1034 }
1035
1036 NativeThreadProtocol *deferred_signal_thread =
1037 running_thread ? running_thread : stopped_thread;
1038
1039 LLDB_LOG(log, "pid {0} {1} tid {2} chosen for interrupt target", GetID(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} {1} tid {2} chosen for interrupt target"
, GetID(), running_thread ? "running" : "stopped", deferred_signal_thread
->GetID()); } while (0)
1040 running_thread ? "running" : "stopped",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} {1} tid {2} chosen for interrupt target"
, GetID(), running_thread ? "running" : "stopped", deferred_signal_thread
->GetID()); } while (0)
1041 deferred_signal_thread->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} {1} tid {2} chosen for interrupt target"
, GetID(), running_thread ? "running" : "stopped", deferred_signal_thread
->GetID()); } while (0);
1042
1043 StopRunningThreads(deferred_signal_thread->GetID());
1044
1045 return Status();
1046}
1047
1048Status NativeProcessLinux::Kill() {
1049 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
1050 LLDB_LOG(log, "pid {0}", GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0}", GetID()); } while (0);
1051
1052 Status error;
1053
1054 switch (m_state) {
1055 case StateType::eStateInvalid:
1056 case StateType::eStateExited:
1057 case StateType::eStateCrashed:
1058 case StateType::eStateDetached:
1059 case StateType::eStateUnloaded:
1060 // Nothing to do - the process is already dead.
1061 LLDB_LOG(log, "ignored for PID {0} due to current state: {1}", GetID(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "ignored for PID {0} due to current state: {1}", GetID
(), m_state); } while (0)
1062 m_state)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "ignored for PID {0} due to current state: {1}", GetID
(), m_state); } while (0);
1063 return error;
1064
1065 case StateType::eStateConnected:
1066 case StateType::eStateAttaching:
1067 case StateType::eStateLaunching:
1068 case StateType::eStateStopped:
1069 case StateType::eStateRunning:
1070 case StateType::eStateStepping:
1071 case StateType::eStateSuspended:
1072 // We can try to kill a process in these states.
1073 break;
1074 }
1075
1076 if (kill(GetID(), SIGKILL9) != 0) {
1077 error.SetErrorToErrno();
1078 return error;
1079 }
1080
1081 return error;
1082}
1083
1084Status NativeProcessLinux::GetMemoryRegionInfo(lldb::addr_t load_addr,
1085 MemoryRegionInfo &range_info) {
1086 // FIXME review that the final memory region returned extends to the end of
1087 // the virtual address space,
1088 // with no perms if it is not mapped.
1089
1090 // Use an approach that reads memory regions from /proc/{pid}/maps. Assume
1091 // proc maps entries are in ascending order.
1092 // FIXME assert if we find differently.
1093
1094 if (m_supports_mem_region == LazyBool::eLazyBoolNo) {
1095 // We're done.
1096 return Status("unsupported");
1097 }
1098
1099 Status error = PopulateMemoryRegionCache();
1100 if (error.Fail()) {
1101 return error;
1102 }
1103
1104 lldb::addr_t prev_base_address = 0;
1105
1106 // FIXME start by finding the last region that is <= target address using
1107 // binary search. Data is sorted.
1108 // There can be a ton of regions on pthreads apps with lots of threads.
1109 for (auto it = m_mem_region_cache.begin(); it != m_mem_region_cache.end();
1110 ++it) {
1111 MemoryRegionInfo &proc_entry_info = it->first;
1112
1113 // Sanity check assumption that /proc/{pid}/maps entries are ascending.
1114 assert((proc_entry_info.GetRange().GetRangeBase() >= prev_base_address) &&(static_cast <bool> ((proc_entry_info.GetRange().GetRangeBase
() >= prev_base_address) && "descending /proc/pid/maps entries detected, unexpected"
) ? void (0) : __assert_fail ("(proc_entry_info.GetRange().GetRangeBase() >= prev_base_address) && \"descending /proc/pid/maps entries detected, unexpected\""
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1115, __extension__ __PRETTY_FUNCTION__))
1115 "descending /proc/pid/maps entries detected, unexpected")(static_cast <bool> ((proc_entry_info.GetRange().GetRangeBase
() >= prev_base_address) && "descending /proc/pid/maps entries detected, unexpected"
) ? void (0) : __assert_fail ("(proc_entry_info.GetRange().GetRangeBase() >= prev_base_address) && \"descending /proc/pid/maps entries detected, unexpected\""
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1115, __extension__ __PRETTY_FUNCTION__));
1116 prev_base_address = proc_entry_info.GetRange().GetRangeBase();
1117 UNUSED_IF_ASSERT_DISABLED(prev_base_address)((void)(prev_base_address));
1118
1119 // If the target address comes before this entry, indicate distance to next
1120 // region.
1121 if (load_addr < proc_entry_info.GetRange().GetRangeBase()) {
1122 range_info.GetRange().SetRangeBase(load_addr);
1123 range_info.GetRange().SetByteSize(
1124 proc_entry_info.GetRange().GetRangeBase() - load_addr);
1125 range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
1126 range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
1127 range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
1128 range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
1129
1130 return error;
1131 } else if (proc_entry_info.GetRange().Contains(load_addr)) {
1132 // The target address is within the memory region we're processing here.
1133 range_info = proc_entry_info;
1134 return error;
1135 }
1136
1137 // The target memory address comes somewhere after the region we just
1138 // parsed.
1139 }
1140
1141 // If we made it here, we didn't find an entry that contained the given
1142 // address. Return the load_addr as start and the amount of bytes betwwen
1143 // load address and the end of the memory as size.
1144 range_info.GetRange().SetRangeBase(load_addr);
1145 range_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS(18446744073709551615UL));
1146 range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
1147 range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
1148 range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
1149 range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
1150 return error;
1151}
1152
1153Status NativeProcessLinux::PopulateMemoryRegionCache() {
1154 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
1155
1156 // If our cache is empty, pull the latest. There should always be at least
1157 // one memory region if memory region handling is supported.
1158 if (!m_mem_region_cache.empty()) {
1159 LLDB_LOG(log, "reusing {0} cached memory region entries",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "reusing {0} cached memory region entries", m_mem_region_cache
.size()); } while (0)
1160 m_mem_region_cache.size())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "reusing {0} cached memory region entries", m_mem_region_cache
.size()); } while (0);
1161 return Status();
1162 }
1163
1164 Status Result;
1165 LinuxMapCallback callback = [&](llvm::Expected<MemoryRegionInfo> Info) {
1166 if (Info) {
1167 FileSpec file_spec(Info->GetName().GetCString());
1168 FileSystem::Instance().Resolve(file_spec);
1169 m_mem_region_cache.emplace_back(*Info, file_spec);
1170 return true;
1171 }
1172
1173 Result = Info.takeError();
1174 m_supports_mem_region = LazyBool::eLazyBoolNo;
1175 LLDB_LOG(log, "failed to parse proc maps: {0}", Result)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "failed to parse proc maps: {0}", Result); } while
(0);
1176 return false;
1177 };
1178
1179 // Linux kernel since 2.6.14 has /proc/{pid}/smaps
1180 // if CONFIG_PROC_PAGE_MONITOR is enabled
1181 auto BufferOrError = getProcFile(GetID(), "smaps");
1182 if (BufferOrError)
1183 ParseLinuxSMapRegions(BufferOrError.get()->getBuffer(), callback);
1184 else {
1185 BufferOrError = getProcFile(GetID(), "maps");
1186 if (!BufferOrError) {
1187 m_supports_mem_region = LazyBool::eLazyBoolNo;
1188 return BufferOrError.getError();
1189 }
1190
1191 ParseLinuxMapRegions(BufferOrError.get()->getBuffer(), callback);
1192 }
1193
1194 if (Result.Fail())
1195 return Result;
1196
1197 if (m_mem_region_cache.empty()) {
1198 // No entries after attempting to read them. This shouldn't happen if
1199 // /proc/{pid}/maps is supported. Assume we don't support map entries via
1200 // procfs.
1201 m_supports_mem_region = LazyBool::eLazyBoolNo;
1202 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "failed to find any procfs maps entries, assuming no support "
"for memory region metadata retrieval"); } while (0)
1203 "failed to find any procfs maps entries, assuming no support "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "failed to find any procfs maps entries, assuming no support "
"for memory region metadata retrieval"); } while (0)
1204 "for memory region metadata retrieval")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "failed to find any procfs maps entries, assuming no support "
"for memory region metadata retrieval"); } while (0);
1205 return Status("not supported");
1206 }
1207
1208 LLDB_LOG(log, "read {0} memory region entries from /proc/{1}/maps",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "read {0} memory region entries from /proc/{1}/maps"
, m_mem_region_cache.size(), GetID()); } while (0)
1209 m_mem_region_cache.size(), GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "read {0} memory region entries from /proc/{1}/maps"
, m_mem_region_cache.size(), GetID()); } while (0);
1210
1211 // We support memory retrieval, remember that.
1212 m_supports_mem_region = LazyBool::eLazyBoolYes;
1213 return Status();
1214}
1215
1216void NativeProcessLinux::DoStopIDBumped(uint32_t newBumpId) {
1217 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
1218 LLDB_LOG(log, "newBumpId={0}", newBumpId)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "newBumpId={0}", newBumpId); } while (0);
1219 LLDB_LOG(log, "clearing {0} entries from memory region cache",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "clearing {0} entries from memory region cache", m_mem_region_cache
.size()); } while (0)
1220 m_mem_region_cache.size())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "clearing {0} entries from memory region cache", m_mem_region_cache
.size()); } while (0);
1221 m_mem_region_cache.clear();
1222}
1223
1224llvm::Expected<uint64_t>
1225NativeProcessLinux::Syscall(llvm::ArrayRef<uint64_t> args) {
1226 PopulateMemoryRegionCache();
1227 auto region_it = llvm::find_if(m_mem_region_cache, [](const auto &pair) {
1228 return pair.first.GetExecutable() == MemoryRegionInfo::eYes;
1229 });
1230 if (region_it == m_mem_region_cache.end())
1231 return llvm::createStringError(llvm::inconvertibleErrorCode(),
1232 "No executable memory region found!");
1233
1234 addr_t exe_addr = region_it->first.GetRange().GetRangeBase();
1235
1236 NativeThreadLinux &thread = *GetThreadByID(GetID());
1237 assert(thread.GetState() == eStateStopped)(static_cast <bool> (thread.GetState() == eStateStopped
) ? void (0) : __assert_fail ("thread.GetState() == eStateStopped"
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1237, __extension__ __PRETTY_FUNCTION__));
1238 NativeRegisterContextLinux &reg_ctx = thread.GetRegisterContext();
1239
1240 NativeRegisterContextLinux::SyscallData syscall_data =
1241 *reg_ctx.GetSyscallData();
1242
1243 DataBufferSP registers_sp;
1244 if (llvm::Error Err = reg_ctx.ReadAllRegisterValues(registers_sp).ToError())
1245 return std::move(Err);
1246 auto restore_regs = llvm::make_scope_exit(
1247 [&] { reg_ctx.WriteAllRegisterValues(registers_sp); });
1248
1249 llvm::SmallVector<uint8_t, 8> memory(syscall_data.Insn.size());
1250 size_t bytes_read;
1251 if (llvm::Error Err =
1252 ReadMemory(exe_addr, memory.data(), memory.size(), bytes_read)
1253 .ToError()) {
1254 return std::move(Err);
1255 }
1256
1257 auto restore_mem = llvm::make_scope_exit(
1258 [&] { WriteMemory(exe_addr, memory.data(), memory.size(), bytes_read); });
1259
1260 if (llvm::Error Err = reg_ctx.SetPC(exe_addr).ToError())
1261 return std::move(Err);
1262
1263 for (const auto &zip : llvm::zip_first(args, syscall_data.Args)) {
1264 if (llvm::Error Err =
1265 reg_ctx
1266 .WriteRegisterFromUnsigned(std::get<1>(zip), std::get<0>(zip))
1267 .ToError()) {
1268 return std::move(Err);
1269 }
1270 }
1271 if (llvm::Error Err = WriteMemory(exe_addr, syscall_data.Insn.data(),
1272 syscall_data.Insn.size(), bytes_read)
1273 .ToError())
1274 return std::move(Err);
1275
1276 m_mem_region_cache.clear();
1277
1278 // With software single stepping the syscall insn buffer must also include a
1279 // trap instruction to stop the process.
1280 int req = SupportHardwareSingleStepping() ? PTRACE_SINGLESTEP : PTRACE_CONT;
1281 if (llvm::Error Err =
1282 PtraceWrapper(req, thread.GetID(), nullptr, nullptr).ToError())
1283 return std::move(Err);
1284
1285 int status;
1286 ::pid_t wait_pid = llvm::sys::RetryAfterSignal(-1, ::waitpid, thread.GetID(),
1287 &status, __WALL0x40000000);
1288 if (wait_pid == -1) {
1289 return llvm::errorCodeToError(
1290 std::error_code(errno(*__errno_location ()), std::generic_category()));
1291 }
1292 assert((unsigned)wait_pid == thread.GetID())(static_cast <bool> ((unsigned)wait_pid == thread.GetID
()) ? void (0) : __assert_fail ("(unsigned)wait_pid == thread.GetID()"
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1292, __extension__ __PRETTY_FUNCTION__));
1293
1294 uint64_t result = reg_ctx.ReadRegisterAsUnsigned(syscall_data.Result, -ESRCH3);
1295
1296 // Values larger than this are actually negative errno numbers.
1297 uint64_t errno_threshold =
1298 (uint64_t(-1) >> (64 - 8 * m_arch.GetAddressByteSize())) - 0x1000;
1299 if (result > errno_threshold) {
1300 return llvm::errorCodeToError(
1301 std::error_code(-result & 0xfff, std::generic_category()));
1302 }
1303
1304 return result;
1305}
1306
1307llvm::Expected<addr_t>
1308NativeProcessLinux::AllocateMemory(size_t size, uint32_t permissions) {
1309
1310 llvm::Optional<NativeRegisterContextLinux::MmapData> mmap_data =
1311 GetCurrentThread()->GetRegisterContext().GetMmapData();
1312 if (!mmap_data)
1313 return llvm::make_error<UnimplementedError>();
1314
1315 unsigned prot = PROT_NONE0x0;
1316 assert((permissions & (ePermissionsReadable | ePermissionsWritable |(static_cast <bool> ((permissions & (ePermissionsReadable
| ePermissionsWritable | ePermissionsExecutable)) == permissions
&& "Unknown permission!") ? void (0) : __assert_fail
("(permissions & (ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable)) == permissions && \"Unknown permission!\""
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1318, __extension__ __PRETTY_FUNCTION__))
1317 ePermissionsExecutable)) == permissions &&(static_cast <bool> ((permissions & (ePermissionsReadable
| ePermissionsWritable | ePermissionsExecutable)) == permissions
&& "Unknown permission!") ? void (0) : __assert_fail
("(permissions & (ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable)) == permissions && \"Unknown permission!\""
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1318, __extension__ __PRETTY_FUNCTION__))
1318 "Unknown permission!")(static_cast <bool> ((permissions & (ePermissionsReadable
| ePermissionsWritable | ePermissionsExecutable)) == permissions
&& "Unknown permission!") ? void (0) : __assert_fail
("(permissions & (ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable)) == permissions && \"Unknown permission!\""
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1318, __extension__ __PRETTY_FUNCTION__));
1319 if (permissions & ePermissionsReadable)
1320 prot |= PROT_READ0x1;
1321 if (permissions & ePermissionsWritable)
1322 prot |= PROT_WRITE0x2;
1323 if (permissions & ePermissionsExecutable)
1324 prot |= PROT_EXEC0x4;
1325
1326 llvm::Expected<uint64_t> Result =
1327 Syscall({mmap_data->SysMmap, 0, size, prot, MAP_ANONYMOUS0x20 | MAP_PRIVATE0x02,
1328 uint64_t(-1), 0});
1329 if (Result)
1330 m_allocated_memory.try_emplace(*Result, size);
1331 return Result;
1332}
1333
1334llvm::Error NativeProcessLinux::DeallocateMemory(lldb::addr_t addr) {
1335 llvm::Optional<NativeRegisterContextLinux::MmapData> mmap_data =
1336 GetCurrentThread()->GetRegisterContext().GetMmapData();
1337 if (!mmap_data)
1338 return llvm::make_error<UnimplementedError>();
1339
1340 auto it = m_allocated_memory.find(addr);
1341 if (it == m_allocated_memory.end())
1342 return llvm::createStringError(llvm::errc::invalid_argument,
1343 "Memory not allocated by the debugger.");
1344
1345 llvm::Expected<uint64_t> Result =
1346 Syscall({mmap_data->SysMunmap, addr, it->second});
1347 if (!Result)
1348 return Result.takeError();
1349
1350 m_allocated_memory.erase(it);
1351 return llvm::Error::success();
1352}
1353
1354Status NativeProcessLinux::ReadMemoryTags(int32_t type, lldb::addr_t addr,
1355 size_t len,
1356 std::vector<uint8_t> &tags) {
1357 llvm::Expected<NativeRegisterContextLinux::MemoryTaggingDetails> details =
1358 GetCurrentThread()->GetRegisterContext().GetMemoryTaggingDetails(type);
1359 if (!details)
1360 return Status(details.takeError());
1361
1362 // Ignore 0 length read
1363 if (!len)
1364 return Status();
1365
1366 // lldb will align the range it requests but it is not required to by
1367 // the protocol so we'll do it again just in case.
1368 // Remove non address bits too. Ptrace calls may work regardless but that
1369 // is not a guarantee.
1370 MemoryTagManager::TagRange range(details->manager->RemoveNonAddressBits(addr),
1371 len);
1372 range = details->manager->ExpandToGranule(range);
1373
1374 // Allocate enough space for all tags to be read
1375 size_t num_tags = range.GetByteSize() / details->manager->GetGranuleSize();
1376 tags.resize(num_tags * details->manager->GetTagSizeInBytes());
1377
1378 struct iovec tags_iovec;
1379 uint8_t *dest = tags.data();
1380 lldb::addr_t read_addr = range.GetRangeBase();
1381
1382 // This call can return partial data so loop until we error or
1383 // get all tags back.
1384 while (num_tags) {
1385 tags_iovec.iov_base = dest;
1386 tags_iovec.iov_len = num_tags;
1387
1388 Status error = NativeProcessLinux::PtraceWrapper(
1389 details->ptrace_read_req, GetID(), reinterpret_cast<void *>(read_addr),
1390 static_cast<void *>(&tags_iovec), 0, nullptr);
1391
1392 if (error.Fail()) {
1393 // Discard partial reads
1394 tags.resize(0);
1395 return error;
1396 }
1397
1398 size_t tags_read = tags_iovec.iov_len;
1399 assert(tags_read && (tags_read <= num_tags))(static_cast <bool> (tags_read && (tags_read <=
num_tags)) ? void (0) : __assert_fail ("tags_read && (tags_read <= num_tags)"
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1399, __extension__ __PRETTY_FUNCTION__));
1400
1401 dest += tags_read * details->manager->GetTagSizeInBytes();
1402 read_addr += details->manager->GetGranuleSize() * tags_read;
1403 num_tags -= tags_read;
1404 }
1405
1406 return Status();
1407}
1408
1409Status NativeProcessLinux::WriteMemoryTags(int32_t type, lldb::addr_t addr,
1410 size_t len,
1411 const std::vector<uint8_t> &tags) {
1412 llvm::Expected<NativeRegisterContextLinux::MemoryTaggingDetails> details =
1413 GetCurrentThread()->GetRegisterContext().GetMemoryTaggingDetails(type);
1414 if (!details)
1
Taking false branch
→
1415 return Status(details.takeError());
1416
1417 // Ignore 0 length write
1418 if (!len)
2
←
Assuming 'len' is not equal to 0
→
3
←
Taking false branch
→
1419 return Status();
1420
1421 // lldb will align the range it requests but it is not required to by
1422 // the protocol so we'll do it again just in case.
1423 // Remove non address bits too. Ptrace calls may work regardless but that
1424 // is not a guarantee.
1425 MemoryTagManager::TagRange range(details->manager->RemoveNonAddressBits(addr),
1426 len);
1427 range = details->manager->ExpandToGranule(range);
1428
1429 // Not checking number of tags here, we may repeat them below
1430 llvm::Expected<std::vector<lldb::addr_t>> unpacked_tags_or_err =
1431 details->manager->UnpackTagsData(tags);
1432 if (!unpacked_tags_or_err)
4
←
Taking false branch
→
1433 return Status(unpacked_tags_or_err.takeError());
1434
1435 llvm::Expected<std::vector<lldb::addr_t>> repeated_tags_or_err =
1436 details->manager->RepeatTagsForRange(*unpacked_tags_or_err, range);
1437 if (!repeated_tags_or_err)
5
←
Taking false branch
→
1438 return Status(repeated_tags_or_err.takeError());
1439
1440 // Repack them for ptrace to use
1441 llvm::Expected<std::vector<uint8_t>> final_tag_data =
1442 details->manager->PackTags(*repeated_tags_or_err);
1443 if (!final_tag_data)
6
←
Taking false branch
→
1444 return Status(final_tag_data.takeError());
1445
1446 struct iovec tags_vec;
1447 uint8_t *src = final_tag_data->data();
1448 lldb::addr_t write_addr = range.GetRangeBase();
1449 // unpacked tags size because the number of bytes per tag might not be 1
1450 size_t num_tags = repeated_tags_or_err->size();
1451
1452 // This call can partially write tags, so we loop until we
1453 // error or all tags have been written.
1454 while (num_tags > 0) {
7
←
Assuming 'num_tags' is > 0
→
8
←
Loop condition is true. Entering loop body
→
1455 tags_vec.iov_base = src;
1456 tags_vec.iov_len = num_tags;
1457
1458 Status error = NativeProcessLinux::PtraceWrapper(
9
←
Calling 'NativeProcessLinux::PtraceWrapper'
→
1459 details->ptrace_write_req, GetID(),
1460 reinterpret_cast<void *>(write_addr), static_cast<void *>(&tags_vec), 0,
1461 nullptr);
1462
1463 if (error.Fail()) {
1464 // Don't attempt to restore the original values in the case of a partial
1465 // write
1466 return error;
1467 }
1468
1469 size_t tags_written = tags_vec.iov_len;
1470 assert(tags_written && (tags_written <= num_tags))(static_cast <bool> (tags_written && (tags_written
<= num_tags)) ? void (0) : __assert_fail ("tags_written && (tags_written <= num_tags)"
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1470, __extension__ __PRETTY_FUNCTION__));
1471
1472 src += tags_written * details->manager->GetTagSizeInBytes();
1473 write_addr += details->manager->GetGranuleSize() * tags_written;
1474 num_tags -= tags_written;
1475 }
1476
1477 return Status();
1478}
1479
1480size_t NativeProcessLinux::UpdateThreads() {
1481 // The NativeProcessLinux monitoring threads are always up to date with
1482 // respect to thread state and they keep the thread list populated properly.
1483 // All this method needs to do is return the thread count.
1484 return m_threads.size();
1485}
1486
1487Status NativeProcessLinux::SetBreakpoint(lldb::addr_t addr, uint32_t size,
1488 bool hardware) {
1489 if (hardware)
1490 return SetHardwareBreakpoint(addr, size);
1491 else
1492 return SetSoftwareBreakpoint(addr, size);
1493}
1494
1495Status NativeProcessLinux::RemoveBreakpoint(lldb::addr_t addr, bool hardware) {
1496 if (hardware)
1497 return RemoveHardwareBreakpoint(addr);
1498 else
1499 return NativeProcessProtocol::RemoveBreakpoint(addr);
1500}
1501
1502llvm::Expected<llvm::ArrayRef<uint8_t>>
1503NativeProcessLinux::GetSoftwareBreakpointTrapOpcode(size_t size_hint) {
1504 // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but the
1505 // linux kernel does otherwise.
1506 static const uint8_t g_arm_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
1507 static const uint8_t g_thumb_opcode[] = {0x01, 0xde};
1508
1509 switch (GetArchitecture().GetMachine()) {
1510 case llvm::Triple::arm:
1511 switch (size_hint) {
1512 case 2:
1513 return llvm::makeArrayRef(g_thumb_opcode);
1514 case 4:
1515 return llvm::makeArrayRef(g_arm_opcode);
1516 default:
1517 return llvm::createStringError(llvm::inconvertibleErrorCode(),
1518 "Unrecognised trap opcode size hint!");
1519 }
1520 default:
1521 return NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_hint);
1522 }
1523}
1524
1525Status NativeProcessLinux::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
1526 size_t &bytes_read) {
1527 if (ProcessVmReadvSupported()) {
1528 // The process_vm_readv path is about 50 times faster than ptrace api. We
1529 // want to use this syscall if it is supported.
1530
1531 const ::pid_t pid = GetID();
1532
1533 struct iovec local_iov, remote_iov;
1534 local_iov.iov_base = buf;
1535 local_iov.iov_len = size;
1536 remote_iov.iov_base = reinterpret_cast<void *>(addr);
1537 remote_iov.iov_len = size;
1538
1539 bytes_read = process_vm_readv(pid, &local_iov, 1, &remote_iov, 1, 0);
1540 const bool success = bytes_read == size;
1541
1542 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
1543 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "using process_vm_readv to read {0} bytes from inferior "
"address {1:x}: {2}", size, addr, success ? "Success" : llvm
::sys::StrError((*__errno_location ()))); } while (0)
1544 "using process_vm_readv to read {0} bytes from inferior "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "using process_vm_readv to read {0} bytes from inferior "
"address {1:x}: {2}", size, addr, success ? "Success" : llvm
::sys::StrError((*__errno_location ()))); } while (0)
1545 "address {1:x}: {2}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "using process_vm_readv to read {0} bytes from inferior "
"address {1:x}: {2}", size, addr, success ? "Success" : llvm
::sys::StrError((*__errno_location ()))); } while (0)
1546 size, addr, success ? "Success" : llvm::sys::StrError(errno))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "using process_vm_readv to read {0} bytes from inferior "
"address {1:x}: {2}", size, addr, success ? "Success" : llvm
::sys::StrError((*__errno_location ()))); } while (0);
1547
1548 if (success)
1549 return Status();
1550 // else the call failed for some reason, let's retry the read using ptrace
1551 // api.
1552 }
1553
1554 unsigned char *dst = static_cast<unsigned char *>(buf);
1555 size_t remainder;
1556 long data;
1557
1558 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_MEMORY(1u << 4)));
1559 LLDB_LOG(log, "addr = {0}, buf = {1}, size = {2}", addr, buf, size)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "addr = {0}, buf = {1}, size = {2}", addr, buf, size
); } while (0);
1560
1561 for (bytes_read = 0; bytes_read < size; bytes_read += remainder) {
1562 Status error = NativeProcessLinux::PtraceWrapper(
1563 PTRACE_PEEKDATA, GetID(), (void *)addr, nullptr, 0, &data);
1564 if (error.Fail())
1565 return error;
1566
1567 remainder = size - bytes_read;
1568 remainder = remainder > k_ptrace_word_size ? k_ptrace_word_size : remainder;
1569
1570 // Copy the data into our buffer
1571 memcpy(dst, &data, remainder);
1572
1573 LLDB_LOG(log, "[{0:x}]:{1:x}", addr, data)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "[{0:x}]:{1:x}", addr, data); } while (0);
1574 addr += k_ptrace_word_size;
1575 dst += k_ptrace_word_size;
1576 }
1577 return Status();
1578}
1579
1580Status NativeProcessLinux::WriteMemory(lldb::addr_t addr, const void *buf,
1581 size_t size, size_t &bytes_written) {
1582 const unsigned char *src = static_cast<const unsigned char *>(buf);
1583 size_t remainder;
1584 Status error;
1585
1586 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_MEMORY(1u << 4)));
1587 LLDB_LOG(log, "addr = {0}, buf = {1}, size = {2}", addr, buf, size)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "addr = {0}, buf = {1}, size = {2}", addr, buf, size
); } while (0);
1588
1589 for (bytes_written = 0; bytes_written < size; bytes_written += remainder) {
1590 remainder = size - bytes_written;
1591 remainder = remainder > k_ptrace_word_size ? k_ptrace_word_size : remainder;
1592
1593 if (remainder == k_ptrace_word_size) {
1594 unsigned long data = 0;
1595 memcpy(&data, src, k_ptrace_word_size);
1596
1597 LLDB_LOG(log, "[{0:x}]:{1:x}", addr, data)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "[{0:x}]:{1:x}", addr, data); } while (0);
1598 error = NativeProcessLinux::PtraceWrapper(PTRACE_POKEDATA, GetID(),
1599 (void *)addr, (void *)data);
1600 if (error.Fail())
1601 return error;
1602 } else {
1603 unsigned char buff[8];
1604 size_t bytes_read;
1605 error = ReadMemory(addr, buff, k_ptrace_word_size, bytes_read);
1606 if (error.Fail())
1607 return error;
1608
1609 memcpy(buff, src, remainder);
1610
1611 size_t bytes_written_rec;
1612 error = WriteMemory(addr, buff, k_ptrace_word_size, bytes_written_rec);
1613 if (error.Fail())
1614 return error;
1615
1616 LLDB_LOG(log, "[{0:x}]:{1:x} ({2:x})", addr, *(const unsigned long *)src,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "[{0:x}]:{1:x} ({2:x})", addr, *(const unsigned long
*)src, *(unsigned long *)buff); } while (0)
1617 *(unsigned long *)buff)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "[{0:x}]:{1:x} ({2:x})", addr, *(const unsigned long
*)src, *(unsigned long *)buff); } while (0);
1618 }
1619
1620 addr += k_ptrace_word_size;
1621 src += k_ptrace_word_size;
1622 }
1623 return error;
1624}
1625
1626Status NativeProcessLinux::GetSignalInfo(lldb::tid_t tid, void *siginfo) const {
1627 return PtraceWrapper(PTRACE_GETSIGINFO, tid, nullptr, siginfo);
1628}
1629
1630Status NativeProcessLinux::GetEventMessage(lldb::tid_t tid,
1631 unsigned long *message) {
1632 return PtraceWrapper(PTRACE_GETEVENTMSG, tid, nullptr, message);
1633}
1634
1635Status NativeProcessLinux::Detach(lldb::tid_t tid) {
1636 if (tid == LLDB_INVALID_THREAD_ID0)
1637 return Status();
1638
1639 return PtraceWrapper(PTRACE_DETACH, tid);
1640}
1641
1642bool NativeProcessLinux::HasThreadNoLock(lldb::tid_t thread_id) {
1643 for (const auto &thread : m_threads) {
1644 assert(thread && "thread list should not contain NULL threads")(static_cast <bool> (thread && "thread list should not contain NULL threads"
) ? void (0) : __assert_fail ("thread && \"thread list should not contain NULL threads\""
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1644, __extension__ __PRETTY_FUNCTION__));
1645 if (thread->GetID() == thread_id) {
1646 // We have this thread.
1647 return true;
1648 }
1649 }
1650
1651 // We don't have this thread.
1652 return false;
1653}
1654
1655void NativeProcessLinux::StopTrackingThread(NativeThreadLinux &thread) {
1656 Log *const log = ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD(1u << 2));
1657 lldb::tid_t thread_id = thread.GetID();
1658 LLDB_LOG(log, "tid: {0}", thread_id)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "tid: {0}", thread_id); } while (0);
1659
1660 auto it = llvm::find_if(m_threads, [&](const auto &thread_up) {
1661 return thread_up.get() == &thread;
1662 });
1663 assert(it != m_threads.end())(static_cast <bool> (it != m_threads.end()) ? void (0) :
__assert_fail ("it != m_threads.end()", "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, 1663, __extension__ __PRETTY_FUNCTION__));
1664 m_threads.erase(it);
1665
1666 NotifyTracersOfThreadDestroyed(thread_id);
1667 SignalIfAllThreadsStopped();
1668}
1669
1670Status NativeProcessLinux::NotifyTracersOfNewThread(lldb::tid_t tid) {
1671 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD(1u << 2)));
1672 Status error(m_intel_pt_manager.OnThreadCreated(tid));
1673 if (error.Fail())
1674 LLDB_LOG(log, "Failed to trace a new thread with intel-pt, tid = {0}. {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "Failed to trace a new thread with intel-pt, tid = {0}. {1}"
, tid, error.AsCString()); } while (0)
1675 tid, error.AsCString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "Failed to trace a new thread with intel-pt, tid = {0}. {1}"
, tid, error.AsCString()); } while (0);
1676 return error;
1677}
1678
1679Status NativeProcessLinux::NotifyTracersOfThreadDestroyed(lldb::tid_t tid) {
1680 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD(1u << 2)));
1681 Status error(m_intel_pt_manager.OnThreadDestroyed(tid));
1682 if (error.Fail())
1683 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "Failed to stop a destroyed thread with intel-pt, tid = {0}. {1}"
, tid, error.AsCString()); } while (0)
1684 "Failed to stop a destroyed thread with intel-pt, tid = {0}. {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "Failed to stop a destroyed thread with intel-pt, tid = {0}. {1}"
, tid, error.AsCString()); } while (0)
1685 tid, error.AsCString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "Failed to stop a destroyed thread with intel-pt, tid = {0}. {1}"
, tid, error.AsCString()); } while (0);
1686 return error;
1687}
1688
1689NativeThreadLinux &NativeProcessLinux::AddThread(lldb::tid_t thread_id,
1690 bool resume) {
1691 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD(1u << 2)));
1692 LLDB_LOG(log, "pid {0} adding thread with tid {1}", GetID(), thread_id)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid {0} adding thread with tid {1}", GetID(), thread_id
); } while (0);
1693
1694 assert(!HasThreadNoLock(thread_id) &&(static_cast <bool> (!HasThreadNoLock(thread_id) &&
"attempted to add a thread by id that already exists") ? void
(0) : __assert_fail ("!HasThreadNoLock(thread_id) && \"attempted to add a thread by id that already exists\""
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1695, __extension__ __PRETTY_FUNCTION__))
1695 "attempted to add a thread by id that already exists")(static_cast <bool> (!HasThreadNoLock(thread_id) &&
"attempted to add a thread by id that already exists") ? void
(0) : __assert_fail ("!HasThreadNoLock(thread_id) && \"attempted to add a thread by id that already exists\""
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1695, __extension__ __PRETTY_FUNCTION__));
1696
1697 // If this is the first thread, save it as the current thread
1698 if (m_threads.empty())
1699 SetCurrentThreadID(thread_id);
1700
1701 m_threads.push_back(std::make_unique<NativeThreadLinux>(*this, thread_id));
1702 NativeThreadLinux &thread =
1703 static_cast<NativeThreadLinux &>(*m_threads.back());
1704
1705 Status tracing_error = NotifyTracersOfNewThread(thread.GetID());
1706 if (tracing_error.Fail()) {
1707 thread.SetStoppedByProcessorTrace(tracing_error.AsCString());
1708 StopRunningThreads(thread.GetID());
1709 } else if (resume)
1710 ResumeThread(thread, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER(2147483647));
1711 else
1712 thread.SetStoppedBySignal(SIGSTOP19);
1713
1714 return thread;
1715}
1716
1717Status NativeProcessLinux::GetLoadedModuleFileSpec(const char *module_path,
1718 FileSpec &file_spec) {
1719 Status error = PopulateMemoryRegionCache();
1720 if (error.Fail())
1721 return error;
1722
1723 FileSpec module_file_spec(module_path);
1724 FileSystem::Instance().Resolve(module_file_spec);
1725
1726 file_spec.Clear();
1727 for (const auto &it : m_mem_region_cache) {
1728 if (it.second.GetFilename() == module_file_spec.GetFilename()) {
1729 file_spec = it.second;
1730 return Status();
1731 }
1732 }
1733 return Status("Module file (%s) not found in /proc/%" PRIu64"l" "u" "/maps file!",
1734 module_file_spec.GetFilename().AsCString(), GetID());
1735}
1736
1737Status NativeProcessLinux::GetFileLoadAddress(const llvm::StringRef &file_name,
1738 lldb::addr_t &load_addr) {
1739 load_addr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
1740 Status error = PopulateMemoryRegionCache();
1741 if (error.Fail())
1742 return error;
1743
1744 FileSpec file(file_name);
1745 for (const auto &it : m_mem_region_cache) {
1746 if (it.second == file) {
1747 load_addr = it.first.GetRange().GetRangeBase();
1748 return Status();
1749 }
1750 }
1751 return Status("No load address found for specified file.");
1752}
1753
1754NativeThreadLinux *NativeProcessLinux::GetThreadByID(lldb::tid_t tid) {
1755 return static_cast<NativeThreadLinux *>(
1756 NativeProcessProtocol::GetThreadByID(tid));
1757}
1758
1759NativeThreadLinux *NativeProcessLinux::GetCurrentThread() {
1760 return static_cast<NativeThreadLinux *>(
1761 NativeProcessProtocol::GetCurrentThread());
1762}
1763
1764Status NativeProcessLinux::ResumeThread(NativeThreadLinux &thread,
1765 lldb::StateType state, int signo) {
1766 Log *const log = ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD(1u << 2));
1767 LLDB_LOG(log, "tid: {0}", thread.GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "tid: {0}", thread.GetID()); } while (0);
1768
1769 // Before we do the resume below, first check if we have a pending stop
1770 // notification that is currently waiting for all threads to stop. This is
1771 // potentially a buggy situation since we're ostensibly waiting for threads
1772 // to stop before we send out the pending notification, and here we are
1773 // resuming one before we send out the pending stop notification.
1774 if (m_pending_notification_tid != LLDB_INVALID_THREAD_ID0) {
1775 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "about to resume tid {0} per explicit request but we have a "
"pending stop notification (tid {1}) that is actively " "waiting for this thread to stop. Valid sequence of events?"
, thread.GetID(), m_pending_notification_tid); } while (0)
1776 "about to resume tid {0} per explicit request but we have a "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "about to resume tid {0} per explicit request but we have a "
"pending stop notification (tid {1}) that is actively " "waiting for this thread to stop. Valid sequence of events?"
, thread.GetID(), m_pending_notification_tid); } while (0)
1777 "pending stop notification (tid {1}) that is actively "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "about to resume tid {0} per explicit request but we have a "
"pending stop notification (tid {1}) that is actively " "waiting for this thread to stop. Valid sequence of events?"
, thread.GetID(), m_pending_notification_tid); } while (0)
1778 "waiting for this thread to stop. Valid sequence of events?",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "about to resume tid {0} per explicit request but we have a "
"pending stop notification (tid {1}) that is actively " "waiting for this thread to stop. Valid sequence of events?"
, thread.GetID(), m_pending_notification_tid); } while (0)
1779 thread.GetID(), m_pending_notification_tid)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "about to resume tid {0} per explicit request but we have a "
"pending stop notification (tid {1}) that is actively " "waiting for this thread to stop. Valid sequence of events?"
, thread.GetID(), m_pending_notification_tid); } while (0);
1780 }
1781
1782 // Request a resume. We expect this to be synchronous and the system to
1783 // reflect it is running after this completes.
1784 switch (state) {
1785 case eStateRunning: {
1786 const auto resume_result = thread.Resume(signo);
1787 if (resume_result.Success())
1788 SetState(eStateRunning, true);
1789 return resume_result;
1790 }
1791 case eStateStepping: {
1792 const auto step_result = thread.SingleStep(signo);
1793 if (step_result.Success())
1794 SetState(eStateRunning, true);
1795 return step_result;
1796 }
1797 default:
1798 LLDB_LOG(log, "Unhandled state {0}.", state)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "Unhandled state {0}.", state); } while (0);
1799 llvm_unreachable("Unhandled state for resume")::llvm::llvm_unreachable_internal("Unhandled state for resume"
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1799);
1800 }
1801}
1802
1803//===----------------------------------------------------------------------===//
1804
1805void NativeProcessLinux::StopRunningThreads(const lldb::tid_t triggering_tid) {
1806 Log *const log = ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD(1u << 2));
1807 LLDB_LOG(log, "about to process event: (triggering_tid: {0})",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "about to process event: (triggering_tid: {0})", triggering_tid
); } while (0)
1808 triggering_tid)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "about to process event: (triggering_tid: {0})", triggering_tid
); } while (0);
1809
1810 m_pending_notification_tid = triggering_tid;
1811
1812 // Request a stop for all the thread stops that need to be stopped and are
1813 // not already known to be stopped.
1814 for (const auto &thread : m_threads) {
1815 if (StateIsRunningState(thread->GetState()))
1816 static_cast<NativeThreadLinux *>(thread.get())->RequestStop();
1817 }
1818
1819 SignalIfAllThreadsStopped();
1820 LLDB_LOG(log, "event processing done")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "event processing done"); } while (0);
1821}
1822
1823void NativeProcessLinux::SignalIfAllThreadsStopped() {
1824 if (m_pending_notification_tid == LLDB_INVALID_THREAD_ID0)
1825 return; // No pending notification. Nothing to do.
1826
1827 for (const auto &thread_sp : m_threads) {
1828 if (StateIsRunningState(thread_sp->GetState()))
1829 return; // Some threads are still running. Don't signal yet.
1830 }
1831
1832 // We have a pending notification and all threads have stopped.
1833 Log *log(
1834 GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1) | LIBLLDB_LOG_BREAKPOINTS(1u << 5)));
1835
1836 // Clear any temporary breakpoints we used to implement software single
1837 // stepping.
1838 for (const auto &thread_info : m_threads_stepping_with_breakpoint) {
1839 Status error = RemoveBreakpoint(thread_info.second);
1840 if (error.Fail())
1841 LLDB_LOG(log, "pid = {0} remove stepping breakpoint: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid = {0} remove stepping breakpoint: {1}", thread_info
.first, error); } while (0)
1842 thread_info.first, error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "pid = {0} remove stepping breakpoint: {1}", thread_info
.first, error); } while (0);
1843 }
1844 m_threads_stepping_with_breakpoint.clear();
1845
1846 // Notify the delegate about the stop
1847 SetCurrentThreadID(m_pending_notification_tid);
1848 SetState(StateType::eStateStopped, true);
1849 m_pending_notification_tid = LLDB_INVALID_THREAD_ID0;
1850}
1851
1852void NativeProcessLinux::ThreadWasCreated(NativeThreadLinux &thread) {
1853 Log *const log = ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD(1u << 2));
1854 LLDB_LOG(log, "tid: {0}", thread.GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "tid: {0}", thread.GetID()); } while (0);
1855
1856 if (m_pending_notification_tid != LLDB_INVALID_THREAD_ID0 &&
1857 StateIsRunningState(thread.GetState())) {
1858 // We will need to wait for this new thread to stop as well before firing
1859 // the notification.
1860 thread.RequestStop();
1861 }
1862}
1863
1864void NativeProcessLinux::SigchldHandler() {
1865 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS(1u << 1)));
1866
1867 // Threads can appear or disappear as a result of event processing, so gather
1868 // the events upfront.
1869 llvm::DenseMap<lldb::tid_t, WaitStatus> tid_events;
1870 for (const auto &thread_up : m_threads) {
1871 int status = -1;
1872 ::pid_t wait_pid =
1873 llvm::sys::RetryAfterSignal(-1, ::waitpid, thread_up->GetID(), &status,
1874 __WALL0x40000000 | __WNOTHREAD0x20000000 | WNOHANG1);
1875
1876 if (wait_pid == 0)
1877 continue; // Nothing to do for this thread.
1878
1879 if (wait_pid == -1) {
1880 Status error(errno(*__errno_location ()), eErrorTypePOSIX);
1881 LLDB_LOG(log, "waitpid({0}, &status, _) failed: {1}", thread_up->GetID(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "waitpid({0}, &status, _) failed: {1}", thread_up
->GetID(), error); } while (0)
1882 error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "waitpid({0}, &status, _) failed: {1}", thread_up
->GetID(), error); } while (0);
1883 continue;
1884 }
1885
1886 assert(wait_pid == static_cast<::pid_t>(thread_up->GetID()))(static_cast <bool> (wait_pid == static_cast<::pid_t
>(thread_up->GetID())) ? void (0) : __assert_fail ("wait_pid == static_cast<::pid_t>(thread_up->GetID())"
, "lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp",
1886, __extension__ __PRETTY_FUNCTION__));
1887
1888 WaitStatus wait_status = WaitStatus::Decode(status);
1889
1890 LLDB_LOG(log, "waitpid({0}) got status = {1}", thread_up->GetID(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "waitpid({0}) got status = {1}", thread_up->GetID
(), wait_status); } while (0)
1891 wait_status)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "waitpid({0}) got status = {1}", thread_up->GetID
(), wait_status); } while (0);
1892 tid_events.try_emplace(thread_up->GetID(), wait_status);
1893 }
1894
1895 for (auto &KV : tid_events) {
1896 LLDB_LOG(log, "processing {0}({1}) ...", KV.first, KV.second)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "processing {0}({1}) ...", KV.first, KV.second); }
while (0);
1897 NativeThreadLinux *thread = GetThreadByID(KV.first);
1898 if (thread) {
1899 MonitorCallback(*thread, KV.second);
1900 } else {
1901 // This can happen if one of the events is an main thread exit.
1902 LLDB_LOG(log, "... but the thread has disappeared")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "... but the thread has disappeared"); } while (0
);
1903 }
1904 }
1905}
1906
1907// Wrapper for ptrace to catch errors and log calls. Note that ptrace sets
1908// errno on error because -1 can be a valid result (i.e. for PTRACE_PEEK*)
1909Status NativeProcessLinux::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
1910 void *data, size_t data_size,
1911 long *result) {
1912 Status error;
1913 long int ret;
1914
1915 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE(1u << 5)));
1916
1917 PtraceDisplayBytes(req, data, data_size);
10
←
Calling 'PtraceDisplayBytes'
→
1918
1919 errno(*__errno_location ()) = 0;
1920 if (req == PTRACE_GETREGSETPTRACE_GETREGSET || req == PTRACE_SETREGSETPTRACE_SETREGSET)
1921 ret = ptrace(static_cast<__ptrace_request>(req), static_cast<::pid_t>(pid),
1922 *(unsigned int *)addr, data);
1923 else
1924 ret = ptrace(static_cast<__ptrace_request>(req), static_cast<::pid_t>(pid),
1925 addr, data);
1926
1927 if (ret == -1)
1928 error.SetErrorToErrno();
1929
1930 if (result)
1931 *result = ret;
1932
1933 LLDB_LOG(log, "ptrace({0}, {1}, {2}, {3}, {4})={5:x}", req, pid, addr, data,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "ptrace({0}, {1}, {2}, {3}, {4})={5:x}", req, pid
, addr, data, data_size, ret); } while (0)
1934 data_size, ret)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "ptrace({0}, {1}, {2}, {3}, {4})={5:x}", req, pid
, addr, data, data_size, ret); } while (0);
1935
1936 PtraceDisplayBytes(req, data, data_size);
1937
1938 if (error.Fail())
1939 LLDB_LOG(log, "ptrace() failed: {0}", error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp"
, __func__, "ptrace() failed: {0}", error); } while (0);
1940
1941 return error;
1942}
1943
1944llvm::Expected<TraceSupportedResponse> NativeProcessLinux::TraceSupported() {
1945 if (IntelPTManager::IsSupported())
1946 return TraceSupportedResponse{"intel-pt", "Intel Processor Trace"};
1947 return NativeProcessProtocol::TraceSupported();
1948}
1949
1950Error NativeProcessLinux::TraceStart(StringRef json_request, StringRef type) {
1951 if (type == "intel-pt") {
1952 if (Expected<TraceIntelPTStartRequest> request =
1953 json::parse<TraceIntelPTStartRequest>(json_request,
1954 "TraceIntelPTStartRequest")) {
1955 std::vector<lldb::tid_t> process_threads;
1956 for (auto &thread : m_threads)
1957 process_threads.push_back(thread->GetID());
1958 return m_intel_pt_manager.TraceStart(*request, process_threads);
1959 } else
1960 return request.takeError();
1961 }
1962
1963 return NativeProcessProtocol::TraceStart(json_request, type);
1964}
1965
1966Error NativeProcessLinux::TraceStop(const TraceStopRequest &request) {
1967 if (request.type == "intel-pt")
1968 return m_intel_pt_manager.TraceStop(request);
1969 return NativeProcessProtocol::TraceStop(request);
1970}
1971
1972Expected<json::Value> NativeProcessLinux::TraceGetState(StringRef type) {
1973 if (type == "intel-pt")
1974 return m_intel_pt_manager.GetState();
1975 return NativeProcessProtocol::TraceGetState(type);
1976}
1977
1978Expected<std::vector<uint8_t>> NativeProcessLinux::TraceGetBinaryData(
1979 const TraceGetBinaryDataRequest &request) {
1980 if (request.type == "intel-pt")
1981 return m_intel_pt_manager.GetBinaryData(request);
1982 return NativeProcessProtocol::TraceGetBinaryData(request);
1983}