src/plugins/dpdk/device/node.c

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