SystemRuntimeMacOSX.h

Go to the documentation of this file.

//===-- SystemRuntimeMacOSX.h -----------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#ifndef LLDB_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_SYSTEMRUNTIMEMACOSX_H
#define LLDB_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_SYSTEMRUNTIMEMACOSX_H
 
#include <mutex>
#include <string>
#include <vector>
 
// Other libraries and framework include
#include "lldb/Core/ModuleList.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/QueueItem.h"
#include "lldb/Target/SystemRuntime.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/StructuredData.h"
#include "lldb/Utility/UUID.h"
 
#include "AppleGetItemInfoHandler.h"
#include "AppleGetPendingItemsHandler.h"
#include "AppleGetQueuesHandler.h"
#include "AppleGetThreadItemInfoHandler.h"
 
class SystemRuntimeMacOSX : public lldb_private::SystemRuntime {
public:
  SystemRuntimeMacOSX(lldb_private::Process *process);
 
  ~SystemRuntimeMacOSX() override;
 
  // Static Functions
  static void Initialize();
 
  static void Terminate();
 
  static llvm::StringRef GetPluginNameStatic() {
    return "systemruntime-macosx";
  }
 
  static lldb_private::SystemRuntime *
  CreateInstance(lldb_private::Process *process);
 
  // instance methods
 
  void Clear(bool clear_process);
 
  void Detach() override;
 
  const std::vector<lldb_private::ConstString> &
  GetExtendedBacktraceTypes() override;
 
  lldb::ThreadSP
  GetExtendedBacktraceThread(lldb::ThreadSP thread,
                             lldb_private::ConstString type) override;
 
  lldb::ThreadSP
  GetExtendedBacktraceForQueueItem(lldb::QueueItemSP queue_item_sp,
                                   lldb_private::ConstString type) override;
 
  lldb::ThreadSP GetExtendedBacktraceFromItemRef(lldb::addr_t item_ref);
 
  void PopulateQueueList(lldb_private::QueueList &queue_list) override;
 
  void PopulateQueuesUsingLibBTR(lldb::addr_t queues_buffer,
                                 uint64_t queues_buffer_size, uint64_t count,
                                 lldb_private::QueueList &queue_list);
 
  void PopulatePendingQueuesUsingLibBTR(lldb::addr_t items_buffer,
                                        uint64_t items_buffer_size,
                                        uint64_t count,
                                        lldb_private::Queue *queue);
 
  std::string
  GetQueueNameFromThreadQAddress(lldb::addr_t dispatch_qaddr) override;
 
  lldb::queue_id_t
  GetQueueIDFromThreadQAddress(lldb::addr_t dispatch_qaddr) override;
 
  lldb::addr_t GetLibdispatchQueueAddressFromThreadQAddress(
      lldb::addr_t dispatch_qaddr) override;
 
  void PopulatePendingItemsForQueue(lldb_private::Queue *queue) override;
 
  void CompleteQueueItem(lldb_private::QueueItem *queue_item,
                         lldb::addr_t item_ref) override;
 
  lldb::QueueKind GetQueueKind(lldb::addr_t dispatch_queue_addr) override;
 
  void AddThreadExtendedInfoPacketHints(
      lldb_private::StructuredData::ObjectSP dict) override;
 
  bool SafeToCallFunctionsOnThisThread(lldb::ThreadSP thread_sp) override;
 
  // PluginInterface protocol
  llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
protected:
  lldb::user_id_t m_break_id;
  mutable std::recursive_mutex m_mutex;
 
private:
  struct libBacktraceRecording_info {
    uint16_t queue_info_version = 0;
    uint16_t queue_info_data_offset = 0;
    uint16_t item_info_version = 0;
    uint16_t item_info_data_offset = 0;
 
    libBacktraceRecording_info() = default;
  };
 
  // A structure which reflects the data recorded in the
  // libBacktraceRecording introspection_dispatch_item_info_s.
  struct ItemInfo {
    lldb::addr_t item_that_enqueued_this;
    lldb::addr_t function_or_block;
    uint64_t enqueuing_thread_id;
    uint64_t enqueuing_queue_serialnum;
    uint64_t target_queue_serialnum;
    uint32_t enqueuing_callstack_frame_count;
    uint32_t stop_id;
    std::vector<lldb::addr_t> enqueuing_callstack;
    std::string enqueuing_thread_label;
    std::string enqueuing_queue_label;
    std::string target_queue_label;
  };
 
  // The offsets of different fields of the dispatch_queue_t structure in
  // a thread/queue process.
  // Based on libdispatch src/queue_private.h, struct dispatch_queue_offsets_s
  // With dqo_version 1-3, the dqo_label field is a per-queue value and cannot
  // be cached.
  // With dqo_version 4 (Mac OS X 10.9 / iOS 7), dqo_label is a constant value
  // that can be cached.
  struct LibdispatchOffsets {
    uint16_t dqo_version;
    uint16_t dqo_label;
    uint16_t dqo_label_size;
    uint16_t dqo_flags;
    uint16_t dqo_flags_size;
    uint16_t dqo_serialnum;
    uint16_t dqo_serialnum_size;
    uint16_t dqo_width;
    uint16_t dqo_width_size;
    uint16_t dqo_running;
    uint16_t dqo_running_size;
 
