DpdkDevice.h

Go to the documentation of this file.

#ifndef PCAPPP_DPDK_DEVICE
#define PCAPPP_DPDK_DEVICE
 
#include <pthread.h>
#include <time.h>
#include "MacAddress.h"
#include "SystemUtils.h"
#include "Device.h"
#include "MBufRawPacket.h"
 
struct rte_mbuf;
struct rte_mempool;
struct rte_eth_conf;
struct rte_eth_dev_tx_buffer;
 
namespace pcpp
{
 
#define DPDK_MAX_RX_QUEUES 16
#define DPDK_MAX_TX_QUEUES 16
 
    class DpdkDeviceList;
    class DpdkDevice;
 
    enum DpdkPMDType {
        PMD_UNKNOWN,
        PMD_BOND,
        PMD_E1000EM,
        PMD_IGB,
        PMD_IGBVF,
        PMD_ENIC,
        PMD_FM10K,
        PMD_I40E,
        PMD_I40EVF,
        PMD_IXGBE,
        PMD_IXGBEVF,
        PMD_MLX4,
        PMD_NULL,
        PMD_PCAP,
        PMD_RING,
        PMD_VIRTIO,
        PMD_VMXNET3,
        PMD_XENVIRT,
        PMD_AF_PACKET
    };
 
    typedef void (*OnDpdkPacketsArriveCallback)(MBufRawPacket* packets, uint32_t numOfPackets, uint8_t threadId, DpdkDevice* device, void* userCookie);
 
    class DpdkDevice : public IDevice
    {
        friend class DpdkDeviceList;
        friend class MBufRawPacket;
    public:
 
        enum DpdkRssHashFunction
        {
            RSS_IPV4                = 0x1,
            RSS_FRAG_IPV4           = 0x2,
            RSS_NONFRAG_IPV4_TCP    = 0x4,
            RSS_NONFRAG_IPV4_UDP    = 0x8,
            RSS_NONFRAG_IPV4_SCTP   = 0x10,
            RSS_NONFRAG_IPV4_OTHER  = 0x20,
            RSS_IPV6                = 0x40,
            RSS_FRAG_IPV6           = 0x80,
            RSS_NONFRAG_IPV6_TCP    = 0x100,
            RSS_NONFRAG_IPV6_UDP    = 0x200,
            RSS_NONFRAG_IPV6_SCTP   = 0x400,
            RSS_NONFRAG_IPV6_OTHER  = 0x800,
            RSS_L2_PAYLOAD          = 0x1000,
            RSS_IPV6_EX             = 0x2000,
            RSS_IPV6_TCP_EX         = 0x4000,
            RSS_IPV6_UDP_EX         = 0x8000,
            RSS_PORT                = 0x10000,
            RSS_VXLAN               = 0x20000,
            RSS_GENEVE              = 0x40000,
            RSS_NVGRE               = 0x80000
        };
 
        struct DpdkDeviceConfiguration
        {
            uint16_t receiveDescriptorsNumber;
 
            uint16_t transmitDescriptorsNumber;
 
            uint16_t flushTxBufferTimeout;
 
            uint8_t* rssKey;
 
            uint8_t rssKeyLength;
 
            uint64_t rssHashFunction;
 
            DpdkDeviceConfiguration(uint16_t receiveDescriptorsNumber = 128,
                    uint16_t transmitDescriptorsNumber = 512,
                    uint16_t flushTxBufferTimeout = 100,
                    uint64_t rssHashFunction = RSS_IPV4 | RSS_IPV6,
                    uint8_t* rssKey = DpdkDevice::m_RSSKey,
                    uint8_t rssKeyLength = 40)
            {
                this->receiveDescriptorsNumber = receiveDescriptorsNumber;
                this->transmitDescriptorsNumber = transmitDescriptorsNumber;
                this->flushTxBufferTimeout = flushTxBufferTimeout;
                this->rssKey = rssKey;
                this->rssKeyLength = rssKeyLength;
                this->rssHashFunction = rssHashFunction;
            }
        };
 
