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/buffer.h>
  23 #include <dpdk/device/dpdk.h>
  24 #include <vnet/classify/vnet_classify.h>
  25 #include <vnet/mpls/packet.h>
  26 #include <vnet/devices/devices.h>
  27 #include <vnet/interface/rx_queue_funcs.h>
  28 #include <vnet/feature/feature.h>
  29 #include <vnet/tcp/tcp_packet.h>
  30
  31 #include <dpdk/device/dpdk_priv.h>
  32
  33 static char *dpdk_error_strings[] = {
  34 #define _(n,s) s,
  35   foreach_dpdk_error
  36 #undef _
  37 };
  38
  39 /* make sure all flags we need are stored in lower 32 bits */
  40 STATIC_ASSERT ((u64) (RTE_MBUF_F_RX_IP_CKSUM_BAD | RTE_MBUF_F_RX_L4_CKSUM_BAD |
  41                       RTE_MBUF_F_RX_FDIR | RTE_MBUF_F_RX_LRO) < (1ULL << 32),
  42                "dpdk flags not in lower word, fix needed");
  43
  44 STATIC_ASSERT (RTE_MBUF_F_RX_L4_CKSUM_BAD == (1ULL << 3),
  45                "bit number of RTE_MBUF_F_RX_L4_CKSUM_BAD is no longer 3!");
  46
  47 static_always_inline uword
  48 dpdk_process_subseq_segs (vlib_main_t * vm, vlib_buffer_t * b,
  49                           struct rte_mbuf *mb, vlib_buffer_t * bt)
  50 {
  51   u8 nb_seg = 1;
  52   struct rte_mbuf *mb_seg = 0;
  53   vlib_buffer_t *b_seg, *b_chain = 0;
  54   mb_seg = mb->next;
  55   b_chain = b;
  56
  57   if (mb->nb_segs < 2)
  58     return 0;
  59
  60   b->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
  61   b->total_length_not_including_first_buffer = 0;
  62
  63   while (nb_seg < mb->nb_segs)
  64     {
  65       ASSERT (mb_seg != 0);
  66
  67       b_seg = vlib_buffer_from_rte_mbuf (mb_seg);
  68       vlib_buffer_copy_template (b_seg, bt);
  69
  70       /*
  71        * The driver (e.g. virtio) may not put the packet data at the start
  72        * of the segment, so don't assume b_seg->current_data == 0 is correct.
  73        */
  74       b_seg->current_data =
  75         (mb_seg->buf_addr + mb_seg->data_off) - (void *) b_seg->data;
  76
  77       b_seg->current_length = mb_seg->data_len;
  78       b->total_length_not_including_first_buffer += mb_seg->data_len;
  79
  80       b_chain->flags |= VLIB_BUFFER_NEXT_PRESENT;
  81       b_chain->next_buffer = vlib_get_buffer_index (vm, b_seg);
  82
  83       b_chain = b_seg;
  84       mb_seg = mb_seg->next;
  85       nb_seg++;
  86     }
  87   return b->total_length_not_including_first_buffer;
  88 }
  89
  90 static_always_inline void
  91 dpdk_prefetch_mbuf_x4 (struct rte_mbuf *mb[])
  92 {
  93   clib_prefetch_load (mb[0]);
  94   clib_prefetch_load (mb[1]);
  95   clib_prefetch_load (mb[2]);
  96   clib_prefetch_load (mb[3]);
  97 }
  98
  99 static_always_inline void
 100 dpdk_prefetch_buffer_x4 (struct rte_mbuf *mb[])
 101 {
 102   vlib_buffer_t *b;
 103   b = vlib_buffer_from_rte_mbuf (mb[0]);
 104   clib_prefetch_store (b);
 105   b = vlib_buffer_from_rte_mbuf (mb[1]);
 106   clib_prefetch_store (b);
 107   b = vlib_buffer_from_rte_mbuf (mb[2]);
 108   clib_prefetch_store (b);
 109   b = vlib_buffer_from_rte_mbuf (mb[3]);
 110   clib_prefetch_store (b);
 111 }
 112
 113 /** \brief Main DPDK input node
 114     @node dpdk-input
 115
 116     This is the main DPDK input node: across each assigned interface,
 117     call rte_eth_rx_burst(...) or similar to obtain a vector of
 118     packets to process. Derive @c vlib_buffer_t metadata from
 119     <code>struct rte_mbuf</code> metadata,
 120     Depending on the resulting metadata: adjust <code>b->current_data,
 121     b->current_length </code> and dispatch directly to
 122     ip4-input-no-checksum, or ip6-input. Trace the packet if required.
 123
 124     @param vm   vlib_main_t corresponding to the current thread
 125     @param node vlib_node_runtime_t
 126     @param f    vlib_frame_t input-node, not used.
 127
 128     @par Graph mechanics: buffer metadata, next index usage
 129
 130     @em Uses:
 131     - <code>struct rte_mbuf mb->ol_flags</code>
 132         - RTE_MBUF_F_RX_IP_CKSUM_BAD
 133
 134     @em Sets:
 135     - <code>b->error</code> if the packet is to be dropped immediately
 136     - <code>b->current_data, b->current_length</code>
 137         - adjusted as needed to skip the L2 header in  direct-dispatch cases
 138     - <code>vnet_buffer(b)->sw_if_index[VLIB_RX]</code>
 139         - rx interface sw_if_index
 140     - <code>vnet_buffer(b)->sw_if_index[VLIB_TX] = ~0</code>
 141         - required by ipX-lookup
 142     - <code>b->flags</code>
 143         - to indicate multi-segment pkts (VLIB_BUFFER_NEXT_PRESENT), etc.
 144
 145     <em>Next Nodes:</em>
 146     - Static arcs to: error-drop, ethernet-input,
 147       ip4-input-no-checksum, ip6-input, mpls-input
 148     - per-interface redirection, controlled by
 149       <code>xd->per_interface_next_index</code>
 150 */
 151
 152 static_always_inline u32
 153 dpdk_ol_flags_extract (struct rte_mbuf **mb, u32 *flags, int count)
 154 {
 155   u32 rv = 0;
 156   int i;
 157   for (i = 0; i < count; i++)
 158     {
 159       /* all flags we are interested in are in lower 8 bits but
 160          that might change */
 161       flags[i] = (u32) mb[i]->ol_flags;
 162       rv |= flags[i];
 163     }
 164   return rv;
 165 }
 166
 167 static_always_inline uword
 168 dpdk_process_rx_burst (vlib_main_t *vm, dpdk_per_thread_data_t *ptd,
 169                        uword n_rx_packets, int maybe_multiseg, u32 *or_flagsp)
 170 {
 171   u32 n_left = n_rx_packets;
 172   vlib_buffer_t *b[4];
 173   struct rte_mbuf **mb = ptd->mbufs;
 174   uword n_bytes = 0;
 175   u32 *flags, or_flags = 0;
 176   vlib_buffer_t bt;
 177
 178   mb = ptd->mbufs;
 179   flags = ptd->flags;
 180
 181   /* copy template into local variable - will save per packet load */
 182   vlib_buffer_copy_template (&bt, &ptd->buffer_template);
 183   while (n_left >= 8)
 184     {
 185       dpdk_prefetch_buffer_x4 (mb + 4);
 186
 187       b[0] = vlib_buffer_from_rte_mbuf (mb[0]);
 188       b[1] = vlib_buffer_from_rte_mbuf (mb[1]);
 189       b[2] = vlib_buffer_from_rte_mbuf (mb[2]);
 190       b[3] = vlib_buffer_from_rte_mbuf (mb[3]);
 191
 192       vlib_buffer_copy_template (b[0], &bt);
 193       vlib_buffer_copy_template (b[1], &bt);
 194       vlib_buffer_copy_template (b[2], &bt);
 195       vlib_buffer_copy_template (b[3], &bt);
 196
 197       dpdk_prefetch_mbuf_x4 (mb + 4);
 198
 199       or_flags |= dpdk_ol_flags_extract (mb, flags, 4);
 200       flags += 4;
 201
 202       b[0]->current_data = mb[0]->data_off - RTE_PKTMBUF_HEADROOM;
 203       n_bytes += b[0]->current_length = mb[0]->data_len;
 204
 205       b[1]->current_data = mb[1]->data_off - RTE_PKTMBUF_HEADROOM;
 206       n_bytes += b[1]->current_length = mb[1]->data_len;
 207
 208       b[2]->current_data = mb[2]->data_off - RTE_PKTMBUF_HEADROOM;
 209       n_bytes += b[2]->current_length = mb[2]->data_len;
 210
 211       b[3]->current_data = mb[3]->data_off - RTE_PKTMBUF_HEADROOM;
 212       n_bytes += b[3]->current_length = mb[3]->data_len;
 213
 214       if (maybe_multiseg)
 215         {
 216           n_bytes += dpdk_process_subseq_segs (vm, b[0], mb[0], &bt);
 217           n_bytes += dpdk_process_subseq_segs (vm, b[1], mb[1], &bt);
 218           n_bytes += dpdk_process_subseq_segs (vm, b[2], mb[2], &bt);
 219           n_bytes += dpdk_process_subseq_segs (vm, b[3], mb[3], &bt);
 220         }
 221
 222       /* next */
 223       mb += 4;
 224       n_left -= 4;
 225     }
 226
 227   while (n_left)
 228     {
 229       b[0] = vlib_buffer_from_rte_mbuf (mb[0]);
 230       vlib_buffer_copy_template (b[0], &bt);
 231       or_flags |= dpdk_ol_flags_extract (mb, flags, 1);
 232       flags += 1;
 233
 234       b[0]->current_data = mb[0]->data_off - RTE_PKTMBUF_HEADROOM;
 235       n_bytes += b[0]->current_length = mb[0]->data_len;
 236
 237       if (maybe_multiseg)
 238         n_bytes += dpdk_process_subseq_segs (vm, b[0], mb[0], &bt);
 239
 240       /* next */
 241       mb += 1;
 242       n_left -= 1;
 243     }
 244
 245   *or_flagsp = or_flags;
 246   return n_bytes;
 247 }
 248
 249 static_always_inline void
 250 dpdk_process_flow_offload (dpdk_device_t * xd, dpdk_per_thread_data_t * ptd,
 251                            uword n_rx_packets)
 252 {
 253   uword n;
 254   dpdk_flow_lookup_entry_t *fle;
 255   vlib_buffer_t *b0;
 256
 257   /* TODO prefetch and quad-loop */
 258   for (n = 0; n < n_rx_packets; n++)
 259     {
 260       if ((ptd->flags[n] & RTE_MBUF_F_RX_FDIR_ID) == 0)
 261         continue;
 262
 263       fle = pool_elt_at_index (xd->flow_lookup_entries,
 264                                ptd->mbufs[n]->hash.fdir.hi);
 265
 266       if (fle->next_index != (u16) ~ 0)
 267         ptd->next[n] = fle->next_index;
 268
 269       if (fle->flow_id != ~0)
 270         {
 271           b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]);
 272           b0->flow_id = fle->flow_id;
 273         }
 274
 275       if (fle->buffer_advance != ~0)
 276         {
 277           b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]);
 278           vlib_buffer_advance (b0, fle->buffer_advance);
 279         }
 280     }
 281 }
 282
 283 static_always_inline u16
 284 dpdk_lro_find_l4_hdr_sz (vlib_buffer_t *b)
 285 {
 286   u16 l4_hdr_sz = 0;
 287   u16 current_offset = 0;
 288   ethernet_header_t *e;
 289   tcp_header_t *tcp;
 290   u8 *data = vlib_buffer_get_current (b);
 291   u16 ethertype;
 292   e = (void *) data;
 293   current_offset += sizeof (e[0]);
 294   ethertype = clib_net_to_host_u16 (e->type);
 295   if (ethernet_frame_is_tagged (ethertype))
 296     {
 297       ethernet_vlan_header_t *vlan = (ethernet_vlan_header_t *) (e + 1);
 298       ethertype = clib_net_to_host_u16 (vlan->type);
 299       current_offset += sizeof (*vlan);
 300       if (ethertype == ETHERNET_TYPE_VLAN)
 301         {
 302           vlan++;
 303           current_offset += sizeof (*vlan);
 304           ethertype = clib_net_to_host_u16 (vlan->type);
 305         }
 306     }
 307   data += current_offset;
 308   if (ethertype == ETHERNET_TYPE_IP4)
 309     {
 310       data += sizeof (ip4_header_t);
 311       tcp = (void *) data;
 312       l4_hdr_sz = tcp_header_bytes (tcp);
 313     }
 314   else
 315     {
 316       /* FIXME: extension headers...*/
 317       data += sizeof (ip6_header_t);
 318       tcp = (void *) data;
 319       l4_hdr_sz = tcp_header_bytes (tcp);
 320     }
 321   return l4_hdr_sz;
 322 }
 323
 324 static_always_inline void
 325 dpdk_process_lro_offload (dpdk_device_t *xd, dpdk_per_thread_data_t *ptd,
 326                           uword n_rx_packets)
 327 {
 328   uword n;
 329   vlib_buffer_t *b0;
 330   for (n = 0; n < n_rx_packets; n++)
 331     {
 332       b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]);
 333       if (ptd->flags[n] & RTE_MBUF_F_RX_LRO)
 334         {
 335           b0->flags |= VNET_BUFFER_F_GSO;
 336           vnet_buffer2 (b0)->gso_size = ptd->mbufs[n]->tso_segsz;
 337           vnet_buffer2 (b0)->gso_l4_hdr_sz = dpdk_lro_find_l4_hdr_sz (b0);
 338         }
 339     }
 340 }
 341
 342 static_always_inline u32
 343 dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd,
 344                    vlib_node_runtime_t * node, u32 thread_index, u16 queue_id)
 345 {
 346   uword n_rx_packets = 0, n_rx_bytes;
 347   dpdk_rx_queue_t *rxq = vec_elt_at_index (xd->rx_queues, queue_id);
 348   u32 n_left, n_trace;
 349   u32 *buffers;
 350   u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 351   struct rte_mbuf **mb;
 352   vlib_buffer_t *b0;
 353   u16 *next;
 354   u32 or_flags;
 355   u32 n;
 356   int single_next = 0;
 357
 358   dpdk_per_thread_data_t *ptd = vec_elt_at_index (dm->per_thread_data,
 359                                                   thread_index);
 360   vlib_buffer_t *bt = &ptd->buffer_template;
 361
 362   if ((xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP) == 0)
 363     return 0;
 364
 365   /* get up to DPDK_RX_BURST_SZ buffers from PMD */
 366   while (n_rx_packets < DPDK_RX_BURST_SZ)
 367     {
 368       u32 n_to_rx = clib_min (DPDK_RX_BURST_SZ - n_rx_packets, 32);
 369
 370       n = rte_eth_rx_burst (xd->port_id, queue_id, ptd->mbufs + n_rx_packets,
 371                             n_to_rx);
 372       n_rx_packets += n;
 373
 374       if (n < n_to_rx)
 375         break;
 376     }
 377
 378   if (n_rx_packets == 0)
 379     return 0;
 380
 381   /* Update buffer template */
 382   vnet_buffer (bt)->sw_if_index[VLIB_RX] = xd->sw_if_index;
 383   bt->error = node->errors[DPDK_ERROR_NONE];
 384   bt->flags = xd->buffer_flags;
 385   /* as DPDK is allocating empty buffers from mempool provided before interface
 386      start for each queue, it is safe to store this in the template */
 387   bt->buffer_pool_index = rxq->buffer_pool_index;
 388   bt->ref_count = 1;
 389   vnet_buffer (bt)->feature_arc_index = 0;
 390   bt->current_config_index = 0;
 391
 392   /* receive burst of packets from DPDK PMD */
 393   if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
 394     next_index = xd->per_interface_next_index;
 395
 396   /* as all packets belong to the same interface feature arc lookup
 397      can be don once and result stored in the buffer template */
 398   if (PREDICT_FALSE (vnet_device_input_have_features (xd->sw_if_index)))
 399     vnet_feature_start_device_input (xd->sw_if_index, &next_index, bt);
 400
 401   if (xd->flags & DPDK_DEVICE_FLAG_MAYBE_MULTISEG)
 402     n_rx_bytes = dpdk_process_rx_burst (vm, ptd, n_rx_packets, 1, &or_flags);
 403   else
 404     n_rx_bytes = dpdk_process_rx_burst (vm, ptd, n_rx_packets, 0, &or_flags);
 405
 406   if (PREDICT_FALSE ((or_flags & RTE_MBUF_F_RX_LRO)))
 407     dpdk_process_lro_offload (xd, ptd, n_rx_packets);
 408
 409   if (PREDICT_FALSE ((or_flags & RTE_MBUF_F_RX_L4_CKSUM_BAD) &&
 410                      (xd->buffer_flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT)))
 411     {
 412       for (n = 0; n < n_rx_packets; n++)
 413         {
 414           /* Check and reset VNET_BUFFER_F_L4_CHECKSUM_CORRECT flag
 415              if RTE_MBUF_F_RX_L4_CKSUM_BAD is set.
 416              The magic num 3 is the bit number of RTE_MBUF_F_RX_L4_CKSUM_BAD
 417              which is defined in DPDK.
 418              Have made a STATIC_ASSERT in this file to ensure this.
 419            */
 420           b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]);
 421           b0->flags ^= (ptd->flags[n] & RTE_MBUF_F_RX_L4_CKSUM_BAD)
 422                        << (VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT - 3);
 423         }
 424     }
 425
 426   if (PREDICT_FALSE (or_flags & RTE_MBUF_F_RX_FDIR))
 427     {
 428       /* some packets will need to go to different next nodes */
 429       for (n = 0; n < n_rx_packets; n++)
 430         ptd->next[n] = next_index;
 431
 432       /* flow offload - process if rx flow offload enabled and at least one
 433          packet is marked */
 434       if (PREDICT_FALSE ((xd->flags & DPDK_DEVICE_FLAG_RX_FLOW_OFFLOAD) &&
 435                          (or_flags & RTE_MBUF_F_RX_FDIR)))
 436         dpdk_process_flow_offload (xd, ptd, n_rx_packets);
 437
 438       /* enqueue buffers to the next node */
 439       vlib_get_buffer_indices_with_offset (vm, (void **) ptd->mbufs,
 440                                            ptd->buffers, n_rx_packets,
 441                                            sizeof (struct rte_mbuf));
 442
 443       vlib_buffer_enqueue_to_next (vm, node, ptd->buffers, ptd->next,
 444                                    n_rx_packets);
 445     }
 446   else
 447     {
 448       u32 *to_next, n_left_to_next;
 449
 450       vlib_get_new_next_frame (vm, node, next_index, to_next, n_left_to_next);
 451       vlib_get_buffer_indices_with_offset (vm, (void **) ptd->mbufs, to_next,
 452                                            n_rx_packets,
 453                                            sizeof (struct rte_mbuf));
 454
 455       if (PREDICT_TRUE (next_index == VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT))
 456         {
 457           vlib_next_frame_t *nf;
 458           vlib_frame_t *f;
 459           ethernet_input_frame_t *ef;
 460           nf = vlib_node_runtime_get_next_frame (vm, node, next_index);
 461           f = vlib_get_frame (vm, nf->frame);
 462           f->flags = ETH_INPUT_FRAME_F_SINGLE_SW_IF_IDX;
 463
 464           ef = vlib_frame_scalar_args (f);
 465           ef->sw_if_index = xd->sw_if_index;
 466           ef->hw_if_index = xd->hw_if_index;
 467
 468           /* if PMD supports ip4 checksum check and there are no packets
 469              marked as ip4 checksum bad we can notify ethernet input so it
 470              can send pacets to ip4-input-no-checksum node */
 471           if (xd->flags & DPDK_DEVICE_FLAG_RX_IP4_CKSUM &&
 472               (or_flags & RTE_MBUF_F_RX_IP_CKSUM_BAD) == 0)
 473             f->flags |= ETH_INPUT_FRAME_F_IP4_CKSUM_OK;
 474           vlib_frame_no_append (f);
 475         }
 476       n_left_to_next -= n_rx_packets;
 477       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 478       single_next = 1;
 479     }
 480
 481   /* packet trace if enabled */
 482   if (PREDICT_FALSE ((n_trace = vlib_get_trace_count (vm, node))))
 483     {
 484       if (single_next)
 485         vlib_get_buffer_indices_with_offset (vm, (void **) ptd->mbufs,
 486                                              ptd->buffers, n_rx_packets,
 487                                              sizeof (struct rte_mbuf));
 488
 489       n_left = n_rx_packets;
 490       buffers = ptd->buffers;
 491       mb = ptd->mbufs;
 492       next = ptd->next;
 493
 494       while (n_trace && n_left)
 495         {
 496           b0 = vlib_get_buffer (vm, buffers[0]);
 497           if (single_next == 0)
 498             next_index = next[0];
 499
 500           if (PREDICT_TRUE
 501               (vlib_trace_buffer
 502                (vm, node, next_index, b0, /* follow_chain */ 0)))
 503             {
 504
 505               dpdk_rx_trace_t *t0 =
 506                 vlib_add_trace (vm, node, b0, sizeof t0[0]);
 507               t0->queue_index = queue_id;
 508               t0->device_index = xd->device_index;
 509               t0->buffer_index = vlib_get_buffer_index (vm, b0);
 510
 511               clib_memcpy_fast (&t0->mb, mb[0], sizeof t0->mb);
 512               clib_memcpy_fast (&t0->buffer, b0,
 513                                 sizeof b0[0] - sizeof b0->pre_data);
 514               clib_memcpy_fast (t0->buffer.pre_data, b0->data,
 515                                 sizeof t0->buffer.pre_data);
 516               clib_memcpy_fast (&t0->data, mb[0]->buf_addr + mb[0]->data_off,
 517                                 sizeof t0->data);
 518               n_trace--;
 519             }
 520
 521           n_left--;
 522           buffers++;
 523           mb++;
 524           next++;
 525         }
 526       vlib_set_trace_count (vm, node, n_trace);
 527     }
 528
 529   vlib_increment_combined_counter
 530     (vnet_get_main ()->interface_main.combined_sw_if_counters
 531      + VNET_INTERFACE_COUNTER_RX, thread_index, xd->sw_if_index,
 532      n_rx_packets, n_rx_bytes);
 533
 534   vnet_device_increment_rx_packets (thread_index, n_rx_packets);
 535
 536   return n_rx_packets;
 537 }
 538
 539 VLIB_NODE_FN (dpdk_input_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
 540                                 vlib_frame_t * f)
 541 {
 542   dpdk_main_t *dm = &dpdk_main;
 543   dpdk_device_t *xd;
 544   uword n_rx_packets = 0;
 545   vnet_hw_if_rxq_poll_vector_t *pv;
 546   u32 thread_index = vm->thread_index;
 547
 548   /*
 549    * Poll all devices on this cpu for input/interrupts.
 550    */
 551
 552   pv = vnet_hw_if_get_rxq_poll_vector (vm, node);
 553
 554   for (int i = 0; i < vec_len (pv); i++)
 555     {
 556       xd = vec_elt_at_index (dm->devices, pv[i].dev_instance);
 557       n_rx_packets +=
 558         dpdk_device_input (vm, dm, xd, node, thread_index, pv[i].queue_id);
 559     }
 560   return n_rx_packets;
 561 }
 562
 563 VLIB_REGISTER_NODE (dpdk_input_node) = {
 564   .type = VLIB_NODE_TYPE_INPUT,
 565   .name = "dpdk-input",
 566   .sibling_of = "device-input",
 567   .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED,
 568
 569   /* Will be enabled if/when hardware is detected. */
 570   .state = VLIB_NODE_STATE_DISABLED,
 571
 572   .format_buffer = format_ethernet_header_with_length,
 573   .format_trace = format_dpdk_rx_trace,
 574
 575   .n_errors = DPDK_N_ERROR,
 576   .error_strings = dpdk_error_strings,
 577 };
 578
 579 /*
 580  * fd.io coding-style-patch-verification: ON
 581  *
 582  * Local Variables:
 583  * eval: (c-set-style "gnu")
 584  * End:
 585  */