| //===-- SystemRuntimeMacOSX.cpp ---------------------------------*- 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 |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "Plugins/Process/Utility/HistoryThread.h" |
| #include "lldb/Breakpoint/StoppointCallbackContext.h" |
| #include "lldb/Core/Module.h" |
| #include "lldb/Core/ModuleSpec.h" |
| #include "lldb/Core/PluginManager.h" |
| #include "lldb/Core/Section.h" |
| #include "lldb/Symbol/ClangASTContext.h" |
| #include "lldb/Symbol/ObjectFile.h" |
| #include "lldb/Symbol/SymbolContext.h" |
| #include "lldb/Target/Process.h" |
| #include "lldb/Target/ProcessStructReader.h" |
| #include "lldb/Target/Queue.h" |
| #include "lldb/Target/QueueList.h" |
| #include "lldb/Target/Target.h" |
| #include "lldb/Target/Thread.h" |
| #include "lldb/Utility/DataBufferHeap.h" |
| #include "lldb/Utility/DataExtractor.h" |
| #include "lldb/Utility/FileSpec.h" |
| #include "lldb/Utility/Log.h" |
| #include "lldb/Utility/StreamString.h" |
| |
| #include "SystemRuntimeMacOSX.h" |
| |
| #include <memory> |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| // Create an instance of this class. This function is filled into the plugin |
| // info class that gets handed out by the plugin factory and allows the lldb to |
| // instantiate an instance of this class. |
| SystemRuntime *SystemRuntimeMacOSX::CreateInstance(Process *process) { |
| bool create = false; |
| if (!create) { |
| create = true; |
| Module *exe_module = process->GetTarget().GetExecutableModulePointer(); |
| if (exe_module) { |
| ObjectFile *object_file = exe_module->GetObjectFile(); |
| if (object_file) { |
| create = (object_file->GetStrata() == ObjectFile::eStrataUser); |
| } |
| } |
| |
| if (create) { |
| const llvm::Triple &triple_ref = |
| process->GetTarget().GetArchitecture().GetTriple(); |
| switch (triple_ref.getOS()) { |
| case llvm::Triple::Darwin: |
| case llvm::Triple::MacOSX: |
| case llvm::Triple::IOS: |
| case llvm::Triple::TvOS: |
| case llvm::Triple::WatchOS: |
| // NEED_BRIDGEOS_TRIPLE case llvm::Triple::BridgeOS: |
| create = triple_ref.getVendor() == llvm::Triple::Apple; |
| break; |
| default: |
| create = false; |
| break; |
| } |
| } |
| } |
| |
| if (create) |
| return new SystemRuntimeMacOSX(process); |
| return nullptr; |
| } |
| |
| // Constructor |
| SystemRuntimeMacOSX::SystemRuntimeMacOSX(Process *process) |
| : SystemRuntime(process), m_break_id(LLDB_INVALID_BREAK_ID), m_mutex(), |
| m_get_queues_handler(process), m_get_pending_items_handler(process), |
| m_get_item_info_handler(process), m_get_thread_item_info_handler(process), |
| m_page_to_free(LLDB_INVALID_ADDRESS), m_page_to_free_size(0), |
| m_lib_backtrace_recording_info(), |
| m_dispatch_queue_offsets_addr(LLDB_INVALID_ADDRESS), |
| m_libdispatch_offsets(), |
| m_libpthread_layout_offsets_addr(LLDB_INVALID_ADDRESS), |
| m_libpthread_offsets(), m_dispatch_tsd_indexes_addr(LLDB_INVALID_ADDRESS), |
| m_libdispatch_tsd_indexes(), |
| m_dispatch_voucher_offsets_addr(LLDB_INVALID_ADDRESS), |
| m_libdispatch_voucher_offsets() {} |
| |
| // Destructor |
| SystemRuntimeMacOSX::~SystemRuntimeMacOSX() { Clear(true); } |
| |
| void SystemRuntimeMacOSX::Detach() { |
| m_get_queues_handler.Detach(); |
| m_get_pending_items_handler.Detach(); |
| m_get_item_info_handler.Detach(); |
| m_get_thread_item_info_handler.Detach(); |
| } |
| |
| // Clear out the state of this class. |
| void SystemRuntimeMacOSX::Clear(bool clear_process) { |
| std::lock_guard<std::recursive_mutex> guard(m_mutex); |
| |
| if (m_process->IsAlive() && LLDB_BREAK_ID_IS_VALID(m_break_id)) |
| m_process->ClearBreakpointSiteByID(m_break_id); |
| |
| if (clear_process) |
| m_process = nullptr; |
| m_break_id = LLDB_INVALID_BREAK_ID; |
| } |
| |
| std::string |
| SystemRuntimeMacOSX::GetQueueNameFromThreadQAddress(addr_t dispatch_qaddr) { |
| std::string dispatch_queue_name; |
| if (dispatch_qaddr == LLDB_INVALID_ADDRESS || dispatch_qaddr == 0) |
| return ""; |
| |
| ReadLibdispatchOffsets(); |
| if (m_libdispatch_offsets.IsValid()) { |
| // dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call for a |
| // thread - deref it to get the address of the dispatch_queue_t structure |
| // for this thread's queue. |
| Status error; |
| addr_t dispatch_queue_addr = |
| m_process->ReadPointerFromMemory(dispatch_qaddr, error); |
| if (error.Success()) { |
| if (m_libdispatch_offsets.dqo_version >= 4) { |
| // libdispatch versions 4+, pointer to dispatch name is in the queue |
| // structure. |
| addr_t pointer_to_label_address = |
| dispatch_queue_addr + m_libdispatch_offsets.dqo_label; |
| addr_t label_addr = |
| m_process->ReadPointerFromMemory(pointer_to_label_address, error); |
| if (error.Success()) { |
| m_process->ReadCStringFromMemory(label_addr, dispatch_queue_name, |
| error); |
| } |
| } else { |
| // libdispatch versions 1-3, dispatch name is a fixed width char array |
| // in the queue structure. |
| addr_t label_addr = |
| dispatch_queue_addr + m_libdispatch_offsets.dqo_label; |
| dispatch_queue_name.resize(m_libdispatch_offsets.dqo_label_size, '\0'); |
| size_t bytes_read = |
| m_process->ReadMemory(label_addr, &dispatch_queue_name[0], |
| m_libdispatch_offsets.dqo_label_size, error); |
| if (bytes_read < m_libdispatch_offsets.dqo_label_size) |
| dispatch_queue_name.erase(bytes_read); |
| } |
| } |
| } |
| return dispatch_queue_name; |
| } |
| |
| lldb::addr_t SystemRuntimeMacOSX::GetLibdispatchQueueAddressFromThreadQAddress( |
| addr_t dispatch_qaddr) { |
| addr_t libdispatch_queue_t_address = LLDB_INVALID_ADDRESS; |
| Status error; |
| libdispatch_queue_t_address = |
| m_process->ReadPointerFromMemory(dispatch_qaddr, error); |
| if (!error.Success()) { |
| libdispatch_queue_t_address = LLDB_INVALID_ADDRESS; |
| } |
| return libdispatch_queue_t_address; |
| } |
| |
| lldb::QueueKind SystemRuntimeMacOSX::GetQueueKind(addr_t dispatch_queue_addr) { |
| if (dispatch_queue_addr == LLDB_INVALID_ADDRESS || dispatch_queue_addr == 0) |
| return eQueueKindUnknown; |
| |
| QueueKind kind = eQueueKindUnknown; |
| ReadLibdispatchOffsets(); |
| if (m_libdispatch_offsets.IsValid() && |
| m_libdispatch_offsets.dqo_version >= 4) { |
| Status error; |
| uint64_t width = m_process->ReadUnsignedIntegerFromMemory( |
| dispatch_queue_addr + m_libdispatch_offsets.dqo_width, |
| m_libdispatch_offsets.dqo_width_size, 0, error); |
| if (error.Success()) { |
| if (width == 1) { |
| kind = eQueueKindSerial; |
| } |
| if (width > 1) { |
| kind = eQueueKindConcurrent; |
| } |
| } |
| } |
| return kind; |
| } |
| |
| void SystemRuntimeMacOSX::AddThreadExtendedInfoPacketHints( |
| lldb_private::StructuredData::ObjectSP dict_sp) { |
| StructuredData::Dictionary *dict = dict_sp->GetAsDictionary(); |
| if (dict) { |
| ReadLibpthreadOffsets(); |
| if (m_libpthread_offsets.IsValid()) { |
| dict->AddIntegerItem("plo_pthread_tsd_base_offset", |
| m_libpthread_offsets.plo_pthread_tsd_base_offset); |
| dict->AddIntegerItem( |
| "plo_pthread_tsd_base_address_offset", |
| m_libpthread_offsets.plo_pthread_tsd_base_address_offset); |
| dict->AddIntegerItem("plo_pthread_tsd_entry_size", |
| m_libpthread_offsets.plo_pthread_tsd_entry_size); |
| } |
| |
| ReadLibdispatchTSDIndexes(); |
| if (m_libdispatch_tsd_indexes.IsValid()) { |
| dict->AddIntegerItem("dti_queue_index", |
| m_libdispatch_tsd_indexes.dti_queue_index); |
| dict->AddIntegerItem("dti_voucher_index", |
| m_libdispatch_tsd_indexes.dti_voucher_index); |
| dict->AddIntegerItem("dti_qos_class_index", |
| m_libdispatch_tsd_indexes.dti_qos_class_index); |
| } |
| } |
| } |
| |
| bool SystemRuntimeMacOSX::SafeToCallFunctionsOnThisThread(ThreadSP thread_sp) { |
| if (thread_sp && thread_sp->GetStackFrameCount() > 0 && |
| thread_sp->GetFrameWithConcreteFrameIndex(0)) { |
| const SymbolContext sym_ctx( |
| thread_sp->GetFrameWithConcreteFrameIndex(0)->GetSymbolContext( |
| eSymbolContextSymbol)); |
| static ConstString g_select_symbol("__select"); |
| if (sym_ctx.GetFunctionName() == g_select_symbol) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| lldb::queue_id_t |
| SystemRuntimeMacOSX::GetQueueIDFromThreadQAddress(lldb::addr_t dispatch_qaddr) { |
| queue_id_t queue_id = LLDB_INVALID_QUEUE_ID; |
| |
| if (dispatch_qaddr == LLDB_INVALID_ADDRESS || dispatch_qaddr == 0) |
| return queue_id; |
| |
| ReadLibdispatchOffsets(); |
| if (m_libdispatch_offsets.IsValid()) { |
| // dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call for a |
| // thread - deref it to get the address of the dispatch_queue_t structure |
| // for this thread's queue. |
| Status error; |
| uint64_t dispatch_queue_addr = |
| m_process->ReadPointerFromMemory(dispatch_qaddr, error); |
| if (error.Success()) { |
| addr_t serialnum_address = |
| dispatch_queue_addr + m_libdispatch_offsets.dqo_serialnum; |
| queue_id_t serialnum = m_process->ReadUnsignedIntegerFromMemory( |
| serialnum_address, m_libdispatch_offsets.dqo_serialnum_size, |
| LLDB_INVALID_QUEUE_ID, error); |
| if (error.Success()) { |
| queue_id = serialnum; |
| } |
| } |
| } |
| |
| return queue_id; |
| } |
| |
| void SystemRuntimeMacOSX::ReadLibdispatchOffsetsAddress() { |
| if (m_dispatch_queue_offsets_addr != LLDB_INVALID_ADDRESS) |
| return; |
| |
| static ConstString g_dispatch_queue_offsets_symbol_name( |
| "dispatch_queue_offsets"); |
| const Symbol *dispatch_queue_offsets_symbol = nullptr; |
| |
| // libdispatch symbols were in libSystem.B.dylib up through Mac OS X 10.6 |
| // ("Snow Leopard") |
| ModuleSpec libSystem_module_spec(FileSpec("libSystem.B.dylib")); |
| ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule( |
| libSystem_module_spec)); |
| if (module_sp) |
| dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType( |
| g_dispatch_queue_offsets_symbol_name, eSymbolTypeData); |
| |
| // libdispatch symbols are in their own dylib as of Mac OS X 10.7 ("Lion") |
| // and later |
| if (dispatch_queue_offsets_symbol == nullptr) { |
| ModuleSpec libdispatch_module_spec(FileSpec("libdispatch.dylib")); |
| module_sp = m_process->GetTarget().GetImages().FindFirstModule( |
| libdispatch_module_spec); |
| if (module_sp) |
| dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType( |
| g_dispatch_queue_offsets_symbol_name, eSymbolTypeData); |
| } |
| if (dispatch_queue_offsets_symbol) |
| m_dispatch_queue_offsets_addr = |
| dispatch_queue_offsets_symbol->GetLoadAddress(&m_process->GetTarget()); |
| } |
| |
| void SystemRuntimeMacOSX::ReadLibdispatchOffsets() { |
| if (m_libdispatch_offsets.IsValid()) |
| return; |
| |
| ReadLibdispatchOffsetsAddress(); |
| |
| uint8_t memory_buffer[sizeof(struct LibdispatchOffsets)]; |
| DataExtractor data(memory_buffer, sizeof(memory_buffer), |
| m_process->GetByteOrder(), |
| m_process->GetAddressByteSize()); |
| |
| Status error; |
| if (m_process->ReadMemory(m_dispatch_queue_offsets_addr, memory_buffer, |
| sizeof(memory_buffer), |
| error) == sizeof(memory_buffer)) { |
| lldb::offset_t data_offset = 0; |
| |
| // The struct LibdispatchOffsets is a series of uint16_t's - extract them |
| // all in one big go. |
| data.GetU16(&data_offset, &m_libdispatch_offsets.dqo_version, |
| sizeof(struct LibdispatchOffsets) / sizeof(uint16_t)); |
| } |
| } |
| |
| void SystemRuntimeMacOSX::ReadLibpthreadOffsetsAddress() { |
| if (m_libpthread_layout_offsets_addr != LLDB_INVALID_ADDRESS) |
| return; |
| |
| static ConstString g_libpthread_layout_offsets_symbol_name( |
| "pthread_layout_offsets"); |
| const Symbol *libpthread_layout_offsets_symbol = nullptr; |
| |
| ModuleSpec libpthread_module_spec(FileSpec("libsystem_pthread.dylib")); |
| ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule( |
| libpthread_module_spec)); |
| if (module_sp) { |
| libpthread_layout_offsets_symbol = |
| module_sp->FindFirstSymbolWithNameAndType( |
| g_libpthread_layout_offsets_symbol_name, eSymbolTypeData); |
| if (libpthread_layout_offsets_symbol) { |
| m_libpthread_layout_offsets_addr = |
| libpthread_layout_offsets_symbol->GetLoadAddress( |
| &m_process->GetTarget()); |
| } |
| } |
| } |
| |
| void SystemRuntimeMacOSX::ReadLibpthreadOffsets() { |
| if (m_libpthread_offsets.IsValid()) |
| return; |
| |
| ReadLibpthreadOffsetsAddress(); |
| |
| if (m_libpthread_layout_offsets_addr != LLDB_INVALID_ADDRESS) { |
| uint8_t memory_buffer[sizeof(struct LibpthreadOffsets)]; |
| DataExtractor data(memory_buffer, sizeof(memory_buffer), |
| m_process->GetByteOrder(), |
| m_process->GetAddressByteSize()); |
| Status error; |
| if (m_process->ReadMemory(m_libpthread_layout_offsets_addr, memory_buffer, |
| sizeof(memory_buffer), |
| error) == sizeof(memory_buffer)) { |
| lldb::offset_t data_offset = 0; |
| |
| // The struct LibpthreadOffsets is a series of uint16_t's - extract them |
| // all in one big go. |
| data.GetU16(&data_offset, &m_libpthread_offsets.plo_version, |
| sizeof(struct LibpthreadOffsets) / sizeof(uint16_t)); |
| } |
| } |
| } |
| |
| void SystemRuntimeMacOSX::ReadLibdispatchTSDIndexesAddress() { |
| if (m_dispatch_tsd_indexes_addr != LLDB_INVALID_ADDRESS) |
| return; |
| |
| static ConstString g_libdispatch_tsd_indexes_symbol_name( |
| "dispatch_tsd_indexes"); |
| const Symbol *libdispatch_tsd_indexes_symbol = nullptr; |
| |
| ModuleSpec libpthread_module_spec(FileSpec("libdispatch.dylib")); |
| ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule( |
| libpthread_module_spec)); |
| if (module_sp) { |
| libdispatch_tsd_indexes_symbol = module_sp->FindFirstSymbolWithNameAndType( |
| g_libdispatch_tsd_indexes_symbol_name, eSymbolTypeData); |
| if (libdispatch_tsd_indexes_symbol) { |
| m_dispatch_tsd_indexes_addr = |
| libdispatch_tsd_indexes_symbol->GetLoadAddress( |
| &m_process->GetTarget()); |
| } |
| } |
| } |
| |
| void SystemRuntimeMacOSX::ReadLibdispatchTSDIndexes() { |
| if (m_libdispatch_tsd_indexes.IsValid()) |
| return; |
| |
| ReadLibdispatchTSDIndexesAddress(); |
| |
| if (m_dispatch_tsd_indexes_addr != LLDB_INVALID_ADDRESS) { |
| |
| // We don't need to check the version number right now, it will be at least 2, |
| // but keep this code around to fetch just the version # for the future where |
| // we need to fetch alternate versions of the struct. |
| #if 0 |
| uint16_t dti_version = 2; |
| Address dti_struct_addr; |
| if (m_process->GetTarget().ResolveLoadAddress (m_dispatch_tsd_indexes_addr, dti_struct_addr)) |
| { |
| Status error; |
| uint16_t version = m_process->GetTarget().ReadUnsignedIntegerFromMemory (dti_struct_addr, false, 2, UINT16_MAX, error); |
| if (error.Success() && dti_version != UINT16_MAX) |
| { |
| dti_version = version; |
| } |
| } |
| #endif |
| |
| ClangASTContext *ast_ctx = |
| m_process->GetTarget().GetScratchClangASTContext(); |
| if (ast_ctx->getASTContext() && |
| m_dispatch_tsd_indexes_addr != LLDB_INVALID_ADDRESS) { |
| CompilerType uint16 = |
| ast_ctx->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 16); |
| CompilerType dispatch_tsd_indexes_s = ast_ctx->CreateRecordType( |
| nullptr, lldb::eAccessPublic, "__lldb_dispatch_tsd_indexes_s", |
| clang::TTK_Struct, lldb::eLanguageTypeC); |
| |
| ClangASTContext::StartTagDeclarationDefinition(dispatch_tsd_indexes_s); |
| ClangASTContext::AddFieldToRecordType(dispatch_tsd_indexes_s, |
| "dti_version", uint16, |
| lldb::eAccessPublic, 0); |
| ClangASTContext::AddFieldToRecordType(dispatch_tsd_indexes_s, |
| "dti_queue_index", uint16, |
| lldb::eAccessPublic, 0); |
| ClangASTContext::AddFieldToRecordType(dispatch_tsd_indexes_s, |
| "dti_voucher_index", uint16, |
| lldb::eAccessPublic, 0); |
| ClangASTContext::AddFieldToRecordType(dispatch_tsd_indexes_s, |
| "dti_qos_class_index", uint16, |
| lldb::eAccessPublic, 0); |
| ClangASTContext::CompleteTagDeclarationDefinition(dispatch_tsd_indexes_s); |
| |
| ProcessStructReader struct_reader(m_process, m_dispatch_tsd_indexes_addr, |
| dispatch_tsd_indexes_s); |
| |
| m_libdispatch_tsd_indexes.dti_version = |
| struct_reader.GetField<uint16_t>(ConstString("dti_version")); |
| m_libdispatch_tsd_indexes.dti_queue_index = |
| struct_reader.GetField<uint16_t>(ConstString("dti_queue_index")); |
| m_libdispatch_tsd_indexes.dti_voucher_index = |
| struct_reader.GetField<uint16_t>(ConstString("dti_voucher_index")); |
| m_libdispatch_tsd_indexes.dti_qos_class_index = |
| struct_reader.GetField<uint16_t>(ConstString("dti_qos_class_index")); |
| } |
| } |
| } |
| |
| ThreadSP SystemRuntimeMacOSX::GetExtendedBacktraceThread(ThreadSP real_thread, |
| ConstString type) { |
| ThreadSP originating_thread_sp; |
| if (BacktraceRecordingHeadersInitialized() && type == "libdispatch") { |
| Status error; |
| |
| // real_thread is either an actual, live thread (in which case we need to |
| // call into libBacktraceRecording to find its originator) or it is an |
| // extended backtrace itself, in which case we get the token from it and |
| // call into libBacktraceRecording to find the originator of that token. |
| |
| if (real_thread->GetExtendedBacktraceToken() != LLDB_INVALID_ADDRESS) { |
| originating_thread_sp = GetExtendedBacktraceFromItemRef( |
| real_thread->GetExtendedBacktraceToken()); |
| } else { |
| ThreadSP cur_thread_sp( |
| m_process->GetThreadList().GetExpressionExecutionThread()); |
| AppleGetThreadItemInfoHandler::GetThreadItemInfoReturnInfo ret = |
| m_get_thread_item_info_handler.GetThreadItemInfo( |
| *cur_thread_sp.get(), real_thread->GetID(), m_page_to_free, |
| m_page_to_free_size, error); |
| m_page_to_free = LLDB_INVALID_ADDRESS; |
| m_page_to_free_size = 0; |
| if (ret.item_buffer_ptr != 0 && |
| ret.item_buffer_ptr != LLDB_INVALID_ADDRESS && |
| ret.item_buffer_size > 0) { |
| DataBufferHeap data(ret.item_buffer_size, 0); |
| if (m_process->ReadMemory(ret.item_buffer_ptr, data.GetBytes(), |
| ret.item_buffer_size, error) && |
| error.Success()) { |
| DataExtractor extractor(data.GetBytes(), data.GetByteSize(), |
| m_process->GetByteOrder(), |
| m_process->GetAddressByteSize()); |
| ItemInfo item = ExtractItemInfoFromBuffer(extractor); |
| originating_thread_sp = std::make_shared<HistoryThread>( |
| *m_process, item.enqueuing_thread_id, item.enqueuing_callstack); |
| originating_thread_sp->SetExtendedBacktraceToken( |
| item.item_that_enqueued_this); |
| originating_thread_sp->SetQueueName( |
| item.enqueuing_queue_label.c_str()); |
| originating_thread_sp->SetQueueID(item.enqueuing_queue_serialnum); |
| // originating_thread_sp->SetThreadName |
| // (item.enqueuing_thread_label.c_str()); |
| } |
| m_page_to_free = ret.item_buffer_ptr; |
| m_page_to_free_size = ret.item_buffer_size; |
| } |
| } |
| } |
| return originating_thread_sp; |
| } |
| |
| ThreadSP |
| SystemRuntimeMacOSX::GetExtendedBacktraceFromItemRef(lldb::addr_t item_ref) { |
| ThreadSP return_thread_sp; |
| |
| AppleGetItemInfoHandler::GetItemInfoReturnInfo ret; |
| ThreadSP cur_thread_sp( |
| m_process->GetThreadList().GetExpressionExecutionThread()); |
| Status error; |
| ret = m_get_item_info_handler.GetItemInfo(*cur_thread_sp.get(), item_ref, |
| m_page_to_free, m_page_to_free_size, |
| error); |
| m_page_to_free = LLDB_INVALID_ADDRESS; |
| m_page_to_free_size = 0; |
| if (ret.item_buffer_ptr != 0 && ret.item_buffer_ptr != LLDB_INVALID_ADDRESS && |
| ret.item_buffer_size > 0) { |
| DataBufferHeap data(ret.item_buffer_size, 0); |
| if (m_process->ReadMemory(ret.item_buffer_ptr, data.GetBytes(), |
| ret.item_buffer_size, error) && |
| error.Success()) { |
| DataExtractor extractor(data.GetBytes(), data.GetByteSize(), |
| m_process->GetByteOrder(), |
| m_process->GetAddressByteSize()); |
| ItemInfo item = ExtractItemInfoFromBuffer(extractor); |
| return_thread_sp = std::make_shared<HistoryThread>( |
| *m_process, item.enqueuing_thread_id, item.enqueuing_callstack); |
| return_thread_sp->SetExtendedBacktraceToken(item.item_that_enqueued_this); |
| return_thread_sp->SetQueueName(item.enqueuing_queue_label.c_str()); |
| return_thread_sp->SetQueueID(item.enqueuing_queue_serialnum); |
| // return_thread_sp->SetThreadName |
| // (item.enqueuing_thread_label.c_str()); |
| |
| m_page_to_free = ret.item_buffer_ptr; |
| m_page_to_free_size = ret.item_buffer_size; |
| } |
| } |
| return return_thread_sp; |
| } |
| |
| ThreadSP |
| SystemRuntimeMacOSX::GetExtendedBacktraceForQueueItem(QueueItemSP queue_item_sp, |
| ConstString type) { |
| ThreadSP extended_thread_sp; |
| if (type != "libdispatch") |
| return extended_thread_sp; |
| |
| extended_thread_sp = std::make_shared<HistoryThread>( |
| *m_process, queue_item_sp->GetEnqueueingThreadID(), |
| queue_item_sp->GetEnqueueingBacktrace()); |
| extended_thread_sp->SetExtendedBacktraceToken( |
| queue_item_sp->GetItemThatEnqueuedThis()); |
| extended_thread_sp->SetQueueName(queue_item_sp->GetQueueLabel().c_str()); |
| extended_thread_sp->SetQueueID(queue_item_sp->GetEnqueueingQueueID()); |
| // extended_thread_sp->SetThreadName |
| // (queue_item_sp->GetThreadLabel().c_str()); |
| |
| return extended_thread_sp; |
| } |
| |
| /* Returns true if we were able to get the version / offset information |
| * out of libBacktraceRecording. false means we were unable to retrieve |
| * this; the queue_info_version field will be 0. |
| */ |
| |
| bool SystemRuntimeMacOSX::BacktraceRecordingHeadersInitialized() { |
| if (m_lib_backtrace_recording_info.queue_info_version != 0) |
| return true; |
| |
| addr_t queue_info_version_address = LLDB_INVALID_ADDRESS; |
| addr_t queue_info_data_offset_address = LLDB_INVALID_ADDRESS; |
| addr_t item_info_version_address = LLDB_INVALID_ADDRESS; |
| addr_t item_info_data_offset_address = LLDB_INVALID_ADDRESS; |
| Target &target = m_process->GetTarget(); |
| |
| static ConstString introspection_dispatch_queue_info_version( |
| "__introspection_dispatch_queue_info_version"); |
| SymbolContextList sc_list; |
| if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType( |
| introspection_dispatch_queue_info_version, eSymbolTypeData, sc_list) > |
| 0) { |
| SymbolContext sc; |
| sc_list.GetContextAtIndex(0, sc); |
| AddressRange addr_range; |
| sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range); |
| queue_info_version_address = |
| addr_range.GetBaseAddress().GetLoadAddress(&target); |
| } |
| sc_list.Clear(); |
| |
| static ConstString introspection_dispatch_queue_info_data_offset( |
| "__introspection_dispatch_queue_info_data_offset"); |
| if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType( |
| introspection_dispatch_queue_info_data_offset, eSymbolTypeData, |
| sc_list) > 0) { |
| SymbolContext sc; |
| sc_list.GetContextAtIndex(0, sc); |
| AddressRange addr_range; |
| sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range); |
| queue_info_data_offset_address = |
| addr_range.GetBaseAddress().GetLoadAddress(&target); |
| } |
| sc_list.Clear(); |
| |
| static ConstString introspection_dispatch_item_info_version( |
| "__introspection_dispatch_item_info_version"); |
| if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType( |
| introspection_dispatch_item_info_version, eSymbolTypeData, sc_list) > |
| 0) { |
| SymbolContext sc; |
| sc_list.GetContextAtIndex(0, sc); |
| AddressRange addr_range; |
| sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range); |
| item_info_version_address = |
| addr_range.GetBaseAddress().GetLoadAddress(&target); |
| } |
| sc_list.Clear(); |
| |
| static ConstString introspection_dispatch_item_info_data_offset( |
| "__introspection_dispatch_item_info_data_offset"); |
| if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType( |
| introspection_dispatch_item_info_data_offset, eSymbolTypeData, |
| sc_list) > 0) { |
| SymbolContext sc; |
| sc_list.GetContextAtIndex(0, sc); |
| AddressRange addr_range; |
| sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range); |
| item_info_data_offset_address = |
| addr_range.GetBaseAddress().GetLoadAddress(&target); |
| } |
| |
| if (queue_info_version_address != LLDB_INVALID_ADDRESS && |
| queue_info_data_offset_address != LLDB_INVALID_ADDRESS && |
| item_info_version_address != LLDB_INVALID_ADDRESS && |
| item_info_data_offset_address != LLDB_INVALID_ADDRESS) { |
| Status error; |
| m_lib_backtrace_recording_info.queue_info_version = |
| m_process->ReadUnsignedIntegerFromMemory(queue_info_version_address, 2, |
| 0, error); |
| if (error.Success()) { |
| m_lib_backtrace_recording_info.queue_info_data_offset = |
| m_process->ReadUnsignedIntegerFromMemory( |
| queue_info_data_offset_address, 2, 0, error); |
| if (error.Success()) { |
| m_lib_backtrace_recording_info.item_info_version = |
| m_process->ReadUnsignedIntegerFromMemory(item_info_version_address, |
| 2, 0, error); |
| if (error.Success()) { |
| m_lib_backtrace_recording_info.item_info_data_offset = |
| m_process->ReadUnsignedIntegerFromMemory( |
| item_info_data_offset_address, 2, 0, error); |
| if (!error.Success()) { |
| m_lib_backtrace_recording_info.queue_info_version = 0; |
| } |
| } else { |
| m_lib_backtrace_recording_info.queue_info_version = 0; |
| } |
| } else { |
| m_lib_backtrace_recording_info.queue_info_version = 0; |
| } |
| } |
| } |
| |
| return m_lib_backtrace_recording_info.queue_info_version != 0; |
| } |
| |
| const std::vector<ConstString> & |
| SystemRuntimeMacOSX::GetExtendedBacktraceTypes() { |
| if (m_types.size() == 0) { |
| m_types.push_back(ConstString("libdispatch")); |
| // We could have pthread as another type in the future if we have a way of |
| // gathering that information & it's useful to distinguish between them. |
| } |
| return m_types; |
| } |
| |
| void SystemRuntimeMacOSX::PopulateQueueList( |
| lldb_private::QueueList &queue_list) { |
| if (BacktraceRecordingHeadersInitialized()) { |
| AppleGetQueuesHandler::GetQueuesReturnInfo queue_info_pointer; |
| ThreadSP cur_thread_sp( |
| m_process->GetThreadList().GetExpressionExecutionThread()); |
| if (cur_thread_sp) { |
| Status error; |
| queue_info_pointer = m_get_queues_handler.GetCurrentQueues( |
| *cur_thread_sp.get(), m_page_to_free, m_page_to_free_size, error); |
| m_page_to_free = LLDB_INVALID_ADDRESS; |
| m_page_to_free_size = 0; |
| if (error.Success()) { |
| |
| if (queue_info_pointer.count > 0 && |
| queue_info_pointer.queues_buffer_size > 0 && |
| queue_info_pointer.queues_buffer_ptr != 0 && |
| queue_info_pointer.queues_buffer_ptr != LLDB_INVALID_ADDRESS) { |
| PopulateQueuesUsingLibBTR(queue_info_pointer.queues_buffer_ptr, |
| queue_info_pointer.queues_buffer_size, |
| queue_info_pointer.count, queue_list); |
| } |
| } |
| } |
| } |
| |
| // We either didn't have libBacktraceRecording (and need to create the queues |
| // list based on threads) or we did get the queues list from |
| // libBacktraceRecording but some special queues may not be included in its |
| // information. This is needed because libBacktraceRecording will only list |
| // queues with pending or running items by default - but the magic com.apple |
| // .main-thread queue on thread 1 is always around. |
| |
| for (ThreadSP thread_sp : m_process->Threads()) { |
| if (thread_sp->GetAssociatedWithLibdispatchQueue() != eLazyBoolNo) { |
| if (thread_sp->GetQueueID() != LLDB_INVALID_QUEUE_ID) { |
| if (queue_list.FindQueueByID(thread_sp->GetQueueID()).get() == |
| nullptr) { |
| QueueSP queue_sp(new Queue(m_process->shared_from_this(), |
| thread_sp->GetQueueID(), |
| thread_sp->GetQueueName())); |
| if (thread_sp->ThreadHasQueueInformation()) { |
| queue_sp->SetKind(thread_sp->GetQueueKind()); |
| queue_sp->SetLibdispatchQueueAddress( |
| thread_sp->GetQueueLibdispatchQueueAddress()); |
| queue_list.AddQueue(queue_sp); |
| } else { |
| queue_sp->SetKind( |
| GetQueueKind(thread_sp->GetQueueLibdispatchQueueAddress())); |
| queue_sp->SetLibdispatchQueueAddress( |
| thread_sp->GetQueueLibdispatchQueueAddress()); |
| queue_list.AddQueue(queue_sp); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // Returns either an array of introspection_dispatch_item_info_ref's for the |
| // pending items on a queue or an array introspection_dispatch_item_info_ref's |
| // and code addresses for the pending items on a queue. The information about |
| // each of these pending items then needs to be fetched individually by passing |
| // the ref to libBacktraceRecording. |
| |
| SystemRuntimeMacOSX::PendingItemsForQueue |
| SystemRuntimeMacOSX::GetPendingItemRefsForQueue(lldb::addr_t queue) { |
| PendingItemsForQueue pending_item_refs; |
| AppleGetPendingItemsHandler::GetPendingItemsReturnInfo pending_items_pointer; |
| ThreadSP cur_thread_sp( |
| m_process->GetThreadList().GetExpressionExecutionThread()); |
| if (cur_thread_sp) { |
| Status error; |
| pending_items_pointer = m_get_pending_items_handler.GetPendingItems( |
| *cur_thread_sp.get(), queue, m_page_to_free, m_page_to_free_size, |
| error); |
| m_page_to_free = LLDB_INVALID_ADDRESS; |
| m_page_to_free_size = 0; |
| if (error.Success()) { |
| if (pending_items_pointer.count > 0 && |
| pending_items_pointer.items_buffer_size > 0 && |
| pending_items_pointer.items_buffer_ptr != 0 && |
| pending_items_pointer.items_buffer_ptr != LLDB_INVALID_ADDRESS) { |
| DataBufferHeap data(pending_items_pointer.items_buffer_size, 0); |
| if (m_process->ReadMemory( |
| pending_items_pointer.items_buffer_ptr, data.GetBytes(), |
| pending_items_pointer.items_buffer_size, error)) { |
| DataExtractor extractor(data.GetBytes(), data.GetByteSize(), |
| m_process->GetByteOrder(), |
| m_process->GetAddressByteSize()); |
| |
| // We either have an array of |
| // void* item_ref |
| // (old style) or we have a structure returned which looks like |
| // |
| // struct introspection_dispatch_pending_item_info_s { |
| // void *item_ref; |
| // void *function_or_block; |
| // }; |
| // |
| // struct introspection_dispatch_pending_items_array_s { |
| // uint32_t version; |
| // uint32_t size_of_item_info; |
| // introspection_dispatch_pending_item_info_s items[]; |
| // } |
| |
| offset_t offset = 0; |
| int i = 0; |
| uint32_t version = extractor.GetU32(&offset); |
| if (version == 1) { |
| pending_item_refs.new_style = true; |
| uint32_t item_size = extractor.GetU32(&offset); |
| uint32_t start_of_array_offset = offset; |
| while (offset < pending_items_pointer.items_buffer_size && |
| static_cast<size_t>(i) < pending_items_pointer.count) { |
| offset = start_of_array_offset + (i * item_size); |
| ItemRefAndCodeAddress item; |
| item.item_ref = extractor.GetPointer(&offset); |
| item.code_address = extractor.GetPointer(&offset); |
| pending_item_refs.item_refs_and_code_addresses.push_back(item); |
| i++; |
| } |
| } else { |
| offset = 0; |
| pending_item_refs.new_style = false; |
| while (offset < pending_items_pointer.items_buffer_size && |
| static_cast<size_t>(i) < pending_items_pointer.count) { |
| ItemRefAndCodeAddress item; |
| item.item_ref = extractor.GetPointer(&offset); |
| item.code_address = LLDB_INVALID_ADDRESS; |
| pending_item_refs.item_refs_and_code_addresses.push_back(item); |
| i++; |
| } |
| } |
| } |
| m_page_to_free = pending_items_pointer.items_buffer_ptr; |
| m_page_to_free_size = pending_items_pointer.items_buffer_size; |
| } |
| } |
| } |
| return pending_item_refs; |
| } |
| |
| void SystemRuntimeMacOSX::PopulatePendingItemsForQueue(Queue *queue) { |
| if (BacktraceRecordingHeadersInitialized()) { |
| PendingItemsForQueue pending_item_refs = |
| GetPendingItemRefsForQueue(queue->GetLibdispatchQueueAddress()); |
| for (ItemRefAndCodeAddress pending_item : |
| pending_item_refs.item_refs_and_code_addresses) { |
| Address addr; |
| m_process->GetTarget().ResolveLoadAddress(pending_item.code_address, |
| addr); |
| QueueItemSP queue_item_sp(new QueueItem(queue->shared_from_this(), |
| m_process->shared_from_this(), |
| pending_item.item_ref, addr)); |
| queue->PushPendingQueueItem(queue_item_sp); |
| } |
| } |
| } |
| |
| void SystemRuntimeMacOSX::CompleteQueueItem(QueueItem *queue_item, |
| addr_t item_ref) { |
| AppleGetItemInfoHandler::GetItemInfoReturnInfo ret; |
| |
| ThreadSP cur_thread_sp( |
| m_process->GetThreadList().GetExpressionExecutionThread()); |
| Status error; |
| ret = m_get_item_info_handler.GetItemInfo(*cur_thread_sp.get(), item_ref, |
| m_page_to_free, m_page_to_free_size, |
| error); |
| m_page_to_free = LLDB_INVALID_ADDRESS; |
| m_page_to_free_size = 0; |
| if (ret.item_buffer_ptr != 0 && ret.item_buffer_ptr != LLDB_INVALID_ADDRESS && |
| ret.item_buffer_size > 0) { |
| DataBufferHeap data(ret.item_buffer_size, 0); |
| if (m_process->ReadMemory(ret.item_buffer_ptr, data.GetBytes(), |
| ret.item_buffer_size, error) && |
| error.Success()) { |
| DataExtractor extractor(data.GetBytes(), data.GetByteSize(), |
| m_process->GetByteOrder(), |
| m_process->GetAddressByteSize()); |
| ItemInfo item = ExtractItemInfoFromBuffer(extractor); |
| queue_item->SetItemThatEnqueuedThis(item.item_that_enqueued_this); |
| queue_item->SetEnqueueingThreadID(item.enqueuing_thread_id); |
| queue_item->SetEnqueueingQueueID(item.enqueuing_queue_serialnum); |
| queue_item->SetStopID(item.stop_id); |
| queue_item->SetEnqueueingBacktrace(item.enqueuing_callstack); |
| queue_item->SetThreadLabel(item.enqueuing_thread_label); |
| queue_item->SetQueueLabel(item.enqueuing_queue_label); |
| queue_item->SetTargetQueueLabel(item.target_queue_label); |
| } |
| m_page_to_free = ret.item_buffer_ptr; |
| m_page_to_free_size = ret.item_buffer_size; |
| } |
| } |
| |
| void SystemRuntimeMacOSX::PopulateQueuesUsingLibBTR( |
| lldb::addr_t queues_buffer, uint64_t queues_buffer_size, uint64_t count, |
| lldb_private::QueueList &queue_list) { |
| Status error; |
| DataBufferHeap data(queues_buffer_size, 0); |
| Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME)); |
| if (m_process->ReadMemory(queues_buffer, data.GetBytes(), queues_buffer_size, |
| error) == queues_buffer_size && |
| error.Success()) { |
| // We've read the information out of inferior memory; free it on the next |
| // call we make |
| m_page_to_free = queues_buffer; |
| m_page_to_free_size = queues_buffer_size; |
| |
| DataExtractor extractor(data.GetBytes(), data.GetByteSize(), |
| m_process->GetByteOrder(), |
| m_process->GetAddressByteSize()); |
| offset_t offset = 0; |
| uint64_t queues_read = 0; |
| |
| // The information about the queues is stored in this format (v1): typedef |
| // struct introspection_dispatch_queue_info_s { |
| // uint32_t offset_to_next; |
| // dispatch_queue_t queue; |
| // uint64_t serialnum; // queue's serialnum in the process, as |
| // provided by libdispatch |
| // uint32_t running_work_items_count; |
| // uint32_t pending_work_items_count; |
| // |
| // char data[]; // Starting here, we have variable-length data: |
| // // char queue_label[]; |
| // } introspection_dispatch_queue_info_s; |
| |
| while (queues_read < count && offset < queues_buffer_size) { |
| offset_t start_of_this_item = offset; |
| |
| uint32_t offset_to_next = extractor.GetU32(&offset); |
| |
| offset += 4; // Skip over the 4 bytes of reserved space |
| addr_t queue = extractor.GetPointer(&offset); |
| uint64_t serialnum = extractor.GetU64(&offset); |
| uint32_t running_work_items_count = extractor.GetU32(&offset); |
| uint32_t pending_work_items_count = extractor.GetU32(&offset); |
| |
| // Read the first field of the variable length data |
| offset = start_of_this_item + |
| m_lib_backtrace_recording_info.queue_info_data_offset; |
| const char *queue_label = extractor.GetCStr(&offset); |
| if (queue_label == nullptr) |
| queue_label = ""; |
| |
| offset_t start_of_next_item = start_of_this_item + offset_to_next; |
| offset = start_of_next_item; |
| |
| if (log) |
| log->Printf("SystemRuntimeMacOSX::PopulateQueuesUsingLibBTR added " |
| "queue with dispatch_queue_t 0x%" PRIx64 |
| ", serial number 0x%" PRIx64 |
| ", running items %d, pending items %d, name '%s'", |
| queue, serialnum, running_work_items_count, |
| pending_work_items_count, queue_label); |
| |
| QueueSP queue_sp( |
| new Queue(m_process->shared_from_this(), serialnum, queue_label)); |
| queue_sp->SetNumRunningWorkItems(running_work_items_count); |
| queue_sp->SetNumPendingWorkItems(pending_work_items_count); |
| queue_sp->SetLibdispatchQueueAddress(queue); |
| queue_sp->SetKind(GetQueueKind(queue)); |
| queue_list.AddQueue(queue_sp); |
| queues_read++; |
| } |
| } |
| } |
| |
| SystemRuntimeMacOSX::ItemInfo SystemRuntimeMacOSX::ExtractItemInfoFromBuffer( |
| lldb_private::DataExtractor &extractor) { |
| ItemInfo item; |
| |
| offset_t offset = 0; |
| |
| item.item_that_enqueued_this = extractor.GetPointer(&offset); |
| item.function_or_block = extractor.GetPointer(&offset); |
| item.enqueuing_thread_id = extractor.GetU64(&offset); |
| item.enqueuing_queue_serialnum = extractor.GetU64(&offset); |
| item.target_queue_serialnum = extractor.GetU64(&offset); |
| item.enqueuing_callstack_frame_count = extractor.GetU32(&offset); |
| item.stop_id = extractor.GetU32(&offset); |
| |
| offset = m_lib_backtrace_recording_info.item_info_data_offset; |
| |
| for (uint32_t i = 0; i < item.enqueuing_callstack_frame_count; i++) { |
| item.enqueuing_callstack.push_back(extractor.GetPointer(&offset)); |
| } |
| item.enqueuing_thread_label = extractor.GetCStr(&offset); |
| item.enqueuing_queue_label = extractor.GetCStr(&offset); |
| item.target_queue_label = extractor.GetCStr(&offset); |
| |
| return item; |
| } |
| |
| void SystemRuntimeMacOSX::Initialize() { |
| PluginManager::RegisterPlugin(GetPluginNameStatic(), |
| GetPluginDescriptionStatic(), CreateInstance); |
| } |
| |
| void SystemRuntimeMacOSX::Terminate() { |
| PluginManager::UnregisterPlugin(CreateInstance); |
| } |
| |
| lldb_private::ConstString SystemRuntimeMacOSX::GetPluginNameStatic() { |
| static ConstString g_name("systemruntime-macosx"); |
| return g_name; |
| } |
| |
| const char *SystemRuntimeMacOSX::GetPluginDescriptionStatic() { |
| return "System runtime plugin for Mac OS X native libraries."; |
| } |
| |
| // PluginInterface protocol |
| lldb_private::ConstString SystemRuntimeMacOSX::GetPluginName() { |
| return GetPluginNameStatic(); |
| } |
| |
| uint32_t SystemRuntimeMacOSX::GetPluginVersion() { return 1; } |
