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-gre/packet.h>
26 #include "dpdk_priv.h"
29 #define MAX(a,b) ((a) < (b) ? (b) : (a))
33 #define MIN(a,b) ((a) < (b) ? (a) : (b))
37 * At least in certain versions of ESXi, vmware e1000's don't honor the
38 * "strip rx CRC" bit. Set this flag to work around that bug FOR UNIT TEST ONLY.
40 * If wireshark complains like so:
42 * "Frame check sequence: 0x00000000 [incorrect, should be <hex-num>]"
43 * and you're using ESXi emulated e1000's, set this flag FOR UNIT TEST ONLY.
45 * Note: do NOT check in this file with this workaround enabled! You'll lose
46 * actual data from e.g. 10xGE interfaces. The extra 4 bytes annoy
47 * wireshark, but they're harmless...
49 #define VMWARE_LENGTH_BUG_WORKAROUND 0
52 u32 cached_next_index;
54 /* convenience variables */
55 vlib_main_t * vlib_main;
56 vnet_main_t * vnet_main;
57 } handoff_dispatch_main_t;
63 } handoff_dispatch_trace_t;
65 /* packet trace format function */
66 static u8 * format_handoff_dispatch_trace (u8 * s, va_list * args)
68 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
69 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
70 handoff_dispatch_trace_t * t = va_arg (*args, handoff_dispatch_trace_t *);
72 s = format (s, "HANDOFF_DISPATCH: sw_if_index %d next_index %d buffer 0x%x",
79 handoff_dispatch_main_t handoff_dispatch_main;
81 vlib_node_registration_t handoff_dispatch_node;
83 #define foreach_handoff_dispatch_error \
84 _(EXAMPLE, "example packets")
87 #define _(sym,str) HANDOFF_DISPATCH_ERROR_##sym,
88 foreach_handoff_dispatch_error
90 HANDOFF_DISPATCH_N_ERROR,
91 } handoff_dispatch_error_t;
93 static char * handoff_dispatch_error_strings[] = {
94 #define _(sym,string) string,
95 foreach_handoff_dispatch_error
100 void vlib_put_handoff_queue_elt (vlib_frame_queue_elt_t * hf)
102 CLIB_MEMORY_BARRIER();
107 handoff_dispatch_node_fn (vlib_main_t * vm,
108 vlib_node_runtime_t * node,
109 vlib_frame_t * frame)
111 u32 n_left_from, * from, * to_next;
112 dpdk_rx_next_t next_index;
114 from = vlib_frame_vector_args (frame);
115 n_left_from = frame->n_vectors;
116 next_index = node->cached_next_index;
118 while (n_left_from > 0)
122 vlib_get_next_frame (vm, node, next_index,
123 to_next, n_left_to_next);
125 while (n_left_from >= 4 && n_left_to_next >= 2)
128 vlib_buffer_t * b0, * b1;
130 u32 sw_if_index0, sw_if_index1;
132 /* Prefetch next iteration. */
134 vlib_buffer_t * p2, * p3;
136 p2 = vlib_get_buffer (vm, from[2]);
137 p3 = vlib_get_buffer (vm, from[3]);
139 vlib_prefetch_buffer_header (p2, LOAD);
140 vlib_prefetch_buffer_header (p3, LOAD);
143 /* speculatively enqueue b0 and b1 to the current next frame */
144 to_next[0] = bi0 = from[0];
145 to_next[1] = bi1 = from[1];
151 b0 = vlib_get_buffer (vm, bi0);
152 b1 = vlib_get_buffer (vm, bi1);
154 next0 = vnet_buffer(b0)->io_handoff.next_index;
155 next1 = vnet_buffer(b1)->io_handoff.next_index;
157 if (PREDICT_FALSE(vm->trace_main.trace_active_hint))
159 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
161 vlib_trace_buffer (vm, node, next0, b0, /* follow_chain */ 0);
162 handoff_dispatch_trace_t *t =
163 vlib_add_trace (vm, node, b0, sizeof (*t));
164 sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
165 t->sw_if_index = sw_if_index0;
166 t->next_index = next0;
167 t->buffer_index = bi0;
169 if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
171 vlib_trace_buffer (vm, node, next1, b1, /* follow_chain */ 0);
172 handoff_dispatch_trace_t *t =
173 vlib_add_trace (vm, node, b1, sizeof (*t));
174 sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX];
175 t->sw_if_index = sw_if_index1;
176 t->next_index = next1;
177 t->buffer_index = bi1;
181 /* verify speculative enqueues, maybe switch current next frame */
182 vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
183 to_next, n_left_to_next,
184 bi0, bi1, next0, next1);
187 while (n_left_from > 0 && n_left_to_next > 0)
194 /* speculatively enqueue b0 to the current next frame */
202 b0 = vlib_get_buffer (vm, bi0);
204 next0 = vnet_buffer(b0)->io_handoff.next_index;
206 if (PREDICT_FALSE(vm->trace_main.trace_active_hint))
208 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
210 vlib_trace_buffer (vm, node, next0, b0, /* follow_chain */ 0);
211 handoff_dispatch_trace_t *t =
212 vlib_add_trace (vm, node, b0, sizeof (*t));
213 sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
214 t->sw_if_index = sw_if_index0;
215 t->next_index = next0;
216 t->buffer_index = bi0;
220 /* verify speculative enqueue, maybe switch current next frame */
221 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
222 to_next, n_left_to_next,
226 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
229 return frame->n_vectors;
232 VLIB_REGISTER_NODE (handoff_dispatch_node) = {
233 .function = handoff_dispatch_node_fn,
234 .name = "handoff-dispatch",
235 .vector_size = sizeof (u32),
236 .format_trace = format_handoff_dispatch_trace,
237 .type = VLIB_NODE_TYPE_INTERNAL,
238 .flags = VLIB_NODE_FLAG_IS_HANDOFF,
240 .n_errors = ARRAY_LEN(handoff_dispatch_error_strings),
241 .error_strings = handoff_dispatch_error_strings,
243 .n_next_nodes = DPDK_RX_N_NEXT,
246 [DPDK_RX_NEXT_DROP] = "error-drop",
247 [DPDK_RX_NEXT_ETHERNET_INPUT] = "ethernet-input",
248 [DPDK_RX_NEXT_IP4_INPUT] = "ip4-input",
249 [DPDK_RX_NEXT_IP6_INPUT] = "ip6-input",
250 [DPDK_RX_NEXT_MPLS_INPUT] = "mpls-gre-input",
254 VLIB_NODE_FUNCTION_MULTIARCH (handoff_dispatch_node, handoff_dispatch_node_fn)
256 clib_error_t *handoff_dispatch_init (vlib_main_t *vm)
258 handoff_dispatch_main_t * mp = &handoff_dispatch_main;
261 mp->vnet_main = &vnet_main;
266 VLIB_INIT_FUNCTION (handoff_dispatch_init);
268 u32 dpdk_get_handoff_node_index (void)
270 return handoff_dispatch_node.index;
273 static char * dpdk_error_strings[] = {
280 dpdk_rx_next_and_error_from_mb_flags_x1 (dpdk_device_t *xd, struct rte_mbuf *mb,
282 u8 * next0, u8 * error0)
284 u8 is0_ip4, is0_ip6, is0_mpls, n0;
285 uint16_t mb_flags = mb->ol_flags;
287 if (PREDICT_FALSE(mb_flags & (
288 #ifdef RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS
289 PKT_EXT_RX_PKT_ERROR | PKT_EXT_RX_BAD_FCS |
290 #endif /* RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS */
291 PKT_RX_IP_CKSUM_BAD | PKT_RX_L4_CKSUM_BAD
294 /* some error was flagged. determine the drop reason */
295 n0 = DPDK_RX_NEXT_DROP;
297 #ifdef RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS
298 (mb_flags & PKT_EXT_RX_PKT_ERROR) ? DPDK_ERROR_RX_PACKET_ERROR :
299 (mb_flags & PKT_EXT_RX_BAD_FCS) ? DPDK_ERROR_RX_BAD_FCS :
300 #endif /* RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS */
301 (mb_flags & PKT_RX_IP_CKSUM_BAD) ? DPDK_ERROR_IP_CHECKSUM_ERROR :
302 (mb_flags & PKT_RX_L4_CKSUM_BAD) ? DPDK_ERROR_L4_CHECKSUM_ERROR :
307 *error0 = DPDK_ERROR_NONE;
308 if (xd->per_interface_next_index != ~0)
309 n0 = xd->per_interface_next_index;
310 else if (mb_flags & PKT_RX_VLAN_PKT)
311 n0 = DPDK_RX_NEXT_ETHERNET_INPUT;
314 n0 = DPDK_RX_NEXT_ETHERNET_INPUT;
315 #if RTE_VERSION >= RTE_VERSION_NUM(2, 1, 0, 0)
316 is0_ip4 = RTE_ETH_IS_IPV4_HDR(mb->packet_type) != 0;
318 is0_ip4 = (mb_flags & (PKT_RX_IPV4_HDR | PKT_RX_IPV4_HDR_EXT)) != 0;
321 if (PREDICT_TRUE(is0_ip4))
322 n0 = DPDK_RX_NEXT_IP4_INPUT;
325 #if RTE_VERSION >= RTE_VERSION_NUM(2, 1, 0, 0)
326 is0_ip6 = RTE_ETH_IS_IPV6_HDR(mb->packet_type) != 0;
329 (mb_flags & (PKT_RX_IPV6_HDR | PKT_RX_IPV6_HDR_EXT)) != 0;
331 if (PREDICT_TRUE(is0_ip6))
332 n0 = DPDK_RX_NEXT_IP6_INPUT;
335 ethernet_header_t *h0 = (ethernet_header_t *) b0->data;
336 is0_mpls = (h0->type == clib_host_to_net_u16(ETHERNET_TYPE_MPLS_UNICAST));
337 n0 = is0_mpls ? DPDK_RX_NEXT_MPLS_INPUT : n0;
345 void dpdk_rx_trace (dpdk_main_t * dm,
346 vlib_node_runtime_t * node,
352 vlib_main_t * vm = vlib_get_main();
363 dpdk_rx_dma_trace_t * t0;
370 b0 = vlib_get_buffer (vm, bi0);
371 mb = rte_mbuf_from_vlib_buffer(b0);
372 dpdk_rx_next_and_error_from_mb_flags_x1 (xd, mb, b0,
374 vlib_trace_buffer (vm, node, next0, b0, /* follow_chain */ 0);
375 t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
376 t0->queue_index = queue_id;
377 t0->device_index = xd->device_index;
378 t0->buffer_index = bi0;
380 clib_memcpy (&t0->mb, mb, sizeof (t0->mb));
381 clib_memcpy (&t0->buffer, b0, sizeof (b0[0]) - sizeof (b0->pre_data));
382 clib_memcpy (t0->buffer.pre_data, b0->data, sizeof (t0->buffer.pre_data));
384 #ifdef RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS
386 * Clear overloaded TX offload flags when a DPDK driver
387 * is using them for RX flags (e.g. Cisco VIC Ethernet driver)
389 mb->ol_flags &= PKT_EXT_RX_CLR_TX_FLAGS_MASK;
390 #endif /* RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS */
397 * dpdk_efd_update_counters()
398 * Update EFD (early-fast-discard) counters
400 void dpdk_efd_update_counters (dpdk_device_t *xd,
404 if (enabled & DPDK_EFD_MONITOR_ENABLED)
406 u64 now = clib_cpu_time_now();
407 if (xd->efd_agent.last_poll_time > 0)
409 u64 elapsed_time = (now - xd->efd_agent.last_poll_time);
410 if (elapsed_time > xd->efd_agent.max_poll_delay)
411 xd->efd_agent.max_poll_delay = elapsed_time;
413 xd->efd_agent.last_poll_time = now;
416 xd->efd_agent.total_packet_cnt += n_buffers;
417 xd->efd_agent.last_burst_sz = n_buffers;
419 if (n_buffers > xd->efd_agent.max_burst_sz)
420 xd->efd_agent.max_burst_sz = n_buffers;
422 if (PREDICT_FALSE(n_buffers == VLIB_FRAME_SIZE))
424 xd->efd_agent.full_frames_cnt++;
425 xd->efd_agent.consec_full_frames_cnt++;
429 xd->efd_agent.consec_full_frames_cnt = 0;
433 /* is_efd_discardable()
434 * returns non zero DPDK error if packet meets early-fast-discard criteria,
437 u32 is_efd_discardable (vlib_thread_main_t *tm,
441 ethernet_header_t *eh = (ethernet_header_t *) b0->data;
443 if (eh->type == clib_host_to_net_u16(ETHERNET_TYPE_IP4))
446 (ip4_header_t *)&(b0->data[sizeof(ethernet_header_t)]);
447 u8 pkt_prec = (ipv4->tos >> 5);
449 return (tm->efd.ip_prec_bitmap & (1 << pkt_prec) ?
450 DPDK_ERROR_IPV4_EFD_DROP_PKTS : DPDK_ERROR_NONE);
452 else if (eh->type == clib_net_to_host_u16(ETHERNET_TYPE_IP6))
455 (ip6_header_t *)&(b0->data[sizeof(ethernet_header_t)]);
457 ((ipv6->ip_version_traffic_class_and_flow_label >> 20) & 0xff);
459 return (tm->efd.ip_prec_bitmap & (1 << pkt_tclass) ?
460 DPDK_ERROR_IPV6_EFD_DROP_PKTS : DPDK_ERROR_NONE);
462 else if (eh->type == clib_net_to_host_u16(ETHERNET_TYPE_MPLS_UNICAST))
464 mpls_unicast_header_t *mpls =
465 (mpls_unicast_header_t *)&(b0->data[sizeof(ethernet_header_t)]);
466 u8 pkt_exp = ((mpls->label_exp_s_ttl >> 9) & 0x07);
468 return (tm->efd.mpls_exp_bitmap & (1 << pkt_exp) ?
469 DPDK_ERROR_MPLS_EFD_DROP_PKTS : DPDK_ERROR_NONE);
471 else if ((eh->type == clib_net_to_host_u16(ETHERNET_TYPE_VLAN)) ||
472 (eh->type == clib_net_to_host_u16(ETHERNET_TYPE_DOT1AD)))
474 ethernet_vlan_header_t *vlan =
475 (ethernet_vlan_header_t *)&(b0->data[sizeof(ethernet_header_t)]);
476 u8 pkt_cos = ((vlan->priority_cfi_and_id >> 13) & 0x07);
478 return (tm->efd.vlan_cos_bitmap & (1 << pkt_cos) ?
479 DPDK_ERROR_VLAN_EFD_DROP_PKTS : DPDK_ERROR_NONE);
482 return DPDK_ERROR_NONE;
486 * This function is used when there are no worker threads.
487 * The main thread performs IO and forwards the packets.
489 static inline u32 dpdk_device_input ( dpdk_main_t * dm,
491 vlib_node_runtime_t * node,
497 u32 next_index = DPDK_RX_NEXT_ETHERNET_INPUT;
498 u32 n_left_to_next, * to_next;
500 vlib_main_t * vm = vlib_get_main();
501 uword n_rx_bytes = 0;
502 u32 n_trace, trace_cnt __attribute__((unused));
503 vlib_buffer_free_list_t * fl;
504 u8 efd_discard_burst = 0;
505 u16 ip_align_offset = 0;
506 u32 buffer_flags_template;
508 if (xd->admin_up == 0)
511 n_buffers = dpdk_rx_burst(dm, xd, queue_id);
515 /* check if EFD (dpdk) is enabled */
516 if (PREDICT_FALSE(use_efd && dm->efd.enabled))
518 /* reset a few stats */
519 xd->efd_agent.last_poll_time = 0;
520 xd->efd_agent.last_burst_sz = 0;
525 if (xd->pmd == VNET_DPDK_PMD_THUNDERX)
528 buffer_flags_template = dm->buffer_flags_template;
530 vec_reset_length (xd->d_trace_buffers);
531 trace_cnt = n_trace = vlib_get_trace_count (vm, node);
533 fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
536 * DAW-FIXME: VMXNET3 device stop/start doesn't work,
537 * therefore fake the stop in the dpdk driver by
538 * silently dropping all of the incoming pkts instead of
539 * stopping the driver / hardware.
541 if (PREDICT_FALSE(xd->admin_up != 1))
543 for (mb_index = 0; mb_index < n_buffers; mb_index++)
544 rte_pktmbuf_free (xd->rx_vectors[queue_id][mb_index]);
549 /* Check for congestion if EFD (Early-Fast-Discard) is enabled
550 * in any mode (e.g. dpdk, monitor, or drop_all)
552 if (PREDICT_FALSE(use_efd && dm->efd.enabled))
554 /* update EFD counters */
555 dpdk_efd_update_counters(xd, n_buffers, dm->efd.enabled);
557 if (PREDICT_FALSE(dm->efd.enabled & DPDK_EFD_DROPALL_ENABLED))
559 /* discard all received packets */
560 for (mb_index = 0; mb_index < n_buffers; mb_index++)
561 rte_pktmbuf_free(xd->rx_vectors[queue_id][mb_index]);
563 xd->efd_agent.discard_cnt += n_buffers;
564 increment_efd_drop_counter(vm,
565 DPDK_ERROR_VLAN_EFD_DROP_PKTS,
571 if (PREDICT_FALSE(xd->efd_agent.consec_full_frames_cnt >=
572 dm->efd.consec_full_frames_hi_thresh))
574 u32 device_queue_sz = rte_eth_rx_queue_count(xd->device_index,
576 if (device_queue_sz >= dm->efd.queue_hi_thresh)
578 /* dpdk device queue has reached the critical threshold */
579 xd->efd_agent.congestion_cnt++;
581 /* apply EFD to packets from the burst */
582 efd_discard_burst = 1;
589 while (n_buffers > 0)
594 vlib_buffer_t * b0, * b_seg, * b_chain = 0;
597 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
599 while (n_buffers > 0 && n_left_to_next > 0)
602 struct rte_mbuf *mb = xd->rx_vectors[queue_id][mb_index];
603 struct rte_mbuf *mb_seg = mb->next;
605 if (PREDICT_TRUE(n_buffers > 2))
607 struct rte_mbuf *pfmb = xd->rx_vectors[queue_id][mb_index+2];
608 vlib_buffer_t *bp = vlib_buffer_from_rte_mbuf(pfmb);
609 CLIB_PREFETCH (pfmb, CLIB_CACHE_LINE_BYTES, STORE);
610 CLIB_PREFETCH (bp, CLIB_CACHE_LINE_BYTES, STORE);
615 b0 = vlib_buffer_from_rte_mbuf(mb);
617 /* check whether EFD is looking for packets to discard */
618 if (PREDICT_FALSE(efd_discard_burst))
620 vlib_thread_main_t * tm = vlib_get_thread_main();
622 if (PREDICT_TRUE(cntr_type = is_efd_discardable(tm, b0, mb)))
624 rte_pktmbuf_free(mb);
625 xd->efd_agent.discard_cnt++;
626 increment_efd_drop_counter(vm,
635 /* Prefetch one next segment if it exists. */
636 if (PREDICT_FALSE(mb->nb_segs > 1))
638 struct rte_mbuf *pfmb = mb->next;
639 vlib_buffer_t *bp = vlib_buffer_from_rte_mbuf(pfmb);
640 CLIB_PREFETCH (pfmb, CLIB_CACHE_LINE_BYTES, LOAD);
641 CLIB_PREFETCH (bp, CLIB_CACHE_LINE_BYTES, STORE);
645 vlib_buffer_init_for_free_list (b0, fl);
648 bi0 = vlib_get_buffer_index (vm, b0);
654 dpdk_rx_next_and_error_from_mb_flags_x1 (xd, mb, b0,
656 #ifdef RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS
658 * Clear overloaded TX offload flags when a DPDK driver
659 * is using them for RX flags (e.g. Cisco VIC Ethernet driver)
662 if (PREDICT_TRUE(trace_cnt == 0))
663 mb->ol_flags &= PKT_EXT_RX_CLR_TX_FLAGS_MASK;
666 #endif /* RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS */
668 b0->error = node->errors[error0];
670 l3_offset0 = ((next0 == DPDK_RX_NEXT_IP4_INPUT ||
671 next0 == DPDK_RX_NEXT_IP6_INPUT ||
672 next0 == DPDK_RX_NEXT_MPLS_INPUT) ?
673 sizeof (ethernet_header_t) : 0);
675 b0->current_data = l3_offset0;
676 b0->current_length = mb->data_len - l3_offset0;
678 if (PREDICT_FALSE (ip_align_offset != 0))
680 if (next0 == DPDK_RX_NEXT_IP4_INPUT ||
681 next0 == DPDK_RX_NEXT_IP6_INPUT)
682 b0->current_data += ip_align_offset;
685 b0->flags = buffer_flags_template;
687 if (VMWARE_LENGTH_BUG_WORKAROUND)
688 b0->current_length -= 4;
690 vnet_buffer(b0)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
691 vnet_buffer(b0)->sw_if_index[VLIB_TX] = (u32)~0;
692 n_rx_bytes += mb->pkt_len;
694 /* Process subsequent segments of multi-segment packets */
695 while ((mb->nb_segs > 1) && (nb_seg < mb->nb_segs))
699 b_seg = vlib_buffer_from_rte_mbuf(mb_seg);
700 vlib_buffer_init_for_free_list (b_seg, fl);
701 b_seg->clone_count = 0;
703 ASSERT((b_seg->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
704 ASSERT(b_seg->current_data == 0);
707 * The driver (e.g. virtio) may not put the packet data at the start
708 * of the segment, so don't assume b_seg->current_data == 0 is correct.
710 b_seg->current_data = (mb_seg->buf_addr + mb_seg->data_off) - (void *)b_seg->data;
712 b_seg->current_length = mb_seg->data_len;
713 b0->total_length_not_including_first_buffer +=
716 b_chain->flags |= VLIB_BUFFER_NEXT_PRESENT;
717 b_chain->next_buffer = vlib_get_buffer_index (vm, b_seg);
720 mb_seg = mb_seg->next;
725 * Turn this on if you run into
726 * "bad monkey" contexts, and you want to know exactly
727 * which nodes they've visited... See main.c...
729 VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b0);
731 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
732 to_next, n_left_to_next,
734 if (PREDICT_FALSE (n_trace > mb_index))
735 vec_add1 (xd->d_trace_buffers, bi0);
739 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
742 if (PREDICT_FALSE (vec_len (xd->d_trace_buffers) > 0))
744 dpdk_rx_trace (dm, node, xd, queue_id, xd->d_trace_buffers,
745 vec_len (xd->d_trace_buffers));
746 vlib_set_trace_count (vm, node, n_trace - vec_len (xd->d_trace_buffers));
749 vlib_increment_combined_counter
750 (vnet_get_main()->interface_main.combined_sw_if_counters
751 + VNET_INTERFACE_COUNTER_RX,
753 xd->vlib_sw_if_index,
754 mb_index, n_rx_bytes);
756 dpdk_worker_t * dw = vec_elt_at_index(dm->workers, cpu_index);
757 dw->aggregate_rx_packets += mb_index;
762 static inline void poll_rate_limit(dpdk_main_t * dm)
764 /* Limit the poll rate by sleeping for N msec between polls */
765 if (PREDICT_FALSE (dm->poll_sleep != 0))
767 struct timespec ts, tsrem;
770 ts.tv_nsec = 1000*1000*dm->poll_sleep; /* 1ms */
772 while (nanosleep(&ts, &tsrem) < 0)
780 dpdk_input (vlib_main_t * vm,
781 vlib_node_runtime_t * node,
784 dpdk_main_t * dm = &dpdk_main;
786 uword n_rx_packets = 0;
787 dpdk_device_and_queue_t * dq;
788 u32 cpu_index = os_get_cpu_number();
791 * Poll all devices on this cpu for input/interrupts.
793 vec_foreach (dq, dm->devices_by_cpu[cpu_index])
795 xd = vec_elt_at_index(dm->devices, dq->device);
796 ASSERT(dq->queue_id == 0);
797 n_rx_packets += dpdk_device_input (dm, xd, node, cpu_index, 0, 0);
806 dpdk_input_rss (vlib_main_t * vm,
807 vlib_node_runtime_t * node,
810 dpdk_main_t * dm = &dpdk_main;
812 uword n_rx_packets = 0;
813 dpdk_device_and_queue_t * dq;
814 u32 cpu_index = os_get_cpu_number();
817 * Poll all devices on this cpu for input/interrupts.
819 vec_foreach (dq, dm->devices_by_cpu[cpu_index])
821 xd = vec_elt_at_index(dm->devices, dq->device);
822 n_rx_packets += dpdk_device_input (dm, xd, node, cpu_index, dq->queue_id, 0);
831 dpdk_input_efd (vlib_main_t * vm,
832 vlib_node_runtime_t * node,
835 dpdk_main_t * dm = &dpdk_main;
837 uword n_rx_packets = 0;
838 dpdk_device_and_queue_t * dq;
839 u32 cpu_index = os_get_cpu_number();
842 * Poll all devices on this cpu for input/interrupts.
844 vec_foreach (dq, dm->devices_by_cpu[cpu_index])
846 xd = vec_elt_at_index(dm->devices, dq->device);
847 n_rx_packets += dpdk_device_input (dm, xd, node, cpu_index, dq->queue_id, 1);
856 VLIB_REGISTER_NODE (dpdk_input_node) = {
857 .function = dpdk_input,
858 .type = VLIB_NODE_TYPE_INPUT,
859 .name = "dpdk-input",
861 /* Will be enabled if/when hardware is detected. */
862 .state = VLIB_NODE_STATE_DISABLED,
864 .format_buffer = format_ethernet_header_with_length,
865 .format_trace = format_dpdk_rx_dma_trace,
867 .n_errors = DPDK_N_ERROR,
868 .error_strings = dpdk_error_strings,
870 .n_next_nodes = DPDK_RX_N_NEXT,
872 [DPDK_RX_NEXT_DROP] = "error-drop",
873 [DPDK_RX_NEXT_ETHERNET_INPUT] = "ethernet-input",
874 [DPDK_RX_NEXT_IP4_INPUT] = "ip4-input-no-checksum",
875 [DPDK_RX_NEXT_IP6_INPUT] = "ip6-input",
876 [DPDK_RX_NEXT_MPLS_INPUT] = "mpls-gre-input",
881 /* handle dpdk_input_rss alternative function */
882 VLIB_NODE_FUNCTION_MULTIARCH_CLONE(dpdk_input)
883 VLIB_NODE_FUNCTION_MULTIARCH_CLONE(dpdk_input_rss)
884 VLIB_NODE_FUNCTION_MULTIARCH_CLONE(dpdk_input_efd)
886 /* this macro defines dpdk_input_rss_multiarch_select() */
887 CLIB_MULTIARCH_SELECT_FN(dpdk_input);
888 CLIB_MULTIARCH_SELECT_FN(dpdk_input_rss);
889 CLIB_MULTIARCH_SELECT_FN(dpdk_input_efd);
892 * Override the next nodes for the dpdk input nodes.
893 * Must be invoked prior to VLIB_INIT_FUNCTION calls.
895 void dpdk_set_next_node (dpdk_rx_next_t next, char *name)
897 vlib_node_registration_t *r = &dpdk_input_node;
898 vlib_node_registration_t *r_io = &dpdk_io_input_node;
899 vlib_node_registration_t *r_handoff = &handoff_dispatch_node;
903 case DPDK_RX_NEXT_IP4_INPUT:
904 case DPDK_RX_NEXT_IP6_INPUT:
905 case DPDK_RX_NEXT_MPLS_INPUT:
906 case DPDK_RX_NEXT_ETHERNET_INPUT:
907 r->next_nodes[next] = name;
908 r_io->next_nodes[next] = name;
909 r_handoff->next_nodes[next] = name;
913 clib_warning ("%s: illegal next %d\n", __FUNCTION__, next);
918 inline vlib_frame_queue_elt_t *
919 vlib_get_handoff_queue_elt (u32 vlib_worker_index)
921 vlib_frame_queue_t *fq;
922 vlib_frame_queue_elt_t *elt;
925 fq = vlib_frame_queues[vlib_worker_index];
928 new_tail = __sync_add_and_fetch (&fq->tail, 1);
930 /* Wait until a ring slot is available */
931 while (new_tail >= fq->head_hint + fq->nelts)
932 vlib_worker_thread_barrier_check ();
934 elt = fq->elts + (new_tail & (fq->nelts-1));
936 /* this would be very bad... */
940 elt->msg_type = VLIB_FRAME_QUEUE_ELT_DISPATCH_FRAME;
941 elt->last_n_vectors = elt->n_vectors = 0;
946 static inline vlib_frame_queue_elt_t *
947 dpdk_get_handoff_queue_elt (
948 u32 vlib_worker_index,
949 vlib_frame_queue_elt_t ** handoff_queue_elt_by_worker_index)
951 vlib_frame_queue_elt_t *elt;
953 if (handoff_queue_elt_by_worker_index [vlib_worker_index])
954 return handoff_queue_elt_by_worker_index [vlib_worker_index];
956 elt = vlib_get_handoff_queue_elt (vlib_worker_index);
958 handoff_queue_elt_by_worker_index [vlib_worker_index] = elt;
963 static inline vlib_frame_queue_t *
964 is_vlib_handoff_queue_congested (
965 u32 vlib_worker_index,
967 vlib_frame_queue_t ** handoff_queue_by_worker_index)
969 vlib_frame_queue_t *fq;
971 fq = handoff_queue_by_worker_index [vlib_worker_index];
972 if (fq != (vlib_frame_queue_t *)(~0))
975 fq = vlib_frame_queues[vlib_worker_index];
978 if (PREDICT_FALSE(fq->tail >= (fq->head_hint + queue_hi_thresh))) {
979 /* a valid entry in the array will indicate the queue has reached
980 * the specified threshold and is congested
982 handoff_queue_by_worker_index [vlib_worker_index] = fq;
983 fq->enqueue_full_events++;
990 static inline u64 ipv4_get_key (ip4_header_t *ip)
994 hash_key = *((u64*)(&ip->address_pair)) ^ ip->protocol;
999 static inline u64 ipv6_get_key (ip6_header_t *ip)
1003 hash_key = ip->src_address.as_u64[0] ^
1004 rotate_left(ip->src_address.as_u64[1],13) ^
1005 rotate_left(ip->dst_address.as_u64[0],26) ^
1006 rotate_left(ip->dst_address.as_u64[1],39) ^
1013 #define MPLS_BOTTOM_OF_STACK_BIT_MASK 0x00000100U
1014 #define MPLS_LABEL_MASK 0xFFFFF000U
1016 static inline u64 mpls_get_key (mpls_unicast_header_t *m)
1022 /* find the bottom of the MPLS label stack. */
1023 if (PREDICT_TRUE(m->label_exp_s_ttl &
1024 clib_net_to_host_u32(MPLS_BOTTOM_OF_STACK_BIT_MASK))) {
1025 goto bottom_lbl_found;
1029 if (PREDICT_TRUE(m->label_exp_s_ttl &
1030 clib_net_to_host_u32(MPLS_BOTTOM_OF_STACK_BIT_MASK))) {
1031 goto bottom_lbl_found;
1035 if (m->label_exp_s_ttl & clib_net_to_host_u32(MPLS_BOTTOM_OF_STACK_BIT_MASK)) {
1036 goto bottom_lbl_found;
1040 if (m->label_exp_s_ttl & clib_net_to_host_u32(MPLS_BOTTOM_OF_STACK_BIT_MASK)) {
1041 goto bottom_lbl_found;
1045 if (m->label_exp_s_ttl & clib_net_to_host_u32(MPLS_BOTTOM_OF_STACK_BIT_MASK)) {
1046 goto bottom_lbl_found;
1049 /* the bottom label was not found - use the last label */
1050 hash_key = m->label_exp_s_ttl & clib_net_to_host_u32(MPLS_LABEL_MASK);
1057 ip_ver = (*((u8 *)m) >> 4);
1059 /* find out if it is IPV4 or IPV6 header */
1060 if (PREDICT_TRUE(ip_ver == 4)) {
1061 hash_key = ipv4_get_key((ip4_header_t *)m);
1062 } else if (PREDICT_TRUE(ip_ver == 6)) {
1063 hash_key = ipv6_get_key((ip6_header_t *)m);
1065 /* use the bottom label */
1066 hash_key = (m-1)->label_exp_s_ttl & clib_net_to_host_u32(MPLS_LABEL_MASK);
1073 static inline u64 eth_get_key (ethernet_header_t *h0)
1078 if (PREDICT_TRUE(h0->type) == clib_host_to_net_u16(ETHERNET_TYPE_IP4)) {
1079 hash_key = ipv4_get_key((ip4_header_t *)(h0+1));
1080 } else if (h0->type == clib_host_to_net_u16(ETHERNET_TYPE_IP6)) {
1081 hash_key = ipv6_get_key((ip6_header_t *)(h0+1));
1082 } else if (h0->type == clib_host_to_net_u16(ETHERNET_TYPE_MPLS_UNICAST)) {
1083 hash_key = mpls_get_key((mpls_unicast_header_t *)(h0+1));
1084 } else if ((h0->type == clib_host_to_net_u16(ETHERNET_TYPE_VLAN)) ||
1085 (h0->type == clib_host_to_net_u16(ETHERNET_TYPE_DOT1AD))) {
1086 ethernet_vlan_header_t * outer = (ethernet_vlan_header_t *)(h0 + 1);
1088 outer = (outer->type == clib_host_to_net_u16(ETHERNET_TYPE_VLAN)) ?
1090 if (PREDICT_TRUE(outer->type) == clib_host_to_net_u16(ETHERNET_TYPE_IP4)) {
1091 hash_key = ipv4_get_key((ip4_header_t *)(outer+1));
1092 } else if (outer->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP6)) {
1093 hash_key = ipv6_get_key((ip6_header_t *)(outer+1));
1094 } else if (outer->type == clib_host_to_net_u16(ETHERNET_TYPE_MPLS_UNICAST)) {
1095 hash_key = mpls_get_key((mpls_unicast_header_t *)(outer+1));
1097 hash_key = outer->type;
1107 * This function is used when dedicated IO threads feed the worker threads.
1109 * Devices are allocated to this thread based on instances and instance_id.
1110 * If instances==0 then the function automatically determines the number
1111 * of instances of this thread, and allocates devices between them.
1112 * If instances != 0, then instance_id must be in the range 0..instances-1.
1113 * The function allocates devices among the specified number of instances,
1114 * with this thread having the given instance id. This option is used for
1115 * splitting devices among differently named "io"-type threads.
1117 void dpdk_io_thread (vlib_worker_thread_t * w,
1121 dpdk_io_thread_callback_t callback)
1123 vlib_main_t * vm = vlib_get_main();
1124 vlib_thread_main_t * tm = vlib_get_thread_main();
1125 vlib_thread_registration_t * tr;
1126 dpdk_main_t * dm = &dpdk_main;
1127 char *io_name = w->registration->name;
1129 dpdk_device_t ** my_devices = 0;
1130 vlib_frame_queue_elt_t ** handoff_queue_elt_by_worker_index = 0;
1131 vlib_frame_queue_t ** congested_handoff_queue_by_worker_index = 0;
1132 vlib_frame_queue_elt_t * hf = 0;
1134 u32 n_left_to_next_worker = 0, * to_next_worker = 0;
1135 u32 next_worker_index = 0;
1136 u32 current_worker_index = ~0;
1137 u32 cpu_index = os_get_cpu_number();
1138 u32 num_workers = 0;
1139 u32 num_devices = 0;
1142 vlib_node_runtime_t * node_trace = 0;
1143 u32 first_worker_index = 0;
1144 u32 buffer_flags_template;
1146 /* Wait until the dpdk init sequence is complete */
1147 while (dm->io_thread_release == 0)
1148 vlib_worker_thread_barrier_check();
1150 clib_time_init (&vm->clib_time);
1152 p = hash_get_mem (tm->thread_registrations_by_name, worker_name);
1154 tr = (vlib_thread_registration_t *) p[0];
1157 num_workers = tr->count;
1158 first_worker_index = tr->first_index;
1161 /* Allocate devices to this thread */
1165 instance_id = w->instance_id;
1167 p = hash_get_mem (tm->thread_registrations_by_name, io_name);
1168 tr = (vlib_thread_registration_t *) p[0];
1169 /* Otherwise, how did we get here */
1170 ASSERT (tr && tr->count);
1171 instances = tr->count;
1175 /* manually assign */
1176 ASSERT (instance_id < instances);
1179 vec_validate (handoff_queue_elt_by_worker_index,
1180 first_worker_index + num_workers - 1);
1182 vec_validate_init_empty (congested_handoff_queue_by_worker_index,
1183 first_worker_index + num_workers - 1,
1184 (vlib_frame_queue_t *)(~0));
1186 buffer_flags_template = dm->buffer_flags_template;
1188 /* And handle them... */
1193 uword n_rx_bytes = 0;
1194 u32 n_trace, trace_cnt __attribute__((unused));
1195 vlib_buffer_free_list_t * fl;
1198 u8 efd_discard_burst;
1200 vlib_worker_thread_barrier_check ();
1202 /* Invoke callback if supplied */
1203 if (PREDICT_FALSE(callback != NULL))
1206 if (PREDICT_FALSE(vec_len(dm->devices) != num_devices))
1208 vec_reset_length(my_devices);
1209 vec_foreach (xd, dm->devices)
1211 if (((xd - dm->devices) % tr->count) == instance_id)
1213 fprintf(stderr, "i/o thread %d (cpu %d) takes port %d\n",
1214 instance_id, (int) os_get_cpu_number(), (int) (xd - dm->devices));
1215 vec_add1 (my_devices, xd);
1218 num_devices = vec_len(dm->devices);
1221 for (i = 0; i < vec_len (my_devices); i++)
1228 n_buffers = dpdk_rx_burst(dm, xd, 0 /* queue_id */);
1232 /* check if EFD (dpdk) is enabled */
1233 if (PREDICT_FALSE(dm->efd.enabled))
1235 /* reset a few stats */
1236 xd->efd_agent.last_poll_time = 0;
1237 xd->efd_agent.last_burst_sz = 0;
1242 trace_cnt = n_trace = 0;
1243 if (PREDICT_FALSE(vm->trace_main.trace_active_hint))
1246 * packet tracing is triggered on the dpdk-input node for
1247 * ease-of-use. Re-fetch the node_runtime for dpdk-input
1248 * in case it has changed.
1250 node_trace = vlib_node_get_runtime (vm, dpdk_input_node.index);
1252 vec_reset_length (xd->d_trace_buffers);
1253 trace_cnt = n_trace = vlib_get_trace_count (vm, node_trace);
1257 * DAW-FIXME: VMXNET3 device stop/start doesn't work,
1258 * therefore fake the stop in the dpdk driver by
1259 * silently dropping all of the incoming pkts instead of
1260 * stopping the driver / hardware.
1262 if (PREDICT_FALSE(xd->admin_up != 1))
1264 for (mb_index = 0; mb_index < n_buffers; mb_index++)
1265 rte_pktmbuf_free (xd->rx_vectors[queue_id][mb_index]);
1269 /* reset EFD action for the burst */
1270 efd_discard_burst = 0;
1272 /* Check for congestion if EFD (Early-Fast-Discard) is enabled
1273 * in any mode (e.g. dpdk, monitor, or drop_all)
1275 if (PREDICT_FALSE(dm->efd.enabled))
1277 /* update EFD counters */
1278 dpdk_efd_update_counters(xd, n_buffers, dm->efd.enabled);
1280 if (PREDICT_FALSE(dm->efd.enabled & DPDK_EFD_DROPALL_ENABLED))
1282 /* drop all received packets */
1283 for (mb_index = 0; mb_index < n_buffers; mb_index++)
1284 rte_pktmbuf_free(xd->rx_vectors[queue_id][mb_index]);
1286 xd->efd_agent.discard_cnt += n_buffers;
1287 increment_efd_drop_counter(vm,
1288 DPDK_ERROR_VLAN_EFD_DROP_PKTS,
1294 if (PREDICT_FALSE(xd->efd_agent.consec_full_frames_cnt >=
1295 dm->efd.consec_full_frames_hi_thresh))
1297 u32 device_queue_sz = rte_eth_rx_queue_count(xd->device_index,
1299 if (device_queue_sz >= dm->efd.queue_hi_thresh)
1301 /* dpdk device queue has reached the critical threshold */
1302 xd->efd_agent.congestion_cnt++;
1304 /* apply EFD to packets from the burst */
1305 efd_discard_burst = 1;
1310 fl = vlib_buffer_get_free_list
1311 (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
1315 while (n_buffers > 0)
1320 vlib_buffer_t * b0, * b_seg, * b_chain = 0;
1321 ethernet_header_t * h0;
1323 struct rte_mbuf *mb = xd->rx_vectors[queue_id][mb_index];
1324 struct rte_mbuf *mb_seg = mb->next;
1326 if (PREDICT_TRUE(n_buffers > 1))
1328 struct rte_mbuf *pfmb = xd->rx_vectors[queue_id][mb_index+2];
1329 vlib_buffer_t *bp = vlib_buffer_from_rte_mbuf(pfmb);
1330 CLIB_PREFETCH (pfmb, CLIB_CACHE_LINE_BYTES, LOAD);
1331 CLIB_PREFETCH (bp, CLIB_CACHE_LINE_BYTES, STORE);
1332 CLIB_PREFETCH (bp->data, CLIB_CACHE_LINE_BYTES, LOAD);
1335 b0 = vlib_buffer_from_rte_mbuf(mb);
1337 /* check whether EFD is looking for packets to discard */
1338 if (PREDICT_FALSE(efd_discard_burst))
1341 if (PREDICT_TRUE(cntr_type = is_efd_discardable(tm, b0, mb)))
1343 rte_pktmbuf_free(mb);
1344 xd->efd_agent.discard_cnt++;
1345 increment_efd_drop_counter(vm,
1355 /* Prefetch one next segment if it exists */
1356 if (PREDICT_FALSE(mb->nb_segs > 1))
1358 struct rte_mbuf *pfmb = mb->next;
1359 vlib_buffer_t *bp = vlib_buffer_from_rte_mbuf(pfmb);
1360 CLIB_PREFETCH (pfmb, CLIB_CACHE_LINE_BYTES, LOAD);
1361 CLIB_PREFETCH (bp, CLIB_CACHE_LINE_BYTES, STORE);
1365 bi0 = vlib_get_buffer_index (vm, b0);
1366 vlib_buffer_init_for_free_list (b0, fl);
1367 b0->clone_count = 0;
1369 dpdk_rx_next_and_error_from_mb_flags_x1 (xd, mb, b0,
1371 #ifdef RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS
1373 * Clear overloaded TX offload flags when a DPDK driver
1374 * is using them for RX flags (e.g. Cisco VIC Ethernet driver)
1376 if (PREDICT_TRUE(trace_cnt == 0))
1377 mb->ol_flags &= PKT_EXT_RX_CLR_TX_FLAGS_MASK;
1380 #endif /* RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS */
1383 clib_warning ("bi %d error %d", bi0, error0);
1387 l3_offset0 = ((next0 == DPDK_RX_NEXT_IP4_INPUT ||
1388 next0 == DPDK_RX_NEXT_IP6_INPUT ||
1389 next0 == DPDK_RX_NEXT_MPLS_INPUT) ?
1390 sizeof (ethernet_header_t) : 0);
1392 b0->current_data = l3_offset0;
1393 b0->current_length = mb->data_len - l3_offset0;
1395 b0->flags = buffer_flags_template;
1397 if (VMWARE_LENGTH_BUG_WORKAROUND)
1398 b0->current_length -= 4;
1400 vnet_buffer(b0)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
1401 vnet_buffer(b0)->sw_if_index[VLIB_TX] = (u32)~0;
1402 vnet_buffer(b0)->io_handoff.next_index = next0;
1403 n_rx_bytes += mb->pkt_len;
1405 /* Process subsequent segments of multi-segment packets */
1406 while ((mb->nb_segs > 1) && (nb_seg < mb->nb_segs))
1408 ASSERT(mb_seg != 0);
1410 b_seg = vlib_buffer_from_rte_mbuf(mb_seg);
1411 vlib_buffer_init_for_free_list (b_seg, fl);
1412 b_seg->clone_count = 0;
1414 ASSERT((b_seg->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
1415 ASSERT(b_seg->current_data == 0);
1418 * The driver (e.g. virtio) may not put the packet data at the start
1419 * of the segment, so don't assume b_seg->current_data == 0 is correct.
1421 b_seg->current_data = (mb_seg->buf_addr + mb_seg->data_off) - (void *)b_seg->data;
1423 b_seg->current_length = mb_seg->data_len;
1424 b0->total_length_not_including_first_buffer +=
1427 b_chain->flags |= VLIB_BUFFER_NEXT_PRESENT;
1428 b_chain->next_buffer = vlib_get_buffer_index (vm, b_seg);
1431 mb_seg = mb_seg->next;
1436 * Turn this on if you run into
1437 * "bad monkey" contexts, and you want to know exactly
1438 * which nodes they've visited... See main.c...
1440 VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b0);
1442 if (PREDICT_FALSE (n_trace > mb_index))
1443 vec_add1 (xd->d_trace_buffers, bi0);
1445 next_worker_index = first_worker_index;
1448 * Force unknown traffic onto worker 0,
1449 * and into ethernet-input. $$$$ add more hashes.
1451 h0 = (ethernet_header_t *) b0->data;
1453 /* Compute ingress LB hash */
1454 hash_key = eth_get_key(h0);
1455 hash = (u32)clib_xxhash(hash_key);
1457 if (PREDICT_TRUE (is_pow2(num_workers)))
1458 next_worker_index += hash & (num_workers - 1);
1460 next_worker_index += hash % num_workers;
1462 /* if EFD is enabled and not already discarding from dpdk,
1463 * check the worker ring/queue for congestion
1465 if (PREDICT_FALSE(tm->efd.enabled && !efd_discard_burst))
1467 vlib_frame_queue_t *fq;
1469 /* fq will be valid if the ring is congested */
1470 fq = is_vlib_handoff_queue_congested(
1471 next_worker_index, tm->efd.queue_hi_thresh,
1472 congested_handoff_queue_by_worker_index);
1474 if (PREDICT_FALSE(fq != NULL))
1477 if (PREDICT_TRUE(cntr_type =
1478 is_efd_discardable(tm, b0, mb)))
1480 /* discard the packet */
1481 fq->enqueue_efd_discards++;
1482 increment_efd_drop_counter(vm, cntr_type, 1);
1483 rte_pktmbuf_free(mb);
1491 if (next_worker_index != current_worker_index)
1494 hf->n_vectors = VLIB_FRAME_SIZE - n_left_to_next_worker;
1496 hf = dpdk_get_handoff_queue_elt(
1498 handoff_queue_elt_by_worker_index);
1500 n_left_to_next_worker = VLIB_FRAME_SIZE - hf->n_vectors;
1501 to_next_worker = &hf->buffer_index[hf->n_vectors];
1502 current_worker_index = next_worker_index;
1505 /* enqueue to correct worker thread */
1506 to_next_worker[0] = bi0;
1508 n_left_to_next_worker--;
1510 if (n_left_to_next_worker == 0)
1512 hf->n_vectors = VLIB_FRAME_SIZE;
1513 vlib_put_handoff_queue_elt(hf);
1514 current_worker_index = ~0;
1515 handoff_queue_elt_by_worker_index[next_worker_index] = 0;
1523 if (PREDICT_FALSE (vec_len (xd->d_trace_buffers) > 0))
1525 /* credit the trace to the trace node */
1526 dpdk_rx_trace (dm, node_trace, xd, queue_id, xd->d_trace_buffers,
1527 vec_len (xd->d_trace_buffers));
1528 vlib_set_trace_count (vm, node_trace, n_trace - vec_len (xd->d_trace_buffers));
1531 vlib_increment_combined_counter
1532 (vnet_get_main()->interface_main.combined_sw_if_counters
1533 + VNET_INTERFACE_COUNTER_RX,
1535 xd->vlib_sw_if_index,
1536 mb_index, n_rx_bytes);
1538 dpdk_worker_t * dw = vec_elt_at_index(dm->workers, cpu_index);
1539 dw->aggregate_rx_packets += mb_index;
1543 hf->n_vectors = VLIB_FRAME_SIZE - n_left_to_next_worker;
1545 /* Ship frames to the worker nodes */
1546 for (i = 0; i < vec_len (handoff_queue_elt_by_worker_index); i++)
1548 if (handoff_queue_elt_by_worker_index[i])
1550 hf = handoff_queue_elt_by_worker_index[i];
1552 * It works better to let the handoff node
1553 * rate-adapt, always ship the handoff queue element.
1555 if (1 || hf->n_vectors == hf->last_n_vectors)
1557 vlib_put_handoff_queue_elt(hf);
1558 handoff_queue_elt_by_worker_index[i] = 0;
1561 hf->last_n_vectors = hf->n_vectors;
1563 congested_handoff_queue_by_worker_index[i] = (vlib_frame_queue_t *)(~0);
1566 current_worker_index = ~0;
1568 vlib_increment_main_loop_counter (vm);
1573 * This function is used when the main thread performs IO and feeds the
1577 dpdk_io_input (vlib_main_t * vm,
1578 vlib_node_runtime_t * node,
1581 dpdk_main_t * dm = &dpdk_main;
1583 vlib_thread_main_t * tm = vlib_get_thread_main();
1584 uword n_rx_packets = 0;
1585 static vlib_frame_queue_elt_t ** handoff_queue_elt_by_worker_index;
1586 static vlib_frame_queue_t ** congested_handoff_queue_by_worker_index = 0;
1587 vlib_frame_queue_elt_t * hf = 0;
1589 u32 n_left_to_next_worker = 0, * to_next_worker = 0;
1590 u32 next_worker_index = 0;
1591 u32 current_worker_index = ~0;
1592 u32 cpu_index = os_get_cpu_number();
1593 static int num_workers_set;
1594 static u32 num_workers;
1596 vlib_node_runtime_t * node_trace;
1597 static u32 first_worker_index;
1598 u32 buffer_flags_template;
1600 if (PREDICT_FALSE(num_workers_set == 0))
1603 vlib_thread_registration_t * tr;
1604 /* Only the standard vnet worker threads are supported */
1605 p = hash_get_mem (tm->thread_registrations_by_name, "workers");
1606 tr = (vlib_thread_registration_t *) p[0];
1609 num_workers = tr->count;
1610 first_worker_index = tr->first_index;
1612 num_workers_set = 1;
1615 if (PREDICT_FALSE(handoff_queue_elt_by_worker_index == 0))
1617 vec_validate (handoff_queue_elt_by_worker_index, tm->n_vlib_mains - 1);
1619 vec_validate_init_empty (congested_handoff_queue_by_worker_index,
1620 first_worker_index + num_workers - 1,
1621 (vlib_frame_queue_t *)(~0));
1624 /* packet tracing is triggered on the dpdk-input node for ease-of-use */
1625 node_trace = vlib_node_get_runtime (vm, dpdk_input_node.index);
1627 buffer_flags_template = dm->buffer_flags_template;
1629 vec_foreach (xd, dm->devices)
1633 uword n_rx_bytes = 0;
1634 u32 n_trace, trace_cnt __attribute__((unused));
1635 vlib_buffer_free_list_t * fl;
1638 u8 efd_discard_burst = 0;
1643 n_buffers = dpdk_rx_burst(dm, xd, queue_id );
1647 /* check if EFD (dpdk) is enabled */
1648 if (PREDICT_FALSE(dm->efd.enabled))
1650 /* reset a few stats */
1651 xd->efd_agent.last_poll_time = 0;
1652 xd->efd_agent.last_burst_sz = 0;
1657 vec_reset_length (xd->d_trace_buffers);
1658 trace_cnt = n_trace = vlib_get_trace_count (vm, node_trace);
1661 * DAW-FIXME: VMXNET3 device stop/start doesn't work,
1662 * therefore fake the stop in the dpdk driver by
1663 * silently dropping all of the incoming pkts instead of
1664 * stopping the driver / hardware.
1666 if (PREDICT_FALSE(xd->admin_up != 1))
1668 for (mb_index = 0; mb_index < n_buffers; mb_index++)
1669 rte_pktmbuf_free (xd->rx_vectors[queue_id][mb_index]);
1673 /* Check for congestion if EFD (Early-Fast-Discard) is enabled
1674 * in any mode (e.g. dpdk, monitor, or drop_all)
1676 if (PREDICT_FALSE(dm->efd.enabled))
1678 /* update EFD counters */
1679 dpdk_efd_update_counters(xd, n_buffers, dm->efd.enabled);
1681 if (PREDICT_FALSE(dm->efd.enabled & DPDK_EFD_DROPALL_ENABLED))
1683 /* discard all received packets */
1684 for (mb_index = 0; mb_index < n_buffers; mb_index++)
1685 rte_pktmbuf_free(xd->rx_vectors[queue_id][mb_index]);
1687 xd->efd_agent.discard_cnt += n_buffers;
1688 increment_efd_drop_counter(vm,
1689 DPDK_ERROR_VLAN_EFD_DROP_PKTS,
1695 if (PREDICT_FALSE(xd->efd_agent.consec_full_frames_cnt >=
1696 dm->efd.consec_full_frames_hi_thresh))
1698 u32 device_queue_sz = rte_eth_rx_queue_count(xd->device_index,
1700 if (device_queue_sz >= dm->efd.queue_hi_thresh)
1702 /* dpdk device queue has reached the critical threshold */
1703 xd->efd_agent.congestion_cnt++;
1705 /* apply EFD to packets from the burst */
1706 efd_discard_burst = 1;
1711 fl = vlib_buffer_get_free_list
1712 (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
1716 while (n_buffers > 0)
1721 vlib_buffer_t * b0, * b_seg, * b_chain = 0;
1722 ethernet_header_t * h0;
1724 struct rte_mbuf *mb = xd->rx_vectors[queue_id][mb_index];
1725 struct rte_mbuf *mb_seg = mb->next;
1727 if (PREDICT_TRUE(n_buffers > 1))
1729 struct rte_mbuf *pfmb = xd->rx_vectors[queue_id][mb_index+2];
1730 vlib_buffer_t *bp = vlib_buffer_from_rte_mbuf(pfmb);
1731 CLIB_PREFETCH (pfmb, CLIB_CACHE_LINE_BYTES, LOAD);
1732 CLIB_PREFETCH (bp, CLIB_CACHE_LINE_BYTES, STORE);
1733 CLIB_PREFETCH (bp->data, CLIB_CACHE_LINE_BYTES, LOAD);
1736 b0 = vlib_buffer_from_rte_mbuf(mb);
1738 /* check whether EFD is looking for packets to discard */
1739 if (PREDICT_FALSE(efd_discard_burst))
1742 if (PREDICT_TRUE(cntr_type = is_efd_discardable(tm, b0, mb)))
1744 rte_pktmbuf_free(mb);
1745 xd->efd_agent.discard_cnt++;
1746 increment_efd_drop_counter(vm,
1756 /* Prefetch one next segment if it exists */
1757 if (PREDICT_FALSE(mb->nb_segs > 1))
1759 struct rte_mbuf *pfmb = mb->next;
1760 vlib_buffer_t *bp = vlib_buffer_from_rte_mbuf(pfmb);
1761 CLIB_PREFETCH (pfmb, CLIB_CACHE_LINE_BYTES, LOAD);
1762 CLIB_PREFETCH (bp, CLIB_CACHE_LINE_BYTES, STORE);
1766 bi0 = vlib_get_buffer_index (vm, b0);
1767 vlib_buffer_init_for_free_list (b0, fl);
1768 b0->clone_count = 0;
1770 dpdk_rx_next_and_error_from_mb_flags_x1 (xd, mb, b0,
1772 #ifdef RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS
1774 * Clear overloaded TX offload flags when a DPDK driver
1775 * is using them for RX flags (e.g. Cisco VIC Ethernet driver)
1777 if (PREDICT_TRUE(trace_cnt == 0))
1778 mb->ol_flags &= PKT_EXT_RX_CLR_TX_FLAGS_MASK;
1781 #endif /* RTE_LIBRTE_MBUF_EXT_RX_OLFLAGS */
1784 clib_warning ("bi %d error %d", bi0, error0);
1788 l3_offset0 = ((next0 == DPDK_RX_NEXT_IP4_INPUT ||
1789 next0 == DPDK_RX_NEXT_IP6_INPUT ||
1790 next0 == DPDK_RX_NEXT_MPLS_INPUT) ?
1791 sizeof (ethernet_header_t) : 0);
1793 b0->current_data = l3_offset0;
1794 b0->current_length = mb->data_len - l3_offset0;
1796 b0->flags = buffer_flags_template;
1798 if (VMWARE_LENGTH_BUG_WORKAROUND)
1799 b0->current_length -= 4;
1801 vnet_buffer(b0)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
1802 vnet_buffer(b0)->sw_if_index[VLIB_TX] = (u32)~0;
1803 vnet_buffer(b0)->io_handoff.next_index = next0;
1804 n_rx_bytes += mb->pkt_len;
1806 /* Process subsequent segments of multi-segment packets */
1807 while ((mb->nb_segs > 1) && (nb_seg < mb->nb_segs))
1809 ASSERT(mb_seg != 0);
1811 b_seg = vlib_buffer_from_rte_mbuf(mb_seg);
1812 vlib_buffer_init_for_free_list (b_seg, fl);
1813 b_seg->clone_count = 0;
1815 ASSERT((b_seg->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
1816 ASSERT(b_seg->current_data == 0);
1819 * The driver (e.g. virtio) may not put the packet data at the start
1820 * of the segment, so don't assume b_seg->current_data == 0 is correct.
1822 b_seg->current_data = (mb_seg->buf_addr + mb_seg->data_off) - (void *)b_seg->data;
1824 b_seg->current_length = mb_seg->data_len;
1825 b0->total_length_not_including_first_buffer +=
1828 b_chain->flags |= VLIB_BUFFER_NEXT_PRESENT;
1829 b_chain->next_buffer = vlib_get_buffer_index (vm, b_seg);
1832 mb_seg = mb_seg->next;
1837 * Turn this on if you run into
1838 * "bad monkey" contexts, and you want to know exactly
1839 * which nodes they've visited... See main.c...
1841 VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b0);
1843 if (PREDICT_FALSE (n_trace > mb_index))
1844 vec_add1 (xd->d_trace_buffers, bi0);
1846 next_worker_index = first_worker_index;
1849 * Force unknown traffic onto worker 0,
1850 * and into ethernet-input. $$$$ add more hashes.
1852 h0 = (ethernet_header_t *) b0->data;
1854 /* Compute ingress LB hash */
1855 hash_key = eth_get_key(h0);
1856 hash = (u32)clib_xxhash(hash_key);
1858 if (PREDICT_TRUE (is_pow2(num_workers)))
1859 next_worker_index += hash & (num_workers - 1);
1861 next_worker_index += hash % num_workers;
1863 /* if EFD is enabled and not already discarding from dpdk,
1864 * check the worker ring/queue for congestion
1866 if (PREDICT_FALSE(tm->efd.enabled && !efd_discard_burst))
1868 vlib_frame_queue_t *fq;
1870 /* fq will be valid if the ring is congested */
1871 fq = is_vlib_handoff_queue_congested(
1872 next_worker_index, tm->efd.queue_hi_thresh,
1873 congested_handoff_queue_by_worker_index);
1875 if (PREDICT_FALSE(fq != NULL))
1878 if (PREDICT_TRUE(cntr_type =
1879 is_efd_discardable(tm, b0, mb)))
1881 /* discard the packet */
1882 fq->enqueue_efd_discards++;
1883 increment_efd_drop_counter(vm, cntr_type, 1);
1884 rte_pktmbuf_free(mb);
1892 if (next_worker_index != current_worker_index)
1895 hf->n_vectors = VLIB_FRAME_SIZE - n_left_to_next_worker;
1897 hf = dpdk_get_handoff_queue_elt(
1899 handoff_queue_elt_by_worker_index);
1901 n_left_to_next_worker = VLIB_FRAME_SIZE - hf->n_vectors;
1902 to_next_worker = &hf->buffer_index[hf->n_vectors];
1903 current_worker_index = next_worker_index;
1906 /* enqueue to correct worker thread */
1907 to_next_worker[0] = bi0;
1909 n_left_to_next_worker--;
1911 if (n_left_to_next_worker == 0)
1913 hf->n_vectors = VLIB_FRAME_SIZE;
1914 vlib_put_handoff_queue_elt(hf);
1915 current_worker_index = ~0;
1916 handoff_queue_elt_by_worker_index[next_worker_index] = 0;
1924 if (PREDICT_FALSE (vec_len (xd->d_trace_buffers) > 0))
1926 /* credit the trace to the trace node */
1927 dpdk_rx_trace (dm, node_trace, xd, queue_id, xd->d_trace_buffers,
1928 vec_len (xd->d_trace_buffers));
1929 vlib_set_trace_count (vm, node_trace, n_trace - vec_len (xd->d_trace_buffers));
1932 vlib_increment_combined_counter
1933 (vnet_get_main()->interface_main.combined_sw_if_counters
1934 + VNET_INTERFACE_COUNTER_RX,
1936 xd->vlib_sw_if_index,
1937 mb_index, n_rx_bytes);
1939 dpdk_worker_t * dw = vec_elt_at_index(dm->workers, cpu_index);
1940 dw->aggregate_rx_packets += mb_index;
1941 n_rx_packets += mb_index;
1945 hf->n_vectors = VLIB_FRAME_SIZE - n_left_to_next_worker;
1947 /* Ship frames to the worker nodes */
1948 for (i = 0; i < vec_len (handoff_queue_elt_by_worker_index); i++)
1950 if (handoff_queue_elt_by_worker_index[i])
1952 hf = handoff_queue_elt_by_worker_index[i];
1954 * It works better to let the handoff node
1955 * rate-adapt, always ship the handoff queue element.
1957 if (1 || hf->n_vectors == hf->last_n_vectors)
1959 vlib_put_handoff_queue_elt(hf);
1960 handoff_queue_elt_by_worker_index[i] = 0;
1963 hf->last_n_vectors = hf->n_vectors;
1965 congested_handoff_queue_by_worker_index[i] = (vlib_frame_queue_t *)(~0);
1968 current_worker_index = ~0;
1969 return n_rx_packets;
1972 VLIB_REGISTER_NODE (dpdk_io_input_node) = {
1973 .function = dpdk_io_input,
1974 .type = VLIB_NODE_TYPE_INPUT,
1975 .name = "dpdk-io-input",
1977 /* Will be enabled if/when hardware is detected. */
1978 .state = VLIB_NODE_STATE_DISABLED,
1980 .format_buffer = format_ethernet_header_with_length,
1981 .format_trace = format_dpdk_rx_dma_trace,
1983 .n_errors = DPDK_N_ERROR,
1984 .error_strings = dpdk_error_strings,
1986 .n_next_nodes = DPDK_RX_N_NEXT,
1988 [DPDK_RX_NEXT_DROP] = "error-drop",
1989 [DPDK_RX_NEXT_ETHERNET_INPUT] = "ethernet-input",
1990 [DPDK_RX_NEXT_IP4_INPUT] = "ip4-input-no-checksum",
1991 [DPDK_RX_NEXT_IP6_INPUT] = "ip6-input",
1992 [DPDK_RX_NEXT_MPLS_INPUT] = "mpls-gre-input",
1998 * Based on the operation type, set lower/upper bits for the given index value
2001 set_efd_bitmap (u8 *bitmap, u32 value, u32 op)
2006 for (ix = 0; ix < 8; ix++) {
2007 if (((op == EFD_OPERATION_LESS_THAN) && (ix < value)) ||
2008 ((op == EFD_OPERATION_GREATER_OR_EQUAL) && (ix >= value))){
2009 (*bitmap) |= (1 << ix);
2015 efd_config (u32 enabled,
2016 u32 ip_prec, u32 ip_op,
2017 u32 mpls_exp, u32 mpls_op,
2018 u32 vlan_cos, u32 vlan_op)
2020 vlib_thread_main_t * tm = vlib_get_thread_main();
2021 dpdk_main_t * dm = &dpdk_main;
2024 tm->efd.enabled |= VLIB_EFD_DISCARD_ENABLED;
2025 dm->efd.enabled |= DPDK_EFD_DISCARD_ENABLED;
2027 tm->efd.enabled &= ~VLIB_EFD_DISCARD_ENABLED;
2028 dm->efd.enabled &= ~DPDK_EFD_DISCARD_ENABLED;
2031 set_efd_bitmap(&tm->efd.ip_prec_bitmap, ip_prec, ip_op);
2032 set_efd_bitmap(&tm->efd.mpls_exp_bitmap, mpls_exp, mpls_op);
2033 set_efd_bitmap(&tm->efd.vlan_cos_bitmap, vlan_cos, vlan_op);