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 u32
  40 dpdk_rx_next_from_etype (struct rte_mbuf *mb)
  41 {
  42   ethernet_header_t *h = rte_pktmbuf_mtod (mb, ethernet_header_t *);
  43   if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP4)))
  44     {
  45       if (PREDICT_TRUE ((mb->ol_flags & PKT_RX_IP_CKSUM_GOOD) != 0))
  46         return VNET_DEVICE_INPUT_NEXT_IP4_NCS_INPUT;
  47       else
  48         return VNET_DEVICE_INPUT_NEXT_IP4_INPUT;
  49     }
  50   else if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP6)))
  51     return VNET_DEVICE_INPUT_NEXT_IP6_INPUT;
  52   else
  53     if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_MPLS)))
  54     return VNET_DEVICE_INPUT_NEXT_MPLS_INPUT;
  55   else
  56     return VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
  57 }
  58
  59 always_inline u32
  60 dpdk_rx_next_from_packet_start (struct rte_mbuf * mb, vlib_buffer_t * b0)
  61 {
  62   ethernet_header_t *h = rte_pktmbuf_mtod (mb, ethernet_header_t *);
  63   word start_delta;
  64   int rv;
  65
  66   start_delta = b0->current_data -
  67     ((mb->buf_addr + mb->data_off) - (void *) b0->data);
  68
  69   vlib_buffer_advance (b0, -start_delta);
  70
  71   if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP4)))
  72     {
  73       if (PREDICT_TRUE ((mb->ol_flags & PKT_RX_IP_CKSUM_GOOD) != 0))
  74         rv = VNET_DEVICE_INPUT_NEXT_IP4_NCS_INPUT;
  75       else
  76         rv = VNET_DEVICE_INPUT_NEXT_IP4_INPUT;
  77     }
  78   else if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP6)))
  79     rv = VNET_DEVICE_INPUT_NEXT_IP6_INPUT;
  80   else
  81     if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_MPLS)))
  82     rv = VNET_DEVICE_INPUT_NEXT_MPLS_INPUT;
  83   else
  84     rv = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
  85
  86   vlib_buffer_advance (b0, start_delta);
  87   return rv;
  88 }
  89
  90 always_inline void
  91 dpdk_rx_error_from_mb (struct rte_mbuf *mb, u32 * next, u8 * error)
  92 {
  93   if (mb->ol_flags & PKT_RX_IP_CKSUM_BAD)
  94     {
  95       *error = DPDK_ERROR_IP_CHECKSUM_ERROR;
  96       *next = VNET_DEVICE_INPUT_NEXT_DROP;
  97     }
  98   else
  99     *error = DPDK_ERROR_NONE;
 100 }
 101
 102 static void
 103 dpdk_rx_trace (dpdk_main_t * dm,
 104                vlib_node_runtime_t * node,
 105                dpdk_device_t * xd,
 106                u16 queue_id, u32 * buffers, uword n_buffers)
 107 {
 108   vlib_main_t *vm = vlib_get_main ();
 109   u32 *b, n_left;
 110   u32 next0;
 111
 112   n_left = n_buffers;
 113   b = buffers;
 114
 115   while (n_left >= 1)
 116     {
 117       u32 bi0;
 118       vlib_buffer_t *b0;
 119       dpdk_rx_dma_trace_t *t0;
 120       struct rte_mbuf *mb;
 121       u8 error0;
 122
 123       bi0 = b[0];
 124       n_left -= 1;
 125
 126       b0 = vlib_get_buffer (vm, bi0);
 127       mb = rte_mbuf_from_vlib_buffer (b0);
 128
 129       if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
 130         next0 = xd->per_interface_next_index;
 131       else
 132         next0 = dpdk_rx_next_from_packet_start (mb, b0);
 133
 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   if (mb->nb_segs < 2)
 197     return;
 198
 199   b->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
 200   b->total_length_not_including_first_buffer = 0;
 201
 202   while (nb_seg < mb->nb_segs)
 203     {
 204       ASSERT (mb_seg != 0);
 205
 206       b_seg = vlib_buffer_from_rte_mbuf (mb_seg);
 207       vlib_buffer_init_for_free_list (b_seg, fl);
 208
 209       ASSERT ((b_seg->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
 210       ASSERT (b_seg->current_data == 0);
 211
 212       /*
 213        * The driver (e.g. virtio) may not put the packet data at the start
 214        * of the segment, so don't assume b_seg->current_data == 0 is correct.
 215        */
 216       b_seg->current_data =
 217         (mb_seg->buf_addr + mb_seg->data_off) - (void *) b_seg->data;
 218
 219       b_seg->current_length = mb_seg->data_len;
 220       b->total_length_not_including_first_buffer += mb_seg->data_len;
 221
 222       b_chain->flags |= VLIB_BUFFER_NEXT_PRESENT;
 223       b_chain->next_buffer = vlib_get_buffer_index (vm, b_seg);
 224
 225       b_chain = b_seg;
 226       mb_seg = mb_seg->next;
 227       nb_seg++;
 228     }
 229 }
 230
 231 static_always_inline void
 232 dpdk_prefetch_buffer (struct rte_mbuf *mb)
 233 {
 234   vlib_buffer_t *b = vlib_buffer_from_rte_mbuf (mb);
 235   CLIB_PREFETCH (mb, CLIB_CACHE_LINE_BYTES, LOAD);
 236   CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, STORE);
 237 }
 238
 239 static_always_inline void
 240 dpdk_prefetch_ethertype (struct rte_mbuf *mb)
 241 {
 242   CLIB_PREFETCH (mb->buf_addr + mb->data_off +
 243                  STRUCT_OFFSET_OF (ethernet_header_t, type),
 244                  CLIB_CACHE_LINE_BYTES, LOAD);
 245 }
 246
 247 /*
 248  * This function is used when there are no worker threads.
 249  * The main thread performs IO and forwards the packets.
 250  */
 251 static_always_inline u32
 252 dpdk_device_input (dpdk_main_t * dm, dpdk_device_t * xd,
 253                    vlib_node_runtime_t * node, u32 thread_index, u16 queue_id,
 254                    int maybe_multiseg)
 255 {
 256   u32 n_buffers;
 257   u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 258   u32 n_left_to_next, *to_next;
 259   u32 mb_index;
 260   vlib_main_t *vm = vlib_get_main ();
 261   uword n_rx_bytes = 0;
 262   u32 n_trace, trace_cnt __attribute__ ((unused));
 263   vlib_buffer_free_list_t *fl;
 264   vlib_buffer_t *bt = vec_elt_at_index (dm->buffer_templates, thread_index);
 265
 266   if ((xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP) == 0)
 267     return 0;
 268
 269   n_buffers = dpdk_rx_burst (dm, xd, queue_id);
 270
 271   if (n_buffers == 0)
 272     {
 273       return 0;
 274     }
 275
 276   vec_reset_length (xd->d_trace_buffers[thread_index]);
 277   trace_cnt = n_trace = vlib_get_trace_count (vm, node);
 278
 279   if (n_trace > 0)
 280     {
 281       u32 n = clib_min (n_trace, n_buffers);
 282       mb_index = 0;
 283
 284       while (n--)
 285         {
 286           struct rte_mbuf *mb = xd->rx_vectors[queue_id][mb_index++];
 287           vlib_buffer_t *b = vlib_buffer_from_rte_mbuf (mb);
 288           vec_add1 (xd->d_trace_buffers[thread_index],
 289                     vlib_get_buffer_index (vm, b));
 290         }
 291     }
 292
 293   fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
 294
 295   /* Update buffer template */
 296   vnet_buffer (bt)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
 297   bt->error = node->errors[DPDK_ERROR_NONE];
 298   /* as DPDK is allocating empty buffers from mempool provided before interface
 299      start for each queue, it is safe to store this in the template */
 300   bt->buffer_pool_index = xd->buffer_pool_for_queue[queue_id];
 301
 302   mb_index = 0;
 303
 304   while (n_buffers > 0)
 305     {
 306       vlib_buffer_t *b0, *b1, *b2, *b3;
 307       u32 bi0, next0;
 308       u32 bi1, next1;
 309       u32 bi2, next2;
 310       u32 bi3, next3;
 311       u8 error0, error1, error2, error3;
 312       i16 offset0, offset1, offset2, offset3;
 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 >= 12 && n_left_to_next >= 4)
 318         {
 319           struct rte_mbuf *mb0, *mb1, *mb2, *mb3;
 320
 321           /* prefetches are interleaved with the rest of the code to reduce
 322              pressure on L1 cache */
 323           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 8]);
 324           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 4]);
 325
 326           mb0 = xd->rx_vectors[queue_id][mb_index];
 327           mb1 = xd->rx_vectors[queue_id][mb_index + 1];
 328           mb2 = xd->rx_vectors[queue_id][mb_index + 2];
 329           mb3 = xd->rx_vectors[queue_id][mb_index + 3];
 330
 331           ASSERT (mb0);
 332           ASSERT (mb1);
 333           ASSERT (mb2);
 334           ASSERT (mb3);
 335
 336           if (maybe_multiseg)
 337             {
 338               if (PREDICT_FALSE (mb0->nb_segs > 1))
 339                 dpdk_prefetch_buffer (mb0->next);
 340               if (PREDICT_FALSE (mb1->nb_segs > 1))
 341                 dpdk_prefetch_buffer (mb1->next);
 342               if (PREDICT_FALSE (mb2->nb_segs > 1))
 343                 dpdk_prefetch_buffer (mb2->next);
 344               if (PREDICT_FALSE (mb3->nb_segs > 1))
 345                 dpdk_prefetch_buffer (mb3->next);
 346             }
 347
 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           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 9]);
 354           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 5]);
 355
 356           clib_memcpy64_x4 (b0, b1, b2, b3, bt);
 357
 358           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 10]);
 359           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 7]);
 360
 361           bi0 = vlib_get_buffer_index (vm, b0);
 362           bi1 = vlib_get_buffer_index (vm, b1);
 363           bi2 = vlib_get_buffer_index (vm, b2);
 364           bi3 = vlib_get_buffer_index (vm, b3);
 365
 366           to_next[0] = bi0;
 367           to_next[1] = bi1;
 368           to_next[2] = bi2;
 369           to_next[3] = bi3;
 370           to_next += 4;
 371           n_left_to_next -= 4;
 372
 373           if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
 374             {
 375               next0 = next1 = next2 = next3 = xd->per_interface_next_index;
 376             }
 377           else
 378             {
 379               next0 = dpdk_rx_next_from_etype (mb0);
 380               next1 = dpdk_rx_next_from_etype (mb1);
 381               next2 = dpdk_rx_next_from_etype (mb2);
 382               next3 = dpdk_rx_next_from_etype (mb3);
 383             }
 384
 385           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 11]);
 386           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 6]);
 387
 388           or_ol_flags = (mb0->ol_flags | mb1->ol_flags |
 389                          mb2->ol_flags | mb3->ol_flags);
 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
 402           offset0 = device_input_next_node_advance[next0];
 403           b0->current_data = mb0->data_off + offset0 - RTE_PKTMBUF_HEADROOM;
 404           b0->flags |= device_input_next_node_flags[next0];
 405           vnet_buffer (b0)->l3_hdr_offset = b0->current_data;
 406           vnet_buffer (b0)->l2_hdr_offset =
 407             mb0->data_off - RTE_PKTMBUF_HEADROOM;
 408           b0->current_length = mb0->data_len - offset0;
 409           n_rx_bytes += mb0->pkt_len;
 410
 411           offset1 = device_input_next_node_advance[next1];
 412           b1->current_data = mb1->data_off + offset1 - RTE_PKTMBUF_HEADROOM;
 413           b1->flags |= device_input_next_node_flags[next1];
 414           vnet_buffer (b1)->l3_hdr_offset = b1->current_data;
 415           vnet_buffer (b1)->l2_hdr_offset =
 416             mb1->data_off - RTE_PKTMBUF_HEADROOM;
 417           b1->current_length = mb1->data_len - offset1;
 418           n_rx_bytes += mb1->pkt_len;
 419
 420           offset2 = device_input_next_node_advance[next2];
 421           b2->current_data = mb2->data_off + offset2 - RTE_PKTMBUF_HEADROOM;
 422           b2->flags |= device_input_next_node_flags[next2];
 423           vnet_buffer (b2)->l3_hdr_offset = b2->current_data;
 424           vnet_buffer (b2)->l2_hdr_offset =
 425             mb2->data_off - RTE_PKTMBUF_HEADROOM;
 426           b2->current_length = mb2->data_len - offset2;
 427           n_rx_bytes += mb2->pkt_len;
 428
 429           offset3 = device_input_next_node_advance[next3];
 430           b3->current_data = mb3->data_off + offset3 - RTE_PKTMBUF_HEADROOM;
 431           b3->flags |= device_input_next_node_flags[next3];
 432           vnet_buffer (b3)->l3_hdr_offset = b3->current_data;
 433           vnet_buffer (b3)->l2_hdr_offset =
 434             mb3->data_off - RTE_PKTMBUF_HEADROOM;
 435           b3->current_length = mb3->data_len - offset3;
 436           n_rx_bytes += mb3->pkt_len;
 437
 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           bi0 = vlib_get_buffer_index (vm, b0);
 492
 493           to_next[0] = bi0;
 494           to_next++;
 495           n_left_to_next--;
 496
 497           if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
 498             next0 = xd->per_interface_next_index;
 499           else
 500             next0 = dpdk_rx_next_from_etype (mb0);
 501
 502           dpdk_rx_error_from_mb (mb0, &next0, &error0);
 503           b0->error = node->errors[error0];
 504
 505           offset0 = device_input_next_node_advance[next0];
 506           b0->current_data = mb0->data_off + offset0 - RTE_PKTMBUF_HEADROOM;
 507           b0->flags |= device_input_next_node_flags[next0];
 508           vnet_buffer (b0)->l3_hdr_offset = b0->current_data;
 509           vnet_buffer (b0)->l2_hdr_offset =
 510             mb0->data_off - RTE_PKTMBUF_HEADROOM;
 511           b0->current_length = mb0->data_len - offset0;
 512           n_rx_bytes += mb0->pkt_len;
 513
 514           /* Process subsequent segments of multi-segment packets */
 515           dpdk_process_subseq_segs (vm, b0, mb0, fl);
 516
 517           /*
 518            * Turn this on if you run into
 519            * "bad monkey" contexts, and you want to know exactly
 520            * which nodes they've visited... See main.c...
 521            */
 522           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 523
 524           /* Do we have any driver RX features configured on the interface? */
 525           vnet_feature_start_device_input_x1 (xd->vlib_sw_if_index, &next0,
 526                                               b0);
 527
 528           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 529                                            to_next, n_left_to_next,
 530                                            bi0, next0);
 531           n_buffers--;
 532           mb_index++;
 533         }
 534       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 535     }
 536
 537   if (PREDICT_FALSE (vec_len (xd->d_trace_buffers[thread_index]) > 0))
 538     {
 539       dpdk_rx_trace (dm, node, xd, queue_id,
 540                      xd->d_trace_buffers[thread_index],
 541                      vec_len (xd->d_trace_buffers[thread_index]));
 542       vlib_set_trace_count (vm, node,
 543                             n_trace -
 544                             vec_len (xd->d_trace_buffers[thread_index]));
 545     }
 546
 547   vlib_increment_combined_counter
 548     (vnet_get_main ()->interface_main.combined_sw_if_counters
 549      + VNET_INTERFACE_COUNTER_RX,
 550      thread_index, xd->vlib_sw_if_index, mb_index, n_rx_bytes);
 551
 552   vnet_device_increment_rx_packets (thread_index, mb_index);
 553
 554   return mb_index;
 555 }
 556
 557 static inline void
 558 poll_rate_limit (dpdk_main_t * dm)
 559 {
 560   /* Limit the poll rate by sleeping for N msec between polls */
 561   if (PREDICT_FALSE (dm->poll_sleep_usec != 0))
 562     {
 563       struct timespec ts, tsrem;
 564
 565       ts.tv_sec = 0;
 566       ts.tv_nsec = 1000 * dm->poll_sleep_usec;
 567
 568       while (nanosleep (&ts, &tsrem) < 0)
 569         {
 570           ts = tsrem;
 571         }
 572     }
 573 }
 574
 575 /** \brief Main DPDK input node
 576     @node dpdk-input
 577
 578     This is the main DPDK input node: across each assigned interface,
 579     call rte_eth_rx_burst(...) or similar to obtain a vector of
 580     packets to process. Handle early packet discard. Derive @c
 581     vlib_buffer_t metadata from <code>struct rte_mbuf</code> metadata,
 582     Depending on the resulting metadata: adjust <code>b->current_data,
 583     b->current_length </code> and dispatch directly to
 584     ip4-input-no-checksum, or ip6-input. Trace the packet if required.
 585
 586     @param vm   vlib_main_t corresponding to the current thread
 587     @param node vlib_node_runtime_t
 588     @param f    vlib_frame_t input-node, not used.
 589
 590     @par Graph mechanics: buffer metadata, next index usage
 591
 592     @em Uses:
 593     - <code>struct rte_mbuf mb->ol_flags</code>
 594         - PKT_RX_IP_CKSUM_BAD
 595     - <code> RTE_ETH_IS_xxx_HDR(mb->packet_type) </code>
 596         - packet classification result
 597
 598     @em Sets:
 599     - <code>b->error</code> if the packet is to be dropped immediately
 600     - <code>b->current_data, b->current_length</code>
 601         - adjusted as needed to skip the L2 header in  direct-dispatch cases
 602     - <code>vnet_buffer(b)->sw_if_index[VLIB_RX]</code>
 603         - rx interface sw_if_index
 604     - <code>vnet_buffer(b)->sw_if_index[VLIB_TX] = ~0</code>
 605         - required by ipX-lookup
 606     - <code>b->flags</code>
 607         - to indicate multi-segment pkts (VLIB_BUFFER_NEXT_PRESENT), etc.
 608
 609     <em>Next Nodes:</em>
 610     - Static arcs to: error-drop, ethernet-input,
 611       ip4-input-no-checksum, ip6-input, mpls-input
 612     - per-interface redirection, controlled by
 613       <code>xd->per_interface_next_index</code>
 614 */
 615
 616 uword
 617 CLIB_MULTIARCH_FN (dpdk_input) (vlib_main_t * vm, vlib_node_runtime_t * node,
 618                                 vlib_frame_t * f)
 619 {
 620   dpdk_main_t *dm = &dpdk_main;
 621   dpdk_device_t *xd;
 622   uword n_rx_packets = 0;
 623   vnet_device_input_runtime_t *rt = (void *) node->runtime_data;
 624   vnet_device_and_queue_t *dq;
 625   u32 thread_index = node->thread_index;
 626
 627   /*
 628    * Poll all devices on this cpu for input/interrupts.
 629    */
 630   /* *INDENT-OFF* */
 631   foreach_device_and_queue (dq, rt->devices_and_queues)
 632     {
 633       xd = vec_elt_at_index(dm->devices, dq->dev_instance);
 634       if (PREDICT_FALSE (xd->flags & DPDK_DEVICE_FLAG_BOND_SLAVE))
 635         continue;       /* Do not poll slave to a bonded interface */
 636       if (xd->flags & DPDK_DEVICE_FLAG_MAYBE_MULTISEG)
 637         n_rx_packets += dpdk_device_input (dm, xd, node, thread_index, dq->queue_id, /* maybe_multiseg */ 1);
 638       else
 639         n_rx_packets += dpdk_device_input (dm, xd, node, thread_index, dq->queue_id, /* maybe_multiseg */ 0);
 640     }
 641   /* *INDENT-ON* */
 642
 643   poll_rate_limit (dm);
 644
 645   return n_rx_packets;
 646 }
 647
 648 #ifndef CLIB_MULTIARCH_VARIANT
 649 /* *INDENT-OFF* */
 650 VLIB_REGISTER_NODE (dpdk_input_node) = {
 651   .function = dpdk_input,
 652   .type = VLIB_NODE_TYPE_INPUT,
 653   .name = "dpdk-input",
 654   .sibling_of = "device-input",
 655
 656   /* Will be enabled if/when hardware is detected. */
 657   .state = VLIB_NODE_STATE_DISABLED,
 658
 659   .format_buffer = format_ethernet_header_with_length,
 660   .format_trace = format_dpdk_rx_dma_trace,
 661
 662   .n_errors = DPDK_N_ERROR,
 663   .error_strings = dpdk_error_strings,
 664 };
 665 /* *INDENT-ON* */
 666
 667 vlib_node_function_t __clib_weak dpdk_input_avx512;
 668 vlib_node_function_t __clib_weak dpdk_input_avx2;
 669
 670 #if __x86_64__
 671 static void __clib_constructor
 672 dpdk_input_multiarch_select (void)
 673 {
 674   if (dpdk_input_avx512 && clib_cpu_supports_avx512f ())
 675     dpdk_input_node.function = dpdk_input_avx512;
 676   else if (dpdk_input_avx2 && clib_cpu_supports_avx2 ())
 677     dpdk_input_node.function = dpdk_input_avx2;
 678 }
 679 #endif
 680 #endif
 681
 682 /*
 683  * fd.io coding-style-patch-verification: ON
 684  *
 685  * Local Variables:
 686  * eval: (c-set-style "gnu")
 687  * End:
 688  */