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