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