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 | } |