        struct LinkStatus
        {
            enum LinkDuplex 
            {
                FULL_DUPLEX, 
                HALF_DUPLEX 
            };
 
            bool linkUp;
            int linkSpeedMbps;
            LinkDuplex linkDuplex;
        };
 
        struct RxTxStats
        {
            uint64_t packets;
            uint64_t bytes;
            uint64_t packetsPerSec;
            uint64_t bytesPerSec;
        };
 
        struct DpdkDeviceStats
        {
            uint8_t devId;
            timespec timestamp;
            RxTxStats rxStats[DPDK_MAX_RX_QUEUES];
            RxTxStats txStats[DPDK_MAX_RX_QUEUES];
            RxTxStats aggregatedRxStats;
            RxTxStats aggregatedTxStats;
            uint64_t rxPacketsDropeedByHW;
            uint64_t rxErroneousPackets;
            uint64_t rxMbufAlocFailed;
        };
 
        virtual ~DpdkDevice();
 
        int getDeviceId() const { return m_Id; }
        std::string getDeviceName() const { return std::string(m_DeviceName); }
 
        MacAddress getMacAddress() const { return m_MacAddress; }
 
        std::string getPMDName() const { return m_PMDName; }
 
        DpdkPMDType getPMDType() const { return m_PMDType; }
 
        std::string getPciAddress() const { return m_PciAddress; }
 
        uint16_t getMtu() const { return m_DeviceMtu; }
 
        bool setMtu(uint16_t newMtu);
 
        bool isVirtual() const;
 
        void getLinkStatus(LinkStatus& linkStatus) const;
 
        uint32_t getCurrentCoreId() const;
 
        uint16_t getNumOfOpenedRxQueues() const { return m_NumOfRxQueuesOpened; }
 
        uint16_t getNumOfOpenedTxQueues() const { return m_NumOfTxQueuesOpened; }
 
        uint16_t getTotalNumOfRxQueues() const { return m_TotalAvailableRxQueues; }
 
        uint16_t getTotalNumOfTxQueues() const { return m_TotalAvailableTxQueues; }
 
 
        uint16_t receivePackets(MBufRawPacketVector& rawPacketsArr, uint16_t rxQueueId) const;
 
        uint16_t receivePackets(MBufRawPacket** rawPacketsArr, uint16_t rawPacketArrLength, uint16_t rxQueueId) const;
 
        uint16_t receivePackets(Packet** packetsArr, uint16_t packetsArrLength, uint16_t rxQueueId) const;
 
        uint16_t sendPackets(MBufRawPacket** rawPacketsArr, uint16_t arrLength, uint16_t txQueueId = 0, bool useTxBuffer = false);
 
        uint16_t sendPackets(Packet** packetsArr, uint16_t arrLength, uint16_t txQueueId = 0, bool useTxBuffer = false);
 
        uint16_t sendPackets(MBufRawPacketVector& rawPacketsVec, uint16_t txQueueId = 0, bool useTxBuffer = false);
 
        uint16_t sendPackets(RawPacketVector& rawPacketsVec, uint16_t txQueueId = 0, bool useTxBuffer = false);
 
        bool sendPacket(RawPacket& rawPacket, uint16_t txQueueId = 0, bool useTxBuffer = false);
 
        bool sendPacket(MBufRawPacket& rawPacket, uint16_t txQueueId = 0, bool useTxBuffer = false);
 
        bool sendPacket(Packet& packet, uint16_t txQueueId = 0, bool useTxBuffer = false);
 
        bool setFilter(GeneralFilter& filter);
 
        bool setFilter(std::string filterAsString);
 
        bool openMultiQueues(uint16_t numOfRxQueuesToOpen, uint16_t numOfTxQueuesToOpen, const DpdkDeviceConfiguration& config = DpdkDeviceConfiguration());
 
