app/test-fib/main.c

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