The Tcpdump Group git mirrors - libpcap/blob - pcap-dpdk.c

   1 /*
   2  * Copyright (C) 2018 jingle YANG. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  *   1. Redistributions of source code must retain the above copyright
   9  *      notice, this list of conditions and the following disclaimer.
  10  *   2. Redistributions in binary form must reproduce the above copyright
  11  *      notice, this list of conditions and the following disclaimer in the
  12  *      documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28 Date: Dec 16, 2018
  29
  30 Description:
  31 1. Pcap-dpdk provides libpcap the ability to use DPDK with the device name as dpdk:{portid}, such as dpdk:0.
  32 2. DPDK is a set of libraries and drivers for fast packet processing. (https://www.dpdk.org/)
  33 3. The testprogs/capturetest provides 6.4Gbps/800,000 pps on Intel 10-Gigabit X540-AT2 with DPDK 18.11.
  34
  35 Limitations:
  36 1. By default DPDK support is no, unless you explicitly set --enable-dpdk with ./configure or -DDISABLE_DPDK=OFF with cmake.
  37 2. Only support link libdpdk.so dynamicly, because the libdpdk.a will not work correctly.
  38 3. Only support read operation, and packet injection has not been supported yet.
  39
  40 Usage:
  41 1. compile DPDK as shared library and install.(https://github.com/DPDK/dpdk.git)
  42
  43 You shall modify the file $RTE_SDK/$RTE_TARGET/.config and set:
  44 CONFIG_RTE_BUILD_SHARED_LIB=y
  45 By the following command:
  46 sed -i 's/CONFIG_RTE_BUILD_SHARED_LIB=n/CONFIG_RTE_BUILD_SHARED_LIB=y/' $RTE_SDK/$RTE_TARGET/.config
  47
  48 2. launch l2fwd that is one of DPDK examples correctly, and get device information.
  49
  50 You shall learn how to bind nic with DPDK-compatible driver by $RTE_SDK/usertools/dpdk-devbind.py, such as igb_uio.
  51 And enable hugepages by dpdk-setup.sh
  52
  53 Then launch the l2fwd with dynamic dirver support. For example:
  54 $RTE_SDK/examples/l2fwd/$RTE_TARGET/l2fwd -dlibrte_pmd_e1000.so -dlibrte_pmd_ixgbe.so -dlibrte_mempool_ring.so -- -p 0x1
  55
  56 3. compile libpcap with dpdk options.
  57
  58 In order to find inlucde and lib automatically, you shall export DPDK envionment variable which are used for compiling DPDK.
  59
  60 export RTE_SDK={your DPDK base directory}
  61 export RTE_TARGET={your target name}
  62
  63 3.1 with configure
  64
  65 ./configure --enable-dpdk --with-dpdk-includes=$RTE_SDK/$RTE_TARGET/include --with-dpdk-libraries=$RTE_SDK/$RTE_TARGET/lib && make -s all && make -s testprogs && make install
  66
  67 3.2 with cmake
  68
  69 mkdir -p build && cd build && cmake -DDISABLE_DPDK=OFF -DDPDK_INC_DIR=$RTE_SDK/$RTE_TARGET/include -DDPDK_LIB_DIR=$RTE_SDK/$RTE_TARGET/lib" ../ && make -s all && make -s testprogs && make install
  70
  71 4. link your own program with libpcap, and use DPDK with the device name as dpdk:{portid}, such as dpdk:0.
  72 And you shall set DPDK configure options by environment variable DPDK_CFG
  73 For example, the testprogs/capturetest could be lanched by:
  74
  75 env DPDK_CFG="--log-level=debug -l0 -dlibrte_pmd_e1000.so -dlibrte_pmd_ixgbe.so -dlibrte_mempool_ring.so" ./capturetest -i dpdk:0
  76 */
  77
  78 #ifdef HAVE_CONFIG_H
  79 #include <config.h>
  80 #endif
  81
  82 #include <ctype.h>
  83 #include <errno.h>
  84 #include <netdb.h>
  85 #include <stdio.h>
  86 #include <stdlib.h>
  87 #include <string.h>
  88 #include <unistd.h>
  89 #include <time.h>
  90
  91 #include <sys/time.h>
  92
  93 //header for calling dpdk
  94 #include <rte_common.h>
  95 #include <rte_log.h>
  96 #include <rte_malloc.h>
  97 #include <rte_memory.h>
  98 #include <rte_eal.h>
  99 #include <rte_launch.h>
 100 #include <rte_atomic.h>
 101 #include <rte_cycles.h>
 102 #include <rte_lcore.h>
 103 #include <rte_per_lcore.h>
 104 #include <rte_branch_prediction.h>
 105 #include <rte_interrupts.h>
 106 #include <rte_random.h>
 107 #include <rte_debug.h>
 108 #include <rte_ether.h>
 109 #include <rte_ethdev.h>
 110 #include <rte_mempool.h>
 111 #include <rte_mbuf.h>
 112 #include <rte_bus.h>
 113
 114 #include "pcap-int.h"
 115 #include "pcap-dpdk.h"
 116
 117 #define DPDK_DEF_LOG_LEV RTE_LOG_ERR
 118 static int is_dpdk_pre_inited=0;
 119 #define DPDK_LIB_NAME "libpcap_dpdk"
 120 #define DPDK_DESC "Data Plane Development Kit (DPDK) Interface"
 121 #define DPDK_ERR_PERM_MSG "permission denied, DPDK needs root permission"
 122 #define DPDK_ARGC_MAX 64
 123 #define DPDK_CFG_MAX_LEN 1024
 124 #define DPDK_DEV_NAME_MAX 32
 125 #define DPDK_DEV_DESC_MAX 512
 126 #define DPDK_CFG_ENV_NAME "DPDK_CFG"
 127 #define DPDK_DEF_MIN_SLEEP_MS 100
 128 static char dpdk_cfg_buf[DPDK_CFG_MAX_LEN];
 129 #define DPDK_MAC_ADDR_SIZE 32
 130 #define DPDK_DEF_MAC_ADDR "00:00:00:00:00:00"
 131 #define DPDK_PCI_ADDR_SIZE 16
 132 #define DPDK_DEF_CFG "--log-level=error -l0 -dlibrte_pmd_e1000.so -dlibrte_pmd_ixgbe.so -dlibrte_mempool_ring.so"
 133 #define DPDK_PREFIX "dpdk:"
 134 #define DPDK_PORTID_MAX 65535U
 135 #define MBUF_POOL_NAME "mbuf_pool"
 136 #define DPDK_TX_BUF_NAME "tx_buffer"
 137 //The number of elements in the mbuf pool.
 138 #define DPDK_NB_MBUFS 8192U
 139 #define MEMPOOL_CACHE_SIZE 256
 140 #define MAX_PKT_BURST 32
 141 // Configurable number of RX/TX ring descriptors
 142 #define RTE_TEST_RX_DESC_DEFAULT 1024
 143 #define RTE_TEST_TX_DESC_DEFAULT 1024
 144
 145 static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 146 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 147
 148 #define RTE_ETH_PCAP_SNAPLEN ETHER_MAX_JUMBO_FRAME_LEN
 149
 150 static struct rte_eth_dev_tx_buffer *tx_buffer;
 151
 152 struct dpdk_ts_helper{
 153         struct timeval start_time;
 154         uint64_t start_cycles;
 155         uint64_t hz;
 156 };
 157 struct pcap_dpdk{
 158         pcap_t * orig;
 159         uint16_t portid; // portid of DPDK
 160         int must_clear_promisc;
 161         uint64_t rx_pkts;
 162         uint64_t bpf_drop;
 163         int nonblock;
 164         struct timeval prev_ts;
 165         struct rte_eth_stats prev_stats;
 166         struct timeval curr_ts;
 167         struct rte_eth_stats curr_stats;
 168         uint64_t pps;
 169         uint64_t bps;
 170         struct rte_mempool * pktmbuf_pool;
 171         struct dpdk_ts_helper ts_helper;
 172         struct ether_addr eth_addr;
 173         char mac_addr[DPDK_MAC_ADDR_SIZE];
 174         char pci_addr[DPDK_PCI_ADDR_SIZE];
 175         unsigned char pcap_tmp_buf[RTE_ETH_PCAP_SNAPLEN];
 176 };
 177
 178 static struct rte_eth_conf port_conf = {
 179         .rxmode = {
 180                 .split_hdr_size = 0,
 181         },
 182         .txmode = {
 183                 .mq_mode = ETH_MQ_TX_NONE,
 184         },
 185 };
 186
 187 static int dpdk_init_timer(struct pcap_dpdk *pd){
 188         gettimeofday(&(pd->ts_helper.start_time),NULL);
 189         pd->ts_helper.start_cycles = rte_get_timer_cycles();
 190         pd->ts_helper.hz = rte_get_timer_hz();
 191         if (pd->ts_helper.hz == 0){
 192                 return -1;
 193         }
 194         return 0;
 195 }
 196 static inline void calculate_timestamp(struct dpdk_ts_helper *helper,struct timeval *ts)
 197 {
 198         uint64_t cycles;
 199         // delta
 200         struct timeval cur_time;
 201         cycles = rte_get_timer_cycles() - helper->start_cycles;
 202         cur_time.tv_sec = (time_t)(cycles/helper->hz);
 203         cur_time.tv_usec = (suseconds_t)((cycles%helper->hz)*1e6/helper->hz);
 204         timeradd(&(helper->start_time), &cur_time, ts);
 205 }
 206
 207 static uint32_t dpdk_gather_data(unsigned char *data, int len, struct rte_mbuf *mbuf)
 208 {
 209         uint32_t total_len = 0;
 210         while (mbuf && (total_len+mbuf->data_len) < len ){
 211                 rte_memcpy(data+total_len, rte_pktmbuf_mtod(mbuf,void *),mbuf->data_len);
 212                 total_len+=mbuf->data_len;
 213                 mbuf=mbuf->next;
 214         }
 215         return total_len;
 216 }
 217
 218 static int pcap_dpdk_dispatch(pcap_t *p, int max_cnt, pcap_handler cb, u_char *cb_arg)
 219 {
 220         struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
 221         int burst_cnt = 0;
 222         int nb_rx=0;
 223         struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
 224         struct rte_mbuf *m;
 225         struct pcap_pkthdr pcap_header;
 226         uint16_t portid = pd->portid;
 227         // In DPDK, pkt_len is sum of lengths for all segments. And data_len is for one segment
 228         uint32_t pkt_len = 0;
 229         int caplen = 0;
 230         u_char *bp = NULL;
 231         int i=0;
 232         unsigned int gather_len =0;
 233         int pkt_cnt = 0;
 234         int is_accepted=0;
 235         u_char *large_buffer=NULL;
 236
 237         pd->rx_pkts = 0;
 238         if ( !PACKET_COUNT_IS_UNLIMITED(max_cnt) && max_cnt < MAX_PKT_BURST){
 239                 burst_cnt = max_cnt;
 240         }else{
 241                 burst_cnt = MAX_PKT_BURST;
 242         }
 243
 244         while( PACKET_COUNT_IS_UNLIMITED(max_cnt) || pkt_cnt < max_cnt){
 245                 if (p->break_loop){
 246                         break;
 247                 }
 248                 nb_rx = (int)rte_eth_rx_burst(portid, 0, pkts_burst, burst_cnt);
 249                 pkt_cnt += nb_rx;
 250                 for ( i = 0; i < nb_rx; i++) {
 251                         m = pkts_burst[i];
 252                         calculate_timestamp(&(pd->ts_helper),&(pcap_header.ts));
 253                         pkt_len = rte_pktmbuf_pkt_len(m);
 254                         // caplen = min(pkt_len, p->snapshot);
 255                         // caplen will not be changed, no matter how long the rte_pktmbuf
 256                         caplen = pkt_len < p->snapshot ? pkt_len: p->snapshot;
 257                         pcap_header.caplen = caplen;
 258                         pcap_header.len = pkt_len;
 259                         // volatile prefetch
 260                         rte_prefetch0(rte_pktmbuf_mtod(m, void *));
 261                         bp = NULL;
 262                         if (m->nb_segs == 1)
 263                         {
 264                                 bp = rte_pktmbuf_mtod(m, u_char *);
 265                         }else{
 266                                 // use fast buffer pcap_tmp_buf if pkt_len is small, no need to call malloc and free
 267                                 if ( pkt_len <= ETHER_MAX_JUMBO_FRAME_LEN)
 268                                 {
 269                                         gather_len = dpdk_gather_data(pd->pcap_tmp_buf, RTE_ETH_PCAP_SNAPLEN, m);
 270                                         bp = pd->pcap_tmp_buf;
 271                                 }else{
 272                                         // need call free later
 273                                         large_buffer = (u_char *)malloc(caplen*sizeof(u_char));
 274                                         gather_len = dpdk_gather_data(large_buffer, caplen, m);
 275                                         bp = large_buffer;
 276                                 }
 277
 278                         }
 279                         if (bp){
 280                                 if (p->fcode.bf_insns==NULL || pcap_filter(p->fcode.bf_insns, bp, pcap_header.len, pcap_header.caplen)){
 281                                         cb(cb_arg, &pcap_header, bp);
 282                                 }else{
 283                                         pd->bpf_drop++;
 284                                 }
 285                         }
 286                         //free all pktmbuf
 287                         rte_pktmbuf_free(m);
 288                         if (large_buffer){
 289                                 free(large_buffer);
 290                                 large_buffer=NULL;
 291                         }
 292                 }
 293         }
 294         pd->rx_pkts = pkt_cnt;
 295         return pd->rx_pkts;
 296 }
 297
 298 static int pcap_dpdk_inject(pcap_t *p, const void *buf _U_, int size _U_)
 299 {
 300         //not implemented yet
 301         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 302                 errno, "dpdk error: Inject function has not been implemented yet");
 303         return PCAP_ERROR;
 304 }
 305
 306 static void pcap_dpdk_close(pcap_t *p)
 307 {
 308         struct pcap_dpdk *pd = p->priv;
 309         if (pd==NULL)
 310         {
 311                 return;
 312         }
 313         if (pd->must_clear_promisc)
 314         {
 315                 rte_eth_promiscuous_disable(pd->portid);
 316         }
 317         rte_eth_dev_stop(pd->portid);
 318         rte_eth_dev_close(pd->portid);
 319         pcap_cleanup_live_common(p);
 320 }
 321
 322 static void nic_stats_display(struct pcap_dpdk *pd)
 323 {
 324         uint16_t portid = pd->portid;
 325         struct rte_eth_stats stats;
 326         rte_eth_stats_get(portid, &stats);
 327         RTE_LOG(INFO,USER1, "portid:%d, RX-packets: %-10"PRIu64"  RX-errors:  %-10"PRIu64
 328                "  RX-bytes:  %-10"PRIu64"  RX-Imissed:  %-10"PRIu64"\n", portid, stats.ipackets, stats.ierrors,
 329                stats.ibytes,stats.imissed);
 330         RTE_LOG(INFO,USER1, "portid:%d, RX-PPS: %-10"PRIu64" RX-Mbps: %.2lf\n", portid, pd->pps, pd->bps/1e6f );
 331 }
 332
 333 static int pcap_dpdk_stats(pcap_t *p, struct pcap_stat *ps)
 334 {
 335         struct pcap_dpdk *pd = p->priv;
 336         calculate_timestamp(&(pd->ts_helper), &(pd->curr_ts));
 337         rte_eth_stats_get(pd->portid,&(pd->curr_stats));
 338         if (ps){
 339                 ps->ps_recv = pd->curr_stats.ipackets;
 340                 ps->ps_drop = pd->curr_stats.ierrors;
 341                 ps->ps_drop += pd->bpf_drop;
 342                 ps->ps_ifdrop = pd->curr_stats.imissed;
 343         }
 344         uint64_t delta_pkt = pd->curr_stats.ipackets - pd->prev_stats.ipackets;
 345         struct timeval delta_tm;
 346         timersub(&(pd->curr_ts),&(pd->prev_ts), &delta_tm);
 347         uint64_t delta_usec = delta_tm.tv_sec*1e6+delta_tm.tv_usec;
 348         uint64_t delta_bit = (pd->curr_stats.ibytes-pd->prev_stats.ibytes)*8;
 349         RTE_LOG(DEBUG, USER1, "delta_usec: %-10"PRIu64" delta_pkt: %-10"PRIu64" delta_bit: %-10"PRIu64"\n", delta_usec, delta_pkt, delta_bit);
 350         pd->pps = (uint64_t)(delta_pkt*1e6f/delta_usec);
 351         pd->bps = (uint64_t)(delta_bit*1e6f/delta_usec);
 352         nic_stats_display(pd);
 353         pd->prev_stats = pd->curr_stats;
 354         pd->prev_ts = pd->curr_ts;
 355         return 0;
 356 }
 357
 358 static int pcap_dpdk_setnonblock(pcap_t *p, int nonblock){
 359         struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
 360         pd->nonblock = nonblock;
 361         return 0;
 362 }
 363
 364 static int pcap_dpdk_getnonblock(pcap_t *p){
 365         struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
 366         return pd->nonblock;
 367 }
 368 static int check_link_status(uint16_t portid, struct rte_eth_link *plink)
 369 {
 370         // wait up to 9 seconds to get link status
 371         rte_eth_link_get(portid, plink);
 372         return plink->link_status == ETH_LINK_UP;
 373 }
 374 static void eth_addr_str(struct ether_addr *addrp, char* mac_str, int len)
 375 {
 376         int offset=0;
 377         if (addrp == NULL){
 378                 pcap_snprintf(mac_str, len-1, DPDK_DEF_MAC_ADDR);
 379                 return;
 380         }
 381         for (int i=0; i<6; i++)
 382         {
 383                 if (offset >= len)
 384                 { // buffer overflow
 385                         return;
 386                 }
 387                 if (i==0)
 388                 {
 389                         pcap_snprintf(mac_str+offset, len-1-offset, "%02X",addrp->addr_bytes[i]);
 390                         offset+=2; // FF
 391                 }else{
 392                         pcap_snprintf(mac_str+offset, len-1-offset, ":%02X", addrp->addr_bytes[i]);
 393                         offset+=3; // :FF
 394                 }
 395         }
 396         return;
 397 }
 398 // return portid by device name, otherwise return -1
 399 static uint16_t portid_by_device(char * device)
 400 {
 401         uint16_t ret = DPDK_PORTID_MAX;
 402         int len = strlen(device);
 403         int prefix_len = strlen(DPDK_PREFIX);
 404         unsigned long ret_ul = 0L;
 405         char *pEnd;
 406         if (len<=prefix_len || strncmp(device, DPDK_PREFIX, prefix_len)) // check prefix dpdk:
 407         {
 408                 return ret;
 409         }
 410         //check all chars are digital
 411         for (int i=prefix_len; device[i]; i++){
 412                 if (device[i]<'0' || device[i]>'9'){
 413                         return ret;
 414                 }
 415         }
 416         ret_ul = strtoul(&(device[prefix_len]), &pEnd, 10);
 417         if (pEnd == &(device[prefix_len]) || *pEnd != '\0'){
 418                 return ret;
 419         }
 420         // too large for portid
 421         if (ret_ul >= DPDK_PORTID_MAX){
 422                 return ret;
 423         }
 424         ret = (uint16_t)ret_ul;
 425         return ret;
 426 }
 427
 428 static int parse_dpdk_cfg(char* dpdk_cfg,char** dargv)
 429 {
 430         int cnt=0;
 431         memset(dargv,0,sizeof(dargv[0])*DPDK_ARGC_MAX);
 432         //current process name
 433         int skip_space = 1;
 434         int i=0;
 435         RTE_LOG(INFO, USER1,"dpdk cfg: %s\n",dpdk_cfg);
 436         // find first non space char
 437         // The last opt is NULL
 438         for (i=0;dpdk_cfg[i] && cnt<DPDK_ARGC_MAX-1;i++){
 439                 if (skip_space && dpdk_cfg[i]!=' '){ // not space
 440                         skip_space=!skip_space; // skip normal char
 441                         dargv[cnt++] = dpdk_cfg+i;
 442                 }
 443                 if (!skip_space && dpdk_cfg[i]==' '){ // fint a space
 444                         dpdk_cfg[i]=0x00; // end of this opt
 445                         skip_space=!skip_space; // skip space char
 446                 }
 447         }
 448         dargv[cnt]=NULL;
 449         return cnt;
 450 }
 451
 452 // only called once
 453 static int dpdk_pre_init(char * ebuf)
 454 {
 455         int dargv_cnt=0;
 456         char *dargv[DPDK_ARGC_MAX];
 457         char *ptr_dpdk_cfg = NULL;
 458         int ret = PCAP_ERROR;
 459         // globale var
 460         if (is_dpdk_pre_inited)
 461         {
 462                 // already inited
 463                 return 0;
 464         }
 465         // check for root permission
 466         if( geteuid() != 0)
 467         {
 468                 RTE_LOG(ERR, USER1, "%s\n", DPDK_ERR_PERM_MSG);
 469                 pcap_fmt_errmsg_for_errno(ebuf, PCAP_ERRBUF_SIZE,
 470                             errno, "dpdk error: %s",
 471                             DPDK_ERR_PERM_MSG);
 472                 ret = PCAP_ERROR_PERM_DENIED;
 473                 return ret;
 474         }
 475         // init EAL
 476         ptr_dpdk_cfg = getenv(DPDK_CFG_ENV_NAME);
 477         // set default log level to debug
 478         rte_log_set_global_level(DPDK_DEF_LOG_LEV);
 479         if (ptr_dpdk_cfg == NULL)
 480         {
 481                 RTE_LOG(INFO,USER1,"env $DPDK_CFG is unset, so using default: %s\n",DPDK_DEF_CFG);
 482                 ptr_dpdk_cfg = DPDK_DEF_CFG;
 483         }
 484         memset(dpdk_cfg_buf,0,sizeof(dpdk_cfg_buf));
 485         snprintf(dpdk_cfg_buf,DPDK_CFG_MAX_LEN-1,"%s %s",DPDK_LIB_NAME,ptr_dpdk_cfg);
 486         dargv_cnt = parse_dpdk_cfg(dpdk_cfg_buf,dargv);
 487         ret = rte_eal_init(dargv_cnt,dargv);
 488         // if init successed, we do not need to do it again later.
 489         if (ret == 0){
 490                 is_dpdk_pre_inited = 1;
 491         }
 492         return ret;
 493 }
 494
 495 static int pcap_dpdk_activate(pcap_t *p)
 496 {
 497         struct pcap_dpdk *pd = p->priv;
 498         pd->orig = p;
 499         int ret = PCAP_ERROR;
 500         uint16_t nb_ports=0;
 501         uint16_t portid= DPDK_PORTID_MAX;
 502         unsigned nb_mbufs = DPDK_NB_MBUFS;
 503         struct rte_eth_rxconf rxq_conf;
 504         struct rte_eth_txconf txq_conf;
 505         struct rte_eth_conf local_port_conf = port_conf;
 506         struct rte_eth_dev_info dev_info;
 507         int is_port_up = 0;
 508         struct rte_eth_link link;
 509         do{
 510                 //init EAL
 511                 ret = dpdk_pre_init(p->errbuf);
 512                 if (ret < 0)
 513                 {
 514                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 515                             errno, "dpdk error: Init failed with device %s",
 516                             p->opt.device);
 517                         ret = PCAP_ERROR;
 518                         break;
 519                 }
 520                 ret = dpdk_init_timer(pd);
 521                 if (ret<0)
 522                 {
 523                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 524                                 errno, "dpdk error: Init timer error with device %s",
 525                                 p->opt.device);
 526                         ret = PCAP_ERROR;
 527                         break;
 528                 }
 529
 530                 nb_ports = rte_eth_dev_count_avail();
 531                 if (nb_ports == 0)
 532                 {
 533                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 534                             errno, "dpdk error: No Ethernet ports");
 535                         ret = PCAP_ERROR;
 536                         break;
 537                 }
 538
 539                 portid = portid_by_device(p->opt.device);
 540                 if (portid == DPDK_PORTID_MAX){
 541                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 542                             errno, "dpdk error: portid is invalid. device %s",
 543                             p->opt.device);
 544                         ret = PCAP_ERROR_NO_SUCH_DEVICE;
 545                         break;
 546                 }
 547
 548                 pd->portid = portid;
 549
 550                 if (p->snapshot <= 0 || p->snapshot > MAXIMUM_SNAPLEN)
 551                 {
 552                         p->snapshot = MAXIMUM_SNAPLEN;
 553                 }
 554                 // create the mbuf pool
 555                 pd->pktmbuf_pool = rte_pktmbuf_pool_create(MBUF_POOL_NAME, nb_mbufs,
 556                         MEMPOOL_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE,
 557                         rte_socket_id());
 558                 if (pd->pktmbuf_pool == NULL)
 559                 {
 560                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 561                             errno, "dpdk error: Cannot init mbuf pool");
 562                         ret = PCAP_ERROR;
 563                         break;
 564                 }
 565                 // config dev
 566                 rte_eth_dev_info_get(portid, &dev_info);
 567                 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
 568                 {
 569                         local_port_conf.txmode.offloads |=DEV_TX_OFFLOAD_MBUF_FAST_FREE;
 570                 }
 571                 // only support 1 queue
 572                 ret = rte_eth_dev_configure(portid, 1, 1, &local_port_conf);
 573                 if (ret < 0)
 574                 {
 575                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 576                             errno, "dpdk error: Cannot configure device: err=%d, port=%u",
 577                             ret, portid);
 578                         ret = PCAP_ERROR;
 579                         break;
 580                 }
 581                 // adjust rx tx
 582                 ret = rte_eth_dev_adjust_nb_rx_tx_desc(portid, &nb_rxd, &nb_txd);
 583                 if (ret < 0)
 584                 {
 585                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 586                             errno, "dpdk error: Cannot adjust number of descriptors: err=%d, port=%u",
 587                             ret, portid);
 588                         ret = PCAP_ERROR;
 589                         break;
 590                 }
 591                 // get MAC addr
 592                 rte_eth_macaddr_get(portid, &(pd->eth_addr));
 593                 eth_addr_str(&(pd->eth_addr), pd->mac_addr, DPDK_MAC_ADDR_SIZE-1);
 594
 595                 // init one RX queue
 596                 rxq_conf = dev_info.default_rxconf;
 597                 rxq_conf.offloads = local_port_conf.rxmode.offloads;
 598                 ret = rte_eth_rx_queue_setup(portid, 0, nb_rxd,
 599                                              rte_eth_dev_socket_id(portid),
 600                                              &rxq_conf,
 601                                              pd->pktmbuf_pool);
 602                 if (ret < 0)
 603                 {
 604                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 605                             errno, "dpdk error: rte_eth_rx_queue_setup:err=%d, port=%u",
 606                             ret, portid);
 607                         ret = PCAP_ERROR;
 608                         break;
 609                 }
 610
 611                 // init one TX queue
 612                 txq_conf = dev_info.default_txconf;
 613                 txq_conf.offloads = local_port_conf.txmode.offloads;
 614                 ret = rte_eth_tx_queue_setup(portid, 0, nb_txd,
 615                                 rte_eth_dev_socket_id(portid),
 616                                 &txq_conf);
 617                 if (ret < 0)
 618                 {
 619                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 620                             errno, "dpdk error: rte_eth_tx_queue_setup:err=%d, port=%u",
 621                             ret, portid);
 622                         ret = PCAP_ERROR;
 623                         break;
 624                 }
 625                 // Initialize TX buffers
 626                 tx_buffer = rte_zmalloc_socket(DPDK_TX_BUF_NAME,
 627                                 RTE_ETH_TX_BUFFER_SIZE(MAX_PKT_BURST), 0,
 628                                 rte_eth_dev_socket_id(portid));
 629                 if (tx_buffer == NULL)
 630                 {
 631                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 632                             errno, "dpdk error: Cannot allocate buffer for tx on port %u", portid);
 633                         ret = PCAP_ERROR;
 634                         break;
 635                 }
 636                 rte_eth_tx_buffer_init(tx_buffer, MAX_PKT_BURST);
 637                 // Start device
 638                 ret = rte_eth_dev_start(portid);
 639                 if (ret < 0)
 640                 {
 641                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 642                             errno, "dpdk error: rte_eth_dev_start:err=%d, port=%u",
 643                             ret, portid);
 644                         ret = PCAP_ERROR;
 645                         break;
 646                 }
 647                 // set promiscuous mode
 648                 if (p->opt.promisc){
 649                         pd->must_clear_promisc=1;
 650                         rte_eth_promiscuous_enable(portid);
 651                 }
 652                 // check link status
 653                 is_port_up = check_link_status(portid, &link);
 654                 if (!is_port_up){
 655                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 656                             errno, "dpdk error: link is down, port=%u",portid);
 657                         ret = PCAP_ERROR_IFACE_NOT_UP;
 658                         break;
 659                 }
 660                 // reset statistics
 661                 rte_eth_stats_reset(pd->portid);
 662                 calculate_timestamp(&(pd->ts_helper), &(pd->prev_ts));
 663                 rte_eth_stats_get(pd->portid,&(pd->prev_stats));
 664                 // format pcap_t
 665                 pd->portid = portid;
 666                 p->fd = pd->portid;
 667                 if (p->snapshot <=0 || p->snapshot> MAXIMUM_SNAPLEN)
 668                 {
 669                         p->snapshot = MAXIMUM_SNAPLEN;
 670                 }
 671                 p->linktype = DLT_EN10MB; // Ethernet, the 10MB is historical.
 672                 p->selectable_fd = p->fd;
 673                 p->read_op = pcap_dpdk_dispatch;
 674                 p->inject_op = pcap_dpdk_inject;
 675                 // using pcap_filter currently, though DPDK provides their own BPF function. Because DPDK BPF needs load a ELF file as a filter.
 676                 p->setfilter_op = install_bpf_program;
 677                 p->setdirection_op = NULL;
 678                 p->set_datalink_op = NULL;
 679                 p->getnonblock_op = pcap_dpdk_getnonblock;
 680                 p->setnonblock_op = pcap_dpdk_setnonblock;
 681                 p->stats_op = pcap_dpdk_stats;
 682                 p->cleanup_op = pcap_dpdk_close;
 683                 p->breakloop_op = pcap_breakloop_common;
 684                 ret = 0; // OK
 685         }while(0);
 686
 687         if (ret <= PCAP_ERROR) // all kinds of error code
 688         {
 689                 pcap_cleanup_live_common(p);
 690         }else{
 691                 rte_eth_dev_get_name_by_port(portid,pd->pci_addr);
 692                 RTE_LOG(INFO, USER1,"Port %d device: %s, MAC:%s, PCI:%s\n", portid, p->opt.device, pd->mac_addr, pd->pci_addr);
 693                 RTE_LOG(INFO, USER1,"Port %d Link Up. Speed %u Mbps - %s\n",
 694                                                         portid, link.link_speed,
 695                                         (link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
 696                                                 ("full-duplex") : ("half-duplex\n"));
 697         }
 698         return ret;
 699 }
 700
 701 // device name for dpdk shoud be in the form as dpdk:number, such as dpdk:0
 702 pcap_t * pcap_dpdk_create(const char *device, char *ebuf, int *is_ours)
 703 {
 704         pcap_t *p=NULL;
 705         *is_ours = 0;
 706
 707         *is_ours = !strncmp(device, "dpdk:", 5);
 708         if (! *is_ours)
 709                 return NULL;
 710         //memset will happen
 711         p = pcap_create_common(ebuf, sizeof(struct pcap_dpdk));
 712
 713         if (p == NULL)
 714                 return NULL;
 715         p->activate_op = pcap_dpdk_activate;
 716         return p;
 717 }
 718
 719 int pcap_dpdk_findalldevs(pcap_if_list_t *devlistp, char *ebuf)
 720 {
 721         int ret=0;
 722         int nb_ports = 0;
 723         char dpdk_name[DPDK_DEV_NAME_MAX];
 724         char dpdk_desc[DPDK_DEV_DESC_MAX];
 725         struct ether_addr eth_addr;
 726         char mac_addr[DPDK_MAC_ADDR_SIZE];
 727         char pci_addr[DPDK_PCI_ADDR_SIZE];
 728         do{
 729                 ret = dpdk_pre_init(ebuf);
 730                 if (ret < 0)
 731                 {
 732                         pcap_fmt_errmsg_for_errno(ebuf, PCAP_ERRBUF_SIZE,
 733                             errno, "error: Init failed with device");
 734                         ret = PCAP_ERROR;
 735                         break;
 736                 }
 737                 nb_ports = rte_eth_dev_count_avail();
 738                 if (nb_ports == 0)
 739                 {
 740                         pcap_fmt_errmsg_for_errno(ebuf, PCAP_ERRBUF_SIZE,
 741                             errno, "DPDK error: No Ethernet ports");
 742                         ret = PCAP_ERROR;
 743                         break;
 744                 }
 745                 for (int i=0; i<nb_ports; i++){
 746                         pcap_snprintf(dpdk_name,DPDK_DEV_NAME_MAX-1,"dpdk:%d",i);
 747                         // mac addr
 748                         rte_eth_macaddr_get(i, &eth_addr);
 749                         eth_addr_str(&eth_addr,mac_addr,DPDK_MAC_ADDR_SIZE);
 750                         // PCI addr
 751                         rte_eth_dev_get_name_by_port(i,pci_addr);
 752                         pcap_snprintf(dpdk_desc,DPDK_DEV_DESC_MAX-1,"%s %s, MAC:%s, PCI:%s", DPDK_DESC, dpdk_name, mac_addr, pci_addr);
 753                         if (add_dev(devlistp, dpdk_name, 0, dpdk_desc, ebuf)==NULL){
 754                                 ret = PCAP_ERROR;
 755                                 break;
 756                         }
 757                 }
 758         }while(0);
 759         return ret;
 760 }