examples/vmdq/main.c

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