examples/vmdq/main.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <stdint.h>
   6 #include <sys/queue.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <stdio.h>
  10 #include <assert.h>
  11 #include <errno.h>
  12 #include <signal.h>
  13 #include <stdarg.h>
  14 #include <inttypes.h>
  15 #include <getopt.h>
  16
  17 #include <rte_common.h>
  18 #include <rte_log.h>
  19 #include <rte_memory.h>
  20 #include <rte_memcpy.h>
  21 #include <rte_eal.h>
  22 #include <rte_launch.h>
  23 #include <rte_atomic.h>
  24 #include <rte_cycles.h>
  25 #include <rte_prefetch.h>
  26 #include <rte_lcore.h>
  27 #include <rte_per_lcore.h>
  28 #include <rte_branch_prediction.h>
  29 #include <rte_interrupts.h>
  30 #include <rte_random.h>
  31 #include <rte_debug.h>
  32 #include <rte_ether.h>
  33 #include <rte_ethdev.h>
  34 #include <rte_mempool.h>
  35 #include <rte_mbuf.h>
  36
  37 #define MAX_QUEUES 1024
  38 /*
  39  * 1024 queues require to meet the needs of a large number of vmdq_pools.
  40  * (RX/TX_queue_nb * RX/TX_ring_descriptors_nb) per port.
  41  */
  42 #define NUM_MBUFS_PER_PORT (MAX_QUEUES * RTE_MAX(RTE_TEST_RX_DESC_DEFAULT, \
  43                                                 RTE_TEST_TX_DESC_DEFAULT))
  44 #define MBUF_CACHE_SIZE 64
  45
  46 #define MAX_PKT_BURST 32
  47
  48 /*
  49  * Configurable number of RX/TX ring descriptors
  50  */
  51 #define RTE_TEST_RX_DESC_DEFAULT 1024
  52 #define RTE_TEST_TX_DESC_DEFAULT 1024
  53
  54 #define INVALID_PORT_ID 0xFF
  55
  56 /* mask of enabled ports */
  57 static uint32_t enabled_port_mask;
  58
  59 /* number of pools (if user does not specify any, 8 by default */
  60 static uint32_t num_queues = 8;
  61 static uint32_t num_pools = 8;
  62
  63 /* empty vmdq configuration structure. Filled in programatically */
  64 static const struct rte_eth_conf vmdq_conf_default = {
  65         .rxmode = {
  66                 .mq_mode        = ETH_MQ_RX_VMDQ_ONLY,
  67                 .split_hdr_size = 0,
  68         },
  69
  70         .txmode = {
  71                 .mq_mode = ETH_MQ_TX_NONE,
  72         },
  73         .rx_adv_conf = {
  74                 /*
  75                  * should be overridden separately in code with
  76                  * appropriate values
  77                  */
  78                 .vmdq_rx_conf = {
  79                         .nb_queue_pools = ETH_8_POOLS,
  80                         .enable_default_pool = 0,
  81                         .default_pool = 0,
  82                         .nb_pool_maps = 0,
  83                         .pool_map = {{0, 0},},
  84                 },
  85         },
  86 };
  87
  88 static unsigned lcore_ids[RTE_MAX_LCORE];
  89 static uint16_t ports[RTE_MAX_ETHPORTS];
  90 static unsigned num_ports; /**< The number of ports specified in command line */
  91
  92 /* array used for printing out statistics */
  93 volatile unsigned long rxPackets[MAX_QUEUES] = {0};
  94
  95 const uint16_t vlan_tags[] = {
  96         0,  1,  2,  3,  4,  5,  6,  7,
  97         8,  9, 10, 11,  12, 13, 14, 15,
  98         16, 17, 18, 19, 20, 21, 22, 23,
  99         24, 25, 26, 27, 28, 29, 30, 31,
 100         32, 33, 34, 35, 36, 37, 38, 39,
 101         40, 41, 42, 43, 44, 45, 46, 47,
 102         48, 49, 50, 51, 52, 53, 54, 55,
 103         56, 57, 58, 59, 60, 61, 62, 63,
 104 };
 105 const uint16_t num_vlans = RTE_DIM(vlan_tags);
 106 static uint16_t num_pf_queues,  num_vmdq_queues;
 107 static uint16_t vmdq_pool_base, vmdq_queue_base;
 108 /* pool mac addr template, pool mac addr is like: 52 54 00 12 port# pool# */
 109 static struct rte_ether_addr pool_addr_template = {
 110         .addr_bytes = {0x52, 0x54, 0x00, 0x12, 0x00, 0x00}
 111 };
 112
 113 /* ethernet addresses of ports */
 114 static struct rte_ether_addr vmdq_ports_eth_addr[RTE_MAX_ETHPORTS];
 115
 116 #define MAX_QUEUE_NUM_10G 128
 117 #define MAX_QUEUE_NUM_1G 8
 118 #define MAX_POOL_MAP_NUM_10G 64
 119 #define MAX_POOL_MAP_NUM_1G 32
 120 #define MAX_POOL_NUM_10G 64
 121 #define MAX_POOL_NUM_1G 8
 122 /*
 123  * Builds up the correct configuration for vmdq based on the vlan tags array
 124  * given above, and determine the queue number and pool map number according to
 125  * valid pool number
 126  */
 127 static inline int
 128 get_eth_conf(struct rte_eth_conf *eth_conf, uint32_t num_pools)
 129 {
 130         struct rte_eth_vmdq_rx_conf conf;
 131         unsigned i;
 132
 133         conf.nb_queue_pools = (enum rte_eth_nb_pools)num_pools;
 134         conf.nb_pool_maps = num_pools;
 135         conf.enable_default_pool = 0;
 136         conf.default_pool = 0; /* set explicit value, even if not used */
 137
 138         for (i = 0; i < conf.nb_pool_maps; i++) {
 139                 conf.pool_map[i].vlan_id = vlan_tags[i];
 140                 conf.pool_map[i].pools = (1UL << (i % num_pools));
 141         }
 142
 143         (void)(rte_memcpy(eth_conf, &vmdq_conf_default, sizeof(*eth_conf)));
 144         (void)(rte_memcpy(&eth_conf->rx_adv_conf.vmdq_rx_conf, &conf,
 145                    sizeof(eth_conf->rx_adv_conf.vmdq_rx_conf)));
 146         return 0;
 147 }
 148
 149 /*
 150  * Initialises a given port using global settings and with the rx buffers
 151  * coming from the mbuf_pool passed as parameter
 152  */
 153 static inline int
 154 port_init(uint16_t port, struct rte_mempool *mbuf_pool)
 155 {
 156         struct rte_eth_dev_info dev_info;
 157         struct rte_eth_rxconf *rxconf;
 158         struct rte_eth_txconf *txconf;
 159         struct rte_eth_conf port_conf;
 160         uint16_t rxRings, txRings;
 161         uint16_t rxRingSize = RTE_TEST_RX_DESC_DEFAULT;
 162         uint16_t txRingSize = RTE_TEST_TX_DESC_DEFAULT;
 163         int retval;
 164         uint16_t q;
 165         uint16_t queues_per_pool;
 166         uint32_t max_nb_pools;
 167
 168         /*
 169          * The max pool number from dev_info will be used to validate the pool
 170          * number specified in cmd line
 171          */
 172         retval = rte_eth_dev_info_get(port, &dev_info);
 173         if (retval != 0) {
 174                 printf("Error during getting device (port %u) info: %s\n",
 175                                 port, strerror(-retval));
 176                 return retval;
 177         }
 178
 179         max_nb_pools = (uint32_t)dev_info.max_vmdq_pools;
 180         /*
 181          * We allow to process part of VMDQ pools specified by num_pools in
 182          * command line.
 183          */
 184         if (num_pools > max_nb_pools) {
 185                 printf("num_pools %d >max_nb_pools %d\n",
 186                         num_pools, max_nb_pools);
 187                 return -1;
 188         }
 189         retval = get_eth_conf(&port_conf, max_nb_pools);
 190         if (retval < 0)
 191                 return retval;
 192
 193         /*
 194          * NIC queues are divided into pf queues and vmdq queues.
 195          */
 196         /* There is assumption here all ports have the same configuration! */
 197         num_pf_queues = dev_info.max_rx_queues - dev_info.vmdq_queue_num;
 198         queues_per_pool = dev_info.vmdq_queue_num / dev_info.max_vmdq_pools;
 199         num_vmdq_queues = num_pools * queues_per_pool;
 200         num_queues = num_pf_queues + num_vmdq_queues;
 201         vmdq_queue_base = dev_info.vmdq_queue_base;
 202         vmdq_pool_base  = dev_info.vmdq_pool_base;
 203
 204         printf("pf queue num: %u, configured vmdq pool num: %u,"
 205                 " each vmdq pool has %u queues\n",
 206                 num_pf_queues, num_pools, queues_per_pool);
 207         printf("vmdq queue base: %d pool base %d\n",
 208                 vmdq_queue_base, vmdq_pool_base);
 209         if (!rte_eth_dev_is_valid_port(port))
 210                 return -1;
 211
 212         /*
 213          * Though in this example, we only receive packets from the first queue
 214          * of each pool and send packets through first rte_lcore_count() tx
 215          * queues of vmdq queues, all queues including pf queues are setup.
 216          * This is because VMDQ queues doesn't always start from zero, and the
 217          * PMD layer doesn't support selectively initialising part of rx/tx
 218          * queues.
 219          */
 220         rxRings = (uint16_t)dev_info.max_rx_queues;
 221         txRings = (uint16_t)dev_info.max_tx_queues;
 222
 223         retval = rte_eth_dev_info_get(port, &dev_info);
 224         if (retval != 0) {
 225                 printf("Error during getting device (port %u) info: %s\n",
 226                                 port, strerror(-retval));
 227                 return retval;
 228         }
 229
 230         if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
 231                 port_conf.txmode.offloads |=
 232                         DEV_TX_OFFLOAD_MBUF_FAST_FREE;
 233         retval = rte_eth_dev_configure(port, rxRings, txRings, &port_conf);
 234         if (retval != 0)
 235                 return retval;
 236
 237         retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &rxRingSize,
 238                                 &txRingSize);
 239         if (retval != 0)
 240                 return retval;
 241         if (RTE_MAX(rxRingSize, txRingSize) > RTE_MAX(RTE_TEST_RX_DESC_DEFAULT,
 242                         RTE_TEST_TX_DESC_DEFAULT)) {
 243                 printf("Mbuf pool has an insufficient size for port %u.\n",
 244                         port);
 245                 return -1;
 246         }
 247
 248         rxconf = &dev_info.default_rxconf;
 249         rxconf->rx_drop_en = 1;
 250         txconf = &dev_info.default_txconf;
 251         txconf->offloads = port_conf.txmode.offloads;
 252         for (q = 0; q < rxRings; q++) {
 253                 retval = rte_eth_rx_queue_setup(port, q, rxRingSize,
 254                                         rte_eth_dev_socket_id(port),
 255                                         rxconf,
 256                                         mbuf_pool);
 257                 if (retval < 0) {
 258                         printf("initialise rx queue %d failed\n", q);
 259                         return retval;
 260                 }
 261         }
 262
 263         for (q = 0; q < txRings; q++) {
 264                 retval = rte_eth_tx_queue_setup(port, q, txRingSize,
 265                                         rte_eth_dev_socket_id(port),
 266                                         txconf);
 267                 if (retval < 0) {
 268                         printf("initialise tx queue %d failed\n", q);
 269                         return retval;
 270                 }
 271         }
 272
 273         retval  = rte_eth_dev_start(port);
 274         if (retval < 0) {
 275                 printf("port %d start failed\n", port);
 276                 return retval;
 277         }
 278
 279         retval = rte_eth_macaddr_get(port, &vmdq_ports_eth_addr[port]);
 280         if (retval < 0) {
 281                 printf("port %d MAC address get failed: %s\n", port,
 282                        rte_strerror(-retval));
 283                 return retval;
 284         }
 285         printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
 286                         " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
 287                         (unsigned)port,
 288                         vmdq_ports_eth_addr[port].addr_bytes[0],
 289                         vmdq_ports_eth_addr[port].addr_bytes[1],
 290                         vmdq_ports_eth_addr[port].addr_bytes[2],
 291                         vmdq_ports_eth_addr[port].addr_bytes[3],
 292                         vmdq_ports_eth_addr[port].addr_bytes[4],
 293                         vmdq_ports_eth_addr[port].addr_bytes[5]);
 294
 295         /*
 296          * Set mac for each pool.
 297          * There is no default mac for the pools in i40.
 298          * Removes this after i40e fixes this issue.
 299          */
 300         for (q = 0; q < num_pools; q++) {
 301                 struct rte_ether_addr mac;
 302                 mac = pool_addr_template;
 303                 mac.addr_bytes[4] = port;
 304                 mac.addr_bytes[5] = q;
 305                 printf("Port %u vmdq pool %u set mac %02x:%02x:%02x:%02x:%02x:%02x\n",
 306                         port, q,
 307                         mac.addr_bytes[0], mac.addr_bytes[1],
 308                         mac.addr_bytes[2], mac.addr_bytes[3],
 309                         mac.addr_bytes[4], mac.addr_bytes[5]);
 310                 retval = rte_eth_dev_mac_addr_add(port, &mac,
 311                                 q + vmdq_pool_base);
 312                 if (retval) {
 313                         printf("mac addr add failed at pool %d\n", q);
 314                         return retval;
 315                 }
 316         }
 317
 318         return 0;
 319 }
 320
 321 /* Check num_pools parameter and set it if OK*/
 322 static int
 323 vmdq_parse_num_pools(const char *q_arg)
 324 {
 325         char *end = NULL;
 326         int n;
 327
 328         /* parse number string */
 329         n = strtol(q_arg, &end, 10);
 330         if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0'))
 331                 return -1;
 332
 333         if (num_pools > num_vlans) {
 334                 printf("num_pools %d > num_vlans %d\n", num_pools, num_vlans);
 335                 return -1;
 336         }
 337
 338         num_pools = n;
 339
 340         return 0;
 341 }
 342
 343
 344 static int
 345 parse_portmask(const char *portmask)
 346 {
 347         char *end = NULL;
 348         unsigned long pm;
 349
 350         /* parse hexadecimal string */
 351         pm = strtoul(portmask, &end, 16);
 352         if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
 353                 return -1;
 354
 355         if (pm == 0)
 356                 return -1;
 357
 358         return pm;
 359 }
 360
 361 /* Display usage */
 362 static void
 363 vmdq_usage(const char *prgname)
 364 {
 365         printf("%s [EAL options] -- -p PORTMASK]\n"
 366         "  --nb-pools NP: number of pools\n",
 367                prgname);
 368 }
 369
 370 /*  Parse the argument (num_pools) given in the command line of the application */
 371 static int
 372 vmdq_parse_args(int argc, char **argv)
 373 {
 374         int opt;
 375         int option_index;
 376         unsigned i;
 377         const char *prgname = argv[0];
 378         static struct option long_option[] = {
 379                 {"nb-pools", required_argument, NULL, 0},
 380                 {NULL, 0, 0, 0}
 381         };
 382
 383         /* Parse command line */
 384         while ((opt = getopt_long(argc, argv, "p:", long_option,
 385                 &option_index)) != EOF) {
 386                 switch (opt) {
 387                 /* portmask */
 388                 case 'p':
 389                         enabled_port_mask = parse_portmask(optarg);
 390                         if (enabled_port_mask == 0) {
 391                                 printf("invalid portmask\n");
 392                                 vmdq_usage(prgname);
 393                                 return -1;
 394                         }
 395                         break;
 396                 case 0:
 397                         if (vmdq_parse_num_pools(optarg) == -1) {
 398                                 printf("invalid number of pools\n");
 399                                 vmdq_usage(prgname);
 400                                 return -1;
 401                         }
 402                         break;
 403
 404                 default:
 405                         vmdq_usage(prgname);
 406                         return -1;
 407                 }
 408         }
 409
 410         for (i = 0; i < RTE_MAX_ETHPORTS; i++) {
 411                 if (enabled_port_mask & (1 << i))
 412                         ports[num_ports++] = (uint8_t)i;
 413         }
 414
 415         if (num_ports < 2 || num_ports % 2) {
 416                 printf("Current enabled port number is %u,"
 417                         "but it should be even and at least 2\n", num_ports);
 418                 return -1;
 419         }
 420
 421         return 0;
 422 }
 423
 424 static void
 425 update_mac_address(struct rte_mbuf *m, unsigned dst_port)
 426 {
 427         struct rte_ether_hdr *eth;
 428         void *tmp;
 429
 430         eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 431
 432         /* 02:00:00:00:00:xx */
 433         tmp = &eth->d_addr.addr_bytes[0];
 434         *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
 435
 436         /* src addr */
 437         rte_ether_addr_copy(&vmdq_ports_eth_addr[dst_port], &eth->s_addr);
 438 }
 439
 440 /* When we receive a HUP signal, print out our stats */
 441 static void
 442 sighup_handler(int signum)
 443 {
 444         unsigned int q = vmdq_queue_base;
 445         for (; q < num_queues; q++) {
 446                 if ((q - vmdq_queue_base) % (num_vmdq_queues / num_pools) == 0)
 447                         printf("\nPool %u: ", (q - vmdq_queue_base) /
 448                                (num_vmdq_queues / num_pools));
 449                 printf("%lu ", rxPackets[q]);
 450         }
 451         printf("\nFinished handling signal %d\n", signum);
 452 }
 453
 454 /*
 455  * Main thread that does the work, reading from INPUT_PORT
 456  * and writing to OUTPUT_PORT
 457  */
 458 static int
 459 lcore_main(__rte_unused void *dummy)
 460 {
 461         const uint16_t lcore_id = (uint16_t)rte_lcore_id();
 462         const uint16_t num_cores = (uint16_t)rte_lcore_count();
 463         uint16_t core_id = 0;
 464         uint16_t startQueue, endQueue;
 465         uint16_t q, i, p;
 466         const uint16_t remainder = (uint16_t)(num_vmdq_queues % num_cores);
 467
 468         for (i = 0; i < num_cores; i++)
 469                 if (lcore_ids[i] == lcore_id) {
 470                         core_id = i;
 471                         break;
 472                 }
 473
 474         if (remainder != 0) {
 475                 if (core_id < remainder) {
 476                         startQueue = (uint16_t)(core_id *
 477                                         (num_vmdq_queues / num_cores + 1));
 478                         endQueue = (uint16_t)(startQueue +
 479                                         (num_vmdq_queues / num_cores) + 1);
 480                 } else {
 481                         startQueue = (uint16_t)(core_id *
 482                                         (num_vmdq_queues / num_cores) +
 483                                         remainder);
 484                         endQueue = (uint16_t)(startQueue +
 485                                         (num_vmdq_queues / num_cores));
 486                 }
 487         } else {
 488                 startQueue = (uint16_t)(core_id *
 489                                 (num_vmdq_queues / num_cores));
 490                 endQueue = (uint16_t)(startQueue +
 491                                 (num_vmdq_queues / num_cores));
 492         }
 493
 494         /* vmdq queue idx doesn't always start from zero.*/
 495         startQueue += vmdq_queue_base;
 496         endQueue   += vmdq_queue_base;
 497         printf("core %u(lcore %u) reading queues %i-%i\n", (unsigned)core_id,
 498                 (unsigned)lcore_id, startQueue, endQueue - 1);
 499
 500         if (startQueue == endQueue) {
 501                 printf("lcore %u has nothing to do\n", lcore_id);
 502                 return 0;
 503         }
 504
 505         for (;;) {
 506                 struct rte_mbuf *buf[MAX_PKT_BURST];
 507                 const uint16_t buf_size = RTE_DIM(buf);
 508
 509                 for (p = 0; p < num_ports; p++) {
 510                         const uint8_t sport = ports[p];
 511                         /* 0 <-> 1, 2 <-> 3 etc */
 512                         const uint8_t dport = ports[p ^ 1];
 513                         if ((sport == INVALID_PORT_ID) || (dport == INVALID_PORT_ID))
 514                                 continue;
 515
 516                         for (q = startQueue; q < endQueue; q++) {
 517                                 const uint16_t rxCount = rte_eth_rx_burst(sport,
 518                                         q, buf, buf_size);
 519
 520                                 if (unlikely(rxCount == 0))
 521                                         continue;
 522
 523                                 rxPackets[q] += rxCount;
 524
 525                                 for (i = 0; i < rxCount; i++)
 526                                         update_mac_address(buf[i], dport);
 527
 528                                 const uint16_t txCount = rte_eth_tx_burst(dport,
 529                                         vmdq_queue_base + core_id,
 530                                         buf,
 531                                         rxCount);
 532
 533                                 if (txCount != rxCount) {
 534                                         for (i = txCount; i < rxCount; i++)
 535                                                 rte_pktmbuf_free(buf[i]);
 536                                 }
 537                         }
 538                 }
 539         }
 540 }
 541
 542 /*
 543  * Update the global var NUM_PORTS and array PORTS according to system ports number
 544  * and return valid ports number
 545  */
 546 static unsigned check_ports_num(unsigned nb_ports)
 547 {
 548         unsigned valid_num_ports = num_ports;
 549         unsigned portid;
 550
 551         if (num_ports > nb_ports) {
 552                 printf("\nSpecified port number(%u) exceeds total system port number(%u)\n",
 553                         num_ports, nb_ports);
 554                 num_ports = nb_ports;
 555         }
 556
 557         for (portid = 0; portid < num_ports; portid++) {
 558                 if (!rte_eth_dev_is_valid_port(ports[portid])) {
 559                         printf("\nSpecified port ID(%u) is not valid\n",
 560                                 ports[portid]);
 561                         ports[portid] = INVALID_PORT_ID;
 562                         valid_num_ports--;
 563                 }
 564         }
 565         return valid_num_ports;
 566 }
 567
 568 /* Main function, does initialisation and calls the per-lcore functions */
 569 int
 570 main(int argc, char *argv[])
 571 {
 572         struct rte_mempool *mbuf_pool;
 573         unsigned lcore_id, core_id = 0;
 574         int ret;
 575         unsigned nb_ports, valid_num_ports;
 576         uint16_t portid;
 577
 578         signal(SIGHUP, sighup_handler);
 579
 580         /* init EAL */
 581         ret = rte_eal_init(argc, argv);
 582         if (ret < 0)
 583                 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
 584         argc -= ret;
 585         argv += ret;
 586
 587         /* parse app arguments */
 588         ret = vmdq_parse_args(argc, argv);
 589         if (ret < 0)
 590                 rte_exit(EXIT_FAILURE, "Invalid VMDQ argument\n");
 591
 592         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++)
 593                 if (rte_lcore_is_enabled(lcore_id))
 594                         lcore_ids[core_id++] = lcore_id;
 595
 596         if (rte_lcore_count() > RTE_MAX_LCORE)
 597                 rte_exit(EXIT_FAILURE, "Not enough cores\n");
 598
 599         nb_ports = rte_eth_dev_count_avail();
 600
 601         /*
 602          * Update the global var NUM_PORTS and global array PORTS
 603          * and get value of var VALID_NUM_PORTS according to system ports number
 604          */
 605         valid_num_ports = check_ports_num(nb_ports);
 606
 607         if (valid_num_ports < 2 || valid_num_ports % 2) {
 608                 printf("Current valid ports number is %u\n", valid_num_ports);
 609                 rte_exit(EXIT_FAILURE, "Error with valid ports number is not even or less than 2\n");
 610         }
 611
 612         mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
 613                 NUM_MBUFS_PER_PORT * nb_ports, MBUF_CACHE_SIZE,
 614                 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
 615         if (mbuf_pool == NULL)
 616                 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
 617
 618         /* initialize all ports */
 619         RTE_ETH_FOREACH_DEV(portid) {
 620                 /* skip ports that are not enabled */
 621                 if ((enabled_port_mask & (1 << portid)) == 0) {
 622                         printf("\nSkipping disabled port %d\n", portid);
 623                         continue;
 624                 }
 625                 if (port_init(portid, mbuf_pool) != 0)
 626                         rte_exit(EXIT_FAILURE, "Cannot initialize network ports\n");
 627         }
 628
 629         /* call lcore_main() on every lcore */
 630         rte_eal_mp_remote_launch(lcore_main, NULL, CALL_MASTER);
 631         RTE_LCORE_FOREACH_SLAVE(lcore_id) {
 632                 if (rte_eal_wait_lcore(lcore_id) < 0)
 633                         return -1;
 634         }
 635
 636         return 0;
 637 }