eth_switch.h

Go to the documentation of this file.

// Copyright 2024-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/list.h>
#include <satcat5/multi_buffer.h>
#include <satcat5/switch_cfg.h>
#include <satcat5/types.h>
 
#ifndef SATCAT5_PMASK_TYPE
#define SATCAT5_PMASK_TYPE u32
#endif
 
namespace satcat5 {
    namespace eth {
        constexpr SATCAT5_PMASK_TYPE PMASK_ALL(-1);
 
        constexpr SATCAT5_PMASK_TYPE PMASK_NONE(0);
 
        constexpr SATCAT5_PMASK_TYPE idx2mask(unsigned idx)
            { return (idx < 65536) ? (SATCAT5_PMASK_TYPE(1) << idx) : 0; }
 
        constexpr unsigned PMASK_SIZE()
            { return 8 * sizeof(SATCAT5_PMASK_TYPE); }
 
        class SwitchLogHandler {
        public:
            virtual void log_packet(const satcat5::eth::SwitchLogMessage& msg) = 0;
 
        protected:
            constexpr SwitchLogHandler() : m_next(nullptr) {}
 
        private:
            friend satcat5::util::ListCore;
            satcat5::eth::SwitchLogHandler* m_next;
        };
 
        class SwitchCore : public satcat5::io::MultiBuffer {
        public:
            SwitchCore(u8* buff, unsigned nbytes);
 
            inline satcat5::eth::SwitchPort* get_port(unsigned idx)
                { return m_ports.get_index(idx); }
 
            SATCAT5_PMASK_TYPE next_port_mask();
 
            inline u32 port_count() const
                { return m_ports.len(); }
 
            inline void set_debug(satcat5::io::Writeable* debug)
                { m_debug = debug; }
 
            inline void add_log(satcat5::eth::SwitchLogHandler* log)
                { m_pktlogs.add(log); }
            inline void remove_log(satcat5::eth::SwitchLogHandler* log)
                { m_pktlogs.remove(log); }
 
            void set_promiscuous(unsigned port_idx, bool enable);
            inline void set_promiscuous_mask(SATCAT5_PMASK_TYPE mask)
                { m_prom_mask = mask; }
            inline SATCAT5_PMASK_TYPE get_promiscuous_mask() const
                { return m_prom_mask; }
 
            void set_traffic_filter(u16 etype = 0);
            inline u16 get_traffic_filter() const
                { return m_stats_filter; }
 
            u32 get_traffic_count();
 
            void debug_if(const satcat5::eth::PluginPacket& pkt, unsigned mask) const;
 
            void debug_log(
                const satcat5::io::MultiPacket* pkt,
                u8 reason, SATCAT5_PMASK_TYPE dst = 0) const;
 
        protected:
            unsigned deliver(satcat5::io::MultiPacket* packet) override;
 
            void process_stats(const satcat5::eth::PluginPacket& pkt);
            satcat5::util::optional<unsigned> process_plugins(
                satcat5::eth::PluginPacket& pkt);
            satcat5::util::optional<unsigned> pkt_has_dropped(
                satcat5::eth::PluginPacket& pkt, unsigned mask);
            unsigned deliver_switch(const satcat5::eth::PluginPacket& pkt);
 
            friend satcat5::eth::PluginCore;
            void plugin_add(satcat5::eth::PluginCore* plugin);
            void plugin_remove(satcat5::eth::PluginCore* plugin);
 
            friend satcat5::eth::SwitchPort;
            void port_add(satcat5::eth::SwitchPort* port);
            void port_remove(satcat5::eth::SwitchPort* port);
            void port_remove(const SATCAT5_PMASK_TYPE& mask);
 
            satcat5::util::List<satcat5::eth::PluginCore> m_plugins;
 
            satcat5::util::List<satcat5::eth::SwitchPort> m_ports;
 
            // Other configuration variables.
            satcat5::io::Writeable* m_debug;
            satcat5::util::List<satcat5::eth::SwitchLogHandler> m_pktlogs;
            SATCAT5_PMASK_TYPE m_free_pmask;
            SATCAT5_PMASK_TYPE m_prom_mask;
            u16 m_stats_filter;
            u32 m_stats_count;
        };
 
        template <unsigned BSIZE = 65536>
        class SwitchCoreStatic : public satcat5::eth::SwitchCore {
        public:
            SwitchCoreStatic() : SwitchCore(m_buff, BSIZE) {}
        protected:
            u8 m_buff[BSIZE];
        };
 
        class SwitchPort
            : public satcat5::io::EventListener
            , public satcat5::io::MultiWriter
        {
        public:
            bool accept(SATCAT5_PMASK_TYPE dst_mask, satcat5::io::MultiPacket* packet);
 
            void plugin_add(satcat5::eth::PluginPort* plugin);
            void plugin_remove(satcat5::eth::PluginPort* plugin);
 
            void plugin_ingress(satcat5::eth::PluginPacket& pkt);
            void plugin_egress(satcat5::eth::PluginPacket& pkt);
 
            inline bool consistency() const
                { return m_egress.consistency(); }
 
            inline satcat5::io::MultiReaderPriority* get_egress()
                { return &m_egress; }
 
            inline satcat5::eth::SwitchCore* get_switch()
                { return m_switch; }
 
            inline void port_enable(bool enable)
                { m_egress.set_port_enable(enable); }
 
            inline bool port_enabled() const
                { return m_egress.get_port_enable(); }
 
            inline void port_flush()
                { write_abort(); m_egress.flush(); }
 
            inline unsigned port_index() const
                { return m_port_index; }
 
            inline SATCAT5_PMASK_TYPE port_mask() const
                { return m_port_mask; }
 
            inline void set_callback(satcat5::io::EventListener* cb)
                { m_egress.set_callback(cb); }
 
            inline satcat5::eth::VtagPolicy vlan_config() const
                { return m_vlan_cfg; }
 
            inline void vlan_config(const VtagPolicy& cfg)
                { m_vlan_cfg = cfg; }
 
            void write_abort() override;
 
            bool write_finalize() override;
 
        protected:
            explicit SwitchPort(
                satcat5::eth::SwitchCore* sw,
                satcat5::io::Writeable* dst);
            ~SwitchPort() SATCAT5_OPTIONAL_DTOR;
 
            // Override for EventListener callback.
            void data_rcvd(satcat5::io::Readable* src) override;
 
            satcat5::eth::SwitchCore* const m_switch;
 
            SATCAT5_PMASK_TYPE m_port_mask;
            const unsigned m_port_index;
 
            satcat5::eth::VtagPolicy m_vlan_cfg;
            // TODO: Support for PAUSE commands?
 
            // Egress pipeline.
            satcat5::io::MultiReaderPriority m_egress;  
            satcat5::io::Writeable* const m_eg_dst;     
            bool m_eg_hdr;                              
 
            satcat5::util::List<satcat5::eth::PluginPort> m_plugins;
 
        private:
            // Linked list of other SwitchPort objects.
            friend satcat5::util::ListCore;
            satcat5::eth::SwitchPort* m_next;
        };
    }
}