Coverage Report

Created: 2022-01-25 06:29

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp
Line
Count
Source (jump to first uncovered line)
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
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
2.60k
      m_get_item_info_retbuffer_mutex() {}
100
101
2.60k
AppleGetItemInfoHandler::~AppleGetItemInfoHandler() = default;
102
103
0
void AppleGetItemInfoHandler::Detach() {
104
105
0
  if (m_process && m_process->IsAlive() &&
106
0
      m_get_item_info_return_buffer_addr != LLDB_INVALID_ADDRESS) {
107
0
    std::unique_lock<std::mutex> lock(m_get_item_info_retbuffer_mutex,
108
0
                                      std::defer_lock);
109
0
    (void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
110
0
    m_process->DeallocateMemory(m_get_item_info_return_buffer_addr);
111
0
  }
112
0
}
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
128
lldb::addr_t AppleGetItemInfoHandler::SetupGetItemInfoFunction(
129
0
    Thread &thread, ValueList &get_item_info_arglist) {
130
0
  ExecutionContext exe_ctx(thread.shared_from_this());
131
0
  DiagnosticManager diagnostics;
132
0
  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
133
0
  lldb::addr_t args_addr = LLDB_INVALID_ADDRESS;
134
0
  FunctionCaller *get_item_info_caller = nullptr;
135
136
  // Scope for mutex locker:
137
0
  {
138
0
    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
0
    if (!m_get_item_info_impl_code) {
144
0
      if (g_get_item_info_function_code != nullptr) {
145
0
        auto utility_fn_or_error = exe_ctx.GetTargetRef().CreateUtilityFunction(
146
0
            g_get_item_info_function_code, g_get_item_info_function_name,
147
0
            eLanguageTypeObjC, exe_ctx);
148
0
        if (!utility_fn_or_error) {
149
0
          LLDB_LOG_ERROR(log, utility_fn_or_error.takeError(),
150
0
                         "Failed to create utility function: {0}.");
151
0
        }
152
0
        m_get_item_info_impl_code = std::move(*utility_fn_or_error);
153
0
      } else {
154
0
        LLDB_LOGF(log, "No get-item-info introspection code found.");
155
0
        return LLDB_INVALID_ADDRESS;
156
0
      }
157
158
      // Next make the runner function for our implementation utility function.
159
0
      auto type_system_or_err =
160
0
          thread.GetProcess()->GetTarget().GetScratchTypeSystemForLanguage(
161
0
              eLanguageTypeC);
162
0
      if (auto err = type_system_or_err.takeError()) {
163
0
        LLDB_LOG_ERROR(log, std::move(err),
164
0
                       "Error inseting get-item-info function");
165
0
        return args_addr;
166
0
      }
167
0
      CompilerType get_item_info_return_type =
168
0
          type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid)
169
0
              .GetPointerType();
170
171
0
      Status error;
172
0
      get_item_info_caller = m_get_item_info_impl_code->MakeFunctionCaller(
173
0
          get_item_info_return_type, get_item_info_arglist,
174
0
          thread.shared_from_this(), error);
175
0
      if (error.Fail() || get_item_info_caller == nullptr) {
176
0
        LLDB_LOGF(log, "Error Inserting get-item-info function: \"%s\".",
177
0
                  error.AsCString());
178
0
        return args_addr;
179
0
      }
180
0
    } else {
181
      // If it's already made, then we can just retrieve the caller:
182
0
      get_item_info_caller = m_get_item_info_impl_code->GetFunctionCaller();
183
0
      if (!get_item_info_caller) {
184
0
        LLDB_LOGF(log, "Failed to get get-item-info introspection caller.");
185
0
        m_get_item_info_impl_code.reset();
186
0
        return args_addr;
187
0
      }
188
0
    }
189
0
  }
190
191
0
  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
0
  if (!get_item_info_caller->WriteFunctionArguments(
199
0
          exe_ctx, args_addr, get_item_info_arglist, diagnostics)) {
200
0
    if (log) {
201
0
      LLDB_LOGF(log, "Error writing get-item-info function arguments.");
202
0
      diagnostics.Dump(log);
203
0
    }
204
205
0
    return args_addr;
206
0
  }
207
208
0
  return args_addr;
209
0
}
210
211
AppleGetItemInfoHandler::GetItemInfoReturnInfo
212
AppleGetItemInfoHandler::GetItemInfo(Thread &thread, uint64_t item,
213
                                     addr_t page_to_free,
214
                                     uint64_t page_to_free_size,
215
0
                                     Status &error) {
216
0
  lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
217
0
  ProcessSP process_sp(thread.CalculateProcess());
218
0
  TargetSP target_sp(thread.CalculateTarget());
219
0
  TypeSystemClang *clang_ast_context =
220
0
      ScratchTypeSystemClang::GetForTarget(*target_sp);
221
0
  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
222
223
0
  GetItemInfoReturnInfo return_value;
224
0
  return_value.item_buffer_ptr = LLDB_INVALID_ADDRESS;
225
0
  return_value.item_buffer_size = 0;
226
227
0
  error.Clear();
228
229
0
  if (!thread.SafeToCallFunctions()) {
230
0
    LLDB_LOGF(log, "Not safe to call functions on thread 0x%" PRIx64,
231
0
              thread.GetID());
232
0
    error.SetErrorString("Not safe to call functions on this thread.");
233
0
    return return_value;
234
0
  }
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
0
  CompilerType clang_void_ptr_type =
259
0
      clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
260
0
  Value return_buffer_ptr_value;
261
0
  return_buffer_ptr_value.SetValueType(Value::ValueType::Scalar);
262
0
  return_buffer_ptr_value.SetCompilerType(clang_void_ptr_type);
263
264
0
  CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
265
0
  Value debug_value;
266
0
  debug_value.SetValueType(Value::ValueType::Scalar);
267
0
  debug_value.SetCompilerType(clang_int_type);
268
269
0
  CompilerType clang_uint64_type =
270
0
      clang_ast_context->GetBasicType(eBasicTypeUnsignedLongLong);
271
0
  Value item_value;
272
0
  item_value.SetValueType(Value::ValueType::Scalar);
273
0
  item_value.SetCompilerType(clang_uint64_type);
274
275
0
  Value page_to_free_value;
276
0
  page_to_free_value.SetValueType(Value::ValueType::Scalar);
277
0
  page_to_free_value.SetCompilerType(clang_void_ptr_type);
278
279
0
  Value page_to_free_size_value;
280
0
  page_to_free_size_value.SetValueType(Value::ValueType::Scalar);
281
0
  page_to_free_size_value.SetCompilerType(clang_uint64_type);
282
283
0
  std::lock_guard<std::mutex> guard(m_get_item_info_retbuffer_mutex);
284
0
  if (m_get_item_info_return_buffer_addr == LLDB_INVALID_ADDRESS) {
285
0
    addr_t bufaddr = process_sp->AllocateMemory(
286
0
        32, ePermissionsReadable | ePermissionsWritable, error);
287
0
    if (!error.Success() || bufaddr == LLDB_INVALID_ADDRESS) {
288
0
      LLDB_LOGF(log, "Failed to allocate memory for return buffer for get "
289
0
                     "current queues func call");
290
0
      return return_value;
291
0
    }
292
0
    m_get_item_info_return_buffer_addr = bufaddr;
293
0
  }
294
295
0
  ValueList argument_values;
296
297
0
  return_buffer_ptr_value.GetScalar() = m_get_item_info_return_buffer_addr;
298
0
  argument_values.PushValue(return_buffer_ptr_value);
299
300
0
  debug_value.GetScalar() = 0;
301
0
  argument_values.PushValue(debug_value);
302
303
0
  item_value.GetScalar() = item;
304
0
  argument_values.PushValue(item_value);
305
306
0
  if (page_to_free != LLDB_INVALID_ADDRESS)
307
0
    page_to_free_value.GetScalar() = page_to_free;
308
0
  else
309
0
    page_to_free_value.GetScalar() = 0;
310
0
  argument_values.PushValue(page_to_free_value);
311
312
0
  page_to_free_size_value.GetScalar() = page_to_free_size;
313
0
  argument_values.PushValue(page_to_free_size_value);
314
315
0
  addr_t args_addr = SetupGetItemInfoFunction(thread, argument_values);
316
317
0
  DiagnosticManager diagnostics;
318
0
  ExecutionContext exe_ctx;
319
0
  EvaluateExpressionOptions options;
320
0
  options.SetUnwindOnError(true);
321
0
  options.SetIgnoreBreakpoints(true);
322
0
  options.SetStopOthers(true);
323
#if __has_feature(address_sanitizer)
324
  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
325
#else
326
0
  options.SetTimeout(std::chrono::milliseconds(500));
327
0
#endif
328
0
  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
329
0
  options.SetTryAllThreads(false);
330
0
  options.SetIsForUtilityExpr(true);
331
0
  thread.CalculateExecutionContext(exe_ctx);
332
333
0
  if (!m_get_item_info_impl_code) {
334
0
    error.SetErrorString("Unable to compile function to call "
335
0
                         "__introspection_dispatch_queue_item_get_info");
336
0
    return return_value;
337
0
  }
338
339
0
  ExpressionResults func_call_ret;
340
0
  Value results;
341
0
  FunctionCaller *func_caller = m_get_item_info_impl_code->GetFunctionCaller();
342
0
  if (!func_caller) {
343
0
    LLDB_LOGF(log, "Could not retrieve function caller for "
344
0
                   "__introspection_dispatch_queue_item_get_info.");
345
0
    error.SetErrorString("Could not retrieve function caller for "
346
0
                         "__introspection_dispatch_queue_item_get_info.");
347
0
    return return_value;
348
0
  }
349
350
0
  func_call_ret = func_caller->ExecuteFunction(exe_ctx, &args_addr, options,
351
0
                                               diagnostics, results);
352
0
  if (func_call_ret != eExpressionCompleted || !error.Success()) {
353
0
    LLDB_LOGF(log,
354
0
              "Unable to call "
355
0
              "__introspection_dispatch_queue_item_get_info(), got "
356
0
              "ExpressionResults %d, error contains %s",
357
0
              func_call_ret, error.AsCString(""));
358
0
    error.SetErrorString("Unable to call "
359
0
                         "__introspection_dispatch_queue_get_item_info() for "
360
0
                         "list of queues");
361
0
    return return_value;
362
0
  }
363
364
0
  return_value.item_buffer_ptr = m_process->ReadUnsignedIntegerFromMemory(
365
0
      m_get_item_info_return_buffer_addr, 8, LLDB_INVALID_ADDRESS, error);
366
0
  if (!error.Success() ||
367
0
      return_value.item_buffer_ptr == LLDB_INVALID_ADDRESS) {
368
0
    return_value.item_buffer_ptr = LLDB_INVALID_ADDRESS;
369
0
    return return_value;
370
0
  }
371
372
0
  return_value.item_buffer_size = m_process->ReadUnsignedIntegerFromMemory(
373
0
      m_get_item_info_return_buffer_addr + 8, 8, 0, error);
374
375
0
  if (!error.Success()) {
376
0
    return_value.item_buffer_ptr = LLDB_INVALID_ADDRESS;
377
0
    return return_value;
378
0
  }
379
0
  LLDB_LOGF(log,
380
0
            "AppleGetItemInfoHandler called "
381
0
            "__introspection_dispatch_queue_item_get_info (page_to_free == "
382
0
            "0x%" PRIx64 ", size = %" PRId64 "), returned page is at 0x%" PRIx64
383
0
            ", size %" PRId64,
384
0
            page_to_free, page_to_free_size, return_value.item_buffer_ptr,
385
0
            return_value.item_buffer_size);
386
387
0
  return return_value;
388
0
}