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