ethdev: remove useless parameter in init functions
[dpdk.git] / examples / load_balancer / config.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 <stdint.h>
37 #include <inttypes.h>
38 #include <sys/types.h>
39 #include <string.h>
40 #include <sys/queue.h>
41 #include <stdarg.h>
42 #include <errno.h>
43 #include <getopt.h>
44
45 #include <rte_common.h>
46 #include <rte_byteorder.h>
47 #include <rte_log.h>
48 #include <rte_memory.h>
49 #include <rte_memcpy.h>
50 #include <rte_memzone.h>
51 #include <rte_tailq.h>
52 #include <rte_eal.h>
53 #include <rte_per_lcore.h>
54 #include <rte_launch.h>
55 #include <rte_atomic.h>
56 #include <rte_cycles.h>
57 #include <rte_prefetch.h>
58 #include <rte_lcore.h>
59 #include <rte_per_lcore.h>
60 #include <rte_branch_prediction.h>
61 #include <rte_interrupts.h>
62 #include <rte_pci.h>
63 #include <rte_random.h>
64 #include <rte_debug.h>
65 #include <rte_ether.h>
66 #include <rte_ethdev.h>
67 #include <rte_ring.h>
68 #include <rte_mempool.h>
69 #include <rte_mbuf.h>
70 #include <rte_ip.h>
71 #include <rte_tcp.h>
72 #include <rte_lpm.h>
73 #include <rte_string_fns.h>
74
75 #include "main.h"
76
77 struct app_params app;
78
79 static const char usage[] =
80 "                                                                               \n"
81 "    load_balancer <EAL PARAMS> -- <APP PARAMS>                                 \n"
82 "                                                                               \n"
83 "Application manadatory parameters:                                             \n"
84 "    --rx \"(PORT, QUEUE, LCORE), ...\" : List of NIC RX ports and queues       \n"
85 "           handled by the I/O RX lcores                                        \n"
86 "    --tx \"(PORT, LCORE), ...\" : List of NIC TX ports handled by the I/O TX   \n"
87 "           lcores                                                              \n"
88 "    --w \"LCORE, ...\" : List of the worker lcores                             \n"
89 "    --lpm \"IP / PREFIX => PORT; ...\" : List of LPM rules used by the worker  \n"
90 "           lcores for packet forwarding                                        \n"
91 "                                                                               \n"
92 "Application optional parameters:                                               \n"
93 "    --rsz \"A, B, C, D\" : Ring sizes                                          \n"
94 "           A = Size (in number of buffer descriptors) of each of the NIC RX    \n"
95 "               rings read by the I/O RX lcores (default value is %u)           \n"
96 "           B = Size (in number of elements) of each of the SW rings used by the\n"
97 "               I/O RX lcores to send packets to worker lcores (default value is\n"
98 "               %u)                                                             \n"
99 "           C = Size (in number of elements) of each of the SW rings used by the\n"
100 "               worker lcores to send packets to I/O TX lcores (default value is\n"
101 "               %u)                                                             \n"
102 "           D = Size (in number of buffer descriptors) of each of the NIC TX    \n"
103 "               rings written by I/O TX lcores (default value is %u)            \n"
104 "    --bsz \"(A, B), (C, D), (E, F)\" :  Burst sizes                            \n"
105 "           A = I/O RX lcore read burst size from NIC RX (default value is %u)  \n"
106 "           B = I/O RX lcore write burst size to output SW rings (default value \n"
107 "               is %u)                                                          \n"
108 "           C = Worker lcore read burst size from input SW rings (default value \n"
109 "               is %u)                                                          \n"
110 "           D = Worker lcore write burst size to output SW rings (default value \n"
111 "               is %u)                                                          \n"
112 "           E = I/O TX lcore read burst size from input SW rings (default value \n"
113 "               is %u)                                                          \n"
114 "           F = I/O TX lcore write burst size to NIC TX (default value is %u)   \n"
115 "    --pos-lb POS : Position of the 1-byte field within the input packet used by\n"
116 "           the I/O RX lcores to identify the worker lcore for the current      \n"
117 "           packet (default value is %u)                                        \n";
118
119 void
120 app_print_usage(void)
121 {
122         printf(usage,
123                 APP_DEFAULT_NIC_RX_RING_SIZE,
124                 APP_DEFAULT_RING_RX_SIZE,
125                 APP_DEFAULT_RING_TX_SIZE,
126                 APP_DEFAULT_NIC_TX_RING_SIZE,
127                 APP_DEFAULT_BURST_SIZE_IO_RX_READ,
128                 APP_DEFAULT_BURST_SIZE_IO_RX_WRITE,
129                 APP_DEFAULT_BURST_SIZE_WORKER_READ,
130                 APP_DEFAULT_BURST_SIZE_WORKER_WRITE,
131                 APP_DEFAULT_BURST_SIZE_IO_TX_READ,
132                 APP_DEFAULT_BURST_SIZE_IO_TX_WRITE,
133                 APP_DEFAULT_IO_RX_LB_POS
134         );
135 }
136
137 #ifndef APP_ARG_RX_MAX_CHARS
138 #define APP_ARG_RX_MAX_CHARS     4096
139 #endif
140
141 #ifndef APP_ARG_RX_MAX_TUPLES
142 #define APP_ARG_RX_MAX_TUPLES    128
143 #endif
144
145 static int
146 str_to_unsigned_array(
147         const char *s, size_t sbuflen,
148         char separator,
149         unsigned num_vals,
150         unsigned *vals)
151 {
152         char str[sbuflen+1];
153         char *splits[num_vals];
154         char *endptr = NULL;
155         int i, num_splits = 0;
156
157         /* copy s so we don't modify original string */
158         snprintf(str, sizeof(str), "%s", s);
159         num_splits = rte_strsplit(str, sizeof(str), splits, num_vals, separator);
160
161         errno = 0;
162         for (i = 0; i < num_splits; i++) {
163                 vals[i] = strtoul(splits[i], &endptr, 0);
164                 if (errno != 0 || *endptr != '\0')
165                         return -1;
166         }
167
168         return num_splits;
169 }
170
171 static int
172 str_to_unsigned_vals(
173         const char *s,
174         size_t sbuflen,
175         char separator,
176         unsigned num_vals, ...)
177 {
178         unsigned i, vals[num_vals];
179         va_list ap;
180
181         num_vals = str_to_unsigned_array(s, sbuflen, separator, num_vals, vals);
182
183         va_start(ap, num_vals);
184         for (i = 0; i < num_vals; i++) {
185                 unsigned *u = va_arg(ap, unsigned *);
186                 *u = vals[i];
187         }
188         va_end(ap);
189         return num_vals;
190 }
191
192 static int
193 parse_arg_rx(const char *arg)
194 {
195         const char *p0 = arg, *p = arg;
196         uint32_t n_tuples;
197
198         if (strnlen(arg, APP_ARG_RX_MAX_CHARS + 1) == APP_ARG_RX_MAX_CHARS + 1) {
199                 return -1;
200         }
201
202         n_tuples = 0;
203         while ((p = strchr(p0,'(')) != NULL) {
204                 struct app_lcore_params *lp;
205                 uint32_t port, queue, lcore, i;
206
207                 p0 = strchr(p++, ')');
208                 if ((p0 == NULL) ||
209                     (str_to_unsigned_vals(p, p0 - p, ',', 3, &port, &queue, &lcore) !=  3)) {
210                         return -2;
211                 }
212
213                 /* Enable port and queue for later initialization */
214                 if ((port >= APP_MAX_NIC_PORTS) || (queue >= APP_MAX_RX_QUEUES_PER_NIC_PORT)) {
215                         return -3;
216                 }
217                 if (app.nic_rx_queue_mask[port][queue] != 0) {
218                         return -4;
219                 }
220                 app.nic_rx_queue_mask[port][queue] = 1;
221
222                 /* Check and assign (port, queue) to I/O lcore */
223                 if (rte_lcore_is_enabled(lcore) == 0) {
224                         return -5;
225                 }
226
227                 if (lcore >= APP_MAX_LCORES) {
228                         return -6;
229                 }
230                 lp = &app.lcore_params[lcore];
231                 if (lp->type == e_APP_LCORE_WORKER) {
232                         return -7;
233                 }
234                 lp->type = e_APP_LCORE_IO;
235                 for (i = 0; i < lp->io.rx.n_nic_queues; i ++) {
236                         if ((lp->io.rx.nic_queues[i].port == port) &&
237                             (lp->io.rx.nic_queues[i].queue == queue)) {
238                                 return -8;
239                         }
240                 }
241                 if (lp->io.rx.n_nic_queues >= APP_MAX_NIC_RX_QUEUES_PER_IO_LCORE) {
242                         return -9;
243                 }
244                 lp->io.rx.nic_queues[lp->io.rx.n_nic_queues].port = (uint8_t) port;
245                 lp->io.rx.nic_queues[lp->io.rx.n_nic_queues].queue = (uint8_t) queue;
246                 lp->io.rx.n_nic_queues ++;
247
248                 n_tuples ++;
249                 if (n_tuples > APP_ARG_RX_MAX_TUPLES) {
250                         return -10;
251                 }
252         }
253
254         if (n_tuples == 0) {
255                 return -11;
256         }
257
258         return 0;
259 }
260
261 #ifndef APP_ARG_TX_MAX_CHARS
262 #define APP_ARG_TX_MAX_CHARS     4096
263 #endif
264
265 #ifndef APP_ARG_TX_MAX_TUPLES
266 #define APP_ARG_TX_MAX_TUPLES    128
267 #endif
268
269 static int
270 parse_arg_tx(const char *arg)
271 {
272         const char *p0 = arg, *p = arg;
273         uint32_t n_tuples;
274
275         if (strnlen(arg, APP_ARG_TX_MAX_CHARS + 1) == APP_ARG_TX_MAX_CHARS + 1) {
276                 return -1;
277         }
278
279         n_tuples = 0;
280         while ((p = strchr(p0,'(')) != NULL) {
281                 struct app_lcore_params *lp;
282                 uint32_t port, lcore, i;
283
284                 p0 = strchr(p++, ')');
285                 if ((p0 == NULL) ||
286                     (str_to_unsigned_vals(p, p0 - p, ',', 2, &port, &lcore) !=  2)) {
287                         return -2;
288                 }
289
290                 /* Enable port and queue for later initialization */
291                 if (port >= APP_MAX_NIC_PORTS) {
292                         return -3;
293                 }
294                 if (app.nic_tx_port_mask[port] != 0) {
295                         return -4;
296                 }
297                 app.nic_tx_port_mask[port] = 1;
298
299                 /* Check and assign (port, queue) to I/O lcore */
300                 if (rte_lcore_is_enabled(lcore) == 0) {
301                         return -5;
302                 }
303
304                 if (lcore >= APP_MAX_LCORES) {
305                         return -6;
306                 }
307                 lp = &app.lcore_params[lcore];
308                 if (lp->type == e_APP_LCORE_WORKER) {
309                         return -7;
310                 }
311                 lp->type = e_APP_LCORE_IO;
312                 for (i = 0; i < lp->io.tx.n_nic_ports; i ++) {
313                         if (lp->io.tx.nic_ports[i] == port) {
314                                 return -8;
315                         }
316                 }
317                 if (lp->io.tx.n_nic_ports >= APP_MAX_NIC_TX_PORTS_PER_IO_LCORE) {
318                         return -9;
319                 }
320                 lp->io.tx.nic_ports[lp->io.tx.n_nic_ports] = (uint8_t) port;
321                 lp->io.tx.n_nic_ports ++;
322
323                 n_tuples ++;
324                 if (n_tuples > APP_ARG_TX_MAX_TUPLES) {
325                         return -10;
326                 }
327         }
328
329         if (n_tuples == 0) {
330                 return -11;
331         }
332
333         return 0;
334 }
335
336 #ifndef APP_ARG_W_MAX_CHARS
337 #define APP_ARG_W_MAX_CHARS     4096
338 #endif
339
340 #ifndef APP_ARG_W_MAX_TUPLES
341 #define APP_ARG_W_MAX_TUPLES    APP_MAX_WORKER_LCORES
342 #endif
343
344 static int
345 parse_arg_w(const char *arg)
346 {
347         const char *p = arg;
348         uint32_t n_tuples;
349
350         if (strnlen(arg, APP_ARG_W_MAX_CHARS + 1) == APP_ARG_W_MAX_CHARS + 1) {
351                 return -1;
352         }
353
354         n_tuples = 0;
355         while (*p != 0) {
356                 struct app_lcore_params *lp;
357                 uint32_t lcore;
358
359                 errno = 0;
360                 lcore = strtoul(p, NULL, 0);
361                 if ((errno != 0)) {
362                         return -2;
363                 }
364
365                 /* Check and enable worker lcore */
366                 if (rte_lcore_is_enabled(lcore) == 0) {
367                         return -3;
368                 }
369
370                 if (lcore >= APP_MAX_LCORES) {
371                         return -4;
372                 }
373                 lp = &app.lcore_params[lcore];
374                 if (lp->type == e_APP_LCORE_IO) {
375                         return -5;
376                 }
377                 lp->type = e_APP_LCORE_WORKER;
378
379                 n_tuples ++;
380                 if (n_tuples > APP_ARG_W_MAX_TUPLES) {
381                         return -6;
382                 }
383
384                 p = strchr(p, ',');
385                 if (p == NULL) {
386                         break;
387                 }
388                 p ++;
389         }
390
391         if (n_tuples == 0) {
392                 return -7;
393         }
394
395         if ((n_tuples & (n_tuples - 1)) != 0) {
396                 return -8;
397         }
398
399         return 0;
400 }
401
402 #ifndef APP_ARG_LPM_MAX_CHARS
403 #define APP_ARG_LPM_MAX_CHARS     4096
404 #endif
405
406 static int
407 parse_arg_lpm(const char *arg)
408 {
409         const char *p = arg, *p0;
410
411         if (strnlen(arg, APP_ARG_LPM_MAX_CHARS + 1) == APP_ARG_TX_MAX_CHARS + 1) {
412                 return -1;
413         }
414
415         while (*p != 0) {
416                 uint32_t ip_a, ip_b, ip_c, ip_d, ip, depth, if_out;
417                 char *endptr;
418
419                 p0 = strchr(p, '/');
420                 if ((p0 == NULL) ||
421                     (str_to_unsigned_vals(p, p0 - p, '.', 4, &ip_a, &ip_b, &ip_c, &ip_d) != 4)) {
422                         return -2;
423                 }
424
425                 p = p0 + 1;
426                 errno = 0;
427                 depth = strtoul(p, &endptr, 0);
428                 if (errno != 0 || *endptr != '=') {
429                         return -3;
430                 }
431                 p = strchr(p, '>');
432                 if (p == NULL) {
433                         return -4;
434                 }
435                 if_out = strtoul(++p, &endptr, 0);
436                 if (errno != 0 || (*endptr != '\0' && *endptr != ';')) {
437                         return -5;
438                 }
439
440                 if ((ip_a >= 256) || (ip_b >= 256) || (ip_c >= 256) || (ip_d >= 256) ||
441                      (depth == 0) || (depth >= 32) ||
442                          (if_out >= APP_MAX_NIC_PORTS)) {
443                         return -6;
444                 }
445                 ip = (ip_a << 24) | (ip_b << 16) | (ip_c << 8) | ip_d;
446
447                 if (app.n_lpm_rules >= APP_MAX_LPM_RULES) {
448                         return -7;
449                 }
450                 app.lpm_rules[app.n_lpm_rules].ip = ip;
451                 app.lpm_rules[app.n_lpm_rules].depth = (uint8_t) depth;
452                 app.lpm_rules[app.n_lpm_rules].if_out = (uint8_t) if_out;
453                 app.n_lpm_rules ++;
454
455                 p = strchr(p, ';');
456                 if (p == NULL) {
457                         return -8;
458                 }
459                 p ++;
460         }
461
462         if (app.n_lpm_rules == 0) {
463                 return -9;
464         }
465
466         return 0;
467 }
468
469 static int
470 app_check_lpm_table(void)
471 {
472         uint32_t rule;
473
474         /* For each rule, check that the output I/F is enabled */
475         for (rule = 0; rule < app.n_lpm_rules; rule ++)
476         {
477                 uint32_t port = app.lpm_rules[rule].if_out;
478
479                 if (app.nic_tx_port_mask[port] == 0) {
480                         return -1;
481                 }
482         }
483
484         return 0;
485 }
486
487 static int
488 app_check_every_rx_port_is_tx_enabled(void)
489 {
490         uint8_t port;
491
492         for (port = 0; port < APP_MAX_NIC_PORTS; port ++) {
493                 if ((app_get_nic_rx_queues_per_port(port) > 0) && (app.nic_tx_port_mask[port] == 0)) {
494                         return -1;
495                 }
496         }
497
498         return 0;
499 }
500
501 #ifndef APP_ARG_RSZ_CHARS
502 #define APP_ARG_RSZ_CHARS 63
503 #endif
504
505 static int
506 parse_arg_rsz(const char *arg)
507 {
508         if (strnlen(arg, APP_ARG_RSZ_CHARS + 1) == APP_ARG_RSZ_CHARS + 1) {
509                 return -1;
510         }
511
512         if (str_to_unsigned_vals(arg, APP_ARG_RSZ_CHARS, ',', 4,
513                         &app.nic_rx_ring_size,
514                         &app.ring_rx_size,
515                         &app.ring_tx_size,
516                         &app.nic_tx_ring_size) !=  4)
517                 return -2;
518
519
520         if ((app.nic_rx_ring_size == 0) ||
521                 (app.nic_tx_ring_size == 0) ||
522                 (app.ring_rx_size == 0) ||
523                 (app.ring_tx_size == 0)) {
524                 return -3;
525         }
526
527         return 0;
528 }
529
530 #ifndef APP_ARG_BSZ_CHARS
531 #define APP_ARG_BSZ_CHARS 63
532 #endif
533
534 static int
535 parse_arg_bsz(const char *arg)
536 {
537         const char *p = arg, *p0;
538         if (strnlen(arg, APP_ARG_BSZ_CHARS + 1) == APP_ARG_BSZ_CHARS + 1) {
539                 return -1;
540         }
541
542         p0 = strchr(p++, ')');
543         if ((p0 == NULL) ||
544             (str_to_unsigned_vals(p, p0 - p, ',', 2, &app.burst_size_io_rx_read, &app.burst_size_io_rx_write) !=  2)) {
545                 return -2;
546         }
547
548         p = strchr(p0, '(');
549         if (p == NULL) {
550                 return -3;
551         }
552
553         p0 = strchr(p++, ')');
554         if ((p0 == NULL) ||
555             (str_to_unsigned_vals(p, p0 - p, ',', 2, &app.burst_size_worker_read, &app.burst_size_worker_write) !=  2)) {
556                 return -4;
557         }
558
559         p = strchr(p0, '(');
560         if (p == NULL) {
561                 return -5;
562         }
563
564         p0 = strchr(p++, ')');
565         if ((p0 == NULL) ||
566             (str_to_unsigned_vals(p, p0 - p, ',', 2, &app.burst_size_io_tx_read, &app.burst_size_io_tx_write) !=  2)) {
567                 return -6;
568         }
569
570         if ((app.burst_size_io_rx_read == 0) ||
571                 (app.burst_size_io_rx_write == 0) ||
572                 (app.burst_size_worker_read == 0) ||
573                 (app.burst_size_worker_write == 0) ||
574                 (app.burst_size_io_tx_read == 0) ||
575                 (app.burst_size_io_tx_write == 0)) {
576                 return -7;
577         }
578
579         if ((app.burst_size_io_rx_read > APP_MBUF_ARRAY_SIZE) ||
580                 (app.burst_size_io_rx_write > APP_MBUF_ARRAY_SIZE) ||
581                 (app.burst_size_worker_read > APP_MBUF_ARRAY_SIZE) ||
582                 (app.burst_size_worker_write > APP_MBUF_ARRAY_SIZE) ||
583                 ((2 * app.burst_size_io_tx_read) > APP_MBUF_ARRAY_SIZE) ||
584                 (app.burst_size_io_tx_write > APP_MBUF_ARRAY_SIZE)) {
585                 return -8;
586         }
587
588         return 0;
589 }
590
591 #ifndef APP_ARG_NUMERICAL_SIZE_CHARS
592 #define APP_ARG_NUMERICAL_SIZE_CHARS 15
593 #endif
594
595 static int
596 parse_arg_pos_lb(const char *arg)
597 {
598         uint32_t x;
599         char *endpt;
600
601         if (strnlen(arg, APP_ARG_NUMERICAL_SIZE_CHARS + 1) == APP_ARG_NUMERICAL_SIZE_CHARS + 1) {
602                 return -1;
603         }
604
605         errno = 0;
606         x = strtoul(arg, &endpt, 10);
607         if (errno != 0 || endpt == arg || *endpt != '\0'){
608                 return -2;
609         }
610
611         if (x >= 64) {
612                 return -3;
613         }
614
615         app.pos_lb = (uint8_t) x;
616
617         return 0;
618 }
619
620 /* Parse the argument given in the command line of the application */
621 int
622 app_parse_args(int argc, char **argv)
623 {
624         int opt, ret;
625         char **argvopt;
626         int option_index;
627         char *prgname = argv[0];
628         static struct option lgopts[] = {
629                 {"rx", 1, 0, 0},
630                 {"tx", 1, 0, 0},
631                 {"w", 1, 0, 0},
632                 {"lpm", 1, 0, 0},
633                 {"rsz", 1, 0, 0},
634                 {"bsz", 1, 0, 0},
635                 {"pos-lb", 1, 0, 0},
636                 {NULL, 0, 0, 0}
637         };
638         uint32_t arg_w = 0;
639         uint32_t arg_rx = 0;
640         uint32_t arg_tx = 0;
641         uint32_t arg_lpm = 0;
642         uint32_t arg_rsz = 0;
643         uint32_t arg_bsz = 0;
644         uint32_t arg_pos_lb = 0;
645
646         argvopt = argv;
647
648         while ((opt = getopt_long(argc, argvopt, "",
649                                 lgopts, &option_index)) != EOF) {
650
651                 switch (opt) {
652                 /* long options */
653                 case 0:
654                         if (!strcmp(lgopts[option_index].name, "rx")) {
655                                 arg_rx = 1;
656                                 ret = parse_arg_rx(optarg);
657                                 if (ret) {
658                                         printf("Incorrect value for --rx argument (%d)\n", ret);
659                                         return -1;
660                                 }
661                         }
662                         if (!strcmp(lgopts[option_index].name, "tx")) {
663                                 arg_tx = 1;
664                                 ret = parse_arg_tx(optarg);
665                                 if (ret) {
666                                         printf("Incorrect value for --tx argument (%d)\n", ret);
667                                         return -1;
668                                 }
669                         }
670                         if (!strcmp(lgopts[option_index].name, "w")) {
671                                 arg_w = 1;
672                                 ret = parse_arg_w(optarg);
673                                 if (ret) {
674                                         printf("Incorrect value for --w argument (%d)\n", ret);
675                                         return -1;
676                                 }
677                         }
678                         if (!strcmp(lgopts[option_index].name, "lpm")) {
679                                 arg_lpm = 1;
680                                 ret = parse_arg_lpm(optarg);
681                                 if (ret) {
682                                         printf("Incorrect value for --lpm argument (%d)\n", ret);
683                                         return -1;
684                                 }
685                         }
686                         if (!strcmp(lgopts[option_index].name, "rsz")) {
687                                 arg_rsz = 1;
688                                 ret = parse_arg_rsz(optarg);
689                                 if (ret) {
690                                         printf("Incorrect value for --rsz argument (%d)\n", ret);
691                                         return -1;
692                                 }
693                         }
694                         if (!strcmp(lgopts[option_index].name, "bsz")) {
695                                 arg_bsz = 1;
696                                 ret = parse_arg_bsz(optarg);
697                                 if (ret) {
698                                         printf("Incorrect value for --bsz argument (%d)\n", ret);
699                                         return -1;
700                                 }
701                         }
702                         if (!strcmp(lgopts[option_index].name, "pos-lb")) {
703                                 arg_pos_lb = 1;
704                                 ret = parse_arg_pos_lb(optarg);
705                                 if (ret) {
706                                         printf("Incorrect value for --pos-lb argument (%d)\n", ret);
707                                         return -1;
708                                 }
709                         }
710                         break;
711
712                 default:
713                         return -1;
714                 }
715         }
716
717         /* Check that all mandatory arguments are provided */
718         if ((arg_rx == 0) || (arg_tx == 0) || (arg_w == 0) || (arg_lpm == 0)){
719                 printf("Not all mandatory arguments are present\n");
720                 return -1;
721         }
722
723         /* Assign default values for the optional arguments not provided */
724         if (arg_rsz == 0) {
725                 app.nic_rx_ring_size = APP_DEFAULT_NIC_RX_RING_SIZE;
726                 app.nic_tx_ring_size = APP_DEFAULT_NIC_TX_RING_SIZE;
727                 app.ring_rx_size = APP_DEFAULT_RING_RX_SIZE;
728                 app.ring_tx_size = APP_DEFAULT_RING_TX_SIZE;
729         }
730
731         if (arg_bsz == 0) {
732                 app.burst_size_io_rx_read = APP_DEFAULT_BURST_SIZE_IO_RX_READ;
733                 app.burst_size_io_rx_write = APP_DEFAULT_BURST_SIZE_IO_RX_WRITE;
734                 app.burst_size_io_tx_read = APP_DEFAULT_BURST_SIZE_IO_TX_READ;
735                 app.burst_size_io_tx_write = APP_DEFAULT_BURST_SIZE_IO_TX_WRITE;
736                 app.burst_size_worker_read = APP_DEFAULT_BURST_SIZE_WORKER_READ;
737                 app.burst_size_worker_write = APP_DEFAULT_BURST_SIZE_WORKER_WRITE;
738         }
739
740         if (arg_pos_lb == 0) {
741                 app.pos_lb = APP_DEFAULT_IO_RX_LB_POS;
742         }
743
744         /* Check cross-consistency of arguments */
745         if ((ret = app_check_lpm_table()) < 0) {
746                 printf("At least one LPM rule is inconsistent (%d)\n", ret);
747                 return -1;
748         }
749         if (app_check_every_rx_port_is_tx_enabled() < 0) {
750                 printf("On LPM lookup miss, packet is sent back on the input port.\n");
751                 printf("At least one RX port is not enabled for TX.\n");
752                 return -2;
753         }
754
755         if (optind >= 0)
756                 argv[optind - 1] = prgname;
757
758         ret = optind - 1;
759         optind = 0; /* reset getopt lib */
760         return ret;
761 }
762
763 int
764 app_get_nic_rx_queues_per_port(uint8_t port)
765 {
766         uint32_t i, count;
767
768         if (port >= APP_MAX_NIC_PORTS) {
769                 return -1;
770         }
771
772         count = 0;
773         for (i = 0; i < APP_MAX_RX_QUEUES_PER_NIC_PORT; i ++) {
774                 if (app.nic_rx_queue_mask[port][i] == 1) {
775                         count ++;
776                 }
777         }
778
779         return count;
780 }
781
782 int
783 app_get_lcore_for_nic_rx(uint8_t port, uint8_t queue, uint32_t *lcore_out)
784 {
785         uint32_t lcore;
786
787         for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
788                 struct app_lcore_params_io *lp = &app.lcore_params[lcore].io;
789                 uint32_t i;
790
791                 if (app.lcore_params[lcore].type != e_APP_LCORE_IO) {
792                         continue;
793                 }
794
795                 for (i = 0; i < lp->rx.n_nic_queues; i ++) {
796                         if ((lp->rx.nic_queues[i].port == port) &&
797                             (lp->rx.nic_queues[i].queue == queue)) {
798                                 *lcore_out = lcore;
799                                 return 0;
800                         }
801                 }
802         }
803
804         return -1;
805 }
806
807 int
808 app_get_lcore_for_nic_tx(uint8_t port, uint32_t *lcore_out)
809 {
810         uint32_t lcore;
811
812         for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
813                 struct app_lcore_params_io *lp = &app.lcore_params[lcore].io;
814                 uint32_t i;
815
816                 if (app.lcore_params[lcore].type != e_APP_LCORE_IO) {
817                         continue;
818                 }
819
820                 for (i = 0; i < lp->tx.n_nic_ports; i ++) {
821                         if (lp->tx.nic_ports[i] == port) {
822                                 *lcore_out = lcore;
823                                 return 0;
824                         }
825                 }
826         }
827
828         return -1;
829 }
830
831 int
832 app_is_socket_used(uint32_t socket)
833 {
834         uint32_t lcore;
835
836         for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
837                 if (app.lcore_params[lcore].type == e_APP_LCORE_DISABLED) {
838                         continue;
839                 }
840
841                 if (socket == rte_lcore_to_socket_id(lcore)) {
842                         return 1;
843                 }
844         }
845
846         return 0;
847 }
848
849 uint32_t
850 app_get_lcores_io_rx(void)
851 {
852         uint32_t lcore, count;
853
854         count = 0;
855         for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
856                 struct app_lcore_params_io *lp_io = &app.lcore_params[lcore].io;
857
858                 if ((app.lcore_params[lcore].type != e_APP_LCORE_IO) ||
859                     (lp_io->rx.n_nic_queues == 0)) {
860                         continue;
861                 }
862
863                 count ++;
864         }
865
866         return count;
867 }
868
869 uint32_t
870 app_get_lcores_worker(void)
871 {
872         uint32_t lcore, count;
873
874         count = 0;
875         for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
876                 if (app.lcore_params[lcore].type != e_APP_LCORE_WORKER) {
877                         continue;
878                 }
879
880                 count ++;
881         }
882
883         if (count > APP_MAX_WORKER_LCORES) {
884                 rte_panic("Algorithmic error (too many worker lcores)\n");
885                 return 0;
886         }
887
888         return count;
889 }
890
891 void
892 app_print_params(void)
893 {
894         unsigned port, queue, lcore, rule, i, j;
895
896         /* Print NIC RX configuration */
897         printf("NIC RX ports: ");
898         for (port = 0; port < APP_MAX_NIC_PORTS; port ++) {
899                 uint32_t n_rx_queues = app_get_nic_rx_queues_per_port((uint8_t) port);
900
901                 if (n_rx_queues == 0) {
902                         continue;
903                 }
904
905                 printf("%u (", port);
906                 for (queue = 0; queue < APP_MAX_RX_QUEUES_PER_NIC_PORT; queue ++) {
907                         if (app.nic_rx_queue_mask[port][queue] == 1) {
908                                 printf("%u ", queue);
909                         }
910                 }
911                 printf(")  ");
912         }
913         printf(";\n");
914
915         /* Print I/O lcore RX params */
916         for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
917                 struct app_lcore_params_io *lp = &app.lcore_params[lcore].io;
918
919                 if ((app.lcore_params[lcore].type != e_APP_LCORE_IO) ||
920                     (lp->rx.n_nic_queues == 0)) {
921                         continue;
922                 }
923
924                 printf("I/O lcore %u (socket %u): ", lcore, rte_lcore_to_socket_id(lcore));
925
926                 printf("RX ports  ");
927                 for (i = 0; i < lp->rx.n_nic_queues; i ++) {
928                         printf("(%u, %u)  ",
929                                 (unsigned) lp->rx.nic_queues[i].port,
930                                 (unsigned) lp->rx.nic_queues[i].queue);
931                 }
932                 printf("; ");
933
934                 printf("Output rings  ");
935                 for (i = 0; i < lp->rx.n_rings; i ++) {
936                         printf("%p  ", lp->rx.rings[i]);
937                 }
938                 printf(";\n");
939         }
940
941         /* Print worker lcore RX params */
942         for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
943                 struct app_lcore_params_worker *lp = &app.lcore_params[lcore].worker;
944
945                 if (app.lcore_params[lcore].type != e_APP_LCORE_WORKER) {
946                         continue;
947                 }
948
949                 printf("Worker lcore %u (socket %u) ID %u: ",
950                         lcore,
951                         rte_lcore_to_socket_id(lcore),
952                         (unsigned)lp->worker_id);
953
954                 printf("Input rings  ");
955                 for (i = 0; i < lp->n_rings_in; i ++) {
956                         printf("%p  ", lp->rings_in[i]);
957                 }
958
959                 printf(";\n");
960         }
961
962         printf("\n");
963
964         /* Print NIC TX configuration */
965         printf("NIC TX ports:  ");
966         for (port = 0; port < APP_MAX_NIC_PORTS; port ++) {
967                 if (app.nic_tx_port_mask[port] == 1) {
968                         printf("%u  ", port);
969                 }
970         }
971         printf(";\n");
972
973         /* Print I/O TX lcore params */
974         for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
975                 struct app_lcore_params_io *lp = &app.lcore_params[lcore].io;
976                 uint32_t n_workers = app_get_lcores_worker();
977
978                 if ((app.lcore_params[lcore].type != e_APP_LCORE_IO) ||
979                      (lp->tx.n_nic_ports == 0)) {
980                         continue;
981                 }
982
983                 printf("I/O lcore %u (socket %u): ", lcore, rte_lcore_to_socket_id(lcore));
984
985                 printf("Input rings per TX port  ");
986                 for (i = 0; i < lp->tx.n_nic_ports; i ++) {
987                         port = lp->tx.nic_ports[i];
988
989                         printf("%u (", port);
990                         for (j = 0; j < n_workers; j ++) {
991                                 printf("%p  ", lp->tx.rings[port][j]);
992                         }
993                         printf(")  ");
994
995                 }
996
997                 printf(";\n");
998         }
999
1000         /* Print worker lcore TX params */
1001         for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
1002                 struct app_lcore_params_worker *lp = &app.lcore_params[lcore].worker;
1003
1004                 if (app.lcore_params[lcore].type != e_APP_LCORE_WORKER) {
1005                         continue;
1006                 }
1007
1008                 printf("Worker lcore %u (socket %u) ID %u: \n",
1009                         lcore,
1010                         rte_lcore_to_socket_id(lcore),
1011                         (unsigned)lp->worker_id);
1012
1013                 printf("Output rings per TX port  ");
1014                 for (port = 0; port < APP_MAX_NIC_PORTS; port ++) {
1015                         if (lp->rings_out[port] != NULL) {
1016                                 printf("%u (%p)  ", port, lp->rings_out[port]);
1017                         }
1018                 }
1019
1020                 printf(";\n");
1021         }
1022
1023         /* Print LPM rules */
1024         printf("LPM rules: \n");
1025         for (rule = 0; rule < app.n_lpm_rules; rule ++) {
1026                 uint32_t ip = app.lpm_rules[rule].ip;
1027                 uint8_t depth = app.lpm_rules[rule].depth;
1028                 uint8_t if_out = app.lpm_rules[rule].if_out;
1029
1030                 printf("\t%u: %u.%u.%u.%u/%u => %u;\n",
1031                         rule,
1032                         (unsigned) (ip & 0xFF000000) >> 24,
1033                         (unsigned) (ip & 0x00FF0000) >> 16,
1034                         (unsigned) (ip & 0x0000FF00) >> 8,
1035                         (unsigned) ip & 0x000000FF,
1036                         (unsigned) depth,
1037                         (unsigned) if_out
1038                 );
1039         }
1040
1041         /* Rings */
1042         printf("Ring sizes: NIC RX = %u; Worker in = %u; Worker out = %u; NIC TX = %u;\n",
1043                 (unsigned) app.nic_rx_ring_size,
1044                 (unsigned) app.ring_rx_size,
1045                 (unsigned) app.ring_tx_size,
1046                 (unsigned) app.nic_tx_ring_size);
1047
1048         /* Bursts */
1049         printf("Burst sizes: I/O RX (rd = %u, wr = %u); Worker (rd = %u, wr = %u); I/O TX (rd = %u, wr = %u)\n",
1050                 (unsigned) app.burst_size_io_rx_read,
1051                 (unsigned) app.burst_size_io_rx_write,
1052                 (unsigned) app.burst_size_worker_read,
1053                 (unsigned) app.burst_size_worker_write,
1054                 (unsigned) app.burst_size_io_tx_read,
1055                 (unsigned) app.burst_size_io_tx_write);
1056 }