| // Copyright 2026 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 "src/performance/trace_manager/shared_buffer.h" | |
| #include <fidl/fuchsia.tracing/cpp/common_types.h> | |
| #include <lib/syslog/cpp/macros.h> | |
| #include <lib/trace-engine/types.h> | |
| #include "src/performance/trace_manager/buffer_forwarder.h" | |
| const char* ModeName(fuchsia_tracing::BufferingMode mode) { | |
| switch (mode) { | |
| case fuchsia_tracing::BufferingMode::kOneshot: | |
| return "oneshot"; | |
| case fuchsia_tracing::BufferingMode::kCircular: | |
| return "circular"; | |
| case fuchsia_tracing::BufferingMode::kStreaming: | |
| return "streaming"; | |
| default: | |
| return "unknown"; | |
| } | |
| } | |
| namespace { | |
| // The size of the initialization record. | |
| constexpr size_t kInitRecordSizeBytes = 16; | |
| // Given |wrapped_count|, return the corresponding buffer number. | |
| int32_t GetBufferNumber(uint32_t wrapped_count) { return static_cast<int32_t>(wrapped_count & 1); } | |
| fuchsia_tracing::BufferingMode EngineBufferingModeToProviderMode(trace_buffering_mode_t mode) { | |
| switch (mode) { | |
| case TRACE_BUFFERING_MODE_ONESHOT: | |
| return fuchsia_tracing::BufferingMode::kOneshot; | |
| case TRACE_BUFFERING_MODE_CIRCULAR: | |
| return fuchsia_tracing::BufferingMode::kCircular; | |
| case TRACE_BUFFERING_MODE_STREAMING: | |
| return fuchsia_tracing::BufferingMode::kStreaming; | |
| default: | |
| __UNREACHABLE; | |
| } | |
| } | |
| } // namespace | |
| SharedBuffer::SharedBuffer(zx::vmo vmo, std::string provider_name, | |
| fuchsia_tracing::BufferingMode buffering_mode, size_t buffer_size, | |
| uint32_t provider_id) | |
| : vmo_(std::move(vmo)), | |
| provider_name_(std::move(provider_name)), | |
| buffering_mode_(buffering_mode), | |
| buffer_size_(buffer_size), | |
| provider_id_(provider_id) {} | |
| zx::result<SharedBuffer> SharedBuffer::Create(size_t buffer_size, | |
| fuchsia_tracing::BufferingMode buffering_mode, | |
| std::string provider_name, uint32_t provider_id) { | |
| zx::vmo buffer_vmo; | |
| if (zx_status_t status = zx::vmo::create(buffer_size, 0u, &buffer_vmo); status != ZX_OK) { | |
| FX_PLOGS(ERROR, status) << std::format("{}: Failed to create trace buffer", provider_name); | |
| return zx::error(status); | |
| } | |
| char vmo_name[ZX_MAX_NAME_LEN]; | |
| size_t would_write = snprintf(vmo_name, ZX_MAX_NAME_LEN, "trace:%s", provider_name.c_str()); | |
| size_t name_length = std::min(ZX_MAX_NAME_LEN, would_write); | |
| if (zx_status_t status = buffer_vmo.set_property(ZX_PROP_NAME, vmo_name, name_length); | |
| status != ZX_OK) { | |
| FX_PLOGS(ERROR, status) << std::format("{}: Failed to set name of trace buffer", provider_name); | |
| return zx::error(status); | |
| } | |
| return zx::ok(SharedBuffer{std::move(buffer_vmo), std::move(provider_name), buffering_mode, | |
| buffer_size, provider_id}); | |
| } | |
| bool SharedBuffer::VerifyBufferHeader(const trace::internal::BufferHeaderReader* header) const { | |
| fuchsia_tracing::BufferingMode converted_mode = | |
| EngineBufferingModeToProviderMode(header->buffering_mode()); | |
| if (converted_mode != buffering_mode_) { | |
| FX_LOGS(ERROR) << std::format("{}: header corrupt, wrong buffering mode: {}", provider_name_, | |
| ModeName(converted_mode)); | |
| return false; | |
| } | |
| return true; | |
| } | |
| zx::unowned_vmo SharedBuffer::Vmo() const { return vmo_.borrow(); } | |
| fuchsia_tracing::BufferingMode SharedBuffer::BufferingMode() const { return buffering_mode_; } | |
| tracing::TransferStatus SharedBuffer::WriteChunk( | |
| const std::shared_ptr<const tracing::BufferForwarder>& output, uint64_t offset, uint64_t last, | |
| uint64_t end, uint64_t buffer_size) const { | |
| ZX_DEBUG_ASSERT(last <= buffer_size); | |
| ZX_DEBUG_ASSERT(end <= buffer_size); | |
| offset += last; | |
| if (buffering_mode_ == fuchsia_tracing::BufferingMode::kOneshot || | |
| // If end is zero then the header wasn't updated when tracing stopped. | |
| end == 0) { | |
| uint64_t size = buffer_size - last; | |
| return output->WriteChunkBy(tracing::BufferForwarder::ForwardStrategy::Records, vmo_, offset, | |
| size); | |
| } | |
| if (end < last) { | |
| FX_LOGS(ERROR) << std::format("{}: buffer data end {} is before already transferred offset {}", | |
| provider_name_, end, last); | |
| return tracing::TransferStatus::kProviderError; | |
| } | |
| uint64_t size = end - last; | |
| return output->WriteChunkBy(tracing::BufferForwarder::ForwardStrategy::Size, vmo_, offset, size); | |
| } | |
| std::optional<SharedBuffer::RollingBufferFingerprint> SharedBuffer::ReadRollingBufferFingerprint( | |
| uint64_t buffer_offset, uint64_t buffer_size) const { | |
| RollingBufferFingerprint fingerprint; | |
| if (buffer_size < fingerprint.size()) { | |
| return std::nullopt; | |
| } | |
| if (zx_status_t status = vmo_.read(fingerprint.data(), buffer_offset, fingerprint.size()); | |
| status != ZX_OK) { | |
| FX_PLOGS(WARNING, status) << std::format("{}: Failed to read start of rolling buffer at {}", | |
| provider_name_, buffer_offset); | |
| return std::nullopt; | |
| } | |
| return fingerprint; | |
| } | |
| bool SharedBuffer::IsRollingBufferUnchangedSinceSaved(int32_t buffer_number, uint64_t buffer_offset, | |
| uint64_t buffer_size) const { | |
| if (buffering_mode_ != fuchsia_tracing::BufferingMode::kStreaming) { | |
| return false; | |
| } | |
| const std::optional<RollingBufferFingerprint>& saved = | |
| saved_rolling_buffer_fingerprints_[static_cast<size_t>(buffer_number)]; | |
| if (!saved) { | |
| return false; | |
| } | |
| std::optional<RollingBufferFingerprint> current = | |
| ReadRollingBufferFingerprint(buffer_offset, buffer_size); | |
| return current == saved; | |
| } | |
| std::pair<tracing::TransferStatus, TransferStats> SharedBuffer::TransferAll( | |
| const std::shared_ptr<const tracing::BufferForwarder>& output) const { | |
| if (auto transfer_status = WriteProviderIdRecord(output); | |
| transfer_status != tracing::TransferStatus::kComplete) { | |
| FX_LOGS(ERROR) << std::format("{}: Failed to write provider info record to trace.", | |
| provider_name_); | |
| return {transfer_status, {}}; | |
| } | |
| trace::internal::trace_buffer_header header_buffer; | |
| if (vmo_.read(&header_buffer, 0, sizeof(header_buffer)) != ZX_OK) { | |
| FX_LOGS(ERROR) << std::format("{}: Failed to read header from buffer_vmo", provider_name_); | |
| return {tracing::TransferStatus::kProviderError, {}}; | |
| } | |
| std::unique_ptr<trace::internal::BufferHeaderReader> header; | |
| std::string error = | |
| trace::internal::BufferHeaderReader::Create(&header_buffer, buffer_size_, &header); | |
| if (error != "") { | |
| FX_LOGS(ERROR) << std::format("{}: header corrupt, {}", provider_name_, error); | |
| return {tracing::TransferStatus::kProviderError, {}}; | |
| } | |
| if (!VerifyBufferHeader(header.get())) { | |
| return {tracing::TransferStatus::kProviderError, {}}; | |
| } | |
| if (header->num_records_dropped() > 0) { | |
| FX_LOGS(WARNING) << std::format("{}: {} records were dropped", provider_name_, | |
| header->num_records_dropped()); | |
| // If we can't write the buffer overflow record, it's not the end of the | |
| // world. | |
| if (output->WriteProviderBufferOverflowEvent(provider_id_) != | |
| tracing::TransferStatus::kComplete) { | |
| FX_LOGS(DEBUG) << std::format( | |
| "{}: Failed to write provider event (buffer overflow) record to trace.", provider_name_); | |
| } | |
| } | |
| if (buffering_mode_ != fuchsia_tracing::BufferingMode::kOneshot) { | |
| uint64_t offset = trace::internal::BufferHeaderReader::get_durable_buffer_offset(); | |
| uint64_t last = last_durable_data_end_; | |
| uint64_t end = header->durable_data_end(); | |
| uint64_t buffer_size = header->durable_buffer_size(); | |
| FX_LOGS(DEBUG) << std::format("Writing durable buffer for {}", provider_name_); | |
| if (auto transfer_status = WriteChunk(output, offset, last, end, buffer_size); | |
| transfer_status != tracing::TransferStatus::kComplete) { | |
| return {transfer_status, {}}; | |
| } | |
| } | |
| // There's only two buffers, thus the earlier one is not the current one. | |
| // It's important to process them in chronological order on the off | |
| // chance that the earlier buffer provides a stringref or threadref | |
| // referenced by the later buffer. | |
| // | |
| // We want to handle the case of still capturing whatever records we can if | |
| // the process crashes, in which case the header won't be up to date. In | |
| // oneshot mode we're covered: We run through the records and see what's | |
| // there. In circular and streaming modes after a buffer gets reused we can't | |
| // do that. But if the process crashes it may be the last trace records that | |
| // are important: we don't want to lose them. As a compromise, if the header | |
| // is marked as valid use it. Otherwise run through the buffer to count the | |
| // records we see. | |
| auto write_rolling_chunk = [this, output, | |
| &header](int32_t buffer_number) -> tracing::TransferStatus { | |
| uint64_t offset = header->GetRollingBufferOffset(buffer_number); | |
| uint64_t last = 0; | |
| uint64_t end = header->rolling_data_end(buffer_number); | |
| uint64_t buffer_size = header->rolling_buffer_size(); | |
| auto name = buffer_number == 0 ? "rolling buffer 0" : "rolling buffer 1"; | |
| // A rolling buffer is only ever written from its start, so if its start still matches what | |
| // was previously forwarded, the provider hasn't written to it since. This happens when a Flush | |
| // switches to a buffer (or a new run starts with CLEAR_ENTIRE) and tracing stops before any new | |
| // records are written. Scanning it would forward stale records that were already sent. | |
| if (end == 0 && IsRollingBufferUnchangedSinceSaved(buffer_number, offset, buffer_size)) { | |
| FX_LOGS(DEBUG) << std::format("{}: {} is unchanged since it was saved, skipping", | |
| provider_name_, name); | |
| return tracing::TransferStatus::kComplete; | |
| } | |
| FX_LOGS(DEBUG) << "Writing chunks for " << name; | |
| auto transfer_status = WriteChunk(output, offset, last, end, buffer_size); | |
| if (transfer_status == tracing::TransferStatus::kComplete && | |
| buffering_mode_ == fuchsia_tracing::BufferingMode::kStreaming && end > 0) { | |
| saved_rolling_buffer_fingerprints_[static_cast<size_t>(buffer_number)] = | |
| ReadRollingBufferFingerprint(offset, buffer_size); | |
| } | |
| return transfer_status; | |
| }; | |
| if (header->wrapped_count() > 0) { | |
| int32_t buffer_number = GetBufferNumber(header->wrapped_count() - 1); | |
| if (buffering_mode_ != fuchsia_tracing::BufferingMode::kStreaming) { | |
| // In non streaming modes, we haven't transferred any data yet, so we always need to transfer | |
| // the non active buffer | |
| if (auto transfer_status = write_rolling_chunk(buffer_number); | |
| transfer_status != tracing::TransferStatus::kComplete) { | |
| return {transfer_status, {}}; | |
| } | |
| } else if (last_wrapped_count_ < header->wrapped_count() - 1) { | |
| // Otherwise, in streaming mode, only write the previous buffer if our local record indicates | |
| // that we haven't transferred this version of it yet. | |
| if (auto transfer_status = write_rolling_chunk(buffer_number); | |
| transfer_status != tracing::TransferStatus::kComplete) { | |
| return {transfer_status, {}}; | |
| } | |
| } | |
| } | |
| int32_t buffer_number = GetBufferNumber(header->wrapped_count()); | |
| if (auto transfer_status = write_rolling_chunk(buffer_number); | |
| transfer_status != tracing::TransferStatus::kComplete) { | |
| return {transfer_status, {}}; | |
| } | |
| uint8_t durable_buffer_used = 0; | |
| if (header->durable_buffer_size() > 0) { | |
| durable_buffer_used = | |
| static_cast<uint8_t>(100 * header->durable_data_end() / header->durable_buffer_size()); | |
| } | |
| TransferStats stats{ | |
| .durable_used_percent = durable_buffer_used, | |
| .wrapped_count = header->wrapped_count(), | |
| .records_dropped = header->num_records_dropped(), | |
| .non_durable_bytes_written = header->rolling_data_end(0) + header->rolling_data_end(1), | |
| }; | |
| return {tracing::TransferStatus::kComplete, stats}; | |
| } | |
| tracing::TransferStatus SharedBuffer::WriteProviderIdRecord( | |
| const std::shared_ptr<const tracing::BufferForwarder>& output) const { | |
| if (provider_info_record_written_) { | |
| return output->WriteProviderSectionRecord(provider_id_); | |
| } | |
| auto status = output->WriteProviderInfoRecord(provider_id_, provider_name_); | |
| provider_info_record_written_ = true; | |
| return status; | |
| } | |
| void SharedBuffer::OnStart(fuchsia_tracing::BufferDisposition disposition) { | |
| switch (disposition) { | |
| case fuchsia_tracing::BufferDisposition::kClearEntire: | |
| last_wrapped_count_ = 0u; | |
| last_durable_data_end_ = 0; | |
| break; | |
| case fuchsia_tracing::BufferDisposition::kClearNondurable: | |
| last_wrapped_count_ = 0u; | |
| break; | |
| case fuchsia_tracing::BufferDisposition::kRetain: | |
| break; | |
| } | |
| } | |
| bool SharedBuffer::StreamingTransfer(const std::shared_ptr<const tracing::BufferForwarder>& output, | |
| uint32_t wrapped_count, uint64_t durable_data_end) { | |
| FX_DCHECK(buffering_mode_ == fuchsia_tracing::BufferingMode::kStreaming); | |
| if (wrapped_count == 0 && last_wrapped_count_ == 0) { | |
| // ok | |
| } else if (wrapped_count != last_wrapped_count_ + 1) { | |
| FX_LOGS(ERROR) << std::format("{}: unexpected wrapped_count from provider: {}", provider_name_, | |
| wrapped_count); | |
| return false; | |
| } else if (durable_data_end < last_durable_data_end_ || (durable_data_end & 7) != 0) { | |
| FX_LOGS(ERROR) << std::format("{}: unexpected durable_data_end from provider: {}", | |
| provider_name_, durable_data_end); | |
| return false; | |
| } | |
| int32_t buffer_number = GetBufferNumber(wrapped_count); | |
| if (WriteProviderIdRecord(output) != tracing::TransferStatus::kComplete) { | |
| FX_LOGS(ERROR) << std::format("{}: Failed to write provider section record to trace.", | |
| provider_name_); | |
| return false; | |
| } | |
| trace::internal::trace_buffer_header header_buffer; | |
| if (vmo_.read(&header_buffer, 0, sizeof(header_buffer)) != ZX_OK) { | |
| FX_LOGS(ERROR) << std::format("{}: Failed to read header from vmo_", provider_name_); | |
| return false; | |
| } | |
| std::unique_ptr<trace::internal::BufferHeaderReader> header; | |
| std::string error = | |
| trace::internal::BufferHeaderReader::Create(&header_buffer, buffer_size_, &header); | |
| if (error != "") { | |
| FX_LOGS(ERROR) << std::format("{}: header corrupt, {}", provider_name_, error); | |
| return false; | |
| } | |
| if (!VerifyBufferHeader(header.get())) { | |
| return false; | |
| } | |
| FX_LOGS(DEBUG) << "Dropped records: " << header->num_records_dropped(); | |
| // Don't use |header.durable_data_end| here, we want the value at the time | |
| // the message was sent. | |
| if (durable_data_end < kInitRecordSizeBytes || durable_data_end > header->durable_buffer_size() || | |
| (durable_data_end & 7) != 0 || durable_data_end < last_durable_data_end_) { | |
| FX_LOGS(ERROR) << std::format("{}: bad durable_data_end: {}", provider_name_, durable_data_end); | |
| return false; | |
| } | |
| // However we can use rolling_data_end from the header. | |
| // This buffer is no longer being written to until we save it. | |
| // [And if it does get written to it'll potentially result in corrupt | |
| // data, but that's not our problem; as long as we can't crash, which is | |
| // always the rule here.] | |
| uint64_t rolling_data_end = header->rolling_data_end(buffer_number); | |
| // Only transfer what's new in the durable buffer since the last time. | |
| uint64_t durable_buffer_offset = trace::internal::BufferHeaderReader::get_durable_buffer_offset(); | |
| if (durable_data_end > last_durable_data_end_) { | |
| uint64_t size = durable_data_end - last_durable_data_end_; | |
| FX_LOGS(DEBUG) << std::format("Writing durable buffer for {}", provider_name_); | |
| if (output->WriteChunkBy(tracing::BufferForwarder::ForwardStrategy::Size, vmo_, | |
| durable_buffer_offset + last_durable_data_end_, | |
| size) != tracing::TransferStatus::kComplete) { | |
| return false; | |
| } | |
| } | |
| uint64_t buffer_offset = header->GetRollingBufferOffset(buffer_number); | |
| auto buffer_name = buffer_number == 0 ? "rolling buffer 0" : "rolling buffer 1"; | |
| FX_LOGS(DEBUG) << std::format("Writing {} for {}", buffer_name, provider_name_); | |
| tracing::TransferStatus transfer_status = output->WriteChunkBy( | |
| tracing::BufferForwarder::ForwardStrategy::Size, vmo_, buffer_offset, rolling_data_end); | |
| if (transfer_status != tracing::TransferStatus::kComplete) { | |
| return false; | |
| } | |
| // The provider won't write to this buffer again until we tell it the buffer is saved, so its | |
| // start is stable here. TransferAll() uses this to recognize a buffer that is still unchanged. | |
| if (rolling_data_end > 0) { | |
| saved_rolling_buffer_fingerprints_[static_cast<size_t>(buffer_number)] = | |
| ReadRollingBufferFingerprint(buffer_offset, header->rolling_buffer_size()); | |
| } | |
| last_wrapped_count_ = wrapped_count; | |
| last_durable_data_end_ = durable_data_end; | |
| return true; | |
| } |