eth_sw_log.h

Go to the documentation of this file.

// Copyright 2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/cfgbus_core.h>
#include <satcat5/eth_address.h>
#include <satcat5/eth_switch.h>
#include <satcat5/io_writeable.h>
#include <satcat5/pkt_buffer.h>
#include <satcat5/polling.h>
#include <satcat5/udp_core.h>
 
namespace satcat5 {
    namespace eth {
        struct SwitchLogMessage {
            // Define "reason codes" used when dropping a packet.
            // These match the codes defined in "eth_frame_common.vhd".
            static constexpr u8
                REASON_KEEP     = 0x00, 
                DROP_OVERFLOW   = 0x01, 
                DROP_BADFCS     = 0x02, 
                DROP_BADFRM     = 0x03, 
                DROP_MCTRL      = 0x04, 
                DROP_VLAN       = 0x05, 
                DROP_VRATE      = 0x06, 
                DROP_PTPERR     = 0x07, 
                DROP_NO_ROUTE   = 0x08, 
                DROP_DISABLED   = 0x09, 
                DROP_UNKNOWN    = 0xFF; 
 
            // Other constants:
            static constexpr u8
                SRC_MASK    = 0x1F,     
                TYPE_MASK   = 0xE0,     
                TYPE_KEEP   = (0 << 5), 
                TYPE_DROP   = (1 << 5), 
                TYPE_SKIP   = (2 << 5); 
            static constexpr u32
                TIME_MASK   = 0xFFFFFF; 
            static constexpr unsigned
                LEN_BYTES   = 24;       
 
            // Raw packet fields
            u32 tstamp;                 
            u8  type_src;               
            satcat5::eth::Header hdr;   
            u32 meta;                   
 
            // Explicitly declare default constructor and assignment methods.
            SwitchLogMessage() = default;
            SwitchLogMessage(const SwitchLogMessage& t) = default;
            SwitchLogMessage& operator=(const SwitchLogMessage& t) = default;
 
            u8 reason() const;
 
            const char* reason_str() const;
 
            inline SATCAT5_PMASK_TYPE dstmask() const
                { return SATCAT5_PMASK_TYPE(meta); }
 
            // Other accessors
            u16 count_drop() const;         
            u16 count_keep() const;         
            inline u8 srcport() const       
                { return type_src & SRC_MASK; }
            inline u8 type() const          
                { return type_src & TYPE_MASK; }
 
            void init_keep(const satcat5::eth::Header& hdr, u8 src, u32 dst);
 
            void init_drop(const satcat5::eth::Header& hdr, u8 src, u8 why);
 
            void init_skip(u16 drop, u16 keep);
 
            void log_to(satcat5::log::LogBuffer& wr) const;
            void write_to(satcat5::io::Writeable* wr) const;
            bool read_from(satcat5::io::Readable* rd);
        };
 
        class SwitchLogHardware : public satcat5::poll::Timer {
        public:
            SwitchLogHardware(
                satcat5::eth::SwitchLogHandler* dst,
                satcat5::cfg::Register src);
 
        protected:
            // Event handlers.
            void timer_event() override;
 
            // Member variables.
            satcat5::eth::SwitchLogHandler* const m_dst;
            satcat5::cfg::Register m_src;
            satcat5::io::ArrayWriteStatic<SwitchLogMessage::LEN_BYTES> m_buff;
        };
 
        class SwitchLogStats : public satcat5::eth::SwitchLogHandler {
        public:
            struct TrafficStats {
                u32 bcast_frames;   
                u32 rcvd_frames;    
                u32 sent_frames;    
                u32 errct_ovr;      
                u32 errct_pkt;      
                u32 errct_total;    
            };
 
            TrafficStats get_port(unsigned idx);
 
            void log_packet(const satcat5::eth::SwitchLogMessage& msg) override;
 
        protected:
            SwitchLogStats(TrafficStats* buff, unsigned size);
 
            // Working buffers are provided by the parent class.
            TrafficStats* const m_stats;    
            const unsigned m_size;          
        };
 
        template <unsigned SIZE = satcat5::eth::PMASK_SIZE>
        class SwitchLogStatsStatic : public satcat5::eth::SwitchLogStats {
        public:
            SwitchLogStatsStatic() : SwitchLogStats(m_stats_buffer, SIZE) {}
 
        protected:
            satcat5::eth::SwitchLogStats::TrafficStats m_stats_buffer[SIZE];
        };
 
