1 //===-- MemoryHistoryASan.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 "MemoryHistoryASan.h" 10 11 #include "lldb/Target/MemoryHistory.h" 12 13 #include "Plugins/Process/Utility/HistoryThread.h" 14 #include "lldb/Core/Debugger.h" 15 #include "lldb/Core/Module.h" 16 #include "lldb/Core/PluginInterface.h" 17 #include "lldb/Core/PluginManager.h" 18 #include "lldb/Core/ValueObject.h" 19 #include "lldb/Expression/UserExpression.h" 20 #include "lldb/Target/ExecutionContext.h" 21 #include "lldb/Target/Target.h" 22 #include "lldb/Target/Thread.h" 23 #include "lldb/Target/ThreadList.h" 24 #include "lldb/lldb-private.h" 25 26 #include <sstream> 27 28 using namespace lldb; 29 using namespace lldb_private; 30 31 MemoryHistorySP MemoryHistoryASan::CreateInstance(const ProcessSP &process_sp) { 32 if (!process_sp.get()) 33 return nullptr; 34 35 Target &target = process_sp->GetTarget(); 36 37 const ModuleList &target_modules = target.GetImages(); 38 std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex()); 39 const size_t num_modules = target_modules.GetSize(); 40 for (size_t i = 0; i < num_modules; ++i) { 41 Module *module_pointer = target_modules.GetModulePointerAtIndexUnlocked(i); 42 43 const Symbol *symbol = module_pointer->FindFirstSymbolWithNameAndType( 44 ConstString("__asan_get_alloc_stack"), lldb::eSymbolTypeAny); 45 46 if (symbol != nullptr) 47 return MemoryHistorySP(new MemoryHistoryASan(process_sp)); 48 } 49 50 return MemoryHistorySP(); 51 } 52 53 void MemoryHistoryASan::Initialize() { 54 PluginManager::RegisterPlugin( 55 GetPluginNameStatic(), "ASan memory history provider.", CreateInstance); 56 } 57 58 void MemoryHistoryASan::Terminate() { 59 PluginManager::UnregisterPlugin(CreateInstance); 60 } 61 62 ConstString MemoryHistoryASan::GetPluginNameStatic() { 63 static ConstString g_name("asan"); 64 return g_name; 65 } 66 67 MemoryHistoryASan::MemoryHistoryASan(const ProcessSP &process_sp) { 68 if (process_sp) 69 m_process_wp = process_sp; 70 } 71 72 const char *memory_history_asan_command_prefix = R"( 73 extern "C" 74 { 75 size_t __asan_get_alloc_stack(void *addr, void **trace, size_t size, int *thread_id); 76 size_t __asan_get_free_stack(void *addr, void **trace, size_t size, int *thread_id); 77 } 78 79 struct data { 80 void *alloc_trace[256]; 81 size_t alloc_count; 82 int alloc_tid; 83 84 void *free_trace[256]; 85 size_t free_count; 86 int free_tid; 87 }; 88 )"; 89 90 const char *memory_history_asan_command_format = 91 R"( 92 data t; 93 94 t.alloc_count = __asan_get_alloc_stack((void *)0x%)" PRIx64 95 R"(, t.alloc_trace, 256, &t.alloc_tid); 96 t.free_count = __asan_get_free_stack((void *)0x%)" PRIx64 97 R"(, t.free_trace, 256, &t.free_tid); 98 99 t; 100 )"; 101 102 static void CreateHistoryThreadFromValueObject(ProcessSP process_sp, 103 ValueObjectSP return_value_sp, 104 const char *type, 105 const char *thread_name, 106 HistoryThreads &result) { 107 std::string count_path = "." + std::string(type) + "_count"; 108 std::string tid_path = "." + std::string(type) + "_tid"; 109 std::string trace_path = "." + std::string(type) + "_trace"; 110 111 ValueObjectSP count_sp = 112 return_value_sp->GetValueForExpressionPath(count_path.c_str()); 113 ValueObjectSP tid_sp = 114 return_value_sp->GetValueForExpressionPath(tid_path.c_str()); 115 116 if (!count_sp || !tid_sp) 117 return; 118 119 int count = count_sp->GetValueAsUnsigned(0); 120 tid_t tid = tid_sp->GetValueAsUnsigned(0) + 1; 121 122 if (count <= 0) 123 return; 124 125 ValueObjectSP trace_sp = 126 return_value_sp->GetValueForExpressionPath(trace_path.c_str()); 127 128 if (!trace_sp) 129 return; 130 131 std::vector<lldb::addr_t> pcs; 132 for (int i = 0; i < count; i++) { 133 addr_t pc = trace_sp->GetChildAtIndex(i, true)->GetValueAsUnsigned(0); 134 if (pc == 0 || pc == 1 || pc == LLDB_INVALID_ADDRESS) 135 continue; 136 pcs.push_back(pc); 137 } 138 139 HistoryThread *history_thread = new HistoryThread(*process_sp, tid, pcs); 140 ThreadSP new_thread_sp(history_thread); 141 std::ostringstream thread_name_with_number; 142 thread_name_with_number << thread_name << " Thread " << tid; 143 history_thread->SetThreadName(thread_name_with_number.str().c_str()); 144 // Save this in the Process' ExtendedThreadList so a strong pointer retains 145 // the object 146 process_sp->GetExtendedThreadList().AddThread(new_thread_sp); 147 result.push_back(new_thread_sp); 148 } 149 150 HistoryThreads MemoryHistoryASan::GetHistoryThreads(lldb::addr_t address) { 151 HistoryThreads result; 152 153 ProcessSP process_sp = m_process_wp.lock(); 154 if (!process_sp) 155 return result; 156 157 ThreadSP thread_sp = 158 process_sp->GetThreadList().GetExpressionExecutionThread(); 159 if (!thread_sp) 160 return result; 161 162 StackFrameSP frame_sp = thread_sp->GetSelectedFrame(); 163 if (!frame_sp) 164 return result; 165 166 ExecutionContext exe_ctx(frame_sp); 167 ValueObjectSP return_value_sp; 168 StreamString expr; 169 Status eval_error; 170 expr.Printf(memory_history_asan_command_format, address, address); 171 172 EvaluateExpressionOptions options; 173 options.SetUnwindOnError(true); 174 options.SetTryAllThreads(true); 175 options.SetStopOthers(true); 176 options.SetIgnoreBreakpoints(true); 177 options.SetTimeout(process_sp->GetUtilityExpressionTimeout()); 178 options.SetPrefix(memory_history_asan_command_prefix); 179 options.SetAutoApplyFixIts(false); 180 options.SetLanguage(eLanguageTypeObjC_plus_plus); 181 182 ExpressionResults expr_result = UserExpression::Evaluate( 183 exe_ctx, options, expr.GetString(), "", return_value_sp, eval_error); 184 if (expr_result != eExpressionCompleted) { 185 process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf( 186 "Warning: Cannot evaluate AddressSanitizer expression:\n%s\n", 187 eval_error.AsCString()); 188 return result; 189 } 190 191 if (!return_value_sp) 192 return result; 193 194 CreateHistoryThreadFromValueObject(process_sp, return_value_sp, "free", 195 "Memory deallocated by", result); 196 CreateHistoryThreadFromValueObject(process_sp, return_value_sp, "alloc", 197 "Memory allocated by", result); 198 199 return result; 200 } 201