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