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 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   while ((mb->nb_segs > 1) && (nb_seg < mb->nb_segs))
 212     {
 213       ASSERT (mb_seg != 0);
 214
 215       b_seg = vlib_buffer_from_rte_mbuf (mb_seg);
 216       vlib_buffer_init_for_free_list (b_seg, fl);
 217
 218       ASSERT ((b_seg->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
 219       ASSERT (b_seg->current_data == 0);
 220
 221       /*
 222        * The driver (e.g. virtio) may not put the packet data at the start
 223        * of the segment, so don't assume b_seg->current_data == 0 is correct.
 224        */
 225       b_seg->current_data =
 226         (mb_seg->buf_addr + mb_seg->data_off) - (void *) b_seg->data;
 227
 228       b_seg->current_length = mb_seg->data_len;
 229       b->total_length_not_including_first_buffer += mb_seg->data_len;
 230
 231       b_chain->flags |= VLIB_BUFFER_NEXT_PRESENT;
 232       b_chain->next_buffer = vlib_get_buffer_index (vm, b_seg);
 233
 234       b_chain = b_seg;
 235       mb_seg = mb_seg->next;
 236       nb_seg++;
 237     }
 238 }
 239
 240 static_always_inline void
 241 dpdk_prefetch_buffer (struct rte_mbuf *mb)
 242 {
 243   vlib_buffer_t *b = vlib_buffer_from_rte_mbuf (mb);
 244   CLIB_PREFETCH (mb, CLIB_CACHE_LINE_BYTES, LOAD);
 245   CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, STORE);
 246 }
 247
 248 static_always_inline void
 249 dpdk_prefetch_ethertype (struct rte_mbuf *mb)
 250 {
 251   CLIB_PREFETCH (mb->buf_addr + mb->data_off +
 252                  STRUCT_OFFSET_OF (ethernet_header_t, type),
 253                  CLIB_CACHE_LINE_BYTES, LOAD);
 254 }
 255
 256
 257 /*
 258    This function should fill 1st cacheline of vlib_buffer_t metadata with data
 259    from buffer template. Instead of filling field by field, we construct
 260    template and then use 128/256 bit vector instruction to copy data.
 261    This code first loads whole cacheline into 4 128-bit registers (xmm)
 262    or two 256 bit registers (ymm) and then stores data into all 4 buffers
 263    efectively saving on register load operations.
 264 */
 265
 266 static_always_inline void
 267 dpdk_buffer_init_from_template (void *d0, void *d1, void *d2, void *d3,
 268                                 void *s)
 269 {
 270   int i;
 271   for (i = 0; i < 2; i++)
 272     {
 273       *(u8x32 *) (((u8 *) d0) + i * 32) =
 274         *(u8x32 *) (((u8 *) d1) + i * 32) =
 275         *(u8x32 *) (((u8 *) d2) + i * 32) =
 276         *(u8x32 *) (((u8 *) d3) + i * 32) = *(u8x32 *) (((u8 *) s) + i * 32);
 277     }
 278 }
 279
 280 /*
 281  * This function is used when there are no worker threads.
 282  * The main thread performs IO and forwards the packets.
 283  */
 284 static_always_inline u32
 285 dpdk_device_input (dpdk_main_t * dm, dpdk_device_t * xd,
 286                    vlib_node_runtime_t * node, u32 thread_index, u16 queue_id,
 287                    int maybe_multiseg)
 288 {
 289   u32 n_buffers;
 290   u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 291   u32 n_left_to_next, *to_next;
 292   u32 mb_index;
 293   vlib_main_t *vm = vlib_get_main ();
 294   uword n_rx_bytes = 0;
 295   u32 n_trace, trace_cnt __attribute__ ((unused));
 296   vlib_buffer_free_list_t *fl;
 297   vlib_buffer_t *bt = vec_elt_at_index (dm->buffer_templates, thread_index);
 298
 299   if ((xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP) == 0)
 300     return 0;
 301
 302   n_buffers = dpdk_rx_burst (dm, xd, queue_id);
 303
 304   if (n_buffers == 0)
 305     {
 306       return 0;
 307     }
 308
 309   vec_reset_length (xd->d_trace_buffers[thread_index]);
 310   trace_cnt = n_trace = vlib_get_trace_count (vm, node);
 311
 312   if (n_trace > 0)
 313     {
 314       u32 n = clib_min (n_trace, n_buffers);
 315       mb_index = 0;
 316
 317       while (n--)
 318         {
 319           struct rte_mbuf *mb = xd->rx_vectors[queue_id][mb_index++];
 320           vlib_buffer_t *b = vlib_buffer_from_rte_mbuf (mb);
 321           vec_add1 (xd->d_trace_buffers[thread_index],
 322                     vlib_get_buffer_index (vm, b));
 323         }
 324     }
 325
 326   fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
 327
 328   /* Update buffer template */
 329   vnet_buffer (bt)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
 330   bt->error = node->errors[DPDK_ERROR_NONE];
 331
 332   mb_index = 0;
 333
 334   while (n_buffers > 0)
 335     {
 336       vlib_buffer_t *b0, *b1, *b2, *b3;
 337       u32 bi0, next0;
 338       u32 bi1, next1;
 339       u32 bi2, next2;
 340       u32 bi3, next3;
 341       u8 error0, error1, error2, error3;
 342       u64 or_ol_flags;
 343
 344       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 345
 346       while (n_buffers >= 12 && n_left_to_next >= 4)
 347         {
 348           struct rte_mbuf *mb0, *mb1, *mb2, *mb3;
 349
 350           /* prefetches are interleaved with the rest of the code to reduce
 351              pressure on L1 cache */
 352           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 8]);
 353           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 4]);
 354
 355           mb0 = xd->rx_vectors[queue_id][mb_index];
 356           mb1 = xd->rx_vectors[queue_id][mb_index + 1];
 357           mb2 = xd->rx_vectors[queue_id][mb_index + 2];
 358           mb3 = xd->rx_vectors[queue_id][mb_index + 3];
 359
 360           ASSERT (mb0);
 361           ASSERT (mb1);
 362           ASSERT (mb2);
 363           ASSERT (mb3);
 364
 365           if (maybe_multiseg)
 366             {
 367               if (PREDICT_FALSE (mb0->nb_segs > 1))
 368                 dpdk_prefetch_buffer (mb0->next);
 369               if (PREDICT_FALSE (mb1->nb_segs > 1))
 370                 dpdk_prefetch_buffer (mb1->next);
 371               if (PREDICT_FALSE (mb2->nb_segs > 1))
 372                 dpdk_prefetch_buffer (mb2->next);
 373               if (PREDICT_FALSE (mb3->nb_segs > 1))
 374                 dpdk_prefetch_buffer (mb3->next);
 375             }
 376
 377           b0 = vlib_buffer_from_rte_mbuf (mb0);
 378           b1 = vlib_buffer_from_rte_mbuf (mb1);
 379           b2 = vlib_buffer_from_rte_mbuf (mb2);
 380           b3 = vlib_buffer_from_rte_mbuf (mb3);
 381
 382           dpdk_buffer_init_from_template (b0, b1, b2, b3, bt);
 383
 384           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 9]);
 385           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 5]);
 386
 387           /* current_data must be set to -RTE_PKTMBUF_HEADROOM in template */
 388           b0->current_data += mb0->data_off;
 389           b1->current_data += mb1->data_off;
 390           b2->current_data += mb2->data_off;
 391           b3->current_data += mb3->data_off;
 392
 393           b0->current_length = mb0->data_len;
 394           b1->current_length = mb1->data_len;
 395           b2->current_length = mb2->data_len;
 396           b3->current_length = mb3->data_len;
 397
 398           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 10]);
 399           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 7]);
 400
 401           bi0 = vlib_get_buffer_index (vm, b0);
 402           bi1 = vlib_get_buffer_index (vm, b1);
 403           bi2 = vlib_get_buffer_index (vm, b2);
 404           bi3 = vlib_get_buffer_index (vm, b3);
 405
 406           to_next[0] = bi0;
 407           to_next[1] = bi1;
 408           to_next[2] = bi2;
 409           to_next[3] = bi3;
 410           to_next += 4;
 411           n_left_to_next -= 4;
 412
 413           if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
 414             {
 415               next0 = next1 = next2 = next3 = xd->per_interface_next_index;
 416             }
 417           else
 418             {
 419               next0 = dpdk_rx_next_from_etype (mb0, b0);
 420               next1 = dpdk_rx_next_from_etype (mb1, b1);
 421               next2 = dpdk_rx_next_from_etype (mb2, b2);
 422               next3 = dpdk_rx_next_from_etype (mb3, b3);
 423             }
 424
 425           dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 11]);
 426           dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 6]);
 427
 428           or_ol_flags = (mb0->ol_flags | mb1->ol_flags |
 429                          mb2->ol_flags | mb3->ol_flags);
 430           if (PREDICT_FALSE (or_ol_flags & PKT_RX_IP_CKSUM_BAD))
 431             {
 432               dpdk_rx_error_from_mb (mb0, &next0, &error0);
 433               dpdk_rx_error_from_mb (mb1, &next1, &error1);
 434               dpdk_rx_error_from_mb (mb2, &next2, &error2);
 435               dpdk_rx_error_from_mb (mb3, &next3, &error3);
 436               b0->error = node->errors[error0];
 437               b1->error = node->errors[error1];
 438               b2->error = node->errors[error2];
 439               b3->error = node->errors[error3];
 440             }
 441
 442           vlib_buffer_advance (b0, device_input_next_node_advance[next0]);
 443           vlib_buffer_advance (b1, device_input_next_node_advance[next1]);
 444           vlib_buffer_advance (b2, device_input_next_node_advance[next2]);
 445           vlib_buffer_advance (b3, device_input_next_node_advance[next3]);
 446
 447           n_rx_bytes += mb0->pkt_len;
 448           n_rx_bytes += mb1->pkt_len;
 449           n_rx_bytes += mb2->pkt_len;
 450           n_rx_bytes += mb3->pkt_len;
 451
 452           /* Process subsequent segments of multi-segment packets */
 453           if (maybe_multiseg)
 454             {
 455               dpdk_process_subseq_segs (vm, b0, mb0, fl);
 456               dpdk_process_subseq_segs (vm, b1, mb1, fl);
 457               dpdk_process_subseq_segs (vm, b2, mb2, fl);
 458               dpdk_process_subseq_segs (vm, b3, mb3, fl);
 459             }
 460
 461           /*
 462            * Turn this on if you run into
 463            * "bad monkey" contexts, and you want to know exactly
 464            * which nodes they've visited... See main.c...
 465            */
 466           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 467           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b1);
 468           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b2);
 469           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b3);
 470
 471           /* Do we have any driver RX features configured on the interface? */
 472           vnet_feature_start_device_input_x4 (xd->vlib_sw_if_index,
 473                                               &next0, &next1, &next2, &next3,
 474                                               b0, b1, b2, b3);
 475
 476           vlib_validate_buffer_enqueue_x4 (vm, node, next_index,
 477                                            to_next, n_left_to_next,
 478                                            bi0, bi1, bi2, bi3,
 479                                            next0, next1, next2, next3);
 480           n_buffers -= 4;
 481           mb_index += 4;
 482         }
 483       while (n_buffers > 0 && n_left_to_next > 0)
 484         {
 485           struct rte_mbuf *mb0 = xd->rx_vectors[queue_id][mb_index];
 486
 487           if (PREDICT_TRUE (n_buffers > 3))
 488             {
 489               dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 2]);
 490               dpdk_prefetch_ethertype (xd->rx_vectors[queue_id]
 491                                        [mb_index + 1]);
 492             }
 493
 494           ASSERT (mb0);
 495
 496           b0 = vlib_buffer_from_rte_mbuf (mb0);
 497
 498           /* Prefetch one next segment if it exists. */
 499           if (PREDICT_FALSE (mb0->nb_segs > 1))
 500             dpdk_prefetch_buffer (mb0->next);
 501
 502           clib_memcpy (b0, bt, CLIB_CACHE_LINE_BYTES);
 503
 504           ASSERT (b0->current_data == -RTE_PKTMBUF_HEADROOM);
 505           b0->current_data += mb0->data_off;
 506           b0->current_length = mb0->data_len;
 507
 508           bi0 = vlib_get_buffer_index (vm, b0);
 509
 510           to_next[0] = bi0;
 511           to_next++;
 512           n_left_to_next--;
 513
 514           if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
 515             next0 = xd->per_interface_next_index;
 516           else
 517             next0 = dpdk_rx_next_from_etype (mb0, b0);
 518
 519           dpdk_rx_error_from_mb (mb0, &next0, &error0);
 520           b0->error = node->errors[error0];
 521
 522           vlib_buffer_advance (b0, device_input_next_node_advance[next0]);
 523
 524           n_rx_bytes += mb0->pkt_len;
 525
 526           /* Process subsequent segments of multi-segment packets */
 527           dpdk_process_subseq_segs (vm, b0, mb0, fl);
 528
 529           /*
 530            * Turn this on if you run into
 531            * "bad monkey" contexts, and you want to know exactly
 532            * which nodes they've visited... See main.c...
 533            */
 534           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 535
 536           /* Do we have any driver RX features configured on the interface? */
 537           vnet_feature_start_device_input_x1 (xd->vlib_sw_if_index, &next0,
 538                                               b0);
 539
 540           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 541                                            to_next, n_left_to_next,
 542                                            bi0, next0);
 543           n_buffers--;
 544           mb_index++;
 545         }
 546       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 547     }
 548
 549   if (PREDICT_FALSE (vec_len (xd->d_trace_buffers[thread_index]) > 0))
 550     {
 551       dpdk_rx_trace (dm, node, xd, queue_id,
 552                      xd->d_trace_buffers[thread_index],
 553                      vec_len (xd->d_trace_buffers[thread_index]));
 554       vlib_set_trace_count (vm, node,
 555                             n_trace -
 556                             vec_len (xd->d_trace_buffers[thread_index]));
 557     }
 558
 559   vlib_increment_combined_counter
 560     (vnet_get_main ()->interface_main.combined_sw_if_counters
 561      + VNET_INTERFACE_COUNTER_RX,
 562      thread_index, xd->vlib_sw_if_index, mb_index, n_rx_bytes);
 563
 564   vnet_device_increment_rx_packets (thread_index, mb_index);
 565
 566   return mb_index;
 567 }
 568
 569 static inline void
 570 poll_rate_limit (dpdk_main_t * dm)
 571 {
 572   /* Limit the poll rate by sleeping for N msec between polls */
 573   if (PREDICT_FALSE (dm->poll_sleep_usec != 0))
 574     {
 575       struct timespec ts, tsrem;
 576
 577       ts.tv_sec = 0;
 578       ts.tv_nsec = 1000 * dm->poll_sleep_usec;
 579
 580       while (nanosleep (&ts, &tsrem) < 0)
 581         {
 582           ts = tsrem;
 583         }
 584     }
 585 }
 586
 587 /** \brief Main DPDK input node
 588     @node dpdk-input
 589
 590     This is the main DPDK input node: across each assigned interface,
 591     call rte_eth_rx_burst(...) or similar to obtain a vector of
 592     packets to process. Handle early packet discard. Derive @c
 593     vlib_buffer_t metadata from <code>struct rte_mbuf</code> metadata,
 594     Depending on the resulting metadata: adjust <code>b->current_data,
 595     b->current_length </code> and dispatch directly to
 596     ip4-input-no-checksum, or ip6-input. Trace the packet if required.
 597
 598     @param vm   vlib_main_t corresponding to the current thread
 599     @param node vlib_node_runtime_t
 600     @param f    vlib_frame_t input-node, not used.
 601
 602     @par Graph mechanics: buffer metadata, next index usage
 603
 604     @em Uses:
 605     - <code>struct rte_mbuf mb->ol_flags</code>
 606         - PKT_RX_IP_CKSUM_BAD
 607     - <code> RTE_ETH_IS_xxx_HDR(mb->packet_type) </code>
 608         - packet classification result
 609
 610     @em Sets:
 611     - <code>b->error</code> if the packet is to be dropped immediately
 612     - <code>b->current_data, b->current_length</code>
 613         - adjusted as needed to skip the L2 header in  direct-dispatch cases
 614     - <code>vnet_buffer(b)->sw_if_index[VLIB_RX]</code>
 615         - rx interface sw_if_index
 616     - <code>vnet_buffer(b)->sw_if_index[VLIB_TX] = ~0</code>
 617         - required by ipX-lookup
 618     - <code>b->flags</code>
 619         - to indicate multi-segment pkts (VLIB_BUFFER_NEXT_PRESENT), etc.
 620
 621     <em>Next Nodes:</em>
 622     - Static arcs to: error-drop, ethernet-input,
 623       ip4-input-no-checksum, ip6-input, mpls-input
 624     - per-interface redirection, controlled by
 625       <code>xd->per_interface_next_index</code>
 626 */
 627
 628 static uword
 629 dpdk_input (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * f)
 630 {
 631   dpdk_main_t *dm = &dpdk_main;
 632   dpdk_device_t *xd;
 633   uword n_rx_packets = 0;
 634   dpdk_device_and_queue_t *dq;
 635   u32 thread_index = vlib_get_thread_index ();
 636
 637   /*
 638    * Poll all devices on this cpu for input/interrupts.
 639    */
 640   /* *INDENT-OFF* */
 641   vec_foreach (dq, dm->devices_by_cpu[thread_index])
 642     {
 643       xd = vec_elt_at_index(dm->devices, dq->device);
 644       if (xd->flags & DPDK_DEVICE_FLAG_MAYBE_MULTISEG)
 645         n_rx_packets += dpdk_device_input (dm, xd, node, thread_index, dq->queue_id, /* maybe_multiseg */ 1);
 646       else
 647         n_rx_packets += dpdk_device_input (dm, xd, node, thread_index, dq->queue_id, /* maybe_multiseg */ 0);
 648     }
 649   /* *INDENT-ON* */
 650
 651   poll_rate_limit (dm);
 652
 653   return n_rx_packets;
 654 }
 655
 656 /* *INDENT-OFF* */
 657 VLIB_REGISTER_NODE (dpdk_input_node) = {
 658   .function = dpdk_input,
 659   .type = VLIB_NODE_TYPE_INPUT,
 660   .name = "dpdk-input",
 661   .sibling_of = "device-input",
 662
 663   /* Will be enabled if/when hardware is detected. */
 664   .state = VLIB_NODE_STATE_DISABLED,
 665
 666   .format_buffer = format_ethernet_header_with_length,
 667   .format_trace = format_dpdk_rx_dma_trace,
 668
 669   .n_errors = DPDK_N_ERROR,
 670   .error_strings = dpdk_error_strings,
 671 };
 672
 673 VLIB_NODE_FUNCTION_MULTIARCH (dpdk_input_node, dpdk_input);
 674 /* *INDENT-ON* */
 675
 676 /*
 677  * fd.io coding-style-patch-verification: ON
 678  *
 679  * Local Variables:
 680  * eval: (c-set-style "gnu")
 681  * End:
 682  */