X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2Fplugins%2Fdpdk%2Fdevice%2Fnode.c;h=b4600324551e2b946ba0d76dc5added7c58db340;hb=6a07348f4a5312310c01fdd5af937ce26580eb2d;hp=250ded5048c0049e202b2af2e671902eb4b5a7eb;hpb=e58041f242bf4bd120ecc9619b88348d80b94c17;p=vpp.git diff --git a/src/plugins/dpdk/device/node.c b/src/plugins/dpdk/device/node.c index 250ded5048c..b4600324551 100644 --- a/src/plugins/dpdk/device/node.c +++ b/src/plugins/dpdk/device/node.c @@ -19,12 +19,14 @@ #include #include +#include #include #include #include -#include #include +#include #include +#include #include @@ -34,9 +36,13 @@ static char *dpdk_error_strings[] = { #undef _ }; -/* make sure all flags we need are stored in lower 8 bits */ -STATIC_ASSERT ((PKT_RX_IP_CKSUM_BAD | PKT_RX_FDIR) < - 256, "dpdk flags not un lower byte, fix needed"); +/* make sure all flags we need are stored in lower 32 bits */ +STATIC_ASSERT ((u64) (RTE_MBUF_F_RX_IP_CKSUM_BAD | RTE_MBUF_F_RX_L4_CKSUM_BAD | + RTE_MBUF_F_RX_FDIR | RTE_MBUF_F_RX_LRO) < (1ULL << 32), + "dpdk flags not in lower word, fix needed"); + +STATIC_ASSERT (RTE_MBUF_F_RX_L4_CKSUM_BAD == (1ULL << 3), + "bit number of RTE_MBUF_F_RX_L4_CKSUM_BAD is no longer 3!"); static_always_inline uword dpdk_process_subseq_segs (vlib_main_t * vm, vlib_buffer_t * b, @@ -84,10 +90,10 @@ dpdk_process_subseq_segs (vlib_main_t * vm, vlib_buffer_t * b, static_always_inline void dpdk_prefetch_mbuf_x4 (struct rte_mbuf *mb[]) { - CLIB_PREFETCH (mb[0], CLIB_CACHE_LINE_BYTES, LOAD); - CLIB_PREFETCH (mb[1], CLIB_CACHE_LINE_BYTES, LOAD); - CLIB_PREFETCH (mb[2], CLIB_CACHE_LINE_BYTES, LOAD); - CLIB_PREFETCH (mb[3], CLIB_CACHE_LINE_BYTES, LOAD); + clib_prefetch_load (mb[0]); + clib_prefetch_load (mb[1]); + clib_prefetch_load (mb[2]); + clib_prefetch_load (mb[3]); } static_always_inline void @@ -95,13 +101,13 @@ dpdk_prefetch_buffer_x4 (struct rte_mbuf *mb[]) { vlib_buffer_t *b; b = vlib_buffer_from_rte_mbuf (mb[0]); - CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD); + clib_prefetch_store (b); b = vlib_buffer_from_rte_mbuf (mb[1]); - CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD); + clib_prefetch_store (b); b = vlib_buffer_from_rte_mbuf (mb[2]); - CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD); + clib_prefetch_store (b); b = vlib_buffer_from_rte_mbuf (mb[3]); - CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD); + clib_prefetch_store (b); } /** \brief Main DPDK input node @@ -123,18 +129,18 @@ dpdk_prefetch_buffer_x4 (struct rte_mbuf *mb[]) @em Uses: - struct rte_mbuf mb->ol_flags - - PKT_RX_IP_CKSUM_BAD + - RTE_MBUF_F_RX_IP_CKSUM_BAD @em Sets: - b->error if the packet is to be dropped immediately - b->current_data, b->current_length - - adjusted as needed to skip the L2 header in direct-dispatch cases + - adjusted as needed to skip the L2 header in direct-dispatch cases - vnet_buffer(b)->sw_if_index[VLIB_RX] - - rx interface sw_if_index + - rx interface sw_if_index - vnet_buffer(b)->sw_if_index[VLIB_TX] = ~0 - - required by ipX-lookup + - required by ipX-lookup - b->flags - - to indicate multi-segment pkts (VLIB_BUFFER_NEXT_PRESENT), etc. + - to indicate multi-segment pkts (VLIB_BUFFER_NEXT_PRESENT), etc. Next Nodes: - Static arcs to: error-drop, ethernet-input, @@ -143,30 +149,30 @@ dpdk_prefetch_buffer_x4 (struct rte_mbuf *mb[]) xd->per_interface_next_index */ -static_always_inline u8 -dpdk_ol_flags_extract (struct rte_mbuf **mb, u8 * flags, int count) +static_always_inline u32 +dpdk_ol_flags_extract (struct rte_mbuf **mb, u32 *flags, int count) { - u8 rv = 0; + u32 rv = 0; int i; for (i = 0; i < count; i++) { /* all flags we are interested in are in lower 8 bits but that might change */ - flags[i] = (u8) mb[i]->ol_flags; + flags[i] = (u32) mb[i]->ol_flags; rv |= flags[i]; } return rv; } static_always_inline uword -dpdk_process_rx_burst (vlib_main_t * vm, dpdk_per_thread_data_t * ptd, - uword n_rx_packets, int maybe_multiseg, u8 * or_flagsp) +dpdk_process_rx_burst (vlib_main_t *vm, dpdk_per_thread_data_t *ptd, + uword n_rx_packets, int maybe_multiseg, u32 *or_flagsp) { u32 n_left = n_rx_packets; vlib_buffer_t *b[4]; struct rte_mbuf **mb = ptd->mbufs; uword n_bytes = 0; - u8 *flags, or_flags = 0; + u32 *flags, or_flags = 0; vlib_buffer_t bt; mb = ptd->mbufs; @@ -213,11 +219,6 @@ dpdk_process_rx_burst (vlib_main_t * vm, dpdk_per_thread_data_t * ptd, n_bytes += dpdk_process_subseq_segs (vm, b[3], mb[3], &bt); } - VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]); - VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[1]); - VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[2]); - VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[3]); - /* next */ mb += 4; n_left -= 4; @@ -235,7 +236,6 @@ dpdk_process_rx_burst (vlib_main_t * vm, dpdk_per_thread_data_t * ptd, if (maybe_multiseg) n_bytes += dpdk_process_subseq_segs (vm, b[0], mb[0], &bt); - VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]); /* next */ mb += 1; @@ -257,7 +257,7 @@ dpdk_process_flow_offload (dpdk_device_t * xd, dpdk_per_thread_data_t * ptd, /* TODO prefetch and quad-loop */ for (n = 0; n < n_rx_packets; n++) { - if ((ptd->flags[n] & (1 << PKT_RX_FDIR)) == 0) + if ((ptd->flags[n] & RTE_MBUF_F_RX_FDIR_ID) == 0) continue; fle = pool_elt_at_index (xd->flow_lookup_entries, @@ -280,18 +280,78 @@ dpdk_process_flow_offload (dpdk_device_t * xd, dpdk_per_thread_data_t * ptd, } } +static_always_inline u16 +dpdk_lro_find_l4_hdr_sz (vlib_buffer_t *b) +{ + u16 l4_hdr_sz = 0; + u16 current_offset = 0; + ethernet_header_t *e; + tcp_header_t *tcp; + u8 *data = vlib_buffer_get_current (b); + u16 ethertype; + e = (void *) data; + current_offset += sizeof (e[0]); + ethertype = clib_net_to_host_u16 (e->type); + if (ethernet_frame_is_tagged (ethertype)) + { + ethernet_vlan_header_t *vlan = (ethernet_vlan_header_t *) (e + 1); + ethertype = clib_net_to_host_u16 (vlan->type); + current_offset += sizeof (*vlan); + if (ethertype == ETHERNET_TYPE_VLAN) + { + vlan++; + current_offset += sizeof (*vlan); + ethertype = clib_net_to_host_u16 (vlan->type); + } + } + data += current_offset; + if (ethertype == ETHERNET_TYPE_IP4) + { + data += sizeof (ip4_header_t); + tcp = (void *) data; + l4_hdr_sz = tcp_header_bytes (tcp); + } + else + { + /* FIXME: extension headers...*/ + data += sizeof (ip6_header_t); + tcp = (void *) data; + l4_hdr_sz = tcp_header_bytes (tcp); + } + return l4_hdr_sz; +} + +static_always_inline void +dpdk_process_lro_offload (dpdk_device_t *xd, dpdk_per_thread_data_t *ptd, + uword n_rx_packets) +{ + uword n; + vlib_buffer_t *b0; + for (n = 0; n < n_rx_packets; n++) + { + b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]); + if (ptd->flags[n] & RTE_MBUF_F_RX_LRO) + { + b0->flags |= VNET_BUFFER_F_GSO; + vnet_buffer2 (b0)->gso_size = ptd->mbufs[n]->tso_segsz; + vnet_buffer2 (b0)->gso_l4_hdr_sz = dpdk_lro_find_l4_hdr_sz (b0); + } + } +} + static_always_inline u32 dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd, vlib_node_runtime_t * node, u32 thread_index, u16 queue_id) { uword n_rx_packets = 0, n_rx_bytes; + dpdk_rx_queue_t *rxq = vec_elt_at_index (xd->rx_queues, queue_id); u32 n_left, n_trace; u32 *buffers; u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT; struct rte_mbuf **mb; vlib_buffer_t *b0; u16 *next; - u8 or_flags; + u32 or_flags; u32 n; int single_next = 0; @@ -305,12 +365,13 @@ dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd, /* get up to DPDK_RX_BURST_SZ buffers from PMD */ while (n_rx_packets < DPDK_RX_BURST_SZ) { - n = rte_eth_rx_burst (xd->port_id, queue_id, - ptd->mbufs + n_rx_packets, - DPDK_RX_BURST_SZ - n_rx_packets); + u32 n_to_rx = clib_min (DPDK_RX_BURST_SZ - n_rx_packets, 32); + + n = rte_eth_rx_burst (xd->port_id, queue_id, ptd->mbufs + n_rx_packets, + n_to_rx); n_rx_packets += n; - if (n < 32) + if (n < n_to_rx) break; } @@ -320,9 +381,11 @@ dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd, /* Update buffer template */ vnet_buffer (bt)->sw_if_index[VLIB_RX] = xd->sw_if_index; bt->error = node->errors[DPDK_ERROR_NONE]; + bt->flags = xd->buffer_flags; /* as DPDK is allocating empty buffers from mempool provided before interface start for each queue, it is safe to store this in the template */ - bt->buffer_pool_index = xd->buffer_pool_for_queue[queue_id]; + bt->buffer_pool_index = rxq->buffer_pool_index; + bt->ref_count = 1; vnet_buffer (bt)->feature_arc_index = 0; bt->current_config_index = 0; @@ -340,7 +403,27 @@ dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd, else n_rx_bytes = dpdk_process_rx_burst (vm, ptd, n_rx_packets, 0, &or_flags); - if (PREDICT_FALSE (or_flags & PKT_RX_FDIR)) + if (PREDICT_FALSE ((or_flags & RTE_MBUF_F_RX_LRO))) + dpdk_process_lro_offload (xd, ptd, n_rx_packets); + + if (PREDICT_FALSE ((or_flags & RTE_MBUF_F_RX_L4_CKSUM_BAD) && + (xd->buffer_flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT))) + { + for (n = 0; n < n_rx_packets; n++) + { + /* Check and reset VNET_BUFFER_F_L4_CHECKSUM_CORRECT flag + if RTE_MBUF_F_RX_L4_CKSUM_BAD is set. + The magic num 3 is the bit number of RTE_MBUF_F_RX_L4_CKSUM_BAD + which is defined in DPDK. + Have made a STATIC_ASSERT in this file to ensure this. + */ + b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]); + b0->flags ^= (ptd->flags[n] & RTE_MBUF_F_RX_L4_CKSUM_BAD) + << (VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT - 3); + } + } + + if (PREDICT_FALSE (or_flags & RTE_MBUF_F_RX_FDIR)) { /* some packets will need to go to different next nodes */ for (n = 0; n < n_rx_packets; n++) @@ -349,7 +432,7 @@ dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd, /* flow offload - process if rx flow offload enabled and at least one packet is marked */ if (PREDICT_FALSE ((xd->flags & DPDK_DEVICE_FLAG_RX_FLOW_OFFLOAD) && - (or_flags & PKT_RX_FDIR))) + (or_flags & RTE_MBUF_F_RX_FDIR))) dpdk_process_flow_offload (xd, ptd, n_rx_packets); /* enqueue buffers to the next node */ @@ -375,7 +458,7 @@ dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd, vlib_frame_t *f; ethernet_input_frame_t *ef; nf = vlib_node_runtime_get_next_frame (vm, node, next_index); - f = vlib_get_frame (vm, nf->frame_index); + f = vlib_get_frame (vm, nf->frame); f->flags = ETH_INPUT_FRAME_F_SINGLE_SW_IF_IDX; ef = vlib_frame_scalar_args (f); @@ -386,8 +469,9 @@ dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd, marked as ip4 checksum bad we can notify ethernet input so it can send pacets to ip4-input-no-checksum node */ if (xd->flags & DPDK_DEVICE_FLAG_RX_IP4_CKSUM && - (or_flags & PKT_RX_IP_CKSUM_BAD) == 0) + (or_flags & RTE_MBUF_F_RX_IP_CKSUM_BAD) == 0) f->flags |= ETH_INPUT_FRAME_F_IP4_CKSUM_OK; + vlib_frame_no_append (f); } n_left_to_next -= n_rx_packets; vlib_put_next_frame (vm, node, next_index, n_left_to_next); @@ -412,21 +496,28 @@ dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd, b0 = vlib_get_buffer (vm, buffers[0]); if (single_next == 0) next_index = next[0]; - vlib_trace_buffer (vm, node, next_index, b0, /* follow_chain */ 0); - - dpdk_rx_trace_t *t0 = vlib_add_trace (vm, node, b0, sizeof t0[0]); - t0->queue_index = queue_id; - t0->device_index = xd->device_index; - t0->buffer_index = vlib_get_buffer_index (vm, b0); - - clib_memcpy_fast (&t0->mb, mb[0], sizeof t0->mb); - clib_memcpy_fast (&t0->buffer, b0, - sizeof b0[0] - sizeof b0->pre_data); - clib_memcpy_fast (t0->buffer.pre_data, b0->data, - sizeof t0->buffer.pre_data); - clib_memcpy_fast (&t0->data, mb[0]->buf_addr + mb[0]->data_off, - sizeof t0->data); - n_trace--; + + if (PREDICT_TRUE + (vlib_trace_buffer + (vm, node, next_index, b0, /* follow_chain */ 0))) + { + + dpdk_rx_trace_t *t0 = + vlib_add_trace (vm, node, b0, sizeof t0[0]); + t0->queue_index = queue_id; + t0->device_index = xd->device_index; + t0->buffer_index = vlib_get_buffer_index (vm, b0); + + clib_memcpy_fast (&t0->mb, mb[0], sizeof t0->mb); + clib_memcpy_fast (&t0->buffer, b0, + sizeof b0[0] - sizeof b0->pre_data); + clib_memcpy_fast (t0->buffer.pre_data, b0->data, + sizeof t0->buffer.pre_data); + clib_memcpy_fast (&t0->data, mb[0]->buf_addr + mb[0]->data_off, + sizeof t0->data); + n_trace--; + } + n_left--; buffers++; mb++; @@ -435,48 +526,6 @@ dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd, vlib_set_trace_count (vm, node, n_trace); } - /* rx pcap capture if enabled */ - if (PREDICT_FALSE (dm->pcap[VLIB_RX].pcap_enable)) - { - u32 bi0; - n_left = n_rx_packets; - buffers = ptd->buffers; - while (n_left) - { - bi0 = buffers[0]; - b0 = vlib_get_buffer (vm, bi0); - buffers++; - - if (dm->pcap[VLIB_RX].pcap_sw_if_index == 0 || - dm->pcap[VLIB_RX].pcap_sw_if_index - == vnet_buffer (b0)->sw_if_index[VLIB_RX]) - { - struct rte_mbuf *mb; - i16 data_start; - i32 temp_advance; - - /* - * Note: current_data will have advanced - * when we skip ethernet input. - * Temporarily back up to the original DMA - * target, so we capture a valid ethernet frame - */ - mb = rte_mbuf_from_vlib_buffer (b0); - - /* Figure out the original data_start */ - data_start = (mb->buf_addr + mb->data_off) - (void *) b0->data; - /* Back up that far */ - temp_advance = b0->current_data - data_start; - vlib_buffer_advance (b0, -temp_advance); - /* Trace the packet */ - pcap_add_buffer (&dm->pcap[VLIB_RX].pcap_main, vm, bi0, 512); - /* and advance again */ - vlib_buffer_advance (b0, temp_advance); - } - n_left--; - } - } - vlib_increment_combined_counter (vnet_get_main ()->interface_main.combined_sw_if_counters + VNET_INTERFACE_COUNTER_RX, thread_index, xd->sw_if_index, @@ -493,23 +542,21 @@ VLIB_NODE_FN (dpdk_input_node) (vlib_main_t * vm, vlib_node_runtime_t * node, dpdk_main_t *dm = &dpdk_main; dpdk_device_t *xd; uword n_rx_packets = 0; - vnet_device_input_runtime_t *rt = (void *) node->runtime_data; - vnet_device_and_queue_t *dq; - u32 thread_index = node->thread_index; + vnet_hw_if_rxq_poll_vector_t *pv; + u32 thread_index = vm->thread_index; /* * Poll all devices on this cpu for input/interrupts. */ - /* *INDENT-OFF* */ - foreach_device_and_queue (dq, rt->devices_and_queues) + + pv = vnet_hw_if_get_rxq_poll_vector (vm, node); + + for (int i = 0; i < vec_len (pv); i++) { - xd = vec_elt_at_index(dm->devices, dq->dev_instance); - if (PREDICT_FALSE (xd->flags & DPDK_DEVICE_FLAG_BOND_SLAVE)) - continue; /* Do not poll slave to a bonded interface */ - n_rx_packets += dpdk_device_input (vm, dm, xd, node, thread_index, - dq->queue_id); + xd = vec_elt_at_index (dm->devices, pv[i].dev_instance); + n_rx_packets += + dpdk_device_input (vm, dm, xd, node, thread_index, pv[i].queue_id); } - /* *INDENT-ON* */ return n_rx_packets; } @@ -518,6 +565,7 @@ VLIB_REGISTER_NODE (dpdk_input_node) = { .type = VLIB_NODE_TYPE_INPUT, .name = "dpdk-input", .sibling_of = "device-input", + .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED, /* Will be enabled if/when hardware is detected. */ .state = VLIB_NODE_STATE_DISABLED,