LLDB mainline
ProcessMachCore.cpp
Go to the documentation of this file.
1//===-- ProcessMachCore.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 <cerrno>
10#include <cstdlib>
11
12#include "llvm/Support/MathExtras.h"
13#include "llvm/Support/Threading.h"
14
15#include "lldb/Core/Debugger.h"
16#include "lldb/Core/Module.h"
19#include "lldb/Core/Section.h"
20#include "lldb/Host/Host.h"
25#include "lldb/Target/Target.h"
26#include "lldb/Target/Thread.h"
30#include "lldb/Utility/Log.h"
31#include "lldb/Utility/State.h"
32#include "lldb/Utility/UUID.h"
33
34#include "ProcessMachCore.h"
36#include "ThreadMachCore.h"
37
38// Needed for the plug-in names for the dynamic loaders.
39#include "lldb/Host/SafeMachO.h"
40
46
47#include <memory>
48#include <mutex>
49
50using namespace lldb;
51using namespace lldb_private;
52
54
55llvm::StringRef ProcessMachCore::GetPluginDescriptionStatic() {
56 return "Mach-O core file debugging plug-in.";
57}
58
61}
62
64 ListenerSP listener_sp,
65 const FileSpec *crash_file,
66 bool can_connect) {
67 lldb::ProcessSP process_sp;
68 if (crash_file && !can_connect) {
69 const size_t header_size = sizeof(llvm::MachO::mach_header);
71 crash_file->GetPath(), header_size, 0);
72 if (data_sp && data_sp->GetByteSize() == header_size) {
73 DataExtractor data(data_sp, lldb::eByteOrderLittle, 4);
74
75 lldb::offset_t data_offset = 0;
76 llvm::MachO::mach_header mach_header;
77 if (ObjectFileMachO::ParseHeader(data, &data_offset, mach_header)) {
78 if (mach_header.filetype == llvm::MachO::MH_CORE)
79 process_sp = std::make_shared<ProcessMachCore>(target_sp, listener_sp,
80 *crash_file);
81 }
82 }
83 }
84 return process_sp;
85}
86
88 bool plugin_specified_by_name) {
89 if (plugin_specified_by_name)
90 return true;
91
92 // For now we are just making sure the file exists for a given module
94 // Don't add the Target's architecture to the ModuleSpec - we may be
95 // working with a core file that doesn't have the correct cpusubtype in the
96 // header but we should still try to use it -
97 // ModuleSpecList::FindMatchingModuleSpec enforces a strict arch mach.
98 ModuleSpec core_module_spec(m_core_file);
100 nullptr, nullptr, nullptr));
101
102 if (m_core_module_sp) {
103 ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
104 if (core_objfile && core_objfile->GetType() == ObjectFile::eTypeCoreFile)
105 return true;
106 }
107 }
108 return false;
109}
110
111// ProcessMachCore constructor
113 ListenerSP listener_sp,
114 const FileSpec &core_file)
115 : PostMortemProcess(target_sp, listener_sp), m_core_aranges(),
116 m_core_range_infos(), m_core_module_sp(), m_core_file(core_file),
117 m_dyld_addr(LLDB_INVALID_ADDRESS),
118 m_mach_kernel_addr(LLDB_INVALID_ADDRESS) {}
119
120// Destructor
122 Clear();
123 // We need to call finalize on the process before destroying ourselves to
124 // make sure all of the broadcaster cleanup goes as planned. If we destruct
125 // this class, then Process::~Process() might have problems trying to fully
126 // destroy the broadcaster.
127 Finalize();
128}
129
131 addr_t &dyld,
132 addr_t &kernel) {
133 Log *log(GetLog(LLDBLog::DynamicLoader | LLDBLog::Process));
134 llvm::MachO::mach_header header;
136 dyld = kernel = LLDB_INVALID_ADDRESS;
137 if (DoReadMemory(addr, &header, sizeof(header), error) != sizeof(header))
138 return false;
139 if (header.magic == llvm::MachO::MH_CIGAM ||
140 header.magic == llvm::MachO::MH_CIGAM_64) {
141 header.magic = llvm::byteswap<uint32_t>(header.magic);
142 header.cputype = llvm::byteswap<uint32_t>(header.cputype);
143 header.cpusubtype = llvm::byteswap<uint32_t>(header.cpusubtype);
144 header.filetype = llvm::byteswap<uint32_t>(header.filetype);
145 header.ncmds = llvm::byteswap<uint32_t>(header.ncmds);
146 header.sizeofcmds = llvm::byteswap<uint32_t>(header.sizeofcmds);
147 header.flags = llvm::byteswap<uint32_t>(header.flags);
148 }
149
150 if (header.magic == llvm::MachO::MH_MAGIC ||
151 header.magic == llvm::MachO::MH_MAGIC_64) {
152 // Check MH_EXECUTABLE to see if we can find the mach image that contains
153 // the shared library list. The dynamic loader (dyld) is what contains the
154 // list for user applications, and the mach kernel contains a global that
155 // has the list of kexts to load
156 switch (header.filetype) {
157 case llvm::MachO::MH_DYLINKER:
158 LLDB_LOGF(log,
159 "ProcessMachCore::%s found a user "
160 "process dyld binary image at 0x%" PRIx64,
161 __FUNCTION__, addr);
162 dyld = addr;
163 return true;
164
165 case llvm::MachO::MH_EXECUTE:
166 // Check MH_EXECUTABLE file types to see if the dynamic link object flag
167 // is NOT set. If it isn't, then we have a mach_kernel.
168 if ((header.flags & llvm::MachO::MH_DYLDLINK) == 0) {
169 LLDB_LOGF(log,
170 "ProcessMachCore::%s found a mach "
171 "kernel binary image at 0x%" PRIx64,
172 __FUNCTION__, addr);
173 // Address of the mach kernel "struct mach_header" in the core file.
174 kernel = addr;
175 return true;
176 }
177 break;
178 }
179 }
180 return false;
181}
182
184 ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
185 SectionList *section_list = core_objfile->GetSectionList();
186 const uint32_t num_sections = section_list->GetNumSections(0);
187
188 bool ranges_are_sorted = true;
189 addr_t vm_addr = 0;
190 for (uint32_t i = 0; i < num_sections; ++i) {
191 Section *section = section_list->GetSectionAtIndex(i).get();
192 if (section && section->GetFileSize() > 0) {
193 lldb::addr_t section_vm_addr = section->GetFileAddress();
194 FileRange file_range(section->GetFileOffset(), section->GetFileSize());
195 VMRangeToFileOffset::Entry range_entry(
196 section_vm_addr, section->GetByteSize(), file_range);
197
198 if (vm_addr > section_vm_addr)
199 ranges_are_sorted = false;
200 vm_addr = section->GetFileAddress();
202
203 if (last_entry &&
204 last_entry->GetRangeEnd() == range_entry.GetRangeBase() &&
205 last_entry->data.GetRangeEnd() == range_entry.data.GetRangeBase()) {
206 last_entry->SetRangeEnd(range_entry.GetRangeEnd());
207 last_entry->data.SetRangeEnd(range_entry.data.GetRangeEnd());
208 } else {
209 m_core_aranges.Append(range_entry);
210 }
211 // Some core files don't fill in the permissions correctly. If that is
212 // the case assume read + execute so clients don't think the memory is
213 // not readable, or executable. The memory isn't writable since this
214 // plug-in doesn't implement DoWriteMemory.
215 uint32_t permissions = section->GetPermissions();
216 if (permissions == 0)
217 permissions = lldb::ePermissionsReadable | lldb::ePermissionsExecutable;
219 section_vm_addr, section->GetByteSize(), permissions));
220 }
221 }
222 if (!ranges_are_sorted) {
225 }
226}
227
228// Some corefiles have a UUID stored in a low memory
229// address. We inspect a set list of addresses for
230// the characters 'uuid' and 16 bytes later there will
231// be a uuid_t UUID. If we can find a binary that
232// matches the UUID, it is loaded with no slide in the target.
234 Log *log(GetLog(LLDBLog::DynamicLoader | LLDBLog::Process));
235 ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
236
237 uint64_t lowmem_uuid_addresses[] = {0x2000204, 0x1000204, 0x1000020, 0x4204,
238 0x1204, 0x1020, 0x4020, 0xc00,
239 0xC0, 0};
240
241 for (uint64_t addr : lowmem_uuid_addresses) {
242 const VMRangeToFileOffset::Entry *core_memory_entry =
244 if (core_memory_entry) {
245 const addr_t offset = addr - core_memory_entry->GetRangeBase();
246 const addr_t bytes_left = core_memory_entry->GetRangeEnd() - addr;
247 // (4-bytes 'uuid' + 12 bytes pad for align + 16 bytes uuid_t) == 32 bytes
248 if (bytes_left >= 32) {
249 char strbuf[4];
250 if (core_objfile->CopyData(
251 core_memory_entry->data.GetRangeBase() + offset, 4, &strbuf) &&
252 strncmp("uuid", (char *)&strbuf, 4) == 0) {
253 uuid_t uuid_bytes;
254 if (core_objfile->CopyData(core_memory_entry->data.GetRangeBase() +
255 offset + 16,
256 sizeof(uuid_t), uuid_bytes)) {
257 UUID uuid(uuid_bytes, sizeof(uuid_t));
258 if (uuid.IsValid()) {
259 LLDB_LOGF(log,
260 "ProcessMachCore::LoadBinaryViaLowmemUUID: found "
261 "binary uuid %s at low memory address 0x%" PRIx64,
262 uuid.GetAsString().c_str(), addr);
263 // We have no address specified, only a UUID. Load it at the file
264 // address.
265 const bool value_is_offset = true;
266 const bool force_symbol_search = true;
267 const bool notify = true;
268 const bool set_address_in_target = true;
269 const bool allow_memory_image_last_resort = false;
271 this, llvm::StringRef(), uuid, 0, value_is_offset,
272 force_symbol_search, notify, set_address_in_target,
273 allow_memory_image_last_resort)) {
275 }
276 // We found metadata saying which binary should be loaded; don't
277 // try an exhaustive search.
278 return true;
279 }
280 }
281 }
282 }
283 }
284 }
285 return false;
286}
287
289 Log *log(GetLog(LLDBLog::DynamicLoader | LLDBLog::Process));
290 ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
291
292 addr_t objfile_binary_value;
293 bool objfile_binary_value_is_offset;
294 UUID objfile_binary_uuid;
296
297 // This will be set to true if we had a metadata hint
298 // specifying a UUID or address -- and we should not fall back
299 // to doing an exhaustive search.
300 bool found_binary_spec_in_metadata = false;
301
302 if (core_objfile->GetCorefileMainBinaryInfo(objfile_binary_value,
303 objfile_binary_value_is_offset,
304 objfile_binary_uuid, type)) {
305 if (log) {
306 log->Printf("ProcessMachCore::LoadBinariesViaMetadata: using binary hint "
307 "from 'main bin spec' "
308 "LC_NOTE with UUID %s value 0x%" PRIx64
309 " value is offset %d and type %d",
310 objfile_binary_uuid.GetAsString().c_str(),
311 objfile_binary_value, objfile_binary_value_is_offset, type);
312 }
313 found_binary_spec_in_metadata = true;
314
315 // If this is the xnu kernel, don't load it now. Note the correct
316 // DynamicLoader plugin to use, and the address of the kernel, and
317 // let the DynamicLoader handle the finding & loading of the binary.
318 if (type == ObjectFile::eBinaryTypeKernel) {
319 m_mach_kernel_addr = objfile_binary_value;
321 } else if (type == ObjectFile::eBinaryTypeUser) {
322 m_dyld_addr = objfile_binary_value;
324 } else {
325 const bool force_symbol_search = true;
326 const bool notify = true;
327 const bool set_address_in_target = true;
328 const bool allow_memory_image_last_resort = false;
330 this, llvm::StringRef(), objfile_binary_uuid,
331 objfile_binary_value, objfile_binary_value_is_offset,
332 force_symbol_search, notify, set_address_in_target,
333 allow_memory_image_last_resort)) {
335 }
336 }
337 }
338
339 // This checks for the presence of an LC_IDENT string in a core file;
340 // LC_IDENT is very obsolete and should not be used in new code, but if the
341 // load command is present, let's use the contents.
342 UUID ident_uuid;
343 addr_t ident_binary_addr = LLDB_INVALID_ADDRESS;
344 std::string corefile_identifier = core_objfile->GetIdentifierString();
345
346 // Search for UUID= and stext= strings in the identifier str.
347 if (corefile_identifier.find("UUID=") != std::string::npos) {
348 size_t p = corefile_identifier.find("UUID=") + strlen("UUID=");
349 std::string uuid_str = corefile_identifier.substr(p, 36);
350 ident_uuid.SetFromStringRef(uuid_str);
351 if (log)
352 log->Printf("Got a UUID from LC_IDENT/kern ver str LC_NOTE: %s",
353 ident_uuid.GetAsString().c_str());
354 found_binary_spec_in_metadata = true;
355 }
356 if (corefile_identifier.find("stext=") != std::string::npos) {
357 size_t p = corefile_identifier.find("stext=") + strlen("stext=");
358 if (corefile_identifier[p] == '0' && corefile_identifier[p + 1] == 'x') {
359 ident_binary_addr =
360 ::strtoul(corefile_identifier.c_str() + p, nullptr, 16);
361 if (log)
362 log->Printf("Got a load address from LC_IDENT/kern ver str "
363 "LC_NOTE: 0x%" PRIx64,
364 ident_binary_addr);
365 found_binary_spec_in_metadata = true;
366 }
367 }
368
369 // Search for a "Darwin Kernel" str indicating kernel; else treat as
370 // standalone
371 if (corefile_identifier.find("Darwin Kernel") != std::string::npos &&
372 ident_uuid.IsValid() && ident_binary_addr != LLDB_INVALID_ADDRESS) {
373 if (log)
374 log->Printf(
375 "ProcessMachCore::LoadBinariesViaMetadata: Found kernel binary via "
376 "LC_IDENT/kern ver str LC_NOTE");
377 m_mach_kernel_addr = ident_binary_addr;
378 found_binary_spec_in_metadata = true;
379 } else if (ident_uuid.IsValid()) {
380 // We have no address specified, only a UUID. Load it at the file
381 // address.
382 const bool value_is_offset = false;
383 const bool force_symbol_search = true;
384 const bool notify = true;
385 const bool set_address_in_target = true;
386 const bool allow_memory_image_last_resort = false;
388 this, llvm::StringRef(), ident_uuid, ident_binary_addr,
389 value_is_offset, force_symbol_search, notify,
390 set_address_in_target, allow_memory_image_last_resort)) {
391 found_binary_spec_in_metadata = true;
393 }
394 }
395
396 // Finally, load any binaries noted by "load binary" LC_NOTEs in the
397 // corefile
398 if (core_objfile->LoadCoreFileImages(*this)) {
399 found_binary_spec_in_metadata = true;
401 }
402
403 if (!found_binary_spec_in_metadata && LoadBinaryViaLowmemUUID())
404 found_binary_spec_in_metadata = true;
405
406 // LoadCoreFileImges may have set the dynamic loader, e.g. in
407 // PlatformDarwinKernel::LoadPlatformBinaryAndSetup().
408 // If we now have a dynamic loader, save its name so we don't
409 // un-set it later.
410 if (m_dyld_up)
412
413 return found_binary_spec_in_metadata;
414}
415
417 Log *log(GetLog(LLDBLog::DynamicLoader | LLDBLog::Process));
418
419 // Search the pages of the corefile for dyld or mach kernel
420 // binaries. There may be multiple things that look like a kernel
421 // in the corefile; disambiguating to the correct one can be difficult.
422
423 std::vector<addr_t> dylds_found;
424 std::vector<addr_t> kernels_found;
425
426 const size_t num_core_aranges = m_core_aranges.GetSize();
427 for (size_t i = 0; i < num_core_aranges; ++i) {
429 lldb::addr_t section_vm_addr_start = entry->GetRangeBase();
430 lldb::addr_t section_vm_addr_end = entry->GetRangeEnd();
431 for (lldb::addr_t section_vm_addr = section_vm_addr_start;
432 section_vm_addr < section_vm_addr_end; section_vm_addr += 0x1000) {
433 addr_t dyld, kernel;
434 if (CheckAddressForDyldOrKernel(section_vm_addr, dyld, kernel)) {
435 if (dyld != LLDB_INVALID_ADDRESS)
436 dylds_found.push_back(dyld);
437 if (kernel != LLDB_INVALID_ADDRESS)
438 kernels_found.push_back(kernel);
439 }
440 }
441 }
442
443 // If we found more than one dyld mach-o header in the corefile,
444 // pick the first one.
445 if (dylds_found.size() > 0)
446 m_dyld_addr = dylds_found[0];
447 if (kernels_found.size() > 0)
448 m_mach_kernel_addr = kernels_found[0];
449
450 // Zero or one kernels found, we're done.
451 if (kernels_found.size() < 2)
452 return;
453
454 // In the case of multiple kernel images found in the core file via
455 // exhaustive search, we may not pick the correct one. See if the
456 // DynamicLoaderDarwinKernel's search heuristics might identify the correct
457 // one.
458
459 // SearchForDarwinKernel will call this class' GetImageInfoAddress method
460 // which will give it the addresses we already have.
461 // Save those aside and set
462 // m_mach_kernel_addr/m_dyld_addr to an invalid address temporarily so
463 // DynamicLoaderDarwinKernel does a real search for the kernel using its
464 // own heuristics.
465
466 addr_t saved_mach_kernel_addr = m_mach_kernel_addr;
467 addr_t saved_user_dyld_addr = m_dyld_addr;
470
471 addr_t better_kernel_address =
473
474 m_mach_kernel_addr = saved_mach_kernel_addr;
475 m_dyld_addr = saved_user_dyld_addr;
476
477 if (better_kernel_address != LLDB_INVALID_ADDRESS) {
478 LLDB_LOGF(log,
479 "ProcessMachCore::%s: Using "
480 "the kernel address "
481 "from DynamicLoaderDarwinKernel",
482 __FUNCTION__);
483 m_mach_kernel_addr = better_kernel_address;
484 }
485}
486
488 Log *log(GetLog(LLDBLog::DynamicLoader | LLDBLog::Process));
489
490 bool found_binary_spec_in_metadata = LoadBinariesViaMetadata();
491 if (!found_binary_spec_in_metadata)
493
494 if (m_dyld_plugin_name.empty()) {
495 // If we found both a user-process dyld and a kernel binary, we need to
496 // decide which to prefer.
499 LLDB_LOGF(log,
500 "ProcessMachCore::%s: Using kernel "
501 "corefile image "
502 "at 0x%" PRIx64,
503 __FUNCTION__, m_mach_kernel_addr);
505 } else if (m_dyld_addr != LLDB_INVALID_ADDRESS) {
506 LLDB_LOGF(log,
507 "ProcessMachCore::%s: Using user process dyld "
508 "image at 0x%" PRIx64,
509 __FUNCTION__, m_dyld_addr);
511 }
512 } else {
514 LLDB_LOGF(log,
515 "ProcessMachCore::%s: Using user process dyld "
516 "image at 0x%" PRIx64,
517 __FUNCTION__, m_dyld_addr);
520 LLDB_LOGF(log,
521 "ProcessMachCore::%s: Using kernel "
522 "corefile image "
523 "at 0x%" PRIx64,
524 __FUNCTION__, m_mach_kernel_addr);
526 }
527 }
528 }
529}
530
533 // For non-user process core files, the permissions on the core file
534 // segments are usually meaningless, they may be just "read", because we're
535 // dealing with kernel coredumps or early startup coredumps and the dumper
536 // is grabbing pages of memory without knowing what they are. If they
537 // aren't marked as "executable", that can break the unwinder which will
538 // check a pc value to see if it is in an executable segment and stop the
539 // backtrace early if it is not ("executable" and "unknown" would both be
540 // fine, but "not executable" will break the unwinder).
541 size_t core_range_infos_size = m_core_range_infos.GetSize();
542 for (size_t i = 0; i < core_range_infos_size; i++) {
545 ent->data = lldb::ePermissionsReadable | lldb::ePermissionsExecutable;
546 }
547 }
548}
549
550// Process Control
553 if (!m_core_module_sp) {
554 error.SetErrorString("invalid core module");
555 return error;
556 }
557
558 ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
559 if (core_objfile == nullptr) {
560 error.SetErrorString("invalid core object file");
561 return error;
562 }
563
564 SetCanJIT(false);
565
566 // The corefile's architecture is our best starting point.
567 ArchSpec arch(m_core_module_sp->GetArchitecture());
568 if (arch.IsValid())
570
572
574
576
577 AddressableBits addressable_bits = core_objfile->GetAddressableBits();
578 addressable_bits.SetProcessMasks(*this);
579
580 return error;
581}
582
584 if (m_dyld_up.get() == nullptr)
586 return m_dyld_up.get();
587}
588
590 ThreadList &new_thread_list) {
591 if (old_thread_list.GetSize(false) == 0) {
592 // Make up the thread the first time this is called so we can setup our one
593 // and only core thread state.
594 ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
595
596 if (core_objfile) {
597 std::set<tid_t> used_tids;
598 const uint32_t num_threads = core_objfile->GetNumThreadContexts();
599 std::vector<tid_t> tids;
600 if (core_objfile->GetCorefileThreadExtraInfos(tids)) {
601 assert(tids.size() == num_threads);
602
603 // Find highest tid value.
604 tid_t highest_tid = 0;
605 for (uint32_t i = 0; i < num_threads; i++) {
606 if (tids[i] != LLDB_INVALID_THREAD_ID && tids[i] > highest_tid)
607 highest_tid = tids[i];
608 }
609 tid_t current_unused_tid = highest_tid + 1;
610 for (uint32_t i = 0; i < num_threads; i++) {
611 if (tids[i] == LLDB_INVALID_THREAD_ID) {
612 tids[i] = current_unused_tid++;
613 }
614 }
615 } else {
616 // No metadata, insert numbers sequentially from 0.
617 for (uint32_t i = 0; i < num_threads; i++) {
618 tids.push_back(i);
619 }
620 }
621
622 for (uint32_t i = 0; i < num_threads; i++) {
623 ThreadSP thread_sp =
624 std::make_shared<ThreadMachCore>(*this, tids[i], i);
625 new_thread_list.AddThread(thread_sp);
626 }
627 }
628 } else {
629 const uint32_t num_threads = old_thread_list.GetSize(false);
630 for (uint32_t i = 0; i < num_threads; ++i)
631 new_thread_list.AddThread(old_thread_list.GetThreadAtIndex(i, false));
632 }
633 return new_thread_list.GetSize(false) > 0;
634}
635
637 // Let all threads recover from stopping and do any clean up based on the
638 // previous thread state (if any).
640 // SetThreadStopInfo (m_last_stop_packet);
641}
642
644
645// Process Queries
646
647bool ProcessMachCore::IsAlive() { return true; }
648
649bool ProcessMachCore::WarnBeforeDetach() const { return false; }
650
651// Process Memory
652size_t ProcessMachCore::ReadMemory(addr_t addr, void *buf, size_t size,
653 Status &error) {
654 // Don't allow the caching that lldb_private::Process::ReadMemory does since
655 // in core files we have it all cached our our core file anyway.
656 return DoReadMemory(addr, buf, size, error);
657}
658
659size_t ProcessMachCore::DoReadMemory(addr_t addr, void *buf, size_t size,
660 Status &error) {
661 ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
662 size_t bytes_read = 0;
663
664 if (core_objfile) {
665 // Segments are not always contiguous in mach-o core files. We have core
666 // files that have segments like:
667 // Address Size File off File size
668 // ---------- ---------- ---------- ----------
669 // LC_SEGMENT 0x000f6000 0x00001000 0x1d509ee8 0x00001000 --- --- 0
670 // 0x00000000 __TEXT LC_SEGMENT 0x0f600000 0x00100000 0x1d50aee8 0x00100000
671 // --- --- 0 0x00000000 __TEXT LC_SEGMENT 0x000f7000 0x00001000
672 // 0x1d60aee8 0x00001000 --- --- 0 0x00000000 __TEXT
673 //
674 // Any if the user executes the following command:
675 //
676 // (lldb) mem read 0xf6ff0
677 //
678 // We would attempt to read 32 bytes from 0xf6ff0 but would only get 16
679 // unless we loop through consecutive memory ranges that are contiguous in
680 // the address space, but not in the file data.
681 while (bytes_read < size) {
682 const addr_t curr_addr = addr + bytes_read;
683 const VMRangeToFileOffset::Entry *core_memory_entry =
685
686 if (core_memory_entry) {
687 const addr_t offset = curr_addr - core_memory_entry->GetRangeBase();
688 const addr_t bytes_left = core_memory_entry->GetRangeEnd() - curr_addr;
689 const size_t bytes_to_read =
690 std::min(size - bytes_read, (size_t)bytes_left);
691 const size_t curr_bytes_read = core_objfile->CopyData(
692 core_memory_entry->data.GetRangeBase() + offset, bytes_to_read,
693 (char *)buf + bytes_read);
694 if (curr_bytes_read == 0)
695 break;
696 bytes_read += curr_bytes_read;
697 } else {
698 // Only set the error if we didn't read any bytes
699 if (bytes_read == 0)
700 error.SetErrorStringWithFormat(
701 "core file does not contain 0x%" PRIx64, curr_addr);
702 break;
703 }
704 }
705 }
706
707 return bytes_read;
708}
709
711 MemoryRegionInfo &region_info) {
712 region_info.Clear();
713 const VMRangeToPermissions::Entry *permission_entry =
715 if (permission_entry) {
716 if (permission_entry->Contains(load_addr)) {
717 region_info.GetRange().SetRangeBase(permission_entry->GetRangeBase());
718 region_info.GetRange().SetRangeEnd(permission_entry->GetRangeEnd());
719 const Flags permissions(permission_entry->data);
720 region_info.SetReadable(permissions.Test(ePermissionsReadable)
723 region_info.SetWritable(permissions.Test(ePermissionsWritable)
726 region_info.SetExecutable(permissions.Test(ePermissionsExecutable)
730 } else if (load_addr < permission_entry->GetRangeBase()) {
731 region_info.GetRange().SetRangeBase(load_addr);
732 region_info.GetRange().SetRangeEnd(permission_entry->GetRangeBase());
736 region_info.SetMapped(MemoryRegionInfo::eNo);
737 }
738 return Status();
739 }
740
741 region_info.GetRange().SetRangeBase(load_addr);
746 region_info.SetMapped(MemoryRegionInfo::eNo);
747 return Status();
748}
749
751
753 static llvm::once_flag g_once_flag;
754
755 llvm::call_once(g_once_flag, []() {
758 });
759}
760
762 // If we found both a user-process dyld and a kernel binary, we need to
763 // decide which to prefer.
766 return m_mach_kernel_addr;
767 }
768 return m_dyld_addr;
769 } else {
771 return m_dyld_addr;
772 }
773 return m_mach_kernel_addr;
774 }
775}
776
778 return m_core_module_sp->GetObjectFile();
779}
unsigned char uuid_t[16]
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
Definition: Log.h:349
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
static llvm::StringRef GetPluginNameStatic()
static lldb::addr_t SearchForDarwinKernel(lldb_private::Process *process)
static llvm::StringRef GetPluginNameStatic()
static llvm::StringRef GetPluginNameStatic()
bool ParseHeader() override
Attempts to parse the object header.
lldb::addr_t m_dyld_addr
bool WarnBeforeDetach() const override
Before lldb detaches from a process, it warns the user that they are about to lose their debug sessio...
static llvm::StringRef GetPluginDescriptionStatic()
static void Initialize()
size_t ReadMemory(lldb::addr_t addr, void *buf, size_t size, lldb_private::Status &error) override
Read of memory from a process.
bool LoadBinaryViaLowmemUUID()
VMRangeToFileOffset m_core_aranges
bool LoadBinariesViaMetadata()
size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size, lldb_private::Status &error) override
Actually do the reading of memory from a process.
CorefilePreference GetCorefilePreference()
If a core file can be interpreted multiple ways, this establishes which style wins.
bool CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name) override
Check if a plug-in instance can debug the file in module.
void CleanupMemoryRegionPermissions()
lldb_private::ObjectFile * GetCoreObjectFile()
ProcessMachCore(lldb::TargetSP target_sp, lldb::ListenerSP listener, const lldb_private::FileSpec &core_file)
llvm::StringRef m_dyld_plugin_name
lldb_private::DynamicLoader * GetDynamicLoader() override
Get the dynamic loader plug-in for this process.
lldb_private::Status DoDestroy() override
static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener, const lldb_private::FileSpec *crash_file_path, bool can_connect)
void RefreshStateAfterStop() override
Currently called as part of ShouldStop.
bool DoUpdateThreadList(lldb_private::ThreadList &old_thread_list, lldb_private::ThreadList &new_thread_list) override
Update the thread list following process plug-in's specific logic.
static llvm::StringRef GetPluginNameStatic()
bool IsAlive() override
Check if a process is still alive.
bool CheckAddressForDyldOrKernel(lldb::addr_t addr, lldb::addr_t &dyld, lldb::addr_t &kernel)
VMRangeToPermissions m_core_range_infos
lldb_private::Status DoLoadCore() override
void LoadBinariesViaExhaustiveSearch()
lldb_private::FileSpec m_core_file
lldb::addr_t m_mach_kernel_addr
lldb::addr_t GetImageInfoAddress() override
Get the image information address for the current process.
~ProcessMachCore() override
lldb::ModuleSP m_core_module_sp
lldb_private::Status DoGetMemoryRegionInfo(lldb::addr_t load_addr, lldb_private::MemoryRegionInfo &region_info) override
DoGetMemoryRegionInfo is called by GetMemoryRegionInfo after it has removed non address bits from loa...
static void Terminate()
A class which holds the metadata from a remote stub/corefile note about how many bits are used for ad...
void SetProcessMasks(lldb_private::Process &process)
An architecture specification class.
Definition: ArchSpec.h:31
bool IsValid() const
Tests if this ArchSpec is valid.
Definition: ArchSpec.h:348
An data extractor class.
Definition: DataExtractor.h:48
A plug-in interface definition class for dynamic loaders.
Definition: DynamicLoader.h:52
static lldb::ModuleSP LoadBinaryWithUUIDAndAddress(Process *process, llvm::StringRef name, UUID uuid, lldb::addr_t value, bool value_is_offset, bool force_symbol_search, bool notify, bool set_address_in_target, bool allow_memory_image_last_resort)
Find/load a binary into lldb given a UUID and the address where it is loaded in memory,...
static DynamicLoader * FindPlugin(Process *process, llvm::StringRef plugin_name)
Find a dynamic loader plugin for a given process.
A file utility class.
Definition: FileSpec.h:56
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:367
static FileSystem & Instance()
std::shared_ptr< DataBuffer > CreateDataBuffer(const llvm::Twine &path, uint64_t size=0, uint64_t offset=0)
Create memory buffer from path.
A class to manage flags.
Definition: Flags.h:22
bool Test(ValueType bit) const
Test a single flag bit.
Definition: Flags.h:96
void void Printf(const char *format,...) __attribute__((format(printf
Prefer using LLDB_LOGF whenever possible.
Definition: Log.cpp:145
void SetMapped(OptionalBool val)
void SetReadable(OptionalBool val)
void SetExecutable(OptionalBool val)
void SetWritable(OptionalBool val)
static Status GetSharedModule(const ModuleSpec &module_spec, lldb::ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr, llvm::SmallVectorImpl< lldb::ModuleSP > *old_modules, bool *did_create_ptr, bool always_create=false)
Definition: ModuleList.cpp:777
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:44
virtual bool GetCorefileThreadExtraInfos(std::vector< lldb::tid_t > &tids)
Get metadata about threads from the corefile.
Definition: ObjectFile.h:561
virtual std::string GetIdentifierString()
Some object files may have an identifier string embedded in them, e.g.
Definition: ObjectFile.h:492
virtual uint32_t GetNumThreadContexts()
Definition: ObjectFile.h:483
virtual bool LoadCoreFileImages(lldb_private::Process &process)
Load binaries listed in a corefile.
Definition: ObjectFile.h:730
@ eTypeCoreFile
A core file that has a checkpoint of a program's execution state.
Definition: ObjectFile.h:51
virtual lldb_private::AddressableBits GetAddressableBits()
Some object files may have the number of bits used for addressing embedded in them,...
Definition: ObjectFile.h:504
size_t CopyData(lldb::offset_t offset, size_t length, void *dst) const
Definition: ObjectFile.cpp:469
virtual SectionList * GetSectionList(bool update_module_section_list=true)
Gets the section list for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:590
virtual bool GetCorefileMainBinaryInfo(lldb::addr_t &value, bool &value_is_offset, UUID &uuid, ObjectFile::BinaryType &type)
When the ObjectFile is a core file, lldb needs to locate the "binary" in the core file.
Definition: ObjectFile.h:532
BinaryType
If we have a corefile binary hint, this enum specifies the binary type which we can use to select the...
Definition: ObjectFile.h:81
@ eBinaryTypeUser
kernel binary
Definition: ObjectFile.h:85
virtual llvm::StringRef GetPluginName()=0
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
Base class for all processes that don't represent a live process, such as coredumps or processes trac...
virtual void Finalize()
This object is about to be destroyed, do any necessary cleanup.
Definition: Process.cpp:521
void SetCanJIT(bool can_jit)
Sets whether executing JIT-compiled code in this process is possible.
Definition: Process.cpp:2329
lldb::DynamicLoaderUP m_dyld_up
Definition: Process.h:2998
ThreadList m_thread_list
The threads for this process as the user will see them.
Definition: Process.h:2976
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1242
const Entry * GetEntryAtIndex(size_t i) const
Definition: RangeMap.h:528
Entry * GetMutableEntryAtIndex(size_t i)
Definition: RangeMap.h:532
const Entry * FindEntryThatContainsOrFollows(B addr) const
Definition: RangeMap.h:614
void Append(const Entry &entry)
Definition: RangeMap.h:451
Entry * FindEntryThatContains(B addr)
Definition: RangeMap.h:563
size_t GetNumSections(uint32_t depth) const
Definition: Section.cpp:533
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:544
uint32_t GetPermissions() const
Get the permissions as OR'ed bits from lldb::Permissions.
Definition: Section.cpp:358
lldb::offset_t GetFileOffset() const
Definition: Section.h:154
lldb::addr_t GetFileAddress() const
Definition: Section.cpp:193
lldb::addr_t GetByteSize() const
Definition: Section.h:170
lldb::offset_t GetFileSize() const
Definition: Section.h:160
An error handling class.
Definition: Status.h:44
bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform=false, bool merge=true)
Set the architecture for this target.
Definition: Target.cpp:1491
void AddThread(const lldb::ThreadSP &thread_sp)
uint32_t GetSize(bool can_update=true)
Definition: ThreadList.cpp:83
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
Definition: ThreadList.cpp:91
bool SetFromStringRef(llvm::StringRef str)
Definition: UUID.cpp:97
std::string GetAsString(llvm::StringRef separator="-") const
Definition: UUID.cpp:49
bool IsValid() const
Definition: UUID.h:69
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:87
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:79
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:425
uint64_t offset_t
Definition: lldb-types.h:83
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:368
@ eByteOrderLittle
std::shared_ptr< lldb_private::Listener > ListenerSP
Definition: lldb-forward.h:349
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:423
uint64_t tid_t
Definition: lldb-types.h:82
Definition: Debugger.h:53
bool Contains(BaseType r) const
Definition: RangeMap.h:93
BaseType GetRangeBase() const
Definition: RangeMap.h:45
void SetRangeEnd(BaseType end)
Definition: RangeMap.h:80
void SetRangeBase(BaseType b)
Set the start value for the range, and keep the same size.
Definition: RangeMap.h:48
BaseType GetRangeEnd() const
Definition: RangeMap.h:78