LLDB mainline
SystemRuntimeMacOSX.cpp
Go to the documentation of this file.
1//===-- SystemRuntimeMacOSX.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
12#include "lldb/Core/Module.h"
15#include "lldb/Core/Section.h"
18#include "lldb/Target/Process.h"
20#include "lldb/Target/Queue.h"
22#include "lldb/Target/Target.h"
23#include "lldb/Target/Thread.h"
28#include "lldb/Utility/Log.h"
30
31#include "SystemRuntimeMacOSX.h"
32
33#include <memory>
34
35using namespace lldb;
36using namespace lldb_private;
37
39
40// Create an instance of this class. This function is filled into the plugin
41// info class that gets handed out by the plugin factory and allows the lldb to
42// instantiate an instance of this class.
43SystemRuntime *SystemRuntimeMacOSX::CreateInstance(Process *process) {
44 bool create = false;
45 if (!create) {
46 create = true;
47 Module *exe_module = process->GetTarget().GetExecutableModulePointer();
48 if (exe_module) {
49 ObjectFile *object_file = exe_module->GetObjectFile();
50 if (object_file) {
51 create = (object_file->GetStrata() == ObjectFile::eStrataUser);
52 }
53 }
54
55 if (create) {
56 const llvm::Triple &triple_ref =
57 process->GetTarget().GetArchitecture().GetTriple();
58 switch (triple_ref.getOS()) {
59 case llvm::Triple::Darwin:
60 case llvm::Triple::MacOSX:
61 case llvm::Triple::IOS:
62 case llvm::Triple::TvOS:
63 case llvm::Triple::WatchOS:
64 // NEED_BRIDGEOS_TRIPLE case llvm::Triple::BridgeOS:
65 create = triple_ref.getVendor() == llvm::Triple::Apple;
66 break;
67 default:
68 create = false;
69 break;
70 }
71 }
72 }
73
74 if (create)
75 return new SystemRuntimeMacOSX(process);
76 return nullptr;
77}
78
79// Constructor
81 : SystemRuntime(process), m_break_id(LLDB_INVALID_BREAK_ID), m_mutex(),
82 m_get_queues_handler(process), m_get_pending_items_handler(process),
83 m_get_item_info_handler(process), m_get_thread_item_info_handler(process),
84 m_page_to_free(LLDB_INVALID_ADDRESS), m_page_to_free_size(0),
85 m_lib_backtrace_recording_info(),
86 m_dispatch_queue_offsets_addr(LLDB_INVALID_ADDRESS),
87 m_libdispatch_offsets(),
88 m_libpthread_layout_offsets_addr(LLDB_INVALID_ADDRESS),
89 m_libpthread_offsets(), m_dispatch_tsd_indexes_addr(LLDB_INVALID_ADDRESS),
90 m_libdispatch_tsd_indexes(),
91 m_dispatch_voucher_offsets_addr(LLDB_INVALID_ADDRESS),
92 m_libdispatch_voucher_offsets() {}
93
94// Destructor
96
102}
103
104// Clear out the state of this class.
105void SystemRuntimeMacOSX::Clear(bool clear_process) {
106 std::lock_guard<std::recursive_mutex> guard(m_mutex);
107
110
111 if (clear_process)
112 m_process = nullptr;
114}
115
116std::string
118 std::string dispatch_queue_name;
119 if (dispatch_qaddr == LLDB_INVALID_ADDRESS || dispatch_qaddr == 0)
120 return "";
121
124 // dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call for a
125 // thread - deref it to get the address of the dispatch_queue_t structure
126 // for this thread's queue.
128 addr_t dispatch_queue_addr =
129 m_process->ReadPointerFromMemory(dispatch_qaddr, error);
130 if (error.Success()) {
132 // libdispatch versions 4+, pointer to dispatch name is in the queue
133 // structure.
134 addr_t pointer_to_label_address =
135 dispatch_queue_addr + m_libdispatch_offsets.dqo_label;
136 addr_t label_addr =
137 m_process->ReadPointerFromMemory(pointer_to_label_address, error);
138 if (error.Success()) {
139 m_process->ReadCStringFromMemory(label_addr, dispatch_queue_name,
140 error);
141 }
142 } else {
143 // libdispatch versions 1-3, dispatch name is a fixed width char array
144 // in the queue structure.
145 addr_t label_addr =
146 dispatch_queue_addr + m_libdispatch_offsets.dqo_label;
147 dispatch_queue_name.resize(m_libdispatch_offsets.dqo_label_size, '\0');
148 size_t bytes_read =
149 m_process->ReadMemory(label_addr, &dispatch_queue_name[0],
151 if (bytes_read < m_libdispatch_offsets.dqo_label_size)
152 dispatch_queue_name.erase(bytes_read);
153 }
154 }
155 }
156 return dispatch_queue_name;
157}
158
160 addr_t dispatch_qaddr) {
161 addr_t libdispatch_queue_t_address = LLDB_INVALID_ADDRESS;
163 libdispatch_queue_t_address =
164 m_process->ReadPointerFromMemory(dispatch_qaddr, error);
165 if (!error.Success()) {
166 libdispatch_queue_t_address = LLDB_INVALID_ADDRESS;
167 }
168 return libdispatch_queue_t_address;
169}
170
172 if (dispatch_queue_addr == LLDB_INVALID_ADDRESS || dispatch_queue_addr == 0)
173 return eQueueKindUnknown;
174
181 dispatch_queue_addr + m_libdispatch_offsets.dqo_width,
183 if (error.Success()) {
184 if (width == 1) {
185 kind = eQueueKindSerial;
186 }
187 if (width > 1) {
189 }
190 }
191 }
192 return kind;
193}
194
198 if (dict) {
201 dict->AddIntegerItem("plo_pthread_tsd_base_offset",
203 dict->AddIntegerItem(
204 "plo_pthread_tsd_base_address_offset",
206 dict->AddIntegerItem("plo_pthread_tsd_entry_size",
208 }
209
212 dict->AddIntegerItem("dti_queue_index",
214 dict->AddIntegerItem("dti_voucher_index",
216 dict->AddIntegerItem("dti_qos_class_index",
218 }
219 }
220}
221
223 if (thread_sp && thread_sp->GetFrameWithConcreteFrameIndex(0)) {
224 const SymbolContext sym_ctx(
225 thread_sp->GetFrameWithConcreteFrameIndex(0)->GetSymbolContext(
226 eSymbolContextSymbol));
227 static ConstString g_select_symbol("__select");
228 if (sym_ctx.GetFunctionName() == g_select_symbol) {
229 return false;
230 }
231 }
232 return true;
233}
234
238
239 if (dispatch_qaddr == LLDB_INVALID_ADDRESS || dispatch_qaddr == 0)
240 return queue_id;
241
244 // dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call for a
245 // thread - deref it to get the address of the dispatch_queue_t structure
246 // for this thread's queue.
248 uint64_t dispatch_queue_addr =
249 m_process->ReadPointerFromMemory(dispatch_qaddr, error);
250 if (error.Success()) {
251 addr_t serialnum_address =
252 dispatch_queue_addr + m_libdispatch_offsets.dqo_serialnum;
254 serialnum_address, m_libdispatch_offsets.dqo_serialnum_size,
256 if (error.Success()) {
257 queue_id = serialnum;
258 }
259 }
260 }
261
262 return queue_id;
263}
264
267 return;
268
269 static ConstString g_dispatch_queue_offsets_symbol_name(
270 "dispatch_queue_offsets");
271 const Symbol *dispatch_queue_offsets_symbol = nullptr;
272
273 // libdispatch symbols were in libSystem.B.dylib up through Mac OS X 10.6
274 // ("Snow Leopard")
275 ModuleSpec libSystem_module_spec(FileSpec("libSystem.B.dylib"));
277 libSystem_module_spec));
278 if (module_sp)
279 dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType(
280 g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
281
282 // libdispatch symbols are in their own dylib as of Mac OS X 10.7 ("Lion")
283 // and later
284 if (dispatch_queue_offsets_symbol == nullptr) {
285 ModuleSpec libdispatch_module_spec(FileSpec("libdispatch.dylib"));
287 libdispatch_module_spec);
288 if (module_sp)
289 dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType(
290 g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
291 }
292 if (dispatch_queue_offsets_symbol)
294 dispatch_queue_offsets_symbol->GetLoadAddress(&m_process->GetTarget());
295}
296
299 return;
300
302
303 uint8_t memory_buffer[sizeof(struct LibdispatchOffsets)];
304 DataExtractor data(memory_buffer, sizeof(memory_buffer),
307
310 sizeof(memory_buffer),
311 error) == sizeof(memory_buffer)) {
312 lldb::offset_t data_offset = 0;
313
314 // The struct LibdispatchOffsets is a series of uint16_t's - extract them
315 // all in one big go.
316 data.GetU16(&data_offset, &m_libdispatch_offsets.dqo_version,
317 sizeof(struct LibdispatchOffsets) / sizeof(uint16_t));
318 }
319}
320
323 return;
324
325 static ConstString g_libpthread_layout_offsets_symbol_name(
326 "pthread_layout_offsets");
327 const Symbol *libpthread_layout_offsets_symbol = nullptr;
328
329 ModuleSpec libpthread_module_spec(FileSpec("libsystem_pthread.dylib"));
331 libpthread_module_spec));
332 if (module_sp) {
333 libpthread_layout_offsets_symbol =
334 module_sp->FindFirstSymbolWithNameAndType(
335 g_libpthread_layout_offsets_symbol_name, eSymbolTypeData);
336 if (libpthread_layout_offsets_symbol) {
338 libpthread_layout_offsets_symbol->GetLoadAddress(
339 &m_process->GetTarget());
340 }
341 }
342}
343
346 return;
347
349
351 uint8_t memory_buffer[sizeof(struct LibpthreadOffsets)];
352 DataExtractor data(memory_buffer, sizeof(memory_buffer),
357 sizeof(memory_buffer),
358 error) == sizeof(memory_buffer)) {
359 lldb::offset_t data_offset = 0;
360
361 // The struct LibpthreadOffsets is a series of uint16_t's - extract them
362 // all in one big go.
363 data.GetU16(&data_offset, &m_libpthread_offsets.plo_version,
364 sizeof(struct LibpthreadOffsets) / sizeof(uint16_t));
365 }
366 }
367}
368
371 return;
372
373 static ConstString g_libdispatch_tsd_indexes_symbol_name(
374 "dispatch_tsd_indexes");
375 const Symbol *libdispatch_tsd_indexes_symbol = nullptr;
376
377 ModuleSpec libpthread_module_spec(FileSpec("libdispatch.dylib"));
379 libpthread_module_spec));
380 if (module_sp) {
381 libdispatch_tsd_indexes_symbol = module_sp->FindFirstSymbolWithNameAndType(
382 g_libdispatch_tsd_indexes_symbol_name, eSymbolTypeData);
383 if (libdispatch_tsd_indexes_symbol) {
385 libdispatch_tsd_indexes_symbol->GetLoadAddress(
386 &m_process->GetTarget());
387 }
388 }
389}
390
393 return;
394
396
398
399// We don't need to check the version number right now, it will be at least 2,
400// but keep this code around to fetch just the version # for the future where
401// we need to fetch alternate versions of the struct.
402#if 0
403 uint16_t dti_version = 2;
404 Address dti_struct_addr;
406 {
408 uint16_t version = m_process->GetTarget().ReadUnsignedIntegerFromMemory (dti_struct_addr, false, 2, UINT16_MAX, error);
409 if (error.Success() && dti_version != UINT16_MAX)
410 {
411 dti_version = version;
412 }
413 }
414#endif
415
416 TypeSystemClangSP scratch_ts_sp =
419 CompilerType uint16 =
420 scratch_ts_sp->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 16);
421 CompilerType dispatch_tsd_indexes_s = scratch_ts_sp->CreateRecordType(
423 "__lldb_dispatch_tsd_indexes_s",
424 llvm::to_underlying(clang::TagTypeKind::Struct),
426
428 TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
429 "dti_version", uint16,
431 TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
432 "dti_queue_index", uint16,
434 TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
435 "dti_voucher_index", uint16,
437 TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
438 "dti_qos_class_index", uint16,
441
443 dispatch_tsd_indexes_s);
444
446 struct_reader.GetField<uint16_t>("dti_version");
448 struct_reader.GetField<uint16_t>("dti_queue_index");
450 struct_reader.GetField<uint16_t>("dti_voucher_index");
452 struct_reader.GetField<uint16_t>("dti_qos_class_index");
453 }
454 }
455}
456
458 ConstString type) {
459 ThreadSP originating_thread_sp;
460 if (BacktraceRecordingHeadersInitialized() && type == "libdispatch") {
462
463 // real_thread is either an actual, live thread (in which case we need to
464 // call into libBacktraceRecording to find its originator) or it is an
465 // extended backtrace itself, in which case we get the token from it and
466 // call into libBacktraceRecording to find the originator of that token.
467
468 if (real_thread->GetExtendedBacktraceToken() != LLDB_INVALID_ADDRESS) {
469 originating_thread_sp = GetExtendedBacktraceFromItemRef(
470 real_thread->GetExtendedBacktraceToken());
471 } else {
472 ThreadSP cur_thread_sp(
476 *cur_thread_sp.get(), real_thread->GetID(), m_page_to_free,
480 if (ret.item_buffer_ptr != 0 &&
482 ret.item_buffer_size > 0) {
483 DataBufferHeap data(ret.item_buffer_size, 0);
485 ret.item_buffer_size, error) &&
486 error.Success()) {
487 DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
490 ItemInfo item = ExtractItemInfoFromBuffer(extractor);
491 originating_thread_sp = std::make_shared<HistoryThread>(
493 originating_thread_sp->SetExtendedBacktraceToken(
495 originating_thread_sp->SetQueueName(
496 item.enqueuing_queue_label.c_str());
497 originating_thread_sp->SetQueueID(item.enqueuing_queue_serialnum);
498 // originating_thread_sp->SetThreadName
499 // (item.enqueuing_thread_label.c_str());
500 }
503 }
504 }
505 } else if (type == "Application Specific Backtrace") {
506 StructuredData::ObjectSP thread_extended_sp =
507 real_thread->GetExtendedInfo();
508
509 if (!thread_extended_sp)
510 return {};
511
512 StructuredData::Array *thread_extended_info =
513 thread_extended_sp->GetAsArray();
514
515 if (!thread_extended_info || !thread_extended_info->GetSize())
516 return {};
517
518 std::vector<addr_t> app_specific_backtrace_pcs;
519
520 auto extract_frame_pc =
521 [&app_specific_backtrace_pcs](StructuredData::Object *obj) -> bool {
522 if (!obj)
523 return false;
524
526 if (!dict)
527 return false;
528
530 if (!dict->GetValueForKeyAsInteger("pc", pc))
531 return false;
532
533 app_specific_backtrace_pcs.push_back(pc);
534
535 return pc != LLDB_INVALID_ADDRESS;
536 };
537
538 if (!thread_extended_info->ForEach(extract_frame_pc))
539 return {};
540
541 originating_thread_sp =
542 std::make_shared<HistoryThread>(*m_process, real_thread->GetIndexID(),
543 app_specific_backtrace_pcs, true);
544 originating_thread_sp->SetQueueName(type.AsCString());
545 }
546 return originating_thread_sp;
547}
548
551 ThreadSP return_thread_sp;
552
554 ThreadSP cur_thread_sp(
557 ret = m_get_item_info_handler.GetItemInfo(*cur_thread_sp.get(), item_ref,
559 error);
563 ret.item_buffer_size > 0) {
564 DataBufferHeap data(ret.item_buffer_size, 0);
566 ret.item_buffer_size, error) &&
567 error.Success()) {
568 DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
571 ItemInfo item = ExtractItemInfoFromBuffer(extractor);
572 return_thread_sp = std::make_shared<HistoryThread>(
574 return_thread_sp->SetExtendedBacktraceToken(item.item_that_enqueued_this);
575 return_thread_sp->SetQueueName(item.enqueuing_queue_label.c_str());
576 return_thread_sp->SetQueueID(item.enqueuing_queue_serialnum);
577 // return_thread_sp->SetThreadName
578 // (item.enqueuing_thread_label.c_str());
579
582 }
583 }
584 return return_thread_sp;
585}
586
589 ConstString type) {
590 ThreadSP extended_thread_sp;
591 if (type != "libdispatch")
592 return extended_thread_sp;
593
594 extended_thread_sp = std::make_shared<HistoryThread>(
595 *m_process, queue_item_sp->GetEnqueueingThreadID(),
596 queue_item_sp->GetEnqueueingBacktrace());
597 extended_thread_sp->SetExtendedBacktraceToken(
598 queue_item_sp->GetItemThatEnqueuedThis());
599 extended_thread_sp->SetQueueName(queue_item_sp->GetQueueLabel().c_str());
600 extended_thread_sp->SetQueueID(queue_item_sp->GetEnqueueingQueueID());
601 // extended_thread_sp->SetThreadName
602 // (queue_item_sp->GetThreadLabel().c_str());
603
604 return extended_thread_sp;
605}
606
607/* Returns true if we were able to get the version / offset information
608 * out of libBacktraceRecording. false means we were unable to retrieve
609 * this; the queue_info_version field will be 0.
610 */
611
614 return true;
615
616 addr_t queue_info_version_address = LLDB_INVALID_ADDRESS;
617 addr_t queue_info_data_offset_address = LLDB_INVALID_ADDRESS;
618 addr_t item_info_version_address = LLDB_INVALID_ADDRESS;
619 addr_t item_info_data_offset_address = LLDB_INVALID_ADDRESS;
620 Target &target = m_process->GetTarget();
621
622 static ConstString introspection_dispatch_queue_info_version(
623 "__introspection_dispatch_queue_info_version");
624 SymbolContextList sc_list;
626 introspection_dispatch_queue_info_version, eSymbolTypeData, sc_list);
627 if (!sc_list.IsEmpty()) {
628 SymbolContext sc;
629 sc_list.GetContextAtIndex(0, sc);
630 AddressRange addr_range;
631 sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range);
632 queue_info_version_address =
633 addr_range.GetBaseAddress().GetLoadAddress(&target);
634 }
635 sc_list.Clear();
636
637 static ConstString introspection_dispatch_queue_info_data_offset(
638 "__introspection_dispatch_queue_info_data_offset");
640 introspection_dispatch_queue_info_data_offset, eSymbolTypeData, sc_list);
641 if (!sc_list.IsEmpty()) {
642 SymbolContext sc;
643 sc_list.GetContextAtIndex(0, sc);
644 AddressRange addr_range;
645 sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range);
646 queue_info_data_offset_address =
647 addr_range.GetBaseAddress().GetLoadAddress(&target);
648 }
649 sc_list.Clear();
650
651 static ConstString introspection_dispatch_item_info_version(
652 "__introspection_dispatch_item_info_version");
654 introspection_dispatch_item_info_version, eSymbolTypeData, sc_list);
655 if (!sc_list.IsEmpty()) {
656 SymbolContext sc;
657 sc_list.GetContextAtIndex(0, sc);
658 AddressRange addr_range;
659 sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range);
660 item_info_version_address =
661 addr_range.GetBaseAddress().GetLoadAddress(&target);
662 }
663 sc_list.Clear();
664
665 static ConstString introspection_dispatch_item_info_data_offset(
666 "__introspection_dispatch_item_info_data_offset");
668 introspection_dispatch_item_info_data_offset, eSymbolTypeData, sc_list);
669 if (!sc_list.IsEmpty()) {
670 SymbolContext sc;
671 sc_list.GetContextAtIndex(0, sc);
672 AddressRange addr_range;
673 sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range);
674 item_info_data_offset_address =
675 addr_range.GetBaseAddress().GetLoadAddress(&target);
676 }
677
678 if (queue_info_version_address != LLDB_INVALID_ADDRESS &&
679 queue_info_data_offset_address != LLDB_INVALID_ADDRESS &&
680 item_info_version_address != LLDB_INVALID_ADDRESS &&
681 item_info_data_offset_address != LLDB_INVALID_ADDRESS) {
684 m_process->ReadUnsignedIntegerFromMemory(queue_info_version_address, 2,
685 0, error);
686 if (error.Success()) {
689 queue_info_data_offset_address, 2, 0, error);
690 if (error.Success()) {
692 m_process->ReadUnsignedIntegerFromMemory(item_info_version_address,
693 2, 0, error);
694 if (error.Success()) {
697 item_info_data_offset_address, 2, 0, error);
698 if (!error.Success()) {
700 }
701 } else {
703 }
704 } else {
706 }
707 }
708 }
709
711}
712
713const std::vector<ConstString> &
715 if (m_types.size() == 0) {
716 m_types.push_back(ConstString("libdispatch"));
717 m_types.push_back(ConstString("Application Specific Backtrace"));
718 // We could have pthread as another type in the future if we have a way of
719 // gathering that information & it's useful to distinguish between them.
720 }
721 return m_types;
722}
723
725 lldb_private::QueueList &queue_list) {
728 ThreadSP cur_thread_sp(
730 if (cur_thread_sp) {
732 queue_info_pointer = m_get_queues_handler.GetCurrentQueues(
733 *cur_thread_sp.get(), m_page_to_free, m_page_to_free_size, error);
736 if (error.Success()) {
737
738 if (queue_info_pointer.count > 0 &&
739 queue_info_pointer.queues_buffer_size > 0 &&
740 queue_info_pointer.queues_buffer_ptr != 0 &&
741 queue_info_pointer.queues_buffer_ptr != LLDB_INVALID_ADDRESS) {
743 queue_info_pointer.queues_buffer_size,
744 queue_info_pointer.count, queue_list);
745 }
746 }
747 }
748 }
749
750 // We either didn't have libBacktraceRecording (and need to create the queues
751 // list based on threads) or we did get the queues list from
752 // libBacktraceRecording but some special queues may not be included in its
753 // information. This is needed because libBacktraceRecording will only list
754 // queues with pending or running items by default - but the magic com.apple
755 // .main-thread queue on thread 1 is always around.
756
757 for (ThreadSP thread_sp : m_process->Threads()) {
758 if (thread_sp->GetAssociatedWithLibdispatchQueue() != eLazyBoolNo) {
759 if (thread_sp->GetQueueID() != LLDB_INVALID_QUEUE_ID) {
760 if (queue_list.FindQueueByID(thread_sp->GetQueueID()).get() ==
761 nullptr) {
762 QueueSP queue_sp(new Queue(m_process->shared_from_this(),
763 thread_sp->GetQueueID(),
764 thread_sp->GetQueueName()));
765 if (thread_sp->ThreadHasQueueInformation()) {
766 queue_sp->SetKind(thread_sp->GetQueueKind());
767 queue_sp->SetLibdispatchQueueAddress(
768 thread_sp->GetQueueLibdispatchQueueAddress());
769 queue_list.AddQueue(queue_sp);
770 } else {
771 queue_sp->SetKind(
772 GetQueueKind(thread_sp->GetQueueLibdispatchQueueAddress()));
773 queue_sp->SetLibdispatchQueueAddress(
774 thread_sp->GetQueueLibdispatchQueueAddress());
775 queue_list.AddQueue(queue_sp);
776 }
777 }
778 }
779 }
780 }
781}
782
783// Returns either an array of introspection_dispatch_item_info_ref's for the
784// pending items on a queue or an array introspection_dispatch_item_info_ref's
785// and code addresses for the pending items on a queue. The information about
786// each of these pending items then needs to be fetched individually by passing
787// the ref to libBacktraceRecording.
788
791 PendingItemsForQueue pending_item_refs = {};
793 ThreadSP cur_thread_sp(
795 if (cur_thread_sp) {
797 pending_items_pointer = m_get_pending_items_handler.GetPendingItems(
798 *cur_thread_sp.get(), queue, m_page_to_free, m_page_to_free_size,
799 error);
802 if (error.Success()) {
803 if (pending_items_pointer.count > 0 &&
804 pending_items_pointer.items_buffer_size > 0 &&
805 pending_items_pointer.items_buffer_ptr != 0 &&
806 pending_items_pointer.items_buffer_ptr != LLDB_INVALID_ADDRESS) {
807 DataBufferHeap data(pending_items_pointer.items_buffer_size, 0);
809 pending_items_pointer.items_buffer_ptr, data.GetBytes(),
810 pending_items_pointer.items_buffer_size, error)) {
811 DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
814
815 // We either have an array of
816 // void* item_ref
817 // (old style) or we have a structure returned which looks like
818 //
819 // struct introspection_dispatch_pending_item_info_s {
820 // void *item_ref;
821 // void *function_or_block;
822 // };
823 //
824 // struct introspection_dispatch_pending_items_array_s {
825 // uint32_t version;
826 // uint32_t size_of_item_info;
827 // introspection_dispatch_pending_item_info_s items[];
828 // }
829
830 offset_t offset = 0;
831 uint64_t i = 0;
832 uint32_t version = extractor.GetU32(&offset);
833 if (version == 1) {
834 pending_item_refs.new_style = true;
835 uint32_t item_size = extractor.GetU32(&offset);
836 uint32_t start_of_array_offset = offset;
837 while (offset < pending_items_pointer.items_buffer_size &&
838 i < pending_items_pointer.count) {
839 offset = start_of_array_offset + (i * item_size);
841 item.item_ref = extractor.GetAddress(&offset);
842 item.code_address = extractor.GetAddress(&offset);
843 pending_item_refs.item_refs_and_code_addresses.push_back(item);
844 i++;
845 }
846 } else {
847 offset = 0;
848 pending_item_refs.new_style = false;
849 while (offset < pending_items_pointer.items_buffer_size &&
850 i < pending_items_pointer.count) {
852 item.item_ref = extractor.GetAddress(&offset);
854 pending_item_refs.item_refs_and_code_addresses.push_back(item);
855 i++;
856 }
857 }
858 }
859 m_page_to_free = pending_items_pointer.items_buffer_ptr;
860 m_page_to_free_size = pending_items_pointer.items_buffer_size;
861 }
862 }
863 }
864 return pending_item_refs;
865}
866
869 PendingItemsForQueue pending_item_refs =
871 for (ItemRefAndCodeAddress pending_item :
872 pending_item_refs.item_refs_and_code_addresses) {
873 Address addr;
875 addr);
876 QueueItemSP queue_item_sp(new QueueItem(queue->shared_from_this(),
877 m_process->shared_from_this(),
878 pending_item.item_ref, addr));
879 queue->PushPendingQueueItem(queue_item_sp);
880 }
881 }
882}
883
885 addr_t item_ref) {
887
888 ThreadSP cur_thread_sp(
891 ret = m_get_item_info_handler.GetItemInfo(*cur_thread_sp.get(), item_ref,
893 error);
897 ret.item_buffer_size > 0) {
898 DataBufferHeap data(ret.item_buffer_size, 0);
900 ret.item_buffer_size, error) &&
901 error.Success()) {
902 DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
905 ItemInfo item = ExtractItemInfoFromBuffer(extractor);
909 queue_item->SetStopID(item.stop_id);
911 queue_item->SetThreadLabel(item.enqueuing_thread_label);
912 queue_item->SetQueueLabel(item.enqueuing_queue_label);
913 queue_item->SetTargetQueueLabel(item.target_queue_label);
914 }
917 }
918}
919
921 lldb::addr_t queues_buffer, uint64_t queues_buffer_size, uint64_t count,
922 lldb_private::QueueList &queue_list) {
924 DataBufferHeap data(queues_buffer_size, 0);
925 Log *log = GetLog(LLDBLog::SystemRuntime);
926 if (m_process->ReadMemory(queues_buffer, data.GetBytes(), queues_buffer_size,
927 error) == queues_buffer_size &&
928 error.Success()) {
929 // We've read the information out of inferior memory; free it on the next
930 // call we make
931 m_page_to_free = queues_buffer;
932 m_page_to_free_size = queues_buffer_size;
933
934 DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
937 offset_t offset = 0;
938 uint64_t queues_read = 0;
939
940 // The information about the queues is stored in this format (v1): typedef
941 // struct introspection_dispatch_queue_info_s {
942 // uint32_t offset_to_next;
943 // dispatch_queue_t queue;
944 // uint64_t serialnum; // queue's serialnum in the process, as
945 // provided by libdispatch
946 // uint32_t running_work_items_count;
947 // uint32_t pending_work_items_count;
948 //
949 // char data[]; // Starting here, we have variable-length data:
950 // // char queue_label[];
951 // } introspection_dispatch_queue_info_s;
952
953 while (queues_read < count && offset < queues_buffer_size) {
954 offset_t start_of_this_item = offset;
955
956 uint32_t offset_to_next = extractor.GetU32(&offset);
957
958 offset += 4; // Skip over the 4 bytes of reserved space
959 addr_t queue = extractor.GetAddress(&offset);
960 uint64_t serialnum = extractor.GetU64(&offset);
961 uint32_t running_work_items_count = extractor.GetU32(&offset);
962 uint32_t pending_work_items_count = extractor.GetU32(&offset);
963
964 // Read the first field of the variable length data
965 offset = start_of_this_item +
967 const char *queue_label = extractor.GetCStr(&offset);
968 if (queue_label == nullptr)
969 queue_label = "";
970
971 offset_t start_of_next_item = start_of_this_item + offset_to_next;
972 offset = start_of_next_item;
973
974 LLDB_LOGF(log,
975 "SystemRuntimeMacOSX::PopulateQueuesUsingLibBTR added "
976 "queue with dispatch_queue_t 0x%" PRIx64
977 ", serial number 0x%" PRIx64
978 ", running items %d, pending items %d, name '%s'",
979 queue, serialnum, running_work_items_count,
980 pending_work_items_count, queue_label);
981
982 QueueSP queue_sp(
983 new Queue(m_process->shared_from_this(), serialnum, queue_label));
984 queue_sp->SetNumRunningWorkItems(running_work_items_count);
985 queue_sp->SetNumPendingWorkItems(pending_work_items_count);
986 queue_sp->SetLibdispatchQueueAddress(queue);
987 queue_sp->SetKind(GetQueueKind(queue));
988 queue_list.AddQueue(queue_sp);
989 queues_read++;
990 }
991 }
992}
993
995 lldb_private::DataExtractor &extractor) {
996 ItemInfo item;
997
998 offset_t offset = 0;
999
1000 item.item_that_enqueued_this = extractor.GetAddress(&offset);
1001 item.function_or_block = extractor.GetAddress(&offset);
1002 item.enqueuing_thread_id = extractor.GetU64(&offset);
1003 item.enqueuing_queue_serialnum = extractor.GetU64(&offset);
1004 item.target_queue_serialnum = extractor.GetU64(&offset);
1005 item.enqueuing_callstack_frame_count = extractor.GetU32(&offset);
1006 item.stop_id = extractor.GetU32(&offset);
1007
1009
1010 for (uint32_t i = 0; i < item.enqueuing_callstack_frame_count; i++) {
1011 item.enqueuing_callstack.push_back(extractor.GetAddress(&offset));
1012 }
1013 item.enqueuing_thread_label = extractor.GetCStr(&offset);
1014 item.enqueuing_queue_label = extractor.GetCStr(&offset);
1015 item.target_queue_label = extractor.GetCStr(&offset);
1016
1017 return item;
1018}
1019
1023 "System runtime plugin for Mac OS X native libraries.", CreateInstance);
1024}
1025
1028}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
Definition: Log.h:349
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
lldb::addr_t m_dispatch_tsd_indexes_addr
lldb::ThreadSP GetExtendedBacktraceThread(lldb::ThreadSP thread, lldb_private::ConstString type) override
Return a Thread which shows the origin of this thread's creation.
PendingItemsForQueue GetPendingItemRefsForQueue(lldb::addr_t queue)
lldb::queue_id_t GetQueueIDFromThreadQAddress(lldb::addr_t dispatch_qaddr) override
Get the QueueID for the libdispatch queue given the thread's dispatch_qaddr.
lldb_private::AppleGetPendingItemsHandler m_get_pending_items_handler
lldb_private::AppleGetQueuesHandler m_get_queues_handler
struct LibdispatchTSDIndexes m_libdispatch_tsd_indexes
libBacktraceRecording_info m_lib_backtrace_recording_info
lldb_private::AppleGetItemInfoHandler m_get_item_info_handler
lldb::addr_t m_dispatch_queue_offsets_addr
std::string GetQueueNameFromThreadQAddress(lldb::addr_t dispatch_qaddr) override
Get the queue name for a thread given a thread's dispatch_qaddr.
void PopulateQueuesUsingLibBTR(lldb::addr_t queues_buffer, uint64_t queues_buffer_size, uint64_t count, lldb_private::QueueList &queue_list)
void Detach() override
Called before detaching from a process.
struct LibdispatchOffsets m_libdispatch_offsets
std::recursive_mutex m_mutex
void PopulatePendingItemsForQueue(lldb_private::Queue *queue) override
Get the pending work items for a libdispatch Queue.
const std::vector< lldb_private::ConstString > & GetExtendedBacktraceTypes() override
Return a list of thread origin extended backtraces that may be available.
lldb_private::AppleGetThreadItemInfoHandler m_get_thread_item_info_handler
lldb::addr_t GetLibdispatchQueueAddressFromThreadQAddress(lldb::addr_t dispatch_qaddr) override
Get the libdispatch_queue_t address for the queue given the thread's dispatch_qaddr.
lldb::QueueKind GetQueueKind(lldb::addr_t dispatch_queue_addr) override
Retrieve the Queue kind for the queue at a thread's dispatch_qaddr.
ItemInfo ExtractItemInfoFromBuffer(lldb_private::DataExtractor &extractor)
lldb::addr_t m_libpthread_layout_offsets_addr
bool SafeToCallFunctionsOnThisThread(lldb::ThreadSP thread_sp) override
Determine whether it is safe to run an expression on a given thread.
void CompleteQueueItem(lldb_private::QueueItem *queue_item, lldb::addr_t item_ref) override
Complete the fields in a QueueItem.
static lldb_private::SystemRuntime * CreateInstance(lldb_private::Process *process)
void AddThreadExtendedInfoPacketHints(lldb_private::StructuredData::ObjectSP dict) override
Add key-value pairs to the StructuredData dictionary object with information debugserver may need whe...
lldb::ThreadSP GetExtendedBacktraceFromItemRef(lldb::addr_t item_ref)
struct LibpthreadOffsets m_libpthread_offsets
lldb::ThreadSP GetExtendedBacktraceForQueueItem(lldb::QueueItemSP queue_item_sp, lldb_private::ConstString type) override
Get the extended backtrace thread for a QueueItem.
void Clear(bool clear_process)
lldb::user_id_t m_break_id
void PopulateQueueList(lldb_private::QueueList &queue_list) override
Populate the Process' QueueList with libdispatch / GCD queues that exist.
SystemRuntimeMacOSX(lldb_private::Process *process)
static llvm::StringRef GetPluginNameStatic()
A section + offset based address range class.
Definition: AddressRange.h:25
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
A section + offset based address class.
Definition: Address.h:59
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
GetItemInfoReturnInfo GetItemInfo(Thread &thread, lldb::addr_t item, lldb::addr_t page_to_free, uint64_t page_to_free_size, lldb_private::Status &error)
Get the information about a work item by calling __introspection_dispatch_queue_item_get_info.
GetPendingItemsReturnInfo GetPendingItems(Thread &thread, lldb::addr_t queue, lldb::addr_t page_to_free, uint64_t page_to_free_size, lldb_private::Status &error)
Get the list of pending items for a given queue via a call to __introspection_dispatch_queue_get_pend...
GetQueuesReturnInfo GetCurrentQueues(Thread &thread, lldb::addr_t page_to_free, uint64_t page_to_free_size, lldb_private::Status &error)
Get the list of queues that exist (with any active or pending items) via a call to introspection_get_...
GetThreadItemInfoReturnInfo GetThreadItemInfo(Thread &thread, lldb::tid_t thread_id, lldb::addr_t page_to_free, uint64_t page_to_free_size, lldb_private::Status &error)
Get the information about a work item by calling __introspection_dispatch_thread_get_item_info.
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:450
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
A uniqued constant string class.
Definition: ConstString.h:40
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:182
A subclass of DataBuffer that stores a data buffer on the heap.
lldb::offset_t GetByteSize() const override
Get the number of bytes in the data buffer.
An data extractor class.
Definition: DataExtractor.h:48
const char * GetCStr(lldb::offset_t *offset_ptr) const
Extract a C string from *offset_ptr.
uint64_t GetU64(lldb::offset_t *offset_ptr) const
Extract a uint64_t value from *offset_ptr.
uint32_t GetU32(lldb::offset_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
uint64_t GetAddress(lldb::offset_t *offset_ptr) const
Extract an address from *offset_ptr.
A file utility class.
Definition: FileSpec.h:57
lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const
Definition: ModuleList.cpp:614
void FindSymbolsWithNameAndType(ConstString name, lldb::SymbolType symbol_type, SymbolContextList &sc_list) const
Definition: ModuleList.cpp:500
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
virtual ObjectFile * GetObjectFile()
Get the object file representation for the current architecture.
Definition: Module.cpp:1255
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:44
virtual ArchSpec GetArchitecture()=0
Get the ArchSpec for this object file.
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
RetType GetField(llvm::StringRef name, RetType fail_value=RetType())
A plug-in interface definition class for debugging a process.
Definition: Process.h:339
ThreadList & GetThreadList()
Definition: Process.h:2187
size_t ReadCStringFromMemory(lldb::addr_t vm_addr, char *cstr, size_t cstr_max_len, Status &error)
Read a NULL terminated C string from memory.
Definition: Process.cpp:1996
virtual size_t ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
Read of memory from a process.
Definition: Process.cpp:1930
lldb::ByteOrder GetByteOrder() const
Definition: Process.cpp:3394
ThreadList::ThreadIterable Threads()
Definition: Process.h:2200
uint64_t ReadUnsignedIntegerFromMemory(lldb::addr_t load_addr, size_t byte_size, uint64_t fail_value, Status &error)
Reads an unsigned integer of the specified byte size from process memory.
Definition: Process.cpp:2071
Status ClearBreakpointSiteByID(lldb::user_id_t break_id)
Definition: Process.cpp:1583
lldb::addr_t ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error)
Definition: Process.cpp:2093
virtual bool IsAlive()
Check if a process is still alive.
Definition: Process.cpp:1090
uint32_t GetAddressByteSize() const
Definition: Process.cpp:3398
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1272
void SetThreadLabel(std::string thread_name)
Definition: QueueItem.h:122
void SetTargetQueueLabel(std::string queue_name)
Definition: QueueItem.h:130
void SetEnqueueingBacktrace(std::vector< lldb::addr_t > backtrace)
Definition: QueueItem.h:116
void SetStopID(uint32_t stop_id)
Definition: QueueItem.h:112
void SetEnqueueingThreadID(lldb::tid_t tid)
Definition: QueueItem.h:100
void SetQueueLabel(std::string queue_name)
Definition: QueueItem.h:126
void SetItemThatEnqueuedThis(lldb::addr_t address_of_item)
Definition: QueueItem.h:94
void SetEnqueueingQueueID(lldb::queue_id_t qid)
Definition: QueueItem.h:104
lldb::QueueSP FindQueueByID(lldb::queue_id_t qid)
Find a queue in the QueueList by QueueID.
Definition: QueueList.cpp:47
void AddQueue(lldb::QueueSP queue)
Add a Queue to the QueueList.
Definition: QueueList.cpp:40
void PushPendingQueueItem(lldb::QueueItemSP item)
Definition: Queue.h:125
lldb::addr_t GetLibdispatchQueueAddress() const
Get the dispatch_queue_t structure address for this Queue.
Definition: Queue.cpp:73
Process * m_process
Definition: Runtime.h:29
static lldb::TypeSystemClangSP GetForTarget(Target &target, std::optional< IsolatedASTKind > ast_kind=DefaultAST, bool create_on_demand=true)
Returns the scratch TypeSystemClang for the given target.
An error handling class.
Definition: Status.h:44
bool ForEach(std::function< bool(Object *object)> const &foreach_callback) const
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const
void AddIntegerItem(llvm::StringRef key, T value)
std::shared_ptr< Object > ObjectSP
Defines a list of symbol context objects.
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
void Clear()
Clear the object's state.
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
ConstString GetFunctionName(Mangled::NamePreference preference=Mangled::ePreferDemangled) const
Find a name of the innermost function for the symbol context.
bool GetAddressRange(uint32_t scope, uint32_t range_idx, bool use_inline_block_range, AddressRange &range) const
Get the address range contained within a symbol context.
lldb::addr_t GetLoadAddress(Target *target) const
Definition: Symbol.cpp:537
A plug-in interface definition class for system runtimes.
Definition: SystemRuntime.h:43
std::vector< ConstString > m_types
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, uint32_t stop_id=SectionLoadHistory::eStopIDNow)
Definition: Target.cpp:3113
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:970
uint64_t ReadUnsignedIntegerFromMemory(const Address &addr, size_t integer_byte_size, uint64_t fail_value, Status &error, bool force_live_memory=false)
Definition: Target.cpp:2119
lldb::ThreadSP GetExpressionExecutionThread()
Definition: ThreadList.cpp:60
static clang::FieldDecl * AddFieldToRecordType(const CompilerType &type, llvm::StringRef name, const CompilerType &field_type, lldb::AccessType access, uint32_t bitfield_bit_size)
static bool CompleteTagDeclarationDefinition(const CompilerType &type)
static bool StartTagDeclarationDefinition(const CompilerType &type)
uint8_t * GetBytes()
Get a pointer to the data.
Definition: DataBuffer.h:108
#define LLDB_INVALID_QUEUE_ID
Definition: lldb-defines.h:96
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:37
#define LLDB_BREAK_ID_IS_VALID(bid)
Definition: lldb-defines.h:39
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::Queue > QueueSP
Definition: lldb-forward.h:386
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:434
uint64_t offset_t
Definition: lldb-types.h:83
@ eLanguageTypeC
Non-standardized C, such as K&R.
@ eEncodingUint
unsigned integer
QueueKind
Queue type.
@ eQueueKindConcurrent
std::shared_ptr< lldb_private::TypeSystemClang > TypeSystemClangSP
Definition: lldb-forward.h:454
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:361
uint64_t queue_id_t
Definition: lldb-types.h:88
std::shared_ptr< lldb_private::QueueItem > QueueItemSP
Definition: lldb-forward.h:388
std::vector< lldb::addr_t > enqueuing_callstack
std::vector< ItemRefAndCodeAddress > item_refs_and_code_addresses