1 //===-- AppleGetItemInfoHandler.cpp ---------------------------------------===//
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 "AppleGetItemInfoHandler.h"
10
11 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/Value.h"
14 #include "lldb/Expression/DiagnosticManager.h"
15 #include "lldb/Expression/FunctionCaller.h"
16 #include "lldb/Expression/UtilityFunction.h"
17 #include "lldb/Symbol/Symbol.h"
18 #include "lldb/Target/ExecutionContext.h"
19 #include "lldb/Target/Process.h"
20 #include "lldb/Target/Target.h"
21 #include "lldb/Target/Thread.h"
22 #include "lldb/Utility/ConstString.h"
23 #include "lldb/Utility/Log.h"
24 #include "lldb/Utility/StreamString.h"
25
26 using namespace lldb;
27 using namespace lldb_private;
28
29 const char *AppleGetItemInfoHandler::g_get_item_info_function_name =
30 "__lldb_backtrace_recording_get_item_info";
31 const char *AppleGetItemInfoHandler::g_get_item_info_function_code =
32 " \n\
33 extern \"C\" \n\
34 { \n\
35 /* \n\
36 * mach defines \n\
37 */ \n\
38 \n\
39 typedef unsigned int uint32_t; \n\
40 typedef unsigned long long uint64_t; \n\
41 typedef uint32_t mach_port_t; \n\
42 typedef mach_port_t vm_map_t; \n\
43 typedef int kern_return_t; \n\
44 typedef uint64_t mach_vm_address_t; \n\
45 typedef uint64_t mach_vm_size_t; \n\
46 \n\
47 mach_port_t mach_task_self (); \n\
48 kern_return_t mach_vm_deallocate (vm_map_t target, mach_vm_address_t address, mach_vm_size_t size); \n\
49 \n\
50 /* \n\
51 * libBacktraceRecording defines \n\
52 */ \n\
53 \n\
54 typedef uint32_t queue_list_scope_t; \n\
55 typedef void *dispatch_queue_t; \n\
56 typedef void *introspection_dispatch_queue_info_t; \n\
57 typedef void *introspection_dispatch_item_info_ref; \n\
58 \n\
59 extern uint64_t __introspection_dispatch_queue_item_get_info (introspection_dispatch_item_info_ref item_info_ref, \n\
60 introspection_dispatch_item_info_ref *returned_queues_buffer, \n\
61 uint64_t *returned_queues_buffer_size); \n\
62 extern int printf(const char *format, ...); \n\
63 \n\
64 /* \n\
65 * return type define \n\
66 */ \n\
67 \n\
68 struct get_item_info_return_values \n\
69 { \n\
70 uint64_t item_info_buffer_ptr; /* the address of the items buffer from libBacktraceRecording */ \n\
71 uint64_t item_info_buffer_size; /* the size of the items buffer from libBacktraceRecording */ \n\
72 }; \n\
73 \n\
74 void __lldb_backtrace_recording_get_item_info \n\
75 (struct get_item_info_return_values *return_buffer, \n\
76 int debug, \n\
77 uint64_t /* introspection_dispatch_item_info_ref item_info_ref */ item, \n\
78 void *page_to_free, \n\
79 uint64_t page_to_free_size) \n\
80 { \n\
81 if (debug) \n\
82 printf (\"entering get_item_info with args return_buffer == %p, debug == %d, item == 0x%llx, page_to_free == %p, page_to_free_size == 0x%llx\\n\", return_buffer, debug, item, page_to_free, page_to_free_size); \n\
83 if (page_to_free != 0) \n\
84 { \n\
85 mach_vm_deallocate (mach_task_self(), (mach_vm_address_t) page_to_free, (mach_vm_size_t) page_to_free_size); \n\
86 } \n\
87 \n\
88 __introspection_dispatch_queue_item_get_info ((void*) item, \n\
89 (void**)&return_buffer->item_info_buffer_ptr, \n\
90 &return_buffer->item_info_buffer_size); \n\
91 } \n\
92 } \n\
93 ";
94
AppleGetItemInfoHandler(Process * process)95 AppleGetItemInfoHandler::AppleGetItemInfoHandler(Process *process)
96 : m_process(process), m_get_item_info_impl_code(),
97 m_get_item_info_function_mutex(),
98 m_get_item_info_return_buffer_addr(LLDB_INVALID_ADDRESS),
99 m_get_item_info_retbuffer_mutex() {}
100
~AppleGetItemInfoHandler()101 AppleGetItemInfoHandler::~AppleGetItemInfoHandler() {}
102
Detach()103 void AppleGetItemInfoHandler::Detach() {
104
105 if (m_process && m_process->IsAlive() &&
106 m_get_item_info_return_buffer_addr != LLDB_INVALID_ADDRESS) {
107 std::unique_lock<std::mutex> lock(m_get_item_info_retbuffer_mutex,
108 std::defer_lock);
109 (void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
110 m_process->DeallocateMemory(m_get_item_info_return_buffer_addr);
111 }
112 }
113
114 // Compile our __lldb_backtrace_recording_get_item_info() function (from the
115 // source above in g_get_item_info_function_code) if we don't find that
116 // function in the inferior already with USE_BUILTIN_FUNCTION defined. (e.g.
117 // this would be the case for testing.)
118 //
119 // Insert the __lldb_backtrace_recording_get_item_info into the inferior
120 // process if needed.
121 //
122 // Write the get_item_info_arglist into the inferior's memory space to prepare
123 // for the call.
124 //
125 // Returns the address of the arguments written down in the inferior process,
126 // which can be used to make the function call.
127
SetupGetItemInfoFunction(Thread & thread,ValueList & get_item_info_arglist)128 lldb::addr_t AppleGetItemInfoHandler::SetupGetItemInfoFunction(
129 Thread &thread, ValueList &get_item_info_arglist) {
130 ExecutionContext exe_ctx(thread.shared_from_this());
131 DiagnosticManager diagnostics;
132 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
133 lldb::addr_t args_addr = LLDB_INVALID_ADDRESS;
134 FunctionCaller *get_item_info_caller = nullptr;
135
136 // Scope for mutex locker:
137 {
138 std::lock_guard<std::mutex> guard(m_get_item_info_function_mutex);
139
140 // First stage is to make the UtilityFunction to hold our injected
141 // function:
142
143 if (!m_get_item_info_impl_code) {
144 if (g_get_item_info_function_code != nullptr) {
145 auto utility_fn_or_error = exe_ctx.GetTargetRef().CreateUtilityFunction(
146 g_get_item_info_function_code, g_get_item_info_function_name,
147 eLanguageTypeObjC, exe_ctx);
148 if (!utility_fn_or_error) {
149 LLDB_LOG_ERROR(log, utility_fn_or_error.takeError(),
150 "Failed to create utility function: {0}.");
151 }
152 m_get_item_info_impl_code = std::move(*utility_fn_or_error);
153 } else {
154 LLDB_LOGF(log, "No get-item-info introspection code found.");
155 return LLDB_INVALID_ADDRESS;
156 }
157
158 // Next make the runner function for our implementation utility function.
159 auto type_system_or_err =
160 thread.GetProcess()->GetTarget().GetScratchTypeSystemForLanguage(
161 eLanguageTypeC);
162 if (auto err = type_system_or_err.takeError()) {
163 LLDB_LOG_ERROR(log, std::move(err),
164 "Error inseting get-item-info function");
165 return args_addr;
166 }
167 CompilerType get_item_info_return_type =
168 type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid)
169 .GetPointerType();
170
171 Status error;
172 get_item_info_caller = m_get_item_info_impl_code->MakeFunctionCaller(
173 get_item_info_return_type, get_item_info_arglist,
174 thread.shared_from_this(), error);
175 if (error.Fail() || get_item_info_caller == nullptr) {
176 LLDB_LOGF(log, "Error Inserting get-item-info function: \"%s\".",
177 error.AsCString());
178 return args_addr;
179 }
180 } else {
181 // If it's already made, then we can just retrieve the caller:
182 get_item_info_caller = m_get_item_info_impl_code->GetFunctionCaller();
183 if (!get_item_info_caller) {
184 LLDB_LOGF(log, "Failed to get get-item-info introspection caller.");
185 m_get_item_info_impl_code.reset();
186 return args_addr;
187 }
188 }
189 }
190
191 diagnostics.Clear();
192
193 // Now write down the argument values for this particular call. This looks
194 // like it might be a race condition if other threads were calling into here,
195 // but actually it isn't because we allocate a new args structure for this
196 // call by passing args_addr = LLDB_INVALID_ADDRESS...
197
198 if (!get_item_info_caller->WriteFunctionArguments(
199 exe_ctx, args_addr, get_item_info_arglist, diagnostics)) {
200 if (log) {
201 LLDB_LOGF(log, "Error writing get-item-info function arguments.");
202 diagnostics.Dump(log);
203 }
204
205 return args_addr;
206 }
207
208 return args_addr;
209 }
210
211 AppleGetItemInfoHandler::GetItemInfoReturnInfo
GetItemInfo(Thread & thread,uint64_t item,addr_t page_to_free,uint64_t page_to_free_size,Status & error)212 AppleGetItemInfoHandler::GetItemInfo(Thread &thread, uint64_t item,
213 addr_t page_to_free,
214 uint64_t page_to_free_size,
215 Status &error) {
216 lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
217 ProcessSP process_sp(thread.CalculateProcess());
218 TargetSP target_sp(thread.CalculateTarget());
219 TypeSystemClang *clang_ast_context =
220 ScratchTypeSystemClang::GetForTarget(*target_sp);
221 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
222
223 GetItemInfoReturnInfo return_value;
224 return_value.item_buffer_ptr = LLDB_INVALID_ADDRESS;
225 return_value.item_buffer_size = 0;
226
227 error.Clear();
228
229 if (!thread.SafeToCallFunctions()) {
230 LLDB_LOGF(log, "Not safe to call functions on thread 0x%" PRIx64,
231 thread.GetID());
232 error.SetErrorString("Not safe to call functions on this thread.");
233 return return_value;
234 }
235
236 // Set up the arguments for a call to
237
238 // struct get_item_info_return_values
239 // {
240 // uint64_t item_info_buffer_ptr; /* the address of the items buffer
241 // from libBacktraceRecording */
242 // uint64_t item_info_buffer_size; /* the size of the items buffer from
243 // libBacktraceRecording */
244 // };
245 //
246 // void __lldb_backtrace_recording_get_item_info
247 // (struct
248 // get_item_info_return_values
249 // *return_buffer,
250 // int debug,
251 // uint64_t item,
252 // void *page_to_free,
253 // uint64_t page_to_free_size)
254
255 // Where the return_buffer argument points to a 24 byte region of memory
256 // already allocated by lldb in the inferior process.
257
258 CompilerType clang_void_ptr_type =
259 clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
260 Value return_buffer_ptr_value;
261 return_buffer_ptr_value.SetValueType(Value::eValueTypeScalar);
262 return_buffer_ptr_value.SetCompilerType(clang_void_ptr_type);
263
264 CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
265 Value debug_value;
266 debug_value.SetValueType(Value::eValueTypeScalar);
267 debug_value.SetCompilerType(clang_int_type);
268
269 CompilerType clang_uint64_type =
270 clang_ast_context->GetBasicType(eBasicTypeUnsignedLongLong);
271 Value item_value;
272 item_value.SetValueType(Value::eValueTypeScalar);
273 item_value.SetCompilerType(clang_uint64_type);
274
275 Value page_to_free_value;
276 page_to_free_value.SetValueType(Value::eValueTypeScalar);
277 page_to_free_value.SetCompilerType(clang_void_ptr_type);
278
279 Value page_to_free_size_value;
280 page_to_free_size_value.SetValueType(Value::eValueTypeScalar);
281 page_to_free_size_value.SetCompilerType(clang_uint64_type);
282
283 std::lock_guard<std::mutex> guard(m_get_item_info_retbuffer_mutex);
284 if (m_get_item_info_return_buffer_addr == LLDB_INVALID_ADDRESS) {
285 addr_t bufaddr = process_sp->AllocateMemory(
286 32, ePermissionsReadable | ePermissionsWritable, error);
287 if (!error.Success() || bufaddr == LLDB_INVALID_ADDRESS) {
288 LLDB_LOGF(log, "Failed to allocate memory for return buffer for get "
289 "current queues func call");
290 return return_value;
291 }
292 m_get_item_info_return_buffer_addr = bufaddr;
293 }
294
295 ValueList argument_values;
296
297 return_buffer_ptr_value.GetScalar() = m_get_item_info_return_buffer_addr;
298 argument_values.PushValue(return_buffer_ptr_value);
299
300 debug_value.GetScalar() = 0;
301 argument_values.PushValue(debug_value);
302
303 item_value.GetScalar() = item;
304 argument_values.PushValue(item_value);
305
306 if (page_to_free != LLDB_INVALID_ADDRESS)
307 page_to_free_value.GetScalar() = page_to_free;
308 else
309 page_to_free_value.GetScalar() = 0;
310 argument_values.PushValue(page_to_free_value);
311
312 page_to_free_size_value.GetScalar() = page_to_free_size;
313 argument_values.PushValue(page_to_free_size_value);
314
315 addr_t args_addr = SetupGetItemInfoFunction(thread, argument_values);
316
317 DiagnosticManager diagnostics;
318 ExecutionContext exe_ctx;
319 EvaluateExpressionOptions options;
320 options.SetUnwindOnError(true);
321 options.SetIgnoreBreakpoints(true);
322 options.SetStopOthers(true);
323 #if __has_feature(address_sanitizer)
324 options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
325 #else
326 options.SetTimeout(std::chrono::milliseconds(500));
327 #endif
328 options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
329 options.SetTryAllThreads(false);
330 options.SetIsForUtilityExpr(true);
331 thread.CalculateExecutionContext(exe_ctx);
332
333 if (!m_get_item_info_impl_code) {
334 error.SetErrorString("Unable to compile function to call "
335 "__introspection_dispatch_queue_item_get_info");
336 return return_value;
337 }
338
339 ExpressionResults func_call_ret;
340 Value results;
341 FunctionCaller *func_caller = m_get_item_info_impl_code->GetFunctionCaller();
342 if (!func_caller) {
343 LLDB_LOGF(log, "Could not retrieve function caller for "
344 "__introspection_dispatch_queue_item_get_info.");
345 error.SetErrorString("Could not retrieve function caller for "
346 "__introspection_dispatch_queue_item_get_info.");
347 return return_value;
348 }
349
350 func_call_ret = func_caller->ExecuteFunction(exe_ctx, &args_addr, options,
351 diagnostics, results);
352 if (func_call_ret != eExpressionCompleted || !error.Success()) {
353 LLDB_LOGF(log,
354 "Unable to call "
355 "__introspection_dispatch_queue_item_get_info(), got "
356 "ExpressionResults %d, error contains %s",
357 func_call_ret, error.AsCString(""));
358 error.SetErrorString("Unable to call "
359 "__introspection_dispatch_queue_get_item_info() for "
360 "list of queues");
361 return return_value;
362 }
363
364 return_value.item_buffer_ptr = m_process->ReadUnsignedIntegerFromMemory(
365 m_get_item_info_return_buffer_addr, 8, LLDB_INVALID_ADDRESS, error);
366 if (!error.Success() ||
367 return_value.item_buffer_ptr == LLDB_INVALID_ADDRESS) {
368 return_value.item_buffer_ptr = LLDB_INVALID_ADDRESS;
369 return return_value;
370 }
371
372 return_value.item_buffer_size = m_process->ReadUnsignedIntegerFromMemory(
373 m_get_item_info_return_buffer_addr + 8, 8, 0, error);
374
375 if (!error.Success()) {
376 return_value.item_buffer_ptr = LLDB_INVALID_ADDRESS;
377 return return_value;
378 }
379 LLDB_LOGF(log,
380 "AppleGetItemInfoHandler called "
381 "__introspection_dispatch_queue_item_get_info (page_to_free == "
382 "0x%" PRIx64 ", size = %" PRId64 "), returned page is at 0x%" PRIx64
383 ", size %" PRId64,
384 page_to_free, page_to_free_size, return_value.item_buffer_ptr,
385 return_value.item_buffer_size);
386
387 return return_value;
388 }
389