2 * Copyright (c) 2015 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
15 #include <vnet/vnet.h>
16 #include <vppinfra/vec.h>
17 #include <vppinfra/error.h>
18 #include <vppinfra/format.h>
19 #include <vppinfra/xxhash.h>
21 #include <vnet/ethernet/ethernet.h>
22 #include <vnet/devices/dpdk/dpdk.h>
23 #include <vnet/classify/vnet_classify.h>
24 #include <vnet/mpls/packet.h>
25 #include <vnet/handoff.h>
26 #include <vnet/devices/devices.h>
27 #include <vnet/feature/feature.h>
29 #include "dpdk_priv.h"
31 static char *dpdk_error_strings[] = {
38 vlib_buffer_is_ip4 (vlib_buffer_t * b)
40 ethernet_header_t *h = (ethernet_header_t *) b->data;
41 return (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP4));
45 vlib_buffer_is_ip6 (vlib_buffer_t * b)
47 ethernet_header_t *h = (ethernet_header_t *) b->data;
48 return (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP6));
52 vlib_buffer_is_mpls (vlib_buffer_t * b)
54 ethernet_header_t *h = (ethernet_header_t *) b->data;
55 return (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_MPLS_UNICAST));
58 #if RTE_VERSION < RTE_VERSION_NUM(16, 11, 0, 0)
59 /* New ol_flags bits added in DPDK-16.11 */
60 #define PKT_RX_IP_CKSUM_GOOD (1ULL << 7)
64 dpdk_rx_next_from_etype (struct rte_mbuf * mb, vlib_buffer_t * b0)
66 if (PREDICT_TRUE (vlib_buffer_is_ip4 (b0)))
67 if (PREDICT_TRUE ((mb->ol_flags & PKT_RX_IP_CKSUM_GOOD) != 0))
68 return VNET_DEVICE_INPUT_NEXT_IP4_NCS_INPUT;
70 return VNET_DEVICE_INPUT_NEXT_IP4_INPUT;
71 else if (PREDICT_TRUE (vlib_buffer_is_ip6 (b0)))
72 return VNET_DEVICE_INPUT_NEXT_IP6_INPUT;
73 else if (PREDICT_TRUE (vlib_buffer_is_mpls (b0)))
74 return VNET_DEVICE_INPUT_NEXT_MPLS_INPUT;
76 return VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
80 dpdk_mbuf_is_vlan (struct rte_mbuf *mb)
82 #if RTE_VERSION >= RTE_VERSION_NUM(16, 11, 0, 0)
83 return (mb->packet_type & RTE_PTYPE_L2_ETHER_VLAN) ==
84 RTE_PTYPE_L2_ETHER_VLAN;
88 (PKT_RX_VLAN_PKT | PKT_RX_VLAN_STRIPPED | PKT_RX_QINQ_STRIPPED)) ==
94 dpdk_mbuf_is_ip4 (struct rte_mbuf *mb)
96 return RTE_ETH_IS_IPV4_HDR (mb->packet_type) != 0;
100 dpdk_mbuf_is_ip6 (struct rte_mbuf *mb)
102 return RTE_ETH_IS_IPV6_HDR (mb->packet_type) != 0;
106 dpdk_rx_next_from_mb (struct rte_mbuf * mb, vlib_buffer_t * b0)
108 if (PREDICT_FALSE (dpdk_mbuf_is_vlan (mb)))
109 return VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
110 else if (PREDICT_TRUE (dpdk_mbuf_is_ip4 (mb)))
111 return VNET_DEVICE_INPUT_NEXT_IP4_NCS_INPUT;
112 else if (PREDICT_TRUE (dpdk_mbuf_is_ip6 (mb)))
113 return VNET_DEVICE_INPUT_NEXT_IP6_INPUT;
114 else if (PREDICT_TRUE (vlib_buffer_is_mpls (b0)))
115 return VNET_DEVICE_INPUT_NEXT_MPLS_INPUT;
117 return dpdk_rx_next_from_etype (mb, b0);
121 dpdk_rx_error_from_mb (struct rte_mbuf *mb, u32 * next, u8 * error)
123 if (mb->ol_flags & PKT_RX_IP_CKSUM_BAD)
125 *error = DPDK_ERROR_IP_CHECKSUM_ERROR;
126 *next = VNET_DEVICE_INPUT_NEXT_DROP;
129 *error = DPDK_ERROR_NONE;
133 dpdk_rx_trace (dpdk_main_t * dm,
134 vlib_node_runtime_t * node,
136 u16 queue_id, u32 * buffers, uword n_buffers)
138 vlib_main_t *vm = vlib_get_main ();
149 dpdk_rx_dma_trace_t *t0;
156 b0 = vlib_get_buffer (vm, bi0);
157 mb = rte_mbuf_from_vlib_buffer (b0);
159 if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
160 next0 = xd->per_interface_next_index;
161 else if (PREDICT_TRUE
162 ((xd->flags & DPDK_DEVICE_FLAG_PMD_SUPPORTS_PTYPE) != 0))
163 next0 = dpdk_rx_next_from_mb (mb, b0);
165 next0 = dpdk_rx_next_from_etype (mb, b0);
167 dpdk_rx_error_from_mb (mb, &next0, &error0);
169 vlib_trace_buffer (vm, node, next0, b0, /* follow_chain */ 0);
170 t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
171 t0->queue_index = queue_id;
172 t0->device_index = xd->device_index;
173 t0->buffer_index = bi0;
175 clib_memcpy (&t0->mb, mb, sizeof (t0->mb));
176 clib_memcpy (&t0->buffer, b0, sizeof (b0[0]) - sizeof (b0->pre_data));
177 clib_memcpy (t0->buffer.pre_data, b0->data,
178 sizeof (t0->buffer.pre_data));
179 clib_memcpy (&t0->data, mb->buf_addr + mb->data_off, sizeof (t0->data));
186 dpdk_rx_burst (dpdk_main_t * dm, dpdk_device_t * xd, u16 queue_id)
192 n_left = VLIB_FRAME_SIZE;
195 if (PREDICT_TRUE (xd->flags & DPDK_DEVICE_FLAG_PMD))
199 n_this_chunk = rte_eth_rx_burst (xd->device_index, queue_id,
200 xd->rx_vectors[queue_id] +
202 n_buffers += n_this_chunk;
203 n_left -= n_this_chunk;
205 /* Empirically, DPDK r1.8 produces vectors w/ 32 or fewer elts */
206 if (n_this_chunk < 32)
219 static_always_inline void
220 dpdk_process_subseq_segs (vlib_main_t * vm, vlib_buffer_t * b,
221 struct rte_mbuf *mb, vlib_buffer_free_list_t * fl)
224 struct rte_mbuf *mb_seg = 0;
225 vlib_buffer_t *b_seg, *b_chain = 0;
229 while ((mb->nb_segs > 1) && (nb_seg < mb->nb_segs))
231 ASSERT (mb_seg != 0);
233 b_seg = vlib_buffer_from_rte_mbuf (mb_seg);
234 vlib_buffer_init_for_free_list (b_seg, fl);
236 ASSERT ((b_seg->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
237 ASSERT (b_seg->current_data == 0);
240 * The driver (e.g. virtio) may not put the packet data at the start
241 * of the segment, so don't assume b_seg->current_data == 0 is correct.
243 b_seg->current_data =
244 (mb_seg->buf_addr + mb_seg->data_off) - (void *) b_seg->data;
246 b_seg->current_length = mb_seg->data_len;
247 b->total_length_not_including_first_buffer += mb_seg->data_len;
249 b_chain->flags |= VLIB_BUFFER_NEXT_PRESENT;
250 b_chain->next_buffer = vlib_get_buffer_index (vm, b_seg);
253 mb_seg = mb_seg->next;
258 static_always_inline void
259 dpdk_prefetch_buffer (struct rte_mbuf *mb)
261 vlib_buffer_t *b = vlib_buffer_from_rte_mbuf (mb);
262 CLIB_PREFETCH (mb, CLIB_CACHE_LINE_BYTES, LOAD);
263 CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, STORE);
267 * This function is used when there are no worker threads.
268 * The main thread performs IO and forwards the packets.
270 static_always_inline u32
271 dpdk_device_input (dpdk_main_t * dm, dpdk_device_t * xd,
272 vlib_node_runtime_t * node, u32 cpu_index, u16 queue_id)
275 u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
276 u32 n_left_to_next, *to_next;
278 vlib_main_t *vm = vlib_get_main ();
279 uword n_rx_bytes = 0;
280 u32 n_trace, trace_cnt __attribute__ ((unused));
281 vlib_buffer_free_list_t *fl;
282 u32 buffer_flags_template;
284 if ((xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP) == 0)
287 n_buffers = dpdk_rx_burst (dm, xd, queue_id);
294 buffer_flags_template = dm->buffer_flags_template;
296 vec_reset_length (xd->d_trace_buffers[cpu_index]);
297 trace_cnt = n_trace = vlib_get_trace_count (vm, node);
301 u32 n = clib_min (n_trace, n_buffers);
306 struct rte_mbuf *mb = xd->rx_vectors[queue_id][mb_index++];
307 vlib_buffer_t *b = vlib_buffer_from_rte_mbuf (mb);
308 vec_add1 (xd->d_trace_buffers[cpu_index],
309 vlib_get_buffer_index (vm, b));
313 fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
317 while (n_buffers > 0)
319 vlib_buffer_t *b0, *b1, *b2, *b3;
320 u32 bi0, next0, l3_offset0;
321 u32 bi1, next1, l3_offset1;
322 u32 bi2, next2, l3_offset2;
323 u32 bi3, next3, l3_offset3;
324 u8 error0, error1, error2, error3;
327 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
329 while (n_buffers > 8 && n_left_to_next > 4)
331 struct rte_mbuf *mb0 = xd->rx_vectors[queue_id][mb_index];
332 struct rte_mbuf *mb1 = xd->rx_vectors[queue_id][mb_index + 1];
333 struct rte_mbuf *mb2 = xd->rx_vectors[queue_id][mb_index + 2];
334 struct rte_mbuf *mb3 = xd->rx_vectors[queue_id][mb_index + 3];
336 dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 4]);
337 dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 5]);
338 dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 6]);
339 dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 7]);
341 if (xd->flags & DPDK_DEVICE_FLAG_MAYBE_MULTISEG)
343 if (PREDICT_FALSE (mb0->nb_segs > 1))
344 dpdk_prefetch_buffer (mb0->next);
345 if (PREDICT_FALSE (mb1->nb_segs > 1))
346 dpdk_prefetch_buffer (mb1->next);
347 if (PREDICT_FALSE (mb2->nb_segs > 1))
348 dpdk_prefetch_buffer (mb2->next);
349 if (PREDICT_FALSE (mb3->nb_segs > 1))
350 dpdk_prefetch_buffer (mb3->next);
358 or_ol_flags = (mb0->ol_flags | mb1->ol_flags |
359 mb2->ol_flags | mb3->ol_flags);
360 b0 = vlib_buffer_from_rte_mbuf (mb0);
361 b1 = vlib_buffer_from_rte_mbuf (mb1);
362 b2 = vlib_buffer_from_rte_mbuf (mb2);
363 b3 = vlib_buffer_from_rte_mbuf (mb3);
365 vlib_buffer_init_for_free_list (b0, fl);
366 vlib_buffer_init_for_free_list (b1, fl);
367 vlib_buffer_init_for_free_list (b2, fl);
368 vlib_buffer_init_for_free_list (b3, fl);
370 bi0 = vlib_get_buffer_index (vm, b0);
371 bi1 = vlib_get_buffer_index (vm, b1);
372 bi2 = vlib_get_buffer_index (vm, b2);
373 bi3 = vlib_get_buffer_index (vm, b3);
382 if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
384 next0 = next1 = next2 = next3 = xd->per_interface_next_index;
386 else if (PREDICT_TRUE
387 ((xd->flags & DPDK_DEVICE_FLAG_PMD_SUPPORTS_PTYPE) != 0))
389 next0 = dpdk_rx_next_from_mb (mb0, b0);
390 next1 = dpdk_rx_next_from_mb (mb1, b1);
391 next2 = dpdk_rx_next_from_mb (mb2, b2);
392 next3 = dpdk_rx_next_from_mb (mb3, b3);
396 next0 = dpdk_rx_next_from_etype (mb0, b0);
397 next1 = dpdk_rx_next_from_etype (mb1, b1);
398 next2 = dpdk_rx_next_from_etype (mb2, b2);
399 next3 = dpdk_rx_next_from_etype (mb3, b3);
402 if (PREDICT_FALSE (or_ol_flags & PKT_RX_IP_CKSUM_BAD))
404 dpdk_rx_error_from_mb (mb0, &next0, &error0);
405 dpdk_rx_error_from_mb (mb1, &next1, &error1);
406 dpdk_rx_error_from_mb (mb2, &next2, &error2);
407 dpdk_rx_error_from_mb (mb3, &next3, &error3);
408 b0->error = node->errors[error0];
409 b1->error = node->errors[error1];
410 b2->error = node->errors[error2];
411 b3->error = node->errors[error3];
415 b0->error = b1->error = node->errors[DPDK_ERROR_NONE];
416 b2->error = b3->error = node->errors[DPDK_ERROR_NONE];
419 l3_offset0 = device_input_next_node_advance[next0];
420 l3_offset1 = device_input_next_node_advance[next1];
421 l3_offset2 = device_input_next_node_advance[next2];
422 l3_offset3 = device_input_next_node_advance[next3];
424 b0->current_data = l3_offset0 + mb0->data_off;
425 b1->current_data = l3_offset1 + mb1->data_off;
426 b2->current_data = l3_offset2 + mb2->data_off;
427 b3->current_data = l3_offset3 + mb3->data_off;
429 b0->current_data -= RTE_PKTMBUF_HEADROOM;
430 b1->current_data -= RTE_PKTMBUF_HEADROOM;
431 b2->current_data -= RTE_PKTMBUF_HEADROOM;
432 b3->current_data -= RTE_PKTMBUF_HEADROOM;
434 b0->current_length = mb0->data_len - l3_offset0;
435 b1->current_length = mb1->data_len - l3_offset1;
436 b2->current_length = mb2->data_len - l3_offset2;
437 b3->current_length = mb3->data_len - l3_offset3;
439 b0->flags = buffer_flags_template;
440 b1->flags = buffer_flags_template;
441 b2->flags = buffer_flags_template;
442 b3->flags = buffer_flags_template;
444 vnet_buffer (b0)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
445 vnet_buffer (b1)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
446 vnet_buffer (b2)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
447 vnet_buffer (b3)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
449 vnet_buffer (b0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
450 vnet_buffer (b1)->sw_if_index[VLIB_TX] = (u32) ~ 0;
451 vnet_buffer (b2)->sw_if_index[VLIB_TX] = (u32) ~ 0;
452 vnet_buffer (b3)->sw_if_index[VLIB_TX] = (u32) ~ 0;
454 n_rx_bytes += mb0->pkt_len;
455 n_rx_bytes += mb1->pkt_len;
456 n_rx_bytes += mb2->pkt_len;
457 n_rx_bytes += mb3->pkt_len;
459 /* Process subsequent segments of multi-segment packets */
460 if (xd->flags & DPDK_DEVICE_FLAG_MAYBE_MULTISEG)
462 dpdk_process_subseq_segs (vm, b0, mb0, fl);
463 dpdk_process_subseq_segs (vm, b1, mb1, fl);
464 dpdk_process_subseq_segs (vm, b2, mb2, fl);
465 dpdk_process_subseq_segs (vm, b3, mb3, fl);
469 * Turn this on if you run into
470 * "bad monkey" contexts, and you want to know exactly
471 * which nodes they've visited... See main.c...
473 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
474 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b1);
475 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b2);
476 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b3);
478 /* Do we have any driver RX features configured on the interface? */
479 vnet_feature_start_device_input_x4 (xd->vlib_sw_if_index,
480 &next0, &next1, &next2, &next3,
482 l3_offset0, l3_offset1,
483 l3_offset2, l3_offset3);
485 vlib_validate_buffer_enqueue_x4 (vm, node, next_index,
486 to_next, n_left_to_next,
488 next0, next1, next2, next3);
492 while (n_buffers > 0 && n_left_to_next > 0)
494 struct rte_mbuf *mb0 = xd->rx_vectors[queue_id][mb_index];
498 b0 = vlib_buffer_from_rte_mbuf (mb0);
500 /* Prefetch one next segment if it exists. */
501 if (PREDICT_FALSE (mb0->nb_segs > 1))
502 dpdk_prefetch_buffer (mb0->next);
504 vlib_buffer_init_for_free_list (b0, fl);
506 bi0 = vlib_get_buffer_index (vm, b0);
512 if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
513 next0 = xd->per_interface_next_index;
514 else if (PREDICT_TRUE
515 ((xd->flags & DPDK_DEVICE_FLAG_PMD_SUPPORTS_PTYPE) != 0))
516 next0 = dpdk_rx_next_from_mb (mb0, b0);
518 next0 = dpdk_rx_next_from_etype (mb0, b0);
520 dpdk_rx_error_from_mb (mb0, &next0, &error0);
521 b0->error = node->errors[error0];
523 l3_offset0 = device_input_next_node_advance[next0];
525 b0->current_data = l3_offset0;
526 b0->current_data += mb0->data_off - RTE_PKTMBUF_HEADROOM;
527 b0->current_length = mb0->data_len - l3_offset0;
529 b0->flags = buffer_flags_template;
531 vnet_buffer (b0)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
532 vnet_buffer (b0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
533 n_rx_bytes += mb0->pkt_len;
535 /* Process subsequent segments of multi-segment packets */
536 dpdk_process_subseq_segs (vm, b0, mb0, fl);
539 * Turn this on if you run into
540 * "bad monkey" contexts, and you want to know exactly
541 * which nodes they've visited... See main.c...
543 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
545 /* Do we have any driver RX features configured on the interface? */
546 vnet_feature_start_device_input_x1 (xd->vlib_sw_if_index, &next0,
549 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
550 to_next, n_left_to_next,
555 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
558 if (PREDICT_FALSE (vec_len (xd->d_trace_buffers[cpu_index]) > 0))
560 dpdk_rx_trace (dm, node, xd, queue_id, xd->d_trace_buffers[cpu_index],
561 vec_len (xd->d_trace_buffers[cpu_index]));
562 vlib_set_trace_count (vm, node, n_trace -
563 vec_len (xd->d_trace_buffers[cpu_index]));
566 vlib_increment_combined_counter
567 (vnet_get_main ()->interface_main.combined_sw_if_counters
568 + VNET_INTERFACE_COUNTER_RX,
569 cpu_index, xd->vlib_sw_if_index, mb_index, n_rx_bytes);
571 dpdk_worker_t *dw = vec_elt_at_index (dm->workers, cpu_index);
572 dw->aggregate_rx_packets += mb_index;
578 poll_rate_limit (dpdk_main_t * dm)
580 /* Limit the poll rate by sleeping for N msec between polls */
581 if (PREDICT_FALSE (dm->poll_sleep != 0))
583 struct timespec ts, tsrem;
586 ts.tv_nsec = 1000 * 1000 * dm->poll_sleep; /* 1ms */
588 while (nanosleep (&ts, &tsrem) < 0)
595 /** \brief Main DPDK input node
598 This is the main DPDK input node: across each assigned interface,
599 call rte_eth_rx_burst(...) or similar to obtain a vector of
600 packets to process. Handle early packet discard. Derive @c
601 vlib_buffer_t metadata from <code>struct rte_mbuf</code> metadata,
602 Depending on the resulting metadata: adjust <code>b->current_data,
603 b->current_length </code> and dispatch directly to
604 ip4-input-no-checksum, or ip6-input. Trace the packet if required.
606 @param vm vlib_main_t corresponding to the current thread
607 @param node vlib_node_runtime_t
608 @param f vlib_frame_t input-node, not used.
610 @par Graph mechanics: buffer metadata, next index usage
613 - <code>struct rte_mbuf mb->ol_flags</code>
614 - PKT_RX_IP_CKSUM_BAD
615 - <code> RTE_ETH_IS_xxx_HDR(mb->packet_type) </code>
616 - packet classification result
619 - <code>b->error</code> if the packet is to be dropped immediately
620 - <code>b->current_data, b->current_length</code>
621 - adjusted as needed to skip the L2 header in direct-dispatch cases
622 - <code>vnet_buffer(b)->sw_if_index[VLIB_RX]</code>
623 - rx interface sw_if_index
624 - <code>vnet_buffer(b)->sw_if_index[VLIB_TX] = ~0</code>
625 - required by ipX-lookup
626 - <code>b->flags</code>
627 - to indicate multi-segment pkts (VLIB_BUFFER_NEXT_PRESENT), etc.
630 - Static arcs to: error-drop, ethernet-input,
631 ip4-input-no-checksum, ip6-input, mpls-input
632 - per-interface redirection, controlled by
633 <code>xd->per_interface_next_index</code>
637 dpdk_input (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * f)
639 dpdk_main_t *dm = &dpdk_main;
641 uword n_rx_packets = 0;
642 dpdk_device_and_queue_t *dq;
643 u32 cpu_index = os_get_cpu_number ();
646 * Poll all devices on this cpu for input/interrupts.
649 vec_foreach (dq, dm->devices_by_cpu[cpu_index])
651 xd = vec_elt_at_index(dm->devices, dq->device);
652 n_rx_packets += dpdk_device_input (dm, xd, node, cpu_index, dq->queue_id);
656 poll_rate_limit (dm);
662 VLIB_REGISTER_NODE (dpdk_input_node) = {
663 .function = dpdk_input,
664 .type = VLIB_NODE_TYPE_INPUT,
665 .name = "dpdk-input",
666 .sibling_of = "device-input",
668 /* Will be enabled if/when hardware is detected. */
669 .state = VLIB_NODE_STATE_DISABLED,
671 .format_buffer = format_ethernet_header_with_length,
672 .format_trace = format_dpdk_rx_dma_trace,
674 .n_errors = DPDK_N_ERROR,
675 .error_strings = dpdk_error_strings,
678 VLIB_NODE_FUNCTION_MULTIARCH (dpdk_input_node, dpdk_input);
682 * fd.io coding-style-patch-verification: ON
685 * eval: (c-set-style "gnu")