| // Copyright 2016 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <inttypes.h> |
| #include <lib/trace-engine/fields.h> |
| |
| #include <string_view> |
| #include <utility> |
| |
| #include <fbl/string_printf.h> |
| #include <trace-reader/reader.h> |
| |
| namespace trace { |
| |
| TraceReader::TraceReader(RecordConsumer record_consumer, ErrorHandler error_handler) |
| : record_consumer_(std::move(record_consumer)), error_handler_(std::move(error_handler)) { |
| // Provider ids begin at 1. We don't have a provider yet but we want to |
| // set the current provider. So set it to non-existent provider 0. |
| RegisterProvider(0u, ""); |
| } |
| |
| bool TraceReader::ReadRecords(Chunk& chunk) { |
| while (true) { |
| while (pending_header_ == 0) { |
| std::optional next = chunk.ReadUint64(); |
| if (!next.has_value()) { |
| return true; // need more data |
| } |
| pending_header_ = next.value(); |
| } |
| |
| auto type = RecordFields::Type::Get<RecordType>(pending_header_); |
| |
| size_t size; |
| if (type != RecordType::kLargeRecord) { |
| size = RecordFields::RecordSize::Get<size_t>(pending_header_); |
| ZX_DEBUG_ASSERT(size <= RecordFields::kMaxRecordSizeWords); |
| static_assert(RecordFields::kMaxRecordSizeBytes <= |
| TRACE_ENCODED_INLINE_LARGE_RECORD_MAX_SIZE); |
| } else { |
| size = LargeBlobFields::RecordSize::Get<size_t>(pending_header_); |
| ZX_DEBUG_ASSERT(size <= BytesToWords(TRACE_ENCODED_INLINE_LARGE_RECORD_MAX_SIZE)); |
| } |
| if (size == 0) { |
| ReportError("Unexpected record of size 0"); |
| return false; // fatal error |
| } |
| |
| // TODO(https://fxbug.dev/42097117): Here we assume that the entire blob payload can |
| // fit into the read buffer. |
| std::optional record_opt = chunk.ReadChunk(size - 1); |
| if (!record_opt.has_value()) { |
| return true; // need more data to decode record |
| } |
| Chunk& record = record_opt.value(); |
| |
| switch (type) { |
| case RecordType::kMetadata: { |
| if (!ReadMetadataRecord(record, pending_header_)) { |
| ReportError("Failed to read metadata record"); |
| } |
| break; |
| } |
| case RecordType::kInitialization: { |
| if (!ReadInitializationRecord(record, pending_header_)) { |
| ReportError("Failed to read initialization record"); |
| } |
| break; |
| } |
| case RecordType::kString: { |
| if (!ReadStringRecord(record, pending_header_)) { |
| ReportError("Failed to read string record"); |
| } |
| break; |
| } |
| case RecordType::kThread: { |
| if (!ReadThreadRecord(record, pending_header_)) { |
| ReportError("Failed to read thread record"); |
| } |
| break; |
| } |
| case RecordType::kEvent: { |
| if (!ReadEventRecord(record, pending_header_)) { |
| ReportError("Failed to read event record"); |
| } |
| break; |
| } |
| case RecordType::kBlob: { |
| void* ptr; |
| if (!ReadBlobRecord(record, pending_header_, &ptr)) { |
| ReportError("Failed to read blob record"); |
| } |
| break; |
| } |
| case RecordType::kKernelObject: { |
| if (!ReadKernelObjectRecord(record, pending_header_)) { |
| ReportError("Failed to read kernel object record"); |
| } |
| break; |
| } |
| case RecordType::kScheduler: { |
| if (!ReadSchedulerRecord(record, pending_header_)) { |
| ReportError("Failed to read scheduler event record"); |
| } |
| break; |
| } |
| case RecordType::kLog: { |
| if (!ReadLogRecord(record, pending_header_)) { |
| ReportError("Failed to read log record"); |
| } |
| break; |
| } |
| case RecordType::kLargeRecord: { |
| if (!ReadLargeRecord(record, pending_header_)) { |
| ReportError("Failed to read large record"); |
| } |
| break; |
| } |
| default: { |
| // Ignore unknown record types for forward compatibility. |
| ReportError( |
| fbl::StringPrintf("Skipping record of unknown type %d", static_cast<uint32_t>(type))); |
| break; |
| } |
| } |
| pending_header_ = 0u; |
| } |
| } |
| |
| bool TraceReader::ReadMetadataRecord(Chunk& record, RecordHeader header) { |
| auto type = MetadataRecordFields::MetadataType::Get<MetadataType>(header); |
| |
| switch (type) { |
| case MetadataType::kProviderInfo: { |
| auto id = ProviderInfoMetadataRecordFields::Id::Get<ProviderId>(header); |
| auto name_length = ProviderInfoMetadataRecordFields::NameLength::Get<size_t>(header); |
| std::optional name_view = record.ReadString(name_length); |
| if (!name_view.has_value()) { |
| return false; |
| } |
| fbl::String name(name_view.value()); |
| |
| RegisterProvider(id, name); |
| record_consumer_( |
| Record(Record::Metadata{MetadataContent(MetadataContent::ProviderInfo{id, name})})); |
| break; |
| } |
| case MetadataType::kProviderSection: { |
| auto id = ProviderSectionMetadataRecordFields::Id::Get<ProviderId>(header); |
| |
| SetCurrentProvider(id); |
| record_consumer_( |
| Record(Record::Metadata{MetadataContent(MetadataContent::ProviderSection{id})})); |
| break; |
| } |
| case MetadataType::kProviderEvent: { |
| auto id = ProviderEventMetadataRecordFields::Id::Get<ProviderId>(header); |
| auto event = ProviderEventMetadataRecordFields::Event::Get<ProviderEventType>(header); |
| switch (event) { |
| case ProviderEventType::kBufferOverflow: |
| record_consumer_( |
| Record(Record::Metadata{MetadataContent(MetadataContent::ProviderEvent{id, event})})); |
| break; |
| default: |
| // Ignore unknown event types for forward compatibility. |
| ReportError(fbl::StringPrintf("Skipping provider event of unknown type %u", |
| static_cast<unsigned>(event))); |
| break; |
| } |
| break; |
| } |
| case MetadataType::kTraceInfo: { |
| auto info_type = TraceInfoMetadataRecordFields::TraceInfoType::Get<TraceInfoType>(header); |
| switch (info_type) { |
| case TraceInfoType::kMagicNumber: { |
| auto record_magic = MagicNumberRecordFields::Magic::Get<uint32_t>(header); |
| record_consumer_(Record(Record::Metadata{MetadataContent(MetadataContent::TraceInfo{ |
| TraceInfoContent(TraceInfoContent::MagicNumberInfo{record_magic})})})); |
| break; |
| } |
| default: { |
| // Ignore unknown trace info types for forward compatibility. |
| ReportError(fbl::StringPrintf("Skipping trace info record of unknown type %u", |
| static_cast<unsigned>(info_type))); |
| break; |
| } |
| } |
| break; |
| } |
| default: { |
| // Ignore unknown metadata types for forward compatibility. |
| ReportError( |
| fbl::StringPrintf("Skipping metadata of unknown type %d", static_cast<uint32_t>(type))); |
| break; |
| } |
| } |
| return true; |
| } |
| |
| bool TraceReader::ReadInitializationRecord(Chunk& record, RecordHeader header) { |
| std::optional ticks_per_second_opt = record.ReadUint64(); |
| if (!ticks_per_second_opt.has_value()) { |
| return false; |
| } |
| trace_ticks_t ticks_per_second = ticks_per_second_opt.value(); |
| if (ticks_per_second == 0) { |
| return false; |
| } |
| |
| record_consumer_(Record(Record::Initialization{ticks_per_second})); |
| return true; |
| } |
| |
| bool TraceReader::ReadStringRecord(Chunk& record, RecordHeader header) { |
| auto index = StringRecordFields::StringIndex::Get<trace_string_index_t>(header); |
| |
| auto length = StringRecordFields::StringLength::Get<size_t>(header); |
| std::optional string_view = record.ReadString(length); |
| if (!string_view.has_value()) { |
| fbl::String errorMessage = fbl::StringPrintf( |
| "Failed to parse a string of length %lu registered with string index: '%d'", length, index); |
| ReportError(errorMessage); |
| return false; |
| } |
| fbl::String string(string_view.value()); |
| |
| if (index < TRACE_ENCODED_STRING_REF_MIN_INDEX || index > TRACE_ENCODED_STRING_REF_MAX_INDEX) { |
| fbl::String errorMessage = fbl::StringPrintf( |
| "String: '%s' registered with invalid string index: '%d'", string.c_str(), index); |
| ReportError(errorMessage); |
| return false; |
| } |
| |
| RegisterString(index, string); |
| record_consumer_(Record(Record::String{index, std::move(string)})); |
| return true; |
| } |
| |
| bool TraceReader::ReadThreadRecord(Chunk& record, RecordHeader header) { |
| auto index = ThreadRecordFields::ThreadIndex::Get<trace_thread_index_t>(header); |
| if (index < TRACE_ENCODED_THREAD_REF_MIN_INDEX || index > TRACE_ENCODED_THREAD_REF_MAX_INDEX) { |
| ReportError("Invalid thread index"); |
| return false; |
| } |
| |
| std::optional process_koid = record.ReadUint64(); |
| if (!process_koid.has_value()) { |
| ReportError("Thread record has invalid process koid"); |
| return false; |
| } |
| std::optional thread_koid = record.ReadUint64(); |
| if (!thread_koid.has_value()) { |
| ReportError("Thread record has invalid thread koid"); |
| return false; |
| } |
| |
| ProcessThread process_thread(process_koid.value(), thread_koid.value()); |
| RegisterThread(index, process_thread); |
| record_consumer_(Record(Record::Thread{index, process_thread})); |
| return true; |
| } |
| |
| bool TraceReader::ReadEventRecord(Chunk& record, RecordHeader header) { |
| auto type = EventRecordFields::EventType::Get<EventType>(header); |
| auto argument_count = EventRecordFields::ArgumentCount::Get<size_t>(header); |
| auto thread_ref = EventRecordFields::ThreadRef::Get<trace_encoded_thread_ref_t>(header); |
| auto category_ref = EventRecordFields::CategoryStringRef::Get<trace_encoded_string_ref_t>(header); |
| auto name_ref = EventRecordFields::NameStringRef::Get<trace_encoded_string_ref_t>(header); |
| |
| std::optional timestamp_opt = record.ReadUint64(); |
| if (!timestamp_opt.has_value()) { |
| return false; |
| } |
| const trace_ticks_t timestamp = timestamp_opt.value(); |
| ProcessThread process_thread; |
| fbl::String category; |
| fbl::String name; |
| std::vector<Argument> arguments; |
| if (!DecodeThreadRef(record, thread_ref, &process_thread) || |
| !DecodeStringRef(record, category_ref, &category) || |
| !DecodeStringRef(record, name_ref, &name) || |
| !ReadArguments(record, argument_count, &arguments)) { |
| auto errorMessage = fbl::StringPrintf( |
| "Invalid event: Event {\n" |
| " Type: %d\n" |
| " ArgumentCount: %lu\n" |
| " ThreadRef: %u (%s)\n" |
| " CategoryRef: %u (%s)\n" |
| " NameRef: %u (%s)\n}", |
| static_cast<uint32_t>(type), argument_count, thread_ref, process_thread.ToString().c_str(), |
| category_ref, category.c_str(), name_ref, name.c_str()); |
| ReportError(errorMessage); |
| return false; |
| } |
| |
| switch (type) { |
| case EventType::kInstant: { |
| std::optional scope = record.ReadUint64(); |
| record_consumer_(Record(Record::Event{ |
| timestamp, process_thread, std::move(category), std::move(name), std::move(arguments), |
| EventData(EventData::Instant{static_cast<EventScope>( |
| scope.value_or(static_cast<uint64_t>(EventScope::kThread)))})})); |
| break; |
| } |
| case EventType::kCounter: { |
| std::optional id = record.ReadUint64(); |
| if (!id.has_value()) { |
| return false; |
| } |
| record_consumer_( |
| Record(Record::Event{timestamp, process_thread, std::move(category), std::move(name), |
| std::move(arguments), EventData(EventData::Counter{id.value()})})); |
| break; |
| } |
| case EventType::kDurationBegin: { |
| record_consumer_( |
| Record(Record::Event{timestamp, process_thread, std::move(category), std::move(name), |
| std::move(arguments), EventData(EventData::DurationBegin{})})); |
| break; |
| } |
| case EventType::kDurationEnd: { |
| record_consumer_( |
| Record(Record::Event{timestamp, process_thread, std::move(category), std::move(name), |
| std::move(arguments), EventData(EventData::DurationEnd{})})); |
| break; |
| } |
| case EventType::kDurationComplete: { |
| std::optional end_time = record.ReadUint64(); |
| if (!end_time.has_value()) { |
| return false; |
| } |
| record_consumer_(Record(Record::Event{ |
| timestamp, process_thread, std::move(category), std::move(name), std::move(arguments), |
| EventData(EventData::DurationComplete{end_time.value()})})); |
| break; |
| } |
| case EventType::kAsyncBegin: { |
| std::optional id = record.ReadUint64(); |
| if (!id.has_value()) { |
| return false; |
| } |
| record_consumer_(Record(Record::Event{timestamp, process_thread, std::move(category), |
| std::move(name), std::move(arguments), |
| EventData(EventData::AsyncBegin{id.value()})})); |
| break; |
| } |
| case EventType::kAsyncInstant: { |
| std::optional id = record.ReadUint64(); |
| if (!id.has_value()) { |
| return false; |
| } |
| record_consumer_(Record(Record::Event{timestamp, process_thread, std::move(category), |
| std::move(name), std::move(arguments), |
| EventData(EventData::AsyncInstant{id.value()})})); |
| break; |
| } |
| case EventType::kAsyncEnd: { |
| std::optional id = record.ReadUint64(); |
| if (!id.has_value()) { |
| return false; |
| } |
| record_consumer_( |
| Record(Record::Event{timestamp, process_thread, std::move(category), std::move(name), |
| std::move(arguments), EventData(EventData::AsyncEnd{id.value()})})); |
| break; |
| } |
| case EventType::kFlowBegin: { |
| std::optional id = record.ReadUint64(); |
| if (!id.has_value()) { |
| return false; |
| } |
| record_consumer_( |
| Record(Record::Event{timestamp, process_thread, std::move(category), std::move(name), |
| std::move(arguments), EventData(EventData::FlowBegin{id.value()})})); |
| break; |
| } |
| case EventType::kFlowStep: { |
| std::optional id = record.ReadUint64(); |
| if (!id.has_value()) { |
| return false; |
| } |
| record_consumer_( |
| Record(Record::Event{timestamp, process_thread, std::move(category), std::move(name), |
| std::move(arguments), EventData(EventData::FlowStep{id.value()})})); |
| break; |
| } |
| case EventType::kFlowEnd: { |
| std::optional id = record.ReadUint64(); |
| if (!id.has_value()) { |
| return false; |
| } |
| record_consumer_( |
| Record(Record::Event{timestamp, process_thread, std::move(category), std::move(name), |
| std::move(arguments), EventData(EventData::FlowEnd{id.value()})})); |
| break; |
| } |
| default: { |
| // Ignore unknown event types for forward compatibility. |
| ReportError( |
| fbl::StringPrintf("Skipping event of unknown type %d", static_cast<uint32_t>(type))); |
| break; |
| } |
| } |
| return true; |
| } |
| |
| bool TraceReader::ReadBlobRecord(Chunk& record, RecordHeader header, void** out_blob) { |
| auto blob_type = BlobRecordFields::BlobType::Get<trace_blob_type_t>(header); |
| auto name_ref = BlobRecordFields::NameStringRef::Get<trace_encoded_string_ref_t>(header); |
| auto blob_size = BlobRecordFields::BlobSize::Get<size_t>(header); |
| fbl::String name; |
| if (!DecodeStringRef(record, name_ref, &name)) |
| return false; |
| auto blob_words = BytesToWords(blob_size); |
| std::optional blob = record.ReadInPlace(blob_words); |
| if (!blob.has_value()) { |
| return false; |
| } |
| |
| record_consumer_(Record(Record::Blob{blob_type, name, blob.value(), blob_size})); |
| return true; |
| } |
| |
| bool TraceReader::ReadKernelObjectRecord(Chunk& record, RecordHeader header) { |
| auto object_type = KernelObjectRecordFields::ObjectType::Get<zx_obj_type_t>(header); |
| auto name_ref = KernelObjectRecordFields::NameStringRef::Get<trace_encoded_string_ref_t>(header); |
| auto argument_count = KernelObjectRecordFields::ArgumentCount::Get<size_t>(header); |
| |
| std::optional koid_opt = record.ReadUint64(); |
| if (!koid_opt.has_value()) { |
| return false; |
| } |
| zx_koid_t koid = koid_opt.value(); |
| fbl::String name; |
| if (!DecodeStringRef(record, name_ref, &name)) { |
| return false; |
| } |
| std::vector<Argument> arguments; |
| if (!ReadArguments(record, argument_count, &arguments)) { |
| return false; |
| } |
| |
| record_consumer_(Record(Record::KernelObject{koid, object_type, name, std::move(arguments)})); |
| return true; |
| } |
| |
| bool TraceReader::ReadSchedulerRecord(Chunk& record, RecordHeader header) { |
| auto event_type = SchedulerRecordFields::EventType::Get<SchedulerEventType>(header); |
| if (event_type == SchedulerEventType::kLegacyContextSwitch) { |
| auto cpu_number = LegacyContextSwitchRecordFields::CpuNumber::Get<trace_cpu_number_t>(header); |
| auto outgoing_thread_state = |
| LegacyContextSwitchRecordFields::OutgoingThreadState::Get<ThreadState>(header); |
| auto outgoing_thread_priority = |
| LegacyContextSwitchRecordFields::OutgoingThreadPriority::Get<trace_thread_priority_t>( |
| header); |
| auto incoming_thread_priority = |
| LegacyContextSwitchRecordFields::IncomingThreadPriority::Get<trace_thread_priority_t>( |
| header); |
| auto outgoing_thread_ref = |
| LegacyContextSwitchRecordFields::OutgoingThreadRef::Get<trace_encoded_thread_ref_t>(header); |
| auto incoming_thread_ref = |
| LegacyContextSwitchRecordFields::IncomingThreadRef::Get<trace_encoded_thread_ref_t>(header); |
| |
| std::optional timestamp_opt = record.ReadUint64(); |
| if (!timestamp_opt.has_value()) { |
| return false; |
| } |
| trace_ticks_t timestamp = timestamp_opt.value(); |
| ProcessThread outgoing_thread; |
| if (!DecodeThreadRef(record, outgoing_thread_ref, &outgoing_thread)) { |
| return false; |
| } |
| ProcessThread incoming_thread; |
| if (!DecodeThreadRef(record, incoming_thread_ref, &incoming_thread)) { |
| return false; |
| } |
| |
| record_consumer_(Record(Record::SchedulerEvent{ |
| {timestamp, cpu_number, outgoing_thread_state, outgoing_thread, incoming_thread, |
| outgoing_thread_priority, incoming_thread_priority}})); |
| return true; |
| } |
| |
| if (event_type == SchedulerEventType::kContextSwitch) { |
| auto argument_count = ContextSwitchRecordFields::ArgumentCount::Get<size_t>(header); |
| auto cpu_number = ContextSwitchRecordFields::CpuNumber::Get<trace_cpu_number_t>(header); |
| auto thread_state = ContextSwitchRecordFields::ThreadState::Get<ThreadState>(header); |
| |
| std::optional timestamp = record.ReadUint64(); |
| if (!timestamp.has_value()) { |
| return false; |
| } |
| |
| std::optional outgoing_tid = record.ReadUint64(); |
| if (!outgoing_tid.has_value()) { |
| return false; |
| } |
| |
| std::optional incoming_tid = record.ReadUint64(); |
| if (!incoming_tid.has_value()) { |
| return false; |
| } |
| |
| std::vector<Argument> arguments; |
| if (!ReadArguments(record, argument_count, &arguments)) { |
| return false; |
| } |
| |
| record_consumer_( |
| Record(Record::SchedulerEvent{{*timestamp, cpu_number, thread_state, *outgoing_tid, |
| *incoming_tid, std::move(arguments)}})); |
| return true; |
| } |
| |
| if (event_type == SchedulerEventType::kThreadWakeup) { |
| auto argument_count = ContextSwitchRecordFields::ArgumentCount::Get<size_t>(header); |
| auto cpu_number = ContextSwitchRecordFields::CpuNumber::Get<trace_cpu_number_t>(header); |
| |
| std::optional timestamp = record.ReadUint64(); |
| if (!timestamp.has_value()) { |
| return false; |
| } |
| |
| std::optional incoming_tid = record.ReadUint64(); |
| if (!incoming_tid.has_value()) { |
| return false; |
| } |
| |
| std::vector<Argument> arguments; |
| if (!ReadArguments(record, argument_count, &arguments)) { |
| return false; |
| } |
| |
| record_consumer_(Record( |
| Record::SchedulerEvent{{*timestamp, cpu_number, *incoming_tid, std::move(arguments)}})); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| bool TraceReader::ReadLogRecord(Chunk& record, RecordHeader header) { |
| auto log_message_length = LogRecordFields::LogMessageLength::Get<uint16_t>(header); |
| |
| if (log_message_length > LogRecordFields::kMaxMessageLength) |
| return false; |
| |
| auto thread_ref = LogRecordFields::ThreadRef::Get<trace_encoded_thread_ref_t>(header); |
| std::optional timestamp_opt = record.ReadUint64(); |
| if (!timestamp_opt.has_value()) { |
| return false; |
| } |
| trace_ticks_t timestamp = timestamp_opt.value(); |
| ProcessThread process_thread; |
| if (!DecodeThreadRef(record, thread_ref, &process_thread)) { |
| return false; |
| } |
| std::optional log_message = record.ReadString(log_message_length); |
| if (!log_message.has_value()) { |
| return false; |
| } |
| record_consumer_( |
| Record(Record::Log{timestamp, process_thread, fbl::String(log_message.value())})); |
| return true; |
| } |
| |
| bool TraceReader::ReadLargeRecord(trace::Chunk& record, trace::RecordHeader header) { |
| auto large_type = LargeRecordFields::LargeType::Get<LargeRecordType>(header); |
| |
| switch (large_type) { |
| case LargeRecordType::kBlob: |
| return ReadLargeBlob(record, header); |
| default: |
| ReportError( |
| fbl::StringPrintf("Skipping unknown large record type %d", ToUnderlyingType(large_type))); |
| } |
| return true; |
| } |
| |
| bool TraceReader::ReadLargeBlob(trace::Chunk& record, trace::RecordHeader header) { |
| auto format_type = LargeBlobFields::BlobFormat::Get<trace_blob_format_t>(header); |
| |
| switch (format_type) { |
| case TRACE_BLOB_FORMAT_EVENT: { |
| std::optional format_header_opt = record.ReadUint64(); |
| if (!format_header_opt.has_value()) { |
| return false; |
| } |
| uint64_t format_header = format_header_opt.value(); |
| |
| using Format = BlobFormatEventFields; |
| auto category_ref = Format::CategoryStringRef::Get<trace_encoded_string_ref_t>(format_header); |
| auto name_ref = Format::NameStringRef::Get<trace_encoded_string_ref_t>(format_header); |
| auto argument_count = Format::ArgumentCount::Get<size_t>(format_header); |
| auto thread_ref = Format::ThreadRef::Get<trace_encoded_thread_ref_t>(format_header); |
| |
| fbl::String category; |
| if (!DecodeStringRef(record, category_ref, &category)) { |
| return false; |
| } |
| fbl::String name; |
| if (!DecodeStringRef(record, name_ref, &name)) { |
| return false; |
| } |
| std::optional timestamp_opt = record.ReadUint64(); |
| if (!timestamp_opt.has_value()) { |
| return false; |
| } |
| trace_ticks_t timestamp = timestamp_opt.value(); |
| ProcessThread process_thread; |
| if (!DecodeThreadRef(record, thread_ref, &process_thread)) { |
| return false; |
| } |
| std::vector<Argument> arguments; |
| if (!ReadArguments(record, argument_count, &arguments)) { |
| return false; |
| } |
| std::optional blob_size = record.ReadUint64(); |
| if (!blob_size.has_value()) { |
| return false; |
| } |
| std::optional blob = record.ReadInPlace(trace::BytesToWords(trace::Pad(blob_size.value()))); |
| if (!blob.has_value()) { |
| return false; |
| } |
| |
| record_consumer_(Record(Record::Large(LargeRecordData::Blob(LargeRecordData::BlobEvent{ |
| std::move(category), |
| std::move(name), |
| timestamp, |
| process_thread, |
| std::move(arguments), |
| blob.value(), |
| blob_size.value(), |
| })))); |
| break; |
| } |
| case TRACE_BLOB_FORMAT_ATTACHMENT: { |
| std::optional format_header_opt = record.ReadUint64(); |
| if (!format_header_opt.has_value()) { |
| return false; |
| } |
| uint64_t format_header = format_header_opt.value(); |
| |
| using Format = BlobFormatAttachmentFields; |
| auto category_ref = Format::CategoryStringRef::Get<trace_encoded_string_ref_t>(format_header); |
| auto name_ref = Format::NameStringRef::Get<trace_encoded_string_ref_t>(format_header); |
| |
| fbl::String category; |
| if (!DecodeStringRef(record, category_ref, &category)) { |
| return false; |
| } |
| fbl::String name; |
| if (!DecodeStringRef(record, name_ref, &name)) { |
| return false; |
| } |
| std::optional blob_size = record.ReadUint64(); |
| if (!blob_size.has_value()) { |
| return false; |
| } |
| std::optional blob = record.ReadInPlace(trace::BytesToWords(trace::Pad(blob_size.value()))); |
| if (!blob.has_value()) { |
| return false; |
| } |
| |
| record_consumer_(Record(Record::Large(LargeRecordData::Blob(LargeRecordData::BlobAttachment{ |
| std::move(category), |
| std::move(name), |
| blob.value(), |
| blob_size.value(), |
| })))); |
| break; |
| } |
| default: |
| ReportError(fbl::StringPrintf("Skipping unknown large blob record format %d", |
| ToUnderlyingType(format_type))); |
| } |
| return true; |
| } |
| |
| bool TraceReader::ReadArguments(Chunk& record, size_t count, std::vector<Argument>* out_arguments) { |
| while (count-- > 0) { |
| std::optional header_opt = record.ReadUint64(); |
| if (!header_opt.has_value()) { |
| ReportError("Failed to read argument header"); |
| return false; |
| } |
| ArgumentHeader header = header_opt.value(); |
| |
| auto size = ArgumentFields::ArgumentSize::Get<size_t>(header); |
| if (size == 0) { |
| ReportError("Invalid argument size"); |
| return false; |
| } |
| |
| std::optional arg_opt = record.ReadChunk(size - 1); |
| if (!arg_opt.has_value()) { |
| ReportError("Failed to read argument"); |
| return false; |
| } |
| Chunk& arg = arg_opt.value(); |
| |
| auto name_ref = ArgumentFields::NameRef::Get<trace_encoded_string_ref_t>(header); |
| fbl::String name; |
| if (!DecodeStringRef(arg, name_ref, &name)) { |
| ReportError("Failed to read argument name"); |
| return false; |
| } |
| |
| auto type = ArgumentFields::Type::Get<ArgumentType>(header); |
| switch (type) { |
| case ArgumentType::kNull: { |
| out_arguments->push_back(Argument{std::move(name), ArgumentValue::MakeNull()}); |
| break; |
| } |
| case ArgumentType::kBool: { |
| auto value = BoolArgumentFields::Value::Get<bool>(header); |
| out_arguments->push_back(Argument{std::move(name), ArgumentValue::MakeBool(value)}); |
| break; |
| } |
| case ArgumentType::kInt32: { |
| auto value = Int32ArgumentFields::Value::Get<int32_t>(header); |
| out_arguments->push_back(Argument{std::move(name), ArgumentValue::MakeInt32(value)}); |
| break; |
| } |
| case ArgumentType::kUint32: { |
| auto value = Uint32ArgumentFields::Value::Get<uint32_t>(header); |
| out_arguments->push_back(Argument{std::move(name), ArgumentValue::MakeUint32(value)}); |
| break; |
| } |
| case ArgumentType::kInt64: { |
| std::optional value = arg.ReadInt64(); |
| if (!value.has_value()) { |
| ReportError("Failed to read int64 argument value"); |
| return false; |
| } |
| out_arguments->push_back( |
| Argument{std::move(name), ArgumentValue::MakeInt64(value.value())}); |
| break; |
| } |
| case ArgumentType::kUint64: { |
| std::optional value = arg.ReadUint64(); |
| if (!value.has_value()) { |
| ReportError("Failed to read uint64 argument value"); |
| return false; |
| } |
| out_arguments->push_back( |
| Argument{std::move(name), ArgumentValue::MakeUint64(value.value())}); |
| break; |
| } |
| case ArgumentType::kDouble: { |
| std::optional value = arg.ReadDouble(); |
| if (!value.has_value()) { |
| ReportError("Failed to read double argument value"); |
| return false; |
| } |
| out_arguments->push_back( |
| Argument{std::move(name), ArgumentValue::MakeDouble(value.value())}); |
| break; |
| } |
| case ArgumentType::kString: { |
| auto string_ref = StringArgumentFields::Index::Get<trace_encoded_string_ref_t>(header); |
| fbl::String value; |
| if (!DecodeStringRef(arg, string_ref, &value)) { |
| ReportError("Failed to read string argument value"); |
| return false; |
| } |
| out_arguments->push_back( |
| Argument{std::move(name), ArgumentValue::MakeString(std::move(value))}); |
| break; |
| } |
| case ArgumentType::kPointer: { |
| std::optional value = arg.ReadUint64(); |
| if (!value.has_value()) { |
| ReportError("Failed to read pointer argument value"); |
| return false; |
| } |
| out_arguments->push_back( |
| Argument{std::move(name), ArgumentValue::MakePointer(value.value())}); |
| break; |
| } |
| case ArgumentType::kKoid: { |
| std::optional value = arg.ReadUint64(); |
| if (!value.has_value()) { |
| ReportError("Failed to read koid argument value"); |
| return false; |
| } |
| out_arguments->push_back(Argument{std::move(name), ArgumentValue::MakeKoid(value.value())}); |
| break; |
| } |
| default: { |
| // Ignore unknown argument types for forward compatibility. |
| ReportError(fbl::StringPrintf("Skipping argument of unknown type %d, argument name %s", |
| static_cast<uint32_t>(type), name.c_str())); |
| break; |
| } |
| } |
| } |
| return true; |
| } |
| |
| fbl::String TraceReader::GetProviderName(ProviderId id) const { |
| auto it = providers_.find(id); |
| if (it != providers_.end()) |
| return it->name; |
| return fbl::String(); |
| } |
| |
| void TraceReader::SetCurrentProvider(ProviderId id) { |
| auto it = providers_.find(id); |
| if (it != providers_.end()) { |
| current_provider_ = &*it; |
| return; |
| } |
| ReportError(fbl::StringPrintf("Registering non-existent provider %u\n", id)); |
| RegisterProvider(id, ""); |
| } |
| |
| void TraceReader::RegisterProvider(ProviderId id, fbl::String name) { |
| auto provider = std::make_unique<ProviderInfo>(); |
| provider->id = id; |
| provider->name = std::move(name); |
| current_provider_ = provider.get(); |
| |
| providers_.insert_or_replace(std::move(provider)); |
| } |
| |
| void TraceReader::RegisterString(trace_string_index_t index, const fbl::String& string) { |
| ZX_DEBUG_ASSERT(index >= TRACE_ENCODED_STRING_REF_MIN_INDEX && |
| index <= TRACE_ENCODED_STRING_REF_MAX_INDEX); |
| |
| StringTableEntry entry(index, string); |
| current_provider_->string_table.emplace(index, std::move(entry)); |
| } |
| |
| void TraceReader::RegisterThread(trace_thread_index_t index, const ProcessThread& process_thread) { |
| ZX_DEBUG_ASSERT(index >= TRACE_ENCODED_THREAD_REF_MIN_INDEX && |
| index <= TRACE_ENCODED_THREAD_REF_MAX_INDEX); |
| |
| ThreadTableEntry entry(index, process_thread); |
| current_provider_->thread_table.emplace(index, std::move(entry)); |
| } |
| |
| bool TraceReader::DecodeStringRef(Chunk& chunk, trace_encoded_string_ref_t string_ref, |
| fbl::String* out_string) const { |
| if (string_ref == TRACE_ENCODED_STRING_REF_EMPTY) { |
| out_string->clear(); |
| return true; |
| } |
| |
| if (string_ref & TRACE_ENCODED_STRING_REF_INLINE_FLAG) { |
| size_t length = string_ref & TRACE_ENCODED_STRING_REF_LENGTH_MASK; |
| if (length > TRACE_ENCODED_STRING_REF_MAX_LENGTH) { |
| ReportError("Could not read inline string"); |
| return false; |
| } |
| |
| std::optional string_view = chunk.ReadString(length); |
| if (!string_view.has_value()) { |
| ReportError("Could not read inline string"); |
| return false; |
| } |
| *out_string = string_view.value(); |
| return true; |
| } |
| |
| auto it = current_provider_->string_table.find(string_ref); |
| if (it == current_provider_->string_table.end()) { |
| fbl::String errorMessage = fbl::StringPrintf("String ref: '%d' not in table", string_ref); |
| ReportError(errorMessage); |
| return false; |
| } |
| *out_string = it->second.string; |
| return true; |
| } |
| |
| bool TraceReader::DecodeThreadRef(Chunk& chunk, trace_encoded_thread_ref_t thread_ref, |
| ProcessThread* out_process_thread) const { |
| if (thread_ref == TRACE_ENCODED_THREAD_REF_INLINE) { |
| std::optional process_koid = chunk.ReadUint64(); |
| if (!process_koid.has_value()) { |
| ReportError("Could not read inline process"); |
| return false; |
| } |
| std::optional thread_koid = chunk.ReadUint64(); |
| if (!thread_koid.has_value()) { |
| ReportError("Could not read inline thread"); |
| return false; |
| } |
| *out_process_thread = ProcessThread(process_koid.value(), thread_koid.value()); |
| return true; |
| } |
| |
| auto it = current_provider_->thread_table.find(thread_ref); |
| if (it == current_provider_->thread_table.end()) { |
| ReportError(fbl::StringPrintf("Thread ref 0x%x not in table", thread_ref)); |
| return false; |
| } |
| *out_process_thread = it->second.process_thread; |
| return true; |
| } |
| |
| void TraceReader::ReportError(fbl::String error) const { |
| if (error_handler_) |
| error_handler_(std::move(error)); |
| } |
| |
| Chunk::Chunk(const uint64_t* begin, size_t num_words) |
| : begin_(begin), current_(begin), end_(begin_ + num_words) {} |
| |
| std::optional<uint64_t> Chunk::ReadUint64() { |
| if (current_ < end_) { |
| return *current_++; |
| } |
| return std::nullopt; |
| } |
| |
| std::optional<int64_t> Chunk::ReadInt64() { |
| if (current_ < end_) { |
| return *reinterpret_cast<const int64_t*>(current_++); |
| } |
| return std::nullopt; |
| } |
| |
| std::optional<double> Chunk::ReadDouble() { |
| if (current_ < end_) { |
| return *reinterpret_cast<const double*>(current_++); |
| } |
| return std::nullopt; |
| } |
| |
| std::optional<Chunk> Chunk::ReadChunk(size_t num_words) { |
| if (current_ + num_words > end_) |
| return std::nullopt; |
| |
| Chunk chunk(current_, num_words); |
| current_ += num_words; |
| return chunk; |
| } |
| |
| std::optional<std::string_view> Chunk::ReadString(size_t length) { |
| auto num_words = BytesToWords(length); |
| if (current_ + num_words > end_) |
| return std::nullopt; |
| |
| std::string_view view(reinterpret_cast<const char*>(current_), length); |
| current_ += num_words; |
| return view; |
| } |
| |
| std::optional<void const*> Chunk::ReadInPlace(size_t num_words) { |
| if (current_ + num_words > end_) |
| return std::nullopt; |
| void const* current = current_; |
| current_ += num_words; |
| return current; |
| } |
| |
| } // namespace trace |
