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 #ifndef CLIB_MULTIARCH_VARIANT
  32 static char *dpdk_error_strings[] = {
  33 #define _(n,s) s,
  34   foreach_dpdk_error
  35 #undef _
  36 };
  37 #endif
  38
  39 always_inline u32
  40 dpdk_rx_next_from_etype (struct rte_mbuf *mb)
  41 {
  42   ethernet_header_t *h = rte_pktmbuf_mtod (mb, ethernet_header_t *);
  43   if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP4)))
  44     {
  45       if (PREDICT_TRUE ((mb->ol_flags & PKT_RX_IP_CKSUM_GOOD) != 0))
  46         return VNET_DEVICE_INPUT_NEXT_IP4_NCS_INPUT;
  47       else
  48         return VNET_DEVICE_INPUT_NEXT_IP4_INPUT;
  49     }
  50   else if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP6)))
  51     return VNET_DEVICE_INPUT_NEXT_IP6_INPUT;
  52   else
  53     if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_MPLS)))
  54     return VNET_DEVICE_INPUT_NEXT_MPLS_INPUT;
  55   else
  56     return VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
  57 }
  58
  59 always_inline void
  60 dpdk_rx_error_from_mb (struct rte_mbuf *mb, u32 * next, u8 * error)
  61 {
  62   if (mb->ol_flags & PKT_RX_IP_CKSUM_BAD)
  63     {
  64       *error = DPDK_ERROR_IP_CHECKSUM_ERROR;
  65       *next = VNET_DEVICE_INPUT_NEXT_DROP;
  66     }
  67   else
  68     *error = DPDK_ERROR_NONE;
  69 }
  70
  71 static void
  72 dpdk_rx_trace (dpdk_main_t * dm,
  73                vlib_node_runtime_t * node,
  74                dpdk_device_t * xd,
  75                u16 queue_id, u32 * buffers, uword n_buffers)
  76 {
  77   vlib_main_t *vm = vlib_get_main ();
  78   u32 *b, n_left;
  79   u32 next0;
  80
  81   n_left = n_buffers;
  82   b = buffers;
  83
  84   while (n_left >= 1)
  85     {
  86       u32 bi0;
  87       vlib_buffer_t *b0;
  88       dpdk_rx_dma_trace_t *t0;
  89       struct rte_mbuf *mb;
  90       u8 error0;
  91
  92       bi0 = b[0];
  93       n_left -= 1;
  94
  95       b0 = vlib_get_buffer (vm, bi0);
  96       mb = rte_mbuf_from_vlib_buffer (b0);
  97
  98       if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
  99         next0 = xd->per_interface_next_index;
 100       else
 101         next0 = dpdk_rx_next_from_etype (mb);
 102
 103       dpdk_rx_error_from_mb (mb, &next0, &error0);
 104
 105       vlib_trace_buffer (vm, node, next0, b0, /* follow_chain */ 0);
 106       t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
 107       t0->queue_index = queue_id;
 108       t0->device_index = xd->device_index;
 109       t0->buffer_index = bi0;
 110
 111       clib_memcpy (&t0->mb, mb, sizeof (t0->mb));
 112       clib_memcpy (&t0->buffer, b0, sizeof (b0[0]) - sizeof (b0->pre_data));
 113       clib_memcpy (t0->buffer.pre_data, b0->data,
 114                    sizeof (t0->buffer.pre_data));
 115       clib_memcpy (&t0->data, mb->buf_addr + mb->data_off, sizeof (t0->data));
 116
 117       b += 1;
 118     }
 119 }
 120
 121 static inline u32
 122 dpdk_rx_burst (dpdk_main_t * dm, dpdk_device_t * xd, u16 queue_id)
 123 {
 124   u32 n_buffers;
 125   u32 n_left;
 126   u32 n_this_chunk;
 127
 128   n_left = VLIB_FRAME_SIZE;
 129   n_buffers = 0;
 130
 131   if (PREDICT_TRUE (xd->flags & DPDK_DEVICE_FLAG_PMD))
 132     {
 133       while (n_left)
 134         {
 135           n_this_chunk = rte_eth_rx_burst (xd->device_index, queue_id,
 136                                            xd->rx_vectors[queue_id] +
 137                                            n_buffers, n_left);
 138           n_buffers += n_this_chunk;
 139           n_left -= n_this_chunk;
 140
 141           /* Empirically, DPDK r1.8 produces vectors w/ 32 or fewer elts */
 142           if (n_this_chunk < 32)
 143             break;
 144         }
 145     }
 146   else
 147     {
 148       ASSERT (0);
 149     }
 150
 151   return n_buffers;
 152 }
 153
 154
 155 static_always_inline void
 156 dpdk_process_subseq_segs (vlib_main_t * vm, vlib_buffer_t * b,
 157                           struct rte_mbuf *mb, vlib_buffer_free_list_t * fl)
 158 {
 159   u8 nb_seg = 1;
 160   struct rte_mbuf *mb_seg = 0;
 161   vlib_buffer_t *b_seg, *b_chain = 0;
 162   mb_seg = mb->next;
 163   b_chain = b;
 164
 165   if (mb->nb_segs < 2)
 166     return;
 167
 168   b->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
 169   b->total_length_not_including_first_buffer = 0;
 170
 171   while (nb_seg < mb->nb_segs)
 172     {
 173       ASSERT (mb_seg != 0);
 174
 175       b_seg = vlib_buffer_from_rte_mbuf (mb_seg);
 176       vlib_buffer_init_for_free_list (b_seg, fl);
 177
 178       ASSERT ((b_seg->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
 179       ASSERT (b_seg->current_data == 0);
 180
 181       /*
 182        * The driver (e.g. virtio) may not put the packet data at the start
 183        * of the segment, so don't assume b_seg->current_data == 0 is correct.
 184        */
 185       b_seg->current_data =
 186         (mb_seg->buf_addr + mb_seg->data_off) - (void *) b_seg->data;
 187
 188       b_seg->current_length = mb_seg->data_len;
 189       b->total_length_not_including_first_buffer += mb_seg->data_len;
 190
 191       b_chain->flags |= VLIB_BUFFER_NEXT_PRESENT;
 192       b_chain->next_buffer = vlib_get_buffer_index (vm, b_seg);
 193
 194       b_chain = b_seg;
 195       mb_seg = mb_seg->next;
 196       nb_seg++;
 197     }
 198 }
 199
 200 static_always_inline void
 201 dpdk_prefetch_buffer (struct rte_mbuf *mb)
 202 {
 203   vlib_buffer_t *b = vlib_buffer_from_rte_mbuf (mb);
 204   CLIB_PREFETCH (mb, CLIB_CACHE_LINE_BYTES, LOAD);
 205   CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, STORE);
 206 }
 207
 208 static_always_inline void
 209 dpdk_prefetch_ethertype (struct rte_mbuf *mb)
 210 {
 211   CLIB_PREFETCH (mb->buf_addr + mb->data_off +
 212                  STRUCT_OFFSET_OF (ethernet_header_t, type),
 213                  CLIB_CACHE_LINE_BYTES, LOAD);
 214 }
 215
 216 /*
 217  * This function is used when there are no worker threads.
 218  * The main thread performs IO and forwards the packets.
 219  */
 220 static_always_inline u32
 221 dpdk_device_input (dpdk_main_t * dm, dpdk_device_t * xd,
 222                    vlib_node_runtime_t * node, u32 thread_index, u16 queue_id,
 223                    int maybe_multiseg)
 224 {
 225   u32 n_buffers;
 226   u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 227   u32 n_left_to_next, *to_next;
 228   u32 mb_index;
 229   vlib_main_t *vm = vlib_get_main ();
 230   uword n_rx_bytes = 0;
 231   u32 n_trace, trace_cnt __attribute__ ((unused));
 232   vlib_buffer_free_list_t *fl;
 233   vlib_buffer_t *bt = vec_elt_at_index (dm->buffer_templates, thread_index);
 234
 235   if ((xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP) == 0)
 236     return 0;
 237
 238   n_buffers = dpdk_rx_burst (dm, xd, queue_id);
 239
 240   if (n_buffers == 0)
 241     {
 242       return 0;
 243     }
 244
 245   vec_reset_length (xd->d_trace_buffers[thread_index]);
 246   trace_cnt = n_trace = vlib_get_trace_count (vm, node);
 247
 248   if (n_trace > 0)
 249     {
 250       u32 n = clib_min (n_trace, n_buffers);
 251       mb_index = 0;
 252
 253       while (n--)
 254         {
 255           struct rte_mbuf *mb = xd->rx_vectors[queue_id][mb_index++];
 256           vlib_buffer_t *b = vlib_buffer_from_rte_mbuf (mb);
 257           vec_add1 (xd->d_trace_buffers[thread_index],
 258                     vlib_get_buffer_index (vm, b));
 259         }
 260     }
 261
 262   fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
 263
 264   /* Update buffer template */
 265   vnet_buffer (bt)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
 266   bt->error = node->errors[DPDK_ERROR_NONE];
 267   /* as DPDK is allocating empty buffers from mempool provided before interface
 268      start for each queue, it is safe to store this in the template */
 269   bt->buffer_pool_index = xd->buffer_pool_for_queue[queue_id];
 270
 271   mb_index = 0;
 272
 273   while (n_buffers > 0)
 274     {
 275       vlib_buffer_t *b0, *b1, *b2, *b3;
 276       u32 bi0, next0;
 277       u32 bi1, next1;
 278       u32 bi2, next2;
 279       u32 bi3, next3;
 280       u8 error0, error1, error2, error3;
 281       i16 offset0, offset1, offset2, offset3;
 282       u64 or_ol_flags;
 283
 284       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 285
 286       while (n_buffers >= 12 && n_left_to_next >= 4)
 287         {
 288           struct rte_mbuf *mb0, *mb1, *mb2, *mb3;
 289
 290           /* prefetches are interleaved with the rest of the code to reduce
 291              pressure on L1 cache */
 292           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 8]);
 293           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 4]);
 294
 295           mb0 = xd->rx_vectors[queue_id][mb_index];
 296           mb1 = xd->rx_vectors[queue_id][mb_index + 1];
 297           mb2 = xd->rx_vectors[queue_id][mb_index + 2];
 298           mb3 = xd->rx_vectors[queue_id][mb_index + 3];
 299
 300           ASSERT (mb0);
 301           ASSERT (mb1);
 302           ASSERT (mb2);
 303           ASSERT (mb3);
 304
 305           if (maybe_multiseg)
 306             {
 307               if (PREDICT_FALSE (mb0->nb_segs > 1))
 308                 dpdk_prefetch_buffer (mb0->next);
 309               if (PREDICT_FALSE (mb1->nb_segs > 1))
 310                 dpdk_prefetch_buffer (mb1->next);
 311               if (PREDICT_FALSE (mb2->nb_segs > 1))
 312                 dpdk_prefetch_buffer (mb2->next);
 313               if (PREDICT_FALSE (mb3->nb_segs > 1))
 314                 dpdk_prefetch_buffer (mb3->next);
 315             }
 316
 317           b0 = vlib_buffer_from_rte_mbuf (mb0);
 318           b1 = vlib_buffer_from_rte_mbuf (mb1);
 319           b2 = vlib_buffer_from_rte_mbuf (mb2);
 320           b3 = vlib_buffer_from_rte_mbuf (mb3);
 321
 322           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 9]);
 323           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 5]);
 324
 325           clib_memcpy64_x4 (b0, b1, b2, b3, bt);
 326
 327           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 10]);
 328           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 7]);
 329
 330           bi0 = vlib_get_buffer_index (vm, b0);
 331           bi1 = vlib_get_buffer_index (vm, b1);
 332           bi2 = vlib_get_buffer_index (vm, b2);
 333           bi3 = vlib_get_buffer_index (vm, b3);
 334
 335           to_next[0] = bi0;
 336           to_next[1] = bi1;
 337           to_next[2] = bi2;
 338           to_next[3] = bi3;
 339           to_next += 4;
 340           n_left_to_next -= 4;
 341
 342           if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
 343             {
 344               next0 = next1 = next2 = next3 = xd->per_interface_next_index;
 345             }
 346           else
 347             {
 348               next0 = dpdk_rx_next_from_etype (mb0);
 349               next1 = dpdk_rx_next_from_etype (mb1);
 350               next2 = dpdk_rx_next_from_etype (mb2);
 351               next3 = dpdk_rx_next_from_etype (mb3);
 352             }
 353
 354           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 11]);
 355           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 6]);
 356
 357           or_ol_flags = (mb0->ol_flags | mb1->ol_flags |
 358                          mb2->ol_flags | mb3->ol_flags);
 359           if (PREDICT_FALSE (or_ol_flags & PKT_RX_IP_CKSUM_BAD))
 360             {
 361               dpdk_rx_error_from_mb (mb0, &next0, &error0);
 362               dpdk_rx_error_from_mb (mb1, &next1, &error1);
 363               dpdk_rx_error_from_mb (mb2, &next2, &error2);
 364               dpdk_rx_error_from_mb (mb3, &next3, &error3);
 365               b0->error = node->errors[error0];
 366               b1->error = node->errors[error1];
 367               b2->error = node->errors[error2];
 368               b3->error = node->errors[error3];
 369             }
 370
 371           offset0 = device_input_next_node_advance[next0];
 372           b0->current_data = mb0->data_off + offset0 - RTE_PKTMBUF_HEADROOM;
 373           b0->flags |= device_input_next_node_flags[next0];
 374           vnet_buffer (b0)->l3_hdr_offset = b0->current_data;
 375           vnet_buffer (b0)->l2_hdr_offset =
 376             mb0->data_off - RTE_PKTMBUF_HEADROOM;
 377           b0->current_length = mb0->data_len - offset0;
 378           n_rx_bytes += mb0->pkt_len;
 379
 380           offset1 = device_input_next_node_advance[next1];
 381           b1->current_data = mb1->data_off + offset1 - RTE_PKTMBUF_HEADROOM;
 382           b1->flags |= device_input_next_node_flags[next1];
 383           vnet_buffer (b1)->l3_hdr_offset = b1->current_data;
 384           vnet_buffer (b1)->l2_hdr_offset =
 385             mb1->data_off - RTE_PKTMBUF_HEADROOM;
 386           b1->current_length = mb1->data_len - offset1;
 387           n_rx_bytes += mb1->pkt_len;
 388
 389           offset2 = device_input_next_node_advance[next2];
 390           b2->current_data = mb2->data_off + offset2 - RTE_PKTMBUF_HEADROOM;
 391           b2->flags |= device_input_next_node_flags[next2];
 392           vnet_buffer (b2)->l3_hdr_offset = b2->current_data;
 393           vnet_buffer (b2)->l2_hdr_offset =
 394             mb2->data_off - RTE_PKTMBUF_HEADROOM;
 395           b2->current_length = mb2->data_len - offset2;
 396           n_rx_bytes += mb2->pkt_len;
 397
 398           offset3 = device_input_next_node_advance[next3];
 399           b3->current_data = mb3->data_off + offset3 - RTE_PKTMBUF_HEADROOM;
 400           b3->flags |= device_input_next_node_flags[next3];
 401           vnet_buffer (b3)->l3_hdr_offset = b3->current_data;
 402           vnet_buffer (b3)->l2_hdr_offset =
 403             mb3->data_off - RTE_PKTMBUF_HEADROOM;
 404           b3->current_length = mb3->data_len - offset3;
 405           n_rx_bytes += mb3->pkt_len;
 406
 407
 408           /* Process subsequent segments of multi-segment packets */
 409           if (maybe_multiseg)
 410             {
 411               dpdk_process_subseq_segs (vm, b0, mb0, fl);
 412               dpdk_process_subseq_segs (vm, b1, mb1, fl);
 413               dpdk_process_subseq_segs (vm, b2, mb2, fl);
 414               dpdk_process_subseq_segs (vm, b3, mb3, fl);
 415             }
 416
 417           /*
 418            * Turn this on if you run into
 419            * "bad monkey" contexts, and you want to know exactly
 420            * which nodes they've visited... See main.c...
 421            */
 422           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 423           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b1);
 424           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b2);
 425           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b3);
 426
 427           /* Do we have any driver RX features configured on the interface? */
 428           vnet_feature_start_device_input_x4 (xd->vlib_sw_if_index,
 429                                               &next0, &next1, &next2, &next3,
 430                                               b0, b1, b2, b3);
 431
 432           vlib_validate_buffer_enqueue_x4 (vm, node, next_index,
 433                                            to_next, n_left_to_next,
 434                                            bi0, bi1, bi2, bi3,
 435                                            next0, next1, next2, next3);
 436           n_buffers -= 4;
 437           mb_index += 4;
 438         }
 439       while (n_buffers > 0 && n_left_to_next > 0)
 440         {
 441           struct rte_mbuf *mb0 = xd->rx_vectors[queue_id][mb_index];
 442
 443           if (PREDICT_TRUE (n_buffers > 3))
 444             {
 445               dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 2]);
 446               dpdk_prefetch_ethertype (xd->rx_vectors[queue_id]
 447                                        [mb_index + 1]);
 448             }
 449
 450           ASSERT (mb0);
 451
 452           b0 = vlib_buffer_from_rte_mbuf (mb0);
 453
 454           /* Prefetch one next segment if it exists. */
 455           if (PREDICT_FALSE (mb0->nb_segs > 1))
 456             dpdk_prefetch_buffer (mb0->next);
 457
 458           clib_memcpy (b0, bt, CLIB_CACHE_LINE_BYTES);
 459
 460           bi0 = vlib_get_buffer_index (vm, b0);
 461
 462           to_next[0] = bi0;
 463           to_next++;
 464           n_left_to_next--;
 465
 466           if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
 467             next0 = xd->per_interface_next_index;
 468           else
 469             next0 = dpdk_rx_next_from_etype (mb0);
 470
 471           dpdk_rx_error_from_mb (mb0, &next0, &error0);
 472           b0->error = node->errors[error0];
 473
 474           offset0 = device_input_next_node_advance[next0];
 475           b0->current_data = mb0->data_off + offset0 - RTE_PKTMBUF_HEADROOM;
 476           b0->flags |= device_input_next_node_flags[next0];
 477           vnet_buffer (b0)->l3_hdr_offset = b0->current_data;
 478           vnet_buffer (b0)->l2_hdr_offset =
 479             mb0->data_off - RTE_PKTMBUF_HEADROOM;
 480           b0->current_length = mb0->data_len - offset0;
 481           n_rx_bytes += mb0->pkt_len;
 482
 483           /* Process subsequent segments of multi-segment packets */
 484           dpdk_process_subseq_segs (vm, b0, mb0, fl);
 485
 486           /*
 487            * Turn this on if you run into
 488            * "bad monkey" contexts, and you want to know exactly
 489            * which nodes they've visited... See main.c...
 490            */
 491           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 492
 493           /* Do we have any driver RX features configured on the interface? */
 494           vnet_feature_start_device_input_x1 (xd->vlib_sw_if_index, &next0,
 495                                               b0);
 496
 497           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 498                                            to_next, n_left_to_next,
 499                                            bi0, next0);
 500           n_buffers--;
 501           mb_index++;
 502         }
 503       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 504     }
 505
 506   if (PREDICT_FALSE (vec_len (xd->d_trace_buffers[thread_index]) > 0))
 507     {
 508       dpdk_rx_trace (dm, node, xd, queue_id,
 509                      xd->d_trace_buffers[thread_index],
 510                      vec_len (xd->d_trace_buffers[thread_index]));
 511       vlib_set_trace_count (vm, node,
 512                             n_trace -
 513                             vec_len (xd->d_trace_buffers[thread_index]));
 514     }
 515
 516   vlib_increment_combined_counter
 517     (vnet_get_main ()->interface_main.combined_sw_if_counters
 518      + VNET_INTERFACE_COUNTER_RX,
 519      thread_index, xd->vlib_sw_if_index, mb_index, n_rx_bytes);
 520
 521   vnet_device_increment_rx_packets (thread_index, mb_index);
 522
 523   return mb_index;
 524 }
 525
 526 static inline void
 527 poll_rate_limit (dpdk_main_t * dm)
 528 {
 529   /* Limit the poll rate by sleeping for N msec between polls */
 530   if (PREDICT_FALSE (dm->poll_sleep_usec != 0))
 531     {
 532       struct timespec ts, tsrem;
 533
 534       ts.tv_sec = 0;
 535       ts.tv_nsec = 1000 * dm->poll_sleep_usec;
 536
 537       while (nanosleep (&ts, &tsrem) < 0)
 538         {
 539           ts = tsrem;
 540         }
 541     }
 542 }
 543
 544 /** \brief Main DPDK input node
 545     @node dpdk-input
 546
 547     This is the main DPDK input node: across each assigned interface,
 548     call rte_eth_rx_burst(...) or similar to obtain a vector of
 549     packets to process. Handle early packet discard. Derive @c
 550     vlib_buffer_t metadata from <code>struct rte_mbuf</code> metadata,
 551     Depending on the resulting metadata: adjust <code>b->current_data,
 552     b->current_length </code> and dispatch directly to
 553     ip4-input-no-checksum, or ip6-input. Trace the packet if required.
 554
 555     @param vm   vlib_main_t corresponding to the current thread
 556     @param node vlib_node_runtime_t
 557     @param f    vlib_frame_t input-node, not used.
 558
 559     @par Graph mechanics: buffer metadata, next index usage
 560
 561     @em Uses:
 562     - <code>struct rte_mbuf mb->ol_flags</code>
 563         - PKT_RX_IP_CKSUM_BAD
 564     - <code> RTE_ETH_IS_xxx_HDR(mb->packet_type) </code>
 565         - packet classification result
 566
 567     @em Sets:
 568     - <code>b->error</code> if the packet is to be dropped immediately
 569     - <code>b->current_data, b->current_length</code>
 570         - adjusted as needed to skip the L2 header in  direct-dispatch cases
 571     - <code>vnet_buffer(b)->sw_if_index[VLIB_RX]</code>
 572         - rx interface sw_if_index
 573     - <code>vnet_buffer(b)->sw_if_index[VLIB_TX] = ~0</code>
 574         - required by ipX-lookup
 575     - <code>b->flags</code>
 576         - to indicate multi-segment pkts (VLIB_BUFFER_NEXT_PRESENT), etc.
 577
 578     <em>Next Nodes:</em>
 579     - Static arcs to: error-drop, ethernet-input,
 580       ip4-input-no-checksum, ip6-input, mpls-input
 581     - per-interface redirection, controlled by
 582       <code>xd->per_interface_next_index</code>
 583 */
 584
 585 uword
 586 CLIB_MULTIARCH_FN (dpdk_input) (vlib_main_t * vm, vlib_node_runtime_t * node,
 587                                 vlib_frame_t * f)
 588 {
 589   dpdk_main_t *dm = &dpdk_main;
 590   dpdk_device_t *xd;
 591   uword n_rx_packets = 0;
 592   vnet_device_input_runtime_t *rt = (void *) node->runtime_data;
 593   vnet_device_and_queue_t *dq;
 594   u32 thread_index = node->thread_index;
 595
 596   /*
 597    * Poll all devices on this cpu for input/interrupts.
 598    */
 599   /* *INDENT-OFF* */
 600   foreach_device_and_queue (dq, rt->devices_and_queues)
 601     {
 602       xd = vec_elt_at_index(dm->devices, dq->dev_instance);
 603       if (PREDICT_FALSE (xd->flags & DPDK_DEVICE_FLAG_BOND_SLAVE))
 604         continue;       /* Do not poll slave to a bonded interface */
 605       if (xd->flags & DPDK_DEVICE_FLAG_MAYBE_MULTISEG)
 606         n_rx_packets += dpdk_device_input (dm, xd, node, thread_index, dq->queue_id, /* maybe_multiseg */ 1);
 607       else
 608         n_rx_packets += dpdk_device_input (dm, xd, node, thread_index, dq->queue_id, /* maybe_multiseg */ 0);
 609     }
 610   /* *INDENT-ON* */
 611
 612   poll_rate_limit (dm);
 613
 614   return n_rx_packets;
 615 }
 616
 617 #ifndef CLIB_MULTIARCH_VARIANT
 618 /* *INDENT-OFF* */
 619 VLIB_REGISTER_NODE (dpdk_input_node) = {
 620   .function = dpdk_input,
 621   .type = VLIB_NODE_TYPE_INPUT,
 622   .name = "dpdk-input",
 623   .sibling_of = "device-input",
 624
 625   /* Will be enabled if/when hardware is detected. */
 626   .state = VLIB_NODE_STATE_DISABLED,
 627
 628   .format_buffer = format_ethernet_header_with_length,
 629   .format_trace = format_dpdk_rx_dma_trace,
 630
 631   .n_errors = DPDK_N_ERROR,
 632   .error_strings = dpdk_error_strings,
 633 };
 634 /* *INDENT-ON* */
 635
 636 vlib_node_function_t __clib_weak dpdk_input_avx512;
 637 vlib_node_function_t __clib_weak dpdk_input_avx2;
 638
 639 #if __x86_64__
 640 static void __clib_constructor
 641 dpdk_input_multiarch_select (void)
 642 {
 643   if (dpdk_input_avx512 && clib_cpu_supports_avx512f ())
 644     dpdk_input_node.function = dpdk_input_avx512;
 645   else if (dpdk_input_avx2 && clib_cpu_supports_avx2 ())
 646     dpdk_input_node.function = dpdk_input_avx2;
 647 }
 648 #endif
 649 #endif
 650
 651 /*
 652  * fd.io coding-style-patch-verification: ON
 653  *
 654  * Local Variables:
 655  * eval: (c-set-style "gnu")
 656  * End:
 657  */