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/buffer.h>
  23 #include <dpdk/device/dpdk.h>
  24 #include <vnet/classify/vnet_classify.h>
  25 #include <vnet/mpls/packet.h>
  26 #include <vnet/handoff.h>
  27 #include <vnet/devices/devices.h>
  28 #include <vnet/feature/feature.h>
  29
  30 #include <dpdk/device/dpdk_priv.h>
  31
  32 static char *dpdk_error_strings[] = {
  33 #define _(n,s) s,
  34   foreach_dpdk_error
  35 #undef _
  36 };
  37
  38 /* make sure all flags we need are stored in lower 8 bits */
  39 STATIC_ASSERT ((PKT_RX_IP_CKSUM_BAD | PKT_RX_FDIR) <
  40                256, "dpdk flags not un lower byte, fix needed");
  41
  42 static_always_inline uword
  43 dpdk_process_subseq_segs (vlib_main_t * vm, vlib_buffer_t * b,
  44                           struct rte_mbuf *mb, vlib_buffer_t * bt)
  45 {
  46   u8 nb_seg = 1;
  47   struct rte_mbuf *mb_seg = 0;
  48   vlib_buffer_t *b_seg, *b_chain = 0;
  49   mb_seg = mb->next;
  50   b_chain = b;
  51
  52   if (mb->nb_segs < 2)
  53     return 0;
  54
  55   b->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
  56   b->total_length_not_including_first_buffer = 0;
  57
  58   while (nb_seg < mb->nb_segs)
  59     {
  60       ASSERT (mb_seg != 0);
  61
  62       b_seg = vlib_buffer_from_rte_mbuf (mb_seg);
  63       vlib_buffer_copy_template (b_seg, bt);
  64
  65       /*
  66        * The driver (e.g. virtio) may not put the packet data at the start
  67        * of the segment, so don't assume b_seg->current_data == 0 is correct.
  68        */
  69       b_seg->current_data =
  70         (mb_seg->buf_addr + mb_seg->data_off) - (void *) b_seg->data;
  71
  72       b_seg->current_length = mb_seg->data_len;
  73       b->total_length_not_including_first_buffer += mb_seg->data_len;
  74
  75       b_chain->flags |= VLIB_BUFFER_NEXT_PRESENT;
  76       b_chain->next_buffer = vlib_get_buffer_index (vm, b_seg);
  77
  78       b_chain = b_seg;
  79       mb_seg = mb_seg->next;
  80       nb_seg++;
  81     }
  82   return b->total_length_not_including_first_buffer;
  83 }
  84
  85 static_always_inline void
  86 dpdk_prefetch_mbuf_x4 (struct rte_mbuf *mb[])
  87 {
  88   CLIB_PREFETCH (mb[0], CLIB_CACHE_LINE_BYTES, LOAD);
  89   CLIB_PREFETCH (mb[1], CLIB_CACHE_LINE_BYTES, LOAD);
  90   CLIB_PREFETCH (mb[2], CLIB_CACHE_LINE_BYTES, LOAD);
  91   CLIB_PREFETCH (mb[3], CLIB_CACHE_LINE_BYTES, LOAD);
  92 }
  93
  94 static_always_inline void
  95 dpdk_prefetch_buffer_x4 (struct rte_mbuf *mb[])
  96 {
  97   vlib_buffer_t *b;
  98   b = vlib_buffer_from_rte_mbuf (mb[0]);
  99   CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
 100   b = vlib_buffer_from_rte_mbuf (mb[1]);
 101   CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
 102   b = vlib_buffer_from_rte_mbuf (mb[2]);
 103   CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
 104   b = vlib_buffer_from_rte_mbuf (mb[3]);
 105   CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
 106 }
 107
 108 /** \brief Main DPDK input node
 109     @node dpdk-input
 110
 111     This is the main DPDK input node: across each assigned interface,
 112     call rte_eth_rx_burst(...) or similar to obtain a vector of
 113     packets to process. Derive @c vlib_buffer_t metadata from
 114     <code>struct rte_mbuf</code> metadata,
 115     Depending on the resulting metadata: adjust <code>b->current_data,
 116     b->current_length </code> and dispatch directly to
 117     ip4-input-no-checksum, or ip6-input. Trace the packet if required.
 118
 119     @param vm   vlib_main_t corresponding to the current thread
 120     @param node vlib_node_runtime_t
 121     @param f    vlib_frame_t input-node, not used.
 122
 123     @par Graph mechanics: buffer metadata, next index usage
 124
 125     @em Uses:
 126     - <code>struct rte_mbuf mb->ol_flags</code>
 127         - PKT_RX_IP_CKSUM_BAD
 128
 129     @em Sets:
 130     - <code>b->error</code> if the packet is to be dropped immediately
 131     - <code>b->current_data, b->current_length</code>
 132         - adjusted as needed to skip the L2 header in  direct-dispatch cases
 133     - <code>vnet_buffer(b)->sw_if_index[VLIB_RX]</code>
 134         - rx interface sw_if_index
 135     - <code>vnet_buffer(b)->sw_if_index[VLIB_TX] = ~0</code>
 136         - required by ipX-lookup
 137     - <code>b->flags</code>
 138         - to indicate multi-segment pkts (VLIB_BUFFER_NEXT_PRESENT), etc.
 139
 140     <em>Next Nodes:</em>
 141     - Static arcs to: error-drop, ethernet-input,
 142       ip4-input-no-checksum, ip6-input, mpls-input
 143     - per-interface redirection, controlled by
 144       <code>xd->per_interface_next_index</code>
 145 */
 146
 147 static_always_inline u16
 148 dpdk_ol_flags_extract (struct rte_mbuf **mb, u16 * flags, int count)
 149 {
 150   u16 rv = 0;
 151   int i;
 152   for (i = 0; i < count; i++)
 153     {
 154       /* all flags we are interested in are in lower 8 bits but
 155          that might change */
 156       flags[i] = (u16) mb[i]->ol_flags;
 157       rv |= flags[i];
 158     }
 159   return rv;
 160 }
 161
 162 static_always_inline uword
 163 dpdk_process_rx_burst (vlib_main_t * vm, dpdk_per_thread_data_t * ptd,
 164                        uword n_rx_packets, int maybe_multiseg,
 165                        u16 * or_flagsp)
 166 {
 167   u32 n_left = n_rx_packets;
 168   vlib_buffer_t *b[4];
 169   struct rte_mbuf **mb = ptd->mbufs;
 170   uword n_bytes = 0;
 171   u16 *flags, or_flags = 0;
 172   vlib_buffer_t bt;
 173
 174   mb = ptd->mbufs;
 175   flags = ptd->flags;
 176
 177   /* copy template into local variable - will save per packet load */
 178   vlib_buffer_copy_template (&bt, &ptd->buffer_template);
 179   while (n_left >= 8)
 180     {
 181       dpdk_prefetch_buffer_x4 (mb + 4);
 182
 183       b[0] = vlib_buffer_from_rte_mbuf (mb[0]);
 184       b[1] = vlib_buffer_from_rte_mbuf (mb[1]);
 185       b[2] = vlib_buffer_from_rte_mbuf (mb[2]);
 186       b[3] = vlib_buffer_from_rte_mbuf (mb[3]);
 187
 188       vlib_buffer_copy_template (b[0], &bt);
 189       vlib_buffer_copy_template (b[1], &bt);
 190       vlib_buffer_copy_template (b[2], &bt);
 191       vlib_buffer_copy_template (b[3], &bt);
 192
 193       dpdk_prefetch_mbuf_x4 (mb + 4);
 194
 195       or_flags |= dpdk_ol_flags_extract (mb, flags, 4);
 196       flags += 4;
 197
 198       b[0]->current_data = mb[0]->data_off - RTE_PKTMBUF_HEADROOM;
 199       n_bytes += b[0]->current_length = mb[0]->data_len;
 200
 201       b[1]->current_data = mb[1]->data_off - RTE_PKTMBUF_HEADROOM;
 202       n_bytes += b[1]->current_length = mb[1]->data_len;
 203
 204       b[2]->current_data = mb[2]->data_off - RTE_PKTMBUF_HEADROOM;
 205       n_bytes += b[2]->current_length = mb[2]->data_len;
 206
 207       b[3]->current_data = mb[3]->data_off - RTE_PKTMBUF_HEADROOM;
 208       n_bytes += b[3]->current_length = mb[3]->data_len;
 209
 210       if (maybe_multiseg)
 211         {
 212           n_bytes += dpdk_process_subseq_segs (vm, b[0], mb[0], &bt);
 213           n_bytes += dpdk_process_subseq_segs (vm, b[1], mb[1], &bt);
 214           n_bytes += dpdk_process_subseq_segs (vm, b[2], mb[2], &bt);
 215           n_bytes += dpdk_process_subseq_segs (vm, b[3], mb[3], &bt);
 216         }
 217
 218       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
 219       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[1]);
 220       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[2]);
 221       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[3]);
 222
 223       /* next */
 224       mb += 4;
 225       n_left -= 4;
 226     }
 227
 228   while (n_left)
 229     {
 230       b[0] = vlib_buffer_from_rte_mbuf (mb[0]);
 231       vlib_buffer_copy_template (b[0], &bt);
 232       or_flags |= dpdk_ol_flags_extract (mb, flags, 1);
 233       flags += 1;
 234
 235       b[0]->current_data = mb[0]->data_off - RTE_PKTMBUF_HEADROOM;
 236       n_bytes += b[0]->current_length = mb[0]->data_len;
 237
 238       if (maybe_multiseg)
 239         n_bytes += dpdk_process_subseq_segs (vm, b[0], mb[0], &bt);
 240       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
 241
 242       /* next */
 243       mb += 1;
 244       n_left -= 1;
 245     }
 246
 247   *or_flagsp = or_flags;
 248   return n_bytes;
 249 }
 250
 251 static_always_inline void
 252 dpdk_process_flow_offload (dpdk_device_t * xd, dpdk_per_thread_data_t * ptd,
 253                            uword n_rx_packets)
 254 {
 255   uword n;
 256   dpdk_flow_lookup_entry_t *fle;
 257   vlib_buffer_t *b0;
 258
 259   /* TODO prefetch and quad-loop */
 260   for (n = 0; n < n_rx_packets; n++)
 261     {
 262       if ((ptd->flags[n] & PKT_RX_FDIR_ID) == 0)
 263         continue;
 264
 265       fle = pool_elt_at_index (xd->flow_lookup_entries,
 266                                ptd->mbufs[n]->hash.fdir.hi);
 267
 268       if (fle->next_index != (u16) ~ 0)
 269         ptd->next[n] = fle->next_index;
 270
 271       if (fle->flow_id != ~0)
 272         {
 273           b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]);
 274           b0->flow_id = fle->flow_id;
 275         }
 276
 277       if (fle->buffer_advance != ~0)
 278         {
 279           b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]);
 280           vlib_buffer_advance (b0, fle->buffer_advance);
 281         }
 282     }
 283 }
 284
 285 static_always_inline u32
 286 dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd,
 287                    vlib_node_runtime_t * node, u32 thread_index, u16 queue_id)
 288 {
 289   uword n_rx_packets = 0, n_rx_bytes;
 290   u32 n_left, n_trace;
 291   u32 *buffers;
 292   u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 293   struct rte_mbuf **mb;
 294   vlib_buffer_t *b0;
 295   u16 *next;
 296   u16 or_flags;
 297   u32 n;
 298   int single_next = 0;
 299
 300   dpdk_per_thread_data_t *ptd = vec_elt_at_index (dm->per_thread_data,
 301                                                   thread_index);
 302   vlib_buffer_t *bt = &ptd->buffer_template;
 303
 304   if ((xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP) == 0)
 305     return 0;
 306
 307   /* get up to DPDK_RX_BURST_SZ buffers from PMD */
 308   while (n_rx_packets < DPDK_RX_BURST_SZ)
 309     {
 310       n = rte_eth_rx_burst (xd->port_id, queue_id,
 311                             ptd->mbufs + n_rx_packets,
 312                             DPDK_RX_BURST_SZ - n_rx_packets);
 313       n_rx_packets += n;
 314
 315       if (n < 32)
 316         break;
 317     }
 318
 319   if (n_rx_packets == 0)
 320     return 0;
 321
 322   /* Update buffer template */
 323   vnet_buffer (bt)->sw_if_index[VLIB_RX] = xd->sw_if_index;
 324   bt->error = node->errors[DPDK_ERROR_NONE];
 325   /* as DPDK is allocating empty buffers from mempool provided before interface
 326      start for each queue, it is safe to store this in the template */
 327   bt->buffer_pool_index = xd->buffer_pool_for_queue[queue_id];
 328   bt->ref_count = 1;
 329   vnet_buffer (bt)->feature_arc_index = 0;
 330   bt->current_config_index = 0;
 331
 332   /* receive burst of packets from DPDK PMD */
 333   if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
 334     next_index = xd->per_interface_next_index;
 335
 336   /* as all packets belong to the same interface feature arc lookup
 337      can be don once and result stored in the buffer template */
 338   if (PREDICT_FALSE (vnet_device_input_have_features (xd->sw_if_index)))
 339     vnet_feature_start_device_input_x1 (xd->sw_if_index, &next_index, bt);
 340
 341   if (xd->flags & DPDK_DEVICE_FLAG_MAYBE_MULTISEG)
 342     n_rx_bytes = dpdk_process_rx_burst (vm, ptd, n_rx_packets, 1, &or_flags);
 343   else
 344     n_rx_bytes = dpdk_process_rx_burst (vm, ptd, n_rx_packets, 0, &or_flags);
 345
 346   if (PREDICT_FALSE (or_flags & PKT_RX_FDIR))
 347     {
 348       /* some packets will need to go to different next nodes */
 349       for (n = 0; n < n_rx_packets; n++)
 350         ptd->next[n] = next_index;
 351
 352       /* flow offload - process if rx flow offload enabled and at least one
 353          packet is marked */
 354       if (PREDICT_FALSE ((xd->flags & DPDK_DEVICE_FLAG_RX_FLOW_OFFLOAD) &&
 355                          (or_flags & PKT_RX_FDIR)))
 356         dpdk_process_flow_offload (xd, ptd, n_rx_packets);
 357
 358       /* enqueue buffers to the next node */
 359       vlib_get_buffer_indices_with_offset (vm, (void **) ptd->mbufs,
 360                                            ptd->buffers, n_rx_packets,
 361                                            sizeof (struct rte_mbuf));
 362
 363       vlib_buffer_enqueue_to_next (vm, node, ptd->buffers, ptd->next,
 364                                    n_rx_packets);
 365     }
 366   else
 367     {
 368       u32 *to_next, n_left_to_next;
 369
 370       vlib_get_new_next_frame (vm, node, next_index, to_next, n_left_to_next);
 371       vlib_get_buffer_indices_with_offset (vm, (void **) ptd->mbufs, to_next,
 372                                            n_rx_packets,
 373                                            sizeof (struct rte_mbuf));
 374
 375       if (PREDICT_TRUE (next_index == VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT))
 376         {
 377           vlib_next_frame_t *nf;
 378           vlib_frame_t *f;
 379           ethernet_input_frame_t *ef;
 380           nf = vlib_node_runtime_get_next_frame (vm, node, next_index);
 381           f = vlib_get_frame (vm, nf->frame_index);
 382           f->flags = ETH_INPUT_FRAME_F_SINGLE_SW_IF_IDX;
 383
 384           ef = vlib_frame_scalar_args (f);
 385           ef->sw_if_index = xd->sw_if_index;
 386           ef->hw_if_index = xd->hw_if_index;
 387
 388           /* if PMD supports ip4 checksum check and there are no packets
 389              marked as ip4 checksum bad we can notify ethernet input so it
 390              can send pacets to ip4-input-no-checksum node */
 391           if (xd->flags & DPDK_DEVICE_FLAG_RX_IP4_CKSUM &&
 392               (or_flags & PKT_RX_IP_CKSUM_BAD) == 0)
 393             f->flags |= ETH_INPUT_FRAME_F_IP4_CKSUM_OK;
 394           vlib_frame_no_append (f);
 395         }
 396       n_left_to_next -= n_rx_packets;
 397       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 398       single_next = 1;
 399     }
 400
 401   /* packet trace if enabled */
 402   if (PREDICT_FALSE ((n_trace = vlib_get_trace_count (vm, node))))
 403     {
 404       if (single_next)
 405         vlib_get_buffer_indices_with_offset (vm, (void **) ptd->mbufs,
 406                                              ptd->buffers, n_rx_packets,
 407                                              sizeof (struct rte_mbuf));
 408
 409       n_left = n_rx_packets;
 410       buffers = ptd->buffers;
 411       mb = ptd->mbufs;
 412       next = ptd->next;
 413
 414       while (n_trace && n_left)
 415         {
 416           b0 = vlib_get_buffer (vm, buffers[0]);
 417           if (single_next == 0)
 418             next_index = next[0];
 419           vlib_trace_buffer (vm, node, next_index, b0, /* follow_chain */ 0);
 420
 421           dpdk_rx_trace_t *t0 = vlib_add_trace (vm, node, b0, sizeof t0[0]);
 422           t0->queue_index = queue_id;
 423           t0->device_index = xd->device_index;
 424           t0->buffer_index = vlib_get_buffer_index (vm, b0);
 425
 426           clib_memcpy_fast (&t0->mb, mb[0], sizeof t0->mb);
 427           clib_memcpy_fast (&t0->buffer, b0,
 428                             sizeof b0[0] - sizeof b0->pre_data);
 429           clib_memcpy_fast (t0->buffer.pre_data, b0->data,
 430                             sizeof t0->buffer.pre_data);
 431           clib_memcpy_fast (&t0->data, mb[0]->buf_addr + mb[0]->data_off,
 432                             sizeof t0->data);
 433           n_trace--;
 434           n_left--;
 435           buffers++;
 436           mb++;
 437           next++;
 438         }
 439       vlib_set_trace_count (vm, node, n_trace);
 440     }
 441
 442   vlib_increment_combined_counter
 443     (vnet_get_main ()->interface_main.combined_sw_if_counters
 444      + VNET_INTERFACE_COUNTER_RX, thread_index, xd->sw_if_index,
 445      n_rx_packets, n_rx_bytes);
 446
 447   vnet_device_increment_rx_packets (thread_index, n_rx_packets);
 448
 449   return n_rx_packets;
 450 }
 451
 452 VLIB_NODE_FN (dpdk_input_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
 453                                 vlib_frame_t * f)
 454 {
 455   dpdk_main_t *dm = &dpdk_main;
 456   dpdk_device_t *xd;
 457   uword n_rx_packets = 0;
 458   vnet_device_input_runtime_t *rt = (void *) node->runtime_data;
 459   vnet_device_and_queue_t *dq;
 460   u32 thread_index = node->thread_index;
 461
 462   /*
 463    * Poll all devices on this cpu for input/interrupts.
 464    */
 465   /* *INDENT-OFF* */
 466   foreach_device_and_queue (dq, rt->devices_and_queues)
 467     {
 468       xd = vec_elt_at_index(dm->devices, dq->dev_instance);
 469       if (PREDICT_FALSE (xd->flags & DPDK_DEVICE_FLAG_BOND_SLAVE))
 470         continue;       /* Do not poll slave to a bonded interface */
 471       n_rx_packets += dpdk_device_input (vm, dm, xd, node, thread_index,
 472                                          dq->queue_id);
 473     }
 474   /* *INDENT-ON* */
 475   return n_rx_packets;
 476 }
 477
 478 /* *INDENT-OFF* */
 479 VLIB_REGISTER_NODE (dpdk_input_node) = {
 480   .type = VLIB_NODE_TYPE_INPUT,
 481   .name = "dpdk-input",
 482   .sibling_of = "device-input",
 483
 484   /* Will be enabled if/when hardware is detected. */
 485   .state = VLIB_NODE_STATE_DISABLED,
 486
 487   .format_buffer = format_ethernet_header_with_length,
 488   .format_trace = format_dpdk_rx_trace,
 489
 490   .n_errors = DPDK_N_ERROR,
 491   .error_strings = dpdk_error_strings,
 492 };
 493 /* *INDENT-ON* */
 494
 495 /*
 496  * fd.io coding-style-patch-verification: ON
 497  *
 498  * Local Variables:
 499  * eval: (c-set-style "gnu")
 500  * End:
 501  */