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