xref: /freebsd/contrib/libpcap/pcap-dpdk.c (revision 56b17de1e8360fe131d425de20b5e75ff3ea897c)
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 dynamically, 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 driver 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 environment 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 launched 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 #include <config.h>
79 
80 #include <errno.h>
81 #include <netdb.h>
82 #include <stdio.h>
83 #include <stdlib.h>
84 #include <string.h>
85 #include <unistd.h>
86 #include <limits.h> /* for INT_MAX */
87 #include <time.h>
88 
89 #include <sys/time.h>
90 
91 //header for calling dpdk
92 #include <rte_config.h>
93 #include <rte_common.h>
94 #include <rte_errno.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 /*
118  * Deal with API changes that break source compatibility.
119  */
120 
121 #ifdef HAVE_STRUCT_RTE_ETHER_ADDR
122 #define ETHER_ADDR_TYPE	struct rte_ether_addr
123 #else
124 #define ETHER_ADDR_TYPE	struct ether_addr
125 #endif
126 
127 #define DPDK_DEF_LOG_LEV RTE_LOG_ERR
128 //
129 // This is set to 0 if we haven't initialized DPDK yet, 1 if we've
130 // successfully initialized it, a negative value, which is the negative
131 // of the rte_errno from rte_eal_init(), if we tried to initialize it
132 // and got an error.
133 //
134 static int is_dpdk_pre_inited=0;
135 #define DPDK_LIB_NAME "libpcap_dpdk"
136 #define DPDK_DESC "Data Plane Development Kit (DPDK) Interface"
137 #define DPDK_ERR_PERM_MSG "permission denied, DPDK needs root permission"
138 #define DPDK_ARGC_MAX 64
139 #define DPDK_CFG_MAX_LEN 1024
140 #define DPDK_DEV_NAME_MAX 32
141 #define DPDK_DEV_DESC_MAX 512
142 #define DPDK_CFG_ENV_NAME "DPDK_CFG"
143 #define DPDK_DEF_MIN_SLEEP_MS 1
144 static char dpdk_cfg_buf[DPDK_CFG_MAX_LEN];
145 #define DPDK_MAC_ADDR_SIZE 32
146 #define DPDK_DEF_MAC_ADDR "00:00:00:00:00:00"
147 #define DPDK_PCI_ADDR_SIZE 16
148 #define DPDK_DEF_CFG "--log-level=error -l0 -dlibrte_pmd_e1000.so -dlibrte_pmd_ixgbe.so -dlibrte_mempool_ring.so"
149 #define DPDK_PREFIX "dpdk:"
150 #define DPDK_PORTID_MAX 65535U
151 #define MBUF_POOL_NAME "mbuf_pool"
152 #define DPDK_TX_BUF_NAME "tx_buffer"
153 //The number of elements in the mbuf pool.
154 #define DPDK_NB_MBUFS 8192U
155 #define MEMPOOL_CACHE_SIZE 256
156 #define MAX_PKT_BURST 32
157 // Configurable number of RX/TX ring descriptors
158 #define RTE_TEST_RX_DESC_DEFAULT 1024
159 #define RTE_TEST_TX_DESC_DEFAULT 1024
160 
161 static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
162 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
163 
164 #ifdef RTE_ETHER_MAX_JUMBO_FRAME_LEN
165 #define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
166 #else
167 #define RTE_ETH_PCAP_SNAPLEN ETHER_MAX_JUMBO_FRAME_LEN
168 #endif
169 
170 static struct rte_eth_dev_tx_buffer *tx_buffer;
171 
172 struct dpdk_ts_helper{
173 	struct timeval start_time;
174 	uint64_t start_cycles;
175 	uint64_t hz;
176 };
177 struct pcap_dpdk{
178 	pcap_t * orig;
179 	uint16_t portid; // portid of DPDK
180 	int must_clear_promisc;
181 	uint64_t bpf_drop;
182 	int nonblock;
183 	struct timeval required_select_timeout;
184 	struct timeval prev_ts;
185 	struct rte_eth_stats prev_stats;
186 	struct timeval curr_ts;
187 	struct rte_eth_stats curr_stats;
188 	uint64_t pps;
189 	uint64_t bps;
190 	struct rte_mempool * pktmbuf_pool;
191 	struct dpdk_ts_helper ts_helper;
192 	ETHER_ADDR_TYPE eth_addr;
193 	char mac_addr[DPDK_MAC_ADDR_SIZE];
194 	char pci_addr[DPDK_PCI_ADDR_SIZE];
195 	unsigned char pcap_tmp_buf[RTE_ETH_PCAP_SNAPLEN];
196 };
197 
198 static struct rte_eth_conf port_conf = {
199 	.rxmode = {
200 		.split_hdr_size = 0,
201 	},
202 	.txmode = {
203 		.mq_mode = ETH_MQ_TX_NONE,
204 	},
205 };
206 
207 static void	dpdk_fmt_errmsg_for_rte_errno(char *, size_t, int,
208     PCAP_FORMAT_STRING(const char *), ...) PCAP_PRINTFLIKE(4, 5);
209 
210 /*
211  * Generate an error message based on a format, arguments, and an
212  * rte_errno, with a message for the rte_errno after the formatted output.
213  */
214 static void dpdk_fmt_errmsg_for_rte_errno(char *errbuf, size_t errbuflen,
215     int errnum, const char *fmt, ...)
216 {
217 	va_list ap;
218 	size_t msglen;
219 	char *p;
220 	size_t errbuflen_remaining;
221 
222 	va_start(ap, fmt);
223 	vsnprintf(errbuf, errbuflen, fmt, ap);
224 	va_end(ap);
225 	msglen = strlen(errbuf);
226 
227 	/*
228 	 * Do we have enough space to append ": "?
229 	 * Including the terminating '\0', that's 3 bytes.
230 	 */
231 	if (msglen + 3 > errbuflen) {
232 		/* No - just give them what we've produced. */
233 		return;
234 	}
235 	p = errbuf + msglen;
236 	errbuflen_remaining = errbuflen - msglen;
237 	*p++ = ':';
238 	*p++ = ' ';
239 	*p = '\0';
240 	msglen += 2;
241 	errbuflen_remaining -= 2;
242 
243 	/*
244 	 * Now append the string for the error code.
245 	 * rte_strerror() is thread-safe, at least as of dpdk 18.11,
246 	 * unlike strerror() - it uses strerror_r() rather than strerror()
247 	 * for UN*X errno values, and prints to what I assume is a per-thread
248 	 * buffer (based on the "PER_LCORE" in "RTE_DEFINE_PER_LCORE" used
249 	 * to declare the buffers statically) for DPDK errors.
250 	 */
251 	snprintf(p, errbuflen_remaining, "%s", rte_strerror(errnum));
252 }
253 
254 static int dpdk_init_timer(struct pcap_dpdk *pd){
255 	gettimeofday(&(pd->ts_helper.start_time),NULL);
256 	pd->ts_helper.start_cycles = rte_get_timer_cycles();
257 	pd->ts_helper.hz = rte_get_timer_hz();
258 	if (pd->ts_helper.hz == 0){
259 		return -1;
260 	}
261 	return 0;
262 }
263 static inline void calculate_timestamp(struct dpdk_ts_helper *helper,struct timeval *ts)
264 {
265 	uint64_t cycles;
266 	// delta
267 	struct timeval cur_time;
268 	cycles = rte_get_timer_cycles() - helper->start_cycles;
269 	cur_time.tv_sec = (time_t)(cycles/helper->hz);
270 	cur_time.tv_usec = (suseconds_t)((cycles%helper->hz)*1e6/helper->hz);
271 	timeradd(&(helper->start_time), &cur_time, ts);
272 }
273 
274 static uint32_t dpdk_gather_data(unsigned char *data, uint32_t len, struct rte_mbuf *mbuf)
275 {
276 	uint32_t total_len = 0;
277 	while (mbuf && (total_len+mbuf->data_len) < len ){
278 		rte_memcpy(data+total_len, rte_pktmbuf_mtod(mbuf,void *),mbuf->data_len);
279 		total_len+=mbuf->data_len;
280 		mbuf=mbuf->next;
281 	}
282 	return total_len;
283 }
284 
285 
286 static int dpdk_read_with_timeout(pcap_t *p, struct rte_mbuf **pkts_burst, const uint16_t burst_cnt){
287 	struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
288 	int nb_rx = 0;
289 	int timeout_ms = p->opt.timeout;
290 	int sleep_ms = 0;
291 	if (pd->nonblock){
292 		// In non-blocking mode, just read once, no matter how many packets are captured.
293 		nb_rx = (int)rte_eth_rx_burst(pd->portid, 0, pkts_burst, burst_cnt);
294 	}else{
295 		// In blocking mode, read many times until packets are captured or timeout or break_loop is set.
296 		// if timeout_ms == 0, it may be blocked forever.
297 		while (timeout_ms == 0 || sleep_ms < timeout_ms){
298 			nb_rx = (int)rte_eth_rx_burst(pd->portid, 0, pkts_burst, burst_cnt);
299 			if (nb_rx){ // got packets within timeout_ms
300 				break;
301 			}else{ // no packet arrives at this round.
302 				if (p->break_loop){
303 					break;
304 				}
305 				// sleep for a very short while.
306 				// block sleep is the only choice, since usleep() will impact performance dramatically.
307 				rte_delay_us_block(DPDK_DEF_MIN_SLEEP_MS*1000);
308 				sleep_ms += DPDK_DEF_MIN_SLEEP_MS;
309 			}
310 		}
311 	}
312 	return nb_rx;
313 }
314 
315 static int pcap_dpdk_dispatch(pcap_t *p, int max_cnt, pcap_handler cb, u_char *cb_arg)
316 {
317 	struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
318 	int burst_cnt = 0;
319 	int nb_rx = 0;
320 	struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
321 	struct rte_mbuf *m;
322 	struct pcap_pkthdr pcap_header;
323 	// In DPDK, pkt_len is sum of lengths for all segments. And data_len is for one segment
324 	uint32_t pkt_len = 0;
325 	uint32_t caplen = 0;
326 	u_char *bp = NULL;
327 	int i=0;
328 	unsigned int gather_len =0;
329 	int pkt_cnt = 0;
330 	u_char *large_buffer=NULL;
331 	int timeout_ms = p->opt.timeout;
332 
333 	/*
334 	 * This can conceivably process more than INT_MAX packets,
335 	 * which would overflow the packet count, causing it either
336 	 * to look like a negative number, and thus cause us to
337 	 * return a value that looks like an error, or overflow
338 	 * back into positive territory, and thus cause us to
339 	 * return a too-low count.
340 	 *
341 	 * Therefore, if the packet count is unlimited, we clip
342 	 * it at INT_MAX; this routine is not expected to
343 	 * process packets indefinitely, so that's not an issue.
344 	 */
345 	if (PACKET_COUNT_IS_UNLIMITED(max_cnt))
346 		max_cnt = INT_MAX;
347 
348 	if (max_cnt < MAX_PKT_BURST){
349 		burst_cnt = max_cnt;
350 	}else{
351 		burst_cnt = MAX_PKT_BURST;
352 	}
353 
354 	while( pkt_cnt < max_cnt){
355 		if (p->break_loop){
356 			p->break_loop = 0;
357 			return PCAP_ERROR_BREAK;
358 		}
359 		// read once in non-blocking mode, or try many times waiting for timeout_ms.
360 		// if timeout_ms == 0, it will be blocked until one packet arrives or break_loop is set.
361 		nb_rx = dpdk_read_with_timeout(p, pkts_burst, burst_cnt);
362 		if (nb_rx == 0){
363 			if (pd->nonblock){
364 				RTE_LOG(DEBUG, USER1, "dpdk: no packets available in non-blocking mode.\n");
365 			}else{
366 				if (p->break_loop){
367 					RTE_LOG(DEBUG, USER1, "dpdk: no packets available and break_loop is set in blocking mode.\n");
368 					p->break_loop = 0;
369 					return PCAP_ERROR_BREAK;
370 
371 				}
372 				RTE_LOG(DEBUG, USER1, "dpdk: no packets available for timeout %d ms in blocking mode.\n", timeout_ms);
373 			}
374 			// break if dpdk reads 0 packet, no matter in blocking(timeout) or non-blocking mode.
375 			break;
376 		}
377 		pkt_cnt += nb_rx;
378 		for ( i = 0; i < nb_rx; i++) {
379 			m = pkts_burst[i];
380 			calculate_timestamp(&(pd->ts_helper),&(pcap_header.ts));
381 			pkt_len = rte_pktmbuf_pkt_len(m);
382 			// caplen = min(pkt_len, p->snapshot);
383 			// caplen will not be changed, no matter how long the rte_pktmbuf
384 			caplen = pkt_len < (uint32_t)p->snapshot ? pkt_len: (uint32_t)p->snapshot;
385 			pcap_header.caplen = caplen;
386 			pcap_header.len = pkt_len;
387 			// volatile prefetch
388 			rte_prefetch0(rte_pktmbuf_mtod(m, void *));
389 			bp = NULL;
390 			if (m->nb_segs == 1)
391 			{
392 				bp = rte_pktmbuf_mtod(m, u_char *);
393 			}else{
394 				// use fast buffer pcap_tmp_buf if pkt_len is small, no need to call malloc and free
395 				if ( pkt_len <= RTE_ETH_PCAP_SNAPLEN)
396 				{
397 					gather_len = dpdk_gather_data(pd->pcap_tmp_buf, RTE_ETH_PCAP_SNAPLEN, m);
398 					bp = pd->pcap_tmp_buf;
399 				}else{
400 					// need call free later
401 					large_buffer = (u_char *)malloc(caplen*sizeof(u_char));
402 					gather_len = dpdk_gather_data(large_buffer, caplen, m);
403 					bp = large_buffer;
404 				}
405 
406 			}
407 			if (bp){
408 				if (p->fcode.bf_insns==NULL || pcapint_filter(p->fcode.bf_insns, bp, pcap_header.len, pcap_header.caplen)){
409 					cb(cb_arg, &pcap_header, bp);
410 				}else{
411 					pd->bpf_drop++;
412 				}
413 			}
414 			//free all pktmbuf
415 			rte_pktmbuf_free(m);
416 			if (large_buffer){
417 				free(large_buffer);
418 				large_buffer=NULL;
419 			}
420 		}
421 	}
422 	return pkt_cnt;
423 }
424 
425 static int pcap_dpdk_inject(pcap_t *p, const void *buf _U_, int size _U_)
426 {
427 	//not implemented yet
428 	pcapint_strlcpy(p->errbuf,
429 	    "dpdk error: Inject function has not been implemented yet",
430 	    PCAP_ERRBUF_SIZE);
431 	return PCAP_ERROR;
432 }
433 
434 static void pcap_dpdk_close(pcap_t *p)
435 {
436 	struct pcap_dpdk *pd = p->priv;
437 	if (pd==NULL)
438 	{
439 		return;
440 	}
441 	if (pd->must_clear_promisc)
442 	{
443 		rte_eth_promiscuous_disable(pd->portid);
444 	}
445 	rte_eth_dev_stop(pd->portid);
446 	rte_eth_dev_close(pd->portid);
447 	pcapint_cleanup_live_common(p);
448 }
449 
450 static void nic_stats_display(struct pcap_dpdk *pd)
451 {
452 	uint16_t portid = pd->portid;
453 	struct rte_eth_stats stats;
454 	rte_eth_stats_get(portid, &stats);
455 	RTE_LOG(INFO,USER1, "portid:%d, RX-packets: %-10"PRIu64"  RX-errors:  %-10"PRIu64
456 	       "  RX-bytes:  %-10"PRIu64"  RX-Imissed:  %-10"PRIu64"\n", portid, stats.ipackets, stats.ierrors,
457 	       stats.ibytes,stats.imissed);
458 	RTE_LOG(INFO,USER1, "portid:%d, RX-PPS: %-10"PRIu64" RX-Mbps: %.2lf\n", portid, pd->pps, pd->bps/1e6f );
459 }
460 
461 static int pcap_dpdk_stats(pcap_t *p, struct pcap_stat *ps)
462 {
463 	struct pcap_dpdk *pd = p->priv;
464 	calculate_timestamp(&(pd->ts_helper), &(pd->curr_ts));
465 	rte_eth_stats_get(pd->portid,&(pd->curr_stats));
466 	if (ps){
467 		ps->ps_recv = pd->curr_stats.ipackets;
468 		ps->ps_drop = pd->curr_stats.ierrors;
469 		ps->ps_drop += pd->bpf_drop;
470 		ps->ps_ifdrop = pd->curr_stats.imissed;
471 	}
472 	uint64_t delta_pkt = pd->curr_stats.ipackets - pd->prev_stats.ipackets;
473 	struct timeval delta_tm;
474 	timersub(&(pd->curr_ts),&(pd->prev_ts), &delta_tm);
475 	uint64_t delta_usec = delta_tm.tv_sec*1e6+delta_tm.tv_usec;
476 	uint64_t delta_bit = (pd->curr_stats.ibytes-pd->prev_stats.ibytes)*8;
477 	RTE_LOG(DEBUG, USER1, "delta_usec: %-10"PRIu64" delta_pkt: %-10"PRIu64" delta_bit: %-10"PRIu64"\n", delta_usec, delta_pkt, delta_bit);
478 	pd->pps = (uint64_t)(delta_pkt*1e6f/delta_usec);
479 	pd->bps = (uint64_t)(delta_bit*1e6f/delta_usec);
480 	nic_stats_display(pd);
481 	pd->prev_stats = pd->curr_stats;
482 	pd->prev_ts = pd->curr_ts;
483 	return 0;
484 }
485 
486 static int pcap_dpdk_setnonblock(pcap_t *p, int nonblock){
487 	struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
488 	pd->nonblock = nonblock;
489 	return 0;
490 }
491 
492 static int pcap_dpdk_getnonblock(pcap_t *p){
493 	struct pcap_dpdk *pd = (struct pcap_dpdk*)(p->priv);
494 	return pd->nonblock;
495 }
496 static int check_link_status(uint16_t portid, struct rte_eth_link *plink)
497 {
498 	// wait up to 9 seconds to get link status
499 	rte_eth_link_get(portid, plink);
500 	return plink->link_status == ETH_LINK_UP;
501 }
502 static void eth_addr_str(ETHER_ADDR_TYPE *addrp, char* mac_str, int len)
503 {
504 	int offset=0;
505 	if (addrp == NULL){
506 		snprintf(mac_str, len-1, DPDK_DEF_MAC_ADDR);
507 		return;
508 	}
509 	for (int i=0; i<6; i++)
510 	{
511 		if (offset >= len)
512 		{ // buffer overflow
513 			return;
514 		}
515 		if (i==0)
516 		{
517 			snprintf(mac_str+offset, len-1-offset, "%02X",addrp->addr_bytes[i]);
518 			offset+=2; // FF
519 		}else{
520 			snprintf(mac_str+offset, len-1-offset, ":%02X", addrp->addr_bytes[i]);
521 			offset+=3; // :FF
522 		}
523 	}
524 	return;
525 }
526 // return portid by device name, otherwise return -1
527 static uint16_t portid_by_device(char * device)
528 {
529 	uint16_t ret = DPDK_PORTID_MAX;
530 	size_t len = strlen(device);
531 	size_t prefix_len = strlen(DPDK_PREFIX);
532 	unsigned long ret_ul = 0L;
533 	char *pEnd;
534 	if (len<=prefix_len || strncmp(device, DPDK_PREFIX, prefix_len)) // check prefix dpdk:
535 	{
536 		return ret;
537 	}
538 	//check all chars are digital
539 	for (int i=prefix_len; device[i]; i++){
540 		if (device[i]<'0' || device[i]>'9'){
541 			return ret;
542 		}
543 	}
544 	ret_ul = strtoul(&(device[prefix_len]), &pEnd, 10);
545 	if (pEnd == &(device[prefix_len]) || *pEnd != '\0'){
546 		return ret;
547 	}
548 	// too large for portid
549 	if (ret_ul >= DPDK_PORTID_MAX){
550 		return ret;
551 	}
552 	ret = (uint16_t)ret_ul;
553 	return ret;
554 }
555 
556 static int parse_dpdk_cfg(char* dpdk_cfg,char** dargv)
557 {
558 	int cnt=0;
559 	memset(dargv,0,sizeof(dargv[0])*DPDK_ARGC_MAX);
560 	//current process name
561 	int skip_space = 1;
562 	int i=0;
563 	RTE_LOG(INFO, USER1,"dpdk cfg: %s\n",dpdk_cfg);
564 	// find first non space char
565 	// The last opt is NULL
566 	for (i=0;dpdk_cfg[i] && cnt<DPDK_ARGC_MAX-1;i++){
567 		if (skip_space && dpdk_cfg[i]!=' '){ // not space
568 			skip_space=!skip_space; // skip normal char
569 			dargv[cnt++] = dpdk_cfg+i;
570 		}
571 		if (!skip_space && dpdk_cfg[i]==' '){ // find a space
572 			dpdk_cfg[i]=0x00; // end of this opt
573 			skip_space=!skip_space; // skip space char
574 		}
575 	}
576 	dargv[cnt]=NULL;
577 	return cnt;
578 }
579 
580 // only called once
581 // Returns:
582 //
583 //    1 on success;
584 //
585 //    0 if "the EAL cannot initialize on this system", which we treat as
586 //    meaning "DPDK isn't available";
587 //
588 //    a PCAP_ERROR_ code for other errors.
589 //
590 // If eaccess_not_fatal is non-zero, treat "a permissions issue" the way
591 // we treat "the EAL cannot initialize on this system".  We use that
592 // when trying to find DPDK devices, as we don't want to fail to return
593 // *any* devices just because we can't support DPDK; when we're trying
594 // to open a device, we need to return a permissions error in that case.
595 static int dpdk_pre_init(char * ebuf, int eaccess_not_fatal)
596 {
597 	int dargv_cnt=0;
598 	char *dargv[DPDK_ARGC_MAX];
599 	char *ptr_dpdk_cfg = NULL;
600 	int ret;
601 	// global var
602 	if (is_dpdk_pre_inited != 0)
603 	{
604 		// already inited; did that succeed?
605 		if (is_dpdk_pre_inited < 0)
606 		{
607 			// failed
608 			goto error;
609 		}
610 		else
611 		{
612 			// succeeded
613 			return 1;
614 		}
615 	}
616 	// init EAL
617 	ptr_dpdk_cfg = getenv(DPDK_CFG_ENV_NAME);
618 	// set default log level to debug
619 	rte_log_set_global_level(DPDK_DEF_LOG_LEV);
620 	if (ptr_dpdk_cfg == NULL)
621 	{
622 		RTE_LOG(INFO,USER1,"env $DPDK_CFG is unset, so using default: %s\n",DPDK_DEF_CFG);
623 		ptr_dpdk_cfg = DPDK_DEF_CFG;
624 	}
625 	memset(dpdk_cfg_buf,0,sizeof(dpdk_cfg_buf));
626 	snprintf(dpdk_cfg_buf,DPDK_CFG_MAX_LEN-1,"%s %s",DPDK_LIB_NAME,ptr_dpdk_cfg);
627 	dargv_cnt = parse_dpdk_cfg(dpdk_cfg_buf,dargv);
628 	ret = rte_eal_init(dargv_cnt,dargv);
629 	if (ret == -1)
630 	{
631 		// Indicate that we've called rte_eal_init() by setting
632 		// is_dpdk_pre_inited to the negative of the error code,
633 		// and process the error.
634 		is_dpdk_pre_inited = -rte_errno;
635 		goto error;
636 	}
637 	// init succeeded, so we do not need to do it again later.
638 	is_dpdk_pre_inited = 1;
639 	return 1;
640 
641 error:
642 	switch (-is_dpdk_pre_inited)
643 	{
644 		case EACCES:
645 			// This "indicates a permissions issue.".
646 			RTE_LOG(ERR, USER1, "%s\n", DPDK_ERR_PERM_MSG);
647 			// If we were told to treat this as just meaning
648 			// DPDK isn't available, do so.
649 			if (eaccess_not_fatal)
650 				return 0;
651 			// Otherwise report a fatal error.
652 			snprintf(ebuf, PCAP_ERRBUF_SIZE,
653 			    "DPDK requires that it run as root");
654 			return PCAP_ERROR_PERM_DENIED;
655 
656 		case EAGAIN:
657 			// This "indicates either a bus or system
658 			// resource was not available, setup may
659 			// be attempted again."
660 			// There's no such error in pcap, so I'm
661 			// not sure what we should do here.
662 			snprintf(ebuf, PCAP_ERRBUF_SIZE,
663 			    "Bus or system resource was not available");
664 			break;
665 
666 		case EALREADY:
667 			// This "indicates that the rte_eal_init
668 			// function has already been called, and
669 			// cannot be called again."
670 			// That's not an error; set the "we've
671 			// been here before" flag and return
672 			// success.
673 			is_dpdk_pre_inited = 1;
674 			return 1;
675 
676 		case EFAULT:
677 			// This "indicates the tailq configuration
678 			// name was not found in memory configuration."
679 			snprintf(ebuf, PCAP_ERRBUF_SIZE,
680 			    "The tailq configuration name was not found in the memory configuration");
681 			return PCAP_ERROR;
682 
683 		case EINVAL:
684 			// This "indicates invalid parameters were
685 			// passed as argv/argc."  Those came from
686 			// the configuration file.
687 			snprintf(ebuf, PCAP_ERRBUF_SIZE,
688 			    "The configuration file has invalid parameters");
689 			break;
690 
691 		case ENOMEM:
692 			// This "indicates failure likely caused by
693 			// an out-of-memory condition."
694 			snprintf(ebuf, PCAP_ERRBUF_SIZE,
695 			    "Out of memory");
696 			break;
697 
698 		case ENODEV:
699 			// This "indicates memory setup issues."
700 			snprintf(ebuf, PCAP_ERRBUF_SIZE,
701 			    "An error occurred setting up memory");
702 			break;
703 
704 		case ENOTSUP:
705 			// This "indicates that the EAL cannot
706 			// initialize on this system."  We treat
707 			// that as meaning DPDK isn't available
708 			// on this machine, rather than as a
709 			// fatal error, and let our caller decide
710 			// whether that's a fatal error (if trying
711 			// to activate a DPDK device) or not (if
712 			// trying to enumerate devices).
713 			return 0;
714 
715 		case EPROTO:
716 			// This "indicates that the PCI bus is
717 			// either not present, or is not readable
718 			// by the eal."  Does "the PCI bus is not
719 			// present" mean "this machine has no PCI
720 			// bus", which strikes me as a "not available"
721 			// case?  If so, should "is not readable by
722 			// the EAL" also something we should treat
723 			// as a "not available" case?  If not, we
724 			// can't distinguish between the two, so
725 			// we're stuck.
726 			snprintf(ebuf, PCAP_ERRBUF_SIZE,
727 			    "PCI bus is not present or not readable by the EAL");
728 			break;
729 
730 		case ENOEXEC:
731 			// This "indicates that a service core
732 			// failed to launch successfully."
733 			snprintf(ebuf, PCAP_ERRBUF_SIZE,
734 			    "A service core failed to launch successfully");
735 			break;
736 
737 		default:
738 			//
739 			// That's not in the list of errors in
740 			// the documentation; let it be reported
741 			// as an error.
742 			//
743 			dpdk_fmt_errmsg_for_rte_errno(ebuf,
744 			    PCAP_ERRBUF_SIZE, -is_dpdk_pre_inited,
745 			    "dpdk error: dpdk_pre_init failed");
746 			break;
747 	}
748 	// Error.
749 	return PCAP_ERROR;
750 }
751 
752 static int pcap_dpdk_activate(pcap_t *p)
753 {
754 	struct pcap_dpdk *pd = p->priv;
755 	pd->orig = p;
756 	int ret = PCAP_ERROR;
757 	uint16_t nb_ports=0;
758 	uint16_t portid= DPDK_PORTID_MAX;
759 	unsigned nb_mbufs = DPDK_NB_MBUFS;
760 	struct rte_eth_rxconf rxq_conf;
761 	struct rte_eth_txconf txq_conf;
762 	struct rte_eth_conf local_port_conf = port_conf;
763 	struct rte_eth_dev_info dev_info;
764 	int is_port_up = 0;
765 	struct rte_eth_link link;
766 	do{
767 		//init EAL; fail if we have insufficient permission
768 		char dpdk_pre_init_errbuf[PCAP_ERRBUF_SIZE];
769 		ret = dpdk_pre_init(dpdk_pre_init_errbuf, 0);
770 		if (ret < 0)
771 		{
772 			// This returns a negative value on an error.
773 			snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
774 			    "Can't open device %s: %s",
775 			    p->opt.device, dpdk_pre_init_errbuf);
776 			// ret is set to the correct error
777 			break;
778 		}
779 		if (ret == 0)
780 		{
781 			// This means DPDK isn't available on this machine.
782 			snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
783 			    "Can't open device %s: DPDK is not available on this machine",
784 			    p->opt.device);
785 			return PCAP_ERROR_NO_SUCH_DEVICE;
786 		}
787 
788 		ret = dpdk_init_timer(pd);
789 		if (ret<0)
790 		{
791 			snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
792 				"dpdk error: Init timer is zero with device %s",
793 				p->opt.device);
794 			ret = PCAP_ERROR;
795 			break;
796 		}
797 
798 		nb_ports = rte_eth_dev_count_avail();
799 		if (nb_ports == 0)
800 		{
801 			snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
802 			    "dpdk error: No Ethernet ports");
803 			ret = PCAP_ERROR;
804 			break;
805 		}
806 
807 		portid = portid_by_device(p->opt.device);
808 		if (portid == DPDK_PORTID_MAX){
809 			snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
810 			    "dpdk error: portid is invalid. device %s",
811 			    p->opt.device);
812 			ret = PCAP_ERROR_NO_SUCH_DEVICE;
813 			break;
814 		}
815 
816 		pd->portid = portid;
817 
818 		if (p->snapshot <= 0 || p->snapshot > MAXIMUM_SNAPLEN)
819 		{
820 			p->snapshot = MAXIMUM_SNAPLEN;
821 		}
822 		// create the mbuf pool
823 		pd->pktmbuf_pool = rte_pktmbuf_pool_create(MBUF_POOL_NAME, nb_mbufs,
824 			MEMPOOL_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE,
825 			rte_socket_id());
826 		if (pd->pktmbuf_pool == NULL)
827 		{
828 			dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
829 			    PCAP_ERRBUF_SIZE, rte_errno,
830 			    "dpdk error: Cannot init mbuf pool");
831 			ret = PCAP_ERROR;
832 			break;
833 		}
834 		// config dev
835 		rte_eth_dev_info_get(portid, &dev_info);
836 		if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
837 		{
838 			local_port_conf.txmode.offloads |=DEV_TX_OFFLOAD_MBUF_FAST_FREE;
839 		}
840 		// only support 1 queue
841 		ret = rte_eth_dev_configure(portid, 1, 1, &local_port_conf);
842 		if (ret < 0)
843 		{
844 			dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
845 			    PCAP_ERRBUF_SIZE, -ret,
846 			    "dpdk error: Cannot configure device: port=%u",
847 			    portid);
848 			ret = PCAP_ERROR;
849 			break;
850 		}
851 		// adjust rx tx
852 		ret = rte_eth_dev_adjust_nb_rx_tx_desc(portid, &nb_rxd, &nb_txd);
853 		if (ret < 0)
854 		{
855 			dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
856 			    PCAP_ERRBUF_SIZE, -ret,
857 			    "dpdk error: Cannot adjust number of descriptors: port=%u",
858 			    portid);
859 			ret = PCAP_ERROR;
860 			break;
861 		}
862 		// get MAC addr
863 		rte_eth_macaddr_get(portid, &(pd->eth_addr));
864 		eth_addr_str(&(pd->eth_addr), pd->mac_addr, DPDK_MAC_ADDR_SIZE-1);
865 
866 		// init one RX queue
867 		rxq_conf = dev_info.default_rxconf;
868 		rxq_conf.offloads = local_port_conf.rxmode.offloads;
869 		ret = rte_eth_rx_queue_setup(portid, 0, nb_rxd,
870 					     rte_eth_dev_socket_id(portid),
871 					     &rxq_conf,
872 					     pd->pktmbuf_pool);
873 		if (ret < 0)
874 		{
875 			dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
876 			    PCAP_ERRBUF_SIZE, -ret,
877 			    "dpdk error: rte_eth_rx_queue_setup:port=%u",
878 			    portid);
879 			ret = PCAP_ERROR;
880 			break;
881 		}
882 
883 		// init one TX queue
884 		txq_conf = dev_info.default_txconf;
885 		txq_conf.offloads = local_port_conf.txmode.offloads;
886 		ret = rte_eth_tx_queue_setup(portid, 0, nb_txd,
887 				rte_eth_dev_socket_id(portid),
888 				&txq_conf);
889 		if (ret < 0)
890 		{
891 			dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
892 			    PCAP_ERRBUF_SIZE, -ret,
893 			    "dpdk error: rte_eth_tx_queue_setup:port=%u",
894 			    portid);
895 			ret = PCAP_ERROR;
896 			break;
897 		}
898 		// Initialize TX buffers
899 		tx_buffer = rte_zmalloc_socket(DPDK_TX_BUF_NAME,
900 				RTE_ETH_TX_BUFFER_SIZE(MAX_PKT_BURST), 0,
901 				rte_eth_dev_socket_id(portid));
902 		if (tx_buffer == NULL)
903 		{
904 			snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
905 			    "dpdk error: Cannot allocate buffer for tx on port %u", portid);
906 			ret = PCAP_ERROR;
907 			break;
908 		}
909 		rte_eth_tx_buffer_init(tx_buffer, MAX_PKT_BURST);
910 		// Start device
911 		ret = rte_eth_dev_start(portid);
912 		if (ret < 0)
913 		{
914 			dpdk_fmt_errmsg_for_rte_errno(p->errbuf,
915 			    PCAP_ERRBUF_SIZE, -ret,
916 			    "dpdk error: rte_eth_dev_start:port=%u",
917 			    portid);
918 			ret = PCAP_ERROR;
919 			break;
920 		}
921 		// set promiscuous mode
922 		if (p->opt.promisc){
923 			pd->must_clear_promisc=1;
924 			rte_eth_promiscuous_enable(portid);
925 		}
926 		// check link status
927 		is_port_up = check_link_status(portid, &link);
928 		if (!is_port_up){
929 			snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
930 			    "dpdk error: link is down, port=%u",portid);
931 			ret = PCAP_ERROR_IFACE_NOT_UP;
932 			break;
933 		}
934 		// reset statistics
935 		rte_eth_stats_reset(pd->portid);
936 		calculate_timestamp(&(pd->ts_helper), &(pd->prev_ts));
937 		rte_eth_stats_get(pd->portid,&(pd->prev_stats));
938 		// format pcap_t
939 		pd->portid = portid;
940 		p->fd = pd->portid;
941 		if (p->snapshot <=0 || p->snapshot> MAXIMUM_SNAPLEN)
942 		{
943 			p->snapshot = MAXIMUM_SNAPLEN;
944 		}
945 		p->linktype = DLT_EN10MB; // Ethernet, the 10MB is historical.
946 		p->selectable_fd = p->fd;
947 		p->read_op = pcap_dpdk_dispatch;
948 		p->inject_op = pcap_dpdk_inject;
949 		// using pcapint_filter currently, though DPDK provides their own BPF function. Because DPDK BPF needs load a ELF file as a filter.
950 		p->setfilter_op = pcapint_install_bpf_program;
951 		p->setdirection_op = NULL;
952 		p->set_datalink_op = NULL;
953 		p->getnonblock_op = pcap_dpdk_getnonblock;
954 		p->setnonblock_op = pcap_dpdk_setnonblock;
955 		p->stats_op = pcap_dpdk_stats;
956 		p->cleanup_op = pcap_dpdk_close;
957 		p->breakloop_op = pcapint_breakloop_common;
958 		// set default timeout
959 		pd->required_select_timeout.tv_sec = 0;
960 		pd->required_select_timeout.tv_usec = DPDK_DEF_MIN_SLEEP_MS*1000;
961 		p->required_select_timeout = &pd->required_select_timeout;
962 		ret = 0; // OK
963 	}while(0);
964 
965 	if (ret <= PCAP_ERROR) // all kinds of error code
966 	{
967 		pcapint_cleanup_live_common(p);
968 	}else{
969 		rte_eth_dev_get_name_by_port(portid,pd->pci_addr);
970 		RTE_LOG(INFO, USER1,"Port %d device: %s, MAC:%s, PCI:%s\n", portid, p->opt.device, pd->mac_addr, pd->pci_addr);
971 		RTE_LOG(INFO, USER1,"Port %d Link Up. Speed %u Mbps - %s\n",
972 							portid, link.link_speed,
973 					(link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
974 						("full-duplex") : ("half-duplex\n"));
975 	}
976 	return ret;
977 }
978 
979 // device name for dpdk should be in the form as dpdk:number, such as dpdk:0
980 pcap_t * pcap_dpdk_create(const char *device, char *ebuf, int *is_ours)
981 {
982 	pcap_t *p=NULL;
983 	*is_ours = 0;
984 
985 	*is_ours = !strncmp(device, "dpdk:", 5);
986 	if (! *is_ours)
987 		return NULL;
988 	//memset will happen
989 	p = PCAP_CREATE_COMMON(ebuf, struct pcap_dpdk);
990 
991 	if (p == NULL)
992 		return NULL;
993 	p->activate_op = pcap_dpdk_activate;
994 	return p;
995 }
996 
997 int pcap_dpdk_findalldevs(pcap_if_list_t *devlistp, char *ebuf)
998 {
999 	int ret=0;
1000 	unsigned int nb_ports = 0;
1001 	char dpdk_name[DPDK_DEV_NAME_MAX];
1002 	char dpdk_desc[DPDK_DEV_DESC_MAX];
1003 	ETHER_ADDR_TYPE eth_addr;
1004 	char mac_addr[DPDK_MAC_ADDR_SIZE];
1005 	char pci_addr[DPDK_PCI_ADDR_SIZE];
1006 	do{
1007 		// init EAL; return "DPDK not available" if we
1008 		// have insufficient permission
1009 		char dpdk_pre_init_errbuf[PCAP_ERRBUF_SIZE];
1010 		ret = dpdk_pre_init(dpdk_pre_init_errbuf, 1);
1011 		if (ret < 0)
1012 		{
1013 			// This returns a negative value on an error.
1014 			snprintf(ebuf, PCAP_ERRBUF_SIZE,
1015 			    "Can't look for DPDK devices: %s",
1016 			    dpdk_pre_init_errbuf);
1017 			ret = PCAP_ERROR;
1018 			break;
1019 		}
1020 		if (ret == 0)
1021 		{
1022 			// This means DPDK isn't available on this machine.
1023 			// That just means "don't return any devices".
1024 			break;
1025 		}
1026 		nb_ports = rte_eth_dev_count_avail();
1027 		if (nb_ports == 0)
1028 		{
1029 			// That just means "don't return any devices".
1030 			ret = 0;
1031 			break;
1032 		}
1033 		for (unsigned int i=0; i<nb_ports; i++){
1034 			snprintf(dpdk_name, DPDK_DEV_NAME_MAX-1,
1035 			    "%s%u", DPDK_PREFIX, i);
1036 			// mac addr
1037 			rte_eth_macaddr_get(i, &eth_addr);
1038 			eth_addr_str(&eth_addr,mac_addr,DPDK_MAC_ADDR_SIZE);
1039 			// PCI addr
1040 			rte_eth_dev_get_name_by_port(i,pci_addr);
1041 			snprintf(dpdk_desc,DPDK_DEV_DESC_MAX-1,"%s %s, MAC:%s, PCI:%s", DPDK_DESC, dpdk_name, mac_addr, pci_addr);
1042 			if (pcapint_add_dev(devlistp, dpdk_name, 0, dpdk_desc, ebuf)==NULL){
1043 				ret = PCAP_ERROR;
1044 				break;
1045 			}
1046 		}
1047 	}while(0);
1048 	return ret;
1049 }
1050 
1051 #ifdef DPDK_ONLY
1052 /*
1053  * This libpcap build supports only DPDK, not regular network interfaces.
1054  */
1055 
1056 /*
1057  * There are no regular interfaces, just DPDK interfaces.
1058  */
1059 int
1060 pcapint_platform_finddevs(pcap_if_list_t *devlistp _U_, char *errbuf)
1061 {
1062 	return (0);
1063 }
1064 
1065 /*
1066  * Attempts to open a regular interface fail.
1067  */
1068 pcap_t *
1069 pcapint_create_interface(const char *device, char *errbuf)
1070 {
1071 	snprintf(errbuf, PCAP_ERRBUF_SIZE,
1072 	    "This version of libpcap only supports DPDK");
1073 	return NULL;
1074 }
1075 
1076 /*
1077  * Libpcap version string.
1078  */
1079 const char *
1080 pcap_lib_version(void)
1081 {
1082 	return (PCAP_VERSION_STRING " (DPDK-only)");
1083 }
1084 #endif
1085