    uint16_t dqo_suspend_cnt; // version 5 and later, starting with Mac OS X
                              // 10.10/iOS 8
    uint16_t dqo_suspend_cnt_size; // version 5 and later, starting with Mac OS
                                   // X 10.10/iOS 8
    uint16_t dqo_target_queue; // version 5 and later, starting with Mac OS X
                               // 10.10/iOS 8
    uint16_t dqo_target_queue_size; // version 5 and later, starting with Mac OS
                                    // X 10.10/iOS 8
    uint16_t
        dqo_priority; // version 5 and later, starting with Mac OS X 10.10/iOS 8
    uint16_t dqo_priority_size; // version 5 and later, starting with Mac OS X
                                // 10.10/iOS 8
 
    LibdispatchOffsets() {
      dqo_version = UINT16_MAX;
      dqo_flags = UINT16_MAX;
      dqo_serialnum = UINT16_MAX;
      dqo_label = UINT16_MAX;
      dqo_width = UINT16_MAX;
      dqo_running = UINT16_MAX;
      dqo_suspend_cnt = UINT16_MAX;
      dqo_target_queue = UINT16_MAX;
      dqo_target_queue = UINT16_MAX;
      dqo_priority = UINT16_MAX;
      dqo_label_size = 0;
      dqo_flags_size = 0;
      dqo_serialnum_size = 0;
      dqo_width_size = 0;
      dqo_running_size = 0;
      dqo_suspend_cnt_size = 0;
      dqo_target_queue_size = 0;
      dqo_priority_size = 0;
    }
 
    bool IsValid() { return dqo_version != UINT16_MAX; }
 
    bool LabelIsValid() { return dqo_label != UINT16_MAX; }
  };
 
  struct LibdispatchVoucherOffsets {
    uint16_t vo_version = UINT16_MAX;
    uint16_t vo_activity_ids_count = UINT16_MAX;
    uint16_t vo_activity_ids_count_size = UINT16_MAX;
    uint16_t vo_activity_ids_array = UINT16_MAX;
    uint16_t vo_activity_ids_array_entry_size = UINT16_MAX;
 
    LibdispatchVoucherOffsets() = default;
 
    bool IsValid() { return vo_version != UINT16_MAX; }
  };
 
  struct LibdispatchTSDIndexes {
    uint16_t dti_version = UINT16_MAX;
    uint64_t dti_queue_index = UINT64_MAX;
    uint64_t dti_voucher_index = UINT64_MAX;
    uint64_t dti_qos_class_index = UINT64_MAX;
 
    LibdispatchTSDIndexes() = default;
 
    bool IsValid() { return dti_version != UINT16_MAX; }
  };
 
  struct LibpthreadOffsets {
    uint16_t plo_version = UINT16_MAX;
    uint16_t plo_pthread_tsd_base_offset = UINT16_MAX;
    uint16_t plo_pthread_tsd_base_address_offset = UINT16_MAX;
    uint16_t plo_pthread_tsd_entry_size = UINT16_MAX;
 
    LibpthreadOffsets() = default;
 
    bool IsValid() { return plo_version != UINT16_MAX; }
  };
 
  // The libBacktraceRecording function
  // __introspection_dispatch_queue_get_pending_items has
  // two forms.  It can either return a simple array of item_refs (void *) size
  // or it can return
  // a header with uint32_t version, a uint32_t size of item, and then an array
  // of item_refs (void*)
  // and code addresses (void*) for all the pending blocks.
 
  struct ItemRefAndCodeAddress {
    lldb::addr_t item_ref;
    lldb::addr_t code_address;
  };
 
  struct PendingItemsForQueue {
    bool new_style; // new-style means both item_refs and code_addresses avail
                    // old-style means only item_refs is filled in
    std::vector<ItemRefAndCodeAddress> item_refs_and_code_addresses;
  };
 
  bool BacktraceRecordingHeadersInitialized();
 
  void ReadLibdispatchOffsetsAddress();
 
  void ReadLibdispatchOffsets();
 
  void ReadLibpthreadOffsetsAddress();
 
  void ReadLibpthreadOffsets();
 
  void ReadLibdispatchTSDIndexesAddress();
 
  void ReadLibdispatchTSDIndexes();
 
  PendingItemsForQueue GetPendingItemRefsForQueue(lldb::addr_t queue);
 
  ItemInfo ExtractItemInfoFromBuffer(lldb_private::DataExtractor &extractor);
 
  lldb_private::AppleGetQueuesHandler m_get_queues_handler;
  lldb_private::AppleGetPendingItemsHandler m_get_pending_items_handler;
  lldb_private::AppleGetItemInfoHandler m_get_item_info_handler;
  lldb_private::AppleGetThreadItemInfoHandler m_get_thread_item_info_handler;
 
  lldb::addr_t m_page_to_free;
  uint64_t m_page_to_free_size;
  libBacktraceRecording_info m_lib_backtrace_recording_info;
 
  lldb::addr_t m_dispatch_queue_offsets_addr;
  struct LibdispatchOffsets m_libdispatch_offsets;
 
  lldb::addr_t m_libpthread_layout_offsets_addr;
  struct LibpthreadOffsets m_libpthread_offsets;
 
  lldb::addr_t m_dispatch_tsd_indexes_addr;
  struct LibdispatchTSDIndexes m_libdispatch_tsd_indexes;
 
  lldb::addr_t m_dispatch_voucher_offsets_addr;
  struct LibdispatchVoucherOffsets m_libdispatch_voucher_offsets;
 
  SystemRuntimeMacOSX(const SystemRuntimeMacOSX &) = delete;
  const SystemRuntimeMacOSX &operator=(const SystemRuntimeMacOSX &) = delete;
};
 
#endif // LLDB_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_SYSTEMRUNTIMEMACOSX_H