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

   1 /*
   2  * Copyright (C) 2018 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
  34 Limitations:
  35 1. By default enable_dpdk is no, unless you set inlcudes and lib dir
  36 by --with-dpdk-includes= --with-dpdk-libraries=
  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 4. I have tested on DPDK v18.11.
  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
  46 2. launch l2fwd that is one of DPDK examples correctly, and get device information.
  47
  48 You shall learn how to bind nic with DPDK-compatible driver by $RTE_SDK/usertools/dpdk-devbind.py, such as igb_uio.
  49 And enable hugepages by dpdk-setup.sh
  50
  51 Then launch the l2fwd with dynamic dirver support. For example:
  52 $RTE_SDK/examples/l2fwd/$RTE_TARGET/l2fwd -dlibrte_pmd_e1000.so -dlibrte_pmd_ixgbe.so -dlibrte_mempool_ring.so -- -p 0x1
  53
  54 3. compile libpcap with dpdk options.
  55
  56 you shall run the following command to generate a new configure
  57
  58 make clean
  59 autoreconf
  60
  61 Then, run configure with dpdk options.
  62 For Ubuntu, they are --with-dpdk-includes=/usr/local/include/dpdk/ --with-dpdk-libraries=/usr/local/lib
  63
  64 4. link your own program with libpcap, and use DPDK with the device name as dpdk[portid], such as dpdk:0.
  65 And you shall set DPDK configure options by environment variable DPDK_CFG
  66 For example, the testprogs/capturetest could be lanched by:
  67
  68 env DPDK_CFG="--log-level=debug -l0 -dlibrte_pmd_e1000.so -dlibrte_pmd_ixgbe.so -dlibrte_mempool_ring.so" ./capturetest -i dpdk:0
  69
  70 The program will print the following message on my computer:
  71
  72 USER1: dpdk cfg: libpcap_dpdk --log-level=debug -l0 -dlibrte_pmd_e1000.so -dlibrte_pmd_ixgbe.so -dlibrte_mempool_ring.so
  73 EAL: Detected 4 lcore(s)
  74 EAL: Detected 1 NUMA nodes
  75 EAL: Multi-process socket /var/run/dpdk/rte/mp_socket
  76 EAL: No free hugepages reported in hugepages-1048576kB
  77 EAL: Probing VFIO support...
  78 EAL: PCI device 0000:00:19.0 on NUMA socket -1
  79 EAL:   Invalid NUMA socket, default to 0
  80 EAL:   probe driver: 8086:1559 net_e1000_em
  81 USER1: pcap_dpdk_activate device dpdk:0 portid 0, pci_addr: 0000:00:19.0
  82 USER1: Port 0 Link Up. Speed 1000 Mbps - full-duplex
  83 USER1: Port 0, MAC address: [MAC ADDR]
  84
  85 Listening on dpdk:0
  86 USER1: dpdk: lcoreid=0 runs for portid=0
  87
  88 */
  89
  90 #ifdef HAVE_CONFIG_H
  91 #include <config.h>
  92 #endif
  93
  94 #include <ctype.h>
  95 #include <errno.h>
  96 #include <netdb.h>
  97 #include <stdio.h>
  98 #include <stdlib.h>
  99 #include <string.h>
 100 #include <unistd.h>
 101 #include <time.h>
 102
 103 #include <sys/time.h>
 104
 105 //header for calling dpdk
 106 #include <rte_common.h>
 107 #include <rte_log.h>
 108 #include <rte_malloc.h>
 109 #include <rte_memory.h>
 110 #include <rte_eal.h>
 111 #include <rte_launch.h>
 112 #include <rte_atomic.h>
 113 #include <rte_cycles.h>
 114 #include <rte_lcore.h>
 115 #include <rte_per_lcore.h>
 116 #include <rte_branch_prediction.h>
 117 #include <rte_interrupts.h>
 118 #include <rte_random.h>
 119 #include <rte_debug.h>
 120 #include <rte_ether.h>
 121 #include <rte_ethdev.h>
 122 #include <rte_mempool.h>
 123 #include <rte_mbuf.h>
 124 #include <rte_bus.h>
 125
 126 #include "pcap-int.h"
 127 #include "pcap-dpdk.h"
 128
 129 #define DPDK_LIB_NAME "libpcap_dpdk"
 130 #define DPDK_ARGC_MAX 64
 131 #define DPDK_CFG_MAX_LEN 1024
 132 #define DPDK_CFG_ENV_NAME "DPDK_CFG"
 133 static char dpdk_cfg_buf[DPDK_CFG_MAX_LEN];
 134 #define DPDK_PCI_ADDR_SIZE 16
 135 #define DPDK_DEF_CFG "--log-level=debug -l0 -dlibrte_pmd_e1000.so -dlibrte_pmd_ixgbe.so -dlibrte_mempool_ring.so"
 136 #define DPDK_PREFIX "dpdk:"
 137 #define MBUF_POOL_NAME "mbuf_pool"
 138 #define DPDK_TX_BUF_NAME "tx_buffer"
 139 //The number of elements in the mbuf pool.
 140 #define DPDK_NB_MBUFS 8192U
 141 #define MEMPOOL_CACHE_SIZE 256
 142 #define MAX_PKT_BURST 32
 143 // Configurable number of RX/TX ring descriptors
 144 #define RTE_TEST_RX_DESC_DEFAULT 1024
 145 #define RTE_TEST_TX_DESC_DEFAULT 1024
 146
 147 static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 148 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 149
 150 #define RTE_ETH_PCAP_SNAPLEN ETHER_MAX_JUMBO_FRAME_LEN
 151
 152 static struct rte_eth_dev_tx_buffer *tx_buffer;
 153
 154 struct dpdk_ts_helper{
 155         struct timeval start_time;
 156         uint64_t start_cycles;
 157         uint64_t hz;
 158 };
 159 struct pcap_dpdk{
 160         pcap_t * orig;
 161         uint16_t portid; // portid of DPDK
 162         pcap_handler cb; //callback and argument
 163         u_char *cb_arg;
 164         int max_cnt;
 165         int must_clear_promisc;
 166         int filter_in_userland;
 167         uint64_t rx_pkts;
 168         uint64_t bpf_drop;
 169         struct ether_addr eth_addr;
 170         struct rte_eth_stats stats;
 171         struct rte_mempool * pktmbuf_pool;
 172         struct dpdk_ts_helper ts_helper;
 173         char pci_addr[DPDK_PCI_ADDR_SIZE];
 174         unsigned char pcap_tmp_buf[RTE_ETH_PCAP_SNAPLEN];
 175         volatile sig_atomic_t break_loop;
 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 unsigned int dpdk_gather_data(unsigned char *data, struct rte_mbuf *mbuf)
 208 {
 209         unsigned int total_len = 0;
 210         while (mbuf && (total_len+mbuf->data_len) < RTE_ETH_PCAP_SNAPLEN ){
 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 void pcap_dpdk_breakloop(pcap_t *p)
 219 {
 220         pcap_breakloop_common(p);
 221         struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
 222         pd->break_loop = p->break_loop;
 223 }
 224 static void dpdk_dispatch_inter(void *dpdk_user)
 225 {
 226         if (dpdk_user == NULL){
 227                 return;
 228         }
 229         pcap_t *p = dpdk_user;
 230         struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
 231         int max_cnt = pd->max_cnt;
 232         pcap_handler cb = pd->cb;
 233         u_char *cb_arg = pd->cb_arg;
 234         int nb_rx=0;
 235         struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
 236         struct rte_mbuf *m;
 237         struct pcap_pkthdr pcap_header;
 238         uint16_t portid = pd->portid;
 239         unsigned lcore_id = rte_lcore_id();
 240         unsigned master_lcore_id = rte_get_master_lcore();
 241         uint16_t data_len = 0;
 242         u_char *bp = NULL;
 243         int i=0;
 244         unsigned int gather_len =0;
 245         int pkt_cnt = 0;
 246         int is_accepted=0;
 247
 248         if(lcore_id == master_lcore_id){
 249                 RTE_LOG(INFO, USER1, "dpdk: lcoreid=%u runs for portid=%u\n", lcore_id, portid);
 250         }else{
 251                 RTE_LOG(INFO, USER1, "dpdk: lcore %u has nothing to do\n", lcore_id);
 252         }
 253         //only use master lcore
 254         if (lcore_id != master_lcore_id){
 255                 return;
 256         }
 257         while( max_cnt==-1 || pkt_cnt < max_cnt){
 258                 if (pd->break_loop){
 259                         break;
 260                 }
 261                 nb_rx = (int)rte_eth_rx_burst(portid, 0, pkts_burst, MAX_PKT_BURST);
 262                 pkt_cnt += nb_rx;
 263                 for ( i = 0; i < nb_rx; i++) {
 264                         m = pkts_burst[i];
 265                         calculate_timestamp(&(pd->ts_helper),&(pcap_header.ts));
 266                         data_len = rte_pktmbuf_data_len(m);
 267                         pcap_header.caplen = data_len;
 268                         pcap_header.len = data_len;
 269                         // volatile prefetch
 270                         rte_prefetch0(rte_pktmbuf_mtod(m, void *));
 271                         bp = NULL;
 272                         if (m->nb_segs == 1)
 273                         {
 274                                 bp = rte_pktmbuf_mtod(m, u_char *);
 275                         }else{
 276                                 if (m->pkt_len <= ETHER_MAX_JUMBO_FRAME_LEN)
 277                                 {
 278                                         gather_len = dpdk_gather_data(pd->pcap_tmp_buf, m);
 279                                         bp = pd->pcap_tmp_buf;
 280                                         pcap_header.caplen = gather_len;
 281                                         pcap_header.len = gather_len;
 282                                 }else{
 283                                         // size too large
 284                                         // why only free this pkt
 285                                         rte_pktmbuf_free(m);
 286                                 }
 287                         }
 288                         if (bp){
 289                                 //default accpet all
 290                                 is_accepted=1;
 291                                 if (pd->filter_in_userland && p->fcode.bf_insns!=NULL)
 292                                 {
 293                                         if (!pcap_filter(p->fcode.bf_insns, bp, pcap_header.len, pcap_header.caplen)){
 294                                                 //rejected
 295                                                 is_accepted=0;
 296                                         }
 297                                 }
 298                                 if (is_accepted){
 299                                         cb(cb_arg, &pcap_header, bp);
 300                                 }else{
 301                                         pd->bpf_drop++;
 302                                 }
 303                         }
 304                 }
 305         }
 306         pd->rx_pkts = pkt_cnt;
 307 }
 308 static int launch_one_lcore(void *dpdk_user)
 309 {
 310         dpdk_dispatch_inter(dpdk_user);
 311         return 0;
 312 }
 313 static int pcap_dpdk_dispatch(pcap_t *p, int max_cnt, pcap_handler cb, u_char *pcap_user)
 314 {
 315         unsigned lcore_id = 0;
 316         struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
 317         pd->rx_pkts=0;
 318         pd->cb = cb;
 319         pd->cb_arg = pcap_user;
 320         pd->max_cnt = max_cnt;
 321         pd->orig = p;
 322         void *dpdk_user = p;
 323         // launch_one_lcore func will be called on every lcore include master core.
 324         rte_eal_mp_remote_launch(launch_one_lcore, dpdk_user, CALL_MASTER);
 325         RTE_LCORE_FOREACH_SLAVE(lcore_id) {
 326                 if (rte_eal_wait_lcore(lcore_id) < 0) {
 327                         break;
 328                 }
 329         }
 330         return pd->rx_pkts;
 331 }
 332
 333 static int pcap_dpdk_inject(pcap_t *p, const void *buf _U_, int size _U_)
 334 {
 335         //not implemented yet
 336         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 337                 errno, "dpdk error: Inject function has not be implemented yet");
 338         return PCAP_ERROR;
 339 }
 340
 341 static void pcap_dpdk_close(pcap_t *p)
 342 {
 343         struct pcap_dpdk *pd = p->priv;
 344         if (pd==NULL)
 345         {
 346                 return;
 347         }
 348         if (pd->must_clear_promisc)
 349         {
 350                 rte_eth_promiscuous_disable(pd->portid);
 351         }
 352         rte_eth_dev_stop(pd->portid);
 353         rte_eth_dev_close(pd->portid);
 354         // free pcap_dpdk?
 355         pcap_cleanup_live_common(p);
 356 }
 357
 358 static int pcap_dpdk_setfilter(pcap_t *p, struct bpf_program *fp)
 359 {
 360         //init bpf for dpdk, only support userspace bfp
 361         struct pcap_dpdk * pd = p->priv;
 362         int ret=0;
 363         ret = install_bpf_program(p, fp);
 364         if (ret==0){
 365                 pd->filter_in_userland = 1;
 366         }
 367         return ret;
 368 }
 369
 370 static void nic_stats_display(uint16_t portid)
 371 {
 372         struct rte_eth_stats stats;
 373         rte_eth_stats_get(portid, &stats);
 374         RTE_LOG(INFO,USER1, "portid:%d, RX-packets: %-10"PRIu64"  RX-errors:  %-10"PRIu64
 375                "  RX-bytes:  %-10"PRIu64"  RX-Imissed:  %-10"PRIu64"\n", portid, stats.ipackets, stats.ierrors,
 376                stats.ibytes,stats.imissed);
 377 }
 378
 379 static int pcap_dpdk_stats(pcap_t *p, struct pcap_stat *ps)
 380 {
 381         struct pcap_dpdk *pd = p->priv;
 382         rte_eth_stats_get(pd->portid,&(pd->stats));
 383         ps->ps_recv = pd->stats.ipackets;
 384         ps->ps_drop = pd->stats.ierrors;
 385         ps->ps_drop += pd->bpf_drop;
 386         ps->ps_ifdrop = pd->stats.imissed;
 387         nic_stats_display(pd->portid);
 388         return 0;
 389 }
 390
 391 static int pcap_dpdk_setnonblock(pcap_t *p, int fd _U_){
 392         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 393                 errno, "dpdk error: setnonblock not support");
 394         return 0;
 395 }
 396
 397 static int pcap_dpdk_getnonblock(pcap_t *p){
 398         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 399                 errno, "dpdk error: getnonblock not support");
 400         return 0;
 401 }
 402
 403 static int check_link_status(uint16_t portid, struct rte_eth_link *plink)
 404 {
 405         uint8_t count = 0;
 406         int is_port_up = 0;
 407         int max_check_time = 2;
 408         int check_interval = 100; // 100ms
 409         for (count = 0; count <= max_check_time; count++) {
 410                 memset(plink, 0, sizeof(struct rte_eth_link));
 411                 rte_eth_link_get_nowait(portid, plink);
 412                 if (plink->link_status == ETH_LINK_UP)
 413                 {
 414                         is_port_up = 1;
 415                         break;
 416                 }else{
 417                         rte_delay_ms(check_interval);
 418                 }
 419         }
 420         return is_port_up;
 421 }
 422
 423 // return portid by device name, otherwise return -1
 424 static uint16_t portid_by_device(char * device)
 425 {
 426         uint16_t ret = -1;
 427         int len = strlen(device);
 428         int prefix_len = strlen(DPDK_PREFIX);
 429         unsigned long ret_ul = 0L;
 430
 431         if (len<=prefix_len || strncmp(device, DPDK_PREFIX, prefix_len)) // check prefix dpdk:
 432         {
 433                 return ret;
 434         }
 435         if (device[prefix_len]>='0' && device[prefix_len]<='9')
 436         { // is digital
 437                 ret_ul = strtoul(&(device[prefix_len]), NULL, 10);
 438                 ret = (uint16_t)ret_ul;
 439         }
 440         return ret;
 441 }
 442
 443 int parse_dpdk_cfg(char* dpdk_cfg,char** dargv)
 444 {
 445         int cnt=0;
 446         memset(dargv,0,sizeof(dargv[0])*DPDK_ARGC_MAX);
 447         //current process name
 448         int skip_space = 1;
 449         int i=0;
 450         RTE_LOG(INFO, USER1,"dpdk cfg: %s\n",dpdk_cfg);
 451         // find first non space char
 452         // The last opt is NULL
 453         for (i=0;dpdk_cfg[i] && cnt<DPDK_ARGC_MAX-1;i++){
 454                 if (skip_space && dpdk_cfg[i]!=0x20){ // not space
 455                         skip_space=!skip_space; // skip normal char
 456                         dargv[cnt++] = dpdk_cfg+i;
 457                 }
 458                 if (!skip_space && dpdk_cfg[i]==0x20){ // fint a space
 459                         dpdk_cfg[i]=0x00; // end of this opt
 460                         skip_space=!skip_space; // skip space char
 461                 }
 462         }
 463         dargv[cnt]=NULL;
 464         return cnt;
 465 }
 466 static int pcap_dpdk_activate(pcap_t *p)
 467 {
 468         struct pcap_dpdk *pd = p->priv;
 469         pd->orig = p;
 470         int ret = PCAP_ERROR;
 471         uint16_t nb_ports=0;
 472         uint16_t portid=-1;
 473         unsigned nb_mbufs = DPDK_NB_MBUFS;
 474         struct rte_eth_rxconf rxq_conf;
 475         struct rte_eth_txconf txq_conf;
 476         struct rte_eth_conf local_port_conf = port_conf;
 477         struct rte_eth_dev_info dev_info;
 478         int is_port_up = 0;
 479         struct rte_eth_link link;
 480         if (p == NULL)
 481         {
 482                 return PCAP_ERROR;
 483         }
 484
 485         do{
 486                 //init EAL
 487                 rte_log_set_global_level(RTE_LOG_DEBUG);
 488                 int dargv_cnt=0;
 489                 char * dargv[DPDK_ARGC_MAX];
 490                 char *ptr_dpdk_cfg = getenv(DPDK_CFG_ENV_NAME);
 491                 if (ptr_dpdk_cfg == NULL)
 492                 {
 493                         RTE_LOG(INFO,USER1,"env $DPDK_CFG is unset, so using default: %s\n",DPDK_DEF_CFG);
 494                         ptr_dpdk_cfg = DPDK_DEF_CFG;
 495                 }
 496                 memset(dpdk_cfg_buf,0,sizeof(dpdk_cfg_buf));
 497                 snprintf(dpdk_cfg_buf,DPDK_CFG_MAX_LEN-1,"%s %s",DPDK_LIB_NAME,ptr_dpdk_cfg);
 498                 dargv_cnt = parse_dpdk_cfg(dpdk_cfg_buf,dargv);
 499                 ret = rte_eal_init(dargv_cnt,dargv);
 500                 if (ret < 0)
 501                 {
 502                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 503                             errno, "dpdk error: Init failed with device %s",
 504                             p->opt.device);
 505                         ret = PCAP_ERROR;
 506                         break;
 507                 }
 508                 ret = dpdk_init_timer(pd);
 509                 if (ret<0)
 510                 {
 511                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 512                                 errno, "dpdk error: Init timer error with device %s",
 513                                 p->opt.device);
 514                         ret = PCAP_ERROR;
 515                         break;
 516                 }
 517
 518                 nb_ports = rte_eth_dev_count_avail();
 519                 if (nb_ports == 0)
 520                 {
 521                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 522                             errno, "dpdk error: No Ethernet ports");
 523                         ret = PCAP_ERROR;
 524                         break;
 525                 }
 526                 // parse portid
 527                 portid = portid_by_device(p->opt.device);
 528                 if (portid == -1){
 529                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 530                             errno, "dpdk error: portid is invalid. device %s",
 531                             p->opt.device);
 532                         ret = PCAP_ERROR;
 533                         break;
 534                 }
 535
 536                 if (portid >= nb_ports)
 537                 {
 538                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 539                             errno, "dpdk error: portid(%u) is larger than nb_ports(%u)",
 540                             portid, nb_ports);
 541                         ret = PCAP_ERROR;
 542                         break;
 543                 }
 544                 pd->portid = portid;
 545                 if (p->snapshot <= 0 || p->snapshot > MAXIMUM_SNAPLEN)
 546                 {
 547                         p->snapshot = MAXIMUM_SNAPLEN;
 548                 }
 549                 // create the mbuf pool
 550                 pd->pktmbuf_pool = rte_pktmbuf_pool_create(MBUF_POOL_NAME, nb_mbufs,
 551                         MEMPOOL_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE,
 552                         rte_socket_id());
 553                 if (pd->pktmbuf_pool == NULL)
 554                 {
 555                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 556                             errno, "dpdk error: Cannot init mbuf pool");
 557                         ret = PCAP_ERROR;
 558                         break;
 559                 }
 560                 // config dev
 561                 rte_eth_dev_info_get(portid, &dev_info);
 562                 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
 563                 {
 564                         local_port_conf.txmode.offloads |=DEV_TX_OFFLOAD_MBUF_FAST_FREE;
 565                 }
 566                 // only support 1 queue
 567                 ret = rte_eth_dev_configure(portid, 1, 1, &local_port_conf);
 568                 if (ret < 0)
 569                 {
 570                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 571                             errno, "dpdk error: Cannot configure device: err=%d, port=%u",
 572                             ret, portid);
 573                         ret = PCAP_ERROR;
 574                         break;
 575                 }
 576                 // adjust rx tx
 577                 ret = rte_eth_dev_adjust_nb_rx_tx_desc(portid, &nb_rxd, &nb_txd);
 578                 if (ret < 0)
 579                 {
 580                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 581                             errno, "dpdk error: Cannot adjust number of descriptors: err=%d, port=%u",
 582                             ret, portid);
 583                         ret = PCAP_ERROR;
 584                         break;
 585                 }
 586                 // get MAC addr
 587                 rte_eth_macaddr_get(portid, &(pd->eth_addr));
 588
 589                 // init one RX queue
 590                 rxq_conf = dev_info.default_rxconf;
 591                 rxq_conf.offloads = local_port_conf.rxmode.offloads;
 592                 ret = rte_eth_rx_queue_setup(portid, 0, nb_rxd,
 593                                              rte_eth_dev_socket_id(portid),
 594                                              &rxq_conf,
 595                                              pd->pktmbuf_pool);
 596                 if (ret < 0)
 597                 {
 598                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 599                             errno, "dpdk error: rte_eth_rx_queue_setup:err=%d, port=%u",
 600                             ret, portid);
 601                         ret = PCAP_ERROR;
 602                         break;
 603                 }
 604
 605                 // init one TX queue
 606                 txq_conf = dev_info.default_txconf;
 607                 txq_conf.offloads = local_port_conf.txmode.offloads;
 608                 ret = rte_eth_tx_queue_setup(portid, 0, nb_txd,
 609                                 rte_eth_dev_socket_id(portid),
 610                                 &txq_conf);
 611                 if (ret < 0)
 612                 {
 613                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 614                             errno, "dpdk error: rte_eth_tx_queue_setup:err=%d, port=%u",
 615                             ret, portid);
 616                         ret = PCAP_ERROR;
 617                         break;
 618                 }
 619                 // Initialize TX buffers
 620                 tx_buffer = rte_zmalloc_socket(DPDK_TX_BUF_NAME,
 621                                 RTE_ETH_TX_BUFFER_SIZE(MAX_PKT_BURST), 0,
 622                                 rte_eth_dev_socket_id(portid));
 623                 if (tx_buffer == NULL)
 624                 {
 625                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 626                             errno, "dpdk error: Cannot allocate buffer for tx on port %u", portid);
 627                         ret = PCAP_ERROR;
 628                         break;
 629                 }
 630                 rte_eth_tx_buffer_init(tx_buffer, MAX_PKT_BURST);
 631                 // Start device
 632                 ret = rte_eth_dev_start(portid);
 633                 if (ret < 0)
 634                 {
 635                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 636                             errno, "dpdk error: rte_eth_dev_start:err=%d, port=%u",
 637                             ret, portid);
 638                         ret = PCAP_ERROR;
 639                         break;
 640                 }
 641                 // set promisc mode
 642                 pd->must_clear_promisc=1;
 643                 rte_eth_promiscuous_enable(portid);
 644                 // check link status
 645                 is_port_up = check_link_status(portid, &link);
 646                 if (!is_port_up){
 647                         pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
 648                             errno, "dpdk error: link is down, port=%u",portid);
 649                         ret = PCAP_ERROR;
 650                         break;
 651                 }
 652                 // reset statistics
 653                 rte_eth_stats_reset(pd->portid);
 654                 // format pcap_t
 655                 pd->portid = portid;
 656                 p->fd = pd->portid;
 657                 if (p->snapshot <=0 || p->snapshot> MAXIMUM_SNAPLEN)
 658                 {
 659                         p->snapshot = MAXIMUM_SNAPLEN;
 660                 }
 661                 p->linktype = DLT_EN10MB; // Ethernet, the 10MB is historical.
 662                 p->selectable_fd = p->fd;
 663                 p->read_op = pcap_dpdk_dispatch;
 664                 p->inject_op = pcap_dpdk_inject;
 665                 p->setfilter_op = pcap_dpdk_setfilter;
 666                 p->setdirection_op = NULL;
 667                 p->set_datalink_op = NULL;
 668                 p->getnonblock_op = pcap_dpdk_getnonblock;
 669                 p->setnonblock_op = pcap_dpdk_setnonblock;
 670                 p->stats_op = pcap_dpdk_stats;
 671                 p->cleanup_op = pcap_dpdk_close;
 672                 p->breakloop_op = pcap_dpdk_breakloop;
 673                 ret = 0; // OK
 674         }while(0);
 675         rte_eth_dev_get_name_by_port(portid,pd->pci_addr);
 676         RTE_LOG(INFO, USER1,"%s device %s portid %d, pci_addr: %s\n", __FUNCTION__, p->opt.device, portid, pd->pci_addr);
 677         RTE_LOG(INFO, USER1,"Port %d Link Up. Speed %u Mbps - %s\n",
 678                                                 portid, link.link_speed,
 679                                 (link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
 680                                         ("full-duplex") : ("half-duplex\n"));
 681         RTE_LOG(INFO, USER1,"Port %u, MAC address:", portid);
 682         for (int i=0; i<6; i++)
 683         {
 684                 if (i==0)
 685                 {
 686                         fprintf(stderr,"%02X",pd->eth_addr.addr_bytes[i]);
 687                 }else{
 688                         fprintf(stderr,":%02X", pd->eth_addr.addr_bytes[i]);
 689                 }
 690         }
 691         fprintf(stderr,"\n\n");
 692         if (ret == PCAP_ERROR)
 693         {
 694                 pcap_cleanup_live_common(p);
 695         }
 696         return ret;
 697 }
 698
 699 // device name for dpdk shoud be in the form as dpdk:number, such as dpdk:0
 700 pcap_t * pcap_dpdk_create(const char *device, char *ebuf, int *is_ours)
 701 {
 702         pcap_t *p=NULL;
 703         *is_ours = 0;
 704
 705         *is_ours = !strncmp(device, "dpdk:", 5);
 706         if (! *is_ours)
 707                 return NULL;
 708         //memset will happen
 709         p = pcap_create_common(ebuf, sizeof(struct pcap_dpdk));
 710
 711         if (p == NULL)
 712                 return NULL;
 713         p->activate_op = pcap_dpdk_activate;
 714         return p;
 715 }
 716
 717 int pcap_dpdk_findalldevs(pcap_if_list_t *devlistp _U_, char *err_str _U_)
 718 {
 719         return 0;
 720 }