src/plugins/dpdk/device/init.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/bitmap.h>
  20 #include <vppinfra/linux/sysfs.h>
  21 #include <vlib/unix/unix.h>
  22 #include <vlib/log.h>
  23
  24 #include <vnet/ethernet/ethernet.h>
  25 #include <dpdk/device/dpdk.h>
  26 #include <vlib/pci/pci.h>
  27 #include <vlib/vmbus/vmbus.h>
  28
  29 #include <rte_ring.h>
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <unistd.h>
  34 #include <sys/stat.h>
  35 #include <sys/mount.h>
  36 #include <string.h>
  37 #include <fcntl.h>
  38
  39 #include <dpdk/device/dpdk_priv.h>
  40
  41 #define ETHER_MAX_LEN   1518  /**< Maximum frame len, including CRC. */
  42
  43 dpdk_main_t dpdk_main;
  44 dpdk_config_main_t dpdk_config_main;
  45
  46 #define LINK_STATE_ELOGS        0
  47
  48 /* Port configuration, mildly modified Intel app values */
  49
  50 static dpdk_port_type_t
  51 port_type_from_speed_capa (struct rte_eth_dev_info *dev_info)
  52 {
  53
  54   if (dev_info->speed_capa & ETH_LINK_SPEED_100G)
  55     return VNET_DPDK_PORT_TYPE_ETH_100G;
  56   else if (dev_info->speed_capa & ETH_LINK_SPEED_56G)
  57     return VNET_DPDK_PORT_TYPE_ETH_56G;
  58   else if (dev_info->speed_capa & ETH_LINK_SPEED_50G)
  59     return VNET_DPDK_PORT_TYPE_ETH_50G;
  60   else if (dev_info->speed_capa & ETH_LINK_SPEED_40G)
  61     return VNET_DPDK_PORT_TYPE_ETH_40G;
  62   else if (dev_info->speed_capa & ETH_LINK_SPEED_25G)
  63     return VNET_DPDK_PORT_TYPE_ETH_25G;
  64   else if (dev_info->speed_capa & ETH_LINK_SPEED_20G)
  65     return VNET_DPDK_PORT_TYPE_ETH_20G;
  66   else if (dev_info->speed_capa & ETH_LINK_SPEED_10G)
  67     return VNET_DPDK_PORT_TYPE_ETH_10G;
  68   else if (dev_info->speed_capa & ETH_LINK_SPEED_5G)
  69     return VNET_DPDK_PORT_TYPE_ETH_5G;
  70   else if (dev_info->speed_capa & ETH_LINK_SPEED_2_5G)
  71     return VNET_DPDK_PORT_TYPE_ETH_2_5G;
  72   else if (dev_info->speed_capa & ETH_LINK_SPEED_1G)
  73     return VNET_DPDK_PORT_TYPE_ETH_1G;
  74
  75   return VNET_DPDK_PORT_TYPE_UNKNOWN;
  76 }
  77
  78 static dpdk_port_type_t
  79 port_type_from_link_speed (u32 link_speed)
  80 {
  81   switch (link_speed)
  82     {
  83     case ETH_SPEED_NUM_1G:
  84       return VNET_DPDK_PORT_TYPE_ETH_1G;
  85     case ETH_SPEED_NUM_2_5G:
  86       return VNET_DPDK_PORT_TYPE_ETH_2_5G;
  87     case ETH_SPEED_NUM_5G:
  88       return VNET_DPDK_PORT_TYPE_ETH_5G;
  89     case ETH_SPEED_NUM_10G:
  90       return VNET_DPDK_PORT_TYPE_ETH_10G;
  91     case ETH_SPEED_NUM_20G:
  92       return VNET_DPDK_PORT_TYPE_ETH_20G;
  93     case ETH_SPEED_NUM_25G:
  94       return VNET_DPDK_PORT_TYPE_ETH_25G;
  95     case ETH_SPEED_NUM_40G:
  96       return VNET_DPDK_PORT_TYPE_ETH_40G;
  97     case ETH_SPEED_NUM_50G:
  98       return VNET_DPDK_PORT_TYPE_ETH_50G;
  99     case ETH_SPEED_NUM_56G:
 100       return VNET_DPDK_PORT_TYPE_ETH_56G;
 101     case ETH_SPEED_NUM_100G:
 102       return VNET_DPDK_PORT_TYPE_ETH_100G;
 103     default:
 104       return VNET_DPDK_PORT_TYPE_UNKNOWN;
 105     }
 106 }
 107
 108 static u32
 109 dpdk_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hi, u32 flags)
 110 {
 111   dpdk_main_t *dm = &dpdk_main;
 112   dpdk_device_t *xd = vec_elt_at_index (dm->devices, hi->dev_instance);
 113   u32 old = 0;
 114
 115   if (ETHERNET_INTERFACE_FLAG_CONFIG_PROMISC (flags))
 116     {
 117       old = (xd->flags & DPDK_DEVICE_FLAG_PROMISC) != 0;
 118
 119       if (flags & ETHERNET_INTERFACE_FLAG_ACCEPT_ALL)
 120         xd->flags |= DPDK_DEVICE_FLAG_PROMISC;
 121       else
 122         xd->flags &= ~DPDK_DEVICE_FLAG_PROMISC;
 123
 124       if (xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP)
 125         {
 126           if (xd->flags & DPDK_DEVICE_FLAG_PROMISC)
 127             rte_eth_promiscuous_enable (xd->port_id);
 128           else
 129             rte_eth_promiscuous_disable (xd->port_id);
 130         }
 131     }
 132   else if (ETHERNET_INTERFACE_FLAG_CONFIG_MTU (flags))
 133     {
 134       xd->port_conf.rxmode.max_rx_pkt_len = hi->max_packet_bytes;
 135       dpdk_device_setup (xd);
 136     }
 137   return old;
 138 }
 139
 140 static void
 141 dpdk_device_lock_init (dpdk_device_t * xd)
 142 {
 143   int q;
 144   vec_validate (xd->lockp, xd->tx_q_used - 1);
 145   for (q = 0; q < xd->tx_q_used; q++)
 146     {
 147       xd->lockp[q] = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES,
 148                                              CLIB_CACHE_LINE_BYTES);
 149       clib_memset ((void *) xd->lockp[q], 0, CLIB_CACHE_LINE_BYTES);
 150     }
 151 }
 152
 153 static struct rte_mempool_ops *
 154 get_ops_by_name (char *ops_name)
 155 {
 156   u32 i;
 157
 158   for (i = 0; i < rte_mempool_ops_table.num_ops; i++)
 159     {
 160       if (!strcmp (ops_name, rte_mempool_ops_table.ops[i].name))
 161         return &rte_mempool_ops_table.ops[i];
 162     }
 163
 164   return 0;
 165 }
 166
 167 static int
 168 dpdk_ring_alloc (struct rte_mempool *mp)
 169 {
 170   u32 rg_flags = 0, count;
 171   i32 ret;
 172   char rg_name[RTE_RING_NAMESIZE];
 173   struct rte_ring *r;
 174
 175   ret = snprintf (rg_name, sizeof (rg_name), RTE_MEMPOOL_MZ_FORMAT, mp->name);
 176   if (ret < 0 || ret >= (i32) sizeof (rg_name))
 177     return -ENAMETOOLONG;
 178
 179   /* ring flags */
 180   if (mp->flags & MEMPOOL_F_SP_PUT)
 181     rg_flags |= RING_F_SP_ENQ;
 182   if (mp->flags & MEMPOOL_F_SC_GET)
 183     rg_flags |= RING_F_SC_DEQ;
 184
 185   count = rte_align32pow2 (mp->size + 1);
 186   /*
 187    * Allocate the ring that will be used to store objects.
 188    * Ring functions will return appropriate errors if we are
 189    * running as a secondary process etc., so no checks made
 190    * in this function for that condition.
 191    */
 192   /* XXX can we get memory from the right socket? */
 193   r = clib_mem_alloc_aligned (rte_ring_get_memsize (count),
 194                               CLIB_CACHE_LINE_BYTES);
 195
 196   /* XXX rte_ring_lookup will not work */
 197
 198   ret = rte_ring_init (r, rg_name, count, rg_flags);
 199   if (ret)
 200     return ret;
 201
 202   mp->pool_data = r;
 203
 204   return 0;
 205 }
 206
 207 static int
 208 dpdk_port_crc_strip_enabled (dpdk_device_t * xd)
 209 {
 210 #if RTE_VERSION < RTE_VERSION_NUM(18, 11, 0, 0)
 211   return ! !(xd->port_conf.rxmode.offloads & DEV_RX_OFFLOAD_CRC_STRIP);
 212 #else
 213   return !(xd->port_conf.rxmode.offloads & DEV_RX_OFFLOAD_KEEP_CRC);
 214 #endif
 215 }
 216
 217 static clib_error_t *
 218 dpdk_lib_init (dpdk_main_t * dm)
 219 {
 220   u32 nports;
 221   u32 mtu, max_rx_frame;
 222   u32 nb_desc = 0;
 223   int i;
 224   clib_error_t *error;
 225   vlib_main_t *vm = vlib_get_main ();
 226   vlib_thread_main_t *tm = vlib_get_thread_main ();
 227   vnet_device_main_t *vdm = &vnet_device_main;
 228   vnet_sw_interface_t *sw;
 229   vnet_hw_interface_t *hi;
 230   dpdk_device_t *xd;
 231   vlib_pci_addr_t last_pci_addr;
 232   u32 last_pci_addr_port = 0;
 233   vlib_thread_registration_t *tr_hqos;
 234   uword *p_hqos;
 235
 236   u32 next_hqos_cpu = 0;
 237   u8 af_packet_instance_num = 0;
 238   u8 bond_ether_instance_num = 0;
 239   last_pci_addr.as_u32 = ~0;
 240
 241   dm->hqos_cpu_first_index = 0;
 242   dm->hqos_cpu_count = 0;
 243
 244   /* find out which cpus will be used for I/O TX */
 245   p_hqos = hash_get_mem (tm->thread_registrations_by_name, "hqos-threads");
 246   tr_hqos = p_hqos ? (vlib_thread_registration_t *) p_hqos[0] : 0;
 247
 248   if (tr_hqos && tr_hqos->count > 0)
 249     {
 250       dm->hqos_cpu_first_index = tr_hqos->first_index;
 251       dm->hqos_cpu_count = tr_hqos->count;
 252     }
 253
 254   vec_validate_aligned (dm->devices_by_hqos_cpu, tm->n_vlib_mains - 1,
 255                         CLIB_CACHE_LINE_BYTES);
 256
 257   nports = rte_eth_dev_count_avail ();
 258
 259   if (nports < 1)
 260     {
 261       dpdk_log_notice ("DPDK drivers found no ports...");
 262     }
 263
 264   if (CLIB_DEBUG > 0)
 265     dpdk_log_notice ("DPDK drivers found %d ports...", nports);
 266
 267   if (dm->conf->enable_tcp_udp_checksum)
 268     dm->buffer_flags_template &= ~(VNET_BUFFER_F_L4_CHECKSUM_CORRECT
 269                                    | VNET_BUFFER_F_L4_CHECKSUM_COMPUTED);
 270
 271   /* vlib_buffer_t template */
 272   vec_validate_aligned (dm->per_thread_data, tm->n_vlib_mains - 1,
 273                         CLIB_CACHE_LINE_BYTES);
 274   for (i = 0; i < tm->n_vlib_mains; i++)
 275     {
 276       dpdk_per_thread_data_t *ptd = vec_elt_at_index (dm->per_thread_data, i);
 277       clib_memset (&ptd->buffer_template, 0, sizeof (vlib_buffer_t));
 278       ptd->buffer_template.flags = dm->buffer_flags_template;
 279       vnet_buffer (&ptd->buffer_template)->sw_if_index[VLIB_TX] = (u32) ~ 0;
 280     }
 281
 282   /* *INDENT-OFF* */
 283   RTE_ETH_FOREACH_DEV(i)
 284     {
 285       u8 addr[6];
 286       u8 vlan_strip = 0;
 287       struct rte_eth_dev_info dev_info;
 288       struct rte_pci_device *pci_dev;
 289       struct rte_eth_link l;
 290       dpdk_device_config_t *devconf = 0;
 291       vlib_pci_addr_t pci_addr;
 292       uword *p = 0;
 293
 294       if (!rte_eth_dev_is_valid_port(i))
 295         continue;
 296
 297       rte_eth_link_get_nowait (i, &l);
 298       rte_eth_dev_info_get (i, &dev_info);
 299
 300       if (dev_info.device == 0)
 301         {
 302           clib_warning ("DPDK bug: missing device info. Skipping %s device",
 303                         dev_info.driver_name);
 304           continue;
 305         }
 306
 307       pci_dev = dpdk_get_pci_device (&dev_info);
 308
 309       if (pci_dev)      /* bonded interface has no pci info */
 310         {
 311           pci_addr.domain = pci_dev->addr.domain;
 312           pci_addr.bus = pci_dev->addr.bus;
 313           pci_addr.slot = pci_dev->addr.devid;
 314           pci_addr.function = pci_dev->addr.function;
 315           p = hash_get (dm->conf->device_config_index_by_pci_addr,
 316                         pci_addr.as_u32);
 317         }
 318
 319
 320       /* Create vnet interface */
 321       vec_add2_aligned (dm->devices, xd, 1, CLIB_CACHE_LINE_BYTES);
 322       xd->nb_rx_desc = DPDK_NB_RX_DESC_DEFAULT;
 323       xd->nb_tx_desc = DPDK_NB_TX_DESC_DEFAULT;
 324       xd->cpu_socket = (i8) rte_eth_dev_socket_id (i);
 325
 326       if (p)
 327         {
 328           devconf = pool_elt_at_index (dm->conf->dev_confs, p[0]);
 329           xd->name = devconf->name;
 330         }
 331       else
 332         devconf = &dm->conf->default_devconf;
 333
 334       /* Handle interface naming for devices with multiple ports sharing same PCI ID */
 335       if (pci_dev)
 336         {
 337           struct rte_eth_dev_info di = { 0 };
 338           struct rte_pci_device *next_pci_dev;
 339           rte_eth_dev_info_get (i + 1, &di);
 340           next_pci_dev = di.device ? RTE_DEV_TO_PCI (di.device) : 0;
 341           if (pci_dev && next_pci_dev &&
 342               pci_addr.as_u32 != last_pci_addr.as_u32 &&
 343               memcmp (&pci_dev->addr, &next_pci_dev->addr,
 344                       sizeof (struct rte_pci_addr)) == 0)
 345             {
 346               xd->interface_name_suffix = format (0, "0");
 347               last_pci_addr.as_u32 = pci_addr.as_u32;
 348               last_pci_addr_port = i;
 349             }
 350           else if (pci_addr.as_u32 == last_pci_addr.as_u32)
 351             {
 352               xd->interface_name_suffix =
 353                 format (0, "%u", i - last_pci_addr_port);
 354             }
 355           else
 356             {
 357               last_pci_addr.as_u32 = ~0;
 358             }
 359         }
 360       else
 361         last_pci_addr.as_u32 = ~0;
 362
 363       clib_memcpy (&xd->tx_conf, &dev_info.default_txconf,
 364                    sizeof (struct rte_eth_txconf));
 365
 366       if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_IPV4_CKSUM)
 367         {
 368           xd->port_conf.rxmode.offloads |= DEV_RX_OFFLOAD_IPV4_CKSUM;
 369           xd->flags |= DPDK_DEVICE_FLAG_RX_IP4_CKSUM;
 370         }
 371
 372       if (dm->conf->no_multi_seg)
 373         {
 374           xd->port_conf.txmode.offloads &= ~DEV_TX_OFFLOAD_MULTI_SEGS;
 375           xd->port_conf.rxmode.offloads &= ~DEV_RX_OFFLOAD_JUMBO_FRAME;
 376           xd->port_conf.rxmode.offloads &= ~DEV_RX_OFFLOAD_SCATTER;
 377         }
 378       else
 379         {
 380           xd->port_conf.txmode.offloads |= DEV_TX_OFFLOAD_MULTI_SEGS;
 381           xd->port_conf.rxmode.offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME;
 382           xd->port_conf.rxmode.offloads |= DEV_RX_OFFLOAD_SCATTER;
 383           xd->flags |= DPDK_DEVICE_FLAG_MAYBE_MULTISEG;
 384         }
 385
 386       xd->tx_q_used = clib_min (dev_info.max_tx_queues, tm->n_vlib_mains);
 387
 388       if (devconf->num_tx_queues > 0
 389           && devconf->num_tx_queues < xd->tx_q_used)
 390         xd->tx_q_used = clib_min (xd->tx_q_used, devconf->num_tx_queues);
 391
 392       if (devconf->num_rx_queues > 1
 393           && dev_info.max_rx_queues >= devconf->num_rx_queues)
 394         {
 395           xd->rx_q_used = devconf->num_rx_queues;
 396           xd->port_conf.rxmode.mq_mode = ETH_MQ_RX_RSS;
 397           if (devconf->rss_fn == 0)
 398             xd->port_conf.rx_adv_conf.rss_conf.rss_hf =
 399               ETH_RSS_IP | ETH_RSS_UDP | ETH_RSS_TCP;
 400           else
 401             {
 402               u64 unsupported_bits;
 403               xd->port_conf.rx_adv_conf.rss_conf.rss_hf = devconf->rss_fn;
 404               unsupported_bits = xd->port_conf.rx_adv_conf.rss_conf.rss_hf;
 405               unsupported_bits &= ~dev_info.flow_type_rss_offloads;
 406               if (unsupported_bits)
 407                 dpdk_log_warn ("Unsupported RSS hash functions: %U",
 408                                format_dpdk_rss_hf_name, unsupported_bits);
 409             }
 410           xd->port_conf.rx_adv_conf.rss_conf.rss_hf &=
 411             dev_info.flow_type_rss_offloads;
 412         }
 413       else
 414         xd->rx_q_used = 1;
 415
 416       xd->flags |= DPDK_DEVICE_FLAG_PMD;
 417
 418       /* workaround for drivers not setting driver_name */
 419       if ((!dev_info.driver_name) && (pci_dev))
 420         dev_info.driver_name = pci_dev->driver->driver.name;
 421
 422       ASSERT (dev_info.driver_name);
 423
 424       if (!xd->pmd)
 425         {
 426
 427
 428 #define _(s,f) else if (dev_info.driver_name &&                 \
 429                         !strcmp(dev_info.driver_name, s))       \
 430                  xd->pmd = VNET_DPDK_PMD_##f;
 431           if (0)
 432             ;
 433           foreach_dpdk_pmd
 434 #undef _
 435             else
 436             xd->pmd = VNET_DPDK_PMD_UNKNOWN;
 437
 438           xd->port_type = VNET_DPDK_PORT_TYPE_UNKNOWN;
 439           xd->nb_rx_desc = DPDK_NB_RX_DESC_DEFAULT;
 440           xd->nb_tx_desc = DPDK_NB_TX_DESC_DEFAULT;
 441
 442           switch (xd->pmd)
 443             {
 444               /* Drivers with valid speed_capa set */
 445             case VNET_DPDK_PMD_E1000EM:
 446             case VNET_DPDK_PMD_IGB:
 447             case VNET_DPDK_PMD_IXGBE:
 448             case VNET_DPDK_PMD_I40E:
 449               xd->port_type = port_type_from_speed_capa (&dev_info);
 450               xd->supported_flow_actions = VNET_FLOW_ACTION_MARK |
 451                 VNET_FLOW_ACTION_REDIRECT_TO_NODE |
 452                 VNET_FLOW_ACTION_BUFFER_ADVANCE |
 453                 VNET_FLOW_ACTION_COUNT | VNET_FLOW_ACTION_DROP;
 454
 455               if (dm->conf->no_tx_checksum_offload == 0)
 456                 {
 457                   xd->port_conf.txmode.offloads |= DEV_TX_OFFLOAD_TCP_CKSUM;
 458                   xd->port_conf.txmode.offloads |= DEV_TX_OFFLOAD_UDP_CKSUM;
 459                   xd->flags |=
 460                     DPDK_DEVICE_FLAG_TX_OFFLOAD |
 461                     DPDK_DEVICE_FLAG_INTEL_PHDR_CKSUM;
 462                 }
 463
 464
 465               break;
 466             case VNET_DPDK_PMD_CXGBE:
 467             case VNET_DPDK_PMD_MLX4:
 468             case VNET_DPDK_PMD_MLX5:
 469             case VNET_DPDK_PMD_QEDE:
 470               xd->port_type = port_type_from_speed_capa (&dev_info);
 471               break;
 472
 473               /* SR-IOV VFs */
 474             case VNET_DPDK_PMD_IGBVF:
 475             case VNET_DPDK_PMD_IXGBEVF:
 476             case VNET_DPDK_PMD_I40EVF:
 477               xd->port_type = VNET_DPDK_PORT_TYPE_ETH_VF;
 478 #if RTE_VERSION < RTE_VERSION_NUM(18, 11, 0, 0)
 479               xd->port_conf.rxmode.offloads |= DEV_RX_OFFLOAD_CRC_STRIP;
 480 #endif
 481               break;
 482
 483             case VNET_DPDK_PMD_THUNDERX:
 484               xd->port_type = VNET_DPDK_PORT_TYPE_ETH_VF;
 485 #if RTE_VERSION < RTE_VERSION_NUM(18, 11, 0, 0)
 486               xd->port_conf.rxmode.offloads |= DEV_RX_OFFLOAD_CRC_STRIP;
 487 #endif
 488
 489               if (dm->conf->no_tx_checksum_offload == 0)
 490                 {
 491                   xd->port_conf.txmode.offloads |= DEV_TX_OFFLOAD_TCP_CKSUM;
 492                   xd->port_conf.txmode.offloads |= DEV_TX_OFFLOAD_UDP_CKSUM;
 493                   xd->flags |= DPDK_DEVICE_FLAG_TX_OFFLOAD;
 494                 }
 495               break;
 496
 497             case VNET_DPDK_PMD_ENA:
 498               xd->port_type = VNET_DPDK_PORT_TYPE_ETH_VF;
 499               xd->port_conf.rxmode.offloads &= ~DEV_RX_OFFLOAD_SCATTER;
 500               break;
 501
 502             case VNET_DPDK_PMD_DPAA2:
 503               xd->port_type = VNET_DPDK_PORT_TYPE_ETH_10G;
 504               break;
 505
 506               /* Cisco VIC */
 507             case VNET_DPDK_PMD_ENIC:
 508               if (l.link_speed == 40000)
 509                 xd->port_type = VNET_DPDK_PORT_TYPE_ETH_40G;
 510               else
 511                 xd->port_type = VNET_DPDK_PORT_TYPE_ETH_10G;
 512               break;
 513
 514               /* Intel Red Rock Canyon */
 515             case VNET_DPDK_PMD_FM10K:
 516               xd->port_type = VNET_DPDK_PORT_TYPE_ETH_SWITCH;
 517 #if RTE_VERSION < RTE_VERSION_NUM(18, 11, 0, 0)
 518               xd->port_conf.rxmode.offloads |= DEV_RX_OFFLOAD_CRC_STRIP;
 519 #endif
 520               break;
 521
 522               /* virtio */
 523             case VNET_DPDK_PMD_VIRTIO:
 524               xd->port_type = VNET_DPDK_PORT_TYPE_ETH_1G;
 525               xd->nb_rx_desc = DPDK_NB_RX_DESC_VIRTIO;
 526               xd->nb_tx_desc = DPDK_NB_TX_DESC_VIRTIO;
 527               break;
 528
 529               /* vmxnet3 */
 530             case VNET_DPDK_PMD_VMXNET3:
 531               xd->port_type = VNET_DPDK_PORT_TYPE_ETH_1G;
 532               xd->port_conf.txmode.offloads |= DEV_TX_OFFLOAD_MULTI_SEGS;
 533               break;
 534
 535             case VNET_DPDK_PMD_AF_PACKET:
 536               xd->port_type = VNET_DPDK_PORT_TYPE_AF_PACKET;
 537               xd->af_packet_instance_num = af_packet_instance_num++;
 538               break;
 539
 540             case VNET_DPDK_PMD_BOND:
 541               xd->port_type = VNET_DPDK_PORT_TYPE_ETH_BOND;
 542               xd->bond_instance_num = bond_ether_instance_num++;
 543               break;
 544
 545             case VNET_DPDK_PMD_VIRTIO_USER:
 546               xd->port_type = VNET_DPDK_PORT_TYPE_VIRTIO_USER;
 547               break;
 548
 549             case VNET_DPDK_PMD_VHOST_ETHER:
 550               xd->port_type = VNET_DPDK_PORT_TYPE_VHOST_ETHER;
 551               break;
 552
 553             case VNET_DPDK_PMD_LIOVF_ETHER:
 554               xd->port_type = VNET_DPDK_PORT_TYPE_ETH_VF;
 555               break;
 556
 557             case VNET_DPDK_PMD_FAILSAFE:
 558               xd->port_type = VNET_DPDK_PORT_TYPE_FAILSAFE;
 559               xd->port_conf.intr_conf.lsc = 1;
 560               break;
 561
 562             case VNET_DPDK_PMD_NETVSC:
 563               xd->port_type = port_type_from_link_speed (l.link_speed);
 564               break;
 565
 566             default:
 567               xd->port_type = VNET_DPDK_PORT_TYPE_UNKNOWN;
 568             }
 569
 570           if (devconf->num_rx_desc)
 571             xd->nb_rx_desc = devconf->num_rx_desc;
 572
 573           if (devconf->num_tx_desc)
 574             xd->nb_tx_desc = devconf->num_tx_desc;
 575         }
 576
 577       if (xd->pmd == VNET_DPDK_PMD_AF_PACKET)
 578         {
 579           f64 now = vlib_time_now (vm);
 580           u32 rnd;
 581           rnd = (u32) (now * 1e6);
 582           rnd = random_u32 (&rnd);
 583           clib_memcpy (addr + 2, &rnd, sizeof (rnd));
 584           addr[0] = 2;
 585           addr[1] = 0xfe;
 586         }
 587       else
 588         rte_eth_macaddr_get (i, (struct ether_addr *) addr);
 589
 590       if (xd->tx_q_used < tm->n_vlib_mains)
 591         dpdk_device_lock_init (xd);
 592
 593       xd->port_id = i;
 594       xd->device_index = xd - dm->devices;
 595       xd->per_interface_next_index = ~0;
 596
 597       /* assign interface to input thread */
 598       int q;
 599
 600       if (devconf->hqos_enabled)
 601         {
 602           xd->flags |= DPDK_DEVICE_FLAG_HQOS;
 603
 604           int cpu;
 605           if (devconf->hqos.hqos_thread_valid)
 606             {
 607               if (devconf->hqos.hqos_thread >= dm->hqos_cpu_count)
 608                 return clib_error_return (0, "invalid HQoS thread index");
 609
 610               cpu = dm->hqos_cpu_first_index + devconf->hqos.hqos_thread;
 611             }
 612           else
 613             {
 614               if (dm->hqos_cpu_count == 0)
 615                 return clib_error_return (0, "no HQoS threads available");
 616
 617               cpu = dm->hqos_cpu_first_index + next_hqos_cpu;
 618
 619               next_hqos_cpu++;
 620               if (next_hqos_cpu == dm->hqos_cpu_count)
 621                 next_hqos_cpu = 0;
 622
 623               devconf->hqos.hqos_thread_valid = 1;
 624               devconf->hqos.hqos_thread = cpu;
 625             }
 626
 627           dpdk_device_and_queue_t *dq;
 628           vec_add2 (dm->devices_by_hqos_cpu[cpu], dq, 1);
 629           dq->device = xd->device_index;
 630           dq->queue_id = 0;
 631         }
 632
 633       /* count the number of descriptors used for this device */
 634       nb_desc += xd->nb_rx_desc + xd->nb_tx_desc * xd->tx_q_used;
 635
 636       error = ethernet_register_interface
 637         (dm->vnet_main, dpdk_device_class.index, xd->device_index,
 638          /* ethernet address */ addr,
 639          &xd->hw_if_index, dpdk_flag_change);
 640       if (error)
 641         return error;
 642
 643       /*
 644        * Ensure default mtu is not > the mtu read from the hardware.
 645        * Otherwise rte_eth_dev_configure() will fail and the port will
 646        * not be available.
 647        * Calculate max_frame_size and mtu supported by NIC
 648        */
 649       if (ETHERNET_MAX_PACKET_BYTES > dev_info.max_rx_pktlen)
 650         {
 651           /*
 652            * This device does not support the platforms's max frame
 653            * size. Use it's advertised mru instead.
 654            */
 655           max_rx_frame = dev_info.max_rx_pktlen;
 656           mtu = dev_info.max_rx_pktlen - sizeof (ethernet_header_t);
 657         }
 658       else
 659         {
 660           /* VPP treats MTU and max_rx_pktlen both equal to
 661            * ETHERNET_MAX_PACKET_BYTES, if dev_info.max_rx_pktlen >=
 662            * ETHERNET_MAX_PACKET_BYTES + sizeof(ethernet_header_t)
 663            */
 664           if (dev_info.max_rx_pktlen >= (ETHERNET_MAX_PACKET_BYTES +
 665                                          sizeof (ethernet_header_t)))
 666             {
 667               mtu = ETHERNET_MAX_PACKET_BYTES;
 668               max_rx_frame = ETHERNET_MAX_PACKET_BYTES;
 669
 670               /*
 671                * Some platforms do not account for Ethernet FCS (4 bytes) in
 672                * MTU calculations. To interop with them increase mru but only
 673                * if the device's settings can support it.
 674                */
 675               if (dpdk_port_crc_strip_enabled (xd) &&
 676                   (dev_info.max_rx_pktlen >= (ETHERNET_MAX_PACKET_BYTES +
 677                                               sizeof (ethernet_header_t) +
 678                                               4)))
 679                 {
 680                   max_rx_frame += 4;
 681                 }
 682             }
 683           else
 684             {
 685               max_rx_frame = ETHERNET_MAX_PACKET_BYTES;
 686               mtu = ETHERNET_MAX_PACKET_BYTES - sizeof (ethernet_header_t);
 687
 688               if (dpdk_port_crc_strip_enabled (xd) &&
 689                   (dev_info.max_rx_pktlen >= (ETHERNET_MAX_PACKET_BYTES + 4)))
 690                 {
 691                   max_rx_frame += 4;
 692                 }
 693             }
 694         }
 695
 696       if (xd->pmd == VNET_DPDK_PMD_FAILSAFE)
 697         {
 698           /* failsafe device numerables are reported with active device only,
 699            * need to query the mtu for current device setup to overwrite
 700            * reported value.
 701            */
 702           uint16_t dev_mtu;
 703           if (!rte_eth_dev_get_mtu (i, &dev_mtu))
 704             {
 705               mtu = dev_mtu;
 706               max_rx_frame = mtu + sizeof (ethernet_header_t);
 707
 708               if (dpdk_port_crc_strip_enabled (xd))
 709                 {
 710                   max_rx_frame += 4;
 711                 }
 712             }
 713         }
 714
 715       /*Set port rxmode config */
 716       xd->port_conf.rxmode.max_rx_pkt_len = max_rx_frame;
 717
 718       sw = vnet_get_hw_sw_interface (dm->vnet_main, xd->hw_if_index);
 719       xd->sw_if_index = sw->sw_if_index;
 720       vnet_hw_interface_set_input_node (dm->vnet_main, xd->hw_if_index,
 721                                         dpdk_input_node.index);
 722
 723       if (devconf->workers)
 724         {
 725           int i;
 726           q = 0;
 727           clib_bitmap_foreach (i, devconf->workers, ({
 728             vnet_hw_interface_assign_rx_thread (dm->vnet_main, xd->hw_if_index, q++,
 729                                              vdm->first_worker_thread_index + i);
 730           }));
 731         }
 732       else
 733         for (q = 0; q < xd->rx_q_used; q++)
 734           {
 735             vnet_hw_interface_assign_rx_thread (dm->vnet_main, xd->hw_if_index, q,      /* any */
 736                                                 ~1);
 737           }
 738
 739       /*Get vnet hardware interface */
 740       hi = vnet_get_hw_interface (dm->vnet_main, xd->hw_if_index);
 741
 742       /*Override default max_packet_bytes and max_supported_bytes set in
 743        * ethernet_register_interface() above*/
 744       if (hi)
 745         {
 746           hi->max_packet_bytes = mtu;
 747           hi->max_supported_packet_bytes = max_rx_frame;
 748         }
 749
 750       if (dm->conf->no_tx_checksum_offload == 0)
 751         if (xd->flags & DPDK_DEVICE_FLAG_TX_OFFLOAD && hi != NULL)
 752           hi->flags |= VNET_HW_INTERFACE_FLAG_SUPPORTS_TX_L4_CKSUM_OFFLOAD;
 753
 754       dpdk_device_setup (xd);
 755
 756       if (vec_len (xd->errors))
 757         dpdk_log_err ("setup failed for device %U. Errors:\n  %U",
 758                       format_dpdk_device_name, i,
 759                       format_dpdk_device_errors, xd);
 760
 761       if (devconf->hqos_enabled)
 762         {
 763           clib_error_t *rv;
 764           rv = dpdk_port_setup_hqos (xd, &devconf->hqos);
 765           if (rv)
 766             return rv;
 767         }
 768
 769       /*
 770        * For cisco VIC vNIC, set default to VLAN strip enabled, unless
 771        * specified otherwise in the startup config.
 772        * For other NICs default to VLAN strip disabled, unless specified
 773        * otherwise in the startup config.
 774        */
 775       if (xd->pmd == VNET_DPDK_PMD_ENIC)
 776         {
 777           if (devconf->vlan_strip_offload != DPDK_DEVICE_VLAN_STRIP_OFF)
 778             vlan_strip = 1;     /* remove vlan tag from VIC port by default */
 779           else
 780             dpdk_log_warn ("VLAN strip disabled for interface\n");
 781         }
 782       else if (devconf->vlan_strip_offload == DPDK_DEVICE_VLAN_STRIP_ON)
 783         vlan_strip = 1;
 784
 785       if (vlan_strip)
 786         {
 787           int vlan_off;
 788           vlan_off = rte_eth_dev_get_vlan_offload (xd->port_id);
 789           vlan_off |= ETH_VLAN_STRIP_OFFLOAD;
 790           if (vlan_off)
 791             xd->port_conf.rxmode.offloads |= DEV_RX_OFFLOAD_VLAN_STRIP;
 792           else
 793             xd->port_conf.rxmode.offloads &= ~DEV_RX_OFFLOAD_VLAN_STRIP;
 794           if (rte_eth_dev_set_vlan_offload (xd->port_id, vlan_off) == 0)
 795             dpdk_log_info ("VLAN strip enabled for interface\n");
 796           else
 797             dpdk_log_warn ("VLAN strip cannot be supported by interface\n");
 798         }
 799
 800       if (hi)
 801         hi->max_packet_bytes = xd->port_conf.rxmode.max_rx_pkt_len
 802           - sizeof (ethernet_header_t);
 803       else
 804         clib_warning ("hi NULL");
 805
 806       if (dm->conf->no_multi_seg)
 807         mtu = mtu > ETHER_MAX_LEN ? ETHER_MAX_LEN : mtu;
 808
 809       rte_eth_dev_set_mtu (xd->port_id, mtu);
 810     }
 811   /* *INDENT-ON* */
 812
 813   if (nb_desc > dm->conf->num_mbufs)
 814     dpdk_log_err ("%d mbufs allocated but total rx/tx ring size is %d\n",
 815                   dm->conf->num_mbufs, nb_desc);
 816
 817   return 0;
 818 }
 819
 820 static void
 821 dpdk_bind_devices_to_uio (dpdk_config_main_t * conf)
 822 {
 823   vlib_main_t *vm = vlib_get_main ();
 824   clib_error_t *error;
 825   u8 *pci_addr = 0;
 826   int num_whitelisted = vec_len (conf->dev_confs);
 827   vlib_pci_device_info_t *d = 0;
 828   vlib_pci_addr_t *addr = 0, *addrs;
 829   int i;
 830
 831   addrs = vlib_pci_get_all_dev_addrs ();
 832   /* *INDENT-OFF* */
 833   vec_foreach (addr, addrs)
 834     {
 835     dpdk_device_config_t * devconf = 0;
 836     vec_reset_length (pci_addr);
 837     pci_addr = format (pci_addr, "%U%c", format_vlib_pci_addr, addr, 0);
 838     if (d)
 839     {
 840       vlib_pci_free_device_info (d);
 841       d = 0;
 842       }
 843     d = vlib_pci_get_device_info (vm, addr, &error);
 844     if (error)
 845     {
 846       clib_error_report (error);
 847       continue;
 848     }
 849
 850     if (d->device_class != PCI_CLASS_NETWORK_ETHERNET && d->device_class != PCI_CLASS_PROCESSOR_CO)
 851       continue;
 852
 853     if (num_whitelisted)
 854       {
 855         uword * p = hash_get (conf->device_config_index_by_pci_addr, addr->as_u32);
 856
 857         if (!p)
 858           {
 859           skipped:
 860             continue;
 861           }
 862
 863         devconf = pool_elt_at_index (conf->dev_confs, p[0]);
 864       }
 865
 866     /* Enforce Device blacklist by vendor and device */
 867     for (i = 0; i < vec_len (conf->blacklist_by_pci_vendor_and_device); i++)
 868       {
 869         u16 vendor, device;
 870         vendor = (u16)(conf->blacklist_by_pci_vendor_and_device[i] >> 16);
 871         device = (u16)(conf->blacklist_by_pci_vendor_and_device[i] & 0xFFFF);
 872         if (d->vendor_id == vendor && d->device_id == device)
 873           {
 874             /*
 875              * Expected case: device isn't whitelisted,
 876              * so blacklist it...
 877              */
 878             if (devconf == 0)
 879               {
 880                 /* Device is blacklisted */
 881                 pool_get (conf->dev_confs, devconf);
 882                 hash_set (conf->device_config_index_by_pci_addr, addr->as_u32,
 883                           devconf - conf->dev_confs);
 884                 devconf->pci_addr.as_u32 = addr->as_u32;
 885                 devconf->is_blacklisted = 1;
 886                 goto skipped;
 887               }
 888             else /* explicitly whitelisted, ignore the device blacklist  */
 889               break;
 890           }
 891       }
 892
 893     /* virtio */
 894     if (d->vendor_id == 0x1af4 &&
 895             (d->device_id == VIRTIO_PCI_LEGACY_DEVICEID_NET ||
 896              d->device_id == VIRTIO_PCI_MODERN_DEVICEID_NET))
 897       ;
 898     /* vmxnet3 */
 899     else if (d->vendor_id == 0x15ad && d->device_id == 0x07b0)
 900       {
 901         /*
 902          * For vmxnet3 PCI, unless it is explicitly specified in the whitelist,
 903          * the default is to put it in the blacklist.
 904          */
 905         if (devconf == 0)
 906           {
 907             pool_get (conf->dev_confs, devconf);
 908             hash_set (conf->device_config_index_by_pci_addr, addr->as_u32,
 909                       devconf - conf->dev_confs);
 910             devconf->pci_addr.as_u32 = addr->as_u32;
 911             devconf->is_blacklisted = 1;
 912           }
 913       }
 914     /* all Intel network devices */
 915     else if (d->vendor_id == 0x8086 && d->device_class == PCI_CLASS_NETWORK_ETHERNET)
 916       ;
 917     /* all Intel QAT devices VFs */
 918     else if (d->vendor_id == 0x8086 && d->device_class == PCI_CLASS_PROCESSOR_CO &&
 919         (d->device_id == 0x0443 || d->device_id == 0x37c9 || d->device_id == 0x19e3))
 920       ;
 921     /* Cisco VIC */
 922     else if (d->vendor_id == 0x1137 && d->device_id == 0x0043)
 923       ;
 924     /* Chelsio T4/T5 */
 925     else if (d->vendor_id == 0x1425 && (d->device_id & 0xe000) == 0x4000)
 926       ;
 927     /* Amazen Elastic Network Adapter */
 928     else if (d->vendor_id == 0x1d0f && d->device_id >= 0xec20 && d->device_id <= 0xec21)
 929       ;
 930     /* Cavium Network Adapter */
 931     else if (d->vendor_id == 0x177d && d->device_id == 0x9712)
 932       ;
 933     /* Cavium FastlinQ QL41000 Series */
 934     else if (d->vendor_id == 0x1077 && d->device_id >= 0x8070 && d->device_id <= 0x8090)
 935       ;
 936     /* Mellanox mlx4 */
 937     else if (d->vendor_id == 0x15b3 && d->device_id >= 0x1003 && d->device_id <= 0x1004)
 938       {
 939         continue;
 940       }
 941     /* Mellanox mlx5 */
 942     else if (d->vendor_id == 0x15b3 && d->device_id >= 0x1013 && d->device_id <= 0x101a)
 943       {
 944         continue;
 945       }
 946     else
 947       {
 948         dpdk_log_warn ("Unsupported PCI device 0x%04x:0x%04x found "
 949                       "at PCI address %s\n", (u16) d->vendor_id, (u16) d->device_id,
 950                       pci_addr);
 951         continue;
 952       }
 953
 954     error = vlib_pci_bind_to_uio (vm, addr, (char *) conf->uio_driver_name);
 955
 956     if (error)
 957       {
 958         if (devconf == 0)
 959           {
 960             pool_get (conf->dev_confs, devconf);
 961             hash_set (conf->device_config_index_by_pci_addr, addr->as_u32,
 962                       devconf - conf->dev_confs);
 963             devconf->pci_addr.as_u32 = addr->as_u32;
 964           }
 965         devconf->is_blacklisted = 1;
 966         clib_error_report (error);
 967       }
 968   }
 969   /* *INDENT-ON* */
 970   vec_free (pci_addr);
 971   vlib_pci_free_device_info (d);
 972 }
 973
 974 static void
 975 dpdk_bind_vmbus_devices_to_uio (dpdk_config_main_t * conf)
 976 {
 977   clib_error_t *error;
 978   vlib_vmbus_addr_t *addrs, *addr = 0;
 979
 980   addrs = vlib_vmbus_get_all_dev_addrs ();
 981
 982   /* *INDENT-OFF* */
 983   vec_foreach (addr, addrs)
 984     {
 985       error = vlib_vmbus_bind_to_uio (addr);
 986
 987       if (error)
 988         {
 989           clib_error_report (error);
 990         }
 991     }
 992   /* *INDENT-ON* */
 993 }
 994
 995 static clib_error_t *
 996 dpdk_device_config (dpdk_config_main_t * conf, vlib_pci_addr_t pci_addr,
 997                     unformat_input_t * input, u8 is_default)
 998 {
 999   clib_error_t *error = 0;
1000   uword *p;
1001   dpdk_device_config_t *devconf;
1002   unformat_input_t sub_input;
1003
1004   if (is_default)
1005     {
1006       devconf = &conf->default_devconf;
1007     }
1008   else
1009     {
1010       p = hash_get (conf->device_config_index_by_pci_addr, pci_addr.as_u32);
1011
1012       if (!p)
1013         {
1014           pool_get (conf->dev_confs, devconf);
1015           hash_set (conf->device_config_index_by_pci_addr, pci_addr.as_u32,
1016                     devconf - conf->dev_confs);
1017         }
1018       else
1019         return clib_error_return (0,
1020                                   "duplicate configuration for PCI address %U",
1021                                   format_vlib_pci_addr, &pci_addr);
1022     }
1023
1024   devconf->pci_addr.as_u32 = pci_addr.as_u32;
1025   devconf->hqos_enabled = 0;
1026   dpdk_device_config_hqos_default (&devconf->hqos);
1027
1028   if (!input)
1029     return 0;
1030
1031   unformat_skip_white_space (input);
1032   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1033     {
1034       if (unformat (input, "num-rx-queues %u", &devconf->num_rx_queues))
1035         ;
1036       else if (unformat (input, "num-tx-queues %u", &devconf->num_tx_queues))
1037         ;
1038       else if (unformat (input, "num-rx-desc %u", &devconf->num_rx_desc))
1039         ;
1040       else if (unformat (input, "num-tx-desc %u", &devconf->num_tx_desc))
1041         ;
1042       else if (unformat (input, "name %s", &devconf->name))
1043         ;
1044       else if (unformat (input, "workers %U", unformat_bitmap_list,
1045                          &devconf->workers))
1046         ;
1047       else
1048         if (unformat
1049             (input, "rss %U", unformat_vlib_cli_sub_input, &sub_input))
1050         {
1051           error = unformat_rss_fn (&sub_input, &devconf->rss_fn);
1052           if (error)
1053             break;
1054         }
1055       else if (unformat (input, "vlan-strip-offload off"))
1056         devconf->vlan_strip_offload = DPDK_DEVICE_VLAN_STRIP_OFF;
1057       else if (unformat (input, "vlan-strip-offload on"))
1058         devconf->vlan_strip_offload = DPDK_DEVICE_VLAN_STRIP_ON;
1059       else
1060         if (unformat
1061             (input, "hqos %U", unformat_vlib_cli_sub_input, &sub_input))
1062         {
1063           devconf->hqos_enabled = 1;
1064           error = unformat_hqos (&sub_input, &devconf->hqos);
1065           if (error)
1066             break;
1067         }
1068       else if (unformat (input, "hqos"))
1069         {
1070           devconf->hqos_enabled = 1;
1071         }
1072       else
1073         {
1074           error = clib_error_return (0, "unknown input `%U'",
1075                                      format_unformat_error, input);
1076           break;
1077         }
1078     }
1079
1080   if (error)
1081     return error;
1082
1083   if (devconf->workers && devconf->num_rx_queues == 0)
1084     devconf->num_rx_queues = clib_bitmap_count_set_bits (devconf->workers);
1085   else if (devconf->workers &&
1086            clib_bitmap_count_set_bits (devconf->workers) !=
1087            devconf->num_rx_queues)
1088     error =
1089       clib_error_return (0,
1090                          "%U: number of worker threads must be "
1091                          "equal to number of rx queues", format_vlib_pci_addr,
1092                          &pci_addr);
1093
1094   return error;
1095 }
1096
1097 static clib_error_t *
1098 dpdk_log_read_ready (clib_file_t * uf)
1099 {
1100   unformat_input_t input;
1101   u8 *line, *s = 0;
1102   int n, n_try;
1103
1104   n = n_try = 4096;
1105   while (n == n_try)
1106     {
1107       uword len = vec_len (s);
1108       vec_resize (s, len + n_try);
1109
1110       n = read (uf->file_descriptor, s + len, n_try);
1111       if (n < 0 && errno != EAGAIN)
1112         return clib_error_return_unix (0, "read");
1113       _vec_len (s) = len + (n < 0 ? 0 : n);
1114     }
1115
1116   unformat_init_vector (&input, s);
1117
1118   while (unformat_user (&input, unformat_line, &line))
1119     {
1120       dpdk_log_notice ("%v", line);
1121       vec_free (line);
1122     }
1123
1124   unformat_free (&input);
1125   return 0;
1126 }
1127
1128 static clib_error_t *
1129 dpdk_config (vlib_main_t * vm, unformat_input_t * input)
1130 {
1131   clib_error_t *error = 0;
1132   dpdk_config_main_t *conf = &dpdk_config_main;
1133   vlib_thread_main_t *tm = vlib_get_thread_main ();
1134   dpdk_device_config_t *devconf;
1135   vlib_pci_addr_t pci_addr;
1136   unformat_input_t sub_input;
1137   uword default_hugepage_sz, x;
1138   u8 *s, *tmp = 0;
1139   u32 log_level;
1140   int ret, i;
1141   int num_whitelisted = 0;
1142   u8 no_pci = 0;
1143   u8 no_vmbus = 0;
1144   u8 file_prefix = 0;
1145   u8 *socket_mem = 0;
1146   u8 *huge_dir_path = 0;
1147   u32 vendor, device;
1148
1149   huge_dir_path =
1150     format (0, "%s/hugepages%c", vlib_unix_get_runtime_dir (), 0);
1151
1152   conf->device_config_index_by_pci_addr = hash_create (0, sizeof (uword));
1153   log_level = RTE_LOG_NOTICE;
1154
1155   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1156     {
1157       /* Prime the pump */
1158       if (unformat (input, "no-hugetlb"))
1159         {
1160           vec_add1 (conf->eal_init_args, (u8 *) "--no-huge");
1161         }
1162
1163       else if (unformat (input, "enable-tcp-udp-checksum"))
1164         conf->enable_tcp_udp_checksum = 1;
1165
1166       else if (unformat (input, "no-tx-checksum-offload"))
1167         conf->no_tx_checksum_offload = 1;
1168
1169       else if (unformat (input, "decimal-interface-names"))
1170         conf->interface_name_format_decimal = 1;
1171
1172       else if (unformat (input, "log-level %U", unformat_dpdk_log_level, &x))
1173         log_level = x;
1174
1175       else if (unformat (input, "no-multi-seg"))
1176         conf->no_multi_seg = 1;
1177
1178       else if (unformat (input, "dev default %U", unformat_vlib_cli_sub_input,
1179                          &sub_input))
1180         {
1181           error =
1182             dpdk_device_config (conf, (vlib_pci_addr_t) (u32) ~ 1, &sub_input,
1183                                 1);
1184
1185           if (error)
1186             return error;
1187         }
1188       else
1189         if (unformat
1190             (input, "dev %U %U", unformat_vlib_pci_addr, &pci_addr,
1191              unformat_vlib_cli_sub_input, &sub_input))
1192         {
1193           error = dpdk_device_config (conf, pci_addr, &sub_input, 0);
1194
1195           if (error)
1196             return error;
1197
1198           num_whitelisted++;
1199         }
1200       else if (unformat (input, "dev %U", unformat_vlib_pci_addr, &pci_addr))
1201         {
1202           error = dpdk_device_config (conf, pci_addr, 0, 0);
1203
1204           if (error)
1205             return error;
1206
1207           num_whitelisted++;
1208         }
1209       else if (unformat (input, "num-mem-channels %d", &conf->nchannels))
1210         conf->nchannels_set_manually = 0;
1211       else if (unformat (input, "num-mbufs %d", &conf->num_mbufs))
1212         ;
1213       else if (unformat (input, "uio-driver %s", &conf->uio_driver_name))
1214         ;
1215       else if (unformat (input, "socket-mem %s", &socket_mem))
1216         ;
1217       else if (unformat (input, "no-pci"))
1218         {
1219           no_pci = 1;
1220           tmp = format (0, "--no-pci%c", 0);
1221           vec_add1 (conf->eal_init_args, tmp);
1222         }
1223       else if (unformat (input, "blacklist %x:%x", &vendor, &device))
1224         {
1225           u32 blacklist_entry;
1226           if (vendor > 0xFFFF)
1227             return clib_error_return (0, "blacklist PCI vendor out of range");
1228           if (device > 0xFFFF)
1229             return clib_error_return (0, "blacklist PCI device out of range");
1230           blacklist_entry = (vendor << 16) | (device & 0xffff);
1231           vec_add1 (conf->blacklist_by_pci_vendor_and_device,
1232                     blacklist_entry);
1233         }
1234       else if (unformat (input, "no-vmbus"))
1235         {
1236           no_vmbus = 1;
1237           tmp = format (0, "--no-vmbus%c", 0);
1238           vec_add1 (conf->eal_init_args, tmp);
1239         }
1240
1241 #define _(a)                                    \
1242       else if (unformat(input, #a))             \
1243         {                                       \
1244           tmp = format (0, "--%s%c", #a, 0);    \
1245           vec_add1 (conf->eal_init_args, tmp);    \
1246         }
1247       foreach_eal_double_hyphen_predicate_arg
1248 #undef _
1249 #define _(a)                                          \
1250         else if (unformat(input, #a " %s", &s))       \
1251           {                                           \
1252             if (!strncmp(#a, "file-prefix", 11)) \
1253               file_prefix = 1;                        \
1254             tmp = format (0, "--%s%c", #a, 0);        \
1255             vec_add1 (conf->eal_init_args, tmp);      \
1256             vec_add1 (s, 0);                          \
1257             if (!strncmp(#a, "vdev", 4))              \
1258               if (strstr((char*)s, "af_packet"))      \
1259                 clib_warning ("af_packet obsoleted. Use CLI 'create host-interface'."); \
1260             vec_add1 (conf->eal_init_args, s);        \
1261           }
1262         foreach_eal_double_hyphen_arg
1263 #undef _
1264 #define _(a,b)                                          \
1265           else if (unformat(input, #a " %s", &s))       \
1266             {                                           \
1267               tmp = format (0, "-%s%c", #b, 0);         \
1268               vec_add1 (conf->eal_init_args, tmp);      \
1269               vec_add1 (s, 0);                          \
1270               vec_add1 (conf->eal_init_args, s);        \
1271             }
1272         foreach_eal_single_hyphen_arg
1273 #undef _
1274 #define _(a,b)                                          \
1275             else if (unformat(input, #a " %s", &s))     \
1276               {                                         \
1277                 tmp = format (0, "-%s%c", #b, 0);       \
1278                 vec_add1 (conf->eal_init_args, tmp);    \
1279                 vec_add1 (s, 0);                        \
1280                 vec_add1 (conf->eal_init_args, s);      \
1281                 conf->a##_set_manually = 1;             \
1282               }
1283         foreach_eal_single_hyphen_mandatory_arg
1284 #undef _
1285         else if (unformat (input, "default"))
1286         ;
1287
1288       else if (unformat_skip_white_space (input))
1289         ;
1290       else
1291         {
1292           error = clib_error_return (0, "unknown input `%U'",
1293                                      format_unformat_error, input);
1294           goto done;
1295         }
1296     }
1297
1298   if (!conf->uio_driver_name)
1299     conf->uio_driver_name = format (0, "auto%c", 0);
1300
1301   default_hugepage_sz = clib_mem_get_default_hugepage_size ();
1302
1303   /* *INDENT-OFF* */
1304   clib_bitmap_foreach (x, tm->cpu_socket_bitmap, (
1305     {
1306       clib_error_t *e;
1307       uword n_pages;
1308       /* preallocate at least 16MB of hugepages per socket,
1309          if more is needed it is up to consumer to preallocate more */
1310       n_pages = round_pow2 ((uword) 16 << 20, default_hugepage_sz);
1311       n_pages /= default_hugepage_sz;
1312
1313       if ((e = clib_sysfs_prealloc_hugepages(x, 0, n_pages)))
1314         clib_error_report (e);
1315   }));
1316   /* *INDENT-ON* */
1317
1318   if (!file_prefix)
1319     {
1320       tmp = format (0, "--file-prefix%c", 0);
1321       vec_add1 (conf->eal_init_args, tmp);
1322       tmp = format (0, "vpp%c", 0);
1323       vec_add1 (conf->eal_init_args, tmp);
1324     }
1325
1326   if (error)
1327     return error;
1328
1329   /* I'll bet that -c and -n must be the first and second args... */
1330   if (!conf->coremask_set_manually)
1331     {
1332       vlib_thread_registration_t *tr;
1333       uword *coremask = 0;
1334       int i;
1335
1336       /* main thread core */
1337       coremask = clib_bitmap_set (coremask, tm->main_lcore, 1);
1338
1339       for (i = 0; i < vec_len (tm->registrations); i++)
1340         {
1341           tr = tm->registrations[i];
1342           coremask = clib_bitmap_or (coremask, tr->coremask);
1343         }
1344
1345       vec_insert (conf->eal_init_args, 2, 1);
1346       conf->eal_init_args[1] = (u8 *) "-c";
1347       tmp = format (0, "%U%c", format_bitmap_hex, coremask, 0);
1348       conf->eal_init_args[2] = tmp;
1349       clib_bitmap_free (coremask);
1350     }
1351
1352   if (!conf->nchannels_set_manually)
1353     {
1354       vec_insert (conf->eal_init_args, 2, 3);
1355       conf->eal_init_args[3] = (u8 *) "-n";
1356       tmp = format (0, "%d", conf->nchannels);
1357       conf->eal_init_args[4] = tmp;
1358     }
1359
1360   if (no_pci == 0 && geteuid () == 0)
1361     dpdk_bind_devices_to_uio (conf);
1362
1363   if (no_vmbus == 0 && geteuid () == 0)
1364     dpdk_bind_vmbus_devices_to_uio (conf);
1365
1366 #define _(x) \
1367     if (devconf->x == 0 && conf->default_devconf.x > 0) \
1368       devconf->x = conf->default_devconf.x ;
1369
1370   /* *INDENT-OFF* */
1371   pool_foreach (devconf, conf->dev_confs, ({
1372
1373     /* default per-device config items */
1374     foreach_dpdk_device_config_item
1375
1376     /* add DPDK EAL whitelist/blacklist entry */
1377     if (num_whitelisted > 0 && devconf->is_blacklisted == 0)
1378       {
1379         tmp = format (0, "-w%c", 0);
1380         vec_add1 (conf->eal_init_args, tmp);
1381         tmp = format (0, "%U%c", format_vlib_pci_addr, &devconf->pci_addr, 0);
1382         vec_add1 (conf->eal_init_args, tmp);
1383       }
1384     else if (num_whitelisted == 0 && devconf->is_blacklisted != 0)
1385       {
1386         tmp = format (0, "-b%c", 0);
1387         vec_add1 (conf->eal_init_args, tmp);
1388         tmp = format (0, "%U%c", format_vlib_pci_addr, &devconf->pci_addr, 0);
1389         vec_add1 (conf->eal_init_args, tmp);
1390       }
1391   }));
1392   /* *INDENT-ON* */
1393
1394 #undef _
1395
1396   /* set master-lcore */
1397   tmp = format (0, "--master-lcore%c", 0);
1398   vec_add1 (conf->eal_init_args, tmp);
1399   tmp = format (0, "%u%c", tm->main_lcore, 0);
1400   vec_add1 (conf->eal_init_args, tmp);
1401
1402
1403   if (socket_mem)
1404     clib_warning ("socket-mem argument is deprecated");
1405
1406   /* NULL terminate the "argv" vector, in case of stupidity */
1407   vec_add1 (conf->eal_init_args, 0);
1408   _vec_len (conf->eal_init_args) -= 1;
1409
1410   /* Set up DPDK eal and packet mbuf pool early. */
1411
1412   rte_log_set_global_level (log_level);
1413   int log_fds[2] = { 0 };
1414   if (pipe (log_fds) == 0)
1415     {
1416       if (fcntl (log_fds[1], F_SETFL, O_NONBLOCK) == 0)
1417         {
1418           FILE *f = fdopen (log_fds[1], "a");
1419           if (f && rte_openlog_stream (f) == 0)
1420             {
1421               clib_file_t t = { 0 };
1422               t.read_function = dpdk_log_read_ready;
1423               t.file_descriptor = log_fds[0];
1424               t.description = format (0, "DPDK logging pipe");
1425               clib_file_add (&file_main, &t);
1426             }
1427         }
1428       else
1429         {
1430           close (log_fds[0]);
1431           close (log_fds[1]);
1432         }
1433     }
1434
1435   vm = vlib_get_main ();
1436
1437   /* make copy of args as rte_eal_init tends to mess up with arg array */
1438   for (i = 1; i < vec_len (conf->eal_init_args); i++)
1439     conf->eal_init_args_str = format (conf->eal_init_args_str, "%s ",
1440                                       conf->eal_init_args[i]);
1441
1442   dpdk_log_warn ("EAL init args: %s", conf->eal_init_args_str);
1443   ret = rte_eal_init (vec_len (conf->eal_init_args),
1444                       (char **) conf->eal_init_args);
1445
1446   /* lazy umount hugepages */
1447   umount2 ((char *) huge_dir_path, MNT_DETACH);
1448   rmdir ((char *) huge_dir_path);
1449   vec_free (huge_dir_path);
1450
1451   if (ret < 0)
1452     return clib_error_return (0, "rte_eal_init returned %d", ret);
1453
1454   /* set custom ring memory allocator */
1455   {
1456     struct rte_mempool_ops *ops = NULL;
1457
1458     ops = get_ops_by_name ("ring_sp_sc");
1459     ops->alloc = dpdk_ring_alloc;
1460
1461     ops = get_ops_by_name ("ring_mp_sc");
1462     ops->alloc = dpdk_ring_alloc;
1463
1464     ops = get_ops_by_name ("ring_sp_mc");
1465     ops->alloc = dpdk_ring_alloc;
1466
1467     ops = get_ops_by_name ("ring_mp_mc");
1468     ops->alloc = dpdk_ring_alloc;
1469   }
1470
1471   /* main thread 1st */
1472   error = dpdk_buffer_pool_create (vm, conf->num_mbufs, rte_socket_id ());
1473   if (error)
1474     return error;
1475
1476   for (i = 0; i < RTE_MAX_LCORE; i++)
1477     {
1478       error = dpdk_buffer_pool_create (vm, conf->num_mbufs,
1479                                        rte_lcore_to_socket_id (i));
1480       if (error)
1481         return error;
1482     }
1483
1484 done:
1485   return error;
1486 }
1487
1488 VLIB_CONFIG_FUNCTION (dpdk_config, "dpdk");
1489
1490 void
1491 dpdk_update_link_state (dpdk_device_t * xd, f64 now)
1492 {
1493   vnet_main_t *vnm = vnet_get_main ();
1494   struct rte_eth_link prev_link = xd->link;
1495   u32 hw_flags = 0;
1496   u8 hw_flags_chg = 0;
1497
1498   /* only update link state for PMD interfaces */
1499   if ((xd->flags & DPDK_DEVICE_FLAG_PMD) == 0)
1500     return;
1501
1502   xd->time_last_link_update = now ? now : xd->time_last_link_update;
1503   clib_memset (&xd->link, 0, sizeof (xd->link));
1504   rte_eth_link_get_nowait (xd->port_id, &xd->link);
1505
1506   if (LINK_STATE_ELOGS)
1507     {
1508       vlib_main_t *vm = vlib_get_main ();
1509       ELOG_TYPE_DECLARE (e) =
1510       {
1511       .format =
1512           "update-link-state: sw_if_index %d, admin_up %d,"
1513           "old link_state %d new link_state %d",.format_args = "i4i1i1i1",};
1514
1515       struct
1516       {
1517         u32 sw_if_index;
1518         u8 admin_up;
1519         u8 old_link_state;
1520         u8 new_link_state;
1521       } *ed;
1522       ed = ELOG_DATA (&vm->elog_main, e);
1523       ed->sw_if_index = xd->sw_if_index;
1524       ed->admin_up = (xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP) != 0;
1525       ed->old_link_state = (u8)
1526         vnet_hw_interface_is_link_up (vnm, xd->hw_if_index);
1527       ed->new_link_state = (u8) xd->link.link_status;
1528     }
1529
1530   if ((xd->flags & (DPDK_DEVICE_FLAG_ADMIN_UP | DPDK_DEVICE_FLAG_BOND_SLAVE))
1531       && ((xd->link.link_status != 0) ^
1532           vnet_hw_interface_is_link_up (vnm, xd->hw_if_index)))
1533     {
1534       hw_flags_chg = 1;
1535       hw_flags |= (xd->link.link_status ? VNET_HW_INTERFACE_FLAG_LINK_UP : 0);
1536     }
1537
1538   if (hw_flags_chg || (xd->link.link_duplex != prev_link.link_duplex))
1539     {
1540       hw_flags_chg = 1;
1541       switch (xd->link.link_duplex)
1542         {
1543         case ETH_LINK_HALF_DUPLEX:
1544           hw_flags |= VNET_HW_INTERFACE_FLAG_HALF_DUPLEX;
1545           break;
1546         case ETH_LINK_FULL_DUPLEX:
1547           hw_flags |= VNET_HW_INTERFACE_FLAG_FULL_DUPLEX;
1548           break;
1549         default:
1550           break;
1551         }
1552     }
1553   if (xd->link.link_speed != prev_link.link_speed)
1554     vnet_hw_interface_set_link_speed (vnm, xd->hw_if_index,
1555                                       xd->link.link_speed * 1000);
1556
1557   if (hw_flags_chg)
1558     {
1559       if (LINK_STATE_ELOGS)
1560         {
1561           vlib_main_t *vm = vlib_get_main ();
1562
1563           ELOG_TYPE_DECLARE (e) =
1564           {
1565           .format =
1566               "update-link-state: sw_if_index %d, new flags %d",.format_args
1567               = "i4i4",};
1568
1569           struct
1570           {
1571             u32 sw_if_index;
1572             u32 flags;
1573           } *ed;
1574           ed = ELOG_DATA (&vm->elog_main, e);
1575           ed->sw_if_index = xd->sw_if_index;
1576           ed->flags = hw_flags;
1577         }
1578       vnet_hw_interface_set_flags (vnm, xd->hw_if_index, hw_flags);
1579     }
1580 }
1581
1582 static uword
1583 dpdk_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f)
1584 {
1585   clib_error_t *error;
1586   vnet_main_t *vnm = vnet_get_main ();
1587   dpdk_main_t *dm = &dpdk_main;
1588   ethernet_main_t *em = &ethernet_main;
1589   dpdk_device_t *xd;
1590   vlib_thread_main_t *tm = vlib_get_thread_main ();
1591   int i;
1592   int j;
1593
1594   error = dpdk_lib_init (dm);
1595
1596   if (error)
1597     clib_error_report (error);
1598
1599   tm->worker_thread_release = 1;
1600
1601   f64 now = vlib_time_now (vm);
1602   vec_foreach (xd, dm->devices)
1603   {
1604     dpdk_update_link_state (xd, now);
1605   }
1606
1607   {
1608     /*
1609      * Extra set up for bond interfaces:
1610      *  1. Setup MACs for bond interfaces and their slave links which was set
1611      *     in dpdk_device_setup() but needs to be done again here to take
1612      *     effect.
1613      *  2. Set up info and register slave link state change callback handling.
1614      *  3. Set up info for bond interface related CLI support.
1615      */
1616     int nports = rte_eth_dev_count_avail ();
1617     if (nports > 0)
1618       {
1619         /* *INDENT-OFF* */
1620         RTE_ETH_FOREACH_DEV(i)
1621           {
1622             xd = NULL;
1623             for (j = 0; j < nports; j++)
1624               {
1625                 if (dm->devices[j].port_id == i)
1626                   {
1627                     xd = &dm->devices[j];
1628                   }
1629               }
1630             if (xd != NULL && xd->pmd == VNET_DPDK_PMD_BOND)
1631               {
1632                 u8 addr[6];
1633                 dpdk_portid_t slink[16];
1634                 int nlink = rte_eth_bond_slaves_get (i, slink, 16);
1635                 if (nlink > 0)
1636                   {
1637                     vnet_hw_interface_t *bhi;
1638                     ethernet_interface_t *bei;
1639                     int rv;
1640
1641                     /* Get MAC of 1st slave link */
1642                     rte_eth_macaddr_get
1643                       (slink[0], (struct ether_addr *) addr);
1644
1645                     /* Set MAC of bounded interface to that of 1st slave link */
1646                     dpdk_log_info ("Set MAC for bond port %d BondEthernet%d",
1647                                    i, xd->bond_instance_num);
1648                     rv = rte_eth_bond_mac_address_set
1649                       (i, (struct ether_addr *) addr);
1650                     if (rv)
1651                       dpdk_log_warn ("Set MAC addr failure rv=%d", rv);
1652
1653                     /* Populate MAC of bonded interface in VPP hw tables */
1654                     bhi = vnet_get_hw_interface
1655                       (vnm, dm->devices[i].hw_if_index);
1656                     bei = pool_elt_at_index
1657                       (em->interfaces, bhi->hw_instance);
1658                     clib_memcpy (bhi->hw_address, addr, 6);
1659                     clib_memcpy (bei->address, addr, 6);
1660
1661                     /* Init l3 packet size allowed on bonded interface */
1662                     bhi->max_packet_bytes = ETHERNET_MAX_PACKET_BYTES;
1663                     while (nlink >= 1)
1664                       {         /* for all slave links */
1665                         int slave = slink[--nlink];
1666                         dpdk_device_t *sdev = &dm->devices[slave];
1667                         vnet_hw_interface_t *shi;
1668                         vnet_sw_interface_t *ssi;
1669                         ethernet_interface_t *sei;
1670                         /* Add MAC to all slave links except the first one */
1671                         if (nlink)
1672                           {
1673                             dpdk_log_info ("Add MAC for slave port %d",
1674                                            slave);
1675                             rv = rte_eth_dev_mac_addr_add
1676                               (slave, (struct ether_addr *) addr, 0);
1677                             if (rv)
1678                               dpdk_log_warn ("Add MAC addr failure rv=%d",
1679                                              rv);
1680                           }
1681                         /* Setup slave link state change callback handling */
1682                         rte_eth_dev_callback_register
1683                           (slave, RTE_ETH_EVENT_INTR_LSC,
1684                            dpdk_port_state_callback, NULL);
1685                         dpdk_device_t *sxd = &dm->devices[slave];
1686                         sxd->flags |= DPDK_DEVICE_FLAG_BOND_SLAVE;
1687                         sxd->bond_port = i;
1688                         /* Set slaves bitmap for bonded interface */
1689                         bhi->bond_info = clib_bitmap_set
1690                           (bhi->bond_info, sdev->hw_if_index, 1);
1691                         /* Set MACs and slave link flags on slave interface */
1692                         shi = vnet_get_hw_interface (vnm, sdev->hw_if_index);
1693                         ssi = vnet_get_sw_interface (vnm, sdev->sw_if_index);
1694                         sei = pool_elt_at_index
1695                           (em->interfaces, shi->hw_instance);
1696                         shi->bond_info = VNET_HW_INTERFACE_BOND_INFO_SLAVE;
1697                         ssi->flags |= VNET_SW_INTERFACE_FLAG_BOND_SLAVE;
1698                         clib_memcpy (shi->hw_address, addr, 6);
1699                         clib_memcpy (sei->address, addr, 6);
1700                         /* Set l3 packet size allowed as the lowest of slave */
1701                         if (bhi->max_packet_bytes > shi->max_packet_bytes)
1702                           bhi->max_packet_bytes = shi->max_packet_bytes;
1703                       }
1704                   }
1705               }
1706           }
1707         /* *INDENT-ON* */
1708       }
1709   }
1710
1711   while (1)
1712     {
1713       /*
1714        * check each time through the loop in case intervals are changed
1715        */
1716       f64 min_wait = dm->link_state_poll_interval < dm->stat_poll_interval ?
1717         dm->link_state_poll_interval : dm->stat_poll_interval;
1718
1719       vlib_process_wait_for_event_or_clock (vm, min_wait);
1720
1721       if (dm->admin_up_down_in_progress)
1722         /* skip the poll if an admin up down is in progress (on any interface) */
1723         continue;
1724
1725       vec_foreach (xd, dm->devices)
1726       {
1727         f64 now = vlib_time_now (vm);
1728         if ((now - xd->time_last_stats_update) >= dm->stat_poll_interval)
1729           dpdk_update_counters (xd, now);
1730         if ((now - xd->time_last_link_update) >= dm->link_state_poll_interval)
1731           dpdk_update_link_state (xd, now);
1732
1733       }
1734     }
1735
1736   return 0;
1737 }
1738
1739 /* *INDENT-OFF* */
1740 VLIB_REGISTER_NODE (dpdk_process_node,static) = {
1741     .function = dpdk_process,
1742     .type = VLIB_NODE_TYPE_PROCESS,
1743     .name = "dpdk-process",
1744     .process_log2_n_stack_bytes = 17,
1745 };
1746 /* *INDENT-ON* */
1747
1748 static clib_error_t *
1749 dpdk_init (vlib_main_t * vm)
1750 {
1751   dpdk_main_t *dm = &dpdk_main;
1752   clib_error_t *error = 0;
1753
1754   /* verify that structs are cacheline aligned */
1755   STATIC_ASSERT (offsetof (dpdk_device_t, cacheline0) == 0,
1756                  "Cache line marker must be 1st element in dpdk_device_t");
1757   STATIC_ASSERT (offsetof (dpdk_device_t, cacheline1) ==
1758                  CLIB_CACHE_LINE_BYTES,
1759                  "Data in cache line 0 is bigger than cache line size");
1760   STATIC_ASSERT (offsetof (frame_queue_trace_t, cacheline0) == 0,
1761                  "Cache line marker must be 1st element in frame_queue_trace_t");
1762   STATIC_ASSERT (RTE_CACHE_LINE_SIZE == 1 << CLIB_LOG2_CACHE_LINE_BYTES,
1763                  "DPDK RTE CACHE LINE SIZE does not match with 1<<CLIB_LOG2_CACHE_LINE_BYTES");
1764
1765   dm->vlib_main = vm;
1766   dm->vnet_main = vnet_get_main ();
1767   dm->conf = &dpdk_config_main;
1768
1769   dm->conf->nchannels = 4;
1770   dm->conf->num_mbufs = dm->conf->num_mbufs ? dm->conf->num_mbufs : NB_MBUF;
1771   vec_add1 (dm->conf->eal_init_args, (u8 *) "vnet");
1772   vec_add1 (dm->conf->eal_init_args, (u8 *) "--in-memory");
1773
1774   /* Default vlib_buffer_t flags, DISABLES tcp/udp checksumming... */
1775   dm->buffer_flags_template = (VLIB_BUFFER_TOTAL_LENGTH_VALID |
1776                                VLIB_BUFFER_EXT_HDR_VALID |
1777                                VNET_BUFFER_F_L4_CHECKSUM_COMPUTED |
1778                                VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
1779
1780   dm->stat_poll_interval = DPDK_STATS_POLL_INTERVAL;
1781   dm->link_state_poll_interval = DPDK_LINK_POLL_INTERVAL;
1782
1783   /* init CLI */
1784   if ((error = vlib_call_init_function (vm, dpdk_cli_init)))
1785     return error;
1786
1787   dm->log_default = vlib_log_register_class ("dpdk", 0);
1788
1789   return error;
1790 }
1791
1792 VLIB_INIT_FUNCTION (dpdk_init);
1793
1794
1795 /*
1796  * fd.io coding-style-patch-verification: ON
1797  *
1798  * Local Variables:
1799  * eval: (c-set-style "gnu")
1800  * End:
1801  */