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