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