app/test-fib: get rid of libresolv dependency
[dpdk.git] / app / test-fib / main.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2019 Intel Corporation
3  */
4
5 #include <getopt.h>
6 #include <string.h>
7 #include <arpa/inet.h>
8 #include <sys/socket.h>
9
10 #include <rte_cycles.h>
11 #include <rte_errno.h>
12 #include <rte_ip.h>
13 #include <rte_random.h>
14 #include <rte_malloc.h>
15 #include <rte_lpm.h>
16 #include <rte_lpm6.h>
17 #include <rte_fib.h>
18 #include <rte_fib6.h>
19
20 #define PRINT_USAGE_START       "%s [EAL options] --\n"
21
22 #define GET_CB_FIELD(in, fd, base, lim, dlm)    do {            \
23         unsigned long val;                                      \
24         char *end_fld;                                          \
25         errno = 0;                                              \
26         val = strtoul((in), &end_fld, (base));                  \
27         if (errno != 0 || end_fld[0] != (dlm) || val > (lim))   \
28                 return -EINVAL;                                 \
29         (fd) = (typeof(fd))val;                                 \
30         (in) = end_fld + 1;                                     \
31 } while (0)
32
33 #define DEF_ROUTES_NUM          0x10000
34 #define DEF_LOOKUP_IPS_NUM      0x100000
35 #define BURST_SZ                64
36 #define DEFAULT_LPM_TBL8        100000U
37
38 #define CMP_FLAG                (1 << 0)
39 #define CMP_ALL_FLAG            (1 << 1)
40 #define IPV6_FLAG               (1 << 2)
41 #define FIB_RIB_TYPE            (1 << 3)
42 #define FIB_V4_DIR_TYPE         (1 << 4)
43 #define FIB_V6_TRIE_TYPE        (1 << 4)
44 #define FIB_TYPE_MASK           (FIB_RIB_TYPE|FIB_V4_DIR_TYPE|FIB_V6_TRIE_TYPE)
45 #define SHUFFLE_FLAG            (1 << 7)
46 #define DRY_RUN_FLAG            (1 << 8)
47
48 static char *distrib_string;
49 static char line[LINE_MAX];
50
51 enum {
52         RT_PREFIX,
53         RT_NEXTHOP,
54         RT_NUM
55 };
56
57 #ifndef NIPQUAD
58 #define NIPQUAD_FMT "%u.%u.%u.%u"
59 #define NIPQUAD(addr)                           \
60         (unsigned)((unsigned char *)&addr)[3],  \
61         (unsigned)((unsigned char *)&addr)[2],  \
62         (unsigned)((unsigned char *)&addr)[1],  \
63         (unsigned)((unsigned char *)&addr)[0]
64
65 #define NIPQUAD6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
66 #define NIPQUAD6(addr)                          \
67         ((uint8_t *)addr)[0] << 8 |     \
68         ((uint8_t *)addr)[1],           \
69         ((uint8_t *)addr)[2] << 8 |     \
70         ((uint8_t *)addr)[3],           \
71         ((uint8_t *)addr)[4] << 8 |     \
72         ((uint8_t *)addr)[5],           \
73         ((uint8_t *)addr)[6] << 8 |     \
74         ((uint8_t *)addr)[7],           \
75         ((uint8_t *)addr)[8] << 8 |     \
76         ((uint8_t *)addr)[9],           \
77         ((uint8_t *)addr)[10] << 8 |    \
78         ((uint8_t *)addr)[11],          \
79         ((uint8_t *)addr)[12] << 8 |    \
80         ((uint8_t *)addr)[13],          \
81         ((uint8_t *)addr)[14] << 8 |    \
82         ((uint8_t *)addr)[15]
83 #endif
84
85 static struct {
86         const char      *prgname;
87         const char      *routes_file;
88         const char      *lookup_ips_file;
89         const char      *routes_file_s;
90         const char      *lookup_ips_file_s;
91         void            *rt;
92         void            *lookup_tbl;
93         uint32_t        nb_routes;
94         uint32_t        nb_lookup_ips;
95         uint32_t        nb_lookup_ips_rnd;
96         uint32_t        nb_routes_per_depth[128 + 1];
97         uint32_t        flags;
98         uint32_t        tbl8;
99         uint8_t         ent_sz;
100         uint8_t         rnd_lookup_ips_ratio;
101         uint8_t         print_fract;
102 } config = {
103         .routes_file = NULL,
104         .lookup_ips_file = NULL,
105         .nb_routes = DEF_ROUTES_NUM,
106         .nb_lookup_ips = DEF_LOOKUP_IPS_NUM,
107         .nb_lookup_ips_rnd = 0,
108         .nb_routes_per_depth = {0},
109         .flags = FIB_V4_DIR_TYPE,
110         .tbl8 = DEFAULT_LPM_TBL8,
111         .ent_sz = 4,
112         .rnd_lookup_ips_ratio = 0,
113         .print_fract = 10
114 };
115
116 struct rt_rule_4 {
117         uint32_t        addr;
118         uint8_t         depth;
119         uint64_t        nh;
120 };
121
122 struct rt_rule_6 {
123         uint8_t         addr[16];
124         uint8_t         depth;
125         uint64_t        nh;
126 };
127
128 static uint64_t
129 get_rnd_rng(uint64_t l, uint64_t u)
130 {
131         if (l == u)
132                 return l;
133         else
134                 return (rte_rand() % (u - l) + l);
135 }
136
137 static __rte_always_inline __attribute__((pure)) uint8_t
138 bits_in_nh(uint8_t nh_sz)
139 {
140         return 8 * (1 << nh_sz);
141 }
142
143 static  __rte_always_inline __attribute__((pure)) uint64_t
144 get_max_nh(uint8_t nh_sz)
145 {
146         /* min between fib and lpm6 which is 21 bits */
147         return RTE_MIN(((1ULL << (bits_in_nh(nh_sz) - 1)) - 1),
148                         (1ULL << 21) - 1);
149 }
150
151 static int
152 get_fib_type(void)
153 {
154         if (config.flags & IPV6_FLAG) {
155                 if ((config.flags & FIB_TYPE_MASK) == FIB_V6_TRIE_TYPE)
156                         return RTE_FIB6_TRIE;
157                 else
158                         return RTE_FIB6_DUMMY;
159         } else {
160                 if ((config.flags & FIB_TYPE_MASK) == FIB_V4_DIR_TYPE)
161                         return RTE_FIB_DIR24_8;
162                 if ((config.flags & FIB_TYPE_MASK) == FIB_RIB_TYPE)
163                         return RTE_FIB_DUMMY;
164         }
165         return -1;
166 }
167
168 static int
169 complete_distrib(uint8_t depth_lim, const uint32_t n, uint8_t rpd[],
170         uint32_t nrpd[])
171 {
172         uint8_t depth;
173         uint32_t nr = 0;
174         uint8_t m = 0;
175
176         /*
177          * complete number of routes for every depth
178          * that was configured with ratio
179          */
180         for (depth = 0; depth <= depth_lim; depth++) {
181                 if (rpd[depth] != 0) {
182                         if (rpd[depth] == UINT8_MAX)
183                                 config.nb_routes_per_depth[depth] =
184                                         nrpd[depth];
185                         else
186                                 config.nb_routes_per_depth[depth] =
187                                         (n * rpd[depth]) / 100;
188
189                         nr += config.nb_routes_per_depth[depth];
190                         m++;
191                 }
192         }
193
194         if (nr > n) {
195                 printf("Too much configured routes\n");
196                 return -1;
197         }
198
199         /*complete number of routes for every unspecified depths*/
200         for (depth = 0; depth <= depth_lim; depth++) {
201                 if (rpd[depth] == 0) {
202                         /*we don't need more than two /1 routes*/
203                         uint64_t max_routes_per_depth =
204                                 1ULL << RTE_MIN(depth, 63);
205                         uint32_t avg_routes_left = (n - nr) /
206                                 (depth_lim + 1 - m++);
207                         config.nb_routes_per_depth[depth] =
208                                 RTE_MIN(max_routes_per_depth, avg_routes_left);
209                         nr += config.nb_routes_per_depth[depth];
210                 }
211         }
212
213         return 0;
214 }
215
216 static int
217 parse_distrib(uint8_t depth_lim, const uint32_t n)
218 {
219         uint8_t rpd[128 + 1] = {0}; /*routes ratios per depth including /0 */
220         uint32_t nrpd[128 + 1] = {0}; /* number of routes per depth */
221         uint32_t n_routes;
222         uint8_t depth, ratio, ratio_acc = 0;
223         char *in;
224
225         in = strtok(distrib_string, ",");
226
227         /*parse configures routes percentage ratios*/
228         while (in != NULL) {
229                 GET_CB_FIELD(in, depth, 0, UINT8_MAX, ':');
230                 if (in[strlen(in) - 1] == '%') {
231                         in[strlen(in) - 1] = 0;
232                         GET_CB_FIELD(in, ratio, 0, UINT8_MAX, '\0');
233                         if (depth > depth_lim) {
234                                 printf("Depth /%d is bigger than maximum "
235                                         "allowed depth /%d for this AF\n",
236                                         depth, depth_lim);
237                                 return -EINVAL;
238                         }
239                         if (ratio > 100) {
240                                 printf("Ratio for depth /%d is bigger "
241                                         "than 100%%\n", depth);
242                                 return -EINVAL;
243                         }
244                         if ((depth < 64) && ((n * ratio) / 100) >
245                                         (1ULL << depth)) {
246                                 printf("Configured ratio %d%% for depth /%d "
247                                         "has %d different routes, but maximum "
248                                         "is %lu\n", ratio, depth,
249                                         ((n * ratio) / 100), (1UL << depth));
250                                 return -EINVAL;
251                         }
252                         rpd[depth] = ratio;
253                         /*configured zero routes for a given depth*/
254                         if (ratio == 0)
255                                 rpd[depth] = UINT8_MAX;
256                         /*sum of all percentage ratios*/
257                         ratio_acc += ratio;
258                 } else {
259                         GET_CB_FIELD(in, n_routes, 0, UINT32_MAX, '\0');
260                         rpd[depth] = UINT8_MAX;
261                         nrpd[depth] = n_routes;
262                 }
263
264                 /*number of configured depths in*/
265                 in = strtok(NULL, ",");
266         }
267
268         if (ratio_acc > 100) {
269                 printf("Total ratio's sum is bigger than 100%%\n");
270                 return -EINVAL;
271         }
272
273         return complete_distrib(depth_lim, n, rpd, nrpd);
274 }
275
276 static void
277 shuffle_rt_4(struct rt_rule_4 *rt, int n)
278 {
279         struct rt_rule_4 tmp;
280         int i, j;
281
282         for (i = 0; i < n; i++) {
283                 j = rte_rand() % n;
284                 tmp.addr = rt[i].addr;
285                 tmp.depth = rt[i].depth;
286                 tmp.nh = rt[i].nh;
287
288                 rt[i].addr = rt[j].addr;
289                 rt[i].depth = rt[j].depth;
290                 rt[i].nh = rt[j].nh;
291
292                 rt[j].addr = tmp.addr;
293                 rt[j].depth = tmp.depth;
294                 rt[j].nh = tmp.nh;
295         }
296 }
297
298 static void
299 shuffle_rt_6(struct rt_rule_6 *rt, int n)
300 {
301         struct rt_rule_6 tmp;
302         int i, j;
303
304         for (i = 0; i < n; i++) {
305                 j = rte_rand() % n;
306                 memcpy(tmp.addr, rt[i].addr, 16);
307                 tmp.depth = rt[i].depth;
308                 tmp.nh = rt[i].nh;
309
310                 memcpy(rt[i].addr, rt[j].addr, 16);
311                 rt[i].depth = rt[j].depth;
312                 rt[i].nh = rt[j].nh;
313
314                 memcpy(rt[j].addr, tmp.addr, 16);
315                 rt[j].depth = tmp.depth;
316                 rt[j].nh = tmp.nh;
317         }
318 }
319
320 static void
321 gen_random_rt_4(struct rt_rule_4 *rt, int nh_sz)
322 {
323         uint32_t i, j, k = 0;
324
325         if (config.nb_routes_per_depth[0] != 0) {
326                 rt[k].addr = 0;
327                 rt[k].depth = 0;
328                 rt[k++].nh = rte_rand() & get_max_nh(nh_sz);
329         }
330
331         for (i = 1; i <= 32; i++) {
332                 double edge = 0;
333                 double step;
334                 step = (double)(1ULL << i) / config.nb_routes_per_depth[i];
335                 for (j = 0; j < config.nb_routes_per_depth[i];
336                                 j++, k++, edge += step) {
337                         uint64_t rnd_val = get_rnd_rng((uint64_t)edge,
338                                 (uint64_t)(edge + step));
339                         rt[k].addr = rnd_val << (32 - i);
340                         rt[k].depth = i;
341                         rt[k].nh = rte_rand() & get_max_nh(nh_sz);
342                 }
343         }
344 }
345
346 static void
347 complete_v6_addr(uint32_t *addr, uint32_t rnd, int n)
348 {
349         int i;
350
351         for (i = 0; i < n; i++)
352                 addr[i] = rte_rand();
353         addr[i++] = rnd;
354         for (; i < 4; i++)
355                 addr[i] = 0;
356 }
357
358 static void
359 gen_random_rt_6(struct rt_rule_6 *rt, int nh_sz)
360 {
361         uint32_t a, i, j, k = 0;
362
363         if (config.nb_routes_per_depth[0] != 0) {
364                 memset(rt[k].addr, 0, 16);
365                 rt[k].depth = 0;
366                 rt[k++].nh = rte_rand() & get_max_nh(nh_sz);
367         }
368
369         for (a = 0; a < 4; a++) {
370                 for (i = 1; i <= 32; i++) {
371                         uint32_t rnd;
372                         double edge = 0;
373                         double step = (double)(1ULL << i) /
374                                 config.nb_routes_per_depth[(a * 32) + i];
375                         for (j = 0; j < config.nb_routes_per_depth[a * 32 + i];
376                                         j++, k++, edge += step) {
377                                 uint64_t rnd_val = get_rnd_rng((uint64_t)edge,
378                                         (uint64_t)(edge + step));
379                                 rnd = rte_cpu_to_be_32(rnd_val << (32 - i));
380                                 complete_v6_addr((uint32_t *)rt[k].addr,
381                                         rnd, a);
382                                 rt[k].depth = (a * 32) + i;
383                                 rt[k].nh = rte_rand() & get_max_nh(nh_sz);
384                         }
385                 }
386         }
387 }
388
389 static inline void
390 set_rnd_ipv6(uint8_t *addr, uint8_t *route, int depth)
391 {
392         int i;
393
394         for (i = 0; i < 16; i++)
395                 addr[i] = rte_rand();
396
397         for (i = 0; i < 16; i++) {
398                 if (depth >= 8)
399                         addr[i] = route[i];
400                 else if (depth > 0) {
401                         addr[i] &= (uint16_t)UINT8_MAX >> depth;
402                         addr[i] |= route[i] & UINT8_MAX << (8 - depth);
403                 } else
404                         return;
405                 depth -= 8;
406         }
407 }
408
409 static void
410 gen_rnd_lookup_tbl(int af)
411 {
412         uint32_t *tbl4 = config.lookup_tbl;
413         uint8_t *tbl6 = config.lookup_tbl;
414         struct rt_rule_4 *rt4 = (struct rt_rule_4 *)config.rt;
415         struct rt_rule_6 *rt6 = (struct rt_rule_6 *)config.rt;
416         uint32_t i, j;
417
418         if (af == AF_INET) {
419                 for (i = 0, j = 0; i < config.nb_lookup_ips;
420                                 i++, j = (j + 1) % config.nb_routes) {
421                         if ((rte_rand() % 100) < config.rnd_lookup_ips_ratio) {
422                                 tbl4[i] = rte_rand();
423                                 config.nb_lookup_ips_rnd++;
424                         } else
425                                 tbl4[i] = rt4[j].addr | (rte_rand() &
426                                         ((1ULL << (32 - rt4[j].depth)) - 1));
427                 }
428         } else {
429                 for (i = 0, j = 0; i < config.nb_lookup_ips;
430                                 i++, j = (j + 1) % config.nb_routes) {
431                         if ((rte_rand() % 100) < config.rnd_lookup_ips_ratio) {
432                                 set_rnd_ipv6(&tbl6[i * 16], rt6[j].addr, 0);
433                                 config.nb_lookup_ips_rnd++;
434                         } else {
435                                 set_rnd_ipv6(&tbl6[i * 16], rt6[j].addr,
436                                         rt6[j].depth);
437                         }
438                 }
439         }
440 }
441
442 static int
443 _inet_net_pton(int af, char *prefix, void *addr)
444 {
445         const char *dlm = "/";
446         char *s, *sp;
447         int ret, depth;
448         unsigned int max_depth;
449
450         if ((prefix == NULL) || (addr == NULL))
451                 return -EINVAL;
452
453         s = strtok_r(prefix, dlm, &sp);
454         if (s == NULL)
455                 return -EINVAL;
456
457         ret = inet_pton(af, s, addr);
458         if (ret != 1)
459                 return -errno;
460
461         s = strtok_r(NULL, dlm, &sp);
462         max_depth = (af == AF_INET) ? 32 : 128;
463         GET_CB_FIELD(s, depth, 0, max_depth, 0);
464
465         return depth;
466 }
467
468 static int
469 parse_rt_4(FILE *f)
470 {
471         int ret, i, j = 0;
472         char *s, *sp, *in[RT_NUM];
473         static const char *dlm = " \t\n";
474         int string_tok_nb = RTE_DIM(in);
475         struct rt_rule_4 *rt;
476
477         rt = (struct rt_rule_4 *)config.rt;
478
479         while (fgets(line, sizeof(line), f) != NULL) {
480                 s = line;
481                 for (i = 0; i != string_tok_nb; i++) {
482                         in[i] = strtok_r(s, dlm, &sp);
483                         if (in[i] == NULL)
484                                 return -EINVAL;
485                         s = NULL;
486                 }
487
488                 ret = _inet_net_pton(AF_INET, in[RT_PREFIX], &rt[j].addr);
489                 if (ret == -1)
490                         return -errno;
491
492                 rt[j].addr = rte_be_to_cpu_32(rt[j].addr);
493                 rt[j].depth = ret;
494                 config.nb_routes_per_depth[ret]++;
495                 GET_CB_FIELD(in[RT_NEXTHOP], rt[j].nh, 0,
496                                 UINT32_MAX, 0);
497                 j++;
498         }
499         return 0;
500 }
501
502 static int
503 parse_rt_6(FILE *f)
504 {
505         int ret, i, j = 0;
506         char *s, *sp, *in[RT_NUM];
507         static const char *dlm = " \t\n";
508         int string_tok_nb = RTE_DIM(in);
509         struct rt_rule_6 *rt;
510
511         rt = (struct rt_rule_6 *)config.rt;
512
513         while (fgets(line, sizeof(line), f) != NULL) {
514                 s = line;
515                 for (i = 0; i != string_tok_nb; i++) {
516                         in[i] = strtok_r(s, dlm, &sp);
517                         if (in[i] == NULL)
518                                 return -EINVAL;
519                         s = NULL;
520                 }
521
522                 ret = _inet_net_pton(AF_INET6, in[RT_PREFIX], rt[j].addr);
523                 if (ret < 0)
524                         return ret;
525
526                 rt[j].depth = ret;
527                 config.nb_routes_per_depth[ret]++;
528                 GET_CB_FIELD(in[RT_NEXTHOP], rt[j].nh, 0,
529                                 UINT32_MAX, 0);
530                 j++;
531         }
532
533         return 0;
534 }
535
536 static int
537 parse_lookup(FILE *f, int af)
538 {
539         int ret, i = 0;
540         uint8_t *tbl = (uint8_t *)config.lookup_tbl;
541         int step = (af == AF_INET) ? 4 : 16;
542         char *s;
543
544         while (fgets(line, sizeof(line), f) != NULL) {
545                 s = strtok(line, " \t\n");
546                 ret = inet_pton(af, s, &tbl[i]);
547                 if (ret != 1)
548                         return -EINVAL;
549                 i += step;
550         }
551         return 0;
552 }
553
554 static int
555 dump_lookup(int af)
556 {
557         FILE *f;
558         uint32_t *tbl4 = config.lookup_tbl;
559         uint8_t *tbl6 = config.lookup_tbl;
560         uint32_t i;
561
562         f = fopen(config.lookup_ips_file_s, "w");
563         if (f == NULL) {
564                 printf("Can not open file %s\n", config.lookup_ips_file_s);
565                 return -1;
566         }
567
568         if (af == AF_INET) {
569                 for (i = 0; i < config.nb_lookup_ips; i++)
570                         fprintf(f, NIPQUAD_FMT"\n", NIPQUAD(tbl4[i]));
571         } else {
572                 for (i = 0; i < config.nb_lookup_ips; i++)
573                         fprintf(f, NIPQUAD6_FMT"\n", NIPQUAD6(&tbl6[i * 16]));
574         }
575         fclose(f);
576         return 0;
577 }
578
579 static void
580 print_config(void)
581 {
582         uint8_t depth_lim;
583         char dlm;
584         int i;
585
586         depth_lim = ((config.flags & IPV6_FLAG) == IPV6_FLAG) ? 128 : 32;
587
588         fprintf(stdout,
589                 "Routes total: %u\n"
590                 "Routes distribution:\n", config.nb_routes);
591
592         for (i = 1; i <= depth_lim; i++) {
593                 fprintf(stdout,
594                         "depth /%d:%u", i, config.nb_routes_per_depth[i]);
595                 if (i % 4 == 0)
596                         dlm = '\n';
597                 else
598                         dlm = '\t';
599                 fprintf(stdout, "%c", dlm);
600         }
601
602         fprintf(stdout,
603                 "Lookup tuples: %u\n"
604                 "Configured ratios of random ips for lookup: %u\n"
605                 "Random lookup ips: %u\n",
606                 config.nb_lookup_ips, config.rnd_lookup_ips_ratio,
607                 config.nb_lookup_ips_rnd);
608 }
609
610 static void
611 print_usage(void)
612 {
613         fprintf(stdout,
614                 PRINT_USAGE_START
615                 "[-f <routes file>]\n"
616                 "[-t <ip's file for lookup>]\n"
617                 "[-n <number of routes (if -f is not specified)>]\n"
618                 "[-l <number of ip's for lookup (if -t is not specified)>]\n"
619                 "[-d <\",\" separated \"depth:n%%\"routes depth distribution"
620                 "(if -f is not specified)>]\n"
621                 "[-r <percentage ratio of random ip's to lookup"
622                 "(if -t is not specified)>]\n"
623                 "[-c <do comarison with LPM library>]\n"
624                 "[-6 <do tests with ipv6 (default ipv4)>]\n"
625                 "[-s <shuffle randomly generated routes>]\n"
626                 "[-a <check nexthops for all ipv4 address space"
627                 "(only valid with -c)>]\n"
628                 "[-b <fib algorithm>]\n\tavailible options for ipv4\n"
629                 "\t\trib - RIB based FIB\n"
630                 "\t\tdir - DIR24_8 based FIB\n"
631                 "\tavailible options for ipv6:\n"
632                 "\t\trib - RIB based FIB\n"
633                 "\t\ttrie - TRIE based FIB\n"
634                 "defaults are: dir for ipv4 and trie for ipv6\n"
635                 "[-e <entry size (valid only for dir and trie fib types): "
636                 "1/2/4/8 (default 4)>]\n"
637                 "[-g <number of tbl8's for dir24_8 or trie FIBs>]\n"
638                 "[-w <path to the file to dump routing table>]\n"
639                 "[-u <path to the file to dump ip's for lookup>]\n",
640                 config.prgname);
641 }
642
643 static int
644 check_config(void)
645 {
646         if ((config.routes_file == NULL) && (config.lookup_ips_file != NULL)) {
647                 printf("-t option only valid with -f option\n");
648                 return -1;
649         }
650
651         if ((config.flags & CMP_ALL_FLAG) && (config.flags & IPV6_FLAG)) {
652                 printf("-a flag is only valid for ipv4\n");
653                 return -1;
654         }
655
656         if ((config.flags & CMP_ALL_FLAG) &&
657                         ((config.flags & CMP_FLAG) != CMP_FLAG)) {
658                 printf("-a flag is valid only with -c flag\n");
659                 return -1;
660         }
661
662         if (!((config.ent_sz == 1) || (config.ent_sz == 2) ||
663                         (config.ent_sz == 4) || (config.ent_sz == 8))) {
664                 printf("wrong -e option %d, can be 1 or 2 or 4 or 8\n",
665                         config.ent_sz);
666                 return -1;
667         }
668
669         if ((config.ent_sz == 1) && (config.flags & IPV6_FLAG)) {
670                 printf("-e 1 is valid only for ipv4\n");
671                 return -1;
672         }
673         return 0;
674 }
675
676 static void
677 parse_opts(int argc, char **argv)
678 {
679         int opt;
680         char *endptr;
681
682         while ((opt = getopt(argc, argv, "f:t:n:d:l:r:c6ab:e:g:w:u:s")) !=
683                         -1) {
684                 switch (opt) {
685                 case 'f':
686                         config.routes_file = optarg;
687                         break;
688                 case 't':
689                         config.lookup_ips_file = optarg;
690                         break;
691                 case 'w':
692                         config.routes_file_s = optarg;
693                         config.flags |= DRY_RUN_FLAG;
694                         break;
695                 case 'u':
696                         config.lookup_ips_file_s = optarg;
697                         config.flags |= DRY_RUN_FLAG;
698                         break;
699                 case 'n':
700                         errno = 0;
701                         config.nb_routes = strtoul(optarg, &endptr, 10);
702                         if ((errno != 0) || (config.nb_routes == 0)) {
703                                 print_usage();
704                                 rte_exit(-EINVAL, "Invalid option -n\n");
705                         }
706                         break;
707                 case 'd':
708                         distrib_string = optarg;
709                         break;
710                 case 'l':
711                         errno = 0;
712                         config.nb_lookup_ips = strtoul(optarg, &endptr, 10);
713                         if ((errno != 0) || (config.nb_lookup_ips == 0)) {
714                                 print_usage();
715                                 rte_exit(-EINVAL, "Invalid option -l\n");
716                         }
717                         break;
718                 case 'r':
719                         errno = 0;
720                         config.rnd_lookup_ips_ratio =
721                                 strtoul(optarg, &endptr, 10);
722                         if ((errno != 0) ||
723                                         (config.rnd_lookup_ips_ratio == 0) ||
724                                         (config.rnd_lookup_ips_ratio >= 100)) {
725                                 print_usage();
726                                 rte_exit(-EINVAL, "Invalid option -r\n");
727                         }
728                         break;
729                 case 's':
730                         config.flags |= SHUFFLE_FLAG;
731                         break;
732                 case 'c':
733                         config.flags |= CMP_FLAG;
734                         break;
735                 case '6':
736                         config.flags |= IPV6_FLAG;
737                         break;
738                 case 'a':
739                         config.flags |= CMP_ALL_FLAG;
740                         break;
741                 case 'b':
742                         if (strcmp(optarg, "rib") == 0) {
743                                 config.flags &= ~FIB_TYPE_MASK;
744                                 config.flags |= FIB_RIB_TYPE;
745                         } else if (strcmp(optarg, "dir") == 0) {
746                                 config.flags &= ~FIB_TYPE_MASK;
747                                 config.flags |= FIB_V4_DIR_TYPE;
748                         } else if (strcmp(optarg, "trie") == 0) {
749                                 config.flags &= ~FIB_TYPE_MASK;
750                                 config.flags |= FIB_V6_TRIE_TYPE;
751                         } else
752                                 rte_exit(-EINVAL, "Invalid option -b\n");
753                         break;
754                 case 'e':
755                         errno = 0;
756                         config.ent_sz = strtoul(optarg, &endptr, 10);
757                         if (errno != 0) {
758                                 print_usage();
759                                 rte_exit(-EINVAL, "Invalid option -e\n");
760                         }
761                         break;
762                 case 'g':
763                         errno = 0;
764                         config.tbl8 = strtoul(optarg, &endptr, 10);
765                         if ((errno != 0) || (config.tbl8 == 0)) {
766                                 print_usage();
767                                 rte_exit(-EINVAL, "Invalid option -g\n");
768                         }
769                         break;
770                 default:
771                         print_usage();
772                         rte_exit(-EINVAL, "Invalid options\n");
773                 }
774         }
775 }
776
777 static int
778 dump_rt_4(struct rt_rule_4 *rt)
779 {
780         FILE *f;
781         uint32_t i;
782
783         f = fopen(config.routes_file_s, "w");
784         if (f == NULL) {
785                 printf("Can not open file %s\n", config.routes_file_s);
786                 return -1;
787         }
788
789         for (i = 0; i < config.nb_routes; i++)
790                 fprintf(f, NIPQUAD_FMT"/%d %"PRIu64"\n", NIPQUAD(rt[i].addr),
791                         rt[i].depth, rt[i].nh);
792
793         fclose(f);
794         return 0;
795 }
796
797 static inline void
798 print_depth_err(void)
799 {
800         printf("LPM does not support /0 prefix length (default route), use "
801                 "-d 0:0 option or remove /0 prefix from routes file\n");
802 }
803
804 static int
805 run_v4(void)
806 {
807         uint64_t start, acc;
808         uint64_t def_nh = 0;
809         struct rte_fib *fib;
810         struct rte_fib_conf conf = {0};
811         struct rt_rule_4 *rt;
812         uint32_t i, j, k;
813         int ret = 0;
814         struct rte_lpm  *lpm = NULL;
815         struct rte_lpm_config lpm_conf;
816         uint32_t *tbl4 = config.lookup_tbl;
817         uint64_t fib_nh[BURST_SZ];
818         uint32_t lpm_nh[BURST_SZ];
819
820         rt = (struct rt_rule_4 *)config.rt;
821
822         if (config.flags & DRY_RUN_FLAG) {
823                 if (config.routes_file_s != NULL)
824                         ret = dump_rt_4(rt);
825                 if (ret != 0)
826                         return ret;
827                 if (config.lookup_ips_file_s != NULL)
828                         ret = dump_lookup(AF_INET);
829                 return ret;
830         }
831
832         conf.type = get_fib_type();
833         conf.default_nh = def_nh;
834         conf.max_routes = config.nb_routes * 2;
835         if (conf.type == RTE_FIB_DIR24_8) {
836                 conf.dir24_8.nh_sz = __builtin_ctz(config.ent_sz);
837                 conf.dir24_8.num_tbl8 = RTE_MIN(config.tbl8,
838                         get_max_nh(conf.dir24_8.nh_sz));
839         }
840
841         fib = rte_fib_create("test", -1, &conf);
842         if (fib == NULL) {
843                 printf("Can not alloc FIB, err %d\n", rte_errno);
844                 return -rte_errno;
845         }
846
847         for (k = config.print_fract, i = 0; k > 0; k--) {
848                 start = rte_rdtsc_precise();
849                 for (j = 0; j < (config.nb_routes - i) / k; j++) {
850                         ret = rte_fib_add(fib, rt[i + j].addr, rt[i + j].depth,
851                                 rt[i + j].nh);
852                         if (unlikely(ret != 0)) {
853                                 printf("Can not add a route to FIB, err %d\n",
854                                         ret);
855                                 return -ret;
856                         }
857                 }
858                 printf("AVG FIB add %"PRIu64"\n",
859                         (rte_rdtsc_precise() - start) / j);
860                 i += j;
861         }
862
863         if (config.flags & CMP_FLAG) {
864                 lpm_conf.max_rules = config.nb_routes * 2;
865                 lpm_conf.number_tbl8s = RTE_MAX(conf.dir24_8.num_tbl8,
866                         config.tbl8);
867
868                 lpm = rte_lpm_create("test_lpm", -1, &lpm_conf);
869                 if (lpm == NULL) {
870                         printf("Can not alloc LPM, err %d\n", rte_errno);
871                         return -rte_errno;
872                 }
873                 for (k = config.print_fract, i = 0; k > 0; k--) {
874                         start = rte_rdtsc_precise();
875                         for (j = 0; j < (config.nb_routes - i) / k; j++) {
876                                 ret = rte_lpm_add(lpm, rt[i + j].addr,
877                                         rt[i + j].depth, rt[i + j].nh);
878                                 if (ret != 0) {
879                                         if (rt[i + j].depth == 0)
880                                                 print_depth_err();
881                                         printf("Can not add a route to LPM, "
882                                                 "err %d\n", ret);
883                                         return -ret;
884                                 }
885                         }
886                         printf("AVG LPM add %"PRIu64"\n",
887                                 (rte_rdtsc_precise() - start) / j);
888                         i += j;
889                 }
890         }
891
892         acc = 0;
893         for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) {
894                 start = rte_rdtsc_precise();
895                 ret = rte_fib_lookup_bulk(fib, tbl4 + i, fib_nh, BURST_SZ);
896                 acc += rte_rdtsc_precise() - start;
897                 if (ret != 0) {
898                         printf("FIB lookup fails, err %d\n", ret);
899                         return -ret;
900                 }
901         }
902         printf("AVG FIB lookup %.1f\n", (double)acc / (double)i);
903
904         if (config.flags & CMP_FLAG) {
905                 acc = 0;
906                 for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) {
907                         start = rte_rdtsc_precise();
908                         ret = rte_lpm_lookup_bulk(lpm, tbl4 + i, lpm_nh,
909                                 BURST_SZ);
910                         acc += rte_rdtsc_precise() - start;
911                         if (ret != 0) {
912                                 printf("LPM lookup fails, err %d\n", ret);
913                                 return -ret;
914                         }
915                 }
916                 printf("AVG LPM lookup %.1f\n", (double)acc / (double)i);
917
918                 for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) {
919                         rte_fib_lookup_bulk(fib, tbl4 + i, fib_nh, BURST_SZ);
920                         rte_lpm_lookup_bulk(lpm, tbl4 + i, lpm_nh, BURST_SZ);
921                         for (j = 0; j < BURST_SZ; j++) {
922                                 struct rte_lpm_tbl_entry *tbl;
923                                 tbl = (struct rte_lpm_tbl_entry *)&lpm_nh[j];
924                                 if ((fib_nh[j] != tbl->next_hop) &&
925                                                 !((tbl->valid == 0) &&
926                                                 (fib_nh[j] == def_nh))) {
927                                         printf("FAIL\n");
928                                         return -1;
929                                 }
930                         }
931                 }
932                 printf("FIB and LPM lookup returns same values\n");
933         }
934
935         for (k = config.print_fract, i = 0; k > 0; k--) {
936                 start = rte_rdtsc_precise();
937                 for (j = 0; j < (config.nb_routes - i) / k; j++)
938                         rte_fib_delete(fib, rt[i + j].addr, rt[i + j].depth);
939
940                 printf("AVG FIB delete %"PRIu64"\n",
941                         (rte_rdtsc_precise() - start) / j);
942                 i += j;
943         }
944
945         if (config.flags & CMP_FLAG) {
946                 for (k = config.print_fract, i = 0; k > 0; k--) {
947                         start = rte_rdtsc_precise();
948                         for (j = 0; j < (config.nb_routes - i) / k; j++)
949                                 rte_lpm_delete(lpm, rt[i + j].addr,
950                                         rt[i + j].depth);
951
952                         printf("AVG LPM delete %"PRIu64"\n",
953                                 (rte_rdtsc_precise() - start) / j);
954                         i += j;
955                 }
956         }
957
958         return 0;
959 }
960
961 static int
962 dump_rt_6(struct rt_rule_6 *rt)
963 {
964         FILE *f;
965         uint32_t i;
966
967         f = fopen(config.routes_file_s, "w");
968         if (f == NULL) {
969                 printf("Can not open file %s\n", config.routes_file_s);
970                 return -1;
971         }
972
973         for (i = 0; i < config.nb_routes; i++) {
974                 fprintf(f, NIPQUAD6_FMT"/%d %"PRIu64"\n", NIPQUAD6(rt[i].addr),
975                         rt[i].depth, rt[i].nh);
976
977         }
978         fclose(f);
979         return 0;
980 }
981
982 static int
983 run_v6(void)
984 {
985         uint64_t start, acc;
986         uint64_t def_nh = 0;
987         struct rte_fib6 *fib;
988         struct rte_fib6_conf conf = {0};
989         struct rt_rule_6 *rt;
990         uint32_t i, j, k;
991         int ret = 0;
992         struct rte_lpm6 *lpm = NULL;
993         struct rte_lpm6_config lpm_conf;
994         uint8_t *tbl6;
995         uint64_t fib_nh[BURST_SZ];
996         int32_t lpm_nh[BURST_SZ];
997
998         rt = (struct rt_rule_6 *)config.rt;
999         tbl6 = config.lookup_tbl;
1000
1001         if (config.flags & DRY_RUN_FLAG) {
1002                 if (config.routes_file_s != NULL)
1003                         ret =  dump_rt_6(rt);
1004                 if (ret != 0)
1005                         return ret;
1006                 if (config.lookup_ips_file_s != NULL)
1007                         ret = dump_lookup(AF_INET6);
1008                 return ret;
1009         }
1010
1011         conf.type = get_fib_type();
1012         conf.default_nh = def_nh;
1013         conf.max_routes = config.nb_routes * 2;
1014         if (conf.type == RTE_FIB6_TRIE) {
1015                 conf.trie.nh_sz = __builtin_ctz(config.ent_sz);
1016                 conf.trie.num_tbl8 = RTE_MIN(config.tbl8,
1017                         get_max_nh(conf.trie.nh_sz));
1018         }
1019
1020         fib = rte_fib6_create("test", -1, &conf);
1021         if (fib == NULL) {
1022                 printf("Can not alloc FIB, err %d\n", rte_errno);
1023                 return -rte_errno;
1024         }
1025
1026         for (k = config.print_fract, i = 0; k > 0; k--) {
1027                 start = rte_rdtsc_precise();
1028                 for (j = 0; j < (config.nb_routes - i) / k; j++) {
1029                         ret = rte_fib6_add(fib, rt[i + j].addr,
1030                                 rt[i + j].depth, rt[i + j].nh);
1031                         if (unlikely(ret != 0)) {
1032                                 printf("Can not add a route to FIB, err %d\n",
1033                                         ret);
1034                                 return -ret;
1035                         }
1036                 }
1037                 printf("AVG FIB add %"PRIu64"\n",
1038                         (rte_rdtsc_precise() - start) / j);
1039                 i += j;
1040         }
1041
1042         if (config.flags & CMP_FLAG) {
1043                 lpm_conf.max_rules = config.nb_routes * 2;
1044                 lpm_conf.number_tbl8s = RTE_MAX(conf.trie.num_tbl8,
1045                         config.tbl8);
1046
1047                 lpm = rte_lpm6_create("test_lpm", -1, &lpm_conf);
1048                 if (lpm == NULL) {
1049                         printf("Can not alloc LPM, err %d\n", rte_errno);
1050                         return -rte_errno;
1051                 }
1052                 for (k = config.print_fract, i = 0; k > 0; k--) {
1053                         start = rte_rdtsc_precise();
1054                         for (j = 0; j < (config.nb_routes - i) / k; j++) {
1055                                 ret = rte_lpm6_add(lpm, rt[i + j].addr,
1056                                         rt[i + j].depth, rt[i + j].nh);
1057                                 if (ret != 0) {
1058                                         if (rt[i + j].depth == 0)
1059                                                 print_depth_err();
1060                                         printf("Can not add a route to LPM, "
1061                                                 "err %d\n", ret);
1062                                         return -ret;
1063                                 }
1064                         }
1065                         printf("AVG LPM add %"PRIu64"\n",
1066                                 (rte_rdtsc_precise() - start) / j);
1067                         i += j;
1068                 }
1069         }
1070
1071         acc = 0;
1072         for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) {
1073                 start = rte_rdtsc_precise();
1074                 ret = rte_fib6_lookup_bulk(fib, (uint8_t (*)[16])(tbl6 + i*16),
1075                         fib_nh, BURST_SZ);
1076                 acc += rte_rdtsc_precise() - start;
1077                 if (ret != 0) {
1078                         printf("FIB lookup fails, err %d\n", ret);
1079                         return -ret;
1080                 }
1081         }
1082         printf("AVG FIB lookup %.1f\n", (double)acc / (double)i);
1083
1084         if (config.flags & CMP_FLAG) {
1085                 acc = 0;
1086                 for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) {
1087                         start = rte_rdtsc_precise();
1088                         ret = rte_lpm6_lookup_bulk_func(lpm,
1089                                 (uint8_t (*)[16])(tbl6 + i*16),
1090                                 lpm_nh, BURST_SZ);
1091                         acc += rte_rdtsc_precise() - start;
1092                         if (ret != 0) {
1093                                 printf("LPM lookup fails, err %d\n", ret);
1094                                 return -ret;
1095                         }
1096                 }
1097                 printf("AVG LPM lookup %.1f\n", (double)acc / (double)i);
1098
1099                 for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) {
1100                         rte_fib6_lookup_bulk(fib,
1101                                 (uint8_t (*)[16])(tbl6 + i*16),
1102                                 fib_nh, BURST_SZ);
1103                         rte_lpm6_lookup_bulk_func(lpm,
1104                                 (uint8_t (*)[16])(tbl6 + i*16),
1105                                 lpm_nh, BURST_SZ);
1106                         for (j = 0; j < BURST_SZ; j++) {
1107                                 if ((fib_nh[j] != (uint32_t)lpm_nh[j]) &&
1108                                                 !((lpm_nh[j] == -1) &&
1109                                                 (fib_nh[j] == def_nh))) {
1110                                         printf("FAIL\n");
1111                                         return -1;
1112                                 }
1113                         }
1114                 }
1115                 printf("FIB and LPM lookup returns same values\n");
1116         }
1117
1118         for (k = config.print_fract, i = 0; k > 0; k--) {
1119                 start = rte_rdtsc_precise();
1120                 for (j = 0; j < (config.nb_routes - i) / k; j++)
1121                         rte_fib6_delete(fib, rt[i + j].addr, rt[i + j].depth);
1122
1123                 printf("AVG FIB delete %"PRIu64"\n",
1124                         (rte_rdtsc_precise() - start) / j);
1125                 i += j;
1126         }
1127
1128         if (config.flags & CMP_FLAG) {
1129                 for (k = config.print_fract, i = 0; k > 0; k--) {
1130                         start = rte_rdtsc_precise();
1131                         for (j = 0; j < (config.nb_routes - i) / k; j++)
1132                                 rte_lpm6_delete(lpm, rt[i + j].addr,
1133                                         rt[i + j].depth);
1134
1135                         printf("AVG LPM delete %"PRIu64"\n",
1136                                 (rte_rdtsc_precise() - start) / j);
1137                         i += j;
1138                 }
1139         }
1140         return 0;
1141 }
1142
1143 int
1144 main(int argc, char **argv)
1145 {
1146         int ret, af, rt_ent_sz, lookup_ent_sz;
1147         FILE *fr = NULL;
1148         FILE *fl = NULL;
1149         uint8_t depth_lim;
1150
1151         ret = rte_eal_init(argc, argv);
1152         if (ret < 0)
1153                 rte_panic("Cannot init EAL\n");
1154
1155         argc -= ret;
1156         argv += ret;
1157
1158         config.prgname = argv[0];
1159
1160         parse_opts(argc, argv);
1161
1162         ret = check_config();
1163         if (ret != 0)
1164                 rte_exit(-ret, "Bad configuration\n");
1165
1166         af = ((config.flags & IPV6_FLAG) == 0) ? AF_INET : AF_INET6;
1167         depth_lim = (af == AF_INET) ? 32 : 128;
1168         rt_ent_sz = (af == AF_INET) ? sizeof(struct rt_rule_4) :
1169                 sizeof(struct rt_rule_6);
1170         lookup_ent_sz = (af == AF_INET) ? 4 : 16;
1171
1172         /* Count number of rules in file*/
1173         if (config.routes_file != NULL) {
1174                 fr = fopen(config.routes_file, "r");
1175                 if (fr == NULL)
1176                         rte_exit(-errno, "Can not open file with routes %s\n",
1177                                 config.routes_file);
1178
1179                 config.nb_routes = 0;
1180                 while (fgets(line, sizeof(line), fr) != NULL)
1181                         config.nb_routes++;
1182                 rewind(fr);
1183         }
1184
1185         /* Count number of ip's in file*/
1186         if (config.lookup_ips_file != NULL) {
1187                 fl = fopen(config.lookup_ips_file, "r");
1188                 if (fl == NULL)
1189                         rte_exit(-errno, "Can not open file with ip's %s\n",
1190                                 config.lookup_ips_file);
1191
1192                 config.nb_lookup_ips = 0;
1193                 while (fgets(line, sizeof(line), fl) != NULL)
1194                         config.nb_lookup_ips++;
1195                 rewind(fl);
1196         }
1197
1198         /* Alloc routes table*/
1199         config.rt  = rte_malloc(NULL, rt_ent_sz * config.nb_routes, 0);
1200         if (config.rt == NULL)
1201                 rte_exit(-ENOMEM, "Can not alloc rt\n");
1202
1203         /* Alloc table with ip's for lookup*/
1204         config.lookup_tbl  = rte_malloc(NULL, lookup_ent_sz *
1205                 config.nb_lookup_ips, 0);
1206         if (config.lookup_tbl == NULL)
1207                 rte_exit(-ENOMEM, "Can not alloc lookup table\n");
1208
1209         /* Fill routes table */
1210         if (fr == NULL) {
1211                 if (distrib_string != NULL)
1212                         ret = parse_distrib(depth_lim, config.nb_routes);
1213                 else {
1214                         uint8_t rpd[129] = {0};
1215                         uint32_t nrpd[129] = {0};
1216                         ret = complete_distrib(depth_lim, config.nb_routes,
1217                                 rpd, nrpd);
1218                 }
1219                 if (ret != 0)
1220                         rte_exit(-ret,
1221                                 "Bad routes distribution configuration\n");
1222                 if (af == AF_INET) {
1223                         gen_random_rt_4(config.rt,
1224                                 __builtin_ctz(config.ent_sz));
1225                         if (config.flags & SHUFFLE_FLAG)
1226                                 shuffle_rt_4(config.rt, config.nb_routes);
1227                 } else {
1228                         gen_random_rt_6(config.rt,
1229                                 __builtin_ctz(config.ent_sz));
1230                         if (config.flags & SHUFFLE_FLAG)
1231                                 shuffle_rt_6(config.rt, config.nb_routes);
1232                 }
1233         } else {
1234                 if (af == AF_INET)
1235                         ret = parse_rt_4(fr);
1236                 else
1237                         ret = parse_rt_6(fr);
1238
1239                 if (ret != 0) {
1240                         rte_exit(-ret, "failed to parse routes file %s\n",
1241                                 config.routes_file);
1242                 }
1243         }
1244
1245         /* Fill lookup table with ip's*/
1246         if (fl == NULL)
1247                 gen_rnd_lookup_tbl(af);
1248         else {
1249                 ret = parse_lookup(fl, af);
1250                 if (ret != 0)
1251                         rte_exit(-ret, "failed to parse lookup file\n");
1252         }
1253
1254         print_config();
1255
1256         if (af == AF_INET)
1257                 ret = run_v4();
1258         else
1259                 ret = run_v6();
1260
1261         return ret;
1262 }