Line data    Source code

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