        bool startCaptureSingleThread(OnDpdkPacketsArriveCallback onPacketsArrive, void* onPacketsArriveUserCookie);
 
        bool startCaptureMultiThreads(OnDpdkPacketsArriveCallback onPacketsArrive, void* onPacketsArriveUserCookie, CoreMask coreMask);
 
        void stopCapture();
 
        int getAmountOfFreeMbufs() const;
 
        int getAmountOfMbufsInUse() const;
 
        void getStatistics(DpdkDeviceStats& stats) const;
 
        void clearStatistics();
 
        uint16_t flushTxBuffer(bool flushOnlyIfTimeoutExpired = false, uint16_t txQueueId = 0);
 
        bool isDeviceSupportRssHashFunction(DpdkRssHashFunction rssHF) const;
 
        bool isDeviceSupportRssHashFunction(uint64_t rssHFMask) const;
 
        uint64_t getSupportedRssHashFunctions() const;
 
 
        //overridden methods
 
        bool open() { return openMultiQueues(1, 1); };
 
        void close();
 
    private:
 
        struct DpdkCoreConfiguration
        {
            int RxQueueId;
            bool IsCoreInUse;
 
            void clear() { RxQueueId = -1; IsCoreInUse = false; }
 
            DpdkCoreConfiguration() : RxQueueId(-1), IsCoreInUse(false) {}
        };
 
        DpdkDevice(int port, uint32_t mBufPoolSize);
        bool initMemPool(struct rte_mempool*& memPool, const char* mempoolName, uint32_t mBufPoolSize);
 
        bool configurePort(uint8_t numOfRxQueues, uint8_t numOfTxQueues);
        bool initQueues(uint8_t numOfRxQueuesToInit, uint8_t numOfTxQueuesToInit);
        bool startDevice();
 
        static int dpdkCaptureThreadMain(void* ptr);
 
        void clearCoreConfiguration();
        bool initCoreConfigurationByCoreMask(CoreMask coreMask);
        int getCoresInUseCount() const;
 
        void setDeviceInfo();
 
        typedef rte_mbuf* (*PacketIterator)(void* packetStorage, int index);
        uint16_t sendPacketsInner(uint16_t txQueueId, void* packetStorage, PacketIterator iter, int arrLength, bool useTxBuffer);
 
        uint64_t convertRssHfToDpdkRssHf(uint64_t rssHF) const;
        uint64_t convertDpdkRssHfToRssHf(uint64_t dpdkRssHF) const;
 
        char m_DeviceName[30];
        DpdkPMDType m_PMDType;
        std::string m_PMDName;
        std::string m_PciAddress;
 
        DpdkDeviceConfiguration m_Config;
 
        int m_Id;
        MacAddress m_MacAddress;
        uint16_t m_DeviceMtu;
        struct rte_mempool* m_MBufMempool;
        struct rte_eth_dev_tx_buffer** m_TxBuffers;
        uint64_t m_TxBufferDrainTsc;
        uint64_t* m_TxBufferLastDrainTsc;
        DpdkCoreConfiguration m_CoreConfiguration[MAX_NUM_OF_CORES];
        uint16_t m_TotalAvailableRxQueues;
        uint16_t m_TotalAvailableTxQueues;
        uint16_t m_NumOfRxQueuesOpened;
        uint16_t m_NumOfTxQueuesOpened;
        OnDpdkPacketsArriveCallback m_OnPacketsArriveCallback;
        void* m_OnPacketsArriveUserCookie;
        bool m_StopThread;
 
        bool m_WasOpened;
 
         // RSS key used by the NIC for load balancing the packets between cores
        static uint8_t m_RSSKey[40];
 
        mutable DpdkDeviceStats m_PrevStats;
    };
 
} // namespace pcpp
 
#endif /* PCAPPP_DPDK_DEVICE */