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