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