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 "RawPacket.h"
#include "PcapLiveDevice.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
    };

    class DpdkDevice;

    #define MBUFRAWPACKET_OBJECT_TYPE 1

    class MBufRawPacket : public RawPacket
    {
        friend class DpdkDevice;

    private:
        struct rte_mbuf* m_MBuf;
        DpdkDevice* m_Device;
        bool m_FreeMbuf;

        void setMBuf(struct rte_mbuf* mBuf, timeval timestamp);
    public:

        MBufRawPacket() : RawPacket(), m_MBuf(NULL), m_Device(NULL), m_FreeMbuf(true) { m_DeleteRawDataAtDestructor = false; }

        virtual ~MBufRawPacket();

        MBufRawPacket(const MBufRawPacket& other);

        bool init(DpdkDevice* device);

        bool initFromRawPacket(const RawPacket* rawPacket, DpdkDevice* device);

        inline rte_mbuf* getMBuf() { return m_MBuf; }

        // overridden methods

        virtual inline uint8_t getObjectType() const { return MBUFRAWPACKET_OBJECT_TYPE; }

        MBufRawPacket& operator=(const MBufRawPacket& other);

        bool setRawData(const uint8_t* pRawData, int rawDataLen, timeval timestamp, LinkLayerType layerType = LINKTYPE_ETHERNET, int frameLength = -1);

        void clear();

        void appendData(const uint8_t* dataToAppend, size_t dataToAppendLen);

        void insertData(int atIndex, const uint8_t* dataToInsert, size_t dataToInsertLen);

        bool removeData(int atIndex, size_t numOfBytesToRemove);

        bool reallocateData(size_t newBufferLength);

        inline void setFreeMbuf(bool val = true) { m_FreeMbuf = val; }
    };

    typedef void (*OnDpdkPacketsArriveCallback)(MBufRawPacket* packets, uint32_t numOfPackets, uint8_t threadId, DpdkDevice* device, void* userCookie);

    typedef PointerVector<MBufRawPacket> MBufRawPacketVector;

    class PciAddress
    {
    public:
        PciAddress() { domain = 0; bus = 0; devid = 0; function = 0; }

        PciAddress(uint16_t domain, uint8_t bus, uint8_t devid, uint8_t function)
        {
            this->domain = domain;
            this->bus = bus;
            this->devid = devid;
            this->function = function;
        }

        uint16_t domain;
        uint8_t bus;
        uint8_t devid;
        uint8_t function;

        std::string toString()
        {
            char pciString[15];
            snprintf(pciString, 15, "%04x:%02x:%02x.%x", domain, bus, devid, function);
            return std::string(pciString);
        }

        bool operator==(const PciAddress &other) const
        {
            return (domain == other.domain && bus == other.bus && devid == other.devid && function == other.function);
        }
    };


    class DpdkDevice : public IPcapDevice
    {
        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();

        inline int getDeviceId() { return m_Id; }
        inline std::string getDeviceName() { return std::string(m_DeviceName); }

        inline MacAddress getMacAddress() { return m_MacAddress; }

        inline std::string getPMDName() { return m_PMDName; }

        inline DpdkPMDType getPMDType() { return m_PMDType; }

        inline PciAddress getPciAddress() { return m_PciAddress; }

        inline uint16_t getMtu() { return m_DeviceMtu; }

        bool setMtu(uint16_t newMtu);

        bool isVirtual();

        void getLinkStatus(LinkStatus& linkStatus);

        uint32_t getCurrentCoreId();

        uint16_t getNumOfOpenedRxQueues() { return m_NumOfRxQueuesOpened; }

        uint16_t getNumOfOpenedTxQueues() { return m_NumOfTxQueuesOpened; }

        uint16_t getTotalNumOfRxQueues() { return m_TotalAvailableRxQueues; }

        uint16_t getTotalNumOfTxQueues() { return m_TotalAvailableTxQueues; }


        uint16_t receivePackets(MBufRawPacketVector& rawPacketsArr, uint16_t rxQueueId);

        uint16_t receivePackets(MBufRawPacket** rawPacketsArr, uint16_t rawPacketArrLength, uint16_t rxQueueId);

        uint16_t receivePackets(Packet** packetsArr, uint16_t packetsArrLength, uint16_t rxQueueId);

        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();

        int getAmountOfMbufsInUse();

        //overridden methods

        bool open() { return openMultiQueues(1, 1); };

        void close();

        void getStatistics(pcap_stat& stats);

        void getStatistics(DpdkDeviceStats& stats);

        void clearStatistics();

        uint16_t flushTxBuffer(bool flushOnlyIfTimeoutExpired = false, uint16_t txQueueId = 0);

        bool isDeviceSupportRssHashFunction(DpdkRssHashFunction rssHF);

        bool isDeviceSupportRssHashFunction(uint64_t rssHFMask);

        uint64_t getSupportedRssHashFunctions();

    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();

        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);
        uint64_t convertDpdkRssHfToRssHf(uint64_t dpdkRssHF);

        char m_DeviceName[30];
        DpdkPMDType m_PMDType;
        std::string m_PMDName;
        PciAddress 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];

        DpdkDeviceStats m_PrevStats;
    };

} // namespace pcpp

#endif /* PCAPPP_DPDK_DEVICE */