VNFs/DPPD-PROX/prox_args.c

   1 /*
   2 // Copyright (c) 2010-2017 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 */
  16
  17 #include <unistd.h>
  18 #include <string.h>
  19
  20 #include <rte_sched.h>
  21 #include <rte_string_fns.h>
  22 #include <rte_version.h>
  23
  24 #include "prox_malloc.h"
  25 #include "version.h"
  26 #include "defines.h"
  27 #include "prox_args.h"
  28 #include "prox_assert.h"
  29 #include "prox_cfg.h"
  30 #include "cfgfile.h"
  31 #include "quit.h"
  32 #include "log.h"
  33 #include "parse_utils.h"
  34 #include "prox_port_cfg.h"
  35 #include "defaults.h"
  36 #include "prox_lua.h"
  37 #include "cqm.h"
  38 #include "prox_compat.h"
  39
  40 #define MAX_RTE_ARGV 64
  41 #define MAX_ARG_LEN  64
  42
  43 struct cfg_depr {
  44         const char *opt;
  45         const char *info;
  46 };
  47
  48 /* Helper macro */
  49 #define STR_EQ(s1, s2)  (!strcmp((s1), (s2)))
  50
  51 /* configuration files support */
  52 static int get_rte_cfg(unsigned sindex, char *str, void *data);
  53 static int get_global_cfg(unsigned sindex, char *str, void *data);
  54 static int get_port_cfg(unsigned sindex, char *str, void *data);
  55 static int get_defaults_cfg(unsigned sindex, char *str, void *data);
  56 static int get_cache_set_cfg(unsigned sindex, char *str, void *data);
  57 static int get_var_cfg(unsigned sindex, char *str, void *data);
  58 static int get_lua_cfg(unsigned sindex, char *str, void *data);
  59 static int get_core_cfg(unsigned sindex, char *str, void *data);
  60
  61 static const char *cfg_file = DEFAULT_CONFIG_FILE;
  62 static struct rte_cfg    rte_cfg;
  63 struct prox_cache_set_cfg  prox_cache_set_cfg[PROX_MAX_CACHE_SET];
  64
  65 static char format_err_str[1024];
  66 static const char *err_str = "Unknown error";
  67
  68 static struct cfg_section eal_default_cfg = {
  69         .name   = "eal options",
  70         .parser = get_rte_cfg,
  71         .data   = &rte_cfg,
  72         .indexp[0]  = 0,
  73         .nbindex = 1,
  74         .error  = 0
  75 };
  76
  77 static struct cfg_section port_cfg = {
  78         .name   = "port #",
  79         .parser = get_port_cfg,
  80         .data   = &prox_port_cfg,
  81         .indexp[0]  = 0,
  82         .nbindex = 1,
  83         .error  = 0
  84 };
  85
  86 static struct cfg_section var_cfg = {
  87         .name   = "variables",
  88         .parser = get_var_cfg,
  89         .data   = 0,
  90         .indexp[0]  = 0,
  91         .nbindex = 1,
  92         .error  = 0
  93 };
  94
  95 static struct cfg_section cache_set_cfg = {
  96         .name   = "cache set #",
  97         .parser = get_cache_set_cfg,
  98         .data   = &prox_cache_set_cfg,
  99         .indexp[0]  = 0,
 100         .nbindex = 1,
 101         .error  = 0
 102 };
 103
 104 static struct cfg_section defaults_cfg = {
 105         .name   = "defaults",
 106         .parser = get_defaults_cfg,
 107         .data   = 0,
 108         .indexp[0]  = 0,
 109         .nbindex = 1,
 110         .error  = 0
 111 };
 112
 113 static struct cfg_section settings_cfg = {
 114         .name   = "global",
 115         .parser = get_global_cfg,
 116         .data   = &prox_cfg,
 117         .indexp[0]  = 0,
 118         .nbindex = 1,
 119         .error  = 0
 120 };
 121
 122 static struct cfg_section lua_cfg = {
 123         .name = "lua",
 124         .parser = get_lua_cfg,
 125         .raw_lines = 1,
 126         .indexp[0] = 0,
 127         .nbindex = 1,
 128         .error = 0,
 129 };
 130
 131 static struct cfg_section core_cfg = {
 132         .name   = "core #",
 133         .parser = get_core_cfg,
 134         .data   = lcore_cfg_init,
 135         .indexp[0]  = 0,
 136         .nbindex = 1,
 137         .error  = 0
 138 };
 139
 140 static void set_errf(const char *format, ...)
 141 {
 142         va_list ap;
 143         va_start(ap, format);
 144         vsnprintf(format_err_str, sizeof(format_err_str), format, ap);
 145         va_end(ap);
 146         err_str = format_err_str;
 147 }
 148
 149 /* [eal options] parser */
 150 static int get_rte_cfg(__attribute__((unused))unsigned sindex, char *str, void *data)
 151 {
 152         struct rte_cfg *pconfig = (struct rte_cfg *)data;
 153
 154         if (str == NULL || pconfig == NULL) {
 155                 return -1;
 156         }
 157
 158         char *pkey = get_cfg_key(str);
 159         if (pkey == NULL) {
 160                 set_errf("Missing key after option");
 161                 return -1;
 162         }
 163
 164         if (STR_EQ(str, "-m")) {
 165                 return parse_int(&pconfig->memory, pkey);
 166         }
 167         if (STR_EQ(str, "-n")) {
 168                 if (parse_int(&pconfig->force_nchannel, pkey)) {
 169                         return -1;
 170                 }
 171                 if (pconfig->force_nchannel == 0) {
 172                         set_errf("Invalid number of memory channels");
 173                         return -1;
 174                 }
 175                 return 0;
 176         }
 177         if (STR_EQ(str, "-r")) {
 178                 if (parse_int(&pconfig->force_nrank, pkey)) {
 179                         return -1;
 180                 }
 181                 if (pconfig->force_nrank == 0 || pconfig->force_nrank > 16) {
 182                         set_errf("Invalid number of memory ranks");
 183                         return -1;
 184                 }
 185                 return 0;
 186         }
 187         /* debug options */
 188         if (STR_EQ(str, "no-pci")) {
 189                 return parse_bool(&pconfig->no_pci, pkey);
 190         }
 191         if (STR_EQ(str, "no-hpet")) {
 192                 return parse_bool(&pconfig->no_hpet, pkey);
 193         }
 194         if (STR_EQ(str, "no-shconf")) {
 195                 return parse_bool(&pconfig->no_shconf, pkey);
 196         }
 197         if (STR_EQ(str, "no-huge")) {
 198                 return parse_bool(&pconfig->no_hugetlbfs, pkey);
 199         }
 200         if (STR_EQ(str, "no-output")) {
 201                 return parse_bool(&pconfig->no_output, pkey);
 202         }
 203
 204         if (STR_EQ(str, "huge-dir")) {
 205                 if (pconfig->hugedir) {
 206                         free(pconfig->hugedir);
 207                 }
 208                 pconfig->hugedir = strdup(pkey);
 209                 return 0;
 210         }
 211
 212         if (STR_EQ(str, "eal")) {
 213                 char eal[MAX_STR_LEN_PROC];
 214                 if (pconfig->eal) {
 215                         free(pconfig->eal);
 216                         pconfig->eal = NULL;
 217                 }
 218                 if (parse_str(eal, pkey, sizeof(eal)))
 219                         return -1;
 220                 pkey = eal;
 221                 strip_spaces(&pkey, 1);
 222                 if (*pkey)
 223                         pconfig->eal = strdup(pkey);
 224                 return 0;
 225         }
 226
 227         set_errf("Option '%s' is not known", str);
 228         return -1;
 229 }
 230
 231 struct cfg_depr global_cfg_depr[] = {
 232         {"virtualization", "This is now set automatically if needed"},
 233         {"qinq_tag", "This option is deprecated"},
 234         {"wait on quit", "This is now set automatically if needed"},
 235         {"version", ""}
 236 };
 237
 238 const char *get_cfg_dir(void)
 239 {
 240         static char dir[PATH_MAX];
 241         size_t end = strlen(cfg_file) - 1;
 242         while (end > 0 && cfg_file[end] != '/')
 243                 end--;
 244
 245         strncpy(dir, cfg_file, end);
 246         return dir;
 247 }
 248
 249 static int get_lua_cfg(__attribute__((unused)) unsigned sindex, __attribute__((unused)) char *str, __attribute__((unused)) void *data)
 250 {
 251         int status;
 252         char cwd[1024];
 253         if (NULL == getcwd(cwd, sizeof(cwd))) {
 254                 set_errf("Failed to get current directory while loading Lua file\n");
 255                 return -1;
 256         }
 257         status = chdir(get_cfg_dir());
 258         if (status) {
 259                 set_errf("Failed to change directory to '%s' while loading Lua file\n", get_cfg_dir());
 260                 return -1;
 261         }
 262
 263         struct lua_State *l = prox_lua();
 264
 265         char str_cpy[1024];
 266         strncpy(str_cpy, str, sizeof(str_cpy));
 267         uint32_t len = strlen(str_cpy);
 268         str_cpy[len++] = '\n';
 269         str_cpy[len++] = 0;
 270
 271         status = luaL_loadstring(l, str_cpy);
 272         if (status) {
 273                 set_errf("Lua error: '%s'\n", lua_tostring(l, -1));
 274                 status = chdir(cwd);
 275                 return -1;
 276         }
 277
 278         status = lua_pcall(l, 0, LUA_MULTRET, 0);
 279         if (status) {
 280                 set_errf("Lua error: '%s'\n", lua_tostring(l, -1));
 281                 status = chdir(cwd);
 282                 return -1;
 283         }
 284
 285         status = chdir(cwd);
 286         if (status) {
 287                 set_errf("Failed to restore current directory to '%s' while loading Lua file\n", cwd);
 288                 return -1;
 289         }
 290
 291         return 0;
 292 }
 293
 294 /* [global] parser */
 295 static int get_global_cfg(__attribute__((unused))unsigned sindex, char *str, void *data)
 296 {
 297         struct prox_cfg *pset = (struct prox_cfg *)data;
 298
 299         if (str == NULL || pset == NULL) {
 300                 return -1;
 301         }
 302
 303         char *pkey = get_cfg_key(str);
 304         if (pkey == NULL) {
 305                 set_errf("Missing key after option");
 306                 return -1;
 307         }
 308
 309         for (uint32_t i = 0; i < RTE_DIM(global_cfg_depr); ++i) {
 310                 if (STR_EQ(str, global_cfg_depr[i].opt)) {
 311                         set_errf("Option '%s' is deprecated%s%s",
 312                                  global_cfg_depr[i].opt, strlen(global_cfg_depr[i].info)? ": ": "", global_cfg_depr[i].info);
 313                         return -1;
 314                 }
 315         }
 316
 317         if (STR_EQ(str, "name")) {
 318                 return parse_str(pset->name, pkey, sizeof(pset->name));
 319         }
 320
 321         if (STR_EQ(str, "start time")) {
 322                 return parse_int(&pset->start_time, pkey);
 323         }
 324
 325         if (STR_EQ(str, "duration time")) {
 326                 return parse_int(&pset->duration_time, pkey);
 327         }
 328
 329         if (STR_EQ(str, "shuffle")) {
 330                 return parse_flag(&pset->flags, DSF_SHUFFLE, pkey);
 331         }
 332         if (STR_EQ(str, "disable cmt")) {
 333                 return parse_flag(&pset->flags, DSF_DISABLE_CMT, pkey);
 334         }
 335         if (STR_EQ(str, "mp rings")) {
 336                 return parse_flag(&pset->flags, DSF_MP_RINGS, pkey);
 337         }
 338         if (STR_EQ(str, "enable bypass")) {
 339                 return parse_flag(&pset->flags, DSF_ENABLE_BYPASS, pkey);
 340         }
 341
 342         if (STR_EQ(str, "cpe table map")) {
 343                 /* The config defined ports through 0, 1, 2 ... which
 344                    need to be associated with ports. This is done
 345                    through defining it using "cpe table map=" */
 346                 return parse_port_name_list((uint32_t*)pset->cpe_table_ports, NULL, PROX_MAX_PORTS, pkey);
 347         }
 348
 349         if (STR_EQ(str, "pre cmd")) {
 350                 return system(pkey);
 351         }
 352
 353         if (STR_EQ(str, "unique mempool per socket")) {
 354                 return parse_flag(&pset->flags, UNIQUE_MEMPOOL_PER_SOCKET, pkey);
 355         }
 356
 357         if (STR_EQ(str, "log buffer size")) {
 358                 if (parse_kmg(&pset->logbuf_size, pkey)) {
 359                         return -1;
 360                 }
 361                 plog_info("Logging to buffer with size = %d\n", pset->logbuf_size);
 362                 return 0;
 363         }
 364
 365         set_errf("Option '%s' is not known", str);
 366         return -1;
 367 }
 368
 369 /* [variable] parser */
 370 static int get_var_cfg(__attribute__((unused)) unsigned sindex, char *str, __attribute__((unused)) void *data)
 371 {
 372         return add_var(str, get_cfg_key(str), 0);
 373 }
 374
 375 /* [defaults] parser */
 376 static int get_defaults_cfg(__attribute__((unused)) unsigned sindex, char *str, __attribute__((unused)) void *data)
 377 {
 378         uint32_t val;
 379         char *pkey;
 380
 381         pkey = get_cfg_key(str);
 382         if (pkey == NULL) {
 383                 set_errf("Missing key after option");
 384                 return -1;
 385         }
 386
 387         if (STR_EQ(str, "mempool size")) {
 388
 389                 if (parse_kmg(&val, pkey)) {
 390                         return -1;
 391                 }
 392
 393                 for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
 394                         struct lcore_cfg *cur_lcore_cfg_init = &lcore_cfg_init[lcore_id];
 395                         cur_lcore_cfg_init->id = lcore_id;
 396                         for (uint8_t task_id = 0; task_id < MAX_TASKS_PER_CORE; ++task_id) {
 397                                 struct task_args *targ = &cur_lcore_cfg_init->targs[task_id];
 398                                 targ->nb_mbuf = val;
 399                                 targ->id = task_id;
 400                         }
 401                 }
 402                 return 0;
 403         }
 404
 405         if (STR_EQ(str, "qinq tag")) {
 406                 for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
 407                         struct lcore_cfg *cur_lcore_cfg_init = &lcore_cfg_init[lcore_id];
 408                         cur_lcore_cfg_init->id = lcore_id;
 409                         for (uint8_t task_id = 0; task_id < MAX_TASKS_PER_CORE; ++task_id) {
 410                                 struct task_args *targ = &cur_lcore_cfg_init->targs[task_id];
 411                                 parse_int(&targ->qinq_tag, pkey);
 412                         }
 413                 }
 414                 return 0;
 415         }
 416         if (STR_EQ(str, "memcache size")) {
 417
 418                 if (parse_kmg(&val, pkey)) {
 419                         return -1;
 420                 }
 421
 422                 for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
 423                         struct lcore_cfg *cur_lcore_cfg_init = &lcore_cfg_init[lcore_id];
 424                         cur_lcore_cfg_init->id = lcore_id;
 425                         for (uint8_t task_id = 0; task_id < MAX_TASKS_PER_CORE; ++task_id) {
 426                                 struct task_args *targ = &cur_lcore_cfg_init->targs[task_id];
 427                                 targ->nb_cache_mbuf = val;
 428                         }
 429                 }
 430                 return 0;
 431         }
 432
 433         set_errf("Option '%s' is not known", str);
 434         return -1;
 435 }
 436
 437 /* [cache set] parser */
 438 static int get_cache_set_cfg(unsigned sindex, char *str, void *data)
 439 {
 440         struct prox_cache_set_cfg *cfg = (struct prox_cache_set_cfg *)data;
 441
 442         uint8_t cur_if = sindex & ~CFG_INDEXED;
 443
 444         if (cur_if >= PROX_MAX_CACHE_SET) {
 445                 set_errf("Cache set ID is too high (max allowed %d)", PROX_MAX_CACHE_SET - 1 );
 446                 return -1;
 447         }
 448
 449         cfg = &prox_cache_set_cfg[cur_if];
 450
 451         if (str == NULL || data == NULL) {
 452                 return -1;
 453         }
 454
 455         char *pkey = get_cfg_key(str);
 456
 457         if (pkey == NULL) {
 458                 set_errf("Missing key after option");
 459                 return -1;
 460         }
 461
 462         if (STR_EQ(str, "mask")) {
 463                 uint32_t val;
 464                 int err = parse_int(&val, pkey);
 465                 if (err) {
 466                         return -1;
 467                 }
 468                 cfg->mask = val;
 469                 cfg->socket_id = -1;
 470                 plog_info("\tCache set %d has mask %x\n", cur_if, cfg->mask);
 471                 return 0;
 472         }
 473         return 0;
 474 }
 475
 476 /* [port] parser */
 477 static int get_port_cfg(unsigned sindex, char *str, void *data)
 478 {
 479         struct prox_port_cfg *cfg = (struct prox_port_cfg *)data;
 480
 481         uint8_t cur_if = sindex & ~CFG_INDEXED;
 482
 483         if (cur_if >= PROX_MAX_PORTS) {
 484                 set_errf("Port ID is too high (max allowed %d)", PROX_MAX_PORTS - 1 );
 485                 return -1;
 486         }
 487
 488         cfg = &prox_port_cfg[cur_if];
 489
 490         if (str == NULL || data == NULL) {
 491                 return -1;
 492         }
 493
 494         char *pkey = get_cfg_key(str);
 495
 496         if (pkey == NULL) {
 497                 set_errf("Missing key after option");
 498                 return -1;
 499         }
 500
 501         if (STR_EQ(str, "mac")) {
 502                 if (STR_EQ(pkey, "hardware")) {
 503                         cfg->type = PROX_PORT_MAC_HW;
 504                 }
 505                 else if (STR_EQ(pkey, "random")) {
 506                         cfg->type = PROX_PORT_MAC_RAND;
 507                 }
 508                 else {
 509                         cfg->type = PROX_PORT_MAC_SET;
 510                         if (parse_mac(&cfg->eth_addr, pkey)) {
 511                                 return -1;
 512                         }
 513                 }
 514         }
 515         else if (STR_EQ(str, "name")) {
 516                 uint32_t val;
 517                 strncpy(cfg->name, pkey, MAX_NAME_SIZE);
 518                 PROX_ASSERT(cur_if < PROX_MAX_PORTS);
 519                 return add_port_name(cur_if, pkey);
 520         }
 521         else if (STR_EQ(str, "rx desc")) {
 522                 return parse_int(&cfg->n_rxd, pkey);
 523         }
 524         else if (STR_EQ(str, "tx desc")) {
 525                 return parse_int(&cfg->n_txd, pkey);
 526         }
 527         else if (STR_EQ(str, "promiscuous")) {
 528                 uint32_t val;
 529                 if (parse_bool(&val, pkey)) {
 530                         return -1;
 531                 }
 532                 cfg->promiscuous = val;
 533         }
 534         else if (STR_EQ(str, "lsc")) {
 535                 cfg->lsc_set_explicitely = 1;
 536                 uint32_t val;
 537                 if (parse_bool(&val, pkey)) {
 538                         return -1;
 539                 }
 540                 cfg->lsc_val = val;
 541         }
 542 #if RTE_VERSION >= RTE_VERSION_NUM(18,8,0,1)
 543         else if (STR_EQ(str, "disable tx offload")) {
 544                 uint32_t val;
 545                 if (parse_int(&val, pkey)) {
 546                         return -1;
 547                 }
 548                 if (val)
 549                         cfg->disabled_tx_offload = val;
 550         }
 551 #endif
 552         else if (STR_EQ(str, "strip crc")) {
 553                 uint32_t val;
 554                 if (parse_bool(&val, pkey)) {
 555                         return -1;
 556                 }
 557                 if (val)
 558                         cfg->requested_rx_offload |= DEV_RX_OFFLOAD_CRC_STRIP;
 559                 else
 560                         cfg->requested_rx_offload &= ~DEV_RX_OFFLOAD_CRC_STRIP;
 561         }
 562         else if (STR_EQ(str, "mtu size")) {
 563                 uint32_t val;
 564                 if (parse_int(&val, pkey)) {
 565                         return -1;
 566                 }
 567                 if (val) {
 568                         cfg->mtu = val;
 569                         // A frame of 1526 bytes (1500 bytes mtu, 14 bytes hdr, 4 bytes crc and 8 bytes vlan)
 570                         // should not be considered as a jumbo frame. However rte_ethdev.c considers that
 571                         // the max_rx_pkt_len for a non jumbo frame is 1518
 572                         cfg->port_conf.rxmode.max_rx_pkt_len = cfg->mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
 573                         if (cfg->port_conf.rxmode.max_rx_pkt_len > ETHER_MAX_LEN) {
 574                                 cfg->requested_rx_offload |= DEV_RX_OFFLOAD_JUMBO_FRAME;
 575                         }
 576                 }
 577         }
 578
 579         else if (STR_EQ(str, "rss")) {
 580                 uint32_t val;
 581                 if (parse_bool(&val, pkey)) {
 582                         return -1;
 583                 }
 584                 if (val) {
 585                         cfg->port_conf.rxmode.mq_mode = ETH_MQ_RX_RSS;
 586                         cfg->port_conf.rx_adv_conf.rss_conf.rss_hf = ETH_RSS_IPV4;
 587                 }
 588         }
 589         else if (STR_EQ(str, "rx_ring")) {
 590                 parse_str(cfg->rx_ring, pkey, sizeof(cfg->rx_ring));
 591         }
 592         else if (STR_EQ(str, "tx_ring")) {
 593                 parse_str(cfg->tx_ring, pkey, sizeof(cfg->tx_ring));
 594         }
 595
 596         return 0;
 597 }
 598
 599 static enum police_action str_to_color(const char *str)
 600 {
 601         if (STR_EQ(str, "green"))
 602                 return ACT_GREEN;
 603         if (STR_EQ(str, "yellow"))
 604                 return ACT_YELLOW;
 605         if (STR_EQ(str, "red"))
 606                 return ACT_RED;
 607         if (STR_EQ(str, "drop"))
 608                 return ACT_DROP;
 609         return ACT_INVALID;
 610 }
 611
 612 struct cfg_depr task_cfg_depr[] = {
 613         {"sig", ""},
 614 };
 615
 616 struct cfg_depr core_cfg_depr[] = {
 617         {"do sig", ""},
 618         {"lat", ""},
 619         {"network side", ""},
 620 };
 621
 622 /* [core] parser */
 623 static int get_core_cfg(unsigned sindex, char *str, void *data)
 624 {
 625         char *pkey;
 626         struct lcore_cfg *lconf = (struct lcore_cfg *)data;
 627
 628         if (str == NULL || lconf == NULL || !(sindex & CFG_INDEXED)) {
 629                 return -1;
 630         }
 631
 632         pkey = get_cfg_key(str);
 633         if (pkey == NULL) {
 634                 set_errf("Missing key after option");
 635                 return -1;
 636         }
 637
 638         uint32_t ncore = sindex & ~CFG_INDEXED;
 639         if (ncore >= RTE_MAX_LCORE) {
 640                 set_errf("Core index too high (max allowed %d)", RTE_MAX_LCORE - 1);
 641                 return -1;
 642         }
 643
 644         lconf = &lconf[ncore];
 645
 646         for (uint32_t i = 0; i < RTE_DIM(core_cfg_depr); ++i) {
 647                 if (STR_EQ(str, core_cfg_depr[i].opt)) {
 648                         set_errf("Option '%s' is deprecated%s%s",
 649                                  core_cfg_depr[i].opt, strlen(core_cfg_depr[i].info)? ": ": "", core_cfg_depr[i].info);
 650                         return -1;
 651                 }
 652         }
 653
 654         char buff[128];
 655         lcore_to_socket_core_ht(ncore, buff, sizeof(buff));
 656         set_self_var(buff);
 657         if (STR_EQ(str, "task")) {
 658
 659                 uint32_t val;
 660                 if (parse_int(&val, pkey)) {
 661                         return -1;
 662                 }
 663                 if (val >= MAX_TASKS_PER_CORE) {
 664                         set_errf("Too many tasks for core (max allowed %d)", MAX_TASKS_PER_CORE - 1);
 665                         return -1;
 666                 }
 667                 if (val != lconf->n_tasks_all) {
 668                         set_errf("Task ID skipped or defined twice");
 669                         return -1;
 670                 }
 671
 672                 lconf->active_task = val;
 673
 674                 lconf->targs[lconf->active_task].task = lconf->active_task;
 675
 676                 if (lconf->n_tasks_all < lconf->active_task + 1) {
 677                         lconf->n_tasks_all = lconf->active_task + 1;
 678                 }
 679                 return 0;
 680         }
 681
 682         struct task_args *targ = &lconf->targs[lconf->active_task];
 683         if (STR_EQ(str, "tx ports from routing table")) {
 684                 uint32_t vals[PROX_MAX_PORTS];
 685                 uint32_t n_if;
 686                 if (!(targ->task_init->flag_features & TASK_FEATURE_ROUTING)) {
 687                         set_errf("tx port form route not supported mode %s",  targ->task_init->mode_str);
 688                         return -1;
 689                 }
 690
 691                 if (parse_port_name_list(vals, &n_if, PROX_MAX_PORTS, pkey)) {
 692                         return -1;
 693                 }
 694
 695                 for (uint8_t i = 0; i < n_if; ++i) {
 696                         targ->tx_port_queue[i].port = vals[i];
 697                         targ->nb_txports++;
 698                 }
 699                 targ->runtime_flags |= TASK_ROUTING;
 700                 return 0;
 701         }
 702         if (STR_EQ(str, "tx ports from cpe table")) {
 703                 uint32_t vals[PROX_MAX_PORTS];
 704                 int n_remap = -1;
 705                 uint32_t ret;
 706                 uint32_t val;
 707                 char* mapping_str = strstr(pkey, " remap=");
 708
 709                 if (mapping_str != NULL) {
 710                         *mapping_str = 0;
 711                         mapping_str += strlen(" remap=");
 712                         n_remap = parse_remap(targ->mapping, mapping_str);
 713                 }
 714
 715                 if (parse_port_name_list(vals, &ret, PROX_MAX_PORTS, pkey)) {
 716                         return -1;
 717                 }
 718
 719                 if (n_remap != -1 && ret != (uint32_t)n_remap) {
 720                         set_errf("Expected %d remap elements but had %d", n_remap, ret);
 721                         return -1;
 722                 }
 723
 724                 for (uint8_t i = 0; i < ret; ++i) {
 725                         targ->tx_port_queue[i].port = vals[i];
 726
 727                         /* default mapping this case is port0 -> port0 */
 728                         if (n_remap == -1) {
 729                                 targ->mapping[vals[i]] = i;
 730                         }
 731                 }
 732
 733                 targ->nb_txports = ret;
 734
 735                 return 0;
 736         }
 737         if (STR_EQ(str, "tx cores from routing table")) {
 738                 if (!(targ->task_init->flag_features & TASK_FEATURE_ROUTING)) {
 739                         set_errf("tx port form route not supported mode %s",  targ->task_init->mode_str);
 740                         return -1;
 741                 }
 742
 743                 struct core_task_set *cts = &targ->core_task_set[0];
 744
 745                 if (parse_task_set(cts, pkey))
 746                         return -1;
 747
 748                 if (cts->n_elems > MAX_WT_PER_LB) {
 749                         set_errf("Maximum worker threads allowed is %u but have %u", MAX_WT_PER_LB, cts->n_elems);
 750                         return -1;
 751                 }
 752
 753                 targ->nb_worker_threads = cts->n_elems;
 754                 targ->nb_txrings = cts->n_elems;
 755
 756                 if (targ->nb_txrings > MAX_RINGS_PER_TASK) {
 757                         set_errf("Maximum allowed TX rings is %u but have %u", MAX_RINGS_PER_TASK, targ->nb_txrings);
 758                         return -1;
 759                 }
 760
 761                 targ->runtime_flags |= TASK_ROUTING;
 762                 return 0;
 763         }
 764         if (STR_EQ(str, "tx cores from cpe table")) {
 765                 struct core_task_set *core_task_set =  &targ->core_task_set[0];
 766                 int ret, ret2;
 767                 char *mapping_str;
 768
 769                 mapping_str = strstr(pkey, " remap=");
 770                 if (mapping_str == NULL) {
 771                         set_errf("There is no default mapping for tx cores from cpe table. Please specify it through remap=");
 772                         return -1;
 773                 }
 774                 *mapping_str = 0;
 775                 mapping_str += strlen(" remap=");
 776                 ret = parse_remap(targ->mapping, mapping_str);
 777                 if (ret <= 0) {
 778                         return -1;
 779                 }
 780
 781                 struct core_task_set *cts = &targ->core_task_set[0];
 782
 783                 if (parse_task_set(cts, pkey))
 784                         return -1;
 785                 if (cts->n_elems > MAX_RINGS_PER_TASK) {
 786                         set_errf("Maximum cores to route to is %u\n", MAX_RINGS_PER_TASK);
 787                         return -1;
 788                 }
 789
 790                 targ->nb_txrings = cts->n_elems;
 791
 792                 if (ret != targ->nb_txrings) {
 793                         set_errf("Expecting same number of remaps as cores\n", str);
 794                         return -1;
 795                 }
 796                 return 0;
 797         }
 798
 799         if (STR_EQ(str, "delay ms")) {
 800                 if (targ->delay_us) {
 801                         set_errf("delay ms and delay us are mutually exclusive\n", str);
 802                         return -1;
 803                 }
 804                 uint32_t delay_ms;
 805                 int rc = parse_int(&delay_ms, pkey);
 806                 targ->delay_us = delay_ms * 1000;
 807                 return rc;
 808         }
 809         if (STR_EQ(str, "delay us")) {
 810                 if (targ->delay_us) {
 811                         set_errf("delay ms and delay us are mutually exclusive\n", str);
 812                         return -1;
 813                 }
 814                 return parse_int(&targ->delay_us, pkey);
 815         }
 816         if (STR_EQ(str, "random delay us")) {
 817                 return parse_int(&targ->random_delay_us, pkey);
 818         }
 819         if (STR_EQ(str, "cpe table timeout ms")) {
 820                 return parse_int(&targ->cpe_table_timeout_ms, pkey);
 821         }
 822         if (STR_EQ(str, "ctrl path polling frequency")) {
 823                 int rc = parse_int(&targ->ctrl_freq, pkey);
 824                 if (rc == 0) {
 825                         if (targ->ctrl_freq == 0) {
 826                                 set_errf("ctrl frequency must be non null.");
 827                                 return -1;
 828                         }
 829                 }
 830                 return rc;
 831         }
 832
 833         if (STR_EQ(str, "handle arp")) {
 834                 return parse_flag(&targ->runtime_flags, TASK_CTRL_HANDLE_ARP, pkey);
 835         }
 836         if (STR_EQ(str, "fast path handle arp")) {
 837                 return parse_flag(&targ->runtime_flags, TASK_FP_HANDLE_ARP, pkey);
 838         }
 839         if (STR_EQ(str, "multiple arp")) {
 840                 return parse_flag(&targ->flags, TASK_MULTIPLE_MAC, pkey);
 841         }
 842
 843         /* Using tx port name, only a _single_ port can be assigned to a task. */
 844         if (STR_EQ(str, "tx port")) {
 845                 if (targ->nb_txports > 0) {
 846                         set_errf("Only one tx port can be defined per task. Use a LB task or routing instead.");
 847                         return -1;
 848                 }
 849
 850                 uint32_t n_if = 0;
 851                 uint32_t ports[PROX_MAX_PORTS];
 852
 853                 if(parse_port_name_list(ports, &n_if, PROX_MAX_PORTS, pkey)) {
 854                         return -1;
 855                 }
 856
 857                 PROX_ASSERT(n_if-1 < PROX_MAX_PORTS);
 858
 859                 for (uint8_t i = 0; i < n_if; ++i) {
 860                         targ->tx_port_queue[i].port = ports[i];
 861                         targ->nb_txports++;
 862                 }
 863
 864                 if (n_if > 1) {
 865                         targ->nb_worker_threads = targ->nb_txports;
 866                 }
 867
 868                 return 0;
 869         }
 870         if (STR_EQ(str, "rx ring")) {
 871                 uint32_t val;
 872                 int err = parse_bool(&val, pkey);
 873                 if (!err && val && targ->rx_port_queue[0].port != OUT_DISCARD) {
 874                         set_errf("Can't read both from internal ring and external port from the same task. Use multiple tasks instead.");
 875                         return -1;
 876                 }
 877
 878                 return parse_flag(&targ->flags, TASK_ARG_RX_RING, pkey);
 879         }
 880         if (STR_EQ(str, "private")) {
 881                 return parse_bool(&targ->use_src, pkey);
 882         }
 883         if (STR_EQ(str, "use src ip")) {
 884                 return parse_bool(&targ->use_src, pkey);
 885         }
 886         if (STR_EQ(str, "nat table")) {
 887                 return parse_str(targ->nat_table, pkey, sizeof(targ->nat_table));
 888         }
 889         if (STR_EQ(str, "rules")) {
 890                 return parse_str(targ->rules, pkey, sizeof(targ->rules));
 891         }
 892         if (STR_EQ(str, "route table")) {
 893                 return parse_str(targ->route_table, pkey, sizeof(targ->route_table));
 894         }
 895         if (STR_EQ(str, "dscp")) {
 896                 return parse_str(targ->dscp, pkey, sizeof(targ->dscp));
 897         }
 898         if (STR_EQ(str, "tun_bindings")) {
 899                 return parse_str(targ->tun_bindings, pkey, sizeof(targ->tun_bindings));
 900         }
 901         if (STR_EQ(str, "cpe table")) {
 902                 return parse_str(targ->cpe_table_name, pkey, sizeof(targ->cpe_table_name));
 903         }
 904         if (STR_EQ(str, "user table")) {
 905                 return parse_str(targ->user_table, pkey, sizeof(targ->user_table));
 906         }
 907         if (STR_EQ(str, "streams")) {
 908                 return parse_str(targ->streams, pkey, sizeof(targ->streams));
 909         }
 910         if (STR_EQ(str, "local lpm")) {
 911                 return parse_flag(&targ->flags, TASK_ARG_LOCAL_LPM, pkey);
 912         }
 913         if (STR_EQ(str, "drop")) {
 914                 return parse_flag(&targ->flags, TASK_ARG_DROP, pkey);
 915         }
 916         if (STR_EQ(str, "loop")) {
 917                 parse_flag(&targ->loop, 1, pkey);
 918                 return parse_flag(&targ->loop, 1, pkey);
 919         }
 920         if (STR_EQ(str, "qinq")) {
 921                 return parse_flag(&targ->flags, TASK_ARG_QINQ_ACL, pkey);
 922         }
 923         if (STR_EQ(str, "bps")) {
 924                 return parse_u64(&targ->rate_bps, pkey);
 925         }
 926         if (STR_EQ(str, "random")) {
 927                 return parse_str(targ->rand_str[targ->n_rand_str++], pkey, sizeof(targ->rand_str[0]));
 928         }
 929         if (STR_EQ(str, "rand_offset")) {
 930                 if (targ->n_rand_str == 0) {
 931                         set_errf("No random defined previously (use random=...)");
 932                         return -1;
 933                 }
 934
 935                 return parse_int(&targ->rand_offset[targ->n_rand_str - 1], pkey);
 936         }
 937         if (STR_EQ(str, "keep src mac")) {
 938                 return parse_flag(&targ->flags, DSF_KEEP_SRC_MAC, pkey);
 939         }
 940         if (STR_EQ(str, "pcap file")) {
 941                 return parse_str(targ->pcap_file, pkey, sizeof(targ->pcap_file));
 942         }
 943         if (STR_EQ(str, "pkt inline")) {
 944                 char pkey2[MAX_CFG_STRING_LEN];
 945                 if (parse_str(pkey2, pkey, sizeof(pkey2)) != 0) {
 946                         set_errf("Error while parsing pkt line, too long\n");
 947                         return -1;
 948                 }
 949
 950                 const size_t pkey_len = strlen(pkey2);
 951                 targ->pkt_size = 0;
 952
 953                 for (size_t i = 0; i < pkey_len; ++i) {
 954                         if (pkey2[i] == ' ')
 955                                 continue;
 956
 957                         if (i + 1 == pkey_len) {
 958                                 set_errf("Incomplete byte at character %z", i);
 959                                 return -1;
 960                         }
 961
 962                         uint8_t byte = 0;
 963
 964                         if (pkey2[i] >= '0' && pkey2[i] <= '9') {
 965                                 byte = (pkey2[i] - '0') << 4;
 966                         }
 967                         else if (pkey2[i] >= 'a' && pkey2[i] <= 'f') {
 968                                 byte = (pkey2[i] - 'a' + 10) << 4;
 969                         }
 970                         else if (pkey2[i] >= 'A' && pkey2[i] <= 'F') {
 971                                 byte = (pkey2[i] - 'A' + 10) << 4;
 972                         }
 973                         else {
 974                                 set_errf("Invalid character in pkt inline at byte %d (%c)", i, pkey2[i]);
 975                                 return -1;
 976                         }
 977
 978                         if (pkey2[i + 1] >= '0' && pkey2[i + 1] <= '9') {
 979                                 byte |= (pkey2[i + 1] - '0');
 980                         }
 981                         else if (pkey2[i + 1] >= 'a' && pkey2[i + 1] <= 'f') {
 982                                 byte |= (pkey2[i + 1] - 'a' + 10);
 983                         }
 984                         else if (pkey2[i + 1] >= 'A' && pkey2[i + 1] <= 'F') {
 985                                 byte |= (pkey2[i + 1] - 'A' + 10);
 986                         }
 987                         else {
 988                                 set_errf("Invalid character in pkt inline at byte %d (%c)", i, pkey2[i + 1]);
 989                                 return -1;
 990                         }
 991                         if (targ->pkt_size == sizeof(targ->pkt_inline)) {
 992                                 set_errf("Inline packet definition can't be longer than %u", sizeof(targ->pkt_inline));
 993                                 return -1;
 994                         }
 995
 996                         targ->pkt_inline[targ->pkt_size++] = byte;
 997                         i += 1;
 998                 }
 999
1000                 return 0;
1001         }
1002         if (STR_EQ(str, "accuracy limit nsec")) {
1003                 return parse_int(&targ->accuracy_limit_nsec, pkey);
1004         }
1005         if (STR_EQ(str, "latency bucket size")) {
1006                 return parse_int(&targ->bucket_size, pkey);
1007         }
1008         if (STR_EQ(str, "latency buffer size")) {
1009                 return parse_int(&targ->latency_buffer_size, pkey);
1010         }
1011         if (STR_EQ(str, "accuracy pos")) {
1012                 return parse_int(&targ->accur_pos, pkey);
1013         }
1014         if (STR_EQ(str, "signature")) {
1015                 return parse_int(&targ->sig, pkey);
1016         }
1017         if (STR_EQ(str, "signature pos")) {
1018                 return parse_int(&targ->sig_pos, pkey);
1019         }
1020         if (STR_EQ(str, "lat pos")) {
1021                 targ->lat_enabled = 1;
1022                 return parse_int(&targ->lat_pos, pkey);
1023         }
1024         if (STR_EQ(str, "packet id pos")) {
1025                 return parse_int(&targ->packet_id_pos, pkey);
1026         }
1027         if (STR_EQ(str, "probability")) {
1028                 float probability;
1029                 int rc = parse_float(&probability, pkey);
1030                 if (probability == 0) {
1031                         set_errf("Probability must be != 0\n");
1032                         return -1;
1033                 } else if (probability > 100.0) {
1034                         set_errf("Probability must be < 100\n");
1035                         return -1;
1036                 }
1037                 targ->probability = probability * 10000;
1038                 return rc;
1039         }
1040         if (STR_EQ(str, "concur conn")) {
1041                 return parse_int(&targ->n_concur_conn, pkey);
1042         }
1043         if (STR_EQ(str, "max setup rate")) {
1044                 return parse_int(&targ->max_setup_rate, pkey);
1045         }
1046         if (STR_EQ(str, "pkt size")) {
1047                 return parse_int(&targ->pkt_size, pkey);
1048         }
1049         if (STR_EQ(str, "min bulk size")) {
1050                 return parse_int(&targ->min_bulk_size, pkey);
1051         }
1052         if (STR_EQ(str, "max bulk size")) {
1053                 return parse_int(&targ->max_bulk_size, pkey);
1054         }
1055         if (STR_EQ(str, "rx port")) {
1056                 if (targ->flags & TASK_ARG_RX_RING) {
1057                         set_errf("Can't read both from internal ring and external port from the same task. Use multiple tasks instead.");
1058                         return -1;
1059                 }
1060                 uint32_t vals[PROX_MAX_PORTS];
1061                 uint32_t n_if;
1062
1063                 if (parse_port_name_list(vals, &n_if, PROX_MAX_PORTS, pkey)) {
1064                         return -1;
1065                 }
1066
1067                 for (uint8_t i = 0; i < n_if; ++i) {
1068                         PROX_ASSERT(vals[i] < PROX_MAX_PORTS);
1069                         targ->rx_port_queue[i].port = vals[i];
1070                         targ->nb_rxports++;
1071                 }
1072                 return 0;
1073         }
1074
1075         if (STR_EQ(str, "mode")) {
1076                 /* Check deprecated task modes */
1077                 char mode[255];
1078                 int ret = parse_str(mode, pkey, sizeof(mode));
1079                 if (ret)
1080                         return ret;
1081
1082                 for (uint32_t i = 0; i < RTE_DIM(task_cfg_depr); ++i) {
1083                         if (STR_EQ(mode, task_cfg_depr[i].opt)) {
1084                                 set_errf("Task mode '%s' is deprecated%s%s",
1085                                          task_cfg_depr[i].opt, strlen(task_cfg_depr[i].info)? ": ": "", task_cfg_depr[i].info);
1086                                 return -1;
1087                         }
1088                 }
1089
1090                 /* master is a special mode that is always needed (cannot be turned off) */
1091                 if (STR_EQ(mode, "master")) {
1092                         prox_cfg.master = ncore;
1093                         targ->mode = MASTER;
1094                         if (lconf->n_tasks_all > 1 || targ->task != 0) {
1095                                 set_errf("Master core can only have one task\n");
1096                                 return -1;
1097                         }
1098                         // Initialize number of tasks to 1 for master, even if no task specified
1099                         lconf->n_tasks_all = 1;
1100                         lconf->active_task = 0;
1101                         lconf->targs[lconf->active_task].task = 0;
1102                         struct task_init* task_init = to_task_init(mode, "");
1103                         if (task_init) {
1104                                 targ->mode = task_init->mode;
1105                         }
1106                         targ->task_init = task_init;
1107                         return 0;
1108                 }
1109
1110                 struct task_init* task_init = to_task_init(mode, "");
1111                 if (task_init) {
1112                         targ->mode = task_init->mode;
1113                 }
1114                 else {
1115                         set_errf("Task mode '%s' is invalid", mode);
1116                         tasks_list();
1117                         return -1;
1118                 }
1119                 targ->task_init = task_init;
1120                 return 0;
1121         }
1122         if (STR_EQ(str, "users")) {
1123                 return parse_int(&targ->n_flows, pkey);
1124         }
1125
1126         if (STR_EQ(str, "mark")) {
1127                 return parse_flag(&targ->runtime_flags, TASK_MARK, pkey);
1128         }
1129
1130         if (STR_EQ(str, "mark green")) {
1131                 return parse_int(&targ->marking[0], pkey);
1132         }
1133
1134         if (STR_EQ(str, "mark yellow")) {
1135                 return parse_int(&targ->marking[1], pkey);
1136         }
1137
1138         if (STR_EQ(str, "mark red")) {
1139                 return parse_int(&targ->marking[2], pkey);
1140         }
1141
1142         if (STR_EQ(str, "tx cores")) {
1143                 uint8_t dest_task = 0;
1144                 /* if user did not specify, dest_port is left at default (first type) */
1145                 uint8_t dest_proto = 0;
1146                 uint8_t ctrl = CTRL_TYPE_DP;
1147                 char *task_str = strstr(pkey, "proto=");
1148                 if (task_str) {
1149                         task_str += strlen("proto=");
1150
1151                         if (STR_EQ(task_str, "ipv4")) {
1152                                 dest_proto = IPV4;
1153                         }
1154                         else if (STR_EQ(task_str, "arp")) {
1155                                 dest_proto = ARP;
1156                         }
1157                         else if (STR_EQ(task_str, "ipv6")) {
1158                                 dest_proto = IPV6;
1159                         }
1160                         else {
1161                                 set_errf("proto needs to be either ipv4, arp or ipv6");
1162                                 return -1;
1163                         }
1164
1165                 }
1166
1167                 task_str = strstr(pkey, "task=");
1168
1169                 if (task_str) {
1170                         --task_str;
1171                         *task_str = 0;
1172                         task_str++;
1173                         task_str += strlen("task=");
1174                         char *task_str_end = strstr(task_str, " ");
1175                         if (task_str_end) {
1176                                 *task_str_end = 0;
1177                         }
1178                         if (0 == strlen(task_str)) {
1179                                 set_errf("Invalid task= syntax");
1180                                 return -1;
1181                         }
1182
1183                         switch (task_str[strlen(task_str) - 1]) {
1184                         case 'p':
1185                                 ctrl = CTRL_TYPE_PKT;
1186                                 break;
1187                         case 'm':
1188                                 ctrl = CTRL_TYPE_MSG;
1189                                 break;
1190                         case '\n':
1191                         case 0:
1192                                 break;
1193                         default:
1194                                 if (task_str[strlen(task_str) -1] < '0' ||
1195                                     task_str[strlen(task_str) -1] > '9') {
1196                                         set_errf("Unknown ring type %c.\n",
1197                                                  task_str[strlen(task_str) - 1]);
1198                                         return -1;
1199                                 }
1200                         }
1201
1202                         dest_task = atoi(task_str);
1203                         if (dest_task >= MAX_TASKS_PER_CORE) {
1204                                 set_errf("Destination task too high (max allowed %d)", MAX_TASKS_PER_CORE - 1);
1205                                 return -1;
1206                         }
1207                 }
1208                 else {
1209                         dest_task = 0;
1210                 }
1211
1212                 struct core_task_set *cts = &targ->core_task_set[dest_proto];
1213
1214                 if (parse_task_set(cts, pkey))
1215                         return -1;
1216
1217                 if (cts->n_elems > MAX_WT_PER_LB) {
1218                         set_errf("Too many worker threads (max allowed %d)", MAX_WT_PER_LB - 1);
1219                         return -1;
1220                 }
1221
1222                 targ->nb_worker_threads = cts->n_elems;
1223                 targ->nb_txrings += cts->n_elems;
1224
1225                 return 0;
1226         }
1227         if (STR_EQ(str, "tx crc")) {
1228                 return parse_flag(&targ->runtime_flags, TASK_TX_CRC, pkey);
1229         }
1230         if (STR_EQ(str, "ring size")) {
1231                 return parse_int(&targ->ring_size, pkey);
1232         }
1233         if (STR_EQ(str, "mempool size")) {
1234                 return parse_kmg(&targ->nb_mbuf, pkey);
1235         }
1236
1237         else if (STR_EQ(str, "mbuf size")) {
1238                 return parse_int(&targ->mbuf_size, pkey);
1239         }
1240         if (STR_EQ(str, "memcache size")) {
1241                 return parse_kmg(&targ->nb_cache_mbuf, pkey);
1242         }
1243
1244         if (STR_EQ(str, "byte offset")) {
1245                 return parse_int(&targ->byte_offset, pkey);
1246         }
1247
1248         if (STR_EQ(str, "name")) {
1249                 return parse_str(lconf->name, pkey, sizeof(lconf->name));
1250         }
1251         /* MPLS configuration */
1252         if (STR_EQ(str, "untag mpls")) {
1253                 return parse_flag(&targ->runtime_flags, TASK_MPLS_TAGGING, pkey);
1254         }
1255
1256         if (STR_EQ(str, "add mpls")) {
1257                 return parse_flag(&targ->runtime_flags, TASK_MPLS_TAGGING, pkey);
1258         }
1259
1260         if (STR_EQ(str, "ether type")) {
1261                 return parse_int(&targ->etype, pkey);
1262         }
1263
1264         if (STR_EQ(str, "cache set")) {
1265                 return parse_int(&lconf->cache_set, pkey);
1266         }
1267
1268         if (STR_EQ(str, "sub mode")) {
1269                 const char* mode_str = targ->task_init->mode_str;
1270                 const char *sub_mode_str = pkey;
1271
1272                 targ->task_init = to_task_init(mode_str, sub_mode_str);
1273                 if (!targ->task_init) {
1274                         if (strcmp(sub_mode_str, "l3") != 0) {
1275                                 set_errf("sub mode %s not supported for mode %s", sub_mode_str, mode_str);
1276                                 return -1;
1277                         }
1278                         targ->task_init = to_task_init(mode_str, "");
1279                         if (!targ->task_init) {
1280                                 set_errf("sub mode %s not supported for mode %s", sub_mode_str, mode_str);
1281                                 return -1;
1282                         }
1283                 }
1284                 if (strcmp(sub_mode_str, "l3") == 0) {
1285                         prox_cfg.flags |= DSF_CTRL_PLANE_ENABLED;
1286                         targ->flags |= TASK_ARG_L3;
1287                         strcpy(targ->sub_mode_str, "l3");
1288                 } else {
1289                         strcpy(targ->sub_mode_str, targ->task_init->sub_mode_str);
1290                 }
1291                 return 0;
1292         }
1293
1294         if (STR_EQ(str, "mempool name")) {
1295                 return parse_str(targ->pool_name, pkey, sizeof(targ->pool_name));
1296         }
1297         if (STR_EQ(str, "dpi engine")) {
1298                 return parse_str(targ->dpi_engine_path, pkey, sizeof(targ->dpi_engine_path));
1299         }
1300         if (STR_EQ(str, "dpi engine arg")) {
1301                 return parse_str(targ->dpi_engine_args[targ->n_dpi_engine_args++], pkey,
1302                                  sizeof(targ->dpi_engine_args[0]));
1303         }
1304         if (STR_EQ(str, "dst mac")) { /* destination MAC address to be used for packets */
1305                 if (parse_mac(&targ->edaddr, pkey)) {
1306                         if (STR_EQ(pkey, "no")) {
1307                                 targ->flags |= TASK_ARG_DO_NOT_SET_DST_MAC;
1308                                 return 0;
1309                         }
1310                         if (STR_EQ(pkey, "packet") == 0)
1311                                 return -1;
1312                         else
1313                                 return 0;
1314                 }
1315                 targ->flags |= TASK_ARG_DST_MAC_SET;
1316                 return 0;
1317         }
1318         if (STR_EQ(str, "src mac")) {
1319                 if (parse_mac(&targ->esaddr, pkey)) {
1320                         if (STR_EQ(pkey, "no")) {
1321                                 targ->flags |= TASK_ARG_DO_NOT_SET_SRC_MAC;
1322                                 return 0;
1323                         }
1324                         else if (STR_EQ(pkey, "packet"))
1325                                 return 0;
1326                         else if (STR_EQ(pkey, "hw")) {
1327                                 targ->flags |= TASK_ARG_HW_SRC_MAC;
1328                                 return 0;
1329                         } else {
1330                                 return -1;
1331                         }
1332                 }
1333                 targ->flags |= TASK_ARG_SRC_MAC_SET;
1334                 return 0;
1335         }
1336         if (STR_EQ(str, "gateway ipv4")) { /* Gateway IP address used when generating */
1337                 return parse_ip(&targ->gateway_ipv4, pkey);
1338         }
1339         if (STR_EQ(str, "local ipv4")) { /* source IP address to be used for packets */
1340                 return parse_ip(&targ->local_ipv4, pkey);
1341         }
1342         if (STR_EQ(str, "remote ipv4")) { /* source IP address to be used for packets */
1343                 return parse_ip(&targ->remote_ipv4, pkey);
1344         }
1345         if (STR_EQ(str, "local ipv6")) { /* source IPv6 address to be used for packets */
1346                 return parse_ip6(&targ->local_ipv6, pkey);
1347         }
1348         if (STR_EQ(str, "number of packets"))
1349                 return parse_int(&targ->n_pkts, pkey);
1350         if (STR_EQ(str, "pipes")) {
1351                 uint32_t val;
1352                 int err = parse_int(&val, pkey);
1353                 if (err)
1354                         return -1;
1355                 if (!val || !rte_is_power_of_2(val)) {
1356                         set_errf("Number of pipes has to be power of 2 and not zero");
1357                         return -1;
1358                 }
1359
1360                 targ->qos_conf.port_params.n_pipes_per_subport = val;
1361                 return 0;
1362         }
1363         if (STR_EQ(str, "queue size")) {
1364                 uint32_t val;
1365                 int err = parse_int(&val, pkey);
1366                 if (err) {
1367                         return -1;
1368                 }
1369
1370                 targ->qos_conf.port_params.qsize[0] = val;
1371                 targ->qos_conf.port_params.qsize[1] = val;
1372                 targ->qos_conf.port_params.qsize[2] = val;
1373                 targ->qos_conf.port_params.qsize[3] = val;
1374                 return 0;
1375         }
1376         if (STR_EQ(str, "subport tb rate")) {
1377                 return parse_int(&targ->qos_conf.subport_params[0].tb_rate, pkey);
1378         }
1379         if (STR_EQ(str, "subport tb size")) {
1380                 return parse_int(&targ->qos_conf.subport_params[0].tb_size, pkey);
1381         }
1382         if (STR_EQ(str, "subport tc 0 rate")) {
1383                 return parse_int(&targ->qos_conf.subport_params[0].tc_rate[0], pkey);
1384         }
1385         if (STR_EQ(str, "subport tc 1 rate")) {
1386                 return parse_int(&targ->qos_conf.subport_params[0].tc_rate[1], pkey);
1387         }
1388         if (STR_EQ(str, "subport tc 2 rate")) {
1389                 return parse_int(&targ->qos_conf.subport_params[0].tc_rate[2], pkey);
1390         }
1391         if (STR_EQ(str, "subport tc 3 rate")) {
1392                 return parse_int(&targ->qos_conf.subport_params[0].tc_rate[3], pkey);
1393         }
1394
1395         if (STR_EQ(str, "subport tc rate")) {
1396                 uint32_t val;
1397                 int err = parse_int(&val, pkey);
1398                 if (err) {
1399                         return -1;
1400                 }
1401
1402                 targ->qos_conf.subport_params[0].tc_rate[0] = val;
1403                 targ->qos_conf.subport_params[0].tc_rate[1] = val;
1404                 targ->qos_conf.subport_params[0].tc_rate[2] = val;
1405                 targ->qos_conf.subport_params[0].tc_rate[3] = val;
1406
1407                 return 0;
1408         }
1409         if (STR_EQ(str, "subport tc period")) {
1410                 return parse_int(&targ->qos_conf.subport_params[0].tc_period, pkey);
1411         }
1412         if (STR_EQ(str, "pipe tb rate")) {
1413                 return parse_int(&targ->qos_conf.pipe_params[0].tb_rate, pkey);
1414         }
1415         if (STR_EQ(str, "pipe tb size")) {
1416                 return parse_int(&targ->qos_conf.pipe_params[0].tb_size, pkey);
1417         }
1418         if (STR_EQ(str, "pipe tc rate")) {
1419                 uint32_t val;
1420                 int err = parse_int(&val, pkey);
1421                 if (err) {
1422                         return -1;
1423                 }
1424
1425                 targ->qos_conf.pipe_params[0].tc_rate[0] = val;
1426                 targ->qos_conf.pipe_params[0].tc_rate[1] = val;
1427                 targ->qos_conf.pipe_params[0].tc_rate[2] = val;
1428                 targ->qos_conf.pipe_params[0].tc_rate[3] = val;
1429                 return 0;
1430         }
1431         if (STR_EQ(str, "pipe tc 0 rate")) {
1432                 return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[0], pkey);
1433         }
1434         if (STR_EQ(str, "pipe tc 1 rate")) {
1435                 return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[1], pkey);
1436         }
1437         if (STR_EQ(str, "pipe tc 2 rate")) {
1438                 return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[2], pkey);
1439         }
1440         if (STR_EQ(str, "pipe tc 3 rate")) {
1441                 return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[3], pkey);
1442         }
1443         if (STR_EQ(str, "pipe tc period")) {
1444                 return parse_int(&targ->qos_conf.pipe_params[0].tc_period, pkey);
1445         }
1446         if (STR_EQ(str, "police action")) {
1447                 char *in = strstr(pkey, " io=");
1448                 if (in == NULL) {
1449                         set_errf("Need to specify io colors using io=in_color,out_color\n");
1450                         return -1;
1451                 }
1452                 *in = 0;
1453                 in += strlen(" io=");
1454
1455                 char *out = strstr(in, ",");
1456                 if (out == NULL) {
1457                         set_errf("Output color not specified\n");
1458                 }
1459                 *out = 0;
1460                 out++;
1461
1462                 enum police_action in_color = str_to_color(in);
1463                 enum police_action out_color = str_to_color(out);
1464
1465                 if (in_color == ACT_INVALID) {
1466                         set_errf("Invalid input color %s. Expected green, yellow or red", in);
1467                         return -1;
1468                 }
1469                 if (out_color == ACT_INVALID) {
1470                         set_errf("Invalid output color %s. Expected green, yellow or red", out);
1471                         return -1;
1472                 }
1473                 enum police_action action = str_to_color(pkey);
1474                 if (action == ACT_INVALID) {
1475                         set_errf("Error action %s. Expected green, yellow, red or drop", pkey);
1476                         return -1;
1477                 }
1478                 targ->police_act[in_color][out_color] = action;
1479
1480                 return 0;
1481         }
1482         if (STR_EQ(str, "qinq tag")) {
1483                 return parse_int(&targ->qinq_tag, pkey);
1484         }
1485         if (STR_EQ(str, "cir")) {
1486                 return parse_int(&targ->cir, pkey);
1487         }
1488         if (STR_EQ(str, "cbs")) {
1489                 return parse_int(&targ->cbs, pkey);
1490         }
1491         if (STR_EQ(str, "pir")) {
1492                 return parse_int(&targ->pir, pkey);
1493         }
1494         if (STR_EQ(str, "pbs")) {
1495                 return parse_int(&targ->pbs, pkey);
1496         }
1497         if (STR_EQ(str, "ebs")) {
1498                 return parse_int(&targ->ebs, pkey);
1499         }
1500         uint32_t queue_id = 0;
1501         if (sscanf(str, "queue %d weight", &queue_id) == 1) {
1502                 uint32_t val;
1503                 int err = parse_int(&val, pkey);
1504                 if (err) {
1505                         return -1;
1506                 }
1507                 targ->qos_conf.pipe_params[0].wrr_weights[queue_id] = val;
1508                 return 0;
1509         }
1510         if (STR_EQ(str, "classify")) {
1511                 if (!(targ->task_init->flag_features & TASK_FEATURE_CLASSIFY)) {
1512                         set_errf("Classify is not supported in '%s' mode", targ->task_init->mode_str);
1513                         return -1;
1514                 }
1515
1516                 return parse_flag(&targ->runtime_flags, TASK_CLASSIFY, pkey);
1517         }
1518         if (STR_EQ(str, "flow table size")) {
1519                 return parse_int(&targ->flow_table_size, pkey);
1520         }
1521 #ifdef GRE_TP
1522         if (STR_EQ(str, "tbf rate")) {
1523                 return parse_int(&targ->tb_rate, pkey);
1524         }
1525         if (STR_EQ(str, "tbf size")) {
1526                 return parse_int(&targ->tb_size, pkey);
1527         }
1528 #endif
1529         if (STR_EQ(str, "max rules")) {
1530                 return parse_int(&targ->n_max_rules, pkey);
1531         }
1532
1533         if (STR_EQ(str, "tunnel hop limit")) {
1534                 uint32_t val;
1535                 int err = parse_int(&val, pkey);
1536                 if (err) {
1537                         return -1;
1538                 }
1539                 targ->tunnel_hop_limit = val;
1540                 return 0;
1541         }
1542
1543         if (STR_EQ(str, "lookup port mask")) {
1544                 uint32_t val;
1545                 int err = parse_int(&val, pkey);
1546                 if (err) {
1547                         return -1;
1548                 }
1549                 targ->lookup_port_mask = val;
1550                 return 0;
1551         }
1552
1553         if (STR_EQ(str, "irq debug")) {
1554                 parse_int(&targ->irq_debug, pkey);
1555                 return 0;
1556         }
1557
1558         set_errf("Option '%s' is not known", str);
1559         /* fail on unknown keys */
1560         return -1;
1561 }
1562
1563 static int str_is_number(const char *in)
1564 {
1565         int dot_once = 0;
1566
1567         for (size_t i = 0; i < strlen(in); ++i) {
1568                 if (!dot_once && in[i] == '.') {
1569                         dot_once = 1;
1570                         continue;
1571                 }
1572
1573                 if (in[i] < '0' || in[i] > '9')
1574                         return 0;
1575         }
1576
1577         return 1;
1578 }
1579
1580 /* command line parameters parsing procedure */
1581 int prox_parse_args(int argc, char **argv)
1582 {
1583         int i, opt, ret;
1584         char *tmp, *tmp2;
1585         char tmp3[64];
1586
1587         /* Default settings */
1588         prox_cfg.flags |= DSF_AUTOSTART | DSF_WAIT_ON_QUIT;
1589         prox_cfg.ui = PROX_UI_CURSES;
1590
1591         plog_info("\tCommand line:");
1592         for (i = 0; i < argc; ++i) {
1593                 plog_info(" %s", argv[i]);
1594         }
1595         plog_info("\n");
1596
1597         while ((opt = getopt(argc, argv, "f:dnzpo:tkuar:emsiw:l:v:q:")) != EOF) {
1598                 switch (opt) {
1599                 case 'f':
1600                         /* path to config file */
1601                         cfg_file = optarg;
1602                         size_t offset = 0;
1603                         for (size_t i = 0; i < strlen(cfg_file); ++i) {
1604                                 if (cfg_file[i] == '/') {
1605                                         offset = i + 1;
1606                                 }
1607                         }
1608
1609                         strncpy(prox_cfg.name, cfg_file + offset, MAX_NAME_SIZE);
1610                         break;
1611                 case 'v':
1612                         plog_set_lvl(atoi(optarg));
1613                         break;
1614                 case 'l':
1615                         prox_cfg.log_name_pid = 0;
1616                         strncpy(prox_cfg.log_name, optarg, MAX_NAME_SIZE);
1617                         break;
1618                 case 'p':
1619                         prox_cfg.log_name_pid = 1;
1620                         break;
1621                 case 'k':
1622                         prox_cfg.use_stats_logger = 1;
1623                         break;
1624                 case 'd':
1625                         prox_cfg.flags |= DSF_DAEMON;
1626                         prox_cfg.ui = PROX_UI_NONE;
1627                         break;
1628                 case 'z':
1629                         prox_cfg.flags |= DSF_USE_DUMMY_CPU_TOPO;
1630                         prox_cfg.flags |= DSF_CHECK_INIT;
1631                         break;
1632                 case 'n':
1633                         prox_cfg.flags |= DSF_USE_DUMMY_DEVICES;
1634                         break;
1635                 case 'r':
1636                         if (!str_is_number(optarg) || strlen(optarg) > 11)
1637                                 return -1;
1638                         strncpy(prox_cfg.update_interval_str, optarg, sizeof(prox_cfg.update_interval_str));
1639                         break;
1640                 case 'o':
1641                         if (prox_cfg.flags & DSF_DAEMON)
1642                                 break;
1643
1644                         if (!strcmp(optarg, "curses")) {
1645                                 prox_cfg.ui = PROX_UI_CURSES;
1646                         }
1647                         else if (!strcmp(optarg, "cli")) {
1648                                 prox_cfg.ui = PROX_UI_CLI;
1649                         }
1650                         else if (!strcmp(optarg, "none")) {
1651                                 prox_cfg.ui = PROX_UI_NONE;
1652                         }
1653                         else {
1654                                 plog_err("Invalid local UI '%s', local UI can be 'curses', 'cli' or 'none'.", optarg);
1655                                 return -1;
1656                         }
1657                         break;
1658                 case 'q':
1659                         if (luaL_loadstring(prox_lua(), optarg)) {
1660                                 set_errf("Lua error: '%s'\n", lua_tostring(prox_lua(), -1));
1661                                 return -1;
1662                         }
1663
1664                         if (lua_pcall(prox_lua(), 0, LUA_MULTRET, 0)) {
1665                                 set_errf("Lua error: '%s'\n", lua_tostring(prox_lua(), -1));
1666                                 return -1;
1667                         }
1668
1669                         break;
1670                 case 'a':
1671                         /* autostart all cores */
1672                         prox_cfg.flags |= DSF_AUTOSTART;
1673                         break;
1674                 case 'e':
1675                         /* don't autostart */
1676                         prox_cfg.flags &= ~DSF_AUTOSTART;
1677                         break;
1678                 case 't':
1679                         prox_cfg.flags |= DSF_LISTEN_TCP;
1680                         break;
1681                 case 'u':
1682                         prox_cfg.flags |= DSF_LISTEN_UDS;
1683                         break;
1684                 case 'm':
1685                         /* list supported task modes and exit */
1686                         prox_cfg.flags |= DSF_LIST_TASK_MODES;
1687                         break;
1688                 case 's':
1689                         /* check configuration file syntax and exit */
1690                         prox_cfg.flags |= DSF_CHECK_SYNTAX;
1691                         break;
1692                 case 'i':
1693                         /* check initialization sequence and exit */
1694                         prox_cfg.flags |= DSF_CHECK_INIT;
1695                         break;
1696                 case 'w':
1697                         tmp = optarg;
1698                         tmp2 = 0;
1699                         if (strlen(tmp) >= 3 &&
1700                             (tmp2 = strchr(tmp, '='))) {
1701                                 *tmp2 = 0;
1702                                 tmp3[0] = '$';
1703                                 strncpy(tmp3 + 1, tmp, 63);
1704                                 plog_info("\tAdding variable: %s = %s\n", tmp3, tmp2 + 1);
1705                                 ret = add_var(tmp3, tmp2 + 1, 1);
1706                                 if (ret == -2) {
1707                                         plog_err("\tFailed to add variable, too many variables defines\n");
1708                                         return -1;
1709                                 }
1710                                 else if(ret == -3) {
1711                                         plog_err("\tFailed to add variable, already defined\n");
1712                                         return -1;
1713                                 }
1714                                 break;
1715                         }
1716                         /* fall-through */
1717                 default:
1718                         plog_err("\tUnknown option\n");
1719                         return -1;
1720                 }
1721         }
1722
1723         /* reset getopt lib for DPDK */
1724         optind = 0;
1725
1726         return 0;
1727 }
1728
1729 static int check_cfg(void)
1730 {
1731         /* Sanity check */
1732 #define RETURN_IF(cond, err)                    \
1733         if (cond) {                             \
1734                 plog_err(err);                  \
1735                 return -1;                      \
1736         };
1737
1738         RETURN_IF(rte_cfg.force_nchannel == 0, "\tError: number of memory channels not specified in [eal options] section\n");
1739         RETURN_IF(prox_cfg.master >= RTE_MAX_LCORE, "\tError: No master core specified (one core needs to have mode=master)\n");
1740
1741 #undef RETURN_IF
1742
1743         return 0;
1744 }
1745
1746 static int calc_tot_rxrings(void)
1747 {
1748         struct lcore_cfg *slconf, *dlconf;
1749         struct task_args *starg, *dtarg;
1750         uint32_t dlcore_id;
1751         uint8_t dtask_id;
1752         struct core_task ct;
1753
1754         dlconf = NULL;
1755         while (core_targ_next_early(&dlconf, &dtarg, 1) == 0) {
1756                 dtarg->tot_rxrings = 0;
1757         }
1758
1759         slconf = NULL;
1760         while (core_targ_next_early(&slconf, &starg, 1) == 0) {
1761                 for (uint8_t idx = 0; idx < MAX_PROTOCOLS; ++idx) {
1762                         for (uint8_t ring_idx = 0; ring_idx < starg->core_task_set[idx].n_elems; ++ring_idx) {
1763                                 ct = starg->core_task_set[idx].core_task[ring_idx];
1764                                 if (!prox_core_active(ct.core, 0)) {
1765                                         set_errf("Core %u is disabled but Core %u task %u is sending to it\n",
1766                                                  ct.core, slconf->id, starg->id);
1767                                         return -1;
1768                                 }
1769
1770                                 dlconf = &lcore_cfg_init[ct.core];
1771
1772                                 if (ct.task >= dlconf->n_tasks_all) {
1773                                         set_errf("Core %u task %u not enabled\n", ct.core, ct.task);
1774                                         return -1;
1775                                 }
1776
1777                                 dtarg = &dlconf->targs[ct.task];
1778
1779                                 /* Control rings are not relevant at this point. */
1780                                 if (ct.type)
1781                                         continue;
1782
1783                                 if (!(dtarg->flags & TASK_ARG_RX_RING)) {
1784                                         set_errf("Core %u task %u is not expecting to receive through a ring\n",
1785                                                  ct.core, ct.task);
1786                                         return -1;
1787                                 }
1788
1789                                 dtarg->tot_rxrings++;
1790                                 if (dtarg->tot_rxrings > MAX_RINGS_PER_TASK) {
1791                                         set_errf("Core %u task %u is receiving from too many tasks",
1792                                                  ct.core, ct.task);
1793                                         return -1;
1794                                 }
1795                         }
1796                 }
1797         }
1798
1799         return 0;
1800 }
1801
1802 static void prox_set_core_mask(void)
1803 {
1804         struct lcore_cfg *lconf;
1805
1806         prox_core_clr();
1807         for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
1808                 lconf = &lcore_cfg_init[lcore_id];
1809                 if (lconf->n_tasks_all > 0 && lconf->targs[0].mode != MASTER) {
1810                         prox_core_set_active(lcore_id);
1811                 }
1812         }
1813 }
1814
1815 static int is_using_no_drop(void)
1816 {
1817         uint32_t lcore_id;
1818         struct lcore_cfg *lconf;
1819         struct task_args *targs;
1820
1821         lcore_id = -1;
1822         while(prox_core_next(&lcore_id, 1) == 0) {
1823                 lconf = &lcore_cfg_init[lcore_id];
1824                 for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
1825                         targs = &lconf->targs[task_id];
1826                         if (!(targs->flags & TASK_ARG_DROP))
1827                                 return 1;
1828                 }
1829         }
1830         return 0;
1831 }
1832
1833 int prox_read_config_file(void)
1834 {
1835         set_global_defaults(&prox_cfg);
1836         set_task_defaults(&prox_cfg, lcore_cfg_init);
1837         set_port_defaults();
1838         plog_info("=== Parsing configuration file '%s' ===\n", cfg_file);
1839         struct cfg_file *pcfg = cfg_open(cfg_file);
1840         if (pcfg == NULL) {
1841                 return -1;
1842         }
1843
1844         struct cfg_section* config_sections[] = {
1845                 &lua_cfg          ,
1846                 &var_cfg          ,
1847                 &eal_default_cfg  ,
1848                 &cache_set_cfg    ,
1849                 &port_cfg         ,
1850                 &defaults_cfg     ,
1851                 &settings_cfg     ,
1852                 &core_cfg         ,
1853                 NULL
1854         };
1855
1856         for (struct cfg_section** section = config_sections; *section != NULL; ++section) {
1857                 const char* name = (*section)->name;
1858                 size_t len = strlen(name);
1859                 plog_info("\t*** Reading [%s] section%s ***\n", name, name[len - 1] == '#'? "s": "");
1860                 cfg_parse(pcfg, *section);
1861
1862                 if ((*section)->error) {
1863                         plog_err("At line %u, section [%s], entry %u: '%s'\n\t%s\n"
1864                                  , pcfg->err_line, pcfg->err_section, pcfg->err_entry + 1, pcfg->cur_line,
1865                                  strlen(get_parse_err())? get_parse_err() : err_str);
1866                         cfg_close(pcfg); /* cannot close before printing error, print uses internal buffer */
1867                         return -1;
1868                 }
1869         }
1870
1871         cfg_close(pcfg);
1872
1873         prox_set_core_mask();
1874
1875         if (is_using_no_drop()) {
1876                 prox_cfg.flags &= ~DSF_WAIT_ON_QUIT;
1877         }
1878
1879         if (calc_tot_rxrings()) {
1880                 plog_err("Error in configuration: %s\n", err_str);
1881                 return -1;
1882         }
1883
1884         return check_cfg();
1885 }
1886
1887 static void failed_rte_eal_init(__attribute__((unused))const char *prog_name)
1888 {
1889         plog_err("\tError in rte_eal_init()\n");
1890 }
1891
1892 int prox_setup_rte(const char *prog_name)
1893 {
1894         char *rte_argv[MAX_RTE_ARGV];
1895         char  rte_arg[MAX_RTE_ARGV][MAX_ARG_LEN];
1896         char tmp[PROX_CM_STR_LEN];
1897         /* create mask of used cores */
1898         plog_info("=== Setting up RTE EAL ===\n");
1899
1900         if (prox_cfg.flags & DSF_USE_DUMMY_CPU_TOPO) {
1901                 plog_info("Using dummy cpu topology\n");
1902                 snprintf(tmp, sizeof(tmp), "0x1");
1903         } else {
1904                 prox_core_to_hex(tmp, sizeof(tmp), 0);
1905                 plog_info("\tWorker threads core mask is %s\n", tmp);
1906                 prox_core_to_hex(tmp, sizeof(tmp), 1);
1907                 plog_info("\tWith master core index %u, full core mask is %s\n", prox_cfg.master, tmp);
1908         }
1909
1910         /* fake command line parameters for rte_eal_init() */
1911         int argc = 0;
1912         rte_argv[argc] = strdup(prog_name);
1913         sprintf(rte_arg[++argc], "-c%s", tmp);
1914         rte_argv[argc] = rte_arg[argc];
1915 #if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
1916         if (prox_cfg.flags & DSF_USE_DUMMY_CPU_TOPO)
1917                 sprintf(rte_arg[++argc], "--master-lcore=%u", 0);
1918         else
1919                 sprintf(rte_arg[++argc], "--master-lcore=%u", prox_cfg.master);
1920         rte_argv[argc] = rte_arg[argc];
1921 #else
1922         /* For old DPDK versions, the master core had to be the first
1923            core. */
1924         uint32_t first_core = -1;
1925
1926         if (prox_core_next(&first_core, 1) == -1) {
1927                 plog_err("Can't core ID of first core in use\n");
1928                 return -1;
1929         }
1930         if (first_core != prox_cfg.master) {
1931                 plog_err("The master core needs to be the first core (master core = %u, first core = %u).\n", first_core, prox_cfg.master);
1932                 return -1;
1933         }
1934 #endif
1935
1936         if (rte_cfg.memory) {
1937                 sprintf(rte_arg[++argc], "-m%u", rte_cfg.memory);
1938                 rte_argv[argc] = rte_arg[argc];
1939         }
1940
1941         if (rte_cfg.force_nchannel) {
1942                 sprintf(rte_arg[++argc], "-n%u", rte_cfg.force_nchannel);
1943                 rte_argv[argc] = rte_arg[argc];
1944         }
1945
1946         if (rte_cfg.force_nrank) {
1947                 sprintf(rte_arg[++argc], "-r%u", rte_cfg.force_nrank);
1948                 rte_argv[argc] = rte_arg[argc];
1949         }
1950
1951         if (rte_cfg.no_hugetlbfs) {
1952                 strcpy(rte_arg[++argc], "--no-huge");
1953                 rte_argv[argc] = rte_arg[argc];
1954         }
1955
1956         if (rte_cfg.no_pci) {
1957                 strcpy(rte_arg[++argc], "--no-pci");
1958                 rte_argv[argc] = rte_arg[argc];
1959         }
1960
1961         if (rte_cfg.no_hpet) {
1962                 strcpy(rte_arg[++argc], "--no-hpet");
1963                 rte_argv[argc] = rte_arg[argc];
1964         }
1965
1966         if (rte_cfg.no_shconf) {
1967                 strcpy(rte_arg[++argc], "--no-shconf");
1968                 rte_argv[argc] = rte_arg[argc];
1969         }
1970
1971         if (rte_cfg.eal != NULL) {
1972                 char *ptr = rte_cfg.eal;
1973                 char *ptr2;
1974                 while (ptr != NULL) {
1975                         while (isspace(*ptr))
1976                                 ptr++;
1977                         ptr2 = ptr;
1978                         ptr = strchr(ptr, ' ');
1979                         if (ptr) {
1980                                 *ptr++ = '\0';
1981                         }
1982                         strcpy(rte_arg[++argc], ptr2);
1983                         rte_argv[argc] = rte_arg[argc];
1984                 }
1985         }
1986
1987         if (rte_cfg.hugedir != NULL) {
1988                 strcpy(rte_arg[++argc], "--huge-dir");
1989                 rte_argv[argc] = rte_arg[argc];
1990                 rte_argv[++argc] = rte_cfg.hugedir;
1991         }
1992
1993         if (rte_cfg.no_output) {
1994                 rte_log_set_global_level(0);
1995         }
1996         /* init EAL */
1997         plog_info("\tEAL command line:");
1998         if (argc >= MAX_RTE_ARGV) {
1999                 plog_err("too many arguments for EAL\n");
2000                 return -1;
2001         }
2002
2003         for (int h = 0; h <= argc; ++h) {
2004                 plog_info(" %s", rte_argv[h]);
2005         }
2006         plog_info("\n");
2007
2008         rte_set_application_usage_hook(failed_rte_eal_init);
2009         if (rte_eal_init(++argc, rte_argv) < 0) {
2010                 plog_err("\tError in rte_eal_init()\n");
2011                 return -1;
2012         }
2013         plog_info("\tEAL Initialized\n");
2014
2015         if (prox_cfg.flags & DSF_USE_DUMMY_CPU_TOPO)
2016                 return 0;
2017
2018         /* check if all active cores are in enabled in DPDK */
2019         for (uint32_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
2020                 if (lcore_id == prox_cfg.master) {
2021                         if (!rte_lcore_is_enabled(lcore_id))
2022                                 return -1;
2023                 }
2024                 else if (rte_lcore_is_enabled(lcore_id) != prox_core_active(lcore_id, 0)) {
2025                         plog_err("\tFailed to enable lcore %u\n", lcore_id);
2026                         return -1;
2027                 }
2028                 else if (lcore_cfg_init[lcore_id].n_tasks_all != 0 && !rte_lcore_is_enabled(lcore_id)) {
2029                         plog_err("\tFailed to enable lcore %u\n", lcore_id);
2030                         return -1;
2031                 }
2032         }
2033         return 0;
2034 }