LLDB mainline
DynamicLoaderFreeBSDKernel.cpp
Go to the documentation of this file.
1//===-- DynamicLoaderFreeBSDKernel.cpp
2//------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
11#include "lldb/Core/Debugger.h"
12#include "lldb/Core/Module.h"
15#include "lldb/Core/Section.h"
22#include "lldb/Target/Target.h"
23#include "lldb/Target/Thread.h"
28#include "lldb/Utility/Log.h"
29#include "lldb/Utility/State.h"
30
32
34#include <memory>
35#include <mutex>
36
37using namespace lldb;
38using namespace lldb_private;
39
41
42void DynamicLoaderFreeBSDKernel::Initialize() {
43 PluginManager::RegisterPlugin(GetPluginNameStatic(),
44 GetPluginDescriptionStatic(), CreateInstance,
45 DebuggerInit);
46}
47
50}
51
53 return "The Dynamic Loader Plugin For FreeBSD Kernel";
54}
55
56static bool is_kernel(Module *module) {
57 if (!module)
58 return false;
59
60 ObjectFile *objfile = module->GetObjectFile();
61 if (!objfile)
62 return false;
63 if (objfile->GetType() != ObjectFile::eTypeExecutable)
64 return false;
65 if (objfile->GetStrata() != ObjectFile::eStrataUnknown &&
67 return false;
68
69 return true;
70}
71
72static bool is_kmod(Module *module) {
73 if (!module)
74 return false;
75 if (!module->GetObjectFile())
76 return false;
77 ObjectFile *objfile = module->GetObjectFile();
78 if (objfile->GetType() != ObjectFile::eTypeObjectFile &&
80 return false;
81
82 return true;
83}
84
85static bool is_reloc(Module *module) {
86 if (!module)
87 return false;
88 if (!module->GetObjectFile())
89 return false;
90 ObjectFile *objfile = module->GetObjectFile();
91 if (objfile->GetType() != ObjectFile::eTypeObjectFile)
92 return false;
93
94 return true;
95}
96
97// Instantiate Function of the FreeBSD Kernel Dynamic Loader Plugin called when
98// Register the Plugin
101 bool force) {
102 // Check the environment when the plugin is not force loaded
103 Module *exec = process->GetTarget().GetExecutableModulePointer();
104 if (exec && !is_kernel(exec)) {
105 return nullptr;
106 }
107 if (!force) {
108 // Check if the target is kernel
109 const llvm::Triple &triple_ref =
110 process->GetTarget().GetArchitecture().GetTriple();
111 if (!triple_ref.isOSFreeBSD()) {
112 return nullptr;
113 }
114 }
115
116 // At this point we have checked the target is a FreeBSD kernel and all we
117 // have to do is to find the kernel address
118 const addr_t kernel_address = FindFreeBSDKernel(process);
119
120 if (CheckForKernelImageAtAddress(process, kernel_address).IsValid())
121 return new DynamicLoaderFreeBSDKernel(process, kernel_address);
122
123 return nullptr;
124}
125
126addr_t
128 addr_t kernel_addr = process->GetImageInfoAddress();
129 if (kernel_addr == LLDB_INVALID_ADDRESS)
130 kernel_addr = FindKernelAtLoadAddress(process);
131 return kernel_addr;
132}
133
134// Get the kernel address if the kernel is not loaded with a slide
136 lldb_private::Process *process) {
137 Module *exe_module = process->GetTarget().GetExecutableModulePointer();
138
139 if (!is_kernel(exe_module))
141
142 ObjectFile *exe_objfile = exe_module->GetObjectFile();
143
144 if (!exe_objfile->GetBaseAddress().IsValid())
146
148 process, exe_objfile->GetBaseAddress().GetFileAddress())
149 .IsValid())
150 return exe_objfile->GetBaseAddress().GetFileAddress();
151
153}
154
155// Read ELF header from memry and return
157 lldb::addr_t addr,
158 llvm::ELF::Elf32_Ehdr &header,
159 bool *read_error) {
161 if (read_error)
162 *read_error = false;
163
164 if (process->ReadMemory(addr, &header, sizeof(header), error) !=
165 sizeof(header)) {
166 if (read_error)
167 *read_error = true;
168 return false;
169 }
170
171 if (!header.checkMagic())
172 return false;
173
174 return true;
175}
176
177// Check the correctness of Kernel and return UUID
179 Process *process, lldb::addr_t addr, bool *read_error) {
180 Log *log = GetLog(LLDBLog::DynamicLoader);
181
182 if (addr == LLDB_INVALID_ADDRESS) {
183 if (read_error)
184 *read_error = true;
185 return UUID();
186 }
187
188 LLDB_LOGF(log,
189 "DynamicLoaderFreeBSDKernel::CheckForKernelImageAtAddress: "
190 "looking for kernel binary at 0x%" PRIx64,
191 addr);
192
193 llvm::ELF::Elf32_Ehdr header;
194 if (!ReadELFHeader(process, addr, header)) {
195 *read_error = true;
196 return UUID();
197 }
198
199 // Check header type
200 if (header.e_type != llvm::ELF::ET_EXEC)
201 return UUID();
202
203 ModuleSP memory_module_sp =
204 process->ReadModuleFromMemory(FileSpec("temp_freebsd_kernel"), addr);
205
206 if (!memory_module_sp.get()) {
207 *read_error = true;
208 return UUID();
209 }
210
211 ObjectFile *exe_objfile = memory_module_sp->GetObjectFile();
212 if (exe_objfile == nullptr) {
213 LLDB_LOGF(log,
214 "DynamicLoaderFreeBSDKernel::CheckForKernelImageAtAddress "
215 "found a binary at 0x%" PRIx64
216 " but could not create an object file from memory",
217 addr);
218 return UUID();
219 }
220
221 // In here, I should check is_kernel for memory_module_sp
222 // However, the ReadModuleFromMemory reads wrong section so that this check
223 // will failed
224 ArchSpec kernel_arch(llvm::ELF::convertEMachineToArchName(header.e_machine));
225
226 if (!process->GetTarget().GetArchitecture().IsCompatibleMatch(kernel_arch))
227 process->GetTarget().SetArchitecture(kernel_arch);
228
229 std::string uuid_str;
230 if (memory_module_sp->GetUUID().IsValid()) {
231 uuid_str = "with UUID ";
232 uuid_str += memory_module_sp->GetUUID().GetAsString();
233 } else {
234 uuid_str = "and no LC_UUID found in load commands ";
235 }
236 LLDB_LOGF(log,
237 "DynamicLoaderFreeBSDKernel::CheckForKernelImageAtAddress: "
238 "kernel binary image found at 0x%" PRIx64 " with arch '%s' %s",
239 addr, kernel_arch.GetTriple().str().c_str(), uuid_str.c_str());
240
241 return memory_module_sp->GetUUID();
242}
243
245 lldb_private::Debugger &debugger) {}
246
248 addr_t kernel_address)
249 : DynamicLoader(process), m_process(process),
250 m_linker_file_list_struct_addr(LLDB_INVALID_ADDRESS),
251 m_linker_file_head_addr(LLDB_INVALID_ADDRESS),
252 m_kernel_load_address(kernel_address), m_mutex() {
253 process->SetCanRunCode(false);
254}
255
257
261}
262
263// Create in memory Module at the load address
265 lldb_private::Process *process) {
266 Log *log = GetLog(LLDBLog::DynamicLoader);
268 return true;
270 return false;
271
272 FileSpec file_spec(m_name);
273
274 ModuleSP memory_module_sp;
275
276 llvm::ELF::Elf32_Ehdr elf_eheader;
277 size_t size_to_read = 512;
278
279 if (ReadELFHeader(process, m_load_address, elf_eheader)) {
280 if (elf_eheader.e_ident[llvm::ELF::EI_CLASS] == llvm::ELF::ELFCLASS32) {
281 size_to_read = sizeof(llvm::ELF::Elf32_Ehdr) +
282 elf_eheader.e_phnum * elf_eheader.e_phentsize;
283 } else if (elf_eheader.e_ident[llvm::ELF::EI_CLASS] ==
284 llvm::ELF::ELFCLASS64) {
285 llvm::ELF::Elf64_Ehdr elf_eheader;
287 if (process->ReadMemory(m_load_address, &elf_eheader, sizeof(elf_eheader),
288 error) == sizeof(elf_eheader))
289 size_to_read = sizeof(llvm::ELF::Elf64_Ehdr) +
290 elf_eheader.e_phnum * elf_eheader.e_phentsize;
291 }
292 }
293
294 memory_module_sp =
295 process->ReadModuleFromMemory(file_spec, m_load_address, size_to_read);
296
297 if (!memory_module_sp)
298 return false;
299
300 bool this_is_kernel = is_kernel(memory_module_sp.get());
301
302 if (!m_uuid.IsValid() && memory_module_sp->GetUUID().IsValid())
303 m_uuid = memory_module_sp->GetUUID();
304
305 m_memory_module_sp = memory_module_sp;
306 m_is_kernel = this_is_kernel;
307
308 // The kernel binary is from memory
309 if (this_is_kernel) {
310 LLDB_LOGF(log, "KextImageInfo::ReadMemoryModule read the kernel binary out "
311 "of memory");
312
313 if (memory_module_sp->GetArchitecture().IsValid())
314 process->GetTarget().SetArchitecture(memory_module_sp->GetArchitecture());
315 }
316
317 return true;
318}
319
321 lldb_private::Process *process) {
322 Log *log = GetLog(LLDBLog::DynamicLoader);
323
324 if (IsLoaded())
325 return true;
326
327 Target &target = process->GetTarget();
328
329 if (IsKernel() && m_uuid.IsValid()) {
330 Stream &s = target.GetDebugger().GetOutputStream();
331 s.Printf("Kernel UUID: %s\n", m_uuid.GetAsString().c_str());
332 s.Printf("Load Address: 0x%" PRIx64 "\n", m_load_address);
333 }
334
335 // Test if the module is loaded into the taget,
336 // maybe the module is loaded manually by user by doing target module add
337 // So that we have to create the module manually
338 if (!m_module_sp) {
339 const ModuleList &target_images = target.GetImages();
340 m_module_sp = target_images.FindModule(m_uuid);
341
342 // Search in the file system
343 if (!m_module_sp) {
344 ModuleSpec module_spec(FileSpec(GetPath()), target.GetArchitecture());
345 if (IsKernel()) {
348 true)) {
349 if (FileSystem::Instance().Exists(module_spec.GetFileSpec()))
350 m_module_sp = std::make_shared<Module>(module_spec.GetFileSpec(),
351 target.GetArchitecture());
352 }
353 }
354
355 if (!m_module_sp)
356 m_module_sp = target.GetOrCreateModule(module_spec, true);
357 if (IsKernel() && !m_module_sp) {
358 Stream &s = target.GetDebugger().GetOutputStream();
359 s.Printf("WARNING: Unable to locate kernel binary on the debugger "
360 "system.\n");
361 }
362 }
363
364 if (m_module_sp) {
365 // If the file is not kernel or kmod, the target should be loaded once and
366 // don't reload again
367 if (!IsKernel() && !is_kmod(m_module_sp.get())) {
368 ModuleSP existing_module_sp = target.GetImages().FindModule(m_uuid);
369 if (existing_module_sp &&
370 existing_module_sp->IsLoadedInTarget(&target)) {
371 LLDB_LOGF(log,
372 "'%s' with UUID %s is not a kmod or kernel, and is "
373 "already registered in target, not loading.",
374 m_name.c_str(), m_uuid.GetAsString().c_str());
375 return true;
376 }
377 }
378 m_uuid = m_module_sp->GetUUID();
379
380 // or append to the images
381 target.GetImages().AppendIfNeeded(m_module_sp, false);
382 }
383 }
384
385 // If this file is relocatable kernel module(x86_64), adjust it's
386 // section(PT_LOAD segment) and return Because the kernel module's load
387 // address is the text section. lldb cannot create full memory module upon
388 // relocatable file So what we do is to set the load address only.
389 if (is_kmod(m_module_sp.get()) && is_reloc(m_module_sp.get())) {
390 m_stop_id = process->GetStopID();
391 bool changed = false;
392 m_module_sp->SetLoadAddress(target, m_load_address, true, changed);
393 return true;
394 }
395
396 if (m_module_sp)
397 ReadMemoryModule(process);
398
399 // Calculate the slides of in memory module
400 if (!m_memory_module_sp || !m_module_sp) {
401 m_module_sp.reset();
402 return false;
403 }
404
405 ObjectFile *ondisk_object_file = m_module_sp->GetObjectFile();
406 ObjectFile *memory_object_file = m_memory_module_sp->GetObjectFile();
407
408 if (!ondisk_object_file || !memory_object_file)
409 m_module_sp.reset();
410
411 // Find the slide address
412 addr_t fixed_slide = LLDB_INVALID_ADDRESS;
413 if (llvm::dyn_cast<ObjectFileELF>(memory_object_file)) {
414 addr_t load_address = memory_object_file->GetBaseAddress().GetFileAddress();
415
416 if (load_address != LLDB_INVALID_ADDRESS &&
417 m_load_address != load_address) {
418 fixed_slide = m_load_address - load_address;
419 LLDB_LOGF(log,
420 "kmod %s in-memory LOAD vmaddr is not correct, using a "
421 "fixed slide of 0x%" PRIx64,
422 m_name.c_str(), fixed_slide);
423 }
424 }
425
426 SectionList *ondisk_section_list = ondisk_object_file->GetSectionList();
427 SectionList *memory_section_list = memory_object_file->GetSectionList();
428
429 if (memory_section_list && ondisk_object_file) {
430 const uint32_t num_ondisk_sections = ondisk_section_list->GetSize();
431 uint32_t num_load_sections = 0;
432
433 for (uint32_t section_idx = 0; section_idx < num_ondisk_sections;
434 ++section_idx) {
435 SectionSP on_disk_section_sp =
436 ondisk_section_list->GetSectionAtIndex(section_idx);
437
438 if (!on_disk_section_sp)
439 continue;
440 if (fixed_slide != LLDB_INVALID_ADDRESS) {
441 target.SetSectionLoadAddress(on_disk_section_sp,
442 on_disk_section_sp->GetFileAddress() +
443 fixed_slide);
444
445 } else {
446 const Section *memory_section =
447 memory_section_list
448 ->FindSectionByName(on_disk_section_sp->GetName())
449 .get();
450 if (memory_section) {
451 target.SetSectionLoadAddress(on_disk_section_sp,
452 memory_section->GetFileAddress());
453 ++num_load_sections;
454 }
455 }
456 }
457
458 if (num_load_sections)
459 m_stop_id = process->GetStopID();
460 else
461 m_module_sp.reset();
462 } else {
463 m_module_sp.reset();
464 }
465
466 if (IsLoaded() && m_module_sp && IsKernel()) {
467 Stream &s = target.GetDebugger().GetOutputStream();
468 ObjectFile *kernel_object_file = m_module_sp->GetObjectFile();
469 if (kernel_object_file) {
470 addr_t file_address =
471 kernel_object_file->GetBaseAddress().GetFileAddress();
472 if (m_load_address != LLDB_INVALID_ADDRESS &&
473 file_address != LLDB_INVALID_ADDRESS) {
474 s.Printf("Kernel slide 0x%" PRIx64 " in memory.\n",
475 m_load_address - file_address);
476 s.Printf("Loaded kernel file %s\n",
477 m_module_sp->GetFileSpec().GetPath().c_str());
478 }
479 }
480 s.Flush();
481 }
482
483 return IsLoaded();
484}
485
486// This function is work for kernel file, others it wil reset load address and
487// return false
489 lldb_private::Process *process) {
490 if (IsLoaded())
491 return true;
492
493 if (m_module_sp) {
494 bool changed = false;
495 if (m_module_sp->SetLoadAddress(process->GetTarget(), 0, true, changed))
496 m_stop_id = process->GetStopID();
497 }
498
499 return false;
500}
501
502// Get the head of found_list
504 std::lock_guard<decltype(m_mutex)> guard(m_mutex);
505
507 // Get tqh_first struct element from linker_files
511 error);
512 if (address != LLDB_INVALID_ADDRESS && error.Success()) {
514 } else {
516 return false;
517 }
518
522 return false;
523 }
524 }
525 return true;
526}
527
528// Parse Kmod info in found_list
530 std::lock_guard<decltype(m_mutex)> guard(m_mutex);
531 KModImageInfo::collection_type linker_files_list;
532 Log *log = GetLog(LLDBLog::DynamicLoader);
533
534 if (!ReadAllKmods(linker_files_head_addr, linker_files_list))
535 return false;
536 LLDB_LOGF(
537 log,
538 "Kmod-changed breakpoint hit, there are %zu kernel modules currently.\n",
539 linker_files_list.size());
540
541 ModuleList &modules = m_process->GetTarget().GetImages();
542 ModuleList remove_modules;
543 ModuleList add_modules;
544
545 for (ModuleSP module : modules.Modules()) {
546 if (is_kernel(module.get()))
547 continue;
548 if (is_kmod(module.get()))
549 remove_modules.AppendIfNeeded(module);
550 }
551
552 m_process->GetTarget().ModulesDidUnload(remove_modules, false);
553
554 for (KModImageInfo &image_info : linker_files_list) {
555 if (m_kld_name_to_uuid.find(image_info.GetName()) !=
556 m_kld_name_to_uuid.end())
557 image_info.SetUUID(m_kld_name_to_uuid[image_info.GetName()]);
558 bool failed_to_load = false;
559 if (!image_info.LoadImageUsingMemoryModule(m_process)) {
560 image_info.LoadImageUsingFileAddress(m_process);
561 failed_to_load = true;
562 } else {
563 m_linker_files_list.push_back(image_info);
564 m_kld_name_to_uuid[image_info.GetName()] = image_info.GetUUID();
565 }
566
567 if (!failed_to_load)
568 add_modules.AppendIfNeeded(image_info.GetModule());
569 }
570 m_process->GetTarget().ModulesDidLoad(add_modules);
571 return true;
572}
573
574// Read all kmod from a given arrays of list
576 Address linker_files_head_addr,
577 KModImageInfo::collection_type &kmods_list) {
578
579 // Get offset of next member and load address symbol
580 static ConstString kld_off_address_symbol_name("kld_off_address");
581 static ConstString kld_off_next_symbol_name("kld_off_next");
582 static ConstString kld_off_filename_symbol_name("kld_off_filename");
583 static ConstString kld_off_pathname_symbol_name("kld_off_pathname");
584 const Symbol *kld_off_address_symbol =
585 m_kernel_image_info.GetModule()->FindFirstSymbolWithNameAndType(
586 kld_off_address_symbol_name, eSymbolTypeData);
587 const Symbol *kld_off_next_symbol =
588 m_kernel_image_info.GetModule()->FindFirstSymbolWithNameAndType(
589 kld_off_next_symbol_name, eSymbolTypeData);
590 const Symbol *kld_off_filename_symbol =
591 m_kernel_image_info.GetModule()->FindFirstSymbolWithNameAndType(
592 kld_off_filename_symbol_name, eSymbolTypeData);
593 const Symbol *kld_off_pathname_symbol =
594 m_kernel_image_info.GetModule()->FindFirstSymbolWithNameAndType(
595 kld_off_pathname_symbol_name, eSymbolTypeData);
596
597 if (!kld_off_address_symbol || !kld_off_next_symbol ||
598 !kld_off_filename_symbol || !kld_off_pathname_symbol)
599 return false;
600
602 const int32_t kld_off_address = m_process->ReadSignedIntegerFromMemory(
603 kld_off_address_symbol->GetAddress().GetLoadAddress(
604 &m_process->GetTarget()),
605 4, 0, error);
606 if (error.Fail())
607 return false;
608 const int32_t kld_off_next = m_process->ReadSignedIntegerFromMemory(
609 kld_off_next_symbol->GetAddress().GetLoadAddress(&m_process->GetTarget()),
610 4, 0, error);
611 if (error.Fail())
612 return false;
613 const int32_t kld_off_filename = m_process->ReadSignedIntegerFromMemory(
614 kld_off_filename_symbol->GetAddress().GetLoadAddress(
615 &m_process->GetTarget()),
616 4, 0, error);
617 if (error.Fail())
618 return false;
619
620 const int32_t kld_off_pathname = m_process->ReadSignedIntegerFromMemory(
621 kld_off_pathname_symbol->GetAddress().GetLoadAddress(
622 &m_process->GetTarget()),
623 4, 0, error);
624 if (error.Fail())
625 return false;
626
627 // Parse KMods
628 addr_t kld_load_addr(LLDB_INVALID_ADDRESS);
629 char kld_filename[255];
630 char kld_pathname[255];
631 addr_t current_kld =
632 linker_files_head_addr.GetLoadAddress(&m_process->GetTarget());
633
634 while (current_kld != 0) {
635 addr_t kld_filename_addr =
636 m_process->ReadPointerFromMemory(current_kld + kld_off_filename, error);
637 if (error.Fail())
638 return false;
639 addr_t kld_pathname_addr =
640 m_process->ReadPointerFromMemory(current_kld + kld_off_pathname, error);
641 if (error.Fail())
642 return false;
643
644 m_process->ReadCStringFromMemory(kld_filename_addr, kld_filename,
645 sizeof(kld_filename), error);
646 if (error.Fail())
647 return false;
648 m_process->ReadCStringFromMemory(kld_pathname_addr, kld_pathname,
649 sizeof(kld_pathname), error);
650 if (error.Fail())
651 return false;
652 kld_load_addr =
653 m_process->ReadPointerFromMemory(current_kld + kld_off_address, error);
654 if (error.Fail())
655 return false;
656
657 kmods_list.emplace_back();
658 KModImageInfo &kmod_info = kmods_list.back();
659 kmod_info.SetName(kld_filename);
660 kmod_info.SetLoadAddress(kld_load_addr);
661 kmod_info.SetPath(kld_pathname);
662
663 current_kld =
664 m_process->ReadPointerFromMemory(current_kld + kld_off_next, error);
665 if (kmod_info.GetName() == "kernel")
666 kmods_list.pop_back();
667 if (error.Fail())
668 return false;
669 }
670
671 return true;
672}
673
674// Read all kmods
676 std::lock_guard<decltype(m_mutex)> guard(m_mutex);
677
678 if (ReadKmodsListHeader()) {
681 m_linker_files_list.clear();
682 }
683 }
684}
685
686// Load all Kernel Modules
688 Log *log = GetLog(LLDBLog::DynamicLoader);
689 LLDB_LOGF(log, "DynamicLoaderFreeBSDKernel::LoadKernelModules "
690 "Start loading Kernel Module");
691
692 // Initialize Kernel Image Information at the first time
695 if (is_kernel(module_sp.get())) {
698 }
699
700 // Set name for kernel
701 llvm::StringRef kernel_name("freebsd_kernel");
702 module_sp = m_kernel_image_info.GetModule();
703 if (module_sp.get() && module_sp->GetObjectFile() &&
704 !module_sp->GetObjectFile()->GetFileSpec().GetFilename().IsEmpty())
705 kernel_name = module_sp->GetObjectFile()
706 ->GetFileSpec()
707 .GetFilename()
708 .GetStringRef();
709 m_kernel_image_info.SetName(kernel_name.data());
710
713 }
714
715 // Build In memory Module
717 // If the kernel is not loaded in the memory, use file to load
720 }
721 }
722
724
727 return;
728 }
729
730 static ConstString modlist_symbol_name("linker_files");
731
732 const Symbol *symbol =
733 m_kernel_image_info.GetModule()->FindFirstSymbolWithNameAndType(
734 modlist_symbol_name, lldb::eSymbolTypeData);
735
736 if (symbol) {
738 ReadAllKmods();
739 } else {
740 LLDB_LOGF(log, "DynamicLoaderFreeBSDKernel::LoadKernelModules "
741 "cannot file modlist symbol");
742 }
743}
744
745// Update symbol when use kldload by setting callback function on kldload
747
748// Hook called when attach to a process
751 Update();
752}
753
754// Hook called after attach to a process
757 Update();
758}
759
760// Clear all member except kernel address
761void DynamicLoaderFreeBSDKernel::Clear(bool clear_process) {
762 std::lock_guard<decltype(m_mutex)> guard(m_mutex);
763 if (clear_process)
764 m_process = nullptr;
768 m_linker_files_list.clear();
769}
770
771// Reinitialize class
773 Clear(true);
774 m_process = process;
775}
776
778 lldb_private::Thread &thread, bool stop_others) {
779 Log *log = GetLog(LLDBLog::Step);
780 LLDB_LOGF(log, "DynamicLoaderFreeBSDKernel::GetStepThroughTrampolinePlan is "
781 "not yet implemented.");
782 return {};
783}
784
786 Status error("shared object cannot be loaded into kernel");
787 return error;
788}
static llvm::raw_ostream & error(Stream &strm)
static bool is_kernel(Module *module)
static bool is_reloc(Module *module)
static bool is_kernel(Module *module)
static bool is_kmod(Module *module)
#define LLDB_LOGF(log,...)
Definition: Log.h:349
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
bool LoadImageUsingFileAddress(lldb_private::Process *process)
bool ReadMemoryModule(lldb_private::Process *process)
bool LoadImageUsingMemoryModule(lldb_private::Process *process)
void DidAttach() override
Called after attaching a process.
DynamicLoaderFreeBSDKernel(lldb_private::Process *process, lldb::addr_t kernel_addr)
KModImageInfo::collection_type m_linker_files_list
lldb_private::Address m_linker_file_list_struct_addr
void PrivateInitialize(lldb_private::Process *process)
lldb_private::Address m_linker_file_head_addr
lldb::ThreadPlanSP GetStepThroughTrampolinePlan(lldb_private::Thread &thread, bool stop_others) override
Provides a plan to step through the dynamic loader trampoline for the current state of thread.
bool ParseKmods(lldb_private::Address linker_files_head_address)
static void DebuggerInit(lldb_private::Debugger &debugger)
static lldb::addr_t FindFreeBSDKernel(lldb_private::Process *process)
lldb_private::Status CanLoadImage() override
Ask if it is ok to try and load or unload an shared library (image).
std::unordered_map< std::string, lldb_private::UUID > m_kld_name_to_uuid
void DidLaunch() override
Called after launching a process.
static lldb::addr_t FindKernelAtLoadAddress(lldb_private::Process *process)
static llvm::StringRef GetPluginDescriptionStatic()
static lldb_private::UUID CheckForKernelImageAtAddress(lldb_private::Process *process, lldb::addr_t address, bool *read_error=nullptr)
static lldb_private::DynamicLoader * CreateInstance(lldb_private::Process *process, bool force)
static bool ReadELFHeader(lldb_private::Process *process, lldb::addr_t address, llvm::ELF::Elf32_Ehdr &header, bool *read_error=nullptr)
A section + offset based address class.
Definition: Address.h:62
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:313
void Clear()
Clear the object's state.
Definition: Address.h:181
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:293
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:355
An architecture specification class.
Definition: ArchSpec.h:31
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:450
bool IsCompatibleMatch(const ArchSpec &rhs) const
Shorthand for IsMatch(rhs, CompatibleMatch).
Definition: ArchSpec.h:502
A uniqued constant string class.
Definition: ConstString.h:40
A class to manage flag bits.
Definition: Debugger.h:79
StreamFile & GetOutputStream()
Definition: Debugger.h:154
A plug-in interface definition class for dynamic loaders.
Definition: DynamicLoader.h:52
void LoadOperatingSystemPlugin(bool flush)
A file utility class.
Definition: FileSpec.h:56
static FileSystem & Instance()
A collection class for Module objects.
Definition: ModuleList.h:103
bool AppendIfNeeded(const lldb::ModuleSP &new_module, bool notify=true)
Append a module to the module list, if it is not already there.
Definition: ModuleList.cpp:280
lldb::ModuleSP FindModule(const Module *module_ptr) const
Definition: ModuleList.cpp:552
ModuleIterable Modules() const
Definition: ModuleList.h:527
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:53
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
virtual ObjectFile * GetObjectFile()
Get the object file representation for the current architecture.
Definition: Module.cpp:1182
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:44
@ eTypeExecutable
A normal executable.
Definition: ObjectFile.h:53
@ eTypeObjectFile
An intermediate object file.
Definition: ObjectFile.h:59
@ eTypeSharedLibrary
A shared library that can be used during execution.
Definition: ObjectFile.h:61
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 lldb_private::Address GetBaseAddress()
Returns base address of this object file.
Definition: ObjectFile.h:479
static bool DownloadObjectAndSymbolFile(ModuleSpec &module_spec, Status &error, bool force_lookup=true, bool copy_executable=true)
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
A plug-in interface definition class for debugging a process.
Definition: Process.h:340
int64_t ReadSignedIntegerFromMemory(lldb::addr_t load_addr, size_t byte_size, int64_t fail_value, Status &error)
Definition: Process.cpp:2090
size_t ReadCStringFromMemory(lldb::addr_t vm_addr, char *cstr, size_t cstr_max_len, Status &error)
Read a NULL terminated C string from memory.
Definition: Process.cpp:2004
virtual size_t ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
Read of memory from a process.
Definition: Process.cpp:1938
virtual lldb::addr_t GetImageInfoAddress()
Get the image information address for the current process.
Definition: Process.cpp:1494
void SetCanRunCode(bool can_run_code)
Sets whether executing code in this process is possible.
Definition: Process.cpp:2345
lldb::addr_t ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error)
Definition: Process.cpp:2101
uint32_t GetStopID() const
Definition: Process.h:1461
lldb::ModuleSP ReadModuleFromMemory(const FileSpec &file_spec, lldb::addr_t header_addr, size_t size_to_read=512)
Definition: Process.cpp:2387
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1276
lldb::SectionSP FindSectionByName(ConstString section_dstr) const
Definition: Section.cpp:552
size_t GetSize() const
Definition: Section.h:75
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:544
lldb::addr_t GetFileAddress() const
Definition: Section.cpp:193
An error handling class.
Definition: Status.h:44
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
virtual void Flush()=0
Flush the stream.
Address GetAddress() const
Definition: Symbol.h:88
void ModulesDidLoad(ModuleList &module_list)
Definition: Target.cpp:1689
Module * GetExecutableModulePointer()
Definition: Target.cpp:1435
Debugger & GetDebugger()
Definition: Target.h:1053
lldb::ModuleSP GetOrCreateModule(const ModuleSpec &module_spec, bool notify, Status *error_ptr=nullptr)
Find a binary on the system and return its Module, or return an existing Module that is already in th...
Definition: Target.cpp:2157
bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform=false, bool merge=true)
Set the architecture for this target.
Definition: Target.cpp:1537
lldb::ModuleSP GetExecutableModule()
Gets the module for the main executable.
Definition: Target.cpp:1421
void ModulesDidUnload(ModuleList &module_list, bool delete_locations)
Definition: Target.cpp:1723
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:970
const ArchSpec & GetArchitecture() const
Definition: Target.h:1012
bool SetSectionLoadAddress(const lldb::SectionSP &section, lldb::addr_t load_addr, bool warn_multiple=false)
Definition: Target.cpp:3120
bool IsValid() const
Definition: UUID.h:69
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
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::ThreadPlan > ThreadPlanSP
Definition: lldb-forward.h:441
std::shared_ptr< lldb_private::Section > SectionSP
Definition: lldb-forward.h:406
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:365