DpdkDevice.h

Go to the documentation of this file.

#ifndef PCAPPP_DPDK_DEVICE
#define PCAPPP_DPDK_DEVICE

#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;

            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;

        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;

        uint64_t getConfiguredRssHashFunction() const;

        std::vector<std::string> rssHashFunctionMaskToString(uint64_t rssHFMask) 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;

        std::string m_DeviceName;
        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 */