Bug Summary

File:src/gnu/usr.bin/clang/liblldbPluginProcess/../../../llvm/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp
Warning:line 648, column 13
Value stored to 'had_nt_regs' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ProcessElfCore.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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbPluginProcess/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/liblldbPluginProcess/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginProcess/../include -I /usr/src/gnu/usr.bin/clang/liblldbPluginProcess/obj -I /usr/src/gnu/usr.bin/clang/liblldbPluginProcess/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -I /usr/src/gnu/usr.bin/clang/liblldbPluginProcess/../../../llvm/lldb/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginProcess/../../../llvm/lldb/source -I /usr/src/gnu/usr.bin/clang/liblldbPluginProcess/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginProcess/obj/../include/lldb/Plugins -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbPluginProcess/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/liblldbPluginProcess/../../../llvm/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp
1//===-- ProcessElfCore.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 <cstdlib>
10
11#include <memory>
12#include <mutex>
13
14#include "lldb/Core/Module.h"
15#include "lldb/Core/ModuleSpec.h"
16#include "lldb/Core/PluginManager.h"
17#include "lldb/Core/Section.h"
18#include "lldb/Target/DynamicLoader.h"
19#include "lldb/Target/MemoryRegionInfo.h"
20#include "lldb/Target/Target.h"
21#include "lldb/Target/UnixSignals.h"
22#include "lldb/Utility/DataBufferHeap.h"
23#include "lldb/Utility/Log.h"
24#include "lldb/Utility/State.h"
25
26#include "llvm/BinaryFormat/ELF.h"
27#include "llvm/Support/Threading.h"
28
29#include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
30#include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
31#include "Plugins/Process/elf-core/RegisterUtilities.h"
32#include "ProcessElfCore.h"
33#include "ThreadElfCore.h"
34
35using namespace lldb_private;
36namespace ELF = llvm::ELF;
37
38LLDB_PLUGIN_DEFINE(ProcessElfCore)namespace lldb_private { void lldb_initialize_ProcessElfCore(
) { ProcessElfCore::Initialize(); } void lldb_terminate_ProcessElfCore
() { ProcessElfCore::Terminate(); } }
39
40ConstString ProcessElfCore::GetPluginNameStatic() {
41 static ConstString g_name("elf-core");
42 return g_name;
43}
44
45const char *ProcessElfCore::GetPluginDescriptionStatic() {
46 return "ELF core dump plug-in.";
47}
48
49void ProcessElfCore::Terminate() {
50 PluginManager::UnregisterPlugin(ProcessElfCore::CreateInstance);
51}
52
53lldb::ProcessSP ProcessElfCore::CreateInstance(lldb::TargetSP target_sp,
54 lldb::ListenerSP listener_sp,
55 const FileSpec *crash_file,
56 bool can_connect) {
57 lldb::ProcessSP process_sp;
58 if (crash_file && !can_connect) {
59 // Read enough data for a ELF32 header or ELF64 header Note: Here we care
60 // about e_type field only, so it is safe to ignore possible presence of
61 // the header extension.
62 const size_t header_size = sizeof(llvm::ELF::Elf64_Ehdr);
63
64 auto data_sp = FileSystem::Instance().CreateDataBuffer(
65 crash_file->GetPath(), header_size, 0);
66 if (data_sp && data_sp->GetByteSize() == header_size &&
67 elf::ELFHeader::MagicBytesMatch(data_sp->GetBytes())) {
68 elf::ELFHeader elf_header;
69 DataExtractor data(data_sp, lldb::eByteOrderLittle, 4);
70 lldb::offset_t data_offset = 0;
71 if (elf_header.Parse(data, &data_offset)) {
72 if (elf_header.e_type == llvm::ELF::ET_CORE)
73 process_sp = std::make_shared<ProcessElfCore>(target_sp, listener_sp,
74 *crash_file);
75 }
76 }
77 }
78 return process_sp;
79}
80
81bool ProcessElfCore::CanDebug(lldb::TargetSP target_sp,
82 bool plugin_specified_by_name) {
83 // For now we are just making sure the file exists for a given module
84 if (!m_core_module_sp && FileSystem::Instance().Exists(m_core_file)) {
85 ModuleSpec core_module_spec(m_core_file, target_sp->GetArchitecture());
86 Status error(ModuleList::GetSharedModule(core_module_spec, m_core_module_sp,
87 nullptr, nullptr, nullptr));
88 if (m_core_module_sp) {
89 ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
90 if (core_objfile && core_objfile->GetType() == ObjectFile::eTypeCoreFile)
91 return true;
92 }
93 }
94 return false;
95}
96
97// ProcessElfCore constructor
98ProcessElfCore::ProcessElfCore(lldb::TargetSP target_sp,
99 lldb::ListenerSP listener_sp,
100 const FileSpec &core_file)
101 : PostMortemProcess(target_sp, listener_sp), m_core_file(core_file) {}
102
103// Destructor
104ProcessElfCore::~ProcessElfCore() {
105 Clear();
106 // We need to call finalize on the process before destroying ourselves to
107 // make sure all of the broadcaster cleanup goes as planned. If we destruct
108 // this class, then Process::~Process() might have problems trying to fully
109 // destroy the broadcaster.
110 Finalize();
111}
112
113// PluginInterface
114ConstString ProcessElfCore::GetPluginName() { return GetPluginNameStatic(); }
115
116uint32_t ProcessElfCore::GetPluginVersion() { return 1; }
117
118lldb::addr_t ProcessElfCore::AddAddressRangeFromLoadSegment(
119 const elf::ELFProgramHeader &header) {
120 const lldb::addr_t addr = header.p_vaddr;
121 FileRange file_range(header.p_offset, header.p_filesz);
122 VMRangeToFileOffset::Entry range_entry(addr, header.p_memsz, file_range);
123
124 // Only add to m_core_aranges if the file size is non zero. Some core files
125 // have PT_LOAD segments for all address ranges, but set f_filesz to zero for
126 // the .text sections since they can be retrieved from the object files.
127 if (header.p_filesz > 0) {
128 VMRangeToFileOffset::Entry *last_entry = m_core_aranges.Back();
129 if (last_entry && last_entry->GetRangeEnd() == range_entry.GetRangeBase() &&
130 last_entry->data.GetRangeEnd() == range_entry.data.GetRangeBase() &&
131 last_entry->GetByteSize() == last_entry->data.GetByteSize()) {
132 last_entry->SetRangeEnd(range_entry.GetRangeEnd());
133 last_entry->data.SetRangeEnd(range_entry.data.GetRangeEnd());
134 } else {
135 m_core_aranges.Append(range_entry);
136 }
137 }
138 // Keep a separate map of permissions that that isn't coalesced so all ranges
139 // are maintained.
140 const uint32_t permissions =
141 ((header.p_flags & llvm::ELF::PF_R) ? lldb::ePermissionsReadable : 0u) |
142 ((header.p_flags & llvm::ELF::PF_W) ? lldb::ePermissionsWritable : 0u) |
143 ((header.p_flags & llvm::ELF::PF_X) ? lldb::ePermissionsExecutable : 0u);
144
145 m_core_range_infos.Append(
146 VMRangeToPermissions::Entry(addr, header.p_memsz, permissions));
147
148 return addr;
149}
150
151// Process Control
152Status ProcessElfCore::DoLoadCore() {
153 Status error;
154 if (!m_core_module_sp) {
155 error.SetErrorString("invalid core module");
156 return error;
157 }
158
159 ObjectFileELF *core = (ObjectFileELF *)(m_core_module_sp->GetObjectFile());
160 if (core == nullptr) {
161 error.SetErrorString("invalid core object file");
162 return error;
163 }
164
165 llvm::ArrayRef<elf::ELFProgramHeader> segments = core->ProgramHeaders();
166 if (segments.size() == 0) {
167 error.SetErrorString("core file has no segments");
168 return error;
169 }
170
171 SetCanJIT(false);
172
173 m_thread_data_valid = true;
174
175 bool ranges_are_sorted = true;
176 lldb::addr_t vm_addr = 0;
177 /// Walk through segments and Thread and Address Map information.
178 /// PT_NOTE - Contains Thread and Register information
179 /// PT_LOAD - Contains a contiguous range of Process Address Space
180 for (const elf::ELFProgramHeader &H : segments) {
181 DataExtractor data = core->GetSegmentData(H);
182
183 // Parse thread contexts and auxv structure
184 if (H.p_type == llvm::ELF::PT_NOTE) {
185 if (llvm::Error error = ParseThreadContextsFromNoteSegment(H, data))
186 return Status(std::move(error));
187 }
188 // PT_LOAD segments contains address map
189 if (H.p_type == llvm::ELF::PT_LOAD) {
190 lldb::addr_t last_addr = AddAddressRangeFromLoadSegment(H);
191 if (vm_addr > last_addr)
192 ranges_are_sorted = false;
193 vm_addr = last_addr;
194 }
195 }
196
197 if (!ranges_are_sorted) {
198 m_core_aranges.Sort();
199 m_core_range_infos.Sort();
200 }
201
202 // Even if the architecture is set in the target, we need to override it to
203 // match the core file which is always single arch.
204 ArchSpec arch(m_core_module_sp->GetArchitecture());
205
206 ArchSpec target_arch = GetTarget().GetArchitecture();
207 ArchSpec core_arch(m_core_module_sp->GetArchitecture());
208 target_arch.MergeFrom(core_arch);
209 GetTarget().SetArchitecture(target_arch);
210
211 SetUnixSignals(UnixSignals::Create(GetArchitecture()));
212
213 // Ensure we found at least one thread that was stopped on a signal.
214 bool siginfo_signal_found = false;
215 bool prstatus_signal_found = false;
216 // Check we found a signal in a SIGINFO note.
217 for (const auto &thread_data : m_thread_data) {
218 if (thread_data.signo != 0)
219 siginfo_signal_found = true;
220 if (thread_data.prstatus_sig != 0)
221 prstatus_signal_found = true;
222 }
223 if (!siginfo_signal_found) {
224 // If we don't have signal from SIGINFO use the signal from each threads
225 // PRSTATUS note.
226 if (prstatus_signal_found) {
227 for (auto &thread_data : m_thread_data)
228 thread_data.signo = thread_data.prstatus_sig;
229 } else if (m_thread_data.size() > 0) {
230 // If all else fails force the first thread to be SIGSTOP
231 m_thread_data.begin()->signo =
232 GetUnixSignals()->GetSignalNumberFromName("SIGSTOP");
233 }
234 }
235
236 // Core files are useless without the main executable. See if we can locate
237 // the main executable using data we found in the core file notes.
238 lldb::ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
239 if (!exe_module_sp) {
240 // The first entry in the NT_FILE might be our executable
241 if (!m_nt_file_entries.empty()) {
242 ModuleSpec exe_module_spec;
243 exe_module_spec.GetArchitecture() = arch;
244 exe_module_spec.GetFileSpec().SetFile(
245 m_nt_file_entries[0].path.GetCString(), FileSpec::Style::native);
246 if (exe_module_spec.GetFileSpec()) {
247 exe_module_sp = GetTarget().GetOrCreateModule(exe_module_spec,
248 true /* notify */);
249 if (exe_module_sp)
250 GetTarget().SetExecutableModule(exe_module_sp, eLoadDependentsNo);
251 }
252 }
253 }
254 return error;
255}
256
257lldb_private::DynamicLoader *ProcessElfCore::GetDynamicLoader() {
258 if (m_dyld_up.get() == nullptr)
259 m_dyld_up.reset(DynamicLoader::FindPlugin(
260 this, DynamicLoaderPOSIXDYLD::GetPluginNameStatic().GetCString()));
261 return m_dyld_up.get();
262}
263
264bool ProcessElfCore::DoUpdateThreadList(ThreadList &old_thread_list,
265 ThreadList &new_thread_list) {
266 const uint32_t num_threads = GetNumThreadContexts();
267 if (!m_thread_data_valid)
268 return false;
269
270 for (lldb::tid_t tid = 0; tid < num_threads; ++tid) {
271 const ThreadData &td = m_thread_data[tid];
272 lldb::ThreadSP thread_sp(new ThreadElfCore(*this, td));
273 new_thread_list.AddThread(thread_sp);
274 }
275 return new_thread_list.GetSize(false) > 0;
276}
277
278void ProcessElfCore::RefreshStateAfterStop() {}
279
280Status ProcessElfCore::DoDestroy() { return Status(); }
281
282// Process Queries
283
284bool ProcessElfCore::IsAlive() { return true; }
285
286// Process Memory
287size_t ProcessElfCore::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
288 Status &error) {
289 // Don't allow the caching that lldb_private::Process::ReadMemory does since
290 // in core files we have it all cached our our core file anyway.
291 return DoReadMemory(addr, buf, size, error);
292}
293
294Status ProcessElfCore::GetMemoryRegionInfo(lldb::addr_t load_addr,
295 MemoryRegionInfo &region_info) {
296 region_info.Clear();
297 const VMRangeToPermissions::Entry *permission_entry =
298 m_core_range_infos.FindEntryThatContainsOrFollows(load_addr);
299 if (permission_entry) {
300 if (permission_entry->Contains(load_addr)) {
301 region_info.GetRange().SetRangeBase(permission_entry->GetRangeBase());
302 region_info.GetRange().SetRangeEnd(permission_entry->GetRangeEnd());
303 const Flags permissions(permission_entry->data);
304 region_info.SetReadable(permissions.Test(lldb::ePermissionsReadable)
305 ? MemoryRegionInfo::eYes
306 : MemoryRegionInfo::eNo);
307 region_info.SetWritable(permissions.Test(lldb::ePermissionsWritable)
308 ? MemoryRegionInfo::eYes
309 : MemoryRegionInfo::eNo);
310 region_info.SetExecutable(permissions.Test(lldb::ePermissionsExecutable)
311 ? MemoryRegionInfo::eYes
312 : MemoryRegionInfo::eNo);
313 region_info.SetMapped(MemoryRegionInfo::eYes);
314 } else if (load_addr < permission_entry->GetRangeBase()) {
315 region_info.GetRange().SetRangeBase(load_addr);
316 region_info.GetRange().SetRangeEnd(permission_entry->GetRangeBase());
317 region_info.SetReadable(MemoryRegionInfo::eNo);
318 region_info.SetWritable(MemoryRegionInfo::eNo);
319 region_info.SetExecutable(MemoryRegionInfo::eNo);
320 region_info.SetMapped(MemoryRegionInfo::eNo);
321 }
322 return Status();
323 }
324
325 region_info.GetRange().SetRangeBase(load_addr);
326 region_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS0xffffffffffffffffULL);
327 region_info.SetReadable(MemoryRegionInfo::eNo);
328 region_info.SetWritable(MemoryRegionInfo::eNo);
329 region_info.SetExecutable(MemoryRegionInfo::eNo);
330 region_info.SetMapped(MemoryRegionInfo::eNo);
331 return Status();
332}
333
334size_t ProcessElfCore::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
335 Status &error) {
336 ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
337
338 if (core_objfile == nullptr)
339 return 0;
340
341 // Get the address range
342 const VMRangeToFileOffset::Entry *address_range =
343 m_core_aranges.FindEntryThatContains(addr);
344 if (address_range == nullptr || address_range->GetRangeEnd() < addr) {
345 error.SetErrorStringWithFormat("core file does not contain 0x%" PRIx64"llx",
346 addr);
347 return 0;
348 }
349
350 // Convert the address into core file offset
351 const lldb::addr_t offset = addr - address_range->GetRangeBase();
352 const lldb::addr_t file_start = address_range->data.GetRangeBase();
353 const lldb::addr_t file_end = address_range->data.GetRangeEnd();
354 size_t bytes_to_read = size; // Number of bytes to read from the core file
355 size_t bytes_copied = 0; // Number of bytes actually read from the core file
356 lldb::addr_t bytes_left =
357 0; // Number of bytes available in the core file from the given address
358
359 // Don't proceed if core file doesn't contain the actual data for this
360 // address range.
361 if (file_start == file_end)
362 return 0;
363
364 // Figure out how many on-disk bytes remain in this segment starting at the
365 // given offset
366 if (file_end > file_start + offset)
367 bytes_left = file_end - (file_start + offset);
368
369 if (bytes_to_read > bytes_left)
370 bytes_to_read = bytes_left;
371
372 // If there is data available on the core file read it
373 if (bytes_to_read)
374 bytes_copied =
375 core_objfile->CopyData(offset + file_start, bytes_to_read, buf);
376
377 return bytes_copied;
378}
379
380void ProcessElfCore::Clear() {
381 m_thread_list.Clear();
382
383 SetUnixSignals(std::make_shared<UnixSignals>());
384}
385
386void ProcessElfCore::Initialize() {
387 static llvm::once_flag g_once_flag;
388
389 llvm::call_once(g_once_flag, []() {
390 PluginManager::RegisterPlugin(GetPluginNameStatic(),
391 GetPluginDescriptionStatic(), CreateInstance);
392 });
393}
394
395lldb::addr_t ProcessElfCore::GetImageInfoAddress() {
396 ObjectFile *obj_file = GetTarget().GetExecutableModule()->GetObjectFile();
397 Address addr = obj_file->GetImageInfoAddress(&GetTarget());
398
399 if (addr.IsValid())
400 return addr.GetLoadAddress(&GetTarget());
401 return LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
402}
403
404// Parse a FreeBSD NT_PRSTATUS note - see FreeBSD sys/procfs.h for details.
405static void ParseFreeBSDPrStatus(ThreadData &thread_data,
406 const DataExtractor &data,
407 bool lp64) {
408 lldb::offset_t offset = 0;
409 int pr_version = data.GetU32(&offset);
410
411 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
412 if (log) {
413 if (pr_version > 1)
414 LLDB_LOGF(log, "FreeBSD PRSTATUS unexpected version %d", pr_version)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("FreeBSD PRSTATUS unexpected version %d"
, pr_version); } while (0);
415 }
416
417 // Skip padding, pr_statussz, pr_gregsetsz, pr_fpregsetsz, pr_osreldate
418 if (lp64)
419 offset += 32;
420 else
421 offset += 16;
422
423 thread_data.signo = data.GetU32(&offset); // pr_cursig
424 thread_data.tid = data.GetU32(&offset); // pr_pid
425 if (lp64)
426 offset += 4;
427
428 size_t len = data.GetByteSize() - offset;
429 thread_data.gpregset = DataExtractor(data, offset, len);
430}
431
432// Parse a FreeBSD NT_PRPSINFO note - see FreeBSD sys/procfs.h for details.
433static void ParseFreeBSDPrPsInfo(ProcessElfCore &process,
434 const DataExtractor &data,
435 bool lp64) {
436 lldb::offset_t offset = 0;
437 int pr_version = data.GetU32(&offset);
438
439 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
440 if (log) {
441 if (pr_version > 1)
442 LLDB_LOGF(log, "FreeBSD PRPSINFO unexpected version %d", pr_version)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("FreeBSD PRPSINFO unexpected version %d"
, pr_version); } while (0);
443 }
444
445 // Skip pr_psinfosz, pr_fname, pr_psargs
446 offset += 108;
447 if (lp64)
448 offset += 4;
449
450 process.SetID(data.GetU32(&offset)); // pr_pid
451}
452
453static llvm::Error ParseNetBSDProcInfo(const DataExtractor &data,
454 uint32_t &cpi_nlwps,
455 uint32_t &cpi_signo,
456 uint32_t &cpi_siglwp,
457 uint32_t &cpi_pid) {
458 lldb::offset_t offset = 0;
459
460 uint32_t version = data.GetU32(&offset);
461 if (version != 1)
462 return llvm::make_error<llvm::StringError>(
463 "Error parsing NetBSD core(5) notes: Unsupported procinfo version",
464 llvm::inconvertibleErrorCode());
465
466 uint32_t cpisize = data.GetU32(&offset);
467 if (cpisize != NETBSD::NT_PROCINFO_SIZE)
468 return llvm::make_error<llvm::StringError>(
469 "Error parsing NetBSD core(5) notes: Unsupported procinfo size",
470 llvm::inconvertibleErrorCode());
471
472 cpi_signo = data.GetU32(&offset); /* killing signal */
473
474 offset += NETBSD::NT_PROCINFO_CPI_SIGCODE_SIZE;
475 offset += NETBSD::NT_PROCINFO_CPI_SIGPEND_SIZE;
476 offset += NETBSD::NT_PROCINFO_CPI_SIGMASK_SIZE;
477 offset += NETBSD::NT_PROCINFO_CPI_SIGIGNORE_SIZE;
478 offset += NETBSD::NT_PROCINFO_CPI_SIGCATCH_SIZE;
479 cpi_pid = data.GetU32(&offset);
480 offset += NETBSD::NT_PROCINFO_CPI_PPID_SIZE;
481 offset += NETBSD::NT_PROCINFO_CPI_PGRP_SIZE;
482 offset += NETBSD::NT_PROCINFO_CPI_SID_SIZE;
483 offset += NETBSD::NT_PROCINFO_CPI_RUID_SIZE;
484 offset += NETBSD::NT_PROCINFO_CPI_EUID_SIZE;
485 offset += NETBSD::NT_PROCINFO_CPI_SVUID_SIZE;
486 offset += NETBSD::NT_PROCINFO_CPI_RGID_SIZE;
487 offset += NETBSD::NT_PROCINFO_CPI_EGID_SIZE;
488 offset += NETBSD::NT_PROCINFO_CPI_SVGID_SIZE;
489 cpi_nlwps = data.GetU32(&offset); /* number of LWPs */
490
491 offset += NETBSD::NT_PROCINFO_CPI_NAME_SIZE;
492 cpi_siglwp = data.GetU32(&offset); /* LWP target of killing signal */
493
494 return llvm::Error::success();
495}
496
497static void ParseOpenBSDProcInfo(ThreadData &thread_data,
498 const DataExtractor &data) {
499 lldb::offset_t offset = 0;
500
501 int version = data.GetU32(&offset);
502 if (version != 1)
503 return;
504
505 offset += 4;
506 thread_data.signo = data.GetU32(&offset);
507}
508
509llvm::Expected<std::vector<CoreNote>>
510ProcessElfCore::parseSegment(const DataExtractor &segment) {
511 lldb::offset_t offset = 0;
512 std::vector<CoreNote> result;
513
514 while (offset < segment.GetByteSize()) {
515 ELFNote note = ELFNote();
516 if (!note.Parse(segment, &offset))
517 return llvm::make_error<llvm::StringError>(
518 "Unable to parse note segment", llvm::inconvertibleErrorCode());
519
520 size_t note_start = offset;
521 size_t note_size = llvm::alignTo(note.n_descsz, 4);
522 DataExtractor note_data(segment, note_start, note_size);
523
524 result.push_back({note, note_data});
525 offset += note_size;
526 }
527
528 return std::move(result);
529}
530
531llvm::Error ProcessElfCore::parseFreeBSDNotes(llvm::ArrayRef<CoreNote> notes) {
532 ArchSpec arch = GetArchitecture();
533 bool lp64 = (arch.GetMachine() == llvm::Triple::aarch64 ||
534 arch.GetMachine() == llvm::Triple::mips64 ||
535 arch.GetMachine() == llvm::Triple::ppc64 ||
536 arch.GetMachine() == llvm::Triple::x86_64);
537 bool have_prstatus = false;
538 bool have_prpsinfo = false;
539 ThreadData thread_data;
540 for (const auto &note : notes) {
541 if (note.info.n_name != "FreeBSD")
542 continue;
543
544 if ((note.info.n_type == ELF::NT_PRSTATUS && have_prstatus) ||
545 (note.info.n_type == ELF::NT_PRPSINFO && have_prpsinfo)) {
546 assert(thread_data.gpregset.GetByteSize() > 0)((void)0);
547 // Add the new thread to thread list
548 m_thread_data.push_back(thread_data);
549 thread_data = ThreadData();
550 have_prstatus = false;
551 have_prpsinfo = false;
552 }
553
554 switch (note.info.n_type) {
555 case ELF::NT_PRSTATUS:
556 have_prstatus = true;
557 ParseFreeBSDPrStatus(thread_data, note.data, lp64);
558 break;
559 case ELF::NT_PRPSINFO:
560 have_prpsinfo = true;
561 ParseFreeBSDPrPsInfo(*this, note.data, lp64);
562 break;
563 case ELF::NT_FREEBSD_THRMISC: {
564 lldb::offset_t offset = 0;
565 thread_data.name = note.data.GetCStr(&offset, 20);
566 break;
567 }
568 case ELF::NT_FREEBSD_PROCSTAT_AUXV:
569 // FIXME: FreeBSD sticks an int at the beginning of the note
570 m_auxv = DataExtractor(note.data, 4, note.data.GetByteSize() - 4);
571 break;
572 default:
573 thread_data.notes.push_back(note);
574 break;
575 }
576 }
577 if (!have_prstatus) {
578 return llvm::make_error<llvm::StringError>(
579 "Could not find NT_PRSTATUS note in core file.",
580 llvm::inconvertibleErrorCode());
581 }
582 m_thread_data.push_back(thread_data);
583 return llvm::Error::success();
584}
585
586/// NetBSD specific Thread context from PT_NOTE segment
587///
588/// NetBSD ELF core files use notes to provide information about
589/// the process's state. The note name is "NetBSD-CORE" for
590/// information that is global to the process, and "NetBSD-CORE@nn",
591/// where "nn" is the lwpid of the LWP that the information belongs
592/// to (such as register state).
593///
594/// NetBSD uses the following note identifiers:
595///
596/// ELF_NOTE_NETBSD_CORE_PROCINFO (value 1)
597/// Note is a "netbsd_elfcore_procinfo" structure.
598/// ELF_NOTE_NETBSD_CORE_AUXV (value 2; since NetBSD 8.0)
599/// Note is an array of AuxInfo structures.
600///
601/// NetBSD also uses ptrace(2) request numbers (the ones that exist in
602/// machine-dependent space) to identify register info notes. The
603/// info in such notes is in the same format that ptrace(2) would
604/// export that information.
605///
606/// For more information see /usr/include/sys/exec_elf.h
607///
608llvm::Error ProcessElfCore::parseNetBSDNotes(llvm::ArrayRef<CoreNote> notes) {
609 ThreadData thread_data;
610 bool had_nt_regs = false;
611
612 // To be extracted from struct netbsd_elfcore_procinfo
613 // Used to sanity check of the LWPs of the process
614 uint32_t nlwps = 0;
615 uint32_t signo; // killing signal
616 uint32_t siglwp; // LWP target of killing signal
617 uint32_t pr_pid;
618
619 for (const auto &note : notes) {
620 llvm::StringRef name = note.info.n_name;
621
622 if (name == "NetBSD-CORE") {
623 if (note.info.n_type == NETBSD::NT_PROCINFO) {
624 llvm::Error error = ParseNetBSDProcInfo(note.data, nlwps, signo,
625 siglwp, pr_pid);
626 if (error)
627 return error;
628 SetID(pr_pid);
629 } else if (note.info.n_type == NETBSD::NT_AUXV) {
630 m_auxv = note.data;
631 }
632 } else if (name.consume_front("NetBSD-CORE@")) {
633 lldb::tid_t tid;
634 if (name.getAsInteger(10, tid))
635 return llvm::make_error<llvm::StringError>(
636 "Error parsing NetBSD core(5) notes: Cannot convert LWP ID "
637 "to integer",
638 llvm::inconvertibleErrorCode());
639
640 switch (GetArchitecture().GetMachine()) {
641 case llvm::Triple::aarch64: {
642 // Assume order PT_GETREGS, PT_GETFPREGS
643 if (note.info.n_type == NETBSD::AARCH64::NT_REGS) {
644 // If this is the next thread, push the previous one first.
645 if (had_nt_regs) {
646 m_thread_data.push_back(thread_data);
647 thread_data = ThreadData();
648 had_nt_regs = false;
Value stored to 'had_nt_regs' is never read
649 }
650
651 thread_data.gpregset = note.data;
652 thread_data.tid = tid;
653 if (thread_data.gpregset.GetByteSize() == 0)
654 return llvm::make_error<llvm::StringError>(
655 "Could not find general purpose registers note in core file.",
656 llvm::inconvertibleErrorCode());
657 had_nt_regs = true;
658 } else if (note.info.n_type == NETBSD::AARCH64::NT_FPREGS) {
659 if (!had_nt_regs || tid != thread_data.tid)
660 return llvm::make_error<llvm::StringError>(
661 "Error parsing NetBSD core(5) notes: Unexpected order "
662 "of NOTEs PT_GETFPREG before PT_GETREG",
663 llvm::inconvertibleErrorCode());
664 thread_data.notes.push_back(note);
665 }
666 } break;
667 case llvm::Triple::x86: {
668 // Assume order PT_GETREGS, PT_GETFPREGS
669 if (note.info.n_type == NETBSD::I386::NT_REGS) {
670 // If this is the next thread, push the previous one first.
671 if (had_nt_regs) {
672 m_thread_data.push_back(thread_data);
673 thread_data = ThreadData();
674 had_nt_regs = false;
675 }
676
677 thread_data.gpregset = note.data;
678 thread_data.tid = tid;
679 if (thread_data.gpregset.GetByteSize() == 0)
680 return llvm::make_error<llvm::StringError>(
681 "Could not find general purpose registers note in core file.",
682 llvm::inconvertibleErrorCode());
683 had_nt_regs = true;
684 } else if (note.info.n_type == NETBSD::I386::NT_FPREGS) {
685 if (!had_nt_regs || tid != thread_data.tid)
686 return llvm::make_error<llvm::StringError>(
687 "Error parsing NetBSD core(5) notes: Unexpected order "
688 "of NOTEs PT_GETFPREG before PT_GETREG",
689 llvm::inconvertibleErrorCode());
690 thread_data.notes.push_back(note);
691 }
692 } break;
693 case llvm::Triple::x86_64: {
694 // Assume order PT_GETREGS, PT_GETFPREGS
695 if (note.info.n_type == NETBSD::AMD64::NT_REGS) {
696 // If this is the next thread, push the previous one first.
697 if (had_nt_regs) {
698 m_thread_data.push_back(thread_data);
699 thread_data = ThreadData();
700 had_nt_regs = false;
701 }
702
703 thread_data.gpregset = note.data;
704 thread_data.tid = tid;
705 if (thread_data.gpregset.GetByteSize() == 0)
706 return llvm::make_error<llvm::StringError>(
707 "Could not find general purpose registers note in core file.",
708 llvm::inconvertibleErrorCode());
709 had_nt_regs = true;
710 } else if (note.info.n_type == NETBSD::AMD64::NT_FPREGS) {
711 if (!had_nt_regs || tid != thread_data.tid)
712 return llvm::make_error<llvm::StringError>(
713 "Error parsing NetBSD core(5) notes: Unexpected order "
714 "of NOTEs PT_GETFPREG before PT_GETREG",
715 llvm::inconvertibleErrorCode());
716 thread_data.notes.push_back(note);
717 }
718 } break;
719 default:
720 break;
721 }
722 }
723 }
724
725 // Push the last thread.
726 if (had_nt_regs)
727 m_thread_data.push_back(thread_data);
728
729 if (m_thread_data.empty())
730 return llvm::make_error<llvm::StringError>(
731 "Error parsing NetBSD core(5) notes: No threads information "
732 "specified in notes",
733 llvm::inconvertibleErrorCode());
734
735 if (m_thread_data.size() != nlwps)
736 return llvm::make_error<llvm::StringError>(
737 "Error parsing NetBSD core(5) notes: Mismatch between the number "
738 "of LWPs in netbsd_elfcore_procinfo and the number of LWPs specified "
739 "by MD notes",
740 llvm::inconvertibleErrorCode());
741
742 // Signal targeted at the whole process.
743 if (siglwp == 0) {
744 for (auto &data : m_thread_data)
745 data.signo = signo;
746 }
747 // Signal destined for a particular LWP.
748 else {
749 bool passed = false;
750
751 for (auto &data : m_thread_data) {
752 if (data.tid == siglwp) {
753 data.signo = signo;
754 passed = true;
755 break;
756 }
757 }
758
759 if (!passed)
760 return llvm::make_error<llvm::StringError>(
761 "Error parsing NetBSD core(5) notes: Signal passed to unknown LWP",
762 llvm::inconvertibleErrorCode());
763 }
764
765 return llvm::Error::success();
766}
767
768llvm::Error ProcessElfCore::parseOpenBSDNotes(llvm::ArrayRef<CoreNote> notes) {
769 ThreadData thread_data;
770 for (const auto &note : notes) {
771 // OpenBSD per-thread information is stored in notes named "OpenBSD@nnn" so
772 // match on the initial part of the string.
773 if (!llvm::StringRef(note.info.n_name).startswith("OpenBSD"))
774 continue;
775
776 switch (note.info.n_type) {
777 case OPENBSD::NT_PROCINFO:
778 ParseOpenBSDProcInfo(thread_data, note.data);
779 break;
780 case OPENBSD::NT_AUXV:
781 m_auxv = note.data;
782 break;
783 case OPENBSD::NT_REGS:
784 thread_data.gpregset = note.data;
785 break;
786 default:
787 thread_data.notes.push_back(note);
788 break;
789 }
790 }
791 if (thread_data.gpregset.GetByteSize() == 0) {
792 return llvm::make_error<llvm::StringError>(
793 "Could not find general purpose registers note in core file.",
794 llvm::inconvertibleErrorCode());
795 }
796 m_thread_data.push_back(thread_data);
797 return llvm::Error::success();
798}
799
800/// A description of a linux process usually contains the following NOTE
801/// entries:
802/// - NT_PRPSINFO - General process information like pid, uid, name, ...
803/// - NT_SIGINFO - Information about the signal that terminated the process
804/// - NT_AUXV - Process auxiliary vector
805/// - NT_FILE - Files mapped into memory
806///
807/// Additionally, for each thread in the process the core file will contain at
808/// least the NT_PRSTATUS note, containing the thread id and general purpose
809/// registers. It may include additional notes for other register sets (floating
810/// point and vector registers, ...). The tricky part here is that some of these
811/// notes have "CORE" in their owner fields, while other set it to "LINUX".
812llvm::Error ProcessElfCore::parseLinuxNotes(llvm::ArrayRef<CoreNote> notes) {
813 const ArchSpec &arch = GetArchitecture();
814 bool have_prstatus = false;
815 bool have_prpsinfo = false;
816 ThreadData thread_data;
817 for (const auto &note : notes) {
818 if (note.info.n_name != "CORE" && note.info.n_name != "LINUX")
819 continue;
820
821 if ((note.info.n_type == ELF::NT_PRSTATUS && have_prstatus) ||
822 (note.info.n_type == ELF::NT_PRPSINFO && have_prpsinfo)) {
823 assert(thread_data.gpregset.GetByteSize() > 0)((void)0);
824 // Add the new thread to thread list
825 m_thread_data.push_back(thread_data);
826 thread_data = ThreadData();
827 have_prstatus = false;
828 have_prpsinfo = false;
829 }
830
831 switch (note.info.n_type) {
832 case ELF::NT_PRSTATUS: {
833 have_prstatus = true;
834 ELFLinuxPrStatus prstatus;
835 Status status = prstatus.Parse(note.data, arch);
836 if (status.Fail())
837 return status.ToError();
838 thread_data.prstatus_sig = prstatus.pr_cursig;
839 thread_data.tid = prstatus.pr_pid;
840 uint32_t header_size = ELFLinuxPrStatus::GetSize(arch);
841 size_t len = note.data.GetByteSize() - header_size;
842 thread_data.gpregset = DataExtractor(note.data, header_size, len);
843 break;
844 }
845 case ELF::NT_PRPSINFO: {
846 have_prpsinfo = true;
847 ELFLinuxPrPsInfo prpsinfo;
848 Status status = prpsinfo.Parse(note.data, arch);
849 if (status.Fail())
850 return status.ToError();
851 thread_data.name.assign (prpsinfo.pr_fname, strnlen (prpsinfo.pr_fname, sizeof (prpsinfo.pr_fname)));
852 SetID(prpsinfo.pr_pid);
853 break;
854 }
855 case ELF::NT_SIGINFO: {
856 ELFLinuxSigInfo siginfo;
857 Status status = siginfo.Parse(note.data, arch);
858 if (status.Fail())
859 return status.ToError();
860 thread_data.signo = siginfo.si_signo;
861 break;
862 }
863 case ELF::NT_FILE: {
864 m_nt_file_entries.clear();
865 lldb::offset_t offset = 0;
866 const uint64_t count = note.data.GetAddress(&offset);
867 note.data.GetAddress(&offset); // Skip page size
868 for (uint64_t i = 0; i < count; ++i) {
869 NT_FILE_Entry entry;
870 entry.start = note.data.GetAddress(&offset);
871 entry.end = note.data.GetAddress(&offset);
872 entry.file_ofs = note.data.GetAddress(&offset);
873 m_nt_file_entries.push_back(entry);
874 }
875 for (uint64_t i = 0; i < count; ++i) {
876 const char *path = note.data.GetCStr(&offset);
877 if (path && path[0])
878 m_nt_file_entries[i].path.SetCString(path);
879 }
880 break;
881 }
882 case ELF::NT_AUXV:
883 m_auxv = note.data;
884 break;
885 default:
886 thread_data.notes.push_back(note);
887 break;
888 }
889 }
890 // Add last entry in the note section
891 if (have_prstatus)
892 m_thread_data.push_back(thread_data);
893 return llvm::Error::success();
894}
895
896/// Parse Thread context from PT_NOTE segment and store it in the thread list
897/// A note segment consists of one or more NOTE entries, but their types and
898/// meaning differ depending on the OS.
899llvm::Error ProcessElfCore::ParseThreadContextsFromNoteSegment(
900 const elf::ELFProgramHeader &segment_header, DataExtractor segment_data) {
901 assert(segment_header.p_type == llvm::ELF::PT_NOTE)((void)0);
902
903 auto notes_or_error = parseSegment(segment_data);
904 if(!notes_or_error)
905 return notes_or_error.takeError();
906 switch (GetArchitecture().GetTriple().getOS()) {
907 case llvm::Triple::FreeBSD:
908 return parseFreeBSDNotes(*notes_or_error);
909 case llvm::Triple::Linux:
910 return parseLinuxNotes(*notes_or_error);
911 case llvm::Triple::NetBSD:
912 return parseNetBSDNotes(*notes_or_error);
913 case llvm::Triple::OpenBSD:
914 return parseOpenBSDNotes(*notes_or_error);
915 default:
916 return llvm::make_error<llvm::StringError>(
917 "Don't know how to parse core file. Unsupported OS.",
918 llvm::inconvertibleErrorCode());
919 }
920}
921
922uint32_t ProcessElfCore::GetNumThreadContexts() {
923 if (!m_thread_data_valid)
924 DoLoadCore();
925 return m_thread_data.size();
926}
927
928ArchSpec ProcessElfCore::GetArchitecture() {
929 ArchSpec arch = m_core_module_sp->GetObjectFile()->GetArchitecture();
930
931 ArchSpec target_arch = GetTarget().GetArchitecture();
932 arch.MergeFrom(target_arch);
933
934 // On MIPS there is no way to differentiate betwenn 32bit and 64bit core
935 // files and this information can't be merged in from the target arch so we
936 // fail back to unconditionally returning the target arch in this config.
937 if (target_arch.IsMIPS()) {
938 return target_arch;
939 }
940
941 return arch;
942}
943
944DataExtractor ProcessElfCore::GetAuxvData() {
945 const uint8_t *start = m_auxv.GetDataStart();
946 size_t len = m_auxv.GetByteSize();
947 lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(start, len));
948 return DataExtractor(buffer, GetByteOrder(), GetAddressByteSize());
949}
950
951bool ProcessElfCore::GetProcessInfo(ProcessInstanceInfo &info) {
952 info.Clear();
953 info.SetProcessID(GetID());
954 info.SetArchitecture(GetArchitecture());
955 lldb::ModuleSP module_sp = GetTarget().GetExecutableModule();
956 if (module_sp) {
957 const bool add_exe_file_as_first_arg = false;
958 info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),
959 add_exe_file_as_first_arg);
960 }
961 return true;
962}