        class SwitchLogWriter
            : public satcat5::eth::SwitchLogHandler
            , protected satcat5::poll::Timer {
        public:
            explicit SwitchLogWriter(satcat5::io::Writeable* dst)
                : m_dst(dst), m_skip_drop(0), m_skip_keep(0) {}
 
            void log_packet(const satcat5::eth::SwitchLogMessage& msg) override;
 
        protected:
            // Event handlers.
            void timer_event() override;
 
            // Member variables.
            satcat5::io::Writeable* const m_dst;
            u16 m_skip_drop;
            u16 m_skip_keep;
        };
 
        template <unsigned NPKT>
        class SwitchLogBuffer : public satcat5::io::ReadableRedirect {
        public:
            SwitchLogBuffer()
                : ReadableRedirect(&m_buffer), m_writer(&m_buffer) {}
 
            inline void clear()
                { m_buffer.clear(); }
 
            inline SwitchLogHandler* writer()
                { return &m_writer; }
 
        protected:
            static constexpr unsigned NBYTES = NPKT * SwitchLogMessage::LEN_BYTES;
            satcat5::io::StreamBufferStatic<NBYTES> m_buffer;
            satcat5::eth::SwitchLogWriter m_writer;
        };
 
        class SwitchLogReader
            : protected satcat5::io::EventListener
            , protected satcat5::net::Protocol
            , protected satcat5::poll::Timer {
        public:
            void set_polling_interval(unsigned msec);
 
        protected:
            explicit SwitchLogReader(satcat5::io::Readable* src);
            SwitchLogReader(satcat5::net::Dispatch* iface, satcat5::net::Type filter);
            ~SwitchLogReader() SATCAT5_OPTIONAL_DTOR;
 
            virtual void log_event(const satcat5::eth::SwitchLogMessage& msg) = 0;
 
            // Event handlers.
            void data_rcvd(satcat5::io::Readable* src) override;
            void data_unlink(satcat5::io::Readable* src) override;
            void frame_rcvd(satcat5::io::LimitedRead& src) override;
            void timer_event() override;
 
            // Member variables.
            satcat5::io::Readable* m_src;
            satcat5::net::Dispatch* const m_iface;
        };
 
        class SwitchLogFormatter : public SwitchLogReader {
        public:
            explicit SwitchLogFormatter(
                satcat5::io::Readable* src,
                const char* lbl = "PktLog");
 
            explicit SwitchLogFormatter(
                satcat5::eth::Dispatch* iface,
                satcat5::eth::MacType etype = satcat5::eth::ETYPE_SWITCH_LOG,
                const char* lbl = "PktLog");
 
            explicit SwitchLogFormatter(
                satcat5::udp::Dispatch* iface,
                satcat5::udp::Port port = satcat5::udp::PORT_SWITCH_LOG,
                const char* lbl = "PktLog");
 
            void log_event(const satcat5::eth::SwitchLogMessage& msg) override;
 
        protected:
            const char* const m_label;
        };
 
        class SwitchLogToPort : public SwitchLogReader {
        public:
            SwitchLogToPort(
                satcat5::io::Readable* src,
                satcat5::eth::SwitchPort* dst,
                satcat5::udp::Dispatch* iface);
 
            SwitchLogToPort(
                satcat5::io::Readable* src,
                satcat5::io::Writeable* dst,
                satcat5::udp::Dispatch* iface);
 
            void connect(
                const satcat5::eth::MacAddr& addr,
                const satcat5::eth::MacType& type = satcat5::eth::ETYPE_SWITCH_LOG,
                const satcat5::eth::VlanTag& vtag = satcat5::eth::VTAG_NONE);
 
            void connect(
                const satcat5::udp::Addr& addr,
                const satcat5::udp::Port& port = satcat5::udp::PORT_SWITCH_LOG,
                const satcat5::eth::VlanTag& vtag = satcat5::eth::VTAG_NONE);
 
            inline void close() {
                m_eth.close();
                m_udp.close();
            }
 
            inline bool ready() const
                { return m_eth.ready() || m_udp.ready(); }
 
            void log_event(const satcat5::eth::SwitchLogMessage& msg) override;
 
        protected:
            satcat5::io::MultiWriterBypass m_dst_port;
            satcat5::io::Writeable* const m_dst_raw;
            satcat5::eth::Address m_eth;
            satcat5::udp::Address m_udp;
            bool m_first;
        };
    }
}