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