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. DPDK support will be on if DPDK is available. Please set DIR for --with-dpdk[=DIR] with ./configure or -DDPDK_DIR[=DIR] with cmake if DPDK is installed manually.
  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 If DPDK has not been found automatically, you shall export DPDK envionment variable which are used for compiling DPDK. And then pass $RTE_SDK/$RTE_TARGET to --with-dpdk or -DDPDK_DIR
  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 --with-dpdk=$RTE_SDK/$RTE_TARGET && make -s all && make -s testprogs && make install
  66
  67 3.2 With cmake
  68
  69 mkdir -p build && cd build && cmake -DDPDK_DIR=$RTE_SDK/$RTE_TARGET ../ && 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 1
 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 bpf_drop;
 162         int nonblock;
 163         struct timeval required_select_timeout;
 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 /*
 188  * Generate an error message based on a format, arguments, and an
 189  * rte_errno, with a message for the rte_errno after the formatted output.
 190  */
 191 static void dpdk_fmt_errmsg_for_rte_errno(char *errbuf, size_t errbuflen,
 192     int errnum, const char *fmt, ...)
 193 {
 194         va_list ap;
 195         size_t msglen;
 196         char *p;
 197         size_t errbuflen_remaining;
 198
 199         va_start(ap, fmt);
 200         pcap_vsnprintf(errbuf, errbuflen, fmt, ap);
 201         va_end(ap);
 202         msglen = strlen(errbuf);
 203
 204         /*
 205          * Do we have enough space to append ": "?
 206          * Including the terminating '\0', that's 3 bytes.
 207          */
 208         if (msglen + 3 > errbuflen) {
 209                 /* No - just give them what we've produced. */
 210                 return;
 211         }
 212         p = errbuf + msglen;
 213         errbuflen_remaining = errbuflen - msglen;
 214         *p++ = ':';
 215         *p++ = ' ';
 216         *p = '\0';
 217         msglen += 2;
 218         errbuflen_remaining -= 2;
 219
 220         /*
 221          * Now append the string for the error code.
 222          * rte_strerror() is thread-safe, at least as of dpdk 18.11,
 223          * unlike strerror() - it uses strerror_r() rather than strerror()
 224          * for UN*X errno values, and prints to what I assume is a per-thread
 225          * buffer (based on the "PER_LCORE" in "RTE_DEFINE_PER_LCORE" used
 226          * to declare the buffers statically) for DPDK errors.
 227          */
 228         pcap_snprintf(p, errbuflen_remaining, "%s", rte_strerror(errnum));
 229 }
 230
 231 static int dpdk_init_timer(struct pcap_dpdk *pd){
 232         gettimeofday(&(pd->ts_helper.start_time),NULL);
 233         pd->ts_helper.start_cycles = rte_get_timer_cycles();
 234         pd->ts_helper.hz = rte_get_timer_hz();
 235         if (pd->ts_helper.hz == 0){
 236                 return -1;
 237         }
 238         return 0;
 239 }
 240 static inline void calculate_timestamp(struct dpdk_ts_helper *helper,struct timeval *ts)
 241 {
 242         uint64_t cycles;
 243         // delta
 244         struct timeval cur_time;
 245         cycles = rte_get_timer_cycles() - helper->start_cycles;
 246         cur_time.tv_sec = (time_t)(cycles/helper->hz);
 247         cur_time.tv_usec = (suseconds_t)((cycles%helper->hz)*1e6/helper->hz);
 248         timeradd(&(helper->start_time), &cur_time, ts);
 249 }
 250
 251 static uint32_t dpdk_gather_data(unsigned char *data, int len, struct rte_mbuf *mbuf)
 252 {
 253         uint32_t total_len = 0;
 254         while (mbuf && (total_len+mbuf->data_len) < len ){
 255                 rte_memcpy(data+total_len, rte_pktmbuf_mtod(mbuf,void *),mbuf->data_len);
 256                 total_len+=mbuf->data_len;
 257                 mbuf=mbuf->next;
 258         }
 259         return total_len;
 260 }
 261
 262
 263 static int dpdk_read_with_timeout(pcap_t *p, uint16_t portid, uint16_t queueid,struct rte_mbuf **pkts_burst, const uint16_t burst_cnt){
 264         struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
 265         int nb_rx = 0;
 266         int timeout_ms = p->opt.timeout;
 267         int sleep_ms = 0;
 268         if (pd->nonblock){
 269                 // In non-blocking mode, just read once, no mater how many packets are captured.
 270                 nb_rx = (int)rte_eth_rx_burst(pd->portid, 0, pkts_burst, burst_cnt);
 271         }else{
 272                 // In blocking mode, read many times until packets are captured or timeout or break_loop is setted.
 273                 // if timeout_ms == 0, it may be blocked forever.
 274                 while (timeout_ms == 0 || sleep_ms < timeout_ms){
 275                         nb_rx = (int)rte_eth_rx_burst(pd->portid, 0, pkts_burst, burst_cnt);
 276                         if (nb_rx){ // got packets within timeout_ms
 277                                 break;
 278                         }else{ // no packet arrives at this round.
 279                                 if (p->break_loop){
 280                                         break;
 281                                 }
 282                                 // sleep for a very short while.
 283                                 // block sleep is the only choice, since usleep() will impact performance dramatically.
 284                                 rte_delay_us_block(DPDK_DEF_MIN_SLEEP_MS*1000);
 285                                 sleep_ms += DPDK_DEF_MIN_SLEEP_MS;
 286                         }
 287                 }
 288         }
 289         return nb_rx;
 290 }
 291
 292 static int pcap_dpdk_dispatch(pcap_t *p, int max_cnt, pcap_handler cb, u_char *cb_arg)
 293 {
 294         struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
 295         int burst_cnt = 0;
 296         int nb_rx = 0;
 297         struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
 298         struct rte_mbuf *m;
 299         struct pcap_pkthdr pcap_header;
 300         uint16_t portid = pd->portid;
 301         // In DPDK, pkt_len is sum of lengths for all segments. And data_len is for one segment
 302         uint32_t pkt_len = 0;
 303         int caplen = 0;
 304         u_char *bp = NULL;
 305         int i=0;
 306         unsigned int gather_len =0;
 307         int pkt_cnt = 0;
 308         int is_accepted=0;
 309         u_char *large_buffer=NULL;
 310         int timeout_ms = p->opt.timeout;
 311
 312         if ( !PACKET_COUNT_IS_UNLIMITED(max_cnt) && max_cnt < MAX_PKT_BURST){
 313                 burst_cnt = max_cnt;
 314         }else{
 315                 burst_cnt = MAX_PKT_BURST;
 316         }
 317
 318         while( PACKET_COUNT_IS_UNLIMITED(max_cnt) || pkt_cnt < max_cnt){
 319                 if (p->break_loop){
 320                         p->break_loop = 0;
 321                         return PCAP_ERROR_BREAK;
 322                 }
 323                 // read once in non-blocking mode, or try many times waiting for timeout_ms.
 324                 // if timeout_ms == 0, it will be blocked until one packet arrives or break_loop is setted.
 325                 nb_rx = dpdk_read_with_timeout(p, portid, 0, pkts_burst, burst_cnt);
 326                 if (nb_rx == 0){
 327                         if (pd->nonblock){
 328                                 RTE_LOG(DEBUG, USER1, "dpdk: no packets available in non-blocking mode.\n");
 329                         }else{
 330                                 if (p->break_loop){
 331                                         RTE_LOG(DEBUG, USER1, "dpdk: no packets available and break_loop is setted in blocking mode.\n");
 332                                         p->break_loop = 0;
 333                                         return PCAP_ERROR_BREAK;
 334
 335                                 }
 336                                 RTE_LOG(DEBUG, USER1, "dpdk: no packets available for timeout %d ms in blocking mode.\n", timeout_ms);
 337                         }
 338                         // break if dpdk reads 0 packet, no matter in blocking(timeout) or non-blocking mode.
 339                         break;
 340                 }
 341                 pkt_cnt += nb_rx;
 342                 for ( i = 0; i < nb_rx; i++) {
 343                         m = pkts_burst[i];
 344                         calculate_timestamp(&(pd->ts_helper),&(pcap_header.ts));
 345                         pkt_len = rte_pktmbuf_pkt_len(m);
 346                         // caplen = min(pkt_len, p->snapshot);
 347                         // caplen will not be changed, no matter how long the rte_pktmbuf
 348                         caplen = pkt_len < p->snapshot ? pkt_len: p->snapshot;
 349                         pcap_header.caplen = caplen;
 350                         pcap_header.len = pkt_len;
 351                         // volatile prefetch
 352                         rte_prefetch0(rte_pktmbuf_mtod(m, void *));
 353                         bp = NULL;
 354                         if (m->nb_segs == 1)
 355                         {
 356                                 bp = rte_pktmbuf_mtod(m, u_char *);
 357                         }else{
 358                                 // use fast buffer pcap_tmp_buf if pkt_len is small, no need to call malloc and free
 359                                 if ( pkt_len <= ETHER_MAX_JUMBO_FRAME_LEN)
 360                                 {
 361                                         gather_len = dpdk_gather_data(pd->pcap_tmp_buf, RTE_ETH_PCAP_SNAPLEN, m);
 362                                         bp = pd->pcap_tmp_buf;
 363                                 }else{
 364                                         // need call free later
 365                                         large_buffer = (u_char *)malloc(caplen*sizeof(u_char));
 366                                         gather_len = dpdk_gather_data(large_buffer, caplen, m);
 367                                         bp = large_buffer;
 368                                 }
 369
 370                         }
 371                         if (bp){
 372                                 if (p->fcode.bf_insns==NULL || pcap_filter(p->fcode.bf_insns, bp, pcap_header.len, pcap_header.caplen)){
 373                                         cb(cb_arg, &pcap_header, bp);
 374                                 }else{
 375                                         pd->bpf_drop++;
 376                                 }
 377                         }
 378                         //free all pktmbuf
 379                         rte_pktmbuf_free(m);
 380                         if (large_buffer){
 381                                 free(large_buffer);
 382                                 large_buffer=NULL;
 383                         }
 384                 }
 385         }
 386         return pkt_cnt;
 387 }
 388
 389 static int pcap_dpdk_inject(pcap_t *p, const void *buf _U_, int size _U_)
 390 {
 391         //not implemented yet
 392         pcap_strlcpy(p->errbuf,
 393             "dpdk error: Inject function has not been implemented yet",
 394             PCAP_ERRBUF_SIZE);
 395         return PCAP_ERROR;
 396 }
 397
 398 static void pcap_dpdk_close(pcap_t *p)
 399 {
 400         struct pcap_dpdk *pd = p->priv;
 401         if (pd==NULL)
 402         {
 403                 return;
 404         }
 405         if (pd->must_clear_promisc)
 406         {
 407                 rte_eth_promiscuous_disable(pd->portid);
 408         }
 409         rte_eth_dev_stop(pd->portid);
 410         rte_eth_dev_close(pd->portid);
 411         pcap_cleanup_live_common(p);
 412 }
 413
 414 static void nic_stats_display(struct pcap_dpdk *pd)
 415 {
 416         uint16_t portid = pd->portid;
 417         struct rte_eth_stats stats;
 418         rte_eth_stats_get(portid, &stats);
 419         RTE_LOG(INFO,USER1, "portid:%d, RX-packets: %-10"PRIu64"  RX-errors:  %-10"PRIu64
 420                "  RX-bytes:  %-10"PRIu64"  RX-Imissed:  %-10"PRIu64"\n", portid, stats.ipackets, stats.ierrors,
 421                stats.ibytes,stats.imissed);
 422         RTE_LOG(INFO,USER1, "portid:%d, RX-PPS: %-10"PRIu64" RX-Mbps: %.2lf\n", portid, pd->pps, pd->bps/1e6f );
 423 }
 424
 425 static int pcap_dpdk_stats(pcap_t *p, struct pcap_stat *ps)
 426 {
 427         struct pcap_dpdk *pd = p->priv;
 428         calculate_timestamp(&(pd->ts_helper), &(pd->curr_ts));
 429         rte_eth_stats_get(pd->portid,&(pd->curr_stats));
 430         if (ps){
 431                 ps->ps_recv = pd->curr_stats.ipackets;
 432                 ps->ps_drop = pd->curr_stats.ierrors;
 433                 ps->ps_drop += pd->bpf_drop;
 434                 ps->ps_ifdrop = pd->curr_stats.imissed;
 435         }
 436         uint64_t delta_pkt = pd->curr_stats.ipackets - pd->prev_stats.ipackets;
 437         struct timeval delta_tm;
 438         timersub(&(pd->curr_ts),&(pd->prev_ts), &delta_tm);
 439         uint64_t delta_usec = delta_tm.tv_sec*1e6+delta_tm.tv_usec;
 440         uint64_t delta_bit = (pd->curr_stats.ibytes-pd->prev_stats.ibytes)*8;
 441         RTE_LOG(DEBUG, USER1, "delta_usec: %-10"PRIu64" delta_pkt: %-10"PRIu64" delta_bit: %-10"PRIu64"\n", delta_usec, delta_pkt, delta_bit);
 442         pd->pps = (uint64_t)(delta_pkt*1e6f/delta_usec);
 443         pd->bps = (uint64_t)(delta_bit*1e6f/delta_usec);
 444         nic_stats_display(pd);
 445         pd->prev_stats = pd->curr_stats;
 446         pd->prev_ts = pd->curr_ts;
 447         return 0;
 448 }
 449
 450 static int pcap_dpdk_setnonblock(pcap_t *p, int nonblock){
 451         struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
 452         pd->nonblock = nonblock;
 453         return 0;
 454 }
 455
 456 static int pcap_dpdk_getnonblock(pcap_t *p){
 457         struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
 458         return pd->nonblock;
 459 }
 460 static int check_link_status(uint16_t portid, struct rte_eth_link *plink)
 461 {
 462         // wait up to 9 seconds to get link status
 463         rte_eth_link_get(portid, plink);
 464         return plink->link_status == ETH_LINK_UP;
 465 }
 466 static void eth_addr_str(struct ether_addr *addrp, char* mac_str, int len)
 467 {
 468         int offset=0;
 469         if (addrp == NULL){
 470                 pcap_snprintf(mac_str, len-1, DPDK_DEF_MAC_ADDR);
 471                 return;
 472         }
 473         for (int i=0; i<6; i++)
 474         {
 475                 if (offset >= len)
 476                 { // buffer overflow
 477                         return;
 478                 }
 479                 if (i==0)
 480                 {
 481                         pcap_snprintf(mac_str+offset, len-1-offset, "%02X",addrp->addr_bytes[i]);
 482                         offset+=2; // FF
 483                 }else{
 484                         pcap_snprintf(mac_str+offset, len-1-offset, ":%02X", addrp->addr_bytes[i]);
 485                         offset+=3; // :FF
 486                 }
 487         }
 488         return;
 489 }
 490 // return portid by device name, otherwise return -1
 491 static uint16_t portid_by_device(char * device)
 492 {
 493         uint16_t ret = DPDK_PORTID_MAX;
 494         int len = strlen(device);
 495         int prefix_len = strlen(DPDK_PREFIX);
 496         unsigned long ret_ul = 0L;
 497         char *pEnd;
 498         if (len<=prefix_len || strncmp(device, DPDK_PREFIX, prefix_len)) // check prefix dpdk:
 499         {
 500                 return ret;
 501         }
 502         //check all chars are digital
 503         for (int i=prefix_len; device[i]; i++){
 504                 if (device[i]<'0' || device[i]>'9'){
 505                         return ret;
 506                 }
 507         }
 508         ret_ul = strtoul(&(device[prefix_len]), &pEnd, 10);
 509         if (pEnd == &(device[prefix_len]) || *pEnd != '\0'){
 510                 return ret;
 511         }
 512         // too large for portid
 513         if (ret_ul >= DPDK_PORTID_MAX){
 514                 return ret;
 515         }
 516         ret = (uint16_t)ret_ul;
 517         return ret;
 518 }
 519
 520 static int parse_dpdk_cfg(char* dpdk_cfg,char** dargv)
 521 {
 522         int cnt=0;
 523         memset(dargv,0,sizeof(dargv[0])*DPDK_ARGC_MAX);
 524         //current process name
 525         int skip_space = 1;
 526         int i=0;
 527         RTE_LOG(INFO, USER1,"dpdk cfg: %s\n",dpdk_cfg);
 528         // find first non space char
 529         // The last opt is NULL
 530         for (i=0;dpdk_cfg[i] && cnt<DPDK_ARGC_MAX-1;i++){
 531                 if (skip_space && dpdk_cfg[i]!=' '){ // not space
 532                         skip_space=!skip_space; // skip normal char
 533                         dargv[cnt++] = dpdk_cfg+i;
 534                 }
 535                 if (!skip_space && dpdk_cfg[i]==' '){ // fint a space
 536                         dpdk_cfg[i]=0x00; // end of this opt
 537                         skip_space=!skip_space; // skip space char
 538                 }
 539         }
 540         dargv[cnt]=NULL;
 541         return cnt;
 542 }
 543
 544 // only called once
 545 static int dpdk_pre_init(void)
 546 {
 547         int dargv_cnt=0;
 548         char *dargv[DPDK_ARGC_MAX];
 549         char *ptr_dpdk_cfg = NULL;
 550         int ret = PCAP_ERROR;
 551         // globale var
 552         if (is_dpdk_pre_inited)
 553         {
 554                 // already inited
 555                 return 0;
 556         }
 557         // check for root permission
 558         if( geteuid() != 0)
 559         {
 560                 RTE_LOG(ERR, USER1, "%s\n", DPDK_ERR_PERM_MSG);
 561                 return PCAP_ERROR_PERM_DENIED;
 562         }
 563         // init EAL
 564         ptr_dpdk_cfg = getenv(DPDK_CFG_ENV_NAME);
 565         // set default log level to debug
 566         rte_log_set_global_level(DPDK_DEF_LOG_LEV);
 567         if (ptr_dpdk_cfg == NULL)
 568         {
 569                 RTE_LOG(INFO,USER1,"env $DPDK_CFG is unset, so using default: %s\n",DPDK_DEF_CFG);
 570                 ptr_dpdk_cfg = DPDK_DEF_CFG;
 571         }
 572         memset(dpdk_cfg_buf,0,sizeof(dpdk_cfg_buf));
 573         snprintf(dpdk_cfg_buf,DPDK_CFG_MAX_LEN-1,"%s %s",DPDK_LIB_NAME,ptr_dpdk_cfg);
 574         dargv_cnt = parse_dpdk_cfg(dpdk_cfg_buf,dargv);
 575         ret = rte_eal_init(dargv_cnt,dargv);
 576         if (ret == -1)
 577         {
 578                 // Error.
 579                 return PCAP_ERROR;
 580         }
 581         // init successed, so we do not need to do it again later.
 582         is_dpdk_pre_inited = 1;
 583         return 0;
 584 }
 585
 586 static int pcap_dpdk_activate(pcap_t *p)
 587 {
 588         struct pcap_dpdk *pd = p->priv;
 589         pd->orig = p;
 590         int ret = PCAP_ERROR;
 591         uint16_t nb_ports=0;
 592         uint16_t portid= DPDK_PORTID_MAX;
 593         unsigned nb_mbufs = DPDK_NB_MBUFS;
 594         struct rte_eth_rxconf rxq_conf;
 595         struct rte_eth_txconf txq_conf;
 596         struct rte_eth_conf local_port_conf = port_conf;
 597         struct rte_eth_dev_info dev_info;
 598         int is_port_up = 0;
 599         struct rte_eth_link link;
 600         do{
 601                 //init EAL
 602                 ret = dpdk_pre_init();
 603                 if (ret < 0)
 604                 {
 605                         // This returns a negative value on an error.
 606                         // That's either PCAP_ERROR_PERM_DENIED if
 607                         // you're not running as root, or PCAP_ERROR
 608                         // if rte_eal_init() fails.
 609                         //
 610                         // If it returned PCAP_ERROR, provide an error
 611                         // message based on rte_errno.  Otherwise, the
 612                         // error message has already been filled in.
 613                         if (ret == PCAP_ERROR)
 614                         {
 615                                 dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
 616                                     PCAP_ERRBUF_SIZE, rte_errno,
 617                                     "dpdk error: Init failed with device %s",
 618                                     p->opt.device);
 619                         }
 620                         else
 621                         {
 622                                 pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
 623                                     "Can't open device %s: DPDK requires that it run as root",
 624                                     p->opt.device);
 625                         }
 626                         // ret is set to the correct error
 627                         break;
 628                 }
 629                 ret = dpdk_init_timer(pd);
 630                 if (ret<0)
 631                 {
 632                         pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
 633                                 "dpdk error: Init timer is zero with device %s",
 634                                 p->opt.device);
 635                         ret = PCAP_ERROR;
 636                         break;
 637                 }
 638
 639                 nb_ports = rte_eth_dev_count_avail();
 640                 if (nb_ports == 0)
 641                 {
 642                         pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
 643                             "dpdk error: No Ethernet ports");
 644                         ret = PCAP_ERROR;
 645                         break;
 646                 }
 647
 648                 portid = portid_by_device(p->opt.device);
 649                 if (portid == DPDK_PORTID_MAX){
 650                         pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
 651                             "dpdk error: portid is invalid. device %s",
 652                             p->opt.device);
 653                         ret = PCAP_ERROR_NO_SUCH_DEVICE;
 654                         break;
 655                 }
 656
 657                 pd->portid = portid;
 658
 659                 if (p->snapshot <= 0 || p->snapshot > MAXIMUM_SNAPLEN)
 660                 {
 661                         p->snapshot = MAXIMUM_SNAPLEN;
 662                 }
 663                 // create the mbuf pool
 664                 pd->pktmbuf_pool = rte_pktmbuf_pool_create(MBUF_POOL_NAME, nb_mbufs,
 665                         MEMPOOL_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE,
 666                         rte_socket_id());
 667                 if (pd->pktmbuf_pool == NULL)
 668                 {
 669                         dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
 670                             PCAP_ERRBUF_SIZE, rte_errno,
 671                             "dpdk error: Cannot init mbuf pool");
 672                         ret = PCAP_ERROR;
 673                         break;
 674                 }
 675                 // config dev
 676                 rte_eth_dev_info_get(portid, &dev_info);
 677                 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
 678                 {
 679                         local_port_conf.txmode.offloads |=DEV_TX_OFFLOAD_MBUF_FAST_FREE;
 680                 }
 681                 // only support 1 queue
 682                 ret = rte_eth_dev_configure(portid, 1, 1, &local_port_conf);
 683                 if (ret < 0)
 684                 {
 685                         dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
 686                             PCAP_ERRBUF_SIZE, -ret,
 687                             "dpdk error: Cannot configure device: port=%u",
 688                             portid);
 689                         ret = PCAP_ERROR;
 690                         break;
 691                 }
 692                 // adjust rx tx
 693                 ret = rte_eth_dev_adjust_nb_rx_tx_desc(portid, &nb_rxd, &nb_txd);
 694                 if (ret < 0)
 695                 {
 696                         dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
 697                             PCAP_ERRBUF_SIZE, -ret,
 698                             "dpdk error: Cannot adjust number of descriptors: port=%u",
 699                             portid);
 700                         ret = PCAP_ERROR;
 701                         break;
 702                 }
 703                 // get MAC addr
 704                 rte_eth_macaddr_get(portid, &(pd->eth_addr));
 705                 eth_addr_str(&(pd->eth_addr), pd->mac_addr, DPDK_MAC_ADDR_SIZE-1);
 706
 707                 // init one RX queue
 708                 rxq_conf = dev_info.default_rxconf;
 709                 rxq_conf.offloads = local_port_conf.rxmode.offloads;
 710                 ret = rte_eth_rx_queue_setup(portid, 0, nb_rxd,
 711                                              rte_eth_dev_socket_id(portid),
 712                                              &rxq_conf,
 713                                              pd->pktmbuf_pool);
 714                 if (ret < 0)
 715                 {
 716                         dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
 717                             PCAP_ERRBUF_SIZE, -ret,
 718                             "dpdk error: rte_eth_rx_queue_setup:port=%u",
 719                             portid);
 720                         ret = PCAP_ERROR;
 721                         break;
 722                 }
 723
 724                 // init one TX queue
 725                 txq_conf = dev_info.default_txconf;
 726                 txq_conf.offloads = local_port_conf.txmode.offloads;
 727                 ret = rte_eth_tx_queue_setup(portid, 0, nb_txd,
 728                                 rte_eth_dev_socket_id(portid),
 729                                 &txq_conf);
 730                 if (ret < 0)
 731                 {
 732                         dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
 733                             PCAP_ERRBUF_SIZE, -ret,
 734                             "dpdk error: rte_eth_tx_queue_setup:port=%u",
 735                             portid);
 736                         ret = PCAP_ERROR;
 737                         break;
 738                 }
 739                 // Initialize TX buffers
 740                 tx_buffer = rte_zmalloc_socket(DPDK_TX_BUF_NAME,
 741                                 RTE_ETH_TX_BUFFER_SIZE(MAX_PKT_BURST), 0,
 742                                 rte_eth_dev_socket_id(portid));
 743                 if (tx_buffer == NULL)
 744                 {
 745                         pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
 746                             "dpdk error: Cannot allocate buffer for tx on port %u", portid);
 747                         ret = PCAP_ERROR;
 748                         break;
 749                 }
 750                 rte_eth_tx_buffer_init(tx_buffer, MAX_PKT_BURST);
 751                 // Start device
 752                 ret = rte_eth_dev_start(portid);
 753                 if (ret < 0)
 754                 {
 755                         dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
 756                             PCAP_ERRBUF_SIZE, -ret,
 757                             "dpdk error: rte_eth_dev_start:port=%u",
 758                             portid);
 759                         ret = PCAP_ERROR;
 760                         break;
 761                 }
 762                 // set promiscuous mode
 763                 if (p->opt.promisc){
 764                         pd->must_clear_promisc=1;
 765                         rte_eth_promiscuous_enable(portid);
 766                 }
 767                 // check link status
 768                 is_port_up = check_link_status(portid, &link);
 769                 if (!is_port_up){
 770                         pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
 771                             "dpdk error: link is down, port=%u",portid);
 772                         ret = PCAP_ERROR_IFACE_NOT_UP;
 773                         break;
 774                 }
 775                 // reset statistics
 776                 rte_eth_stats_reset(pd->portid);
 777                 calculate_timestamp(&(pd->ts_helper), &(pd->prev_ts));
 778                 rte_eth_stats_get(pd->portid,&(pd->prev_stats));
 779                 // format pcap_t
 780                 pd->portid = portid;
 781                 p->fd = pd->portid;
 782                 if (p->snapshot <=0 || p->snapshot> MAXIMUM_SNAPLEN)
 783                 {
 784                         p->snapshot = MAXIMUM_SNAPLEN;
 785                 }
 786                 p->linktype = DLT_EN10MB; // Ethernet, the 10MB is historical.
 787                 p->selectable_fd = p->fd;
 788                 p->read_op = pcap_dpdk_dispatch;
 789                 p->inject_op = pcap_dpdk_inject;
 790                 // using pcap_filter currently, though DPDK provides their own BPF function. Because DPDK BPF needs load a ELF file as a filter.
 791                 p->setfilter_op = install_bpf_program;
 792                 p->setdirection_op = NULL;
 793                 p->set_datalink_op = NULL;
 794                 p->getnonblock_op = pcap_dpdk_getnonblock;
 795                 p->setnonblock_op = pcap_dpdk_setnonblock;
 796                 p->stats_op = pcap_dpdk_stats;
 797                 p->cleanup_op = pcap_dpdk_close;
 798                 p->breakloop_op = pcap_breakloop_common;
 799                 // set default timeout
 800                 pd->required_select_timeout.tv_sec = 0;
 801                 pd->required_select_timeout.tv_usec = DPDK_DEF_MIN_SLEEP_MS*1000;
 802                 p->required_select_timeout = &pd->required_select_timeout;
 803                 ret = 0; // OK
 804         }while(0);
 805
 806         if (ret <= PCAP_ERROR) // all kinds of error code
 807         {
 808                 pcap_cleanup_live_common(p);
 809         }else{
 810                 rte_eth_dev_get_name_by_port(portid,pd->pci_addr);
 811                 RTE_LOG(INFO, USER1,"Port %d device: %s, MAC:%s, PCI:%s\n", portid, p->opt.device, pd->mac_addr, pd->pci_addr);
 812                 RTE_LOG(INFO, USER1,"Port %d Link Up. Speed %u Mbps - %s\n",
 813                                                         portid, link.link_speed,
 814                                         (link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
 815                                                 ("full-duplex") : ("half-duplex\n"));
 816         }
 817         return ret;
 818 }
 819
 820 // device name for dpdk shoud be in the form as dpdk:number, such as dpdk:0
 821 pcap_t * pcap_dpdk_create(const char *device, char *ebuf, int *is_ours)
 822 {
 823         pcap_t *p=NULL;
 824         *is_ours = 0;
 825
 826         *is_ours = !strncmp(device, "dpdk:", 5);
 827         if (! *is_ours)
 828                 return NULL;
 829         //memset will happen
 830         p = pcap_create_common(ebuf, sizeof(struct pcap_dpdk));
 831
 832         if (p == NULL)
 833                 return NULL;
 834         p->activate_op = pcap_dpdk_activate;
 835         return p;
 836 }
 837
 838 int pcap_dpdk_findalldevs(pcap_if_list_t *devlistp, char *ebuf)
 839 {
 840         int ret=0;
 841         unsigned int nb_ports = 0;
 842         char dpdk_name[DPDK_DEV_NAME_MAX];
 843         char dpdk_desc[DPDK_DEV_DESC_MAX];
 844         struct ether_addr eth_addr;
 845         char mac_addr[DPDK_MAC_ADDR_SIZE];
 846         char pci_addr[DPDK_PCI_ADDR_SIZE];
 847         do{
 848                 ret = dpdk_pre_init();
 849                 if (ret < 0)
 850                 {
 851                         // This returns a negative value on an error.
 852                         // That's either PCAP_ERROR_PERM_DENIED if
 853                         // you're not running as root, or PCAP_ERROR
 854                         // if rte_eal_init() fails.
 855                         //
 856                         // If it returned PCAP_ERROR, provide an error
 857                         // message based on rte_errno.  Otherwise, the
 858                         // error message has already been filled in.
 859                         if (ret == PCAP_ERROR)
 860                         {
 861                                 dpdk_fmt_errmsg_for_rte_errno(ebuf,
 862                                     PCAP_ERRBUF_SIZE, rte_errno,
 863                                     "dpdk error: Init failed");
 864                         }
 865                         else
 866                         {
 867                                 pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,
 868                                     "DPDK requires that it run as root");
 869                         }
 870                         // ret is set to the correct error
 871                         break;
 872                 }
 873                 nb_ports = rte_eth_dev_count_avail();
 874                 if (nb_ports == 0)
 875                 {
 876                         pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,
 877                             "DPDK error: No Ethernet ports");
 878                         ret = PCAP_ERROR;
 879                         break;
 880                 }
 881                 for (unsigned int i=0; i<nb_ports; i++){
 882                         pcap_snprintf(dpdk_name, DPDK_DEV_NAME_MAX-1,
 883                             "%s%u", DPDK_PREFIX, i);
 884                         // mac addr
 885                         rte_eth_macaddr_get(i, &eth_addr);
 886                         eth_addr_str(&eth_addr,mac_addr,DPDK_MAC_ADDR_SIZE);
 887                         // PCI addr
 888                         rte_eth_dev_get_name_by_port(i,pci_addr);
 889                         pcap_snprintf(dpdk_desc,DPDK_DEV_DESC_MAX-1,"%s %s, MAC:%s, PCI:%s", DPDK_DESC, dpdk_name, mac_addr, pci_addr);
 890                         if (add_dev(devlistp, dpdk_name, 0, dpdk_desc, ebuf)==NULL){
 891                                 ret = PCAP_ERROR;
 892                                 break;
 893                         }
 894                 }
 895         }while(0);
 896         return ret;
 897 }
 898
 899 #ifdef DPDK_ONLY
 900 /*
 901  * This libpcap build supports only DPDK, not regular network interfaces.
 902  */
 903
 904 /*
 905  * There are no regular interfaces, just DPDK interfaces.
 906  */
 907 int
 908 pcap_platform_finddevs(pcap_if_list_t *devlistp _U_, char *errbuf)
 909 {
 910         return (0);
 911 }
 912
 913 /*
 914  * Attempts to open a regular interface fail.
 915  */
 916 pcap_t *
 917 pcap_create_interface(const char *device, char *errbuf)
 918 {
 919         pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
 920             "This version of libpcap only supports DPDK");
 921         return NULL;
 922 }
 923
 924 /*
 925  * Libpcap version string.
 926  */
 927 const char *
 928 pcap_lib_version(void)
 929 {
 930         return (PCAP_VERSION_STRING " (DPDK-only)");
 931 }
 932 #endif