third_party/pigweed/repo/pw_trace_tokenized/trace_buffer.cc

   1 // Copyright 2020 The Pigweed Authors
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
   4 // use this file except in compliance with the License. You may obtain a copy of
   5 // the License at
   6 //
   7 //     https://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  12 // License for the specific language governing permissions and limitations under
  13 // the License.
  14 //==============================================================================
  15 //
  16 #include "pw_trace_tokenized/trace_buffer.h"
  17
  18 #include <span>
  19
  20 #include "pw_ring_buffer/prefixed_entry_ring_buffer.h"
  21 #include "pw_trace_tokenized/trace_callback.h"
  22
  23 namespace pw {
  24 namespace trace {
  25 namespace {
  26
  27 class TraceBuffer {
  28  public:
  29   TraceBuffer() {
  30     ring_buffer_.SetBuffer(raw_buffer_);
  31     Callbacks::Instance().RegisterSink(
  32         TraceSinkStartBlock, TraceSinkAddBytes, TraceSinkEndBlock, this);
  33   }
  34
  35   static void TraceSinkStartBlock(void* user_data, size_t size) {
  36     TraceBuffer* buffer = reinterpret_cast<TraceBuffer*>(user_data);
  37     if (size > PW_TRACE_BUFFER_MAX_BLOCK_SIZE_BYTES) {
  38       buffer->block_size_ = 0;  // Skip this block
  39       return;
  40     }
  41     buffer->block_size_ = static_cast<uint16_t>(size);
  42     buffer->block_idx_ = 0;
  43   }
  44
  45   static void TraceSinkAddBytes(void* user_data,
  46                                 const void* bytes,
  47                                 size_t size) {
  48     TraceBuffer* buffer = reinterpret_cast<TraceBuffer*>(user_data);
  49     if (buffer->block_size_ == 0 ||
  50         buffer->block_idx_ + size > buffer->block_size_) {
  51       return;  // Block is too large, skipping.
  52     }
  53     memcpy(&buffer->current_block_[buffer->block_idx_], bytes, size);
  54     buffer->block_idx_ += size;
  55   }
  56
  57   static void TraceSinkEndBlock(void* user_data) {
  58     TraceBuffer* buffer = reinterpret_cast<TraceBuffer*>(user_data);
  59     if (buffer->block_idx_ != buffer->block_size_) {
  60       return;  // Block is too large, skipping.
  61     }
  62     buffer->ring_buffer_.PushBack(std::span<const std::byte>(
  63         &buffer->current_block_[0], buffer->block_size_));
  64   }
  65
  66   pw::ring_buffer::PrefixedEntryRingBuffer& RingBuffer() {
  67     return ring_buffer_;
  68   };
  69
  70  private:
  71   uint16_t block_size_ = 0;
  72   uint16_t block_idx_ = 0;
  73   std::byte current_block_[PW_TRACE_BUFFER_MAX_BLOCK_SIZE_BYTES];
  74   std::byte raw_buffer_[PW_TRACE_BUFFER_SIZE_BYTES];
  75   pw::ring_buffer::PrefixedEntryRingBuffer ring_buffer_{false};
  76 };
  77
  78 #if PW_TRACE_BUFFER_SIZE_BYTES > 0
  79 TraceBuffer trace_buffer_instance;
  80 #endif  // PW_TRACE_BUFFER_SIZE_BYTES > 0
  81
  82 }  // namespace
  83
  84 void ClearBuffer() { trace_buffer_instance.RingBuffer().Clear(); }
  85
  86 pw::ring_buffer::PrefixedEntryRingBuffer* GetBuffer() {
  87   return &trace_buffer_instance.RingBuffer();
  88 }
  89
  90 }  // namespace trace
  91 }  // namespace pw