LLDB  mainline
DynamicLoaderDarwinKernel.cpp
Go to the documentation of this file.
1 //===-- DynamicLoaderDarwinKernel.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 
11 #include "lldb/Core/Debugger.h"
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/ModuleSpec.h"
15 #include "lldb/Core/Section.h"
16 #include "lldb/Core/StreamFile.h"
19 #include "lldb/Symbol/ObjectFile.h"
22 #include "lldb/Target/StackFrame.h"
23 #include "lldb/Target/Target.h"
24 #include "lldb/Target/Thread.h"
28 #include "lldb/Utility/Log.h"
29 #include "lldb/Utility/State.h"
30 
32 
33 #include <algorithm>
34 #include <memory>
35 
36 //#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
37 #ifdef ENABLE_DEBUG_PRINTF
38 #include <cstdio>
39 #define DEBUG_PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)
40 #else
41 #define DEBUG_PRINTF(fmt, ...)
42 #endif
43 
44 using namespace lldb;
45 using namespace lldb_private;
46 
48 
49 // Progressively greater amounts of scanning we will allow For some targets
50 // very early in startup, we can't do any random reads of memory or we can
51 // crash the device so a setting is needed that can completely disable the
52 // KASLR scans.
53 
55  eKASLRScanNone = 0, // No reading into the inferior at all
56  eKASLRScanLowgloAddresses, // Check one word of memory for a possible kernel
57  // addr, then see if a kernel is there
58  eKASLRScanNearPC, // Scan backwards from the current $pc looking for kernel;
59  // checking at 96 locations total
60  eKASLRScanExhaustiveScan // Scan through the entire possible kernel address
61  // range looking for a kernel
62 };
63 
64 static constexpr OptionEnumValueElement g_kaslr_kernel_scan_enum_values[] = {
65  {
67  "none",
68  "Do not read memory looking for a Darwin kernel when attaching.",
69  },
70  {
72  "basic",
73  "Check for the Darwin kernel's load addr in the lowglo page "
74  "(boot-args=debug) only.",
75  },
76  {
78  "fast-scan",
79  "Scan near the pc value on attach to find the Darwin kernel's load "
80  "address.",
81  },
82  {
84  "exhaustive-scan",
85  "Scan through the entire potential address range of Darwin kernel "
86  "(only on 32-bit targets).",
87  },
88 };
89 
90 #define LLDB_PROPERTIES_dynamicloaderdarwinkernel
91 #include "DynamicLoaderDarwinKernelProperties.inc"
92 
93 enum {
94 #define LLDB_PROPERTIES_dynamicloaderdarwinkernel
95 #include "DynamicLoaderDarwinKernelPropertiesEnum.inc"
96 };
97 
99 public:
101  static ConstString g_setting_name("darwin-kernel");
102  return g_setting_name;
103  }
104 
106  m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
107  m_collection_sp->Initialize(g_dynamicloaderdarwinkernel_properties);
108  }
109 
110  ~DynamicLoaderDarwinKernelProperties() override = default;
111 
112  bool GetLoadKexts() const {
113  const uint32_t idx = ePropertyLoadKexts;
114  return m_collection_sp->GetPropertyAtIndexAsBoolean(
115  nullptr, idx,
116  g_dynamicloaderdarwinkernel_properties[idx].default_uint_value != 0);
117  }
118 
120  const uint32_t idx = ePropertyScanType;
121  return (KASLRScanType)m_collection_sp->GetPropertyAtIndexAsEnumeration(
122  nullptr, idx,
123  g_dynamicloaderdarwinkernel_properties[idx].default_uint_value);
124  }
125 };
126 
128  static DynamicLoaderDarwinKernelProperties g_settings;
129  return g_settings;
130 }
131 
132 // Create an instance of this class. This function is filled into the plugin
133 // info class that gets handed out by the plugin factory and allows the lldb to
134 // instantiate an instance of this class.
136  bool force) {
137  if (!force) {
138  // If the user provided an executable binary and it is not a kernel, this
139  // plugin should not create an instance.
140  Module *exe_module = process->GetTarget().GetExecutableModulePointer();
141  if (exe_module) {
142  ObjectFile *object_file = exe_module->GetObjectFile();
143  if (object_file) {
144  if (object_file->GetStrata() != ObjectFile::eStrataKernel) {
145  return nullptr;
146  }
147  }
148  }
149 
150  // If the target's architecture does not look like an Apple environment,
151  // this plugin should not create an instance.
152  const llvm::Triple &triple_ref =
153  process->GetTarget().GetArchitecture().GetTriple();
154  switch (triple_ref.getOS()) {
155  case llvm::Triple::Darwin:
156  case llvm::Triple::MacOSX:
157  case llvm::Triple::IOS:
158  case llvm::Triple::TvOS:
159  case llvm::Triple::WatchOS:
160  // NEED_BRIDGEOS_TRIPLE case llvm::Triple::BridgeOS:
161  if (triple_ref.getVendor() != llvm::Triple::Apple) {
162  return nullptr;
163  }
164  break;
165  // If we have triple like armv7-unknown-unknown, we should try looking for
166  // a Darwin kernel.
167  case llvm::Triple::UnknownOS:
168  break;
169  default:
170  return nullptr;
171  break;
172  }
173  }
174 
175  // At this point if there is an ExecutableModule, it is a kernel and the
176  // Target is some variant of an Apple system. If the Process hasn't provided
177  // the kernel load address, we need to look around in memory to find it.
178 
179  const addr_t kernel_load_address = SearchForDarwinKernel(process);
180  if (CheckForKernelImageAtAddress(kernel_load_address, process).IsValid()) {
181  process->SetCanRunCode(false);
182  return new DynamicLoaderDarwinKernel(process, kernel_load_address);
183  }
184  return nullptr;
185 }
186 
189  addr_t kernel_load_address = process->GetImageInfoAddress();
190  if (kernel_load_address == LLDB_INVALID_ADDRESS) {
191  kernel_load_address = SearchForKernelAtSameLoadAddr(process);
192  if (kernel_load_address == LLDB_INVALID_ADDRESS) {
193  kernel_load_address = SearchForKernelWithDebugHints(process);
194  if (kernel_load_address == LLDB_INVALID_ADDRESS) {
195  kernel_load_address = SearchForKernelNearPC(process);
196  if (kernel_load_address == LLDB_INVALID_ADDRESS) {
197  kernel_load_address = SearchForKernelViaExhaustiveSearch(process);
198  }
199  }
200  }
201  }
202  return kernel_load_address;
203 }
204 
205 // Check if the kernel binary is loaded in memory without a slide. First verify
206 // that the ExecutableModule is a kernel before we proceed. Returns the address
207 // of the kernel if one was found, else LLDB_INVALID_ADDRESS.
210  Module *exe_module = process->GetTarget().GetExecutableModulePointer();
211  if (exe_module == nullptr)
212  return LLDB_INVALID_ADDRESS;
213 
214  ObjectFile *exe_objfile = exe_module->GetObjectFile();
215  if (exe_objfile == nullptr)
216  return LLDB_INVALID_ADDRESS;
217 
218  if (exe_objfile->GetType() != ObjectFile::eTypeExecutable ||
219  exe_objfile->GetStrata() != ObjectFile::eStrataKernel)
220  return LLDB_INVALID_ADDRESS;
221 
222  if (!exe_objfile->GetBaseAddress().IsValid())
223  return LLDB_INVALID_ADDRESS;
224 
225  if (CheckForKernelImageAtAddress(
226  exe_objfile->GetBaseAddress().GetFileAddress(), process) ==
227  exe_module->GetUUID())
228  return exe_objfile->GetBaseAddress().GetFileAddress();
229 
230  return LLDB_INVALID_ADDRESS;
231 }
232 
233 // If the debug flag is included in the boot-args nvram setting, the kernel's
234 // load address will be noted in the lowglo page at a fixed address Returns the
235 // address of the kernel if one was found, else LLDB_INVALID_ADDRESS.
238  if (GetGlobalProperties().GetScanType() == eKASLRScanNone)
239  return LLDB_INVALID_ADDRESS;
240 
241  Status read_err;
242  addr_t kernel_addresses_64[] = {
243  0xfffffff000002010ULL,
244  0xfffffff000004010ULL, // newest arm64 devices
245  0xffffff8000004010ULL, // 2014-2015-ish arm64 devices
246  0xffffff8000002010ULL, // oldest arm64 devices
248  addr_t kernel_addresses_32[] = {0xffff0110, // 2016 and earlier armv7 devices
249  0xffff1010, LLDB_INVALID_ADDRESS};
250 
251  uint8_t uval[8];
252  if (process->GetAddressByteSize() == 8) {
253  for (size_t i = 0; kernel_addresses_64[i] != LLDB_INVALID_ADDRESS; i++) {
254  if (process->ReadMemoryFromInferior (kernel_addresses_64[i], uval, 8, read_err) == 8)
255  {
256  DataExtractor data (&uval, 8, process->GetByteOrder(), process->GetAddressByteSize());
257  offset_t offset = 0;
258  uint64_t addr = data.GetU64 (&offset);
259  if (CheckForKernelImageAtAddress(addr, process).IsValid()) {
260  return addr;
261  }
262  }
263  }
264  }
265 
266  if (process->GetAddressByteSize() == 4) {
267  for (size_t i = 0; kernel_addresses_32[i] != LLDB_INVALID_ADDRESS; i++) {
268  if (process->ReadMemoryFromInferior (kernel_addresses_32[i], uval, 4, read_err) == 4)
269  {
270  DataExtractor data (&uval, 4, process->GetByteOrder(), process->GetAddressByteSize());
271  offset_t offset = 0;
272  uint32_t addr = data.GetU32 (&offset);
273  if (CheckForKernelImageAtAddress(addr, process).IsValid()) {
274  return addr;
275  }
276  }
277  }
278  }
279 
280  return LLDB_INVALID_ADDRESS;
281 }
282 
283 // If the kernel is currently executing when lldb attaches, and we don't have a
284 // better way of finding the kernel's load address, try searching backwards
285 // from the current pc value looking for the kernel's Mach header in memory.
286 // Returns the address of the kernel if one was found, else
287 // LLDB_INVALID_ADDRESS.
290  if (GetGlobalProperties().GetScanType() == eKASLRScanNone ||
291  GetGlobalProperties().GetScanType() == eKASLRScanLowgloAddresses) {
292  return LLDB_INVALID_ADDRESS;
293  }
294 
295  ThreadSP thread = process->GetThreadList().GetSelectedThread();
296  if (thread.get() == nullptr)
297  return LLDB_INVALID_ADDRESS;
298  addr_t pc = thread->GetRegisterContext()->GetPC(LLDB_INVALID_ADDRESS);
299 
300  int ptrsize = process->GetTarget().GetArchitecture().GetAddressByteSize();
301 
302  // The kernel is always loaded in high memory, if the top bit is zero,
303  // this isn't a kernel.
304  if (ptrsize == 8) {
305  if ((pc & (1ULL << 63)) == 0) {
306  return LLDB_INVALID_ADDRESS;
307  }
308  } else {
309  if ((pc & (1ULL << 31)) == 0) {
310  return LLDB_INVALID_ADDRESS;
311  }
312  }
313 
314  if (pc == LLDB_INVALID_ADDRESS)
315  return LLDB_INVALID_ADDRESS;
316 
317  int pagesize = 0x4000; // 16k pages on 64-bit targets
318  if (ptrsize == 4)
319  pagesize = 0x1000; // 4k pages on 32-bit targets
320 
321  // The kernel will be loaded on a page boundary.
322  // Round the current pc down to the nearest page boundary.
323  addr_t addr = pc & ~(pagesize - 1ULL);
324 
325  // Search backwards for 32 megabytes, or first memory read error.
326  while (pc - addr < 32 * 0x100000) {
327  bool read_error;
328  if (CheckForKernelImageAtAddress(addr, process, &read_error).IsValid())
329  return addr;
330 
331  // Stop scanning on the first read error we encounter; we've walked
332  // past this executable block of memory.
333  if (read_error == true)
334  break;
335 
336  addr -= pagesize;
337  }
338 
339  return LLDB_INVALID_ADDRESS;
340 }
341 
342 // Scan through the valid address range for a kernel binary. This is uselessly
343 // slow in 64-bit environments so we don't even try it. This scan is not
344 // enabled by default even for 32-bit targets. Returns the address of the
345 // kernel if one was found, else LLDB_INVALID_ADDRESS.
347  Process *process) {
348  if (GetGlobalProperties().GetScanType() != eKASLRScanExhaustiveScan) {
349  return LLDB_INVALID_ADDRESS;
350  }
351 
352  addr_t kernel_range_low, kernel_range_high;
353  if (process->GetTarget().GetArchitecture().GetAddressByteSize() == 8) {
354  kernel_range_low = 1ULL << 63;
355  kernel_range_high = UINT64_MAX;
356  } else {
357  kernel_range_low = 1ULL << 31;
358  kernel_range_high = UINT32_MAX;
359  }
360 
361  // Stepping through memory at one-megabyte resolution looking for a kernel
362  // rarely works (fast enough) with a 64-bit address space -- for now, let's
363  // not even bother. We may be attaching to something which *isn't* a kernel
364  // and we don't want to spin for minutes on-end looking for a kernel.
365  if (process->GetTarget().GetArchitecture().GetAddressByteSize() == 8)
366  return LLDB_INVALID_ADDRESS;
367 
368  addr_t addr = kernel_range_low;
369 
370  while (addr >= kernel_range_low && addr < kernel_range_high) {
371  // x86_64 kernels are at offset 0
372  if (CheckForKernelImageAtAddress(addr, process).IsValid())
373  return addr;
374  // 32-bit arm kernels are at offset 0x1000 (one 4k page)
375  if (CheckForKernelImageAtAddress(addr + 0x1000, process).IsValid())
376  return addr + 0x1000;
377  // 64-bit arm kernels are at offset 0x4000 (one 16k page)
378  if (CheckForKernelImageAtAddress(addr + 0x4000, process).IsValid())
379  return addr + 0x4000;
380  addr += 0x100000;
381  }
382  return LLDB_INVALID_ADDRESS;
383 }
384 
385 // Read the mach_header struct out of memory and return it.
386 // Returns true if the mach_header was successfully read,
387 // Returns false if there was a problem reading the header, or it was not
388 // a Mach-O header.
389 
390 bool
391 DynamicLoaderDarwinKernel::ReadMachHeader(addr_t addr, Process *process, llvm::MachO::mach_header &header,
392  bool *read_error) {
393  Status error;
394  if (read_error)
395  *read_error = false;
396 
397  // Read the mach header and see whether it looks like a kernel
398  if (process->ReadMemory(addr, &header, sizeof(header), error) !=
399  sizeof(header)) {
400  if (read_error)
401  *read_error = true;
402  return false;
403  }
404 
405  const uint32_t magicks[] = { llvm::MachO::MH_MAGIC_64, llvm::MachO::MH_MAGIC, llvm::MachO::MH_CIGAM, llvm::MachO::MH_CIGAM_64};
406 
407  bool found_matching_pattern = false;
408  for (size_t i = 0; i < llvm::array_lengthof (magicks); i++)
409  if (::memcmp (&header.magic, &magicks[i], sizeof (uint32_t)) == 0)
410  found_matching_pattern = true;
411 
412  if (!found_matching_pattern)
413  return false;
414 
415  if (header.magic == llvm::MachO::MH_CIGAM ||
416  header.magic == llvm::MachO::MH_CIGAM_64) {
417  header.magic = llvm::ByteSwap_32(header.magic);
418  header.cputype = llvm::ByteSwap_32(header.cputype);
419  header.cpusubtype = llvm::ByteSwap_32(header.cpusubtype);
420  header.filetype = llvm::ByteSwap_32(header.filetype);
421  header.ncmds = llvm::ByteSwap_32(header.ncmds);
422  header.sizeofcmds = llvm::ByteSwap_32(header.sizeofcmds);
423  header.flags = llvm::ByteSwap_32(header.flags);
424  }
425 
426  return true;
427 }
428 
429 // Given an address in memory, look to see if there is a kernel image at that
430 // address.
431 // Returns a UUID; if a kernel was not found at that address, UUID.IsValid()
432 // will be false.
435  Process *process,
436  bool *read_error) {
438  if (addr == LLDB_INVALID_ADDRESS) {
439  if (read_error)
440  *read_error = true;
441  return UUID();
442  }
443 
444  LLDB_LOGF(log,
445  "DynamicLoaderDarwinKernel::CheckForKernelImageAtAddress: "
446  "looking for kernel binary at 0x%" PRIx64,
447  addr);
448 
449  llvm::MachO::mach_header header;
450 
451  if (!ReadMachHeader(addr, process, header, read_error))
452  return UUID();
453 
454  // First try a quick test -- read the first 4 bytes and see if there is a
455  // valid Mach-O magic field there
456  // (the first field of the mach_header/mach_header_64 struct).
457  // A kernel is an executable which does not have the dynamic link object flag
458  // set.
459  if (header.filetype == llvm::MachO::MH_EXECUTE &&
460  (header.flags & llvm::MachO::MH_DYLDLINK) == 0) {
461  // Create a full module to get the UUID
462  ModuleSP memory_module_sp =
463  process->ReadModuleFromMemory(FileSpec("temp_mach_kernel"), addr);
464  if (!memory_module_sp.get())
465  return UUID();
466 
467  ObjectFile *exe_objfile = memory_module_sp->GetObjectFile();
468  if (exe_objfile == nullptr) {
469  LLDB_LOGF(log,
470  "DynamicLoaderDarwinKernel::CheckForKernelImageAtAddress "
471  "found a binary at 0x%" PRIx64
472  " but could not create an object file from memory",
473  addr);
474  return UUID();
475  }
476 
477  if (exe_objfile->GetType() == ObjectFile::eTypeExecutable &&
478  exe_objfile->GetStrata() == ObjectFile::eStrataKernel) {
479  ArchSpec kernel_arch(eArchTypeMachO, header.cputype, header.cpusubtype);
480  if (!process->GetTarget().GetArchitecture().IsCompatibleMatch(
481  kernel_arch)) {
482  process->GetTarget().SetArchitecture(kernel_arch);
483  }
484  if (log) {
485  std::string uuid_str;
486  if (memory_module_sp->GetUUID().IsValid()) {
487  uuid_str = "with UUID ";
488  uuid_str += memory_module_sp->GetUUID().GetAsString();
489  } else {
490  uuid_str = "and no LC_UUID found in load commands ";
491  }
492  LLDB_LOGF(
493  log,
494  "DynamicLoaderDarwinKernel::CheckForKernelImageAtAddress: "
495  "kernel binary image found at 0x%" PRIx64 " with arch '%s' %s",
496  addr, kernel_arch.GetTriple().str().c_str(), uuid_str.c_str());
497  }
498  return memory_module_sp->GetUUID();
499  }
500  }
501 
502  return UUID();
503 }
504 
505 // Constructor
507  lldb::addr_t kernel_addr)
508  : DynamicLoader(process), m_kernel_load_address(kernel_addr), m_kernel(),
509  m_kext_summary_header_ptr_addr(), m_kext_summary_header_addr(),
510  m_kext_summary_header(), m_known_kexts(), m_mutex(),
511  m_break_id(LLDB_INVALID_BREAK_ID) {
512  Status error;
513  PlatformSP platform_sp(
514  Platform::Create(PlatformDarwinKernel::GetPluginNameStatic(), error));
515  if (platform_sp.get())
516  process->GetTarget().SetPlatform(platform_sp);
517 }
518 
519 // Destructor
521 
525 }
526 /// Called after attaching a process.
527 ///
528 /// Allow DynamicLoader plug-ins to execute some code after
529 /// attaching to a process.
532  UpdateIfNeeded();
533 }
534 
535 /// Called after attaching a process.
536 ///
537 /// Allow DynamicLoader plug-ins to execute some code after
538 /// attaching to a process.
541  UpdateIfNeeded();
542 }
543 
544 // Clear out the state of this class.
545 void DynamicLoaderDarwinKernel::Clear(bool clear_process) {
546  std::lock_guard<std::recursive_mutex> guard(m_mutex);
547 
550 
551  if (clear_process)
552  m_process = nullptr;
553  m_kernel.Clear();
554  m_known_kexts.clear();
558 }
559 
561  Process *process) {
562  if (IsLoaded())
563  return true;
564 
565  if (m_module_sp) {
566  bool changed = false;
567  if (m_module_sp->SetLoadAddress(process->GetTarget(), 0, true, changed))
568  m_load_process_stop_id = process->GetStopID();
569  }
570  return false;
571 }
572 
574  m_module_sp = module_sp;
575  if (module_sp.get() && module_sp->GetObjectFile()) {
576  if (module_sp->GetObjectFile()->GetType() == ObjectFile::eTypeExecutable &&
577  module_sp->GetObjectFile()->GetStrata() == ObjectFile::eStrataKernel) {
578  m_kernel_image = true;
579  } else {
580  m_kernel_image = false;
581  }
582  }
583 }
584 
586  return m_module_sp;
587 }
588 
590  addr_t load_addr) {
591  m_load_address = load_addr;
592 }
593 
595  return m_load_address;
596 }
597 
599  return m_size;
600 }
601 
603  m_size = size;
604 }
605 
607  return m_load_process_stop_id;
608 }
609 
611  uint32_t stop_id) {
612  m_load_process_stop_id = stop_id;
613 }
614 
617  if (m_uuid.IsValid() || rhs.GetUUID().IsValid()) {
618  return m_uuid == rhs.GetUUID();
619  }
620 
621  return m_name == rhs.GetName() && m_load_address == rhs.GetLoadAddress();
622 }
623 
625  m_name = name;
626 }
627 
629  return m_name;
630 }
631 
633  m_uuid = uuid;
634 }
635 
637  return m_uuid;
638 }
639 
640 // Given the m_load_address from the kext summaries, and a UUID, try to create
641 // an in-memory Module at that address. Require that the MemoryModule have a
642 // matching UUID and detect if this MemoryModule is a kernel or a kext.
643 //
644 // Returns true if m_memory_module_sp is now set to a valid Module.
645 
647  Process *process) {
649  if (m_memory_module_sp.get() != nullptr)
650  return true;
651  if (m_load_address == LLDB_INVALID_ADDRESS)
652  return false;
653 
654  FileSpec file_spec(m_name.c_str());
655 
656  llvm::MachO::mach_header mh;
657  size_t size_to_read = 512;
658  if (ReadMachHeader(m_load_address, process, mh)) {
659  if (mh.magic == llvm::MachO::MH_CIGAM || mh.magic == llvm::MachO::MH_MAGIC)
660  size_to_read = sizeof(llvm::MachO::mach_header) + mh.sizeofcmds;
661  if (mh.magic == llvm::MachO::MH_CIGAM_64 ||
662  mh.magic == llvm::MachO::MH_MAGIC_64)
663  size_to_read = sizeof(llvm::MachO::mach_header_64) + mh.sizeofcmds;
664  }
665 
666  ModuleSP memory_module_sp =
667  process->ReadModuleFromMemory(file_spec, m_load_address, size_to_read);
668 
669  if (memory_module_sp.get() == nullptr)
670  return false;
671 
672  bool is_kernel = false;
673  if (memory_module_sp->GetObjectFile()) {
674  if (memory_module_sp->GetObjectFile()->GetType() ==
675  ObjectFile::eTypeExecutable &&
676  memory_module_sp->GetObjectFile()->GetStrata() ==
677  ObjectFile::eStrataKernel) {
678  is_kernel = true;
679  } else if (memory_module_sp->GetObjectFile()->GetType() ==
680  ObjectFile::eTypeSharedLibrary) {
681  is_kernel = false;
682  }
683  }
684 
685  // If this is a kext, and the kernel specified what UUID we should find at
686  // this load address, require that the memory module have a matching UUID or
687  // something has gone wrong and we should discard it.
688  if (m_uuid.IsValid()) {
689  if (m_uuid != memory_module_sp->GetUUID()) {
690  if (log) {
691  LLDB_LOGF(log,
692  "KextImageInfo::ReadMemoryModule the kernel said to find "
693  "uuid %s at 0x%" PRIx64
694  " but instead we found uuid %s, throwing it away",
695  m_uuid.GetAsString().c_str(), m_load_address,
696  memory_module_sp->GetUUID().GetAsString().c_str());
697  }
698  return false;
699  }
700  }
701 
702  // If the in-memory Module has a UUID, let's use that.
703  if (!m_uuid.IsValid() && memory_module_sp->GetUUID().IsValid()) {
704  m_uuid = memory_module_sp->GetUUID();
705  }
706 
707  m_memory_module_sp = memory_module_sp;
708  m_kernel_image = is_kernel;
709  if (is_kernel) {
710  if (log) {
711  // This is unusual and probably not intended
712  LLDB_LOGF(log,
713  "KextImageInfo::ReadMemoryModule read the kernel binary out "
714  "of memory");
715  }
716  if (memory_module_sp->GetArchitecture().IsValid()) {
717  process->GetTarget().SetArchitecture(memory_module_sp->GetArchitecture());
718  }
719  if (m_uuid.IsValid()) {
720  ModuleSP exe_module_sp = process->GetTarget().GetExecutableModule();
721  if (exe_module_sp.get() && exe_module_sp->GetUUID().IsValid()) {
722  if (m_uuid != exe_module_sp->GetUUID()) {
723  // The user specified a kernel binary that has a different UUID than
724  // the kernel actually running in memory. This never ends well;
725  // clear the user specified kernel binary from the Target.
726 
727  m_module_sp.reset();
728 
729  ModuleList user_specified_kernel_list;
730  user_specified_kernel_list.Append(exe_module_sp);
731  process->GetTarget().GetImages().Remove(user_specified_kernel_list);
732  }
733  }
734  }
735  }
736 
737  return true;
738 }
739 
741  return m_kernel_image;
742 }
743 
745  m_kernel_image = is_kernel;
746 }
747 
749  Process *process) {
750  if (IsLoaded())
751  return true;
752 
753  Target &target = process->GetTarget();
754 
755  // kexts will have a uuid from the table.
756  // for the kernel, we'll need to read the load commands out of memory to get it.
757  if (m_uuid.IsValid() == false) {
758  if (ReadMemoryModule(process) == false) {
760  LLDB_LOGF(log,
761  "Unable to read '%s' from memory at address 0x%" PRIx64
762  " to get the segment load addresses.",
763  m_name.c_str(), m_load_address);
764  return false;
765  }
766  }
767 
768  if (IsKernel() && m_uuid.IsValid()) {
769  Stream &s = target.GetDebugger().GetOutputStream();
770  s.Printf("Kernel UUID: %s\n", m_uuid.GetAsString().c_str());
771  s.Printf("Load Address: 0x%" PRIx64 "\n", m_load_address);
772  }
773 
774  if (!m_module_sp) {
775  // See if the kext has already been loaded into the target, probably by the
776  // user doing target modules add.
777  const ModuleList &target_images = target.GetImages();
778  m_module_sp = target_images.FindModule(m_uuid);
779 
780  // Search for the kext on the local filesystem via the UUID
781  if (!m_module_sp && m_uuid.IsValid()) {
782  ModuleSpec module_spec;
783  module_spec.GetUUID() = m_uuid;
784  module_spec.GetArchitecture() = target.GetArchitecture();
785 
786  // For the kernel, we really do need an on-disk file copy of the binary
787  // to do anything useful. This will force a call to dsymForUUID if it
788  // exists, instead of depending on the DebugSymbols preferences being
789  // set.
790  if (IsKernel()) {
791  if (Symbols::DownloadObjectAndSymbolFile(module_spec, true)) {
792  if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
793  m_module_sp = std::make_shared<Module>(module_spec.GetFileSpec(),
794  target.GetArchitecture());
795  }
796  }
797  }
798 
799  // If the current platform is PlatformDarwinKernel, create a ModuleSpec
800  // with the filename set to be the bundle ID for this kext, e.g.
801  // "com.apple.filesystems.msdosfs", and ask the platform to find it.
802  // PlatformDarwinKernel does a special scan for kexts on the local
803  // system.
804  PlatformSP platform_sp(target.GetPlatform());
805  if (!m_module_sp && platform_sp) {
806  ConstString platform_name(platform_sp->GetPluginName());
807  static ConstString g_platform_name(
809  if (platform_name == g_platform_name) {
810  ModuleSpec kext_bundle_module_spec(module_spec);
811  FileSpec kext_filespec(m_name.c_str());
812  FileSpecList search_paths = target.GetExecutableSearchPaths();
813  kext_bundle_module_spec.GetFileSpec() = kext_filespec;
814  platform_sp->GetSharedModule(kext_bundle_module_spec, process,
815  m_module_sp, &search_paths, nullptr,
816  nullptr);
817  }
818  }
819 
820  // Ask the Target to find this file on the local system, if possible.
821  // This will search in the list of currently-loaded files, look in the
822  // standard search paths on the system, and on a Mac it will try calling
823  // the DebugSymbols framework with the UUID to find the binary via its
824  // search methods.
825  if (!m_module_sp) {
826  m_module_sp = target.GetOrCreateModule(module_spec, true /* notify */);
827  }
828 
829  if (IsKernel() && !m_module_sp) {
830  Stream &s = target.GetDebugger().GetOutputStream();
831  s.Printf("WARNING: Unable to locate kernel binary on the debugger "
832  "system.\n");
833  }
834  }
835 
836  // If we managed to find a module, append it to the target's list of
837  // images. If we also have a memory module, require that they have matching
838  // UUIDs
839  if (m_module_sp) {
840  if (m_uuid.IsValid() && m_module_sp->GetUUID() == m_uuid) {
841  target.GetImages().AppendIfNeeded(m_module_sp, false);
842  if (IsKernel() &&
843  target.GetExecutableModulePointer() != m_module_sp.get()) {
844  target.SetExecutableModule(m_module_sp, eLoadDependentsNo);
845  }
846  }
847  }
848  }
849 
850  // If we've found a binary, read the load commands out of memory so we
851  // can set the segment load addresses.
852  if (m_module_sp)
853  ReadMemoryModule (process);
854 
855  static ConstString g_section_name_LINKEDIT("__LINKEDIT");
856 
857  if (m_memory_module_sp && m_module_sp) {
858  if (m_module_sp->GetUUID() == m_memory_module_sp->GetUUID()) {
859  ObjectFile *ondisk_object_file = m_module_sp->GetObjectFile();
860  ObjectFile *memory_object_file = m_memory_module_sp->GetObjectFile();
861 
862  if (memory_object_file && ondisk_object_file) {
863  // The memory_module for kexts may have an invalid __LINKEDIT seg; skip
864  // it.
865  const bool ignore_linkedit = !IsKernel();
866 
867  SectionList *ondisk_section_list = ondisk_object_file->GetSectionList();
868  SectionList *memory_section_list = memory_object_file->GetSectionList();
869  if (memory_section_list && ondisk_section_list) {
870  const uint32_t num_ondisk_sections = ondisk_section_list->GetSize();
871  // There may be CTF sections in the memory image so we can't always
872  // just compare the number of sections (which are actually segments
873  // in mach-o parlance)
874  uint32_t sect_idx = 0;
875 
876  // Use the memory_module's addresses for each section to set the file
877  // module's load address as appropriate. We don't want to use a
878  // single slide value for the entire kext - different segments may be
879  // slid different amounts by the kext loader.
880 
881  uint32_t num_sections_loaded = 0;
882  for (sect_idx = 0; sect_idx < num_ondisk_sections; ++sect_idx) {
883  SectionSP ondisk_section_sp(
884  ondisk_section_list->GetSectionAtIndex(sect_idx));
885  if (ondisk_section_sp) {
886  // Don't ever load __LINKEDIT as it may or may not be actually
887  // mapped into memory and there is no current way to tell.
888  // I filed rdar://problem/12851706 to track being able to tell
889  // if the __LINKEDIT is actually mapped, but until then, we need
890  // to not load the __LINKEDIT
891  if (ignore_linkedit &&
892  ondisk_section_sp->GetName() == g_section_name_LINKEDIT)
893  continue;
894 
895  const Section *memory_section =
896  memory_section_list
897  ->FindSectionByName(ondisk_section_sp->GetName())
898  .get();
899  if (memory_section) {
900  target.SetSectionLoadAddress(ondisk_section_sp,
901  memory_section->GetFileAddress());
902  ++num_sections_loaded;
903  }
904  }
905  }
906  if (num_sections_loaded > 0)
907  m_load_process_stop_id = process->GetStopID();
908  else
909  m_module_sp.reset(); // No sections were loaded
910  } else
911  m_module_sp.reset(); // One or both section lists
912  } else
913  m_module_sp.reset(); // One or both object files missing
914  } else
915  m_module_sp.reset(); // UUID mismatch
916  }
917 
918  bool is_loaded = IsLoaded();
919 
920  if (is_loaded && m_module_sp && IsKernel()) {
921  Stream &s = target.GetDebugger().GetOutputStream();
922  ObjectFile *kernel_object_file = m_module_sp->GetObjectFile();
923  if (kernel_object_file) {
924  addr_t file_address =
925  kernel_object_file->GetBaseAddress().GetFileAddress();
926  if (m_load_address != LLDB_INVALID_ADDRESS &&
927  file_address != LLDB_INVALID_ADDRESS) {
928  s.Printf("Kernel slid 0x%" PRIx64 " in memory.\n",
929  m_load_address - file_address);
930  }
931  }
932  {
933  s.Printf("Loaded kernel file %s\n",
934  m_module_sp->GetFileSpec().GetPath().c_str());
935  }
936  s.Flush();
937  }
938 
939  // Notify the target about the module being added;
940  // set breakpoints, load dSYM scripts, etc. as needed.
941  if (is_loaded && m_module_sp) {
942  ModuleList loaded_module_list;
943  loaded_module_list.Append(m_module_sp);
944  target.ModulesDidLoad(loaded_module_list);
945  }
946 
947  return is_loaded;
948 }
949 
951  if (m_memory_module_sp)
952  return m_memory_module_sp->GetArchitecture().GetAddressByteSize();
953  if (m_module_sp)
954  return m_module_sp->GetArchitecture().GetAddressByteSize();
955  return 0;
956 }
957 
959  if (m_memory_module_sp)
960  return m_memory_module_sp->GetArchitecture().GetByteOrder();
961  if (m_module_sp)
962  return m_module_sp->GetArchitecture().GetByteOrder();
963  return endian::InlHostByteOrder();
964 }
965 
968  if (m_memory_module_sp)
969  return m_memory_module_sp->GetArchitecture();
970  if (m_module_sp)
971  return m_module_sp->GetArchitecture();
972  return lldb_private::ArchSpec();
973 }
974 
975 // Load the kernel module and initialize the "m_kernel" member. Return true
976 // _only_ if the kernel is loaded the first time through (subsequent calls to
977 // this function should return false after the kernel has been already loaded).
980  m_kernel.Clear();
982  m_kernel.SetIsKernel(true);
983 
984  ConstString kernel_name("mach_kernel");
985  if (m_kernel.GetModule().get() && m_kernel.GetModule()->GetObjectFile() &&
987  ->GetObjectFile()
988  ->GetFileSpec()
989  .GetFilename()
990  .IsEmpty()) {
991  kernel_name =
992  m_kernel.GetModule()->GetObjectFile()->GetFileSpec().GetFilename();
993  }
994  m_kernel.SetName(kernel_name.AsCString());
995 
999  m_kernel.GetModule()) {
1000  // We didn't get a hint from the process, so we will try the kernel at
1001  // the address that it exists at in the file if we have one
1002  ObjectFile *kernel_object_file = m_kernel.GetModule()->GetObjectFile();
1003  if (kernel_object_file) {
1004  addr_t load_address =
1005  kernel_object_file->GetBaseAddress().GetLoadAddress(
1006  &m_process->GetTarget());
1007  addr_t file_address =
1008  kernel_object_file->GetBaseAddress().GetFileAddress();
1009  if (load_address != LLDB_INVALID_ADDRESS && load_address != 0) {
1010  m_kernel.SetLoadAddress(load_address);
1011  if (load_address != file_address) {
1012  // Don't accidentally relocate the kernel to the File address --
1013  // the Load address has already been set to its actual in-memory
1014  // address. Mark it as IsLoaded.
1016  }
1017  } else {
1018  m_kernel.SetLoadAddress(file_address);
1019  }
1020  }
1021  }
1022  }
1023 
1027  }
1028  }
1029 
1030  // The operating system plugin gets loaded and initialized in
1031  // LoadImageUsingMemoryModule when we discover the kernel dSYM. For a core
1032  // file in particular, that's the wrong place to do this, since we haven't
1033  // fixed up the section addresses yet. So let's redo it here.
1035 
1036  if (m_kernel.IsLoaded() && m_kernel.GetModule()) {
1037  static ConstString kext_summary_symbol("gLoadedKextSummaries");
1038  const Symbol *symbol =
1039  m_kernel.GetModule()->FindFirstSymbolWithNameAndType(
1040  kext_summary_symbol, eSymbolTypeData);
1041  if (symbol) {
1043  // Update all image infos
1045  }
1046  } else {
1047  m_kernel.Clear();
1048  }
1049  }
1050 }
1051 
1052 // Static callback function that gets called when our DYLD notification
1053 // breakpoint gets hit. We update all of our image infos and then let our super
1054 // class DynamicLoader class decide if we should stop or not (based on global
1055 // preference).
1057  void *baton, StoppointCallbackContext *context, user_id_t break_id,
1058  user_id_t break_loc_id) {
1059  return static_cast<DynamicLoaderDarwinKernel *>(baton)->BreakpointHit(
1060  context, break_id, break_loc_id);
1061 }
1062 
1064  user_id_t break_id,
1065  user_id_t break_loc_id) {
1067  LLDB_LOGF(log, "DynamicLoaderDarwinKernel::BreakpointHit (...)\n");
1068 
1070 
1071  if (log)
1072  PutToLog(log);
1073 
1074  return GetStopWhenImagesChange();
1075 }
1076 
1078  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1079 
1080  // the all image infos is already valid for this process stop ID
1081 
1083  const uint32_t addr_size = m_kernel.GetAddressByteSize();
1084  const ByteOrder byte_order = m_kernel.GetByteOrder();
1085  Status error;
1086  // Read enough bytes for a "OSKextLoadedKextSummaryHeader" structure which
1087  // is currently 4 uint32_t and a pointer.
1088  uint8_t buf[24];
1089  DataExtractor data(buf, sizeof(buf), byte_order, addr_size);
1090  const size_t count = 4 * sizeof(uint32_t) + addr_size;
1091  const bool force_live_memory = true;
1094  m_kext_summary_header_addr, force_live_memory)) {
1095  // We got a valid address for our kext summary header and make sure it
1096  // isn't NULL
1099  const size_t bytes_read = m_process->GetTarget().ReadMemory(
1100  m_kext_summary_header_addr, buf, count, error, force_live_memory);
1101  if (bytes_read == count) {
1102  lldb::offset_t offset = 0;
1103  m_kext_summary_header.version = data.GetU32(&offset);
1104  if (m_kext_summary_header.version > 128) {
1106  s.Printf("WARNING: Unable to read kext summary header, got "
1107  "improbable version number %u\n",
1109  // If we get an improbably large version number, we're probably
1110  // getting bad memory.
1112  return false;
1113  }
1114  if (m_kext_summary_header.version >= 2) {
1115  m_kext_summary_header.entry_size = data.GetU32(&offset);
1116  if (m_kext_summary_header.entry_size > 4096) {
1117  // If we get an improbably large entry_size, we're probably
1118  // getting bad memory.
1119  Stream &s =
1121  s.Printf("WARNING: Unable to read kext summary header, got "
1122  "improbable entry_size %u\n",
1125  return false;
1126  }
1127  } else {
1128  // Versions less than 2 didn't have an entry size, it was hard
1129  // coded
1132  }
1133  m_kext_summary_header.entry_count = data.GetU32(&offset);
1134  if (m_kext_summary_header.entry_count > 10000) {
1135  // If we get an improbably large number of kexts, we're probably
1136  // getting bad memory.
1138  s.Printf("WARNING: Unable to read kext summary header, got "
1139  "improbable number of kexts %u\n",
1142  return false;
1143  }
1144  return true;
1145  }
1146  }
1147  }
1148  }
1150  return false;
1151 }
1152 
1153 // We've either (a) just attached to a new kernel, or (b) the kexts-changed
1154 // breakpoint was hit and we need to figure out what kexts have been added or
1155 // removed. Read the kext summaries from the inferior kernel memory, compare
1156 // them against the m_known_kexts vector and update the m_known_kexts vector as
1157 // needed to keep in sync with the inferior.
1158 
1160  const Address &kext_summary_addr, uint32_t count) {
1161  KextImageInfo::collection kext_summaries;
1163  LLDB_LOGF(log,
1164  "Kexts-changed breakpoint hit, there are %d kexts currently.\n",
1165  count);
1166 
1167  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1168 
1169  if (!ReadKextSummaries(kext_summary_addr, count, kext_summaries))
1170  return false;
1171 
1172  // read the plugin.dynamic-loader.darwin-kernel.load-kexts setting -- if the
1173  // user requested no kext loading, don't print any messages about kexts &
1174  // don't try to read them.
1175  const bool load_kexts = GetGlobalProperties().GetLoadKexts();
1176 
1177  // By default, all kexts we've loaded in the past are marked as "remove" and
1178  // all of the kexts we just found out about from ReadKextSummaries are marked
1179  // as "add".
1180  std::vector<bool> to_be_removed(m_known_kexts.size(), true);
1181  std::vector<bool> to_be_added(count, true);
1182 
1183  int number_of_new_kexts_being_added = 0;
1184  int number_of_old_kexts_being_removed = m_known_kexts.size();
1185 
1186  const uint32_t new_kexts_size = kext_summaries.size();
1187  const uint32_t old_kexts_size = m_known_kexts.size();
1188 
1189  // The m_known_kexts vector may have entries that have been Cleared, or are a
1190  // kernel.
1191  for (uint32_t old_kext = 0; old_kext < old_kexts_size; old_kext++) {
1192  bool ignore = false;
1193  KextImageInfo &image_info = m_known_kexts[old_kext];
1194  if (image_info.IsKernel()) {
1195  ignore = true;
1196  } else if (image_info.GetLoadAddress() == LLDB_INVALID_ADDRESS &&
1197  !image_info.GetModule()) {
1198  ignore = true;
1199  }
1200 
1201  if (ignore) {
1202  number_of_old_kexts_being_removed--;
1203  to_be_removed[old_kext] = false;
1204  }
1205  }
1206 
1207  // Scan over the list of kexts we just read from the kernel, note those that
1208  // need to be added and those already loaded.
1209  for (uint32_t new_kext = 0; new_kext < new_kexts_size; new_kext++) {
1210  bool add_this_one = true;
1211  for (uint32_t old_kext = 0; old_kext < old_kexts_size; old_kext++) {
1212  if (m_known_kexts[old_kext] == kext_summaries[new_kext]) {
1213  // We already have this kext, don't re-load it.
1214  to_be_added[new_kext] = false;
1215  // This kext is still present, do not remove it.
1216  to_be_removed[old_kext] = false;
1217 
1218  number_of_old_kexts_being_removed--;
1219  add_this_one = false;
1220  break;
1221  }
1222  }
1223  // If this "kext" entry is actually an alias for the kernel -- the kext was
1224  // compiled into the kernel or something -- then we don't want to load the
1225  // kernel's text section at a different address. Ignore this kext entry.
1226  if (kext_summaries[new_kext].GetUUID().IsValid() &&
1227  m_kernel.GetUUID().IsValid() &&
1228  kext_summaries[new_kext].GetUUID() == m_kernel.GetUUID()) {
1229  to_be_added[new_kext] = false;
1230  break;
1231  }
1232  if (add_this_one) {
1233  number_of_new_kexts_being_added++;
1234  }
1235  }
1236 
1237  if (number_of_new_kexts_being_added == 0 &&
1238  number_of_old_kexts_being_removed == 0)
1239  return true;
1240 
1242  if (load_kexts) {
1243  if (number_of_new_kexts_being_added > 0 &&
1244  number_of_old_kexts_being_removed > 0) {
1245  s.Printf("Loading %d kext modules and unloading %d kext modules ",
1246  number_of_new_kexts_being_added,
1247  number_of_old_kexts_being_removed);
1248  } else if (number_of_new_kexts_being_added > 0) {
1249  s.Printf("Loading %d kext modules ", number_of_new_kexts_being_added);
1250  } else if (number_of_old_kexts_being_removed > 0) {
1251  s.Printf("Unloading %d kext modules ", number_of_old_kexts_being_removed);
1252  }
1253  }
1254 
1255  if (log) {
1256  if (load_kexts) {
1257  LLDB_LOGF(log,
1258  "DynamicLoaderDarwinKernel::ParseKextSummaries: %d kexts "
1259  "added, %d kexts removed",
1260  number_of_new_kexts_being_added,
1261  number_of_old_kexts_being_removed);
1262  } else {
1263  LLDB_LOGF(log,
1264  "DynamicLoaderDarwinKernel::ParseKextSummaries kext loading is "
1265  "disabled, else would have %d kexts added, %d kexts removed",
1266  number_of_new_kexts_being_added,
1267  number_of_old_kexts_being_removed);
1268  }
1269  }
1270 
1271  // Build up a list of <kext-name, uuid> for any kexts that fail to load
1272  std::vector<std::pair<std::string, UUID>> kexts_failed_to_load;
1273  if (number_of_new_kexts_being_added > 0) {
1274  ModuleList loaded_module_list;
1275 
1276  const uint32_t num_of_new_kexts = kext_summaries.size();
1277  for (uint32_t new_kext = 0; new_kext < num_of_new_kexts; new_kext++) {
1278  if (to_be_added[new_kext]) {
1279  KextImageInfo &image_info = kext_summaries[new_kext];
1280  bool kext_successfully_added = true;
1281  if (load_kexts) {
1282  if (!image_info.LoadImageUsingMemoryModule(m_process)) {
1283  kexts_failed_to_load.push_back(std::pair<std::string, UUID>(
1284  kext_summaries[new_kext].GetName(),
1285  kext_summaries[new_kext].GetUUID()));
1286  image_info.LoadImageAtFileAddress(m_process);
1287  kext_successfully_added = false;
1288  }
1289  }
1290 
1291  m_known_kexts.push_back(image_info);
1292 
1293  if (image_info.GetModule() &&
1294  m_process->GetStopID() == image_info.GetProcessStopId())
1295  loaded_module_list.AppendIfNeeded(image_info.GetModule());
1296 
1297  if (load_kexts) {
1298  if (kext_successfully_added)
1299  s.Printf(".");
1300  else
1301  s.Printf("-");
1302  }
1303 
1304  if (log)
1305  kext_summaries[new_kext].PutToLog(log);
1306  }
1307  }
1308  m_process->GetTarget().ModulesDidLoad(loaded_module_list);
1309  }
1310 
1311  if (number_of_old_kexts_being_removed > 0) {
1312  ModuleList loaded_module_list;
1313  const uint32_t num_of_old_kexts = m_known_kexts.size();
1314  for (uint32_t old_kext = 0; old_kext < num_of_old_kexts; old_kext++) {
1315  ModuleList unloaded_module_list;
1316  if (to_be_removed[old_kext]) {
1317  KextImageInfo &image_info = m_known_kexts[old_kext];
1318  // You can't unload the kernel.
1319  if (!image_info.IsKernel()) {
1320  if (image_info.GetModule()) {
1321  unloaded_module_list.AppendIfNeeded(image_info.GetModule());
1322  }
1323  s.Printf(".");
1324  image_info.Clear();
1325  // should pull it out of the KextImageInfos vector but that would
1326  // mutate the list and invalidate the to_be_removed bool vector;
1327  // leaving it in place once Cleared() is relatively harmless.
1328  }
1329  }
1330  m_process->GetTarget().ModulesDidUnload(unloaded_module_list, false);
1331  }
1332  }
1333 
1334  if (load_kexts) {
1335  s.Printf(" done.\n");
1336  if (kexts_failed_to_load.size() > 0 && number_of_new_kexts_being_added > 0) {
1337  s.Printf("Failed to load %d of %d kexts:\n",
1338  (int)kexts_failed_to_load.size(),
1339  number_of_new_kexts_being_added);
1340  // print a sorted list of <kext-name, uuid> kexts which failed to load
1341  unsigned longest_name = 0;
1342  std::sort(kexts_failed_to_load.begin(), kexts_failed_to_load.end());
1343  for (const auto &ku : kexts_failed_to_load) {
1344  if (ku.first.size() > longest_name)
1345  longest_name = ku.first.size();
1346  }
1347  for (const auto &ku : kexts_failed_to_load) {
1348  std::string uuid;
1349  if (ku.second.IsValid())
1350  uuid = ku.second.GetAsString();
1351  s.Printf(" %-*s %s\n", longest_name, ku.first.c_str(), uuid.c_str());
1352  }
1353  }
1354  s.Flush();
1355  }
1356 
1357  return true;
1358 }
1359 
1361  const Address &kext_summary_addr, uint32_t image_infos_count,
1362  KextImageInfo::collection &image_infos) {
1363  const ByteOrder endian = m_kernel.GetByteOrder();
1364  const uint32_t addr_size = m_kernel.GetAddressByteSize();
1365 
1366  image_infos.resize(image_infos_count);
1367  const size_t count = image_infos.size() * m_kext_summary_header.entry_size;
1368  DataBufferHeap data(count, 0);
1369  Status error;
1370 
1371  const bool force_live_memory = true;
1372  const size_t bytes_read = m_process->GetTarget().ReadMemory(
1373  kext_summary_addr, data.GetBytes(), data.GetByteSize(), error, force_live_memory);
1374  if (bytes_read == count) {
1375 
1376  DataExtractor extractor(data.GetBytes(), data.GetByteSize(), endian,
1377  addr_size);
1378  uint32_t i = 0;
1379  for (uint32_t kext_summary_offset = 0;
1380  i < image_infos.size() &&
1381  extractor.ValidOffsetForDataOfSize(kext_summary_offset,
1383  ++i, kext_summary_offset += m_kext_summary_header.entry_size) {
1384  lldb::offset_t offset = kext_summary_offset;
1385  const void *name_data =
1386  extractor.GetData(&offset, KERNEL_MODULE_MAX_NAME);
1387  if (name_data == nullptr)
1388  break;
1389  image_infos[i].SetName((const char *)name_data);
1390  UUID uuid = UUID::fromOptionalData(extractor.GetData(&offset, 16), 16);
1391  image_infos[i].SetUUID(uuid);
1392  image_infos[i].SetLoadAddress(extractor.GetU64(&offset));
1393  image_infos[i].SetSize(extractor.GetU64(&offset));
1394  }
1395  if (i < image_infos.size())
1396  image_infos.resize(i);
1397  } else {
1398  image_infos.clear();
1399  }
1400  return image_infos.size();
1401 }
1402 
1404  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1405 
1406  if (ReadKextSummaryHeader()) {
1409  Address summary_addr(m_kext_summary_header_addr);
1410  summary_addr.Slide(m_kext_summary_header.GetSize());
1411  if (!ParseKextSummaries(summary_addr,
1413  m_known_kexts.clear();
1414  }
1415  return true;
1416  }
1417  }
1418  return false;
1419 }
1420 
1421 // Dump an image info structure to the file handle provided.
1423  if (m_load_address == LLDB_INVALID_ADDRESS) {
1424  LLDB_LOG(log, "uuid={0} name=\"{1}\" (UNLOADED)", m_uuid.GetAsString(),
1425  m_name);
1426  } else {
1427  LLDB_LOG(log, "addr={0:x+16} size={1:x+16} uuid={2} name=\"{3}\"",
1428  m_load_address, m_size, m_uuid.GetAsString(), m_name);
1429  }
1430 }
1431 
1432 // Dump the _dyld_all_image_infos members and all current image infos that we
1433 // have parsed to the file handle provided.
1435  if (log == nullptr)
1436  return;
1437 
1438  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1439  LLDB_LOGF(log,
1440  "gLoadedKextSummaries = 0x%16.16" PRIx64
1441  " { version=%u, entry_size=%u, entry_count=%u }",
1445 
1446  size_t i;
1447  const size_t count = m_known_kexts.size();
1448  if (count > 0) {
1449  log->PutCString("Loaded:");
1450  for (i = 0; i < count; i++)
1451  m_known_kexts[i].PutToLog(log);
1452  }
1453 }
1454 
1456  DEBUG_PRINTF("DynamicLoaderDarwinKernel::%s() process state = %s\n",
1457  __FUNCTION__, StateAsCString(m_process->GetState()));
1458  Clear(true);
1459  m_process = process;
1460 }
1461 
1464  DEBUG_PRINTF("DynamicLoaderDarwinKernel::%s() process state = %s\n",
1465  __FUNCTION__, StateAsCString(m_process->GetState()));
1466 
1467  const bool internal_bp = true;
1468  const bool hardware = false;
1469  const LazyBool skip_prologue = eLazyBoolNo;
1470  FileSpecList module_spec_list;
1471  module_spec_list.Append(m_kernel.GetModule()->GetFileSpec());
1472  Breakpoint *bp =
1473  m_process->GetTarget()
1474  .CreateBreakpoint(&module_spec_list, nullptr,
1475  "OSKextLoadedKextSummariesUpdated",
1476  eFunctionNameTypeFull, eLanguageTypeUnknown, 0,
1477  skip_prologue, internal_bp, hardware)
1478  .get();
1479 
1481  true);
1482  m_break_id = bp->GetID();
1483  }
1484 }
1485 
1486 // Member function that gets called when the process state changes.
1488  StateType state) {
1489  DEBUG_PRINTF("DynamicLoaderDarwinKernel::%s(%s)\n", __FUNCTION__,
1490  StateAsCString(state));
1491  switch (state) {
1492  case eStateConnected:
1493  case eStateAttaching:
1494  case eStateLaunching:
1495  case eStateInvalid:
1496  case eStateUnloaded:
1497  case eStateExited:
1498  case eStateDetached:
1499  Clear(false);
1500  break;
1501 
1502  case eStateStopped:
1503  UpdateIfNeeded();
1504  break;
1505 
1506  case eStateRunning:
1507  case eStateStepping:
1508  case eStateCrashed:
1509  case eStateSuspended:
1510  break;
1511  }
1512 }
1513 
1514 ThreadPlanSP
1516  bool stop_others) {
1517  ThreadPlanSP thread_plan_sp;
1519  LLDB_LOGF(log, "Could not find symbol for step through.");
1520  return thread_plan_sp;
1521 }
1522 
1524  Status error;
1525  error.SetErrorString(
1526  "always unsafe to load or unload shared libraries in the darwin kernel");
1527  return error;
1528 }
1529 
1531  PluginManager::RegisterPlugin(GetPluginNameStatic(),
1534 }
1535 
1537  PluginManager::UnregisterPlugin(CreateInstance);
1538 }
1539 
1541  lldb_private::Debugger &debugger) {
1542  if (!PluginManager::GetSettingForDynamicLoaderPlugin(
1544  const bool is_global_setting = true;
1545  PluginManager::CreateSettingForDynamicLoaderPlugin(
1546  debugger, GetGlobalProperties().GetValueProperties(),
1547  ConstString("Properties for the DynamicLoaderDarwinKernel plug-in."),
1548  is_global_setting);
1549  }
1550 }
1551 
1553  static ConstString g_name("darwin-kernel");
1554  return g_name;
1555 }
1556 
1558  return "Dynamic loader plug-in that watches for shared library loads/unloads "
1559  "in the MacOSX kernel.";
1560 }
1561 
1562 // PluginInterface protocol
1564  return GetPluginNameStatic();
1565 }
1566 
1569  switch (magic) {
1570  case llvm::MachO::MH_MAGIC:
1571  case llvm::MachO::MH_MAGIC_64:
1572  return endian::InlHostByteOrder();
1573 
1574  case llvm::MachO::MH_CIGAM:
1575  case llvm::MachO::MH_CIGAM_64:
1577  return lldb::eByteOrderLittle;
1578  else
1579  return lldb::eByteOrderBig;
1580 
1581  default:
1582  break;
1583  }
1584  return lldb::eByteOrderInvalid;
1585 }
DynamicLoaderDarwinKernel::KextImageInfo::collection
std::vector< KextImageInfo > collection
Definition: DynamicLoaderDarwinKernel.h:190
lldb_private::UUID
Definition: UUID.h:23
lldb_private::Module::GetObjectFile
virtual ObjectFile * GetObjectFile()
Get the object file representation for the current architecture.
Definition: Module.cpp:1238
LLDB_BREAK_ID_IS_VALID
#define LLDB_BREAK_ID_IS_VALID(bid)
Definition: lldb-defines.h:51
lldb_private::DataBufferHeap::GetBytes
uint8_t * GetBytes() override
Definition: DataBufferHeap.cpp:34
lldb_private::DataBufferHeap::GetByteSize
lldb::offset_t GetByteSize() const override
Definition: DataBufferHeap.cpp:45
lldb_private::SectionList::FindSectionByName
lldb::SectionSP FindSectionByName(ConstString section_dstr) const
Definition: Section.cpp:484
DynamicLoaderDarwinKernel::KextImageInfo::SetModule
void SetModule(lldb::ModuleSP module)
Definition: DynamicLoaderDarwinKernel.cpp:573
DynamicLoaderDarwinKernel::GetPluginNameStatic
static lldb_private::ConstString GetPluginNameStatic()
Definition: DynamicLoaderDarwinKernel.cpp:1552
lldb_private::ArchSpec
Definition: ArchSpec.h:33
LIBLLDB_LOG_DYNAMIC_LOADER
#define LIBLLDB_LOG_DYNAMIC_LOADER
Definition: Logging.h:17
lldb_private::StoppointCallbackContext
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
Definition: StoppointCallbackContext.h:26
DynamicLoaderDarwinKernel::SearchForKernelWithDebugHints
static lldb::addr_t SearchForKernelWithDebugHints(lldb_private::Process *process)
Definition: DynamicLoaderDarwinKernel.cpp:237
DynamicLoaderDarwinKernel::KextImageInfo::GetProcessStopId
uint32_t GetProcessStopId() const
Definition: DynamicLoaderDarwinKernel.cpp:606
DynamicLoaderDarwinKernel::KextImageInfo::PutToLog
void PutToLog(lldb_private::Log *log) const
Definition: DynamicLoaderDarwinKernel.cpp:1422
lldb_private::Stoppoint::GetID
lldb::break_id_t GetID() const
Definition: Stoppoint.cpp:22
DynamicLoaderDarwinKernel::DebuggerInitialize
static void DebuggerInitialize(lldb_private::Debugger &debugger)
Definition: DynamicLoaderDarwinKernel.cpp:1540
lldb_private::Address::Clear
void Clear()
Clear the object's state.
Definition: Address.h:178
lldb_private::Address::IsValid
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:336
DynamicLoaderDarwinKernel::OSKextLoadedKextSummaryHeader::entry_size
uint32_t entry_size
Definition: DynamicLoaderDarwinKernel.h:211
lldb_private::Process::ReadMemory
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:1914
ModuleSpec.h
DynamicLoaderDarwinKernel::m_kext_summary_header
OSKextLoadedKextSummaryHeader m_kext_summary_header
Definition: DynamicLoaderDarwinKernel.h:287
DynamicLoaderDarwinKernel::m_mutex
std::recursive_mutex m_mutex
Definition: DynamicLoaderDarwinKernel.h:289
DynamicLoaderDarwinKernel::m_kernel_load_address
lldb::addr_t m_kernel_load_address
Definition: DynamicLoaderDarwinKernel.h:282
lldb_private::Symbol
Definition: Symbol.h:20
lldb_private::Target::GetOrCreateModule
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:1979
lldb::eStateAttaching
@ eStateAttaching
Process is currently trying to attach.
Definition: lldb-enumerations.h:78
lldb_private::UUID::IsValid
bool IsValid() const
Definition: UUID.h:79
lldb_private::SectionList::GetSize
size_t GetSize() const
Definition: Section.h:74
DynamicLoaderDarwinKernel::KextImageInfo::GetUUID
lldb_private::UUID GetUUID() const
Definition: DynamicLoaderDarwinKernel.cpp:636
DynamicLoaderDarwinKernel::m_kernel
KextImageInfo m_kernel
Definition: DynamicLoaderDarwinKernel.h:283
DynamicLoaderDarwinKernel::KextImageInfo::GetModule
lldb::ModuleSP GetModule()
Definition: DynamicLoaderDarwinKernel.cpp:585
lldb_private::Process::ReadModuleFromMemory
lldb::ModuleSP ReadModuleFromMemory(const FileSpec &file_spec, lldb::addr_t header_addr, size_t size_to_read=512)
Definition: Process.cpp:2388
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:249
lldb_private::Process
Definition: Process.h:340
lldb_private::Target::GetExecutableModulePointer
Module * GetExecutableModulePointer()
Definition: Target.cpp:1362
DynamicLoaderDarwinKernel::SearchForDarwinKernel
static lldb::addr_t SearchForDarwinKernel(lldb_private::Process *process)
Definition: DynamicLoaderDarwinKernel.cpp:188
DynamicLoaderDarwinKernel::m_known_kexts
KextImageInfo::collection m_known_kexts
Definition: DynamicLoaderDarwinKernel.h:288
DynamicLoaderDarwinKernel::KextImageInfo::SetName
void SetName(const char *)
Definition: DynamicLoaderDarwinKernel.cpp:624
lldb_private::Target::GetExecutableModule
lldb::ModuleSP GetExecutableModule()
Gets the module for the main executable.
Definition: Target.cpp:1348
lldb_private::Process::ClearBreakpointSiteByID
Status ClearBreakpointSiteByID(lldb::user_id_t break_id)
Definition: Process.cpp:1569
Module.h
lldb_private::Process::GetThreadList
ThreadList & GetThreadList()
Definition: Process.h:2114
lldb_private::Process::GetTarget
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1212
lldb_private::StateAsCString
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
StoppointCallbackContext.h
lldb_private::Stream::Flush
virtual void Flush()=0
Flush the stream.
lldb_private::Debugger::GetOutputStream
StreamFile & GetOutputStream()
Definition: Debugger.h:173
lldb::eSymbolTypeData
@ eSymbolTypeData
Definition: lldb-enumerations.h:618
lldb_private::Module
Definition: Module.h:84
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
LocateSymbolFile.h
lldb_private::SectionList
Definition: Section.h:34
DynamicLoaderDarwinKernel::PrivateProcessStateChanged
void PrivateProcessStateChanged(lldb_private::Process *process, lldb::StateType state)
Definition: DynamicLoaderDarwinKernel.cpp:1487
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
DynamicLoaderDarwinKernel::SearchForKernelAtSameLoadAddr
static lldb::addr_t SearchForKernelAtSameLoadAddr(lldb_private::Process *process)
Definition: DynamicLoaderDarwinKernel.cpp:209
DynamicLoaderDarwinKernel::KextImageInfo::GetSize
uint64_t GetSize() const
Definition: DynamicLoaderDarwinKernel.cpp:598
StackFrame.h
lldb_private::Process::IsAlive
virtual bool IsAlive()
Check if a process is still alive.
Definition: Process.cpp:1085
DynamicLoaderDarwinKernel::ParseKextSummaries
bool ParseKextSummaries(const lldb_private::Address &kext_summary_addr, uint32_t count)
Definition: DynamicLoaderDarwinKernel.cpp:1159
lldb_private::Stream
Definition: Stream.h:28
lldb_private::Target::CreateBreakpoint
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpec &file, uint32_t line_no, uint32_t column, lldb::addr_t offset, LazyBool check_inlines, LazyBool skip_prologue, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
Definition: Target.cpp:331
lldb_private::ArchSpec::GetTriple
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:444
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
pc
@ pc
Definition: CompactUnwindInfo.cpp:1250
lldb_private::LazyBool
LazyBool
Definition: lldb-private-enumerations.h:115
lldb_private::Target::GetDebugger
Debugger & GetDebugger()
Definition: Target.h:999
DynamicLoaderDarwinKernel::Clear
void Clear(bool clear_process)
Definition: DynamicLoaderDarwinKernel.cpp:545
Debugger.h
lldb_private::Target
Definition: Target.h:450
Section.h
DynamicLoaderDarwinKernelProperties
Definition: DynamicLoaderDarwinKernel.cpp:98
lldb_private::DataExtractor::GetU64
uint64_t GetU64(lldb::offset_t *offset_ptr) const
Extract a uint64_t value from *offset_ptr.
Definition: DataExtractor.cpp:476
DynamicLoaderDarwinKernel::CreateInstance
static lldb_private::DynamicLoader * CreateInstance(lldb_private::Process *process, bool force)
Definition: DynamicLoaderDarwinKernel.cpp:135
lldb_private::Target::GetImages
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:924
lldb_private::Process::GetState
lldb::StateType GetState()
Get accessor for the current process state.
Definition: Process.cpp:1295
DynamicLoaderDarwinKernelProperties::GetSettingName
static ConstString & GetSettingName()
Definition: DynamicLoaderDarwinKernel.cpp:100
lldb_private::eArchTypeMachO
@ eArchTypeMachO
Definition: lldb-private-enumerations.h:63
lldb_private::Process::ReadMemoryFromInferior
size_t ReadMemoryFromInferior(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
Read of memory from a process.
Definition: Process.cpp:2074
lldb::eStateExited
@ eStateExited
Process has exited and can't be examined.
Definition: lldb-enumerations.h:90
DynamicLoaderDarwinKernel::KextImageInfo::IsKernel
bool IsKernel() const
Definition: DynamicLoaderDarwinKernel.cpp:740
DynamicLoaderDarwinKernel::KextImageInfo::GetArchitecture
lldb_private::ArchSpec GetArchitecture() const
Definition: DynamicLoaderDarwinKernel.cpp:967
eKASLRScanLowgloAddresses
@ eKASLRScanLowgloAddresses
Definition: DynamicLoaderDarwinKernel.cpp:56
lldb_private::DynamicLoader::LoadOperatingSystemPlugin
void LoadOperatingSystemPlugin(bool flush)
Definition: DynamicLoader.cpp:238
lldb_private::ArchSpec::IsCompatibleMatch
bool IsCompatibleMatch(const ArchSpec &rhs) const
Compare an ArchSpec to another ArchSpec, requiring a compatible cpu type match between them.
Definition: ArchSpec.cpp:934
lldb::eStateStopped
@ eStateStopped
Process or thread is stopped and can be examined.
Definition: lldb-enumerations.h:84
Target.h
lldb_private::ModuleSpec::GetUUID
UUID & GetUUID()
Definition: ModuleSpec.h:104
lldb_private::Properties
Definition: UserSettingsController.h:33
LIBLLDB_LOG_HOST
#define LIBLLDB_LOG_HOST
Definition: Logging.h:28
lldb_private::Target::GetPlatform
lldb::PlatformSP GetPlatform()
Definition: Target.h:1341
DynamicLoaderDarwinKernelProperties::GetLoadKexts
bool GetLoadKexts() const
Definition: DynamicLoaderDarwinKernel.cpp:112
lldb_private::Section::GetFileAddress
lldb::addr_t GetFileAddress() const
Definition: Section.cpp:203
lldb_private::FileSpec
Definition: FileSpec.h:56
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::ObjectFile::GetSectionList
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:583
DynamicLoaderDarwinKernel::UpdateIfNeeded
void UpdateIfNeeded()
Definition: DynamicLoaderDarwinKernel.cpp:522
KASLRScanType
KASLRScanType
Definition: DynamicLoaderDarwinKernel.cpp:54
DynamicLoaderDarwinKernel::KextImageInfo::IsLoaded
bool IsLoaded()
Definition: DynamicLoaderDarwinKernel.h:142
lldb::eStateCrashed
@ eStateCrashed
Process or thread has crashed and can be examined.
Definition: lldb-enumerations.h:88
DynamicLoaderDarwinKernelProperties::GetScanType
KASLRScanType GetScanType() const
Definition: DynamicLoaderDarwinKernel.cpp:119
DynamicLoaderDarwinKernel::DynamicLoaderDarwinKernel
DynamicLoaderDarwinKernel(lldb_private::Process *process, lldb::addr_t kernel_addr)
Definition: DynamicLoaderDarwinKernel.cpp:506
lldb_private::ModuleList::Remove
bool Remove(const lldb::ModuleSP &module_sp, bool notify=true)
Remove a module from the module list.
lldb_private::DataExtractor
Definition: DataExtractor.h:48
lldb_private::ModuleList
Definition: ModuleList.h:72
Log.h
DynamicLoaderDarwinKernel::KextImageInfo::LoadImageUsingMemoryModule
bool LoadImageUsingMemoryModule(lldb_private::Process *process)
Definition: DynamicLoaderDarwinKernel.cpp:748
lldb_private::ModuleList::AppendIfNeeded
bool AppendIfNeeded(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list, if it is not already there.
lldb_private::eLoadDependentsNo
@ eLoadDependentsNo
Definition: Target.h:63
lldb_private::Target::SetSectionLoadAddress
bool SetSectionLoadAddress(const lldb::SectionSP &section, lldb::addr_t load_addr, bool warn_multiple=false)
Definition: Target.cpp:2824
lldb_private::Thread
Definition: Thread.h:60
lldb::eStateConnected
@ eStateConnected
Process is connected to remote debug services, but not launched or attached to anything yet.
Definition: lldb-enumerations.h:76
PlatformDarwinKernel::GetPluginNameStatic
static lldb_private::ConstString GetPluginNameStatic()
Definition: PlatformDarwinKernel.cpp:956
DynamicLoaderDarwinKernel::BreakpointHitCallback
static bool BreakpointHitCallback(void *baton, lldb_private::StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
Definition: DynamicLoaderDarwinKernel.cpp:1056
lldb_private::ObjectFile::GetBaseAddress
virtual lldb_private::Address GetBaseAddress()
Returns base address of this object file.
Definition: ObjectFile.h:481
lldb::eStateLaunching
@ eStateLaunching
Process is in the process of launching.
Definition: lldb-enumerations.h:79
GetName
static llvm::StringRef GetName(XcodeSDK::Type type)
Definition: XcodeSDK.cpp:21
lldb_private::Address::GetFileAddress
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:290
DynamicLoaderDarwinKernel
Definition: DynamicLoaderDarwinKernel.h:24
DynamicLoaderDarwinKernel::CanLoadImage
lldb_private::Status CanLoadImage() override
Ask if it is ok to try and load or unload an shared library (image).
Definition: DynamicLoaderDarwinKernel.cpp:1523
DynamicLoaderDarwinKernel::~DynamicLoaderDarwinKernel
~DynamicLoaderDarwinKernel() override
Definition: DynamicLoaderDarwinKernel.cpp:520
OperatingSystem.h
lldb_private::Process::GetAddressByteSize
uint32_t GetAddressByteSize() const
Definition: Process.cpp:3340
lldb_private::ConstString
Definition: ConstString.h:40
DynamicLoaderDarwinKernel.h
DynamicLoaderDarwinKernel::KextImageInfo
Definition: DynamicLoaderDarwinKernel.h:124
DynamicLoaderDarwinKernel::KextImageInfo::ReadMemoryModule
bool ReadMemoryModule(lldb_private::Process *process)
Definition: DynamicLoaderDarwinKernel.cpp:646
lldb_private::GetLogIfAllCategoriesSet
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
eKASLRScanNearPC
@ eKASLRScanNearPC
Definition: DynamicLoaderDarwinKernel.cpp:58
if
if(CMAKE_SYSTEM_NAME MATCHES "Windows") add_definitions(-DEXPORT_LIBLLDB) endif() get_property(LLDB_ALL_PLUGINS GLOBAL PROPERTY LLDB_PLUGINS) if(LLDB_BUILD_FRAMEWORK) set(option_install_prefix INSTALL_PREFIX $
Definition: API/CMakeLists.txt:1
lldb_private::SectionList::GetSectionAtIndex
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:476
DynamicLoaderDarwinKernel::OSKextLoadedKextSummaryHeader::version
uint32_t version
Definition: DynamicLoaderDarwinKernel.h:210
DynamicLoaderDarwinKernel::GetStepThroughTrampolinePlan
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.
Definition: DynamicLoaderDarwinKernel.cpp:1515
lldb_private::DynamicLoader
Definition: DynamicLoader.h:52
lldb::eStateDetached
@ eStateDetached
Process has been detached and can't be examined.
Definition: lldb-enumerations.h:89
lldb_private::DynamicLoader::m_process
Process * m_process
The process that this dynamic loader plug-in is tracking.
Definition: DynamicLoader.h:312
DynamicLoaderDarwinKernel::KextImageInfo::GetName
std::string GetName() const
Definition: DynamicLoaderDarwinKernel.cpp:628
DynamicLoaderDarwinKernel::KextImageInfo::LoadImageAtFileAddress
bool LoadImageAtFileAddress(lldb_private::Process *process)
Definition: DynamicLoaderDarwinKernel.cpp:560
DynamicLoaderDarwinKernel::PrivateInitialize
void PrivateInitialize(lldb_private::Process *process)
Definition: DynamicLoaderDarwinKernel.cpp:1455
lldb_private::Target::SetArchitecture
bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform=false)
Set the architecture for this target.
Definition: Target.cpp:1462
lldb_private::Debugger
Definition: Debugger.h:70
ThreadPlanRunToAddress.h
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
DynamicLoaderDarwinKernel::KextImageInfo::SetLoadAddress
void SetLoadAddress(lldb::addr_t load_addr)
Definition: DynamicLoaderDarwinKernel.cpp:589
DynamicLoaderDarwinKernel::OSKextLoadedKextSummaryHeader::entry_count
uint32_t entry_count
Definition: DynamicLoaderDarwinKernel.h:212
DynamicLoaderDarwinKernel::KextImageInfo::SetUUID
void SetUUID(const lldb_private::UUID &uuid)
Definition: DynamicLoaderDarwinKernel.cpp:632
Thread.h
lldb::eStateUnloaded
@ eStateUnloaded
Process is object is valid, but not currently loaded.
Definition: lldb-enumerations.h:75
DynamicLoaderDarwinKernel::ReadMachHeader
static bool ReadMachHeader(lldb::addr_t addr, lldb_private::Process *process, llvm::MachO::mach_header &mh, bool *read_error=nullptr)
Definition: DynamicLoaderDarwinKernel.cpp:391
OptionValueProperties.h
DynamicLoaderDarwinKernel::SetNotificationBreakpointIfNeeded
void SetNotificationBreakpointIfNeeded()
Definition: DynamicLoaderDarwinKernel.cpp:1462
lldb_private::ArchSpec::GetAddressByteSize
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:683
DynamicLoaderDarwinKernel::GetByteOrderFromMagic
static lldb::ByteOrder GetByteOrderFromMagic(uint32_t magic)
Definition: DynamicLoaderDarwinKernel.cpp:1568
ObjectFile.h
lldb_private::Target::SetExecutableModule
void SetExecutableModule(lldb::ModuleSP &module_sp, LoadDependentFiles load_dependent_files=eLoadDependentsDefault)
Set the main executable module.
Definition: Target.cpp:1397
DynamicLoaderDarwinKernel::KextImageInfo::SetProcessStopId
void SetProcessStopId(uint32_t stop_id)
Definition: DynamicLoaderDarwinKernel.cpp:610
lldb_private::Section
Definition: Section.h:96
DynamicLoaderDarwinKernel::ReadKextSummaries
uint32_t ReadKextSummaries(const lldb_private::Address &kext_summary_addr, uint32_t image_infos_count, KextImageInfo::collection &image_infos)
Definition: DynamicLoaderDarwinKernel.cpp:1360
LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:49
DynamicLoaderDarwinKernel::KextImageInfo::SetIsKernel
void SetIsKernel(bool is_kernel)
Definition: DynamicLoaderDarwinKernel.cpp:744
lldb_private::ModuleList::FindModule
lldb::ModuleSP FindModule(const Module *module_ptr) const
Definition: ModuleList.cpp:491
DynamicLoaderDarwinKernel::KextImageInfo::Clear
void Clear()
Definition: DynamicLoaderDarwinKernel.h:128
StreamFile.h
lldb::eStateStepping
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
Definition: lldb-enumerations.h:86
DynamicLoaderDarwinKernel::CheckForKernelImageAtAddress
static lldb_private::UUID CheckForKernelImageAtAddress(lldb::addr_t addr, lldb_private::Process *process, bool *read_error=nullptr)
Definition: DynamicLoaderDarwinKernel.cpp:434
DynamicLoaderDarwinKernel::KextImageInfo::SetSize
void SetSize(uint64_t size)
Definition: DynamicLoaderDarwinKernel.cpp:602
lldb::eStateSuspended
@ eStateSuspended
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
Definition: lldb-enumerations.h:91
eKASLRScanExhaustiveScan
@ eKASLRScanExhaustiveScan
Definition: DynamicLoaderDarwinKernel.cpp:60
lldb_private::ModuleSpec::GetFileSpec
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:58
lldb_private::ModuleSpec
Definition: ModuleSpec.h:26
lldb_private::Target::GetArchitecture
const ArchSpec & GetArchitecture() const
Definition: Target.h:966
DynamicLoaderDarwinKernel::KERNEL_MODULE_MAX_NAME
@ KERNEL_MODULE_MAX_NAME
Definition: DynamicLoaderDarwinKernel.h:89
lldb_private::Status
Definition: Status.h:44
DynamicLoaderDarwinKernel::GetPluginName
lldb_private::ConstString GetPluginName() override
Definition: DynamicLoaderDarwinKernel.cpp:1563
lldb_private::Target::ReadMemory
size_t ReadMemory(const Address &addr, void *dst, size_t dst_len, Status &error, bool force_live_memory=false, lldb::addr_t *load_addr_ptr=nullptr)
Definition: Target.cpp:1721
lldb::eByteOrderInvalid
@ eByteOrderInvalid
Definition: lldb-enumerations.h:139
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
DynamicLoaderDarwinKernel::Terminate
static void Terminate()
Definition: DynamicLoaderDarwinKernel.cpp:1536
uint32_t
DynamicLoaderDarwinKernel::OSKextLoadedKextSummaryHeader::GetSize
uint32_t GetSize()
Definition: DynamicLoaderDarwinKernel.h:217
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
DynamicLoaderDarwinKernel::BreakpointHit
bool BreakpointHit(lldb_private::StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
Definition: DynamicLoaderDarwinKernel.cpp:1063
PlatformDarwinKernel.h
lldb_private::Address
Definition: Address.h:59
lldb_private::Target::ModulesDidLoad
void ModulesDidLoad(ModuleList &module_list)
Definition: Target.cpp:1613
DEBUG_PRINTF
#define DEBUG_PRINTF(fmt,...)
Definition: DynamicLoaderDarwinKernel.cpp:41
DynamicLoaderDarwinKernel::KextImageInfo::m_module_sp
lldb::ModuleSP m_module_sp
Definition: DynamicLoaderDarwinKernel.h:196
lldb_private::ObjectFile::GetStrata
Strata GetStrata()
Definition: ObjectFile.h:621
eKASLRScanNone
@ eKASLRScanNone
Definition: DynamicLoaderDarwinKernel.cpp:55
lldb_private::endian::InlHostByteOrder
lldb::ByteOrder InlHostByteOrder()
Definition: Endian.h:25
DynamicLoaderDarwinKernel::PutToLog
void PutToLog(lldb_private::Log *log) const
Definition: DynamicLoaderDarwinKernel.cpp:1434
lldb_private::Breakpoint::SetCallback
void SetCallback(BreakpointHitCallback callback, void *baton, bool is_synchronous=false)
Set the callback action invoked when the breakpoint is hit.
Definition: Breakpoint.cpp:412
DynamicLoaderDarwinKernel::ReadAllKextSummaries
bool ReadAllKextSummaries()
Definition: DynamicLoaderDarwinKernel.cpp:1403
DynamicLoaderDarwinKernel::m_kext_summary_header_ptr_addr
lldb_private::Address m_kext_summary_header_ptr_addr
Definition: DynamicLoaderDarwinKernel.h:285
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:310
DynamicLoaderDarwinKernel::ReadKextSummaryHeader
bool ReadKextSummaryHeader()
Definition: DynamicLoaderDarwinKernel.cpp:1077
lldb_private::DynamicLoader::GetStopWhenImagesChange
bool GetStopWhenImagesChange() const
Get whether the process should stop when images change.
Definition: DynamicLoader.cpp:66
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:31
DynamicLoaderDarwinKernelProperties::DynamicLoaderDarwinKernelProperties
DynamicLoaderDarwinKernelProperties()
Definition: DynamicLoaderDarwinKernel.cpp:105
lldb_private::DataExtractor::GetU32
uint32_t GetU32(lldb::offset_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
Definition: DataExtractor.cpp:427
DynamicLoaderDarwinKernel::KextImageInfo::m_load_process_stop_id
uint32_t m_load_process_stop_id
Definition: DynamicLoaderDarwinKernel.h:198
PluginManager.h
DynamicLoaderDarwinKernel::m_kext_summary_header_addr
lldb_private::Address m_kext_summary_header_addr
Definition: DynamicLoaderDarwinKernel.h:286
DynamicLoaderDarwinKernel::SearchForKernelNearPC
static lldb::addr_t SearchForKernelNearPC(lldb_private::Process *process)
Definition: DynamicLoaderDarwinKernel.cpp:289
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:86
lldb_private::ModuleSpec::GetArchitecture
ArchSpec & GetArchitecture()
Definition: ModuleSpec.h:94
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:242
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
DynamicLoaderDarwinKernel::GetPluginDescriptionStatic
static const char * GetPluginDescriptionStatic()
Definition: DynamicLoaderDarwinKernel.cpp:1557
DynamicLoaderDarwinKernel::KextImageInfo::operator==
bool operator==(const KextImageInfo &rhs)
Definition: DynamicLoaderDarwinKernel.cpp:616
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
DynamicLoaderDarwinKernel::KextImageInfo::GetAddressByteSize
uint32_t GetAddressByteSize()
Definition: DynamicLoaderDarwinKernel.cpp:950
lldb_private::Process::GetImageInfoAddress
virtual lldb::addr_t GetImageInfoAddress()
Get the image information address for the current process.
Definition: Process.cpp:1473
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
DynamicLoaderDarwinKernel::Initialize
static void Initialize()
Definition: DynamicLoaderDarwinKernel.cpp:1530
LIBLLDB_LOG_STEP
#define LIBLLDB_LOG_STEP
Definition: Logging.h:21
lldb::eByteOrderBig
@ eByteOrderBig
Definition: lldb-enumerations.h:140
lldb::eStateInvalid
@ eStateInvalid
Definition: lldb-enumerations.h:74
GetGlobalProperties
static DynamicLoaderDarwinKernelProperties & GetGlobalProperties()
Definition: DynamicLoaderDarwinKernel.cpp:127
lldb_private::DataExtractor::GetData
const void * GetData(lldb::offset_t *offset_ptr, lldb::offset_t length) const
Extract length bytes from *offset_ptr.
Definition: DataExtractor.h:337
State.h
DynamicLoaderDarwinKernel::DidAttach
void DidAttach() override
Called after attaching a process.
Definition: DynamicLoaderDarwinKernel.cpp:530
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:73
lldb_private::Process::GetByteOrder
lldb::ByteOrder GetByteOrder() const
Definition: Process.cpp:3336
LLDB_PLUGIN_DEFINE
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
lldb_private::Log
Definition: Log.h:49
DynamicLoaderDarwinKernel::KERNEL_MODULE_ENTRY_SIZE_VERSION_1
@ KERNEL_MODULE_ENTRY_SIZE_VERSION_1
Definition: DynamicLoaderDarwinKernel.h:94
lldb_private::Module::GetUUID
const lldb_private::UUID & GetUUID()
Get a reference to the UUID value contained in this object.
Definition: Module.cpp:345
lldb_private::Target::ModulesDidUnload
void ModulesDidUnload(ModuleList &module_list, bool delete_locations)
Definition: Target.cpp:1645
lldb_private::Target::SetPlatform
void SetPlatform(const lldb::PlatformSP &platform_sp)
Definition: Target.h:1343
lldb_private::GetLogIfAnyCategoriesSet
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:62
lldb_private::Process::GetStopID
uint32_t GetStopID() const
Definition: Process.h:1371
lldb_private::ThreadList::GetSelectedThread
lldb::ThreadSP GetSelectedThread()
Definition: ThreadList.cpp:648
DataBuffer.h
lldb::eByteOrderLittle
@ eByteOrderLittle
Definition: lldb-enumerations.h:142
lldb_private::DataBufferHeap
Definition: DataBufferHeap.h:30
lldb_private::Address::Slide
bool Slide(int64_t offset)
Definition: Address.h:440
lldb_private::Process::SetCanRunCode
void SetCanRunCode(bool can_run_code)
Sets whether executing code in this process is possible.
Definition: Process.cpp:2363
lldb_private::DataExtractor::ValidOffsetForDataOfSize
bool ValidOffsetForDataOfSize(lldb::offset_t offset, lldb::offset_t length) const
Test the availability of length bytes of data from offset.
Definition: DataExtractor.h:965
lldb
Definition: SBAddress.h:15
DynamicLoaderDarwinKernel::DidLaunch
void DidLaunch() override
Called after attaching a process.
Definition: DynamicLoaderDarwinKernel.cpp:539
lldb::eStateRunning
@ eStateRunning
Process or thread is running and can't be examined.
Definition: lldb-enumerations.h:85
RegisterContext.h
DynamicLoaderDarwinKernel::KextImageInfo::GetByteOrder
lldb::ByteOrder GetByteOrder()
Definition: DynamicLoaderDarwinKernel.cpp:958
g_kaslr_kernel_scan_enum_values
static constexpr OptionEnumValueElement g_kaslr_kernel_scan_enum_values[]
Definition: DynamicLoaderDarwinKernel.cpp:64
lldb_private::ObjectFile
Definition: ObjectFile.h:58
DynamicLoaderDarwinKernel::KextImageInfo::GetLoadAddress
lldb::addr_t GetLoadAddress() const
Definition: DynamicLoaderDarwinKernel.cpp:594
lldb_private::TargetProperties::GetExecutableSearchPaths
FileSpecList GetExecutableSearchPaths()
Definition: Target.cpp:4036
lldb_private::ModuleList::Append
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
DataBufferHeap.h
UINT64_MAX
#define UINT64_MAX
Definition: lldb-defines.h:35
lldb_private::Breakpoint
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:79
DynamicLoaderDarwinKernel::LoadKernelModuleIfNeeded
void LoadKernelModuleIfNeeded()
Definition: DynamicLoaderDarwinKernel.cpp:978
DynamicLoaderDarwinKernel::m_break_id
lldb::user_id_t m_break_id
Definition: DynamicLoaderDarwinKernel.h:290
lldb_private::ObjectFile::GetType
Type GetType()
Definition: ObjectFile.h:615
lldb::ByteOrder
ByteOrder
Byte ordering definitions.
Definition: lldb-enumerations.h:138
DynamicLoaderDarwinKernel::SearchForKernelViaExhaustiveSearch
static lldb::addr_t SearchForKernelViaExhaustiveSearch(lldb_private::Process *process)
Definition: DynamicLoaderDarwinKernel.cpp:346
lldb_private::Log::PutCString
void PutCString(const char *cstr)
Definition: Log.cpp:118
lldb_private::Target::ReadPointerFromMemory
bool ReadPointerFromMemory(const Address &addr, Status &error, Address &pointer_addr, bool force_live_memory=false)
Definition: Target.cpp:1949
lldb_private::Symbol::GetAddress
Address GetAddress() const
Definition: Symbol.h:73