ethdev: remove useless parameter in init functions
[dpdk.git] / examples / l2fwd / 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 <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <stdint.h>
38 #include <inttypes.h>
39 #include <sys/types.h>
40 #include <sys/queue.h>
41 #include <netinet/in.h>
42 #include <setjmp.h>
43 #include <stdarg.h>
44 #include <ctype.h>
45 #include <errno.h>
46 #include <getopt.h>
47
48 #include <rte_common.h>
49 #include <rte_log.h>
50 #include <rte_memory.h>
51 #include <rte_memcpy.h>
52 #include <rte_memzone.h>
53 #include <rte_tailq.h>
54 #include <rte_eal.h>
55 #include <rte_per_lcore.h>
56 #include <rte_launch.h>
57 #include <rte_atomic.h>
58 #include <rte_cycles.h>
59 #include <rte_prefetch.h>
60 #include <rte_lcore.h>
61 #include <rte_per_lcore.h>
62 #include <rte_branch_prediction.h>
63 #include <rte_interrupts.h>
64 #include <rte_pci.h>
65 #include <rte_random.h>
66 #include <rte_debug.h>
67 #include <rte_ether.h>
68 #include <rte_ethdev.h>
69 #include <rte_ring.h>
70 #include <rte_mempool.h>
71 #include <rte_mbuf.h>
72
73 #define RTE_LOGTYPE_L2FWD RTE_LOGTYPE_USER1
74
75 #define MBUF_SIZE (2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM)
76 #define NB_MBUF   8192
77
78 #define MAX_PKT_BURST 32
79 #define BURST_TX_DRAIN_US 100 /* TX drain every ~100us */
80
81 /*
82  * Configurable number of RX/TX ring descriptors
83  */
84 #define RTE_TEST_RX_DESC_DEFAULT 128
85 #define RTE_TEST_TX_DESC_DEFAULT 512
86 static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
87 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
88
89 /* ethernet addresses of ports */
90 static struct ether_addr l2fwd_ports_eth_addr[RTE_MAX_ETHPORTS];
91
92 /* mask of enabled ports */
93 static uint32_t l2fwd_enabled_port_mask = 0;
94
95 /* list of enabled ports */
96 static uint32_t l2fwd_dst_ports[RTE_MAX_ETHPORTS];
97
98 static unsigned int l2fwd_rx_queue_per_lcore = 1;
99
100 struct mbuf_table {
101         unsigned len;
102         struct rte_mbuf *m_table[MAX_PKT_BURST];
103 };
104
105 #define MAX_RX_QUEUE_PER_LCORE 16
106 #define MAX_TX_QUEUE_PER_PORT 16
107 struct lcore_queue_conf {
108         unsigned n_rx_port;
109         unsigned rx_port_list[MAX_RX_QUEUE_PER_LCORE];
110         struct mbuf_table tx_mbufs[RTE_MAX_ETHPORTS];
111
112 } __rte_cache_aligned;
113 struct lcore_queue_conf lcore_queue_conf[RTE_MAX_LCORE];
114
115 static const struct rte_eth_conf port_conf = {
116         .rxmode = {
117                 .split_hdr_size = 0,
118                 .header_split   = 0, /**< Header Split disabled */
119                 .hw_ip_checksum = 0, /**< IP checksum offload disabled */
120                 .hw_vlan_filter = 0, /**< VLAN filtering disabled */
121                 .jumbo_frame    = 0, /**< Jumbo Frame Support disabled */
122                 .hw_strip_crc   = 0, /**< CRC stripped by hardware */
123         },
124         .txmode = {
125                 .mq_mode = ETH_MQ_TX_NONE,
126         },
127 };
128
129 struct rte_mempool * l2fwd_pktmbuf_pool = NULL;
130
131 /* Per-port statistics struct */
132 struct l2fwd_port_statistics {
133         uint64_t tx;
134         uint64_t rx;
135         uint64_t dropped;
136 } __rte_cache_aligned;
137 struct l2fwd_port_statistics port_statistics[RTE_MAX_ETHPORTS];
138
139 /* A tsc-based timer responsible for triggering statistics printout */
140 #define TIMER_MILLISECOND 2000000ULL /* around 1ms at 2 Ghz */
141 #define MAX_TIMER_PERIOD 86400 /* 1 day max */
142 static int64_t timer_period = 10 * TIMER_MILLISECOND * 1000; /* default period is 10 seconds */
143
144 /* Print out statistics on packets dropped */
145 static void
146 print_stats(void)
147 {
148         uint64_t total_packets_dropped, total_packets_tx, total_packets_rx;
149         unsigned portid;
150
151         total_packets_dropped = 0;
152         total_packets_tx = 0;
153         total_packets_rx = 0;
154
155         const char clr[] = { 27, '[', '2', 'J', '\0' };
156         const char topLeft[] = { 27, '[', '1', ';', '1', 'H','\0' };
157
158                 /* Clear screen and move to top left */
159         printf("%s%s", clr, topLeft);
160
161         printf("\nPort statistics ====================================");
162
163         for (portid = 0; portid < RTE_MAX_ETHPORTS; portid++) {
164                 /* skip disabled ports */
165                 if ((l2fwd_enabled_port_mask & (1 << portid)) == 0)
166                         continue;
167                 printf("\nStatistics for port %u ------------------------------"
168                            "\nPackets sent: %24"PRIu64
169                            "\nPackets received: %20"PRIu64
170                            "\nPackets dropped: %21"PRIu64,
171                            portid,
172                            port_statistics[portid].tx,
173                            port_statistics[portid].rx,
174                            port_statistics[portid].dropped);
175
176                 total_packets_dropped += port_statistics[portid].dropped;
177                 total_packets_tx += port_statistics[portid].tx;
178                 total_packets_rx += port_statistics[portid].rx;
179         }
180         printf("\nAggregate statistics ==============================="
181                    "\nTotal packets sent: %18"PRIu64
182                    "\nTotal packets received: %14"PRIu64
183                    "\nTotal packets dropped: %15"PRIu64,
184                    total_packets_tx,
185                    total_packets_rx,
186                    total_packets_dropped);
187         printf("\n====================================================\n");
188 }
189
190 /* Send the burst of packets on an output interface */
191 static int
192 l2fwd_send_burst(struct lcore_queue_conf *qconf, unsigned n, uint8_t port)
193 {
194         struct rte_mbuf **m_table;
195         unsigned ret;
196         unsigned queueid =0;
197
198         m_table = (struct rte_mbuf **)qconf->tx_mbufs[port].m_table;
199
200         ret = rte_eth_tx_burst(port, (uint16_t) queueid, m_table, (uint16_t) n);
201         port_statistics[port].tx += ret;
202         if (unlikely(ret < n)) {
203                 port_statistics[port].dropped += (n - ret);
204                 do {
205                         rte_pktmbuf_free(m_table[ret]);
206                 } while (++ret < n);
207         }
208
209         return 0;
210 }
211
212 /* Enqueue packets for TX and prepare them to be sent */
213 static int
214 l2fwd_send_packet(struct rte_mbuf *m, uint8_t port)
215 {
216         unsigned lcore_id, len;
217         struct lcore_queue_conf *qconf;
218
219         lcore_id = rte_lcore_id();
220
221         qconf = &lcore_queue_conf[lcore_id];
222         len = qconf->tx_mbufs[port].len;
223         qconf->tx_mbufs[port].m_table[len] = m;
224         len++;
225
226         /* enough pkts to be sent */
227         if (unlikely(len == MAX_PKT_BURST)) {
228                 l2fwd_send_burst(qconf, MAX_PKT_BURST, port);
229                 len = 0;
230         }
231
232         qconf->tx_mbufs[port].len = len;
233         return 0;
234 }
235
236 static void
237 l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
238 {
239         struct ether_hdr *eth;
240         void *tmp;
241         unsigned dst_port;
242
243         dst_port = l2fwd_dst_ports[portid];
244         eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
245
246         /* 02:00:00:00:00:xx */
247         tmp = &eth->d_addr.addr_bytes[0];
248         *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
249
250         /* src addr */
251         ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->s_addr);
252
253         l2fwd_send_packet(m, (uint8_t) dst_port);
254 }
255
256 /* main processing loop */
257 static void
258 l2fwd_main_loop(void)
259 {
260         struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
261         struct rte_mbuf *m;
262         unsigned lcore_id;
263         uint64_t prev_tsc, diff_tsc, cur_tsc, timer_tsc;
264         unsigned i, j, portid, nb_rx;
265         struct lcore_queue_conf *qconf;
266         const uint64_t drain_tsc = (rte_get_tsc_hz() + US_PER_S - 1) / US_PER_S * BURST_TX_DRAIN_US;
267
268         prev_tsc = 0;
269         timer_tsc = 0;
270
271         lcore_id = rte_lcore_id();
272         qconf = &lcore_queue_conf[lcore_id];
273
274         if (qconf->n_rx_port == 0) {
275                 RTE_LOG(INFO, L2FWD, "lcore %u has nothing to do\n", lcore_id);
276                 return;
277         }
278
279         RTE_LOG(INFO, L2FWD, "entering main loop on lcore %u\n", lcore_id);
280
281         for (i = 0; i < qconf->n_rx_port; i++) {
282
283                 portid = qconf->rx_port_list[i];
284                 RTE_LOG(INFO, L2FWD, " -- lcoreid=%u portid=%u\n", lcore_id,
285                         portid);
286         }
287
288         while (1) {
289
290                 cur_tsc = rte_rdtsc();
291
292                 /*
293                  * TX burst queue drain
294                  */
295                 diff_tsc = cur_tsc - prev_tsc;
296                 if (unlikely(diff_tsc > drain_tsc)) {
297
298                         for (portid = 0; portid < RTE_MAX_ETHPORTS; portid++) {
299                                 if (qconf->tx_mbufs[portid].len == 0)
300                                         continue;
301                                 l2fwd_send_burst(&lcore_queue_conf[lcore_id],
302                                                  qconf->tx_mbufs[portid].len,
303                                                  (uint8_t) portid);
304                                 qconf->tx_mbufs[portid].len = 0;
305                         }
306
307                         /* if timer is enabled */
308                         if (timer_period > 0) {
309
310                                 /* advance the timer */
311                                 timer_tsc += diff_tsc;
312
313                                 /* if timer has reached its timeout */
314                                 if (unlikely(timer_tsc >= (uint64_t) timer_period)) {
315
316                                         /* do this only on master core */
317                                         if (lcore_id == rte_get_master_lcore()) {
318                                                 print_stats();
319                                                 /* reset the timer */
320                                                 timer_tsc = 0;
321                                         }
322                                 }
323                         }
324
325                         prev_tsc = cur_tsc;
326                 }
327
328                 /*
329                  * Read packet from RX queues
330                  */
331                 for (i = 0; i < qconf->n_rx_port; i++) {
332
333                         portid = qconf->rx_port_list[i];
334                         nb_rx = rte_eth_rx_burst((uint8_t) portid, 0,
335                                                  pkts_burst, MAX_PKT_BURST);
336
337                         port_statistics[portid].rx += nb_rx;
338
339                         for (j = 0; j < nb_rx; j++) {
340                                 m = pkts_burst[j];
341                                 rte_prefetch0(rte_pktmbuf_mtod(m, void *));
342                                 l2fwd_simple_forward(m, portid);
343                         }
344                 }
345         }
346 }
347
348 static int
349 l2fwd_launch_one_lcore(__attribute__((unused)) void *dummy)
350 {
351         l2fwd_main_loop();
352         return 0;
353 }
354
355 /* display usage */
356 static void
357 l2fwd_usage(const char *prgname)
358 {
359         printf("%s [EAL options] -- -p PORTMASK [-q NQ]\n"
360                "  -p PORTMASK: hexadecimal bitmask of ports to configure\n"
361                "  -q NQ: number of queue (=ports) per lcore (default is 1)\n"
362                    "  -T PERIOD: statistics will be refreshed each PERIOD seconds (0 to disable, 10 default, 86400 maximum)\n",
363                prgname);
364 }
365
366 static int
367 l2fwd_parse_portmask(const char *portmask)
368 {
369         char *end = NULL;
370         unsigned long pm;
371
372         /* parse hexadecimal string */
373         pm = strtoul(portmask, &end, 16);
374         if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
375                 return -1;
376
377         if (pm == 0)
378                 return -1;
379
380         return pm;
381 }
382
383 static unsigned int
384 l2fwd_parse_nqueue(const char *q_arg)
385 {
386         char *end = NULL;
387         unsigned long n;
388
389         /* parse hexadecimal string */
390         n = strtoul(q_arg, &end, 10);
391         if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0'))
392                 return 0;
393         if (n == 0)
394                 return 0;
395         if (n >= MAX_RX_QUEUE_PER_LCORE)
396                 return 0;
397
398         return n;
399 }
400
401 static int
402 l2fwd_parse_timer_period(const char *q_arg)
403 {
404         char *end = NULL;
405         int n;
406
407         /* parse number string */
408         n = strtol(q_arg, &end, 10);
409         if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0'))
410                 return -1;
411         if (n >= MAX_TIMER_PERIOD)
412                 return -1;
413
414         return n;
415 }
416
417 /* Parse the argument given in the command line of the application */
418 static int
419 l2fwd_parse_args(int argc, char **argv)
420 {
421         int opt, ret;
422         char **argvopt;
423         int option_index;
424         char *prgname = argv[0];
425         static struct option lgopts[] = {
426                 {NULL, 0, 0, 0}
427         };
428
429         argvopt = argv;
430
431         while ((opt = getopt_long(argc, argvopt, "p:q:T:",
432                                   lgopts, &option_index)) != EOF) {
433
434                 switch (opt) {
435                 /* portmask */
436                 case 'p':
437                         l2fwd_enabled_port_mask = l2fwd_parse_portmask(optarg);
438                         if (l2fwd_enabled_port_mask == 0) {
439                                 printf("invalid portmask\n");
440                                 l2fwd_usage(prgname);
441                                 return -1;
442                         }
443                         break;
444
445                 /* nqueue */
446                 case 'q':
447                         l2fwd_rx_queue_per_lcore = l2fwd_parse_nqueue(optarg);
448                         if (l2fwd_rx_queue_per_lcore == 0) {
449                                 printf("invalid queue number\n");
450                                 l2fwd_usage(prgname);
451                                 return -1;
452                         }
453                         break;
454
455                 /* timer period */
456                 case 'T':
457                         timer_period = l2fwd_parse_timer_period(optarg) * 1000 * TIMER_MILLISECOND;
458                         if (timer_period < 0) {
459                                 printf("invalid timer period\n");
460                                 l2fwd_usage(prgname);
461                                 return -1;
462                         }
463                         break;
464
465                 /* long options */
466                 case 0:
467                         l2fwd_usage(prgname);
468                         return -1;
469
470                 default:
471                         l2fwd_usage(prgname);
472                         return -1;
473                 }
474         }
475
476         if (optind >= 0)
477                 argv[optind-1] = prgname;
478
479         ret = optind-1;
480         optind = 0; /* reset getopt lib */
481         return ret;
482 }
483
484 /* Check the link status of all ports in up to 9s, and print them finally */
485 static void
486 check_all_ports_link_status(uint8_t port_num, uint32_t port_mask)
487 {
488 #define CHECK_INTERVAL 100 /* 100ms */
489 #define MAX_CHECK_TIME 90 /* 9s (90 * 100ms) in total */
490         uint8_t portid, count, all_ports_up, print_flag = 0;
491         struct rte_eth_link link;
492
493         printf("\nChecking link status");
494         fflush(stdout);
495         for (count = 0; count <= MAX_CHECK_TIME; count++) {
496                 all_ports_up = 1;
497                 for (portid = 0; portid < port_num; portid++) {
498                         if ((port_mask & (1 << portid)) == 0)
499                                 continue;
500                         memset(&link, 0, sizeof(link));
501                         rte_eth_link_get_nowait(portid, &link);
502                         /* print link status if flag set */
503                         if (print_flag == 1) {
504                                 if (link.link_status)
505                                         printf("Port %d Link Up - speed %u "
506                                                 "Mbps - %s\n", (uint8_t)portid,
507                                                 (unsigned)link.link_speed,
508                                 (link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
509                                         ("full-duplex") : ("half-duplex\n"));
510                                 else
511                                         printf("Port %d Link Down\n",
512                                                 (uint8_t)portid);
513                                 continue;
514                         }
515                         /* clear all_ports_up flag if any link down */
516                         if (link.link_status == 0) {
517                                 all_ports_up = 0;
518                                 break;
519                         }
520                 }
521                 /* after finally printing all link status, get out */
522                 if (print_flag == 1)
523                         break;
524
525                 if (all_ports_up == 0) {
526                         printf(".");
527                         fflush(stdout);
528                         rte_delay_ms(CHECK_INTERVAL);
529                 }
530
531                 /* set the print_flag if all ports up or timeout */
532                 if (all_ports_up == 1 || count == (MAX_CHECK_TIME - 1)) {
533                         print_flag = 1;
534                         printf("done\n");
535                 }
536         }
537 }
538
539 int
540 main(int argc, char **argv)
541 {
542         struct lcore_queue_conf *qconf;
543         struct rte_eth_dev_info dev_info;
544         int ret;
545         uint8_t nb_ports;
546         uint8_t nb_ports_available;
547         uint8_t portid, last_port;
548         unsigned lcore_id, rx_lcore_id;
549         unsigned nb_ports_in_mask = 0;
550
551         /* init EAL */
552         ret = rte_eal_init(argc, argv);
553         if (ret < 0)
554                 rte_exit(EXIT_FAILURE, "Invalid EAL arguments\n");
555         argc -= ret;
556         argv += ret;
557
558         /* parse application arguments (after the EAL ones) */
559         ret = l2fwd_parse_args(argc, argv);
560         if (ret < 0)
561                 rte_exit(EXIT_FAILURE, "Invalid L2FWD arguments\n");
562
563         /* create the mbuf pool */
564         l2fwd_pktmbuf_pool =
565                 rte_mempool_create("mbuf_pool", NB_MBUF,
566                                    MBUF_SIZE, 32,
567                                    sizeof(struct rte_pktmbuf_pool_private),
568                                    rte_pktmbuf_pool_init, NULL,
569                                    rte_pktmbuf_init, NULL,
570                                    rte_socket_id(), 0);
571         if (l2fwd_pktmbuf_pool == NULL)
572                 rte_exit(EXIT_FAILURE, "Cannot init mbuf pool\n");
573
574         nb_ports = rte_eth_dev_count();
575         if (nb_ports == 0)
576                 rte_exit(EXIT_FAILURE, "No Ethernet ports - bye\n");
577
578         if (nb_ports > RTE_MAX_ETHPORTS)
579                 nb_ports = RTE_MAX_ETHPORTS;
580
581         /* reset l2fwd_dst_ports */
582         for (portid = 0; portid < RTE_MAX_ETHPORTS; portid++)
583                 l2fwd_dst_ports[portid] = 0;
584         last_port = 0;
585
586         /*
587          * Each logical core is assigned a dedicated TX queue on each port.
588          */
589         for (portid = 0; portid < nb_ports; portid++) {
590                 /* skip ports that are not enabled */
591                 if ((l2fwd_enabled_port_mask & (1 << portid)) == 0)
592                         continue;
593
594                 if (nb_ports_in_mask % 2) {
595                         l2fwd_dst_ports[portid] = last_port;
596                         l2fwd_dst_ports[last_port] = portid;
597                 }
598                 else
599                         last_port = portid;
600
601                 nb_ports_in_mask++;
602
603                 rte_eth_dev_info_get(portid, &dev_info);
604         }
605         if (nb_ports_in_mask % 2) {
606                 printf("Notice: odd number of ports in portmask.\n");
607                 l2fwd_dst_ports[last_port] = last_port;
608         }
609
610         rx_lcore_id = 0;
611         qconf = NULL;
612
613         /* Initialize the port/queue configuration of each logical core */
614         for (portid = 0; portid < nb_ports; portid++) {
615                 /* skip ports that are not enabled */
616                 if ((l2fwd_enabled_port_mask & (1 << portid)) == 0)
617                         continue;
618
619                 /* get the lcore_id for this port */
620                 while (rte_lcore_is_enabled(rx_lcore_id) == 0 ||
621                        lcore_queue_conf[rx_lcore_id].n_rx_port ==
622                        l2fwd_rx_queue_per_lcore) {
623                         rx_lcore_id++;
624                         if (rx_lcore_id >= RTE_MAX_LCORE)
625                                 rte_exit(EXIT_FAILURE, "Not enough cores\n");
626                 }
627
628                 if (qconf != &lcore_queue_conf[rx_lcore_id])
629                         /* Assigned a new logical core in the loop above. */
630                         qconf = &lcore_queue_conf[rx_lcore_id];
631
632                 qconf->rx_port_list[qconf->n_rx_port] = portid;
633                 qconf->n_rx_port++;
634                 printf("Lcore %u: RX port %u\n", rx_lcore_id, (unsigned) portid);
635         }
636
637         nb_ports_available = nb_ports;
638
639         /* Initialise each port */
640         for (portid = 0; portid < nb_ports; portid++) {
641                 /* skip ports that are not enabled */
642                 if ((l2fwd_enabled_port_mask & (1 << portid)) == 0) {
643                         printf("Skipping disabled port %u\n", (unsigned) portid);
644                         nb_ports_available--;
645                         continue;
646                 }
647                 /* init port */
648                 printf("Initializing port %u... ", (unsigned) portid);
649                 fflush(stdout);
650                 ret = rte_eth_dev_configure(portid, 1, 1, &port_conf);
651                 if (ret < 0)
652                         rte_exit(EXIT_FAILURE, "Cannot configure device: err=%d, port=%u\n",
653                                   ret, (unsigned) portid);
654
655                 rte_eth_macaddr_get(portid,&l2fwd_ports_eth_addr[portid]);
656
657                 /* init one RX queue */
658                 fflush(stdout);
659                 ret = rte_eth_rx_queue_setup(portid, 0, nb_rxd,
660                                              rte_eth_dev_socket_id(portid),
661                                              NULL,
662                                              l2fwd_pktmbuf_pool);
663                 if (ret < 0)
664                         rte_exit(EXIT_FAILURE, "rte_eth_rx_queue_setup:err=%d, port=%u\n",
665                                   ret, (unsigned) portid);
666
667                 /* init one TX queue on each port */
668                 fflush(stdout);
669                 ret = rte_eth_tx_queue_setup(portid, 0, nb_txd,
670                                 rte_eth_dev_socket_id(portid),
671                                 NULL);
672                 if (ret < 0)
673                         rte_exit(EXIT_FAILURE, "rte_eth_tx_queue_setup:err=%d, port=%u\n",
674                                 ret, (unsigned) portid);
675
676                 /* Start device */
677                 ret = rte_eth_dev_start(portid);
678                 if (ret < 0)
679                         rte_exit(EXIT_FAILURE, "rte_eth_dev_start:err=%d, port=%u\n",
680                                   ret, (unsigned) portid);
681
682                 printf("done: \n");
683
684                 rte_eth_promiscuous_enable(portid);
685
686                 printf("Port %u, MAC address: %02X:%02X:%02X:%02X:%02X:%02X\n\n",
687                                 (unsigned) portid,
688                                 l2fwd_ports_eth_addr[portid].addr_bytes[0],
689                                 l2fwd_ports_eth_addr[portid].addr_bytes[1],
690                                 l2fwd_ports_eth_addr[portid].addr_bytes[2],
691                                 l2fwd_ports_eth_addr[portid].addr_bytes[3],
692                                 l2fwd_ports_eth_addr[portid].addr_bytes[4],
693                                 l2fwd_ports_eth_addr[portid].addr_bytes[5]);
694
695                 /* initialize port stats */
696                 memset(&port_statistics, 0, sizeof(port_statistics));
697         }
698
699         if (!nb_ports_available) {
700                 rte_exit(EXIT_FAILURE,
701                         "All available ports are disabled. Please set portmask.\n");
702         }
703
704         check_all_ports_link_status(nb_ports, l2fwd_enabled_port_mask);
705
706         /* launch per-lcore init on every lcore */
707         rte_eal_mp_remote_launch(l2fwd_launch_one_lcore, NULL, CALL_MASTER);
708         RTE_LCORE_FOREACH_SLAVE(lcore_id) {
709                 if (rte_eal_wait_lcore(lcore_id) < 0)
710                         return -1;
711         }
712
713         return 0;
714 }
715