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