src/plugins/dpdk/device/node.c

   1 /*
   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:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   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.
  14  */
  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>
  20
  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>
  28
  29 #include <dpdk/device/dpdk_priv.h>
  30
  31 static char *dpdk_error_strings[] = {
  32 #define _(n,s) s,
  33   foreach_dpdk_error
  34 #undef _
  35 };
  36
  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");
  40
  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)
  44 {
  45   u8 nb_seg = 1;
  46   struct rte_mbuf *mb_seg = 0;
  47   vlib_buffer_t *b_seg, *b_chain = 0;
  48   mb_seg = mb->next;
  49   b_chain = b;
  50
  51   if (mb->nb_segs < 2)
  52     return 0;
  53
  54   b->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
  55   b->total_length_not_including_first_buffer = 0;
  56
  57   while (nb_seg < mb->nb_segs)
  58     {
  59       ASSERT (mb_seg != 0);
  60
  61       b_seg = vlib_buffer_from_rte_mbuf (mb_seg);
  62       vlib_buffer_init_for_free_list (b_seg, fl);
  63
  64       ASSERT ((b_seg->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
  65       ASSERT (b_seg->current_data == 0);
  66
  67       /*
  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.
  70        */
  71       b_seg->current_data =
  72         (mb_seg->buf_addr + mb_seg->data_off) - (void *) b_seg->data;
  73
  74       b_seg->current_length = mb_seg->data_len;
  75       b->total_length_not_including_first_buffer += mb_seg->data_len;
  76
  77       b_chain->flags |= VLIB_BUFFER_NEXT_PRESENT;
  78       b_chain->next_buffer = vlib_get_buffer_index (vm, b_seg);
  79
  80       b_chain = b_seg;
  81       mb_seg = mb_seg->next;
  82       nb_seg++;
  83     }
  84   return b->total_length_not_including_first_buffer;
  85 }
  86
  87 static_always_inline void
  88 dpdk_prefetch_mbuf_x4 (struct rte_mbuf *mb[])
  89 {
  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);
  94 }
  95
  96 static_always_inline void
  97 dpdk_prefetch_buffer_x4 (struct rte_mbuf *mb[])
  98 {
  99   vlib_buffer_t *b;
 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);
 108 }
 109
 110 /** \brief Main DPDK input node
 111     @node dpdk-input
 112
 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.
 120
 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.
 124
 125     @par Graph mechanics: buffer metadata, next index usage
 126
 127     @em Uses:
 128     - <code>struct rte_mbuf mb->ol_flags</code>
 129         - PKT_RX_IP_CKSUM_BAD
 130
 131     @em Sets:
 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.
 141
 142     <em>Next Nodes:</em>
 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>
 147 */
 148
 149 static_always_inline u8
 150 dpdk_ol_flags_extract (struct rte_mbuf **mb, u8 * flags, int count)
 151 {
 152   u8 rv = 0;
 153   int i;
 154   for (i = 0; i < count; i++)
 155     {
 156       /* all flags we are interested in are in lower 8 bits but
 157          that might change */
 158       flags[i] = (u8) mb[i]->ol_flags;
 159       rv |= flags[i];
 160     }
 161   return rv;
 162 }
 163
 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)
 167 {
 168   u32 n_left = n_rx_packets;
 169   vlib_buffer_t *b[4];
 170   vlib_buffer_free_list_t *fl;
 171   struct rte_mbuf **mb = ptd->mbufs;
 172   uword n_bytes = 0;
 173   u8 *flags, or_flags = 0;
 174
 175   if (maybe_multiseg)
 176     fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
 177
 178   mb = ptd->mbufs;
 179   flags = ptd->flags;
 180
 181   while (n_left >= 8)
 182     {
 183       dpdk_prefetch_buffer_x4 (mb + 4);
 184
 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]);
 189
 190       clib_memcpy64_x4 (b[0], b[1], b[2], b[3], &ptd->buffer_template);
 191
 192       dpdk_prefetch_mbuf_x4 (mb + 4);
 193
 194       or_flags |= dpdk_ol_flags_extract (mb, flags, 4);
 195       flags += 4;
 196
 197       b[0]->current_data = mb[0]->data_off - RTE_PKTMBUF_HEADROOM;
 198       n_bytes += b[0]->current_length = mb[0]->data_len;
 199
 200       b[1]->current_data = mb[1]->data_off - RTE_PKTMBUF_HEADROOM;
 201       n_bytes += b[1]->current_length = mb[1]->data_len;
 202
 203       b[2]->current_data = mb[2]->data_off - RTE_PKTMBUF_HEADROOM;
 204       n_bytes += b[2]->current_length = mb[2]->data_len;
 205
 206       b[3]->current_data = mb[3]->data_off - RTE_PKTMBUF_HEADROOM;
 207       n_bytes += b[3]->current_length = mb[3]->data_len;
 208
 209       if (maybe_multiseg)
 210         {
 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);
 215         }
 216
 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]);
 221
 222       /* next */
 223       mb += 4;
 224       n_left -= 4;
 225     }
 226
 227   while (n_left)
 228     {
 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);
 232       flags += 1;
 233
 234       b[0]->current_data = mb[0]->data_off - RTE_PKTMBUF_HEADROOM;
 235       n_bytes += b[0]->current_length = mb[0]->data_len;
 236
 237       if (maybe_multiseg)
 238         n_bytes += dpdk_process_subseq_segs (vm, b[0], mb[0], fl);
 239       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
 240
 241       /* next */
 242       mb += 1;
 243       n_left -= 1;
 244     }
 245
 246   *or_flagsp = or_flags;
 247   return n_bytes;
 248 }
 249
 250 static_always_inline void
 251 dpdk_process_flow_offload (dpdk_device_t * xd, dpdk_per_thread_data_t * ptd,
 252                            uword n_rx_packets)
 253 {
 254   uword n;
 255   dpdk_flow_lookup_entry_t *fle;
 256   vlib_buffer_t *b0;
 257
 258   /* TODO prefetch and quad-loop */
 259   for (n = 0; n < n_rx_packets; n++)
 260     {
 261       if ((ptd->flags[n] & (1 << PKT_RX_FDIR)) == 0)
 262         continue;
 263
 264       fle = pool_elt_at_index (xd->flow_lookup_entries,
 265                                ptd->mbufs[n]->hash.fdir.hi);
 266
 267       if (fle->next_index != (u16) ~ 0)
 268         ptd->next[n] = fle->next_index;
 269
 270       if (fle->flow_id != ~0)
 271         {
 272           b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]);
 273           b0->flow_id = fle->flow_id;
 274         }
 275
 276       if (fle->buffer_advance != ~0)
 277         {
 278           b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]);
 279           vlib_buffer_advance (b0, fle->buffer_advance);
 280         }
 281     }
 282 }
 283
 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)
 287 {
 288   uword n_rx_packets = 0, n_rx_bytes;
 289   u32 n_left, n_trace;
 290   u32 *buffers;
 291   u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 292   struct rte_mbuf **mb;
 293   vlib_buffer_t *b0;
 294   u16 *next;
 295   u8 or_flags;
 296   u32 n;
 297   int single_next = 0;
 298
 299   dpdk_per_thread_data_t *ptd = vec_elt_at_index (dm->per_thread_data,
 300                                                   thread_index);
 301   vlib_buffer_t *bt = &ptd->buffer_template;
 302
 303   if ((xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP) == 0)
 304     return 0;
 305
 306   /* get up to DPDK_RX_BURST_SZ buffers from PMD */
 307   while (n_rx_packets < DPDK_RX_BURST_SZ)
 308     {
 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);
 312       n_rx_packets += n;
 313
 314       if (n < 32)
 315         break;
 316     }
 317
 318   if (n_rx_packets == 0)
 319     return 0;
 320
 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;
 329
 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;
 333
 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);
 338
 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);
 341   else
 342     n_rx_bytes = dpdk_process_rx_burst (vm, ptd, n_rx_packets, 0, &or_flags);
 343
 344   if (PREDICT_FALSE (or_flags & (1 << PKT_RX_FDIR)))
 345     {
 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;
 349
 350       /* flow offload - process if rx flow offload enabled and at least one
 351          packet is marked */
 352       if (PREDICT_FALSE ((xd->flags & DPDK_DEVICE_FLAG_RX_FLOW_OFFLOAD) &&
 353                          (or_flags & (1 << PKT_RX_FDIR))))
 354         dpdk_process_flow_offload (xd, ptd, n_rx_packets);
 355
 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));
 360
 361       vlib_buffer_enqueue_to_next (vm, node, ptd->buffers, ptd->next,
 362                                    n_rx_packets);
 363     }
 364   else
 365     {
 366       u32 *to_next, n_left_to_next;
 367
 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,
 370                                            n_rx_packets,
 371                                            sizeof (struct rte_mbuf));
 372
 373       if (PREDICT_TRUE (next_index == VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT))
 374         {
 375           vlib_next_frame_t *nf;
 376           vlib_frame_t *f;
 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;
 381
 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;
 385
 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 & (1 << PKT_RX_IP_CKSUM_BAD)) == 0)
 391             f->flags |= ETH_INPUT_FRAME_F_IP4_CKSUM_OK;
 392         }
 393       n_left_to_next -= n_rx_packets;
 394       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 395       single_next = 1;
 396     }
 397
 398   /* packet trace if enabled */
 399   if (PREDICT_FALSE ((n_trace = vlib_get_trace_count (vm, node))))
 400     {
 401       if (single_next)
 402         vlib_get_buffer_indices_with_offset (vm, (void **) ptd->mbufs,
 403                                              ptd->buffers, n_rx_packets,
 404                                              sizeof (struct rte_mbuf));
 405
 406       n_left = n_rx_packets;
 407       buffers = ptd->buffers;
 408       mb = ptd->mbufs;
 409       next = ptd->next;
 410
 411       while (n_trace && n_left)
 412         {
 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);
 417
 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);
 422
 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,
 429                             sizeof t0->data);
 430           n_trace--;
 431           n_left--;
 432           buffers++;
 433           mb++;
 434           next++;
 435         }
 436       vlib_set_trace_count (vm, node, n_trace);
 437     }
 438
 439   /* rx pcap capture if enabled */
 440   if (PREDICT_FALSE (dm->pcap[VLIB_RX].pcap_enable))
 441     {
 442       u32 bi0;
 443       n_left = n_rx_packets;
 444       buffers = ptd->buffers;
 445       while (n_left)
 446         {
 447           bi0 = buffers[0];
 448           b0 = vlib_get_buffer (vm, bi0);
 449           buffers++;
 450
 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])
 454             {
 455               struct rte_mbuf *mb;
 456               i16 data_start;
 457               i32 temp_advance;
 458
 459               /*
 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
 464                */
 465               mb = rte_mbuf_from_vlib_buffer (b0);
 466
 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);
 476             }
 477           n_left--;
 478         }
 479     }
 480
 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);
 485
 486   vnet_device_increment_rx_packets (thread_index, n_rx_packets);
 487
 488   return n_rx_packets;
 489 }
 490
 491 VLIB_NODE_FN (dpdk_input_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
 492                                 vlib_frame_t * f)
 493 {
 494   dpdk_main_t *dm = &dpdk_main;
 495   dpdk_device_t *xd;
 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;
 500
 501   /*
 502    * Poll all devices on this cpu for input/interrupts.
 503    */
 504   /* *INDENT-OFF* */
 505   foreach_device_and_queue (dq, rt->devices_and_queues)
 506     {
 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,
 511                                          dq->queue_id);
 512     }
 513   /* *INDENT-ON* */
 514   return n_rx_packets;
 515 }
 516
 517 /* *INDENT-OFF* */
 518 VLIB_REGISTER_NODE (dpdk_input_node) = {
 519   .type = VLIB_NODE_TYPE_INPUT,
 520   .name = "dpdk-input",
 521   .sibling_of = "device-input",
 522
 523   /* Will be enabled if/when hardware is detected. */
 524   .state = VLIB_NODE_STATE_DISABLED,
 525
 526   .format_buffer = format_ethernet_header_with_length,
 527   .format_trace = format_dpdk_rx_trace,
 528
 529   .n_errors = DPDK_N_ERROR,
 530   .error_strings = dpdk_error_strings,
 531 };
 532 /* *INDENT-ON* */
 533
 534 /*
 535  * fd.io coding-style-patch-verification: ON
 536  *
 537  * Local Variables:
 538  * eval: (c-set-style "gnu")
 539  * End:
 540  */