Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #ifndef vnsw_agent_pkt_trace_hpp
       7             : #define vnsw_agent_pkt_trace_hpp
       8             : 
       9             : #include <boost/scoped_array.hpp>
      10             : 
      11             : struct AgentHdr;
      12             : 
      13             : class PktTrace {
      14             : public:
      15             :     static const std::size_t kPktMaxTraceSize = 512;  // number of bytes stored
      16             :     static const std::size_t kPktNumBuffers = 100;     // number of buffers stored
      17             :     static const std::size_t kPktMaxNumBuffers = 512000;
      18             : 
      19             :     enum Direction {
      20             :         In,
      21             :         Out,
      22             :         Invalid
      23             :     };
      24             : 
      25             :     struct Pkt {
      26             :         Direction dir;
      27             :         std::size_t len;
      28             :         uint8_t pkt[kPktMaxTraceSize];
      29             : 
      30        3200 :         Pkt() : dir(Invalid), len(0) {}
      31             :         void Copy(Direction d, std::size_t l, uint8_t *msg,
      32             :                   std::size_t pkt_trace_size, const AgentHdr *hdr);
      33             :     };
      34             : 
      35             :     typedef boost::function<void(PktTrace::Pkt &)> Cb;
      36             : 
      37          32 :     PktTrace() : end_(-1), count_(0), num_buffers_(kPktNumBuffers),
      38          32 :                  pkt_trace_size_(kPktMaxTraceSize) {
      39          32 :                  pkt_buffer_.resize(num_buffers_);
      40          32 :     }
      41          32 :     virtual ~PktTrace() {}
      42             : 
      43             :     void AddPktTrace(Direction dir, std::size_t len, uint8_t *msg,
      44             :                      const AgentHdr *hdr);
      45           0 :     void Clear() {
      46           0 :         count_ = 0;
      47           0 :         end_ = -1;
      48           0 :     }
      49             : 
      50           0 :     void Iterate(Cb cb) {
      51           0 :         if (!cb.empty() && count_) {
      52           0 :             uint32_t start_ =
      53           0 :                 (count_ < num_buffers_) ? 0 : (end_ + 1) % num_buffers_;
      54           0 :             for (uint32_t i = 0; i < count_; i++)
      55           0 :                 cb(pkt_buffer_[(start_ + i) % num_buffers_]);
      56             :         }
      57           0 :     }
      58             : 
      59           0 :     std::size_t num_buffers() const { return num_buffers_; }
      60           0 :     std::size_t pkt_trace_size() const { return pkt_trace_size_; }
      61             : 
      62          32 :     void set_pkt_trace_size(std::size_t size) {
      63          32 :         pkt_trace_size_ = std::min(size, kPktMaxTraceSize);
      64          32 :     }
      65             : 
      66             :     // change number of buffers
      67           0 :     void set_num_buffers(uint32_t num_buffers) {
      68           0 :         if (num_buffers_ != num_buffers) {
      69             :             // existing buffers are cleared upon resizing
      70           0 :             count_ = 0;
      71           0 :             end_ = -1;
      72           0 :             num_buffers_ = num_buffers;
      73           0 :             pkt_buffer_.resize(num_buffers_);
      74             :         }
      75           0 :     }
      76             : 
      77             : private:
      78             :     uint32_t end_;
      79             :     uint32_t count_;
      80             :     std::size_t num_buffers_;
      81             :     std::size_t pkt_trace_size_;
      82             :     std::vector<Pkt> pkt_buffer_;
      83             : };
      84             : 
      85             : #endif