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