Coverage Report

Created: 2022-01-22 13:19

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