Coverage Report

Created: 2022-01-22 13:19

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp
Line
Count
Source (jump to first uncovered line)
1
//===-- AppleGetQueuesHandler.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 "AppleGetQueuesHandler.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 *AppleGetQueuesHandler::g_get_current_queues_function_name =
30
    "__lldb_backtrace_recording_get_current_queues";
31
const char *AppleGetQueuesHandler::g_get_current_queues_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 *introspection_dispatch_queue_info_t;                                                          \n\
56
                                                                                                                \n\
57
    extern uint64_t __introspection_dispatch_get_queues (queue_list_scope_t scope,                              \n\
58
                                                 introspection_dispatch_queue_info_t *returned_queues_buffer,   \n\
59
                                                 uint64_t *returned_queues_buffer_size);                        \n\
60
    extern int printf(const char *format, ...);                                                                 \n\
61
                                                                                                                \n\
62
    /*                                                                                                          \n\
63
     * return type define                                                                                       \n\
64
     */                                                                                                         \n\
65
                                                                                                                \n\
66
    struct get_current_queues_return_values                                                                     \n\
67
    {                                                                                                           \n\
68
        uint64_t queues_buffer_ptr;    /* the address of the queues buffer from libBacktraceRecording */        \n\
69
        uint64_t queues_buffer_size;   /* the size of the queues buffer from libBacktraceRecording */           \n\
70
        uint64_t count;                /* the number of queues included in the queues buffer */                 \n\
71
    };                                                                                                          \n\
72
                                                                                                                \n\
73
    void  __lldb_backtrace_recording_get_current_queues                                                         \n\
74
                                               (struct get_current_queues_return_values *return_buffer,         \n\
75
                                                int debug,                                                      \n\
76
                                                void *page_to_free,                                             \n\
77
                                                uint64_t page_to_free_size)                                     \n\
