DpdkDevice.h

Go to the documentation of this file.

#pragma once
 
// GCOVR_EXCL_START
 
#include <pthread.h>
#include <time.h>
#include <vector>
#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
#define PCPP_RSS_HASH_MAGIC_NUMBER 0x123456
 
    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_NONE = 0,
            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,
            RSS_ALL_SUPPORTED = -1,
            RSS_DEFAULT = PCPP_RSS_HASH_MAGIC_NUMBER
        };
 
        struct DpdkDeviceConfiguration
        {
            uint16_t receiveDescriptorsNumber;
 
            uint16_t transmitDescriptorsNumber;
 
            uint16_t flushTxBufferTimeout;
 
            uint8_t* rssKey;
 
            uint8_t rssKeyLength;
 
            uint64_t rssHashFunction;
 
            explicit DpdkDeviceConfiguration(uint16_t receiveDescriptorsNumber = 128,
                                             uint16_t transmitDescriptorsNumber = 512,
                                             uint16_t flushTxBufferTimeout = 100,
                                             uint64_t rssHashFunction = RSS_DEFAULT,
                                             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 rxPacketsDroppedByHW;
            uint64_t rxErroneousPackets;
            uint64_t rxMbufAlocFailed;
        };
 
        virtual ~DpdkDevice();
 
        int getDeviceId() const
        {
            return m_Id;
        }
        std::string getDeviceName() const
        {
            return 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;
 
        bool 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;
 
        uint64_t getConfiguredRssHashFunction() const;
 
        std::vector<std::string> rssHashFunctionMaskToString(uint64_t rssHFMask) const;
 
        // overridden methods
 
        bool open() override
        {
            return openMultiQueues(1, 1);
        };
 
        void close() override;
 
    private:
        struct DpdkCoreConfiguration
        {
            int RxQueueId;
            bool IsCoreInUse;
 
            void clear()
            {
                RxQueueId = -1;
                IsCoreInUse = false;
            }
 
            DpdkCoreConfiguration() : RxQueueId(-1), IsCoreInUse(false)
            {}
        };
 
        DpdkDevice(int port, uint32_t mBufPoolSize, uint16_t mMbufDataSize);
        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;
 
        std::string m_DeviceName;
        DpdkPMDType m_PMDType;
        std::string m_PMDName;
        std::string m_PciAddress;
 
        DpdkDeviceConfiguration m_Config;
 
        int m_Id;
        MacAddress m_MacAddress;
        int16_t m_DeviceSocketId;
        uint16_t m_DeviceMtu;
        uint16_t m_MBufDataSize;
        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
 
// GCOVR_EXCL_STOP