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 q;
 445         for (q = 0; q < num_queues; q++) {
 446                 if (q % (num_queues/num_pools) == 0)
 447                         printf("\nPool %u: ", q/(num_queues/num_pools));
 448                 printf("%lu ", rxPackets[q]);
 449         }
 450         printf("\nFinished handling signal %d\n", signum);
 451 }
 452
 453 /*
 454  * Main thread that does the work, reading from INPUT_PORT
 455  * and writing to OUTPUT_PORT
 456  */
 457 static int
 458 lcore_main(__attribute__((__unused__)) void *dummy)
 459 {
 460         const uint16_t lcore_id = (uint16_t)rte_lcore_id();
 461         const uint16_t num_cores = (uint16_t)rte_lcore_count();
 462         uint16_t core_id = 0;
 463         uint16_t startQueue, endQueue;
 464         uint16_t q, i, p;
 465         const uint16_t remainder = (uint16_t)(num_vmdq_queues % num_cores);
 466
 467         for (i = 0; i < num_cores; i++)
 468                 if (lcore_ids[i] == lcore_id) {
 469                         core_id = i;
 470                         break;
 471                 }
 472
 473         if (remainder != 0) {
 474                 if (core_id < remainder) {
 475                         startQueue = (uint16_t)(core_id *
 476                                         (num_vmdq_queues / num_cores + 1));
 477                         endQueue = (uint16_t)(startQueue +
 478                                         (num_vmdq_queues / num_cores) + 1);
 479                 } else {
 480                         startQueue = (uint16_t)(core_id *
 481                                         (num_vmdq_queues / num_cores) +
 482                                         remainder);
 483                         endQueue = (uint16_t)(startQueue +
 484                                         (num_vmdq_queues / num_cores));
 485                 }
 486         } else {
 487                 startQueue = (uint16_t)(core_id *
 488                                 (num_vmdq_queues / num_cores));
 489                 endQueue = (uint16_t)(startQueue +
 490                                 (num_vmdq_queues / num_cores));
 491         }
 492
 493         /* vmdq queue idx doesn't always start from zero.*/
 494         startQueue += vmdq_queue_base;
 495         endQueue   += vmdq_queue_base;
 496         printf("core %u(lcore %u) reading queues %i-%i\n", (unsigned)core_id,
 497                 (unsigned)lcore_id, startQueue, endQueue - 1);
 498
 499         if (startQueue == endQueue) {
 500                 printf("lcore %u has nothing to do\n", lcore_id);
 501                 return 0;
 502         }
 503
 504         for (;;) {
 505                 struct rte_mbuf *buf[MAX_PKT_BURST];
 506                 const uint16_t buf_size = RTE_DIM(buf);
 507
 508                 for (p = 0; p < num_ports; p++) {
 509                         const uint8_t sport = ports[p];
 510                         /* 0 <-> 1, 2 <-> 3 etc */
 511                         const uint8_t dport = ports[p ^ 1];
 512                         if ((sport == INVALID_PORT_ID) || (dport == INVALID_PORT_ID))
 513                                 continue;
 514
 515                         for (q = startQueue; q < endQueue; q++) {
 516                                 const uint16_t rxCount = rte_eth_rx_burst(sport,
 517                                         q, buf, buf_size);
 518
 519                                 if (unlikely(rxCount == 0))
 520                                         continue;
 521
 522                                 rxPackets[q] += rxCount;
 523
 524                                 for (i = 0; i < rxCount; i++)
 525                                         update_mac_address(buf[i], dport);
 526
 527                                 const uint16_t txCount = rte_eth_tx_burst(dport,
 528                                         vmdq_queue_base + core_id,
 529                                         buf,
 530                                         rxCount);
 531
 532                                 if (txCount != rxCount) {
 533                                         for (i = txCount; i < rxCount; i++)
 534                                                 rte_pktmbuf_free(buf[i]);
 535                                 }
 536                         }
 537                 }
 538         }
 539 }
 540
 541 /*
 542  * Update the global var NUM_PORTS and array PORTS according to system ports number
 543  * and return valid ports number
 544  */
 545 static unsigned check_ports_num(unsigned nb_ports)
 546 {
 547         unsigned valid_num_ports = num_ports;
 548         unsigned portid;
 549
 550         if (num_ports > nb_ports) {
 551                 printf("\nSpecified port number(%u) exceeds total system port number(%u)\n",
 552                         num_ports, nb_ports);
 553                 num_ports = nb_ports;
 554         }
 555
 556         for (portid = 0; portid < num_ports; portid++) {
 557                 if (!rte_eth_dev_is_valid_port(ports[portid])) {
 558                         printf("\nSpecified port ID(%u) is not valid\n",
 559                                 ports[portid]);
 560                         ports[portid] = INVALID_PORT_ID;
 561                         valid_num_ports--;
 562                 }
 563         }
 564         return valid_num_ports;
 565 }
 566
 567 /* Main function, does initialisation and calls the per-lcore functions */
 568 int
 569 main(int argc, char *argv[])
 570 {
 571         struct rte_mempool *mbuf_pool;
 572         unsigned lcore_id, core_id = 0;
 573         int ret;
 574         unsigned nb_ports, valid_num_ports;
 575         uint16_t portid;
 576
 577         signal(SIGHUP, sighup_handler);
 578
 579         /* init EAL */
 580         ret = rte_eal_init(argc, argv);
 581         if (ret < 0)
 582                 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
 583         argc -= ret;
 584         argv += ret;
 585
 586         /* parse app arguments */
 587         ret = vmdq_parse_args(argc, argv);
 588         if (ret < 0)
 589                 rte_exit(EXIT_FAILURE, "Invalid VMDQ argument\n");
 590
 591         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++)
 592                 if (rte_lcore_is_enabled(lcore_id))
 593                         lcore_ids[core_id++] = lcore_id;
 594
 595         if (rte_lcore_count() > RTE_MAX_LCORE)
 596                 rte_exit(EXIT_FAILURE, "Not enough cores\n");
 597
 598         nb_ports = rte_eth_dev_count_avail();
 599
 600         /*
 601          * Update the global var NUM_PORTS and global array PORTS
 602          * and get value of var VALID_NUM_PORTS according to system ports number
 603          */
 604         valid_num_ports = check_ports_num(nb_ports);
 605
 606         if (valid_num_ports < 2 || valid_num_ports % 2) {
 607                 printf("Current valid ports number is %u\n", valid_num_ports);
 608                 rte_exit(EXIT_FAILURE, "Error with valid ports number is not even or less than 2\n");
 609         }
 610
 611         mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
 612                 NUM_MBUFS_PER_PORT * nb_ports, MBUF_CACHE_SIZE,
 613                 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
 614         if (mbuf_pool == NULL)
 615                 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
 616
 617         /* initialize all ports */
 618         RTE_ETH_FOREACH_DEV(portid) {
 619                 /* skip ports that are not enabled */
 620                 if ((enabled_port_mask & (1 << portid)) == 0) {
 621                         printf("\nSkipping disabled port %d\n", portid);
 622                         continue;
 623                 }
 624                 if (port_init(portid, mbuf_pool) != 0)
 625                         rte_exit(EXIT_FAILURE, "Cannot initialize network ports\n");
 626         }
 627
 628         /* call lcore_main() on every lcore */
 629         rte_eal_mp_remote_launch(lcore_main, NULL, CALL_MASTER);
 630         RTE_LCORE_FOREACH_SLAVE(lcore_id) {
 631                 if (rte_eal_wait_lcore(lcore_id) < 0)
 632                         return -1;
 633         }
 634
 635         return 0;
 636 }