78
{                                                                                                               \n\
79
    if (debug)                                                                                                  \n\
80
      printf (\"entering get_current_queues with args %p, %d, 0x%p, 0x%llx\\n\", return_buffer, debug, page_to_free, page_to_free_size); \n\
81
    if (page_to_free != 0)                                                                                      \n\
82
    {                                                                                                           \n\
83
        mach_vm_deallocate (mach_task_self(), (mach_vm_address_t) page_to_free, (mach_vm_size_t) page_to_free_size); \n\
84
    }                                                                                                           \n\
85
                                                                                                                \n\
86
    return_buffer->count = __introspection_dispatch_get_queues (                                                \n\
87
                                                      /* QUEUES_WITH_ANY_ITEMS */ 2,                            \n\
88
                                                      (void**)&return_buffer->queues_buffer_ptr,                \n\
89
                                                      &return_buffer->queues_buffer_size);                      \n\
90
    if (debug)                                                                                                  \n\
91
        printf(\"result was count %lld\\n\", return_buffer->count);                                             \n\
92
}                                                                                                               \n\
93
}                                                                                                               \n\
94
";
95
96
AppleGetQueuesHandler::AppleGetQueuesHandler(Process *process)
97
    : m_process(process), m_get_queues_impl_code_up(),
98
      m_get_queues_function_mutex(),
99
      m_get_queues_return_buffer_addr(LLDB_INVALID_ADDRESS),
100
2.60k
      m_get_queues_retbuffer_mutex() {}
101
102
2.60k
AppleGetQueuesHandler::~AppleGetQueuesHandler() = default;
103
104
0
void AppleGetQueuesHandler::Detach() {
105
106
0
  if (m_process && m_process->IsAlive() &&
107
0
      m_get_queues_return_buffer_addr != LLDB_INVALID_ADDRESS) {
108
0
    std::unique_lock<std::mutex> lock(m_get_queues_retbuffer_mutex,
109
0
                                      std::defer_lock);
110
0
    (void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
111
0
    m_process->DeallocateMemory(m_get_queues_return_buffer_addr);
112
0
  }
113
0
}
114
115
// Construct a CompilerType for the structure that
116
// g_get_current_queues_function_code will return by value so we can extract
117
// the fields after performing the function call. i.e. we are getting this
118
// struct returned to us:
119
//
120
//    struct get_current_queues_return_values
121
//    {
122
//        introspection_dispatch_queue_info_t *queues_buffer;
123
//        uint64_t queues_buffer_size;
124
//        uint64_t count;
125
//    };
126
127
// Compile our __lldb_backtrace_recording_get_current_queues() function (from
128
// the source above in g_get_current_queues_function_code) if we don't find
129
// that function in the inferior already with USE_BUILTIN_FUNCTION defined.
130
// (e.g. this would be the case for testing.)
131
//
132
// Insert the __lldb_backtrace_recording_get_current_queues into the inferior
133
// process if needed.
134
//
135
// Write the get_queues_arglist into the inferior's memory space to prepare for
136
// the call.
137
//
138
// Returns the address of the arguments written down in the inferior process,
139
// which can be used to make the function call.
140
141
lldb::addr_t
142
AppleGetQueuesHandler::SetupGetQueuesFunction(Thread &thread,
143
0
                                              ValueList &get_queues_arglist) {
144
0
  ThreadSP thread_sp(thread.shared_from_this());
145
0
  ExecutionContext exe_ctx(thread_sp);
146
147
0
  Address impl_code_address;
148
0
  DiagnosticManager diagnostics;
149
0
  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
150
0
  lldb::addr_t args_addr = LLDB_INVALID_ADDRESS;
151
152
0
  FunctionCaller *get_queues_caller = nullptr;
153
154
  // Scope for mutex locker:
155
0
  {
156
0
    std::lock_guard<std::mutex> guard(m_get_queues_function_mutex);
157
158
    // First stage is to make the ClangUtility to hold our injected function:
159
160
0
    if (!m_get_queues_impl_code_up) {
161
0
      if (g_get_current_queues_function_code != nullptr) {
162
0
        auto utility_fn_or_error = exe_ctx.GetTargetRef().CreateUtilityFunction(
163
0
            g_get_current_queues_function_code,
164
0
            g_get_current_queues_function_name, eLanguageTypeC, exe_ctx);
165
0
        if (!utility_fn_or_error) {
166
0
          LLDB_LOG_ERROR(log, utility_fn_or_error.takeError(),
167
0
                         "Failed to create UtilityFunction for queues "
168
0
                         "introspection: {0}.");
169
0
          return args_addr;
170
0
        }
171
0
        m_get_queues_impl_code_up = std::move(*utility_fn_or_error);
172
0
      } else {
173
0
        if (log) {
174
0
          LLDB_LOGF(log, "No queues introspection code found.");
175
0
          diagnostics.Dump(log);
176
0
        }
177
0
        return LLDB_INVALID_ADDRESS;
178
0
      }
179
0
    }
180
181
    // Next make the runner function for our implementation utility function.
182
0
    TypeSystemClang *clang_ast_context =
183
0
        ScratchTypeSystemClang::GetForTarget(thread.GetProcess()->GetTarget());
184
0
    CompilerType get_queues_return_type =
185
0
        clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
186
0
    Status error;
187
0
    get_queues_caller = m_get_queues_impl_code_up->MakeFunctionCaller(
188
0
        get_queues_return_type, get_queues_arglist, thread_sp, error);
189
0
    if (error.Fail() || get_queues_caller == nullptr) {
190
0
      LLDB_LOGF(log,
191
0
                "Could not get function caller for get-queues function: %s.",
192
0
                error.AsCString());
193
0
      return args_addr;
194
0
    }
195
0
  }
196
197
0
  diagnostics.Clear();
198
199
  // Now write down the argument values for this particular call.  This looks
200
  // like it might be a race condition if other threads were calling into here,
201
  // but actually it isn't because we allocate a new args structure for this
202
  // call by passing args_addr = LLDB_INVALID_ADDRESS...
203
204
0
  if (!get_queues_caller->WriteFunctionArguments(
205
0
          exe_ctx, args_addr, get_queues_arglist, diagnostics)) {
206
0
    if (log) {
207
0
      LLDB_LOGF(log, "Error writing get-queues function arguments.");
208
0
      diagnostics.Dump(log);
209
0
    }
210
0
    return args_addr;
211
0
  }
212
213
0
  return args_addr;
214
0
}
215
216
AppleGetQueuesHandler::GetQueuesReturnInfo
217
AppleGetQueuesHandler::GetCurrentQueues(Thread &thread, addr_t page_to_free,
218
                                        uint64_t page_to_free_size,
219
0
                                        Status &error) {
220
0
  lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
221
0
  ProcessSP process_sp(thread.CalculateProcess());
222
0
  TargetSP target_sp(thread.CalculateTarget());
223
0
  TypeSystemClang *clang_ast_context =
224
0
      ScratchTypeSystemClang::GetForTarget(*target_sp);
225
0
  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
226
227
0
  GetQueuesReturnInfo return_value;
228
0
  return_value.queues_buffer_ptr = LLDB_INVALID_ADDRESS;
229
0
  return_value.queues_buffer_size = 0;
230
0
  return_value.count = 0;
231
232
0
  error.Clear();
233
234
0
  if (!thread.SafeToCallFunctions()) {
235
0
    LLDB_LOGF(log, "Not safe to call functions on thread 0x%" PRIx64,
236
0
              thread.GetID());
237
0
    error.SetErrorString("Not safe to call functions on this thread.");
238
0
    return return_value;
239
0
  }
240
241
  // Set up the arguments for a call to
242
243
  // struct get_current_queues_return_values
244
  // {
245
  //    uint64_t queues_buffer_ptr;    /* the address of the queues buffer from
246
  //    libBacktraceRecording */
247
  //    uint64_t queues_buffer_size;   /* the size of the queues buffer from
248
  //    libBacktraceRecording */
249
  //    uint64_t count;                /* the number of queues included in the
250
  //    queues buffer */
251
  // };
252
  //
253
  //  void
254
  //    __lldb_backtrace_recording_get_current_queues
255
  //                                         (struct
256
  //                                         get_current_queues_return_values
257
  //                                         *return_buffer,
258
  //                                          void *page_to_free,
259
  //                                          uint64_t page_to_free_size);
260
261
  // Where the return_buffer argument points to a 24 byte region of memory
262
  // already allocated by lldb in the inferior process.
263
264
0
  CompilerType clang_void_ptr_type =
265
0
      clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
266
0
  Value return_buffer_ptr_value;
267
0
  return_buffer_ptr_value.SetValueType(Value::ValueType::Scalar);
268
0
  return_buffer_ptr_value.SetCompilerType(clang_void_ptr_type);
269
270
0
  CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
271
0
  Value debug_value;
272
0
  debug_value.SetValueType(Value::ValueType::Scalar);
273
0
  debug_value.SetCompilerType(clang_int_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
  CompilerType clang_uint64_type =
280
0
      clang_ast_context->GetBasicType(eBasicTypeUnsignedLongLong);
281
0
  Value page_to_free_size_value;
282
0
  page_to_free_size_value.SetValueType(Value::ValueType::Scalar);
283
0
  page_to_free_size_value.SetCompilerType(clang_uint64_type);
284
285
0
  std::lock_guard<std::mutex> guard(m_get_queues_retbuffer_mutex);
286
0
  if (m_get_queues_return_buffer_addr == LLDB_INVALID_ADDRESS) {
287
0
    addr_t bufaddr = process_sp->AllocateMemory(
288
0
        32, ePermissionsReadable | ePermissionsWritable, error);
289
0
    if (!error.Success() || bufaddr == LLDB_INVALID_ADDRESS) {
290
0
      LLDB_LOGF(log, "Failed to allocate memory for return buffer for get "
291
0
                     "current queues func call");
292
0
      return return_value;
293
0
    }
294
0
    m_get_queues_return_buffer_addr = bufaddr;
295
0
  }
296
297
0
  ValueList argument_values;
298
299
0
  return_buffer_ptr_value.GetScalar() = m_get_queues_return_buffer_addr;
300
0
  argument_values.PushValue(return_buffer_ptr_value);
301
302
0
  debug_value.GetScalar() = 0;
303
0
  argument_values.PushValue(debug_value);
304
305
0
  if (page_to_free != LLDB_INVALID_ADDRESS)
306
0
    page_to_free_value.GetScalar() = page_to_free;
307
0
  else
308
0
    page_to_free_value.GetScalar() = 0;
309
0
  argument_values.PushValue(page_to_free_value);
310
311
0
  page_to_free_size_value.GetScalar() = page_to_free_size;
312
0
  argument_values.PushValue(page_to_free_size_value);
313
314
0
  addr_t args_addr = SetupGetQueuesFunction(thread, argument_values);
315
316
0
  if (!m_get_queues_impl_code_up) {
317
0
    error.SetErrorString(
318
0
        "Unable to compile __introspection_dispatch_get_queues.");
319
0
    return return_value;
320
0
  }
321
322
0
  FunctionCaller *get_queues_caller =
323
0
      m_get_queues_impl_code_up->GetFunctionCaller();
324
325
0
  if (get_queues_caller == nullptr) {
326
0
    error.SetErrorString(
327
0
        "Unable to get caller for call __introspection_dispatch_get_queues");
328
0
    return return_value;
329
0
  }
330
331
0
  DiagnosticManager diagnostics;
332
0
  ExecutionContext exe_ctx;
333
0
  EvaluateExpressionOptions options;
334
0
  options.SetUnwindOnError(true);
335
0
  options.SetIgnoreBreakpoints(true);
336
0
  options.SetStopOthers(true);
337
#if __has_feature(address_sanitizer)
338
  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
339
#else
340
0
  options.SetTimeout(std::chrono::milliseconds(500));
341
0
#endif
342
0
  options.SetTryAllThreads(false);
343
0
  options.SetIsForUtilityExpr(true);
344
0
  thread.CalculateExecutionContext(exe_ctx);
345
346
0
  ExpressionResults func_call_ret;
347
0
  Value results;
348
0
  func_call_ret = get_queues_caller->ExecuteFunction(
349
0
      exe_ctx, &args_addr, options, diagnostics, results);
350
0
  if (func_call_ret != eExpressionCompleted || !error.Success()) {
351
0
    LLDB_LOGF(log,
352
0
              "Unable to call introspection_get_dispatch_queues(), got "
353
0
              "ExpressionResults %d, error contains %s",
354
0
              func_call_ret, error.AsCString(""));
355
0
    error.SetErrorString("Unable to call introspection_get_dispatch_queues() "
356
0
                         "for list of queues");
357
0
    return return_value;
358
0
  }
359
360
0
  return_value.queues_buffer_ptr = m_process->ReadUnsignedIntegerFromMemory(
361
0
      m_get_queues_return_buffer_addr, 8, LLDB_INVALID_ADDRESS, error);
362
0
  if (!error.Success() ||
363
0
      return_value.queues_buffer_ptr == LLDB_INVALID_ADDRESS) {
364
0
    return_value.queues_buffer_ptr = LLDB_INVALID_ADDRESS;
365
0
    return return_value;
366
0
  }
367
368
0
  return_value.queues_buffer_size = m_process->ReadUnsignedIntegerFromMemory(
369
0
      m_get_queues_return_buffer_addr + 8, 8, 0, error);
370
371
0
  if (!error.Success()) {
372
0
    return_value.queues_buffer_ptr = LLDB_INVALID_ADDRESS;
373
0
    return return_value;
374
0
  }
375
376
0
  return_value.count = m_process->ReadUnsignedIntegerFromMemory(
377
0
      m_get_queues_return_buffer_addr + 16, 8, 0, error);
378
0
  if (!error.Success()) {
379
0
    return_value.queues_buffer_ptr = LLDB_INVALID_ADDRESS;
380
0
    return return_value;
381
0
  }
382
383
0
  LLDB_LOGF(log,
384
0
            "AppleGetQueuesHandler called "
385
0
            "__introspection_dispatch_get_queues (page_to_free == "
386
0
            "0x%" PRIx64 ", size = %" PRId64 "), returned page is at 0x%" PRIx64
387
0
            ", size %" PRId64 ", count = %" PRId64,
388
0
            page_to_free, page_to_free_size, return_value.queues_buffer_ptr,
389
0
            return_value.queues_buffer_size, return_value.count);
390
391
0
  return return_value;
392
0
}