1 //===-- DynamicLoaderMacOS.cpp -----------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Breakpoint/StoppointCallbackContext.h"
10 #include "lldb/Core/Debugger.h"
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/PluginManager.h"
13 #include "lldb/Core/Section.h"
14 #include "lldb/Symbol/ClangASTContext.h"
15 #include "lldb/Symbol/ObjectFile.h"
16 #include "lldb/Symbol/SymbolVendor.h"
17 #include "lldb/Target/ABI.h"
18 #include "lldb/Target/StackFrame.h"
19 #include "lldb/Target/Target.h"
20 #include "lldb/Target/Thread.h"
21 #include "lldb/Utility/Log.h"
22 #include "lldb/Utility/State.h"
23 
24 #include "DynamicLoaderDarwin.h"
25 #include "DynamicLoaderMacOS.h"
26 
27 using namespace lldb;
28 using namespace lldb_private;
29 
30 // Create an instance of this class. This function is filled into the plugin
31 // info class that gets handed out by the plugin factory and allows the lldb to
32 // instantiate an instance of this class.
33 DynamicLoader *DynamicLoaderMacOS::CreateInstance(Process *process,
34                                                   bool force) {
35   bool create = force;
36   if (!create) {
37     create = true;
38     Module *exe_module = process->GetTarget().GetExecutableModulePointer();
39     if (exe_module) {
40       ObjectFile *object_file = exe_module->GetObjectFile();
41       if (object_file) {
42         create = (object_file->GetStrata() == ObjectFile::eStrataUser);
43       }
44     }
45 
46     if (create) {
47       const llvm::Triple &triple_ref =
48           process->GetTarget().GetArchitecture().GetTriple();
49       switch (triple_ref.getOS()) {
50       case llvm::Triple::Darwin:
51       case llvm::Triple::MacOSX:
52       case llvm::Triple::IOS:
53       case llvm::Triple::TvOS:
54       case llvm::Triple::WatchOS:
55       // NEED_BRIDGEOS_TRIPLE case llvm::Triple::BridgeOS:
56         create = triple_ref.getVendor() == llvm::Triple::Apple;
57         break;
58       default:
59         create = false;
60         break;
61       }
62     }
63   }
64 
65   if (!UseDYLDSPI(process)) {
66     create = false;
67   }
68 
69   if (create)
70     return new DynamicLoaderMacOS(process);
71   return nullptr;
72 }
73 
74 // Constructor
75 DynamicLoaderMacOS::DynamicLoaderMacOS(Process *process)
76     : DynamicLoaderDarwin(process), m_image_infos_stop_id(UINT32_MAX),
77       m_break_id(LLDB_INVALID_BREAK_ID), m_mutex(),
78       m_maybe_image_infos_address(LLDB_INVALID_ADDRESS) {}
79 
80 // Destructor
81 DynamicLoaderMacOS::~DynamicLoaderMacOS() {
82   if (LLDB_BREAK_ID_IS_VALID(m_break_id))
83     m_process->GetTarget().RemoveBreakpointByID(m_break_id);
84 }
85 
86 bool DynamicLoaderMacOS::ProcessDidExec() {
87   std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
88   bool did_exec = false;
89   if (m_process) {
90     // If we are stopped after an exec, we will have only one thread...
91     if (m_process->GetThreadList().GetSize() == 1) {
92       // Maybe we still have an image infos address around?  If so see
93       // if that has changed, and if so we have exec'ed.
94       if (m_maybe_image_infos_address != LLDB_INVALID_ADDRESS) {
95         lldb::addr_t image_infos_address = m_process->GetImageInfoAddress();
96         if (image_infos_address != m_maybe_image_infos_address) {
97           // We don't really have to reset this here, since we are going to
98           // call DoInitialImageFetch right away to handle the exec.  But in
99           // case anybody looks at it in the meantime, it can't hurt.
100           m_maybe_image_infos_address = image_infos_address;
101           did_exec = true;
102         }
103       }
104 
105       if (!did_exec) {
106         // See if we are stopped at '_dyld_start'
107         ThreadSP thread_sp(m_process->GetThreadList().GetThreadAtIndex(0));
108         if (thread_sp) {
109           lldb::StackFrameSP frame_sp(thread_sp->GetStackFrameAtIndex(0));
110           if (frame_sp) {
111             const Symbol *symbol =
112                 frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol;
113             if (symbol) {
114               if (symbol->GetName() == "_dyld_start")
115                 did_exec = true;
116             }
117           }
118         }
119       }
120     }
121   }
122 
123   if (did_exec) {
124     m_libpthread_module_wp.reset();
125     m_pthread_getspecific_addr.Clear();
126   }
127   return did_exec;
128 }
129 
130 // Clear out the state of this class.
131 void DynamicLoaderMacOS::DoClear() {
132   std::lock_guard<std::recursive_mutex> guard(m_mutex);
133 
134   if (LLDB_BREAK_ID_IS_VALID(m_break_id))
135     m_process->GetTarget().RemoveBreakpointByID(m_break_id);
136 
137   m_break_id = LLDB_INVALID_BREAK_ID;
138 }
139 
140 // Check if we have found DYLD yet
141 bool DynamicLoaderMacOS::DidSetNotificationBreakpoint() {
142   return LLDB_BREAK_ID_IS_VALID(m_break_id);
143 }
144 
145 void DynamicLoaderMacOS::ClearNotificationBreakpoint() {
146   if (LLDB_BREAK_ID_IS_VALID(m_break_id)) {
147     m_process->GetTarget().RemoveBreakpointByID(m_break_id);
148     m_break_id = LLDB_INVALID_BREAK_ID;
149   }
150 }
151 
152 // Try and figure out where dyld is by first asking the Process if it knows
153 // (which currently calls down in the lldb::Process to get the DYLD info
154 // (available on SnowLeopard only). If that fails, then check in the default
155 // addresses.
156 void DynamicLoaderMacOS::DoInitialImageFetch() {
157   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
158 
159   // Remove any binaries we pre-loaded in the Target before
160   // launching/attaching. If the same binaries are present in the process,
161   // we'll get them from the shared module cache, we won't need to re-load them
162   // from disk.
163   UnloadAllImages();
164 
165   StructuredData::ObjectSP all_image_info_json_sp(
166       m_process->GetLoadedDynamicLibrariesInfos());
167   ImageInfo::collection image_infos;
168   if (all_image_info_json_sp.get() &&
169       all_image_info_json_sp->GetAsDictionary() &&
170       all_image_info_json_sp->GetAsDictionary()->HasKey("images") &&
171       all_image_info_json_sp->GetAsDictionary()
172           ->GetValueForKey("images")
173           ->GetAsArray()) {
174     if (JSONImageInformationIntoImageInfo(all_image_info_json_sp,
175                                           image_infos)) {
176       if (log)
177         log->Printf("Initial module fetch:  Adding %" PRId64 " modules.\n",
178                     (uint64_t)image_infos.size());
179 
180       UpdateSpecialBinariesFromNewImageInfos(image_infos);
181       AddModulesUsingImageInfos(image_infos);
182     }
183   }
184 
185   m_dyld_image_infos_stop_id = m_process->GetStopID();
186   m_maybe_image_infos_address = m_process->GetImageInfoAddress();
187 }
188 
189 bool DynamicLoaderMacOS::NeedToDoInitialImageFetch() { return true; }
190 
191 // Static callback function that gets called when our DYLD notification
192 // breakpoint gets hit. We update all of our image infos and then let our super
193 // class DynamicLoader class decide if we should stop or not (based on global
194 // preference).
195 bool DynamicLoaderMacOS::NotifyBreakpointHit(void *baton,
196                                              StoppointCallbackContext *context,
197                                              lldb::user_id_t break_id,
198                                              lldb::user_id_t break_loc_id) {
199   // Let the event know that the images have changed
200   // DYLD passes three arguments to the notification breakpoint.
201   // Arg1: enum dyld_notify_mode mode - 0 = adding, 1 = removing, 2 = remove
202   // all Arg2: unsigned long icount        - Number of shared libraries
203   // added/removed Arg3: uint64_t mach_headers[]     - Array of load addresses
204   // of binaries added/removed
205 
206   DynamicLoaderMacOS *dyld_instance = (DynamicLoaderMacOS *)baton;
207 
208   ExecutionContext exe_ctx(context->exe_ctx_ref);
209   Process *process = exe_ctx.GetProcessPtr();
210 
211   // This is a sanity check just in case this dyld_instance is an old dyld
212   // plugin's breakpoint still lying around.
213   if (process != dyld_instance->m_process)
214     return false;
215 
216   if (dyld_instance->m_image_infos_stop_id != UINT32_MAX &&
217       process->GetStopID() < dyld_instance->m_image_infos_stop_id) {
218     return false;
219   }
220 
221   const lldb::ABISP &abi = process->GetABI();
222   if (abi) {
223     // Build up the value array to store the three arguments given above, then
224     // get the values from the ABI:
225 
226     ClangASTContext *clang_ast_context =
227         process->GetTarget().GetScratchClangASTContext();
228     ValueList argument_values;
229 
230     Value mode_value;    // enum dyld_notify_mode { dyld_notify_adding=0,
231                          // dyld_notify_removing=1, dyld_notify_remove_all=2 };
232     Value count_value;   // unsigned long count
233     Value headers_value; // uint64_t machHeaders[] (aka void*)
234 
235     CompilerType clang_void_ptr_type =
236         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
237     CompilerType clang_uint32_type =
238         clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
239             lldb::eEncodingUint, 32);
240     CompilerType clang_uint64_type =
241         clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
242             lldb::eEncodingUint, 32);
243 
244     mode_value.SetValueType(Value::eValueTypeScalar);
245     mode_value.SetCompilerType(clang_uint32_type);
246 
247     if (process->GetTarget().GetArchitecture().GetAddressByteSize() == 4) {
248       count_value.SetValueType(Value::eValueTypeScalar);
249       count_value.SetCompilerType(clang_uint32_type);
250     } else {
251       count_value.SetValueType(Value::eValueTypeScalar);
252       count_value.SetCompilerType(clang_uint64_type);
253     }
254 
255     headers_value.SetValueType(Value::eValueTypeScalar);
256     headers_value.SetCompilerType(clang_void_ptr_type);
257 
258     argument_values.PushValue(mode_value);
259     argument_values.PushValue(count_value);
260     argument_values.PushValue(headers_value);
261 
262     if (abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values)) {
263       uint32_t dyld_mode =
264           argument_values.GetValueAtIndex(0)->GetScalar().UInt(-1);
265       if (dyld_mode != static_cast<uint32_t>(-1)) {
266         // Okay the mode was right, now get the number of elements, and the
267         // array of new elements...
268         uint32_t image_infos_count =
269             argument_values.GetValueAtIndex(1)->GetScalar().UInt(-1);
270         if (image_infos_count != static_cast<uint32_t>(-1)) {
271           addr_t header_array =
272               argument_values.GetValueAtIndex(2)->GetScalar().ULongLong(-1);
273           if (header_array != static_cast<uint64_t>(-1)) {
274             std::vector<addr_t> image_load_addresses;
275             for (uint64_t i = 0; i < image_infos_count; i++) {
276               Status error;
277               addr_t addr = process->ReadUnsignedIntegerFromMemory(
278                   header_array + (8 * i), 8, LLDB_INVALID_ADDRESS, error);
279               if (addr != LLDB_INVALID_ADDRESS) {
280                 image_load_addresses.push_back(addr);
281               }
282             }
283             if (dyld_mode == 0) {
284               // dyld_notify_adding
285               dyld_instance->AddBinaries(image_load_addresses);
286             } else if (dyld_mode == 1) {
287               // dyld_notify_removing
288               dyld_instance->UnloadImages(image_load_addresses);
289             } else if (dyld_mode == 2) {
290               // dyld_notify_remove_all
291               dyld_instance->UnloadAllImages();
292             }
293           }
294         }
295       }
296     }
297   } else {
298     process->GetTarget().GetDebugger().GetAsyncErrorStream()->Printf(
299         "No ABI plugin located for triple %s -- shared libraries will not be "
300         "registered!\n",
301         process->GetTarget().GetArchitecture().GetTriple().getTriple().c_str());
302   }
303 
304   // Return true to stop the target, false to just let the target run
305   return dyld_instance->GetStopWhenImagesChange();
306 }
307 
308 void DynamicLoaderMacOS::AddBinaries(
309     const std::vector<lldb::addr_t> &load_addresses) {
310   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
311   ImageInfo::collection image_infos;
312 
313   if (log)
314     log->Printf("Adding %" PRId64 " modules.", (uint64_t)load_addresses.size());
315   StructuredData::ObjectSP binaries_info_sp =
316       m_process->GetLoadedDynamicLibrariesInfos(load_addresses);
317   if (binaries_info_sp.get() && binaries_info_sp->GetAsDictionary() &&
318       binaries_info_sp->GetAsDictionary()->HasKey("images") &&
319       binaries_info_sp->GetAsDictionary()
320           ->GetValueForKey("images")
321           ->GetAsArray() &&
322       binaries_info_sp->GetAsDictionary()
323               ->GetValueForKey("images")
324               ->GetAsArray()
325               ->GetSize() == load_addresses.size()) {
326     if (JSONImageInformationIntoImageInfo(binaries_info_sp, image_infos)) {
327       UpdateSpecialBinariesFromNewImageInfos(image_infos);
328       AddModulesUsingImageInfos(image_infos);
329     }
330     m_dyld_image_infos_stop_id = m_process->GetStopID();
331   }
332 }
333 
334 // Dump the _dyld_all_image_infos members and all current image infos that we
335 // have parsed to the file handle provided.
336 void DynamicLoaderMacOS::PutToLog(Log *log) const {
337   if (log == nullptr)
338     return;
339 }
340 
341 bool DynamicLoaderMacOS::SetNotificationBreakpoint() {
342   if (m_break_id == LLDB_INVALID_BREAK_ID) {
343     ConstString g_symbol_name("_dyld_debugger_notification");
344     const Symbol *symbol = nullptr;
345     ModuleSP dyld_sp(GetDYLDModule());
346     if (dyld_sp) {
347       symbol = dyld_sp->FindFirstSymbolWithNameAndType(g_symbol_name,
348                                                        eSymbolTypeCode);
349     }
350     if (symbol &&
351         (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())) {
352       addr_t symbol_address =
353           symbol->GetAddressRef().GetOpcodeLoadAddress(&m_process->GetTarget());
354       if (symbol_address != LLDB_INVALID_ADDRESS) {
355         bool internal = true;
356         bool hardware = false;
357         Breakpoint *breakpoint =
358             m_process->GetTarget()
359                 .CreateBreakpoint(symbol_address, internal, hardware)
360                 .get();
361         breakpoint->SetCallback(DynamicLoaderMacOS::NotifyBreakpointHit, this,
362                                 true);
363         breakpoint->SetBreakpointKind("shared-library-event");
364         m_break_id = breakpoint->GetID();
365       }
366     }
367   }
368   return m_break_id != LLDB_INVALID_BREAK_ID;
369 }
370 
371 addr_t
372 DynamicLoaderMacOS::GetDyldLockVariableAddressFromModule(Module *module) {
373   SymbolContext sc;
374   SymbolVendor *sym_vendor = module->GetSymbolVendor();
375   Target &target = m_process->GetTarget();
376   if (sym_vendor) {
377     Symtab *symtab = sym_vendor->GetSymtab();
378     if (symtab) {
379       std::vector<uint32_t> match_indexes;
380       ConstString g_symbol_name("_dyld_global_lock_held");
381       uint32_t num_matches = 0;
382       num_matches =
383           symtab->AppendSymbolIndexesWithName(g_symbol_name, match_indexes);
384       if (num_matches == 1) {
385         Symbol *symbol = symtab->SymbolAtIndex(match_indexes[0]);
386         if (symbol &&
387             (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())) {
388           return symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
389         }
390       }
391     }
392   }
393   return LLDB_INVALID_ADDRESS;
394 }
395 
396 //  Look for this symbol:
397 //
398 //  int __attribute__((visibility("hidden")))           _dyld_global_lock_held =
399 //  0;
400 //
401 //  in libdyld.dylib.
402 Status DynamicLoaderMacOS::CanLoadImage() {
403   Status error;
404   addr_t symbol_address = LLDB_INVALID_ADDRESS;
405   Target &target = m_process->GetTarget();
406   const ModuleList &target_modules = target.GetImages();
407   std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
408   const size_t num_modules = target_modules.GetSize();
409   ConstString g_libdyld_name("libdyld.dylib");
410 
411   // Find any modules named "libdyld.dylib" and look for the symbol there first
412   for (size_t i = 0; i < num_modules; i++) {
413     Module *module_pointer = target_modules.GetModulePointerAtIndexUnlocked(i);
414     if (module_pointer) {
415       if (module_pointer->GetFileSpec().GetFilename() == g_libdyld_name) {
416         symbol_address = GetDyldLockVariableAddressFromModule(module_pointer);
417         if (symbol_address != LLDB_INVALID_ADDRESS)
418           break;
419       }
420     }
421   }
422 
423   // Search through all modules looking for the symbol in them
424   if (symbol_address == LLDB_INVALID_ADDRESS) {
425     for (size_t i = 0; i < num_modules; i++) {
426       Module *module_pointer =
427           target_modules.GetModulePointerAtIndexUnlocked(i);
428       if (module_pointer) {
429         addr_t symbol_address =
430             GetDyldLockVariableAddressFromModule(module_pointer);
431         if (symbol_address != LLDB_INVALID_ADDRESS)
432           break;
433       }
434     }
435   }
436 
437   // Default assumption is that it is OK to load images. Only say that we
438   // cannot load images if we find the symbol in libdyld and it indicates that
439   // we cannot.
440 
441   if (symbol_address != LLDB_INVALID_ADDRESS) {
442     {
443       int lock_held =
444           m_process->ReadUnsignedIntegerFromMemory(symbol_address, 4, 0, error);
445       if (lock_held != 0) {
446         error.SetErrorString("dyld lock held - unsafe to load images.");
447       }
448     }
449   } else {
450     // If we were unable to find _dyld_global_lock_held in any modules, or it
451     // is not loaded into memory yet, we may be at process startup (sitting  at
452     // _dyld_start) - so we should not allow dlopen calls. But if we found more
453     // than one module then we are clearly past _dyld_start so in that case
454     // we'll default to "it's safe".
455     if (num_modules <= 1)
456         error.SetErrorString("could not find the dyld library or "
457                                        "the dyld lock symbol");
458   }
459   return error;
460 }
461 
462 bool DynamicLoaderMacOS::GetSharedCacheInformation(
463     lldb::addr_t &base_address, UUID &uuid, LazyBool &using_shared_cache,
464     LazyBool &private_shared_cache) {
465   base_address = LLDB_INVALID_ADDRESS;
466   uuid.Clear();
467   using_shared_cache = eLazyBoolCalculate;
468   private_shared_cache = eLazyBoolCalculate;
469 
470   if (m_process) {
471     StructuredData::ObjectSP info = m_process->GetSharedCacheInfo();
472     StructuredData::Dictionary *info_dict = nullptr;
473     if (info.get() && info->GetAsDictionary()) {
474       info_dict = info->GetAsDictionary();
475     }
476 
477     // {"shared_cache_base_address":140735683125248,"shared_cache_uuid
478     // ":"DDB8D70C-
479     // C9A2-3561-B2C8-BE48A4F33F96","no_shared_cache":false,"shared_cache_private_cache":false}
480 
481     if (info_dict && info_dict->HasKey("shared_cache_uuid") &&
482         info_dict->HasKey("no_shared_cache") &&
483         info_dict->HasKey("shared_cache_base_address")) {
484       base_address = info_dict->GetValueForKey("shared_cache_base_address")
485                          ->GetIntegerValue(LLDB_INVALID_ADDRESS);
486       std::string uuid_str =
487           info_dict->GetValueForKey("shared_cache_uuid")->GetStringValue();
488       if (!uuid_str.empty())
489         uuid.SetFromStringRef(uuid_str);
490       if (!info_dict->GetValueForKey("no_shared_cache")->GetBooleanValue())
491         using_shared_cache = eLazyBoolYes;
492       else
493         using_shared_cache = eLazyBoolNo;
494       if (info_dict->GetValueForKey("shared_cache_private_cache")
495               ->GetBooleanValue())
496         private_shared_cache = eLazyBoolYes;
497       else
498         private_shared_cache = eLazyBoolNo;
499 
500       return true;
501     }
502   }
503   return false;
504 }
505 
506 void DynamicLoaderMacOS::Initialize() {
507   PluginManager::RegisterPlugin(GetPluginNameStatic(),
508                                 GetPluginDescriptionStatic(), CreateInstance);
509 }
510 
511 void DynamicLoaderMacOS::Terminate() {
512   PluginManager::UnregisterPlugin(CreateInstance);
513 }
514 
515 lldb_private::ConstString DynamicLoaderMacOS::GetPluginNameStatic() {
516   static ConstString g_name("macos-dyld");
517   return g_name;
518 }
519 
520 const char *DynamicLoaderMacOS::GetPluginDescriptionStatic() {
521   return "Dynamic loader plug-in that watches for shared library loads/unloads "
522          "in MacOSX user processes.";
523 }
524 
525 // PluginInterface protocol
526 lldb_private::ConstString DynamicLoaderMacOS::GetPluginName() {
527   return GetPluginNameStatic();
528 }
529 
530 uint32_t DynamicLoaderMacOS::GetPluginVersion() { return 1; }
531