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 <dpdk/device/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/device/dpdk_priv.h>
31 static char *dpdk_error_strings[] = {
37 /* make sure all flags we need are stored in lower 8 bits */
38 STATIC_ASSERT ((PKT_RX_IP_CKSUM_BAD | PKT_RX_FDIR) <
39 256, "dpdk flags not un lower byte, fix needed");
41 static_always_inline uword
42 dpdk_process_subseq_segs (vlib_main_t * vm, vlib_buffer_t * b,
43 struct rte_mbuf *mb, vlib_buffer_free_list_t * fl)
46 struct rte_mbuf *mb_seg = 0;
47 vlib_buffer_t *b_seg, *b_chain = 0;
54 b->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
55 b->total_length_not_including_first_buffer = 0;
57 while (nb_seg < mb->nb_segs)
61 b_seg = vlib_buffer_from_rte_mbuf (mb_seg);
62 vlib_buffer_init_for_free_list (b_seg, fl);
64 ASSERT ((b_seg->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
65 ASSERT (b_seg->current_data == 0);
68 * The driver (e.g. virtio) may not put the packet data at the start
69 * of the segment, so don't assume b_seg->current_data == 0 is correct.
72 (mb_seg->buf_addr + mb_seg->data_off) - (void *) b_seg->data;
74 b_seg->current_length = mb_seg->data_len;
75 b->total_length_not_including_first_buffer += mb_seg->data_len;
77 b_chain->flags |= VLIB_BUFFER_NEXT_PRESENT;
78 b_chain->next_buffer = vlib_get_buffer_index (vm, b_seg);
81 mb_seg = mb_seg->next;
84 return b->total_length_not_including_first_buffer;
87 static_always_inline void
88 dpdk_prefetch_mbuf_x4 (struct rte_mbuf *mb[])
90 CLIB_PREFETCH (mb[0], CLIB_CACHE_LINE_BYTES, LOAD);
91 CLIB_PREFETCH (mb[1], CLIB_CACHE_LINE_BYTES, LOAD);
92 CLIB_PREFETCH (mb[2], CLIB_CACHE_LINE_BYTES, LOAD);
93 CLIB_PREFETCH (mb[3], CLIB_CACHE_LINE_BYTES, LOAD);
96 static_always_inline void
97 dpdk_prefetch_buffer_x4 (struct rte_mbuf *mb[])
100 b = vlib_buffer_from_rte_mbuf (mb[0]);
101 CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
102 b = vlib_buffer_from_rte_mbuf (mb[1]);
103 CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
104 b = vlib_buffer_from_rte_mbuf (mb[2]);
105 CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
106 b = vlib_buffer_from_rte_mbuf (mb[3]);
107 CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
110 /** \brief Main DPDK input node
113 This is the main DPDK input node: across each assigned interface,
114 call rte_eth_rx_burst(...) or similar to obtain a vector of
115 packets to process. Derive @c vlib_buffer_t metadata from
116 <code>struct rte_mbuf</code> metadata,
117 Depending on the resulting metadata: adjust <code>b->current_data,
118 b->current_length </code> and dispatch directly to
119 ip4-input-no-checksum, or ip6-input. Trace the packet if required.
121 @param vm vlib_main_t corresponding to the current thread
122 @param node vlib_node_runtime_t
123 @param f vlib_frame_t input-node, not used.
125 @par Graph mechanics: buffer metadata, next index usage
128 - <code>struct rte_mbuf mb->ol_flags</code>
129 - PKT_RX_IP_CKSUM_BAD
132 - <code>b->error</code> if the packet is to be dropped immediately
133 - <code>b->current_data, b->current_length</code>
134 - adjusted as needed to skip the L2 header in direct-dispatch cases
135 - <code>vnet_buffer(b)->sw_if_index[VLIB_RX]</code>
136 - rx interface sw_if_index
137 - <code>vnet_buffer(b)->sw_if_index[VLIB_TX] = ~0</code>
138 - required by ipX-lookup
139 - <code>b->flags</code>
140 - to indicate multi-segment pkts (VLIB_BUFFER_NEXT_PRESENT), etc.
143 - Static arcs to: error-drop, ethernet-input,
144 ip4-input-no-checksum, ip6-input, mpls-input
145 - per-interface redirection, controlled by
146 <code>xd->per_interface_next_index</code>
149 static_always_inline u8
150 dpdk_ol_flags_extract (struct rte_mbuf **mb, u8 * flags, int count)
154 for (i = 0; i < count; i++)
156 /* all flags we are interested in are in lower 8 bits but
158 flags[i] = (u8) mb[i]->ol_flags;
164 static_always_inline uword
165 dpdk_process_rx_burst (vlib_main_t * vm, dpdk_per_thread_data_t * ptd,
166 uword n_rx_packets, int maybe_multiseg, u8 * or_flagsp)
168 u32 n_left = n_rx_packets;
170 vlib_buffer_free_list_t *fl;
171 struct rte_mbuf **mb = ptd->mbufs;
173 u8 *flags, or_flags = 0;
176 fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
183 dpdk_prefetch_buffer_x4 (mb + 4);
185 b[0] = vlib_buffer_from_rte_mbuf (mb[0]);
186 b[1] = vlib_buffer_from_rte_mbuf (mb[1]);
187 b[2] = vlib_buffer_from_rte_mbuf (mb[2]);
188 b[3] = vlib_buffer_from_rte_mbuf (mb[3]);
190 clib_memcpy64_x4 (b[0], b[1], b[2], b[3], &ptd->buffer_template);
192 dpdk_prefetch_mbuf_x4 (mb + 4);
194 or_flags |= dpdk_ol_flags_extract (mb, flags, 4);
197 b[0]->current_data = mb[0]->data_off - RTE_PKTMBUF_HEADROOM;
198 n_bytes += b[0]->current_length = mb[0]->data_len;
200 b[1]->current_data = mb[1]->data_off - RTE_PKTMBUF_HEADROOM;
201 n_bytes += b[1]->current_length = mb[1]->data_len;
203 b[2]->current_data = mb[2]->data_off - RTE_PKTMBUF_HEADROOM;
204 n_bytes += b[2]->current_length = mb[2]->data_len;
206 b[3]->current_data = mb[3]->data_off - RTE_PKTMBUF_HEADROOM;
207 n_bytes += b[3]->current_length = mb[3]->data_len;
211 n_bytes += dpdk_process_subseq_segs (vm, b[0], mb[0], fl);
212 n_bytes += dpdk_process_subseq_segs (vm, b[1], mb[1], fl);
213 n_bytes += dpdk_process_subseq_segs (vm, b[2], mb[2], fl);
214 n_bytes += dpdk_process_subseq_segs (vm, b[3], mb[3], fl);
217 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
218 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[1]);
219 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[2]);
220 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[3]);
229 b[0] = vlib_buffer_from_rte_mbuf (mb[0]);
230 clib_memcpy_fast (b[0], &ptd->buffer_template, 64);
231 or_flags |= dpdk_ol_flags_extract (mb, flags, 1);
234 b[0]->current_data = mb[0]->data_off - RTE_PKTMBUF_HEADROOM;
235 n_bytes += b[0]->current_length = mb[0]->data_len;
238 n_bytes += dpdk_process_subseq_segs (vm, b[0], mb[0], fl);
239 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
246 *or_flagsp = or_flags;
250 static_always_inline void
251 dpdk_process_flow_offload (dpdk_device_t * xd, dpdk_per_thread_data_t * ptd,
255 dpdk_flow_lookup_entry_t *fle;
258 /* TODO prefetch and quad-loop */
259 for (n = 0; n < n_rx_packets; n++)
261 if ((ptd->flags[n] & (1 << PKT_RX_FDIR)) == 0)
264 fle = pool_elt_at_index (xd->flow_lookup_entries,
265 ptd->mbufs[n]->hash.fdir.hi);
267 if (fle->next_index != (u16) ~ 0)
268 ptd->next[n] = fle->next_index;
270 if (fle->flow_id != ~0)
272 b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]);
273 b0->flow_id = fle->flow_id;
276 if (fle->buffer_advance != ~0)
278 b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]);
279 vlib_buffer_advance (b0, fle->buffer_advance);
284 static_always_inline u32
285 dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd,
286 vlib_node_runtime_t * node, u32 thread_index, u16 queue_id)
288 uword n_rx_packets = 0, n_rx_bytes;
291 u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
292 struct rte_mbuf **mb;
299 dpdk_per_thread_data_t *ptd = vec_elt_at_index (dm->per_thread_data,
301 vlib_buffer_t *bt = &ptd->buffer_template;
303 if ((xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP) == 0)
306 /* get up to DPDK_RX_BURST_SZ buffers from PMD */
307 while (n_rx_packets < DPDK_RX_BURST_SZ)
309 n = rte_eth_rx_burst (xd->port_id, queue_id,
310 ptd->mbufs + n_rx_packets,
311 DPDK_RX_BURST_SZ - n_rx_packets);
318 if (n_rx_packets == 0)
321 /* Update buffer template */
322 vnet_buffer (bt)->sw_if_index[VLIB_RX] = xd->sw_if_index;
323 bt->error = node->errors[DPDK_ERROR_NONE];
324 /* as DPDK is allocating empty buffers from mempool provided before interface
325 start for each queue, it is safe to store this in the template */
326 bt->buffer_pool_index = xd->buffer_pool_for_queue[queue_id];
327 vnet_buffer (bt)->feature_arc_index = 0;
328 bt->current_config_index = 0;
330 /* receive burst of packets from DPDK PMD */
331 if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
332 next_index = xd->per_interface_next_index;
334 /* as all packets belong to the same interface feature arc lookup
335 can be don once and result stored in the buffer template */
336 if (PREDICT_FALSE (vnet_device_input_have_features (xd->sw_if_index)))
337 vnet_feature_start_device_input_x1 (xd->sw_if_index, &next_index, bt);
339 if (xd->flags & DPDK_DEVICE_FLAG_MAYBE_MULTISEG)
340 n_rx_bytes = dpdk_process_rx_burst (vm, ptd, n_rx_packets, 1, &or_flags);
342 n_rx_bytes = dpdk_process_rx_burst (vm, ptd, n_rx_packets, 0, &or_flags);
344 if (PREDICT_FALSE (or_flags & PKT_RX_FDIR))
346 /* some packets will need to go to different next nodes */
347 for (n = 0; n < n_rx_packets; n++)
348 ptd->next[n] = next_index;
350 /* flow offload - process if rx flow offload enabled and at least one
352 if (PREDICT_FALSE ((xd->flags & DPDK_DEVICE_FLAG_RX_FLOW_OFFLOAD) &&
353 (or_flags & PKT_RX_FDIR)))
354 dpdk_process_flow_offload (xd, ptd, n_rx_packets);
356 /* enqueue buffers to the next node */
357 vlib_get_buffer_indices_with_offset (vm, (void **) ptd->mbufs,
358 ptd->buffers, n_rx_packets,
359 sizeof (struct rte_mbuf));
361 vlib_buffer_enqueue_to_next (vm, node, ptd->buffers, ptd->next,
366 u32 *to_next, n_left_to_next;
368 vlib_get_new_next_frame (vm, node, next_index, to_next, n_left_to_next);
369 vlib_get_buffer_indices_with_offset (vm, (void **) ptd->mbufs, to_next,
371 sizeof (struct rte_mbuf));
373 if (PREDICT_TRUE (next_index == VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT))
375 vlib_next_frame_t *nf;
377 ethernet_input_frame_t *ef;
378 nf = vlib_node_runtime_get_next_frame (vm, node, next_index);
379 f = vlib_get_frame (vm, nf->frame_index);
380 f->flags = ETH_INPUT_FRAME_F_SINGLE_SW_IF_IDX;
382 ef = vlib_frame_scalar_args (f);
383 ef->sw_if_index = xd->sw_if_index;
384 ef->hw_if_index = xd->hw_if_index;
386 /* if PMD supports ip4 checksum check and there are no packets
387 marked as ip4 checksum bad we can notify ethernet input so it
388 can send pacets to ip4-input-no-checksum node */
389 if (xd->flags & DPDK_DEVICE_FLAG_RX_IP4_CKSUM &&
390 (or_flags & PKT_RX_IP_CKSUM_BAD) == 0)
391 f->flags |= ETH_INPUT_FRAME_F_IP4_CKSUM_OK;
393 n_left_to_next -= n_rx_packets;
394 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
398 /* packet trace if enabled */
399 if (PREDICT_FALSE ((n_trace = vlib_get_trace_count (vm, node))))
402 vlib_get_buffer_indices_with_offset (vm, (void **) ptd->mbufs,
403 ptd->buffers, n_rx_packets,
404 sizeof (struct rte_mbuf));
406 n_left = n_rx_packets;
407 buffers = ptd->buffers;
411 while (n_trace && n_left)
413 b0 = vlib_get_buffer (vm, buffers[0]);
414 if (single_next == 0)
415 next_index = next[0];
416 vlib_trace_buffer (vm, node, next_index, b0, /* follow_chain */ 0);
418 dpdk_rx_trace_t *t0 = vlib_add_trace (vm, node, b0, sizeof t0[0]);
419 t0->queue_index = queue_id;
420 t0->device_index = xd->device_index;
421 t0->buffer_index = vlib_get_buffer_index (vm, b0);
423 clib_memcpy_fast (&t0->mb, mb[0], sizeof t0->mb);
424 clib_memcpy_fast (&t0->buffer, b0,
425 sizeof b0[0] - sizeof b0->pre_data);
426 clib_memcpy_fast (t0->buffer.pre_data, b0->data,
427 sizeof t0->buffer.pre_data);
428 clib_memcpy_fast (&t0->data, mb[0]->buf_addr + mb[0]->data_off,
436 vlib_set_trace_count (vm, node, n_trace);
439 /* rx pcap capture if enabled */
440 if (PREDICT_FALSE (dm->pcap[VLIB_RX].pcap_enable))
443 n_left = n_rx_packets;
444 buffers = ptd->buffers;
448 b0 = vlib_get_buffer (vm, bi0);
451 if (dm->pcap[VLIB_RX].pcap_sw_if_index == 0 ||
452 dm->pcap[VLIB_RX].pcap_sw_if_index
453 == vnet_buffer (b0)->sw_if_index[VLIB_RX])
460 * Note: current_data will have advanced
461 * when we skip ethernet input.
462 * Temporarily back up to the original DMA
463 * target, so we capture a valid ethernet frame
465 mb = rte_mbuf_from_vlib_buffer (b0);
467 /* Figure out the original data_start */
468 data_start = (mb->buf_addr + mb->data_off) - (void *) b0->data;
469 /* Back up that far */
470 temp_advance = b0->current_data - data_start;
471 vlib_buffer_advance (b0, -temp_advance);
472 /* Trace the packet */
473 pcap_add_buffer (&dm->pcap[VLIB_RX].pcap_main, vm, bi0, 512);
474 /* and advance again */
475 vlib_buffer_advance (b0, temp_advance);
481 vlib_increment_combined_counter
482 (vnet_get_main ()->interface_main.combined_sw_if_counters
483 + VNET_INTERFACE_COUNTER_RX, thread_index, xd->sw_if_index,
484 n_rx_packets, n_rx_bytes);
486 vnet_device_increment_rx_packets (thread_index, n_rx_packets);
491 VLIB_NODE_FN (dpdk_input_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
494 dpdk_main_t *dm = &dpdk_main;
496 uword n_rx_packets = 0;
497 vnet_device_input_runtime_t *rt = (void *) node->runtime_data;
498 vnet_device_and_queue_t *dq;
499 u32 thread_index = node->thread_index;
502 * Poll all devices on this cpu for input/interrupts.
505 foreach_device_and_queue (dq, rt->devices_and_queues)
507 xd = vec_elt_at_index(dm->devices, dq->dev_instance);
508 if (PREDICT_FALSE (xd->flags & DPDK_DEVICE_FLAG_BOND_SLAVE))
509 continue; /* Do not poll slave to a bonded interface */
510 n_rx_packets += dpdk_device_input (vm, dm, xd, node, thread_index,
518 VLIB_REGISTER_NODE (dpdk_input_node) = {
519 .type = VLIB_NODE_TYPE_INPUT,
520 .name = "dpdk-input",
521 .sibling_of = "device-input",
523 /* Will be enabled if/when hardware is detected. */
524 .state = VLIB_NODE_STATE_DISABLED,
526 .format_buffer = format_ethernet_header_with_length,
527 .format_trace = format_dpdk_rx_trace,
529 .n_errors = DPDK_N_ERROR,
530 .error_strings = dpdk_error_strings,
535 * fd.io coding-style-patch-verification: ON
538 * eval: (c-set-style "gnu")