| // 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 <string.h> |
| |
| #include <utility> |
| |
| #include <fbl/string_buffer.h> |
| #include <fbl/string_printf.h> |
| #include <trace-reader/records.h> |
| |
| namespace trace { |
| namespace { |
| const char* EventScopeToString(EventScope scope) { |
| switch (scope) { |
| case EventScope::kGlobal: |
| return "global"; |
| case EventScope::kProcess: |
| return "process"; |
| case EventScope::kThread: |
| return "thread"; |
| } |
| return "???"; |
| } |
| |
| const char* ThreadStateToString(ThreadState state) { |
| switch (state) { |
| case ThreadState::kNew: |
| return "new"; |
| case ThreadState::kRunning: |
| return "running"; |
| case ThreadState::kSuspended: |
| return "suspended"; |
| case ThreadState::kBlocked: |
| return "blocked"; |
| case ThreadState::kDying: |
| return "dying"; |
| case ThreadState::kDead: |
| return "dead"; |
| } |
| return "???"; |
| } |
| |
| const char* ObjectTypeToString(zx_obj_type_t type) { |
| switch (type) { |
| case ZX_OBJ_TYPE_PROCESS: |
| return "process"; |
| case ZX_OBJ_TYPE_THREAD: |
| return "thread"; |
| case ZX_OBJ_TYPE_VMO: |
| return "vmo"; |
| case ZX_OBJ_TYPE_CHANNEL: |
| return "channel"; |
| case ZX_OBJ_TYPE_EVENT: |
| return "event"; |
| case ZX_OBJ_TYPE_PORT: |
| return "port"; |
| case ZX_OBJ_TYPE_INTERRUPT: |
| return "interrupt"; |
| case ZX_OBJ_TYPE_PCI_DEVICE: |
| return "pci-device"; |
| case ZX_OBJ_TYPE_LOG: |
| return "log"; |
| case ZX_OBJ_TYPE_SOCKET: |
| return "socket"; |
| case ZX_OBJ_TYPE_RESOURCE: |
| return "resource"; |
| case ZX_OBJ_TYPE_EVENTPAIR: |
| return "event-pair"; |
| case ZX_OBJ_TYPE_JOB: |
| return "job"; |
| case ZX_OBJ_TYPE_VMAR: |
| return "vmar"; |
| case ZX_OBJ_TYPE_FIFO: |
| return "fifo"; |
| case ZX_OBJ_TYPE_GUEST: |
| return "guest"; |
| case ZX_OBJ_TYPE_VCPU: |
| return "vcpu"; |
| case ZX_OBJ_TYPE_TIMER: |
| return "timer"; |
| case ZX_OBJ_TYPE_IOMMU: |
| return "iommu"; |
| case ZX_OBJ_TYPE_BTI: |
| return "bti"; |
| case ZX_OBJ_TYPE_PROFILE: |
| return "profile"; |
| case ZX_OBJ_TYPE_PMT: |
| return "pmt"; |
| case ZX_OBJ_TYPE_SUSPEND_TOKEN: |
| return "suspend-token"; |
| case ZX_OBJ_TYPE_PAGER: |
| return "pager"; |
| case ZX_OBJ_TYPE_EXCEPTION: |
| return "exception"; |
| default: |
| return "???"; |
| } |
| } |
| |
| template <size_t max_preview_start, size_t max_preview_end> |
| fbl::String PreviewBlobData(const void* blob, size_t blob_size) { |
| static_assert((max_preview_start + max_preview_end) > 0); |
| |
| auto blob_data = (const unsigned char*)blob; |
| fbl::StringBuffer<3 * (max_preview_start + max_preview_end) + 128> result; |
| |
| size_t num_leading_bytes; |
| size_t num_trailing_bytes; |
| if (blob_size <= (max_preview_start + max_preview_end)) { |
| num_leading_bytes = blob_size; |
| num_trailing_bytes = 0; |
| } else { |
| num_leading_bytes = max_preview_start; |
| num_trailing_bytes = max_preview_end; |
| } |
| |
| result.Append('<'); |
| for (size_t i = 0; i < num_leading_bytes; i++) { |
| if (i > 0) |
| result.Append(' '); |
| result.AppendPrintf("%02x", blob_data[i]); |
| } |
| if (num_trailing_bytes) |
| result.Append(" ..."); |
| for (size_t i = blob_size - num_trailing_bytes; i < blob_size; i++) { |
| result.Append(' '); |
| result.AppendPrintf("%02x", blob_data[i]); |
| } |
| result.Append('>'); |
| |
| return result.ToString(); |
| } |
| |
| fbl::String FormatArgumentList(const std::vector<trace::Argument>& args) { |
| fbl::StringBuffer<1024> result; |
| |
| result.Append('{'); |
| for (size_t i = 0; i < args.size(); i++) { |
| if (i != 0) |
| result.Append(", "); |
| result.Append(args[i].ToString()); |
| } |
| result.Append('}'); |
| |
| return result.ToString(); |
| } |
| } // namespace |
| |
| fbl::String ProcessThread::ToString() const { |
| return fbl::StringPrintf("%" PRIu64 "/%" PRIu64, process_koid_, thread_koid_); |
| } |
| |
| fbl::String ArgumentValue::ToString() const { |
| switch (type()) { |
| case ArgumentType::kNull: |
| return "null"; |
| case ArgumentType::kBool: |
| return fbl::StringPrintf("bool(%s)", cpp17::get<Bool>(value_).value ? "true" : "false"); |
| case ArgumentType::kInt32: |
| return fbl::StringPrintf("int32(%" PRId32 ")", cpp17::get<int32_t>(value_)); |
| case ArgumentType::kUint32: |
| return fbl::StringPrintf("uint32(%" PRIu32 ")", cpp17::get<uint32_t>(value_)); |
| case ArgumentType::kInt64: |
| return fbl::StringPrintf("int64(%" PRId64 ")", cpp17::get<int64_t>(value_)); |
| case ArgumentType::kUint64: |
| return fbl::StringPrintf("uint64(%" PRIu64 ")", cpp17::get<uint64_t>(value_)); |
| case ArgumentType::kDouble: |
| return fbl::StringPrintf("double(%f)", cpp17::get<double>(value_)); |
| case ArgumentType::kString: |
| return fbl::StringPrintf("string(\"%s\")", cpp17::get<fbl::String>(value_).c_str()); |
| case ArgumentType::kPointer: |
| return fbl::StringPrintf("pointer(%p)", |
| reinterpret_cast<void*>(cpp17::get<Pointer>(value_).value)); |
| case ArgumentType::kKoid: |
| return fbl::StringPrintf("koid(%" PRIu64 ")", cpp17::get<Koid>(value_).value); |
| } |
| ZX_ASSERT(false); |
| } |
| |
| fbl::String Argument::ToString() const { |
| return fbl::StringPrintf("%s: %s", name_.c_str(), value_.ToString().c_str()); |
| } |
| |
| void TraceInfoContent::Destroy() { |
| switch (type_) { |
| case TraceInfoType::kMagicNumber: |
| magic_number_info_.~MagicNumberInfo(); |
| break; |
| } |
| } |
| |
| void TraceInfoContent::MoveFrom(TraceInfoContent&& other) { |
| type_ = other.type_; |
| switch (type_) { |
| case TraceInfoType::kMagicNumber: |
| new (&magic_number_info_) MagicNumberInfo(std::move(other.magic_number_info_)); |
| break; |
| } |
| } |
| |
| fbl::String TraceInfoContent::ToString() const { |
| switch (type_) { |
| case TraceInfoType::kMagicNumber: |
| return fbl::StringPrintf("MagicNumberInfo(magic_value: 0x%" PRIx32 ")", |
| magic_number_info_.magic_value); |
| } |
| ZX_ASSERT(false); |
| } |
| |
| void MetadataContent::Destroy() { |
| switch (type_) { |
| case MetadataType::kProviderInfo: |
| provider_info_.~ProviderInfo(); |
| break; |
| case MetadataType::kProviderSection: |
| provider_section_.~ProviderSection(); |
| break; |
| case MetadataType::kProviderEvent: |
| provider_event_.~ProviderEvent(); |
| break; |
| case MetadataType::kTraceInfo: |
| trace_info_.~TraceInfo(); |
| break; |
| } |
| } |
| |
| void MetadataContent::MoveFrom(MetadataContent&& other) { |
| type_ = other.type_; |
| switch (type_) { |
| case MetadataType::kProviderInfo: |
| new (&provider_info_) ProviderInfo(std::move(other.provider_info_)); |
| break; |
| case MetadataType::kProviderSection: |
| new (&provider_section_) ProviderSection(std::move(other.provider_section_)); |
| break; |
| case MetadataType::kProviderEvent: |
| new (&provider_event_) ProviderEvent(std::move(other.provider_event_)); |
| break; |
| case MetadataType::kTraceInfo: |
| new (&trace_info_) TraceInfo(std::move(other.trace_info_)); |
| break; |
| } |
| } |
| |
| fbl::String MetadataContent::ToString() const { |
| switch (type_) { |
| case MetadataType::kProviderInfo: |
| return fbl::StringPrintf("ProviderInfo(id: %" PRId32 ", name: \"%s\")", provider_info_.id, |
| provider_info_.name.c_str()); |
| case MetadataType::kProviderSection: |
| return fbl::StringPrintf("ProviderSection(id: %" PRId32 ")", provider_section_.id); |
| case MetadataType::kProviderEvent: { |
| fbl::String name; |
| ProviderEventType type = provider_event_.event; |
| switch (type) { |
| case ProviderEventType::kBufferOverflow: |
| name = "buffer overflow"; |
| break; |
| default: |
| name = fbl::StringPrintf("unknown(%u)", static_cast<unsigned>(type)); |
| break; |
| } |
| return fbl::StringPrintf("ProviderEvent(id: %" PRId32 ", %s)", provider_event_.id, |
| name.c_str()); |
| } |
| case MetadataType::kTraceInfo: { |
| return fbl::StringPrintf("TraceInfo(content: %s)", trace_info_.content.ToString().c_str()); |
| } |
| } |
| ZX_ASSERT(false); |
| } |
| |
| void EventData::Destroy() { |
| switch (type_) { |
| case EventType::kInstant: |
| instant_.~Instant(); |
| break; |
| case EventType::kCounter: |
| counter_.~Counter(); |
| break; |
| case EventType::kDurationBegin: |
| duration_begin_.~DurationBegin(); |
| break; |
| case EventType::kDurationEnd: |
| duration_end_.~DurationEnd(); |
| break; |
| case EventType::kDurationComplete: |
| duration_complete_.~DurationComplete(); |
| break; |
| case EventType::kAsyncBegin: |
| async_begin_.~AsyncBegin(); |
| break; |
| case EventType::kAsyncInstant: |
| async_instant_.~AsyncInstant(); |
| break; |
| case EventType::kAsyncEnd: |
| async_end_.~AsyncEnd(); |
| break; |
| case EventType::kFlowBegin: |
| flow_begin_.~FlowBegin(); |
| break; |
| case EventType::kFlowStep: |
| flow_step_.~FlowStep(); |
| break; |
| case EventType::kFlowEnd: |
| flow_end_.~FlowEnd(); |
| break; |
| } |
| } |
| |
| void EventData::MoveFrom(EventData&& other) { |
| type_ = other.type_; |
| switch (type_) { |
| case EventType::kInstant: |
| new (&instant_) Instant(std::move(other.instant_)); |
| break; |
| case EventType::kCounter: |
| new (&counter_) Counter(std::move(other.counter_)); |
| break; |
| case EventType::kDurationBegin: |
| new (&duration_begin_) DurationBegin(std::move(other.duration_begin_)); |
| break; |
| case EventType::kDurationEnd: |
| new (&duration_end_) DurationEnd(std::move(other.duration_end_)); |
| break; |
| case EventType::kDurationComplete: |
| new (&duration_complete_) DurationComplete(std::move(other.duration_complete_)); |
| break; |
| case EventType::kAsyncBegin: |
| new (&async_begin_) AsyncBegin(std::move(other.async_begin_)); |
| break; |
| case EventType::kAsyncInstant: |
| new (&async_instant_) AsyncInstant(std::move(other.async_instant_)); |
| break; |
| case EventType::kAsyncEnd: |
| new (&async_end_) AsyncEnd(std::move(other.async_end_)); |
| break; |
| case EventType::kFlowBegin: |
| new (&flow_begin_) FlowBegin(std::move(other.flow_begin_)); |
| break; |
| case EventType::kFlowStep: |
| new (&flow_step_) FlowStep(std::move(other.flow_step_)); |
| break; |
| case EventType::kFlowEnd: |
| new (&flow_end_) FlowEnd(std::move(other.flow_end_)); |
| break; |
| } |
| } |
| |
| fbl::String EventData::ToString() const { |
| switch (type_) { |
| case EventType::kInstant: |
| return fbl::StringPrintf("Instant(scope: %s)", EventScopeToString(instant_.scope)); |
| case EventType::kCounter: |
| return fbl::StringPrintf("Counter(id: %" PRIu64 ")", counter_.id); |
| case EventType::kDurationBegin: |
| return "DurationBegin"; |
| case EventType::kDurationEnd: |
| return "DurationEnd"; |
| case EventType::kDurationComplete: |
| return fbl::StringPrintf("DurationComplete(end_ts: %" PRIu64 ")", |
| duration_complete_.end_time); |
| case EventType::kAsyncBegin: |
| return fbl::StringPrintf("AsyncBegin(id: %" PRIu64 ")", async_begin_.id); |
| case EventType::kAsyncInstant: |
| return fbl::StringPrintf("AsyncInstant(id: %" PRIu64 ")", async_instant_.id); |
| case EventType::kAsyncEnd: |
| return fbl::StringPrintf("AsyncEnd(id: %" PRIu64 ")", async_end_.id); |
| case EventType::kFlowBegin: |
| return fbl::StringPrintf("FlowBegin(id: %" PRIu64 ")", flow_begin_.id); |
| case EventType::kFlowStep: |
| return fbl::StringPrintf("FlowStep(id: %" PRIu64 ")", flow_step_.id); |
| case EventType::kFlowEnd: |
| return fbl::StringPrintf("FlowEnd(id: %" PRIu64 ")", flow_end_.id); |
| } |
| ZX_ASSERT(false); |
| } |
| |
| void LargeRecordData::Destroy() { |
| switch (type_) { |
| case LargeRecordType::kBlob: |
| blob_.~Blob(); |
| break; |
| } |
| } |
| |
| void LargeRecordData::MoveFrom(trace::LargeRecordData&& other) { |
| switch (type_) { |
| case LargeRecordType::kBlob: |
| new (&blob_) Blob(std::move(other.blob_)); |
| break; |
| } |
| } |
| |
| fbl::String LargeRecordData::ToString() const { |
| switch (type_) { |
| case LargeRecordType::kBlob: |
| if (cpp17::holds_alternative<BlobEvent>(blob_)) { |
| const auto& data = cpp17::get<BlobEvent>(blob_); |
| return fbl::StringPrintf( |
| "Blob(format: blob_event, category: \"%s\", name: \"%s\", " |
| "ts: %" PRIu64 |
| ", pt: %s, %s, " |
| "size: %" PRIu64 ", preview: %s)", |
| data.category.c_str(), data.name.c_str(), data.timestamp, |
| data.process_thread.ToString().c_str(), FormatArgumentList(data.arguments).c_str(), |
| data.blob_size, PreviewBlobData<8, 8>(data.blob, data.blob_size).c_str()); |
| } else if (cpp17::holds_alternative<BlobAttachment>(blob_)) { |
| const auto& data = cpp17::get<BlobAttachment>(blob_); |
| return fbl::StringPrintf( |
| "Blob(format: blob_attachment, category: \"%s\", name: \"%s\", " |
| "size: %" PRIu64 ", preview: %s)", |
| data.category.c_str(), data.name.c_str(), data.blob_size, |
| PreviewBlobData<8, 8>(data.blob, data.blob_size).c_str()); |
| } |
| break; |
| } |
| ZX_ASSERT(false); |
| } |
| |
| void Record::Destroy() { |
| switch (type_) { |
| case RecordType::kMetadata: |
| metadata_.~Metadata(); |
| break; |
| case RecordType::kInitialization: |
| initialization_.~Initialization(); |
| break; |
| case RecordType::kString: |
| string_.~String(); |
| break; |
| case RecordType::kThread: |
| thread_.~Thread(); |
| break; |
| case RecordType::kEvent: |
| event_.~Event(); |
| break; |
| case RecordType::kBlob: |
| blob_.~Blob(); |
| break; |
| case RecordType::kKernelObject: |
| kernel_object_.~KernelObject(); |
| break; |
| case RecordType::kScheduler: |
| scheduler_event_.~SchedulerEvent(); |
| break; |
| case RecordType::kLog: |
| log_.~Log(); |
| break; |
| case RecordType::kLargeRecord: |
| large_.~Large(); |
| break; |
| } |
| } |
| |
| void Record::MoveFrom(Record&& other) { |
| type_ = other.type_; |
| switch (type_) { |
| case RecordType::kMetadata: |
| new (&metadata_) Metadata(std::move(other.metadata_)); |
| break; |
| case RecordType::kInitialization: |
| new (&initialization_) Initialization(std::move(other.initialization_)); |
| break; |
| case RecordType::kString: |
| new (&string_) String(std::move(other.string_)); |
| break; |
| case RecordType::kThread: |
| new (&thread_) Thread(std::move(other.thread_)); |
| break; |
| case RecordType::kEvent: |
| new (&event_) Event(std::move(other.event_)); |
| break; |
| case RecordType::kBlob: |
| new (&blob_) Blob(std::move(other.blob_)); |
| break; |
| case RecordType::kKernelObject: |
| new (&kernel_object_) KernelObject(std::move(other.kernel_object_)); |
| break; |
| case RecordType::kScheduler: |
| new (&scheduler_event_) SchedulerEvent(std::move(other.scheduler_event_)); |
| break; |
| case RecordType::kLog: |
| new (&log_) Log(std::move(other.log_)); |
| break; |
| case RecordType::kLargeRecord: |
| new (&large_) Large(std::move(other.large_)); |
| break; |
| } |
| } |
| |
| fbl::String Record::ToString() const { |
| switch (type_) { |
| case RecordType::kMetadata: |
| return fbl::StringPrintf("Metadata(content: %s)", metadata_.content.ToString().c_str()); |
| case RecordType::kInitialization: |
| return fbl::StringPrintf("Initialization(ticks_per_second: %" PRIu64 ")", |
| initialization_.ticks_per_second); |
| case RecordType::kString: |
| return fbl::StringPrintf("String(index: %" PRIu32 ", \"%s\")", string_.index, |
| string_.string.c_str()); |
| case RecordType::kThread: |
| return fbl::StringPrintf("Thread(index: %" PRIu32 ", %s)", thread_.index, |
| thread_.process_thread.ToString().c_str()); |
| case RecordType::kEvent: |
| return fbl::StringPrintf( |
| "Event(ts: %" PRIu64 ", pt: %s, category: \"%s\", name: \"%s\", %s, %s)", |
| event_.timestamp, event_.process_thread.ToString().c_str(), event_.category.c_str(), |
| event_.name.c_str(), event_.data.ToString().c_str(), |
| FormatArgumentList(event_.arguments).c_str()); |
| break; |
| case RecordType::kBlob: |
| return fbl::StringPrintf("Blob(name: %s, size: %zu, preview: %s)", blob_.name.c_str(), |
| blob_.blob_size, |
| PreviewBlobData<8, 8>(blob_.blob, blob_.blob_size).c_str()); |
| case RecordType::kKernelObject: |
| return fbl::StringPrintf("KernelObject(koid: %" PRIu64 ", type: %s, name: \"%s\", %s)", |
| kernel_object_.koid, ObjectTypeToString(kernel_object_.object_type), |
| kernel_object_.name.c_str(), |
| FormatArgumentList(kernel_object_.arguments).c_str()); |
| break; |
| case RecordType::kScheduler: |
| if (scheduler_event_.type() == SchedulerEventType::kLegacyContextSwitch) { |
| auto& context_switch = scheduler_event_.legacy_context_switch(); |
| return fbl::StringPrintf("ContextSwitch(ts: %" PRIu64 ", cpu: %" PRIu32 |
| ", os: %s, opt: %s, ipt: %s" |
| ", oprio: %" PRIu32 ", iprio: %" PRIu32 ")", |
| context_switch.timestamp, context_switch.cpu_number, |
| ThreadStateToString(context_switch.outgoing_thread_state), |
| context_switch.outgoing_thread.ToString().c_str(), |
| context_switch.incoming_thread.ToString().c_str(), |
| context_switch.outgoing_thread_priority, |
| context_switch.incoming_thread_priority); |
| } |
| if (scheduler_event_.type() == SchedulerEventType::kContextSwitch) { |
| auto& context_switch = scheduler_event_.context_switch(); |
| return fbl::StringPrintf("ContextSwitch(ts: %" PRIu64 ", cpu: %" PRIu32 |
| ", os: %s, ot: %" PRIu64 ", it: %" PRIu64 ", %s)", |
| context_switch.timestamp, context_switch.cpu_number, |
| ThreadStateToString(context_switch.outgoing_thread_state), |
| context_switch.outgoing_tid, context_switch.incoming_tid, |
| FormatArgumentList(context_switch.arguments).c_str()); |
| } |
| if (scheduler_event_.type() == SchedulerEventType::kThreadWakeup) { |
| auto& thread_wakeup = scheduler_event_.thread_wakeup(); |
| return fbl::StringPrintf( |
| "ThreadWakeup(ts: %" PRIu64 ", cpu: %" PRIu32 ", it: %" PRIu64 ", %s)", |
| thread_wakeup.timestamp, thread_wakeup.cpu_number, thread_wakeup.incoming_tid, |
| FormatArgumentList(thread_wakeup.arguments).c_str()); |
| } |
| return fbl::StringPrintf("UnknownSchedulerEvent(type: %d)", |
| static_cast<int>(scheduler_event_.type())); |
| case RecordType::kLog: |
| return fbl::StringPrintf("Log(ts: %" PRIu64 ", pt: %s, \"%s\")", log_.timestamp, |
| log_.process_thread.ToString().c_str(), log_.message.c_str()); |
| case RecordType::kLargeRecord: |
| return fbl::StringPrintf("LargeRecord(%s)", large_.ToString().c_str()); |
| } |
| ZX_ASSERT(false); |
| } |
| |
| std::optional<fbl::String> Record::GetName() const { |
| switch (type_) { |
| // Do not have a namefield |
| case RecordType::kMetadata: |
| case RecordType::kInitialization: |
| case RecordType::kString: |
| case RecordType::kThread: |
| case RecordType::kScheduler: |
| case RecordType::kLog: |
| case RecordType::kLargeRecord: |
| return std::nullopt; |
| case RecordType::kEvent: |
| return {event_.name}; |
| case RecordType::kBlob: |
| return {blob_.name}; |
| case RecordType::kKernelObject: |
| return {kernel_object_.name}; |
| } |
| } |
| |
| } // namespace trace |
