2 // Copyright (c) 2010-2020 Intel Corporation
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
8 // http://www.apache.org/licenses/LICENSE-2.0
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.
20 #include <rte_sched.h>
21 #include <rte_string_fns.h>
22 #include <rte_version.h>
24 #include "prox_malloc.h"
27 #include "prox_args.h"
28 #include "prox_assert.h"
33 #include "parse_utils.h"
34 #include "prox_port_cfg.h"
39 #include "prox_ipv6.h"
40 #include "prox_compat.h"
42 #define MAX_RTE_ARGV 64
43 #define MAX_ARG_LEN 64
51 #define STR_EQ(s1, s2) (!strcmp((s1), (s2)))
53 /* configuration files support */
54 static int get_rte_cfg(unsigned sindex, char *str, void *data);
55 static int get_global_cfg(unsigned sindex, char *str, void *data);
56 static int get_port_cfg(unsigned sindex, char *str, void *data);
57 static int get_defaults_cfg(unsigned sindex, char *str, void *data);
58 static int get_cache_set_cfg(unsigned sindex, char *str, void *data);
59 static int get_var_cfg(unsigned sindex, char *str, void *data);
60 static int get_lua_cfg(unsigned sindex, char *str, void *data);
61 static int get_core_cfg(unsigned sindex, char *str, void *data);
63 static const char *cfg_file = DEFAULT_CONFIG_FILE;
64 static struct rte_cfg rte_cfg;
65 struct prox_cache_set_cfg prox_cache_set_cfg[PROX_MAX_CACHE_SET];
67 static char format_err_str[1024];
68 static const char *err_str = "Unknown error";
70 static struct cfg_section eal_default_cfg = {
71 .name = "eal options",
72 .parser = get_rte_cfg,
79 static struct cfg_section port_cfg = {
81 .parser = get_port_cfg,
82 .data = &prox_port_cfg,
88 static struct cfg_section var_cfg = {
90 .parser = get_var_cfg,
97 static struct cfg_section cache_set_cfg = {
98 .name = "cache set #",
99 .parser = get_cache_set_cfg,
100 .data = &prox_cache_set_cfg,
106 static struct cfg_section defaults_cfg = {
108 .parser = get_defaults_cfg,
115 static struct cfg_section settings_cfg = {
117 .parser = get_global_cfg,
124 static struct cfg_section lua_cfg = {
126 .parser = get_lua_cfg,
133 static struct cfg_section core_cfg = {
135 .parser = get_core_cfg,
136 .data = lcore_cfg_init,
142 struct deferred_port {
143 struct task_args *targ;
148 static struct deferred_port deferred_port[PROX_MAX_PORTS];
149 static int n_deferred_ports = 0;
151 static void set_errf(const char *format, ...)
154 va_start(ap, format);
155 vsnprintf(format_err_str, sizeof(format_err_str), format, ap);
157 err_str = format_err_str;
160 /* [eal options] parser */
161 static int get_rte_cfg(__attribute__((unused))unsigned sindex, char *str, void *data)
163 struct rte_cfg *pconfig = (struct rte_cfg *)data;
165 if (str == NULL || pconfig == NULL) {
169 char *pkey = get_cfg_key(str);
171 set_errf("Missing key after option");
175 if (STR_EQ(str, "-m")) {
176 return parse_int(&pconfig->memory, pkey);
178 if (STR_EQ(str, "-n")) {
179 if (parse_int(&pconfig->force_nchannel, pkey)) {
182 if (pconfig->force_nchannel == 0) {
183 set_errf("Invalid number of memory channels");
188 if (STR_EQ(str, "-r")) {
189 if (parse_int(&pconfig->force_nrank, pkey)) {
192 if (pconfig->force_nrank == 0 || pconfig->force_nrank > 16) {
193 set_errf("Invalid number of memory ranks");
199 if (STR_EQ(str, "no-pci")) {
200 return parse_bool(&pconfig->no_pci, pkey);
202 if (STR_EQ(str, "no-hpet")) {
203 return parse_bool(&pconfig->no_hpet, pkey);
205 if (STR_EQ(str, "no-shconf")) {
206 return parse_bool(&pconfig->no_shconf, pkey);
208 if (STR_EQ(str, "no-huge")) {
209 return parse_bool(&pconfig->no_hugetlbfs, pkey);
211 if (STR_EQ(str, "no-output")) {
212 return parse_bool(&pconfig->no_output, pkey);
215 if (STR_EQ(str, "huge-dir")) {
216 if (pconfig->hugedir) {
217 free(pconfig->hugedir);
219 pconfig->hugedir = strdup(pkey);
223 if (STR_EQ(str, "eal")) {
224 char eal[MAX_STR_LEN_PROC];
229 if (parse_str(eal, pkey, sizeof(eal)))
232 strip_spaces(&pkey, 1);
234 pconfig->eal = strdup(pkey);
238 set_errf("Option '%s' is not known", str);
242 struct cfg_depr global_cfg_depr[] = {
243 {"virtualization", "This is now set automatically if needed"},
244 {"qinq_tag", "This option is deprecated"},
245 {"wait on quit", "This is now set automatically if needed"},
249 const char *get_cfg_dir(void)
251 static char dir[PATH_MAX];
252 size_t end = strlen(cfg_file) - 1;
253 while (end > 0 && cfg_file[end] != '/')
256 strncpy(dir, cfg_file, end);
260 static int get_lua_cfg(__attribute__((unused)) unsigned sindex, __attribute__((unused)) char *str, __attribute__((unused)) void *data)
264 if (NULL == getcwd(cwd, sizeof(cwd))) {
265 set_errf("Failed to get current directory while loading Lua file\n");
268 status = chdir(get_cfg_dir());
270 set_errf("Failed to change directory to '%s' while loading Lua file\n", get_cfg_dir());
274 struct lua_State *l = prox_lua();
277 prox_strncpy(str_cpy, str, sizeof(str_cpy));
278 uint32_t len = strlen(str_cpy);
279 str_cpy[len++] = '\n';
282 status = luaL_loadstring(l, str_cpy);
284 set_errf("Lua error: '%s'\n", lua_tostring(l, -1));
289 status = lua_pcall(l, 0, LUA_MULTRET, 0);
291 set_errf("Lua error: '%s'\n", lua_tostring(l, -1));
298 set_errf("Failed to restore current directory to '%s' while loading Lua file\n", cwd);
305 /* [global] parser */
306 static int get_global_cfg(__attribute__((unused))unsigned sindex, char *str, void *data)
308 struct prox_cfg *pset = (struct prox_cfg *)data;
310 if (str == NULL || pset == NULL) {
314 char *pkey = get_cfg_key(str);
316 set_errf("Missing key after option");
320 for (uint32_t i = 0; i < RTE_DIM(global_cfg_depr); ++i) {
321 if (STR_EQ(str, global_cfg_depr[i].opt)) {
322 set_errf("Option '%s' is deprecated%s%s",
323 global_cfg_depr[i].opt, strlen(global_cfg_depr[i].info)? ": ": "", global_cfg_depr[i].info);
328 if (STR_EQ(str, "name")) {
329 return parse_str(pset->name, pkey, sizeof(pset->name));
332 if (STR_EQ(str, "start time")) {
333 return parse_int(&pset->start_time, pkey);
336 if (STR_EQ(str, "duration time")) {
337 return parse_int(&pset->duration_time, pkey);
340 if (STR_EQ(str, "shuffle")) {
341 return parse_flag(&pset->flags, DSF_SHUFFLE, pkey);
343 if (STR_EQ(str, "disable cmt")) {
344 return parse_flag(&pset->flags, DSF_DISABLE_CMT, pkey);
346 if (STR_EQ(str, "mp rings")) {
347 return parse_flag(&pset->flags, DSF_MP_RINGS, pkey);
349 if (STR_EQ(str, "enable bypass")) {
350 return parse_flag(&pset->flags, DSF_ENABLE_BYPASS, pkey);
352 if (STR_EQ(str, "poll timeout")) {
353 return parse_int(&pset->poll_timeout, pkey);
355 if (STR_EQ(str, "heartbeat timeout")) {
356 return parse_int(&pset->heartbeat_timeout, pkey);
359 if (STR_EQ(str, "cpe table map")) {
360 /* The config defined ports through 0, 1, 2 ... which
361 need to be associated with ports. This is done
362 through defining it using "cpe table map=" */
363 return parse_port_name_list((uint32_t*)pset->cpe_table_ports, NULL, PROX_MAX_PORTS, pkey);
366 if (STR_EQ(str, "pre cmd")) {
370 if (STR_EQ(str, "unique mempool per socket")) {
371 return parse_flag(&pset->flags, UNIQUE_MEMPOOL_PER_SOCKET, pkey);
374 if (STR_EQ(str, "log buffer size")) {
375 if (parse_kmg(&pset->logbuf_size, pkey)) {
378 plog_info("Logging to buffer with size = %d\n", pset->logbuf_size);
382 set_errf("Option '%s' is not known", str);
386 /* [variable] parser */
387 static int get_var_cfg(__attribute__((unused)) unsigned sindex, char *str, __attribute__((unused)) void *data)
389 return add_var(str, get_cfg_key(str), 0);
392 /* [defaults] parser */
393 static int get_defaults_cfg(__attribute__((unused)) unsigned sindex, char *str, __attribute__((unused)) void *data)
398 pkey = get_cfg_key(str);
400 set_errf("Missing key after option");
404 if (STR_EQ(str, "mempool size")) {
406 if (parse_kmg(&val, pkey)) {
410 for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
411 struct lcore_cfg *cur_lcore_cfg_init = &lcore_cfg_init[lcore_id];
412 cur_lcore_cfg_init->id = lcore_id;
413 for (uint8_t task_id = 0; task_id < MAX_TASKS_PER_CORE; ++task_id) {
414 struct task_args *targ = &cur_lcore_cfg_init->targs[task_id];
422 if (STR_EQ(str, "qinq tag")) {
423 for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
424 struct lcore_cfg *cur_lcore_cfg_init = &lcore_cfg_init[lcore_id];
425 cur_lcore_cfg_init->id = lcore_id;
426 for (uint8_t task_id = 0; task_id < MAX_TASKS_PER_CORE; ++task_id) {
427 struct task_args *targ = &cur_lcore_cfg_init->targs[task_id];
428 parse_int(&targ->qinq_tag, pkey);
433 if (STR_EQ(str, "memcache size")) {
435 if (parse_kmg(&val, pkey)) {
439 for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
440 struct lcore_cfg *cur_lcore_cfg_init = &lcore_cfg_init[lcore_id];
441 cur_lcore_cfg_init->id = lcore_id;
442 for (uint8_t task_id = 0; task_id < MAX_TASKS_PER_CORE; ++task_id) {
443 struct task_args *targ = &cur_lcore_cfg_init->targs[task_id];
444 targ->nb_cache_mbuf = val;
450 set_errf("Option '%s' is not known", str);
454 /* [cache set] parser */
455 static int get_cache_set_cfg(unsigned sindex, char *str, void *data)
457 struct prox_cache_set_cfg *cfg = (struct prox_cache_set_cfg *)data;
459 uint8_t cur_if = sindex & ~CFG_INDEXED;
461 if (cur_if >= PROX_MAX_CACHE_SET) {
462 set_errf("Cache set ID is too high (max allowed %d)", PROX_MAX_CACHE_SET - 1 );
466 cfg = &prox_cache_set_cfg[cur_if];
468 if (str == NULL || data == NULL) {
472 char *pkey = get_cfg_key(str);
475 set_errf("Missing key after option");
479 if (STR_EQ(str, "mask")) {
481 int err = parse_int(&val, pkey);
487 plog_info("\tCache set %d has mask %x\n", cur_if, cfg->mask);
494 static int get_port_cfg(unsigned sindex, char *str, void *data)
496 struct prox_port_cfg *cfg = (struct prox_port_cfg *)data;
498 uint8_t cur_if = sindex & ~CFG_INDEXED;
500 if (cur_if >= PROX_MAX_PORTS) {
501 set_errf("Port ID is too high (max allowed %d)", PROX_MAX_PORTS - 1 );
505 cfg = &prox_port_cfg[cur_if];
507 if (str == NULL || data == NULL) {
511 char *pkey = get_cfg_key(str);
514 set_errf("Missing key after option");
518 if (STR_EQ(str, "mac")) {
519 if (STR_EQ(pkey, "hardware")) {
520 cfg->type = PROX_PORT_MAC_HW;
522 else if (STR_EQ(pkey, "random")) {
523 cfg->type = PROX_PORT_MAC_RAND;
526 cfg->type = PROX_PORT_MAC_SET;
527 if (parse_mac(&cfg->eth_addr, pkey)) {
532 else if (STR_EQ(str, "name")) {
534 prox_strncpy(cfg->name, pkey, MAX_NAME_SIZE);
535 PROX_ASSERT(cur_if < PROX_MAX_PORTS);
536 return add_port_name(cur_if, pkey);
538 else if (STR_EQ(str, "rx desc")) {
539 return parse_int(&cfg->n_rxd, pkey);
541 else if (STR_EQ(str, "tx desc")) {
542 return parse_int(&cfg->n_txd, pkey);
544 else if (STR_EQ(str, "promiscuous")) {
546 if (parse_bool(&val, pkey)) {
549 cfg->promiscuous = val;
551 else if (STR_EQ(str, "multicast")) {
553 if (cfg->nb_mc_addr >= NB_MCAST_ADDR) {
554 plog_err("too many multicast addresses\n");
557 if (parse_mac(&cfg->mc_addr[cfg->nb_mc_addr], pkey)) {
562 else if (STR_EQ(str, "lsc")) {
563 cfg->lsc_set_explicitely = 1;
565 if (parse_bool(&val, pkey)) {
570 else if (STR_EQ(str, "local ipv4")) {
571 return parse_ip(&cfg->ip, pkey);
573 else if (STR_EQ(str, "vdev")) {
574 prox_strncpy(cfg->vdev, pkey, MAX_NAME_SIZE);
576 #if RTE_VERSION >= RTE_VERSION_NUM(18,8,0,1)
577 else if (STR_EQ(str, "disable tx offload")) {
579 if (parse_int(&val, pkey)) {
583 cfg->disabled_tx_offload = val;
586 else if (STR_EQ(str, "strip crc")) {
588 if (parse_bool(&val, pkey)) {
591 #if defined(DEV_RX_OFFLOAD_CRC_STRIP)
593 cfg->requested_rx_offload |= DEV_RX_OFFLOAD_CRC_STRIP;
595 cfg->requested_rx_offload &= ~DEV_RX_OFFLOAD_CRC_STRIP;
597 #if defined (DEV_RX_OFFLOAD_KEEP_CRC)
599 cfg->requested_rx_offload &= ~DEV_RX_OFFLOAD_KEEP_CRC;
602 cfg->requested_rx_offload |= DEV_RX_OFFLOAD_KEEP_CRC;
606 else if (STR_EQ(str, "vlan tag")) {
607 return parse_int(&cfg->vlan_tag, pkey);
609 else if (STR_EQ(str, "vlan")) {
610 #if RTE_VERSION >= RTE_VERSION_NUM(18,8,0,1)
612 if (parse_bool(&val, pkey)) {
616 cfg->requested_rx_offload |= DEV_RX_OFFLOAD_VLAN_STRIP;
617 cfg->requested_tx_offload |= DEV_TX_OFFLOAD_VLAN_INSERT;
619 cfg->requested_rx_offload &= ~DEV_RX_OFFLOAD_VLAN_STRIP;
620 cfg->requested_tx_offload &= ~DEV_TX_OFFLOAD_VLAN_INSERT;
623 plog_warn("vlan option not supported : update DPDK at least to 18.08 to support this option\n");
626 else if (STR_EQ(str, "mtu size")) {
628 if (parse_int(&val, pkey)) {
633 // A frame of 1526 bytes (1500 bytes mtu, 14 bytes hdr, 4 bytes crc and 8 bytes vlan)
634 // should not be considered as a jumbo frame. However rte_ethdev.c considers that
635 // the max_rx_pkt_len for a non jumbo frame is 1518
636 cfg->port_conf.rxmode.max_rx_pkt_len = cfg->mtu + PROX_RTE_ETHER_HDR_LEN + PROX_RTE_ETHER_CRC_LEN;
637 if (cfg->port_conf.rxmode.max_rx_pkt_len > PROX_RTE_ETHER_MAX_LEN) {
638 cfg->requested_rx_offload |= DEV_RX_OFFLOAD_JUMBO_FRAME;
643 else if (STR_EQ(str, "rss")) {
645 if (parse_bool(&val, pkey)) {
649 cfg->port_conf.rxmode.mq_mode = ETH_MQ_RX_RSS;
650 cfg->port_conf.rx_adv_conf.rss_conf.rss_hf = ETH_RSS_IPV4;
653 else if (STR_EQ(str, "rx_ring")) {
654 parse_str(cfg->rx_ring, pkey, sizeof(cfg->rx_ring));
656 else if (STR_EQ(str, "tx_ring")) {
657 parse_str(cfg->tx_ring, pkey, sizeof(cfg->tx_ring));
663 static enum police_action str_to_color(const char *str)
665 if (STR_EQ(str, "green"))
667 if (STR_EQ(str, "yellow"))
669 if (STR_EQ(str, "red"))
671 if (STR_EQ(str, "drop"))
676 struct cfg_depr task_cfg_depr[] = {
680 struct cfg_depr core_cfg_depr[] = {
683 {"network side", ""},
687 static int get_core_cfg(unsigned sindex, char *str, void *data)
690 struct lcore_cfg *lconf = (struct lcore_cfg *)data;
692 if (str == NULL || lconf == NULL || !(sindex & CFG_INDEXED)) {
696 pkey = get_cfg_key(str);
698 set_errf("Missing key after option");
702 uint32_t ncore = sindex & ~CFG_INDEXED;
703 if (ncore >= RTE_MAX_LCORE) {
704 set_errf("Core index too high (max allowed %d)", RTE_MAX_LCORE - 1);
708 lconf = &lconf[ncore];
710 for (uint32_t i = 0; i < RTE_DIM(core_cfg_depr); ++i) {
711 if (STR_EQ(str, core_cfg_depr[i].opt)) {
712 set_errf("Option '%s' is deprecated%s%s",
713 core_cfg_depr[i].opt, strlen(core_cfg_depr[i].info)? ": ": "", core_cfg_depr[i].info);
719 lcore_to_socket_core_ht(ncore, buff, sizeof(buff));
721 if (STR_EQ(str, "task")) {
724 if (parse_int(&val, pkey)) {
727 if (val >= MAX_TASKS_PER_CORE) {
728 set_errf("Too many tasks for core (max allowed %d)", MAX_TASKS_PER_CORE - 1);
731 if (val != lconf->n_tasks_all) {
732 set_errf("Task ID skipped or defined twice");
736 lconf->active_task = val;
738 lconf->targs[lconf->active_task].task = lconf->active_task;
740 if (lconf->n_tasks_all < lconf->active_task + 1) {
741 lconf->n_tasks_all = lconf->active_task + 1;
746 struct task_args *targ = &lconf->targs[lconf->active_task];
747 if (STR_EQ(str, "tx ports from routing table")) {
748 uint32_t vals[PROX_MAX_PORTS];
750 if (!(targ->task_init->flag_features & TASK_FEATURE_ROUTING)) {
751 set_errf("tx port form route not supported mode %s", targ->task_init->mode_str);
755 if (parse_port_name_list(vals, &n_if, PROX_MAX_PORTS, pkey)) {
759 for (uint8_t i = 0; i < n_if; ++i) {
760 targ->tx_port_queue[i].port = vals[i];
763 targ->runtime_flags |= TASK_ROUTING;
766 if (STR_EQ(str, "tx ports from cpe table")) {
767 uint32_t vals[PROX_MAX_PORTS];
771 char* mapping_str = strstr(pkey, " remap=");
773 if (mapping_str != NULL) {
775 mapping_str += strlen(" remap=");
776 n_remap = parse_remap(targ->mapping, mapping_str);
779 if (parse_port_name_list(vals, &ret, PROX_MAX_PORTS, pkey)) {
783 if (n_remap != -1 && ret != (uint32_t)n_remap) {
784 set_errf("Expected %d remap elements but had %d", n_remap, ret);
788 for (uint8_t i = 0; i < ret; ++i) {
789 targ->tx_port_queue[i].port = vals[i];
791 /* default mapping this case is port0 -> port0 */
793 targ->mapping[vals[i]] = i;
797 targ->nb_txports = ret;
801 if (STR_EQ(str, "tx cores from routing table")) {
802 if (!(targ->task_init->flag_features & TASK_FEATURE_ROUTING)) {
803 set_errf("tx port form route not supported mode %s", targ->task_init->mode_str);
807 struct core_task_set *cts = &targ->core_task_set[0];
809 if (parse_task_set(cts, pkey))
812 if (cts->n_elems > MAX_WT_PER_LB) {
813 set_errf("Maximum worker threads allowed is %u but have %u", MAX_WT_PER_LB, cts->n_elems);
817 targ->nb_worker_threads = cts->n_elems;
818 targ->nb_txrings = cts->n_elems;
820 if (targ->nb_txrings > MAX_RINGS_PER_TASK) {
821 set_errf("Maximum allowed TX rings is %u but have %u", MAX_RINGS_PER_TASK, targ->nb_txrings);
825 targ->runtime_flags |= TASK_ROUTING;
828 if (STR_EQ(str, "tx cores from cpe table")) {
829 struct core_task_set *core_task_set = &targ->core_task_set[0];
833 mapping_str = strstr(pkey, " remap=");
834 if (mapping_str == NULL) {
835 set_errf("There is no default mapping for tx cores from cpe table. Please specify it through remap=");
839 mapping_str += strlen(" remap=");
840 ret = parse_remap(targ->mapping, mapping_str);
845 struct core_task_set *cts = &targ->core_task_set[0];
847 if (parse_task_set(cts, pkey))
849 if (cts->n_elems > MAX_RINGS_PER_TASK) {
850 set_errf("Maximum cores to route to is %u\n", MAX_RINGS_PER_TASK);
854 targ->nb_txrings = cts->n_elems;
856 if (ret != targ->nb_txrings) {
857 set_errf("Expecting same number of remaps as cores\n", str);
863 if (STR_EQ(str, "delay ms")) {
864 if (targ->delay_us) {
865 set_errf("delay ms and delay us are mutually exclusive\n", str);
869 int rc = parse_int(&delay_ms, pkey);
870 targ->delay_us = delay_ms * 1000;
873 if (STR_EQ(str, "delay us")) {
874 if (targ->delay_us) {
875 set_errf("delay ms and delay us are mutually exclusive\n", str);
878 return parse_int(&targ->delay_us, pkey);
880 if (STR_EQ(str, "random delay us")) {
881 return parse_int(&targ->random_delay_us, pkey);
883 if (STR_EQ(str, "cpe table timeout ms")) {
884 return parse_int(&targ->cpe_table_timeout_ms, pkey);
886 if (STR_EQ(str, "ctrl path polling frequency")) {
887 int rc = parse_int(&targ->ctrl_freq, pkey);
889 if (targ->ctrl_freq == 0) {
890 set_errf("ctrl frequency must be non null.");
897 if (STR_EQ(str, "handle arp")) {
898 return parse_flag(&targ->runtime_flags, TASK_CTRL_HANDLE_ARP, pkey);
900 if (STR_EQ(str, "fast path handle arp")) {
901 return parse_flag(&targ->runtime_flags, TASK_FP_HANDLE_ARP, pkey);
904 /* Using tx port name, only a _single_ port can be assigned to a task. */
905 if (STR_EQ(str, "tx port")) {
906 if (targ->nb_txports > 0) {
907 set_errf("Only one tx port can be defined per task. Use a LB task or routing instead.");
912 uint32_t ports[PROX_MAX_PORTS];
914 if(parse_port_name_list(ports, &n_if, PROX_MAX_PORTS, pkey)) {
915 // Port name not found, but could be a virtual device of a secondary process
916 // As DPDK not started yet, we can only check the config file to see whether we are a secondary process
918 (strstr(rte_cfg.eal, "secondary") || strstr(rte_cfg.eal, "auto")) &&
919 (n_deferred_ports < PROX_MAX_PORTS)) {
920 prox_strncpy(deferred_port[n_deferred_ports].name, pkey, sizeof(deferred_port[n_deferred_ports].name));
921 deferred_port[n_deferred_ports].is_rx_port = 0;
922 deferred_port[n_deferred_ports++].targ = targ;
928 PROX_ASSERT(n_if-1 < PROX_MAX_PORTS);
930 for (uint8_t i = 0; i < n_if; ++i) {
931 targ->tx_port_queue[i].port = ports[i];
936 targ->nb_worker_threads = targ->nb_txports;
941 if (STR_EQ(str, "rx ring")) {
943 int err = parse_bool(&val, pkey);
944 if (!err && val && targ->rx_port_queue[0].port != OUT_DISCARD) {
945 set_errf("Can't read both from internal ring and external port from the same task. Use multiple tasks instead.");
949 return parse_flag(&targ->flags, TASK_ARG_RX_RING, pkey);
951 if (STR_EQ(str, "private")) {
952 return parse_bool(&targ->use_src, pkey);
954 if (STR_EQ(str, "use src ip")) {
955 return parse_bool(&targ->use_src, pkey);
957 if (STR_EQ(str, "nat table")) {
958 return parse_str(targ->nat_table, pkey, sizeof(targ->nat_table));
960 if (STR_EQ(str, "rules")) {
961 return parse_str(targ->rules, pkey, sizeof(targ->rules));
963 if (STR_EQ(str, "route table")) {
964 return parse_str(targ->route_table, pkey, sizeof(targ->route_table));
966 if (STR_EQ(str, "dscp")) {
967 return parse_str(targ->dscp, pkey, sizeof(targ->dscp));
969 if (STR_EQ(str, "tun_bindings")) {
970 return parse_str(targ->tun_bindings, pkey, sizeof(targ->tun_bindings));
972 if (STR_EQ(str, "cpe table")) {
973 return parse_str(targ->cpe_table_name, pkey, sizeof(targ->cpe_table_name));
975 if (STR_EQ(str, "user table")) {
976 return parse_str(targ->user_table, pkey, sizeof(targ->user_table));
978 if (STR_EQ(str, "streams")) {
979 return parse_str(targ->streams, pkey, sizeof(targ->streams));
981 if (STR_EQ(str, "Unsollicited NA")) {
982 return parse_flag(&targ->flags, TASK_ARG_SEND_NA_AT_STARTUP, pkey);
984 if (STR_EQ(str, "local lpm")) {
985 return parse_flag(&targ->flags, TASK_ARG_LOCAL_LPM, pkey);
987 if (STR_EQ(str, "drop")) {
988 return parse_flag(&targ->flags, TASK_ARG_DROP, pkey);
990 if (STR_EQ(str, "loop")) {
991 parse_flag(&targ->loop, 1, pkey);
992 return parse_flag(&targ->loop, 1, pkey);
994 if (STR_EQ(str, "qinq")) {
995 return parse_flag(&targ->flags, TASK_ARG_QINQ_ACL, pkey);
997 if (STR_EQ(str, "bps")) {
998 return parse_u64(&targ->rate_bps, pkey);
1000 if (STR_EQ(str, "random")) {
1001 return parse_str(targ->rand_str[targ->n_rand_str++], pkey, sizeof(targ->rand_str[0]));
1003 if (STR_EQ(str, "rand_offset")) {
1004 if (targ->n_rand_str == 0) {
1005 set_errf("No random defined previously (use random=...)");
1009 return parse_int(&targ->rand_offset[targ->n_rand_str - 1], pkey);
1011 if (STR_EQ(str, "keep src mac")) {
1012 return parse_flag(&targ->flags, DSF_KEEP_SRC_MAC, pkey);
1014 if (STR_EQ(str, "pcap file")) {
1015 return parse_str(targ->pcap_file, pkey, sizeof(targ->pcap_file));
1017 if (STR_EQ(str, "imix")) {
1018 char pkey2[MAX_CFG_STRING_LEN], *ptr;
1019 if (parse_str(pkey2, pkey, sizeof(pkey2)) != 0) {
1020 set_errf("Error while parsing imix, too long\n");
1023 const size_t pkey_len = strlen(pkey2);
1024 targ->imix_nb_pkts = 0;
1026 while (targ->imix_nb_pkts < MAX_IMIX_PKTS) {
1027 if (parse_int(&targ->imix_pkt_sizes[targ->imix_nb_pkts], ptr) != 0)
1029 targ->imix_nb_pkts++;
1030 if ((ptr = strchr(ptr, ',')) == NULL)
1033 if (targ->imix_nb_pkts == MAX_IMIX_PKTS) {
1034 set_errf("Too many packet sizes specified");
1038 plog_info("%d IMIX packets:", targ->imix_nb_pkts);
1039 for (size_t i = 0; i < targ->imix_nb_pkts; ++i) {
1040 plog_info("%d ", targ->imix_pkt_sizes[i]);
1045 if (STR_EQ(str, "pkt inline")) {
1046 char pkey2[MAX_CFG_STRING_LEN];
1047 if (parse_str(pkey2, pkey, sizeof(pkey2)) != 0) {
1048 set_errf("Error while parsing pkt line, too long\n");
1052 const size_t pkey_len = strlen(pkey2);
1055 for (size_t i = 0; i < pkey_len; ++i) {
1056 if (pkey2[i] == ' ')
1059 if (i + 1 == pkey_len) {
1060 set_errf("Incomplete byte at character %z", i);
1066 if (pkey2[i] >= '0' && pkey2[i] <= '9') {
1067 byte = (pkey2[i] - '0') << 4;
1069 else if (pkey2[i] >= 'a' && pkey2[i] <= 'f') {
1070 byte = (pkey2[i] - 'a' + 10) << 4;
1072 else if (pkey2[i] >= 'A' && pkey2[i] <= 'F') {
1073 byte = (pkey2[i] - 'A' + 10) << 4;
1076 set_errf("Invalid character in pkt inline at byte %d (%c)", i, pkey2[i]);
1080 if (pkey2[i + 1] >= '0' && pkey2[i + 1] <= '9') {
1081 byte |= (pkey2[i + 1] - '0');
1083 else if (pkey2[i + 1] >= 'a' && pkey2[i + 1] <= 'f') {
1084 byte |= (pkey2[i + 1] - 'a' + 10);
1086 else if (pkey2[i + 1] >= 'A' && pkey2[i + 1] <= 'F') {
1087 byte |= (pkey2[i + 1] - 'A' + 10);
1090 set_errf("Invalid character in pkt inline at byte %d (%c)", i, pkey2[i + 1]);
1093 if (targ->pkt_size == sizeof(targ->pkt_inline)) {
1094 set_errf("Inline packet definition can't be longer than %u", sizeof(targ->pkt_inline));
1098 targ->pkt_inline[targ->pkt_size++] = byte;
1104 if (STR_EQ(str, "accuracy limit nsec")) {
1105 return parse_int(&targ->accuracy_limit_nsec, pkey);
1107 if (STR_EQ(str, "latency bucket size")) {
1108 return parse_int(&targ->bucket_size, pkey);
1110 if (STR_EQ(str, "latency buffer size")) {
1111 return parse_int(&targ->latency_buffer_size, pkey);
1113 if (STR_EQ(str, "accuracy pos")) {
1114 return parse_int(&targ->accur_pos, pkey);
1116 if (STR_EQ(str, "signature")) {
1117 return parse_int(&targ->sig, pkey);
1119 if (STR_EQ(str, "signature pos")) {
1120 return parse_int(&targ->sig_pos, pkey);
1122 if (STR_EQ(str, "lat pos")) {
1123 targ->lat_enabled = 1;
1124 return parse_int(&targ->lat_pos, pkey);
1126 if (STR_EQ(str, "packet id pos")) {
1127 return parse_int(&targ->packet_id_pos, pkey);
1129 if (STR_EQ(str, "probability")) {
1131 int rc = parse_float(&probability, pkey);
1132 if (probability == 0) {
1133 set_errf("Probability must be != 0\n");
1135 } else if (probability > 100.0) {
1136 set_errf("Probability must be < 100\n");
1139 targ->probability = probability * 10000;
1142 if (STR_EQ(str, "concur conn")) {
1143 return parse_int(&targ->n_concur_conn, pkey);
1145 if (STR_EQ(str, "max setup rate")) {
1146 return parse_int(&targ->max_setup_rate, pkey);
1148 if (STR_EQ(str, "pkt size")) {
1149 return parse_int(&targ->pkt_size, pkey);
1151 if (STR_EQ(str, "min bulk size")) {
1152 return parse_int(&targ->min_bulk_size, pkey);
1154 if (STR_EQ(str, "max bulk size")) {
1155 return parse_int(&targ->max_bulk_size, pkey);
1157 if (STR_EQ(str, "rx port")) {
1158 if (targ->flags & TASK_ARG_RX_RING) {
1159 set_errf("Can't read both from internal ring and external port from the same task. Use multiple tasks instead.");
1162 uint32_t vals[PROX_MAX_PORTS];
1165 if (parse_port_name_list(vals, &n_if, PROX_MAX_PORTS, pkey)) {
1166 // Port name not found, but could be a virtual device of a secondary process
1167 // As DPDK not started yet, we can only check the config file to see whether we are a secondary process
1169 (strstr(rte_cfg.eal, "secondary") || strstr(rte_cfg.eal, "auto")) &&
1170 (n_deferred_ports < PROX_MAX_PORTS)) {
1171 prox_strncpy(deferred_port[n_deferred_ports].name, pkey, sizeof(deferred_port[n_deferred_ports].name));
1172 deferred_port[n_deferred_ports].is_rx_port = 1;
1173 deferred_port[n_deferred_ports++].targ = targ;
1179 for (uint8_t i = 0; i < n_if; ++i) {
1180 PROX_ASSERT(vals[i] < PROX_MAX_PORTS);
1181 targ->rx_port_queue[i].port = vals[i];
1187 if (STR_EQ(str, "mode")) {
1188 /* Check deprecated task modes */
1190 int ret = parse_str(mode, pkey, sizeof(mode));
1194 for (uint32_t i = 0; i < RTE_DIM(task_cfg_depr); ++i) {
1195 if (STR_EQ(mode, task_cfg_depr[i].opt)) {
1196 set_errf("Task mode '%s' is deprecated%s%s",
1197 task_cfg_depr[i].opt, strlen(task_cfg_depr[i].info)? ": ": "", task_cfg_depr[i].info);
1202 /* master is a special mode that is always needed (cannot be turned off) */
1203 if (STR_EQ(mode, "master")) {
1204 prox_cfg.master = ncore;
1205 targ->mode = MASTER;
1206 if (lconf->n_tasks_all > 1 || targ->task != 0) {
1207 set_errf("Master core can only have one task\n");
1210 // Initialize number of tasks to 1 for master, even if no task specified
1211 lconf->n_tasks_all = 1;
1212 lconf->active_task = 0;
1213 lconf->targs[lconf->active_task].task = 0;
1214 struct task_init* task_init = to_task_init(mode, "");
1216 targ->mode = task_init->mode;
1218 targ->task_init = task_init;
1222 struct task_init* task_init = to_task_init(mode, "");
1224 targ->mode = task_init->mode;
1227 set_errf("Task mode '%s' is invalid", mode);
1231 targ->task_init = task_init;
1234 if (STR_EQ(str, "users")) {
1235 return parse_int(&targ->n_flows, pkey);
1238 if (STR_EQ(str, "mark")) {
1239 return parse_flag(&targ->runtime_flags, TASK_MARK, pkey);
1242 if (STR_EQ(str, "mark green")) {
1243 return parse_int(&targ->marking[0], pkey);
1246 if (STR_EQ(str, "mark yellow")) {
1247 return parse_int(&targ->marking[1], pkey);
1250 if (STR_EQ(str, "mark red")) {
1251 return parse_int(&targ->marking[2], pkey);
1254 if (STR_EQ(str, "tx cores")) {
1255 uint8_t dest_task = 0;
1256 /* if user did not specify, dest_port is left at default (first type) */
1257 uint8_t dest_proto = 0;
1258 uint8_t ctrl = CTRL_TYPE_DP;
1259 char *task_str = strstr(pkey, "proto=");
1261 task_str += strlen("proto=");
1263 if (STR_EQ(task_str, "ipv4")) {
1266 else if (STR_EQ(task_str, "arp")) {
1269 else if (STR_EQ(task_str, "ipv6")) {
1273 set_errf("proto needs to be either ipv4, arp or ipv6");
1279 task_str = strstr(pkey, "task=");
1285 task_str += strlen("task=");
1286 char *task_str_end = strstr(task_str, " ");
1290 if (0 == strlen(task_str)) {
1291 set_errf("Invalid task= syntax");
1295 switch (task_str[strlen(task_str) - 1]) {
1297 ctrl = CTRL_TYPE_PKT;
1300 ctrl = CTRL_TYPE_MSG;
1306 if (task_str[strlen(task_str) -1] < '0' ||
1307 task_str[strlen(task_str) -1] > '9') {
1308 set_errf("Unknown ring type %c.\n",
1309 task_str[strlen(task_str) - 1]);
1314 dest_task = atoi(task_str);
1315 if (dest_task >= MAX_TASKS_PER_CORE) {
1316 set_errf("Destination task too high (max allowed %d)", MAX_TASKS_PER_CORE - 1);
1324 struct core_task_set *cts = &targ->core_task_set[dest_proto];
1326 if (parse_task_set(cts, pkey))
1329 if (cts->n_elems > MAX_WT_PER_LB) {
1330 set_errf("Too many worker threads (max allowed %d)", MAX_WT_PER_LB - 1);
1334 targ->nb_worker_threads = cts->n_elems;
1335 targ->nb_txrings += cts->n_elems;
1339 if (STR_EQ(str, "tx crc")) {
1340 return parse_flag(&targ->runtime_flags, TASK_TX_CRC, pkey);
1342 if (STR_EQ(str, "ring size")) {
1343 return parse_int(&targ->ring_size, pkey);
1345 if (STR_EQ(str, "mempool size")) {
1346 return parse_kmg(&targ->nb_mbuf, pkey);
1349 else if (STR_EQ(str, "mbuf size")) {
1350 return parse_int(&targ->mbuf_size, pkey);
1352 if (STR_EQ(str, "memcache size")) {
1353 return parse_kmg(&targ->nb_cache_mbuf, pkey);
1356 if (STR_EQ(str, "byte offset")) {
1357 return parse_int(&targ->byte_offset, pkey);
1360 if (STR_EQ(str, "realtime scheduling")) {
1361 return parse_flag(&lconf->flags, LCONF_FLAG_SCHED_RR, pkey);
1363 if (STR_EQ(str, "name")) {
1364 return parse_str(lconf->name, pkey, sizeof(lconf->name));
1366 /* MPLS configuration */
1367 if (STR_EQ(str, "untag mpls")) {
1368 return parse_flag(&targ->runtime_flags, TASK_MPLS_TAGGING, pkey);
1371 if (STR_EQ(str, "add mpls")) {
1372 return parse_flag(&targ->runtime_flags, TASK_MPLS_TAGGING, pkey);
1375 if (STR_EQ(str, "ether type")) {
1376 return parse_int(&targ->etype, pkey);
1379 if (STR_EQ(str, "cache set")) {
1380 return parse_int(&lconf->cache_set, pkey);
1383 if (STR_EQ(str, "sub mode")) {
1384 const char* mode_str = targ->task_init->mode_str;
1385 const char *sub_mode_str = pkey;
1387 targ->task_init = to_task_init(mode_str, sub_mode_str);
1388 if (!targ->task_init) {
1389 if ((strcmp(sub_mode_str, "l3") != 0) && (strcmp(sub_mode_str, "ndp") != 0)) {
1390 set_errf("sub mode %s not supported for mode %s", sub_mode_str, mode_str);
1393 targ->task_init = to_task_init(mode_str, "");
1394 if (!targ->task_init) {
1395 set_errf("sub mode %s not supported for mode %s", sub_mode_str, mode_str);
1399 if (strcmp(sub_mode_str, "l3") == 0) {
1400 prox_cfg.flags |= DSF_L3_ENABLED;
1401 targ->flags |= TASK_ARG_L3;
1402 strcpy(targ->sub_mode_str, "l3");
1403 } else if (strcmp(sub_mode_str, "ndp") == 0) {
1404 prox_cfg.flags |= DSF_NDP_ENABLED;
1405 targ->flags |= TASK_ARG_NDP;
1406 strcpy(targ->sub_mode_str, "ndp");
1408 strcpy(targ->sub_mode_str, targ->task_init->sub_mode_str);
1413 if (STR_EQ(str, "mempool name")) {
1414 return parse_str(targ->pool_name, pkey, sizeof(targ->pool_name));
1416 if (STR_EQ(str, "dpi engine")) {
1417 return parse_str(targ->dpi_engine_path, pkey, sizeof(targ->dpi_engine_path));
1419 if (STR_EQ(str, "dpi engine arg")) {
1420 return parse_str(targ->dpi_engine_args[targ->n_dpi_engine_args++], pkey,
1421 sizeof(targ->dpi_engine_args[0]));
1423 if (STR_EQ(str, "dst mac")) { /* destination MAC address to be used for packets */
1424 if (parse_mac(&targ->edaddr, pkey)) {
1425 if (STR_EQ(pkey, "no")) {
1426 targ->flags |= TASK_ARG_DO_NOT_SET_DST_MAC;
1429 if (STR_EQ(pkey, "packet") == 0)
1434 targ->flags |= TASK_ARG_DST_MAC_SET;
1437 if (STR_EQ(str, "src mac")) {
1438 if (parse_mac(&targ->esaddr, pkey)) {
1439 if (STR_EQ(pkey, "no")) {
1440 targ->flags |= TASK_ARG_DO_NOT_SET_SRC_MAC;
1443 else if (STR_EQ(pkey, "packet"))
1445 else if (STR_EQ(pkey, "hw")) {
1446 targ->flags |= TASK_ARG_HW_SRC_MAC;
1452 targ->flags |= TASK_ARG_SRC_MAC_SET;
1455 if (STR_EQ(str, "igmp ipv4")) { /* IGMP Group */
1456 return parse_ip(&targ->igmp_address, pkey);
1458 if (STR_EQ(str, "gateway ipv4")) { /* Gateway IP address used when generating */
1459 if ((targ->flags & TASK_ARG_L3) == 0)
1460 plog_warn("gateway ipv4 configured but L3 sub mode not enabled\n");
1461 if (targ->local_ipv4)
1462 targ->local_prefix = 32;
1463 return parse_ip(&targ->gateway_ipv4, pkey);
1465 if (STR_EQ(str, "ipv6 router")) { /* we simulate an IPV6 router */
1466 int rc = parse_flag(&targ->ipv6_router, 1, pkey);
1467 if (!rc && targ->ipv6_router) {
1468 plog_info("\tipv6 router configured => NDP enabled\n");
1469 prox_cfg.flags |= DSF_NDP_ENABLED;
1470 targ->flags |= TASK_ARG_NDP;
1471 strcpy(targ->sub_mode_str, "ndp");
1475 if (STR_EQ(str, "local ipv4")) { /* source IP address to be used for packets */
1476 struct ip4_subnet cidr;
1477 if (parse_ip4_cidr(&cidr, pkey) != 0) {
1478 if (targ->gateway_ipv4)
1479 targ->local_prefix = 32;
1481 targ->local_prefix = 0;
1482 return parse_ip(&targ->local_ipv4, pkey);
1484 targ->local_ipv4 = cidr.ip;
1485 targ->local_prefix = cidr.prefix;
1489 if (STR_EQ(str, "remote ipv4")) { /* source IP address to be used for packets */
1490 return parse_ip(&targ->remote_ipv4, pkey);
1492 if (STR_EQ(str, "global ipv6")) {
1493 if (parse_ip6(&targ->global_ipv6, pkey) == 0) {
1494 plog_info("\tglobal ipv6 configured => NDP enabled\n");
1495 targ->flags |= TASK_ARG_NDP;
1496 prox_cfg.flags |= DSF_NDP_ENABLED;
1497 strcpy(targ->sub_mode_str, "ndp");
1499 plog_err("Unable to parse content of local ipv6: %s\n", pkey);
1504 if (STR_EQ(str, "local ipv6")) { /* source IPv6 address to be used for packets */
1505 if (parse_ip6(&targ->local_ipv6, pkey) == 0) {
1506 plog_info("\tlocal ipv6 configured => NDP enabled\n");
1507 targ->flags |= TASK_ARG_NDP;
1508 prox_cfg.flags |= DSF_NDP_ENABLED;
1509 strcpy(targ->sub_mode_str, "ndp");
1511 plog_err("Unable to parse content of local ipv6: %s\n", pkey);
1516 if (STR_EQ(str, "router prefix")) {
1517 if (parse_ip6(&targ->router_prefix, pkey) == 0) {
1518 plog_info("\trouter prefix set to "IPv6_BYTES_FMT" (%s)\n", IPv6_BYTES(targ->router_prefix.bytes), IP6_Canonical(&targ->router_prefix));
1520 plog_err("Unable to parse content of router prefix: %s\n", pkey);
1525 if (STR_EQ(str, "arp timeout"))
1526 return parse_int(&targ->reachable_timeout, pkey);
1527 if (STR_EQ(str, "arp update time"))
1528 return parse_int(&targ->arp_ndp_retransmit_timeout, pkey);
1529 if (STR_EQ(str, "number of packets"))
1530 return parse_int(&targ->n_pkts, pkey);
1531 if (STR_EQ(str, "pipes")) {
1533 int err = parse_int(&val, pkey);
1536 if (!val || !rte_is_power_of_2(val)) {
1537 set_errf("Number of pipes has to be power of 2 and not zero");
1541 targ->qos_conf.port_params.n_pipes_per_subport = val;
1544 if (STR_EQ(str, "queue size")) {
1546 int err = parse_int(&val, pkey);
1550 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1551 targ->qos_conf.subport_params[0].qsize[0] = val;
1552 targ->qos_conf.subport_params[0].qsize[1] = val;
1553 targ->qos_conf.subport_params[0].qsize[2] = val;
1554 targ->qos_conf.subport_params[0].qsize[3] = val;
1556 targ->qos_conf.port_params.qsize[0] = val;
1557 targ->qos_conf.port_params.qsize[1] = val;
1558 targ->qos_conf.port_params.qsize[2] = val;
1559 targ->qos_conf.port_params.qsize[3] = val;
1563 if (STR_EQ(str, "subport tb rate")) {
1564 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1565 return parse_u64(&targ->qos_conf.subport_params[0].tb_rate, pkey);
1567 return parse_int(&targ->qos_conf.subport_params[0].tb_rate, pkey);
1570 if (STR_EQ(str, "subport tb size")) {
1571 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1572 return parse_u64(&targ->qos_conf.subport_params[0].tb_size, pkey);
1574 return parse_int(&targ->qos_conf.subport_params[0].tb_size, pkey);
1577 if (STR_EQ(str, "subport tc 0 rate")) {
1578 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1579 return parse_u64(&targ->qos_conf.subport_params[0].tc_rate[0], pkey);
1581 return parse_int(&targ->qos_conf.subport_params[0].tc_rate[0], pkey);
1584 if (STR_EQ(str, "subport tc 1 rate")) {
1585 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1586 return parse_u64(&targ->qos_conf.subport_params[0].tc_rate[1], pkey);
1588 return parse_int(&targ->qos_conf.subport_params[0].tc_rate[1], pkey);
1591 if (STR_EQ(str, "subport tc 2 rate")) {
1592 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1593 return parse_u64(&targ->qos_conf.subport_params[0].tc_rate[2], pkey);
1595 return parse_int(&targ->qos_conf.subport_params[0].tc_rate[2], pkey);
1598 if (STR_EQ(str, "subport tc 3 rate")) {
1599 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1600 return parse_u64(&targ->qos_conf.subport_params[0].tc_rate[3], pkey);
1602 return parse_int(&targ->qos_conf.subport_params[0].tc_rate[3], pkey);
1606 if (STR_EQ(str, "subport tc rate")) {
1608 int err = parse_int(&val, pkey);
1613 targ->qos_conf.subport_params[0].tc_rate[0] = val;
1614 targ->qos_conf.subport_params[0].tc_rate[1] = val;
1615 targ->qos_conf.subport_params[0].tc_rate[2] = val;
1616 targ->qos_conf.subport_params[0].tc_rate[3] = val;
1620 if (STR_EQ(str, "subport tc period")) {
1621 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1622 return parse_u64(&targ->qos_conf.subport_params[0].tc_period, pkey);
1624 return parse_int(&targ->qos_conf.subport_params[0].tc_period, pkey);
1627 if (STR_EQ(str, "pipe tb rate")) {
1628 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1629 return parse_u64(&targ->qos_conf.pipe_params[0].tb_rate, pkey);
1631 return parse_int(&targ->qos_conf.pipe_params[0].tb_rate, pkey);
1634 if (STR_EQ(str, "pipe tb size")) {
1635 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1636 return parse_u64(&targ->qos_conf.pipe_params[0].tb_size, pkey);
1638 return parse_int(&targ->qos_conf.pipe_params[0].tb_size, pkey);
1641 if (STR_EQ(str, "pipe tc rate")) {
1643 int err = parse_int(&val, pkey);
1648 targ->qos_conf.pipe_params[0].tc_rate[0] = val;
1649 targ->qos_conf.pipe_params[0].tc_rate[1] = val;
1650 targ->qos_conf.pipe_params[0].tc_rate[2] = val;
1651 targ->qos_conf.pipe_params[0].tc_rate[3] = val;
1654 if (STR_EQ(str, "pipe tc 0 rate")) {
1655 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1656 return parse_u64(&targ->qos_conf.pipe_params[0].tc_rate[0], pkey);
1658 return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[0], pkey);
1661 if (STR_EQ(str, "pipe tc 1 rate")) {
1662 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1663 return parse_u64(&targ->qos_conf.pipe_params[0].tc_rate[1], pkey);
1665 return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[1], pkey);
1668 if (STR_EQ(str, "pipe tc 2 rate")) {
1669 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1670 return parse_u64(&targ->qos_conf.pipe_params[0].tc_rate[2], pkey);
1672 return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[2], pkey);
1675 if (STR_EQ(str, "pipe tc 3 rate")) {
1676 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1677 return parse_u64(&targ->qos_conf.pipe_params[0].tc_rate[3], pkey);
1679 return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[3], pkey);
1682 if (STR_EQ(str, "pipe tc period")) {
1683 #if RTE_VERSION >= RTE_VERSION_NUM(19,11,0,0)
1684 return parse_u64(&targ->qos_conf.pipe_params[0].tc_period, pkey);
1686 return parse_int(&targ->qos_conf.pipe_params[0].tc_period, pkey);
1689 if (STR_EQ(str, "police action")) {
1690 char *in = strstr(pkey, " io=");
1692 set_errf("Need to specify io colors using io=in_color,out_color\n");
1696 in += strlen(" io=");
1698 char *out = strstr(in, ",");
1700 set_errf("Output color not specified\n");
1705 enum police_action in_color = str_to_color(in);
1706 enum police_action out_color = str_to_color(out);
1708 if (in_color == ACT_INVALID) {
1709 set_errf("Invalid input color %s. Expected green, yellow or red", in);
1712 if (out_color == ACT_INVALID) {
1713 set_errf("Invalid output color %s. Expected green, yellow or red", out);
1716 enum police_action action = str_to_color(pkey);
1717 if (action == ACT_INVALID) {
1718 set_errf("Error action %s. Expected green, yellow, red or drop", pkey);
1721 targ->police_act[in_color][out_color] = action;
1725 if (STR_EQ(str, "qinq tag")) {
1726 return parse_int(&targ->qinq_tag, pkey);
1728 if (STR_EQ(str, "cir")) {
1729 return parse_int(&targ->cir, pkey);
1731 if (STR_EQ(str, "cbs")) {
1732 return parse_int(&targ->cbs, pkey);
1734 if (STR_EQ(str, "pir")) {
1735 return parse_int(&targ->pir, pkey);
1737 if (STR_EQ(str, "pbs")) {
1738 return parse_int(&targ->pbs, pkey);
1740 if (STR_EQ(str, "ebs")) {
1741 return parse_int(&targ->ebs, pkey);
1743 uint32_t queue_id = 0;
1744 if (sscanf(str, "queue %d weight", &queue_id) == 1) {
1746 int err = parse_int(&val, pkey);
1750 if (queue_id >= RTE_SCHED_BE_QUEUES_PER_PIPE) {
1751 set_errf("queue_id must be < %d", RTE_SCHED_BE_QUEUES_PER_PIPE);
1754 targ->qos_conf.pipe_params[0].wrr_weights[queue_id] = val;
1757 if (STR_EQ(str, "classify")) {
1758 if (!(targ->task_init->flag_features & TASK_FEATURE_CLASSIFY)) {
1759 set_errf("Classify is not supported in '%s' mode", targ->task_init->mode_str);
1763 return parse_flag(&targ->runtime_flags, TASK_CLASSIFY, pkey);
1765 if (STR_EQ(str, "flow table size")) {
1766 return parse_int(&targ->flow_table_size, pkey);
1769 if (STR_EQ(str, "tbf rate")) {
1770 return parse_int(&targ->tb_rate, pkey);
1772 if (STR_EQ(str, "tbf size")) {
1773 return parse_int(&targ->tb_size, pkey);
1776 if (STR_EQ(str, "max rules")) {
1777 return parse_int(&targ->n_max_rules, pkey);
1780 if (STR_EQ(str, "tunnel hop limit")) {
1782 int err = parse_int(&val, pkey);
1786 targ->tunnel_hop_limit = val;
1790 if (STR_EQ(str, "lookup port mask")) {
1792 int err = parse_int(&val, pkey);
1796 targ->lookup_port_mask = val;
1800 if (STR_EQ(str, "irq debug")) {
1801 parse_int(&targ->irq_debug, pkey);
1805 set_errf("Option '%s' is not known", str);
1806 /* fail on unknown keys */
1810 static int str_is_number(const char *in)
1814 for (size_t i = 0; i < strlen(in); ++i) {
1815 if (!dot_once && in[i] == '.') {
1820 if (in[i] < '0' || in[i] > '9')
1827 /* command line parameters parsing procedure */
1828 int prox_parse_args(int argc, char **argv)
1834 /* Default settings */
1835 prox_cfg.flags |= DSF_AUTOSTART | DSF_WAIT_ON_QUIT;
1836 prox_cfg.ui = PROX_UI_CURSES;
1838 plog_info("\tCommand line:");
1839 for (i = 0; i < argc; ++i) {
1840 plog_info(" %s", argv[i]);
1844 while ((opt = getopt(argc, argv, "f:dnzpo:tkuar:emsiw:l:v:q:")) != EOF) {
1847 /* path to config file */
1850 for (size_t i = 0; i < strlen(cfg_file); ++i) {
1851 if (cfg_file[i] == '/') {
1856 prox_strncpy(prox_cfg.name, cfg_file + offset, MAX_NAME_SIZE);
1859 plog_set_lvl(atoi(optarg));
1862 prox_cfg.log_name_pid = 0;
1863 prox_strncpy(prox_cfg.log_name, optarg, MAX_NAME_SIZE);
1866 prox_cfg.log_name_pid = 1;
1869 prox_cfg.use_stats_logger = 1;
1872 prox_cfg.flags |= DSF_DAEMON;
1873 prox_cfg.ui = PROX_UI_NONE;
1876 prox_cfg.flags |= DSF_USE_DUMMY_CPU_TOPO;
1877 prox_cfg.flags |= DSF_CHECK_INIT;
1880 prox_cfg.flags |= DSF_USE_DUMMY_DEVICES;
1883 if (!str_is_number(optarg) || strlen(optarg) > 11)
1885 prox_strncpy(prox_cfg.update_interval_str, optarg, sizeof(prox_cfg.update_interval_str));
1888 if (prox_cfg.flags & DSF_DAEMON)
1891 if (!strcmp(optarg, "curses")) {
1892 prox_cfg.ui = PROX_UI_CURSES;
1894 else if (!strcmp(optarg, "cli")) {
1895 prox_cfg.ui = PROX_UI_CLI;
1897 else if (!strcmp(optarg, "none")) {
1898 prox_cfg.ui = PROX_UI_NONE;
1901 plog_err("Invalid local UI '%s', local UI can be 'curses', 'cli' or 'none'.", optarg);
1906 if (luaL_loadstring(prox_lua(), optarg)) {
1907 set_errf("Lua error: '%s'\n", lua_tostring(prox_lua(), -1));
1911 if (lua_pcall(prox_lua(), 0, LUA_MULTRET, 0)) {
1912 set_errf("Lua error: '%s'\n", lua_tostring(prox_lua(), -1));
1918 /* autostart all cores */
1919 prox_cfg.flags |= DSF_AUTOSTART;
1922 /* don't autostart */
1923 prox_cfg.flags &= ~DSF_AUTOSTART;
1926 prox_cfg.flags |= DSF_LISTEN_TCP;
1929 prox_cfg.flags |= DSF_LISTEN_UDS;
1932 /* list supported task modes and exit */
1933 prox_cfg.flags |= DSF_LIST_TASK_MODES;
1936 /* check configuration file syntax and exit */
1937 prox_cfg.flags |= DSF_CHECK_SYNTAX;
1940 /* check initialization sequence and exit */
1941 prox_cfg.flags |= DSF_CHECK_INIT;
1946 if (strlen(tmp) >= 3 &&
1947 (tmp2 = strchr(tmp, '='))) {
1950 prox_strncpy(tmp3 + 1, tmp, 63);
1951 plog_info("\tAdding variable: %s = %s\n", tmp3, tmp2 + 1);
1952 ret = add_var(tmp3, tmp2 + 1, 1);
1954 plog_err("\tFailed to add variable, too many variables defines\n");
1957 else if(ret == -3) {
1958 plog_err("\tFailed to add variable, already defined\n");
1965 plog_err("\tUnknown option\n");
1970 /* reset getopt lib for DPDK */
1976 static int check_cfg(void)
1979 #define RETURN_IF(cond, err) \
1985 RETURN_IF(rte_cfg.force_nchannel == 0, "\tError: number of memory channels not specified in [eal options] section\n");
1986 RETURN_IF(prox_cfg.master >= RTE_MAX_LCORE, "\tError: No master core specified (one core needs to have mode=master)\n");
1993 static int calc_tot_rxrings(void)
1995 struct lcore_cfg *slconf, *dlconf;
1996 struct task_args *starg, *dtarg;
1999 struct core_task ct;
2002 while (core_targ_next_early(&dlconf, &dtarg, 1) == 0) {
2003 dtarg->tot_rxrings = 0;
2007 while (core_targ_next_early(&slconf, &starg, 1) == 0) {
2008 for (uint8_t idx = 0; idx < MAX_PROTOCOLS; ++idx) {
2009 for (uint8_t ring_idx = 0; ring_idx < starg->core_task_set[idx].n_elems; ++ring_idx) {
2010 ct = starg->core_task_set[idx].core_task[ring_idx];
2011 if (!prox_core_active(ct.core, 0)) {
2012 set_errf("Core %u is disabled but Core %u task %u is sending to it\n",
2013 ct.core, slconf->id, starg->id);
2017 dlconf = &lcore_cfg_init[ct.core];
2019 if (ct.task >= dlconf->n_tasks_all) {
2020 set_errf("Core %u task %u not enabled\n", ct.core, ct.task);
2024 dtarg = &dlconf->targs[ct.task];
2026 /* Control rings are not relevant at this point. */
2030 if (!(dtarg->flags & TASK_ARG_RX_RING)) {
2031 set_errf("Core %u task %u is not expecting to receive through a ring\n",
2036 dtarg->tot_rxrings++;
2037 if (dtarg->tot_rxrings > MAX_RINGS_PER_TASK) {
2038 set_errf("Core %u task %u is receiving from too many tasks",
2049 static void prox_set_core_mask(void)
2051 struct lcore_cfg *lconf;
2054 for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
2055 lconf = &lcore_cfg_init[lcore_id];
2056 if (lconf->n_tasks_all > 0 && lconf->targs[0].mode != MASTER) {
2057 prox_core_set_active(lcore_id);
2062 static int is_using_no_drop(void)
2065 struct lcore_cfg *lconf;
2066 struct task_args *targs;
2069 while(prox_core_next(&lcore_id, 1) == 0) {
2070 lconf = &lcore_cfg_init[lcore_id];
2071 for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
2072 targs = &lconf->targs[task_id];
2073 if (!(targs->flags & TASK_ARG_DROP))
2080 int prox_read_config_file(void)
2082 set_global_defaults(&prox_cfg);
2083 set_task_defaults(&prox_cfg, lcore_cfg_init);
2084 set_port_defaults();
2085 plog_info("=== Parsing configuration file '%s' ===\n", cfg_file);
2086 struct cfg_file *pcfg = cfg_open(cfg_file);
2091 struct cfg_section* config_sections[] = {
2103 for (struct cfg_section** section = config_sections; *section != NULL; ++section) {
2104 const char* name = (*section)->name;
2105 size_t len = strlen(name);
2106 plog_info("\t*** Reading [%s] section%s ***\n", name, name[len - 1] == '#'? "s": "");
2107 cfg_parse(pcfg, *section);
2109 if ((*section)->error) {
2110 plog_err("At line %u, section [%s], entry %u: '%s'\n\t%s\n"
2111 , pcfg->err_line, pcfg->err_section, pcfg->err_entry + 1, pcfg->cur_line,
2112 strlen(get_parse_err())? get_parse_err() : err_str);
2113 cfg_close(pcfg); /* cannot close before printing error, print uses internal buffer */
2120 prox_set_core_mask();
2122 if (is_using_no_drop()) {
2123 prox_cfg.flags &= ~DSF_WAIT_ON_QUIT;
2126 if (calc_tot_rxrings()) {
2127 plog_err("Error in configuration: %s\n", err_str);
2134 static void failed_rte_eal_init(__attribute__((unused))const char *prog_name)
2136 plog_err("\tError in rte_eal_init()\n");
2139 int prox_setup_rte(const char *prog_name)
2141 char *rte_argv[MAX_RTE_ARGV];
2142 char rte_arg[MAX_RTE_ARGV][MAX_ARG_LEN];
2143 char tmp[PROX_CM_STR_LEN];
2144 /* create mask of used cores */
2145 plog_info("=== Setting up RTE EAL ===\n");
2147 if (prox_cfg.flags & DSF_USE_DUMMY_CPU_TOPO) {
2148 plog_info("Using dummy cpu topology\n");
2149 snprintf(tmp, sizeof(tmp), "0x1");
2151 prox_core_to_hex(tmp, sizeof(tmp), 0);
2152 plog_info("\tWorker threads core mask is %s\n", tmp);
2153 prox_core_to_hex(tmp, sizeof(tmp), 1);
2154 plog_info("\tWith master core index %u, full core mask is %s\n", prox_cfg.master, tmp);
2157 /* fake command line parameters for rte_eal_init() */
2159 rte_argv[argc] = strdup(prog_name);
2160 sprintf(rte_arg[++argc], "-c%s", tmp);
2161 rte_argv[argc] = rte_arg[argc];
2162 #if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
2163 if (prox_cfg.flags & DSF_USE_DUMMY_CPU_TOPO)
2164 sprintf(rte_arg[++argc], "--master-lcore=%u", 0);
2166 sprintf(rte_arg[++argc], "--master-lcore=%u", prox_cfg.master);
2167 rte_argv[argc] = rte_arg[argc];
2169 /* For old DPDK versions, the master core had to be the first
2171 uint32_t first_core = -1;
2173 if (prox_core_next(&first_core, 1) == -1) {
2174 plog_err("Can't core ID of first core in use\n");
2177 if (first_core != prox_cfg.master) {
2178 plog_err("The master core needs to be the first core (master core = %u, first core = %u).\n", first_core, prox_cfg.master);
2183 if (rte_cfg.memory) {
2184 sprintf(rte_arg[++argc], "-m%u", rte_cfg.memory);
2185 rte_argv[argc] = rte_arg[argc];
2188 if (rte_cfg.force_nchannel) {
2189 sprintf(rte_arg[++argc], "-n%u", rte_cfg.force_nchannel);
2190 rte_argv[argc] = rte_arg[argc];
2193 if (rte_cfg.force_nrank) {
2194 sprintf(rte_arg[++argc], "-r%u", rte_cfg.force_nrank);
2195 rte_argv[argc] = rte_arg[argc];
2198 if (rte_cfg.no_hugetlbfs) {
2199 strcpy(rte_arg[++argc], "--no-huge");
2200 rte_argv[argc] = rte_arg[argc];
2203 if (rte_cfg.no_pci) {
2204 strcpy(rte_arg[++argc], "--no-pci");
2205 rte_argv[argc] = rte_arg[argc];
2208 if (rte_cfg.no_hpet) {
2209 strcpy(rte_arg[++argc], "--no-hpet");
2210 rte_argv[argc] = rte_arg[argc];
2213 if (rte_cfg.no_shconf) {
2214 strcpy(rte_arg[++argc], "--no-shconf");
2215 rte_argv[argc] = rte_arg[argc];
2218 if (rte_cfg.eal != NULL) {
2219 char *ptr = rte_cfg.eal;
2221 while (ptr != NULL) {
2222 while (isspace(*ptr))
2225 ptr = strchr(ptr, ' ');
2229 strcpy(rte_arg[++argc], ptr2);
2230 rte_argv[argc] = rte_arg[argc];
2234 if (rte_cfg.hugedir != NULL) {
2235 strcpy(rte_arg[++argc], "--huge-dir");
2236 rte_argv[argc] = rte_arg[argc];
2237 rte_argv[++argc] = rte_cfg.hugedir;
2240 if (rte_cfg.no_output) {
2241 rte_log_set_global_level(0);
2244 plog_info("\tEAL command line:");
2245 if (argc >= MAX_RTE_ARGV) {
2246 plog_err("too many arguments for EAL\n");
2250 for (int h = 0; h <= argc; ++h) {
2251 plog_info(" %s", rte_argv[h]);
2255 rte_set_application_usage_hook(failed_rte_eal_init);
2256 if (rte_eal_init(++argc, rte_argv) < 0) {
2257 plog_err("\tError in rte_eal_init()\n");
2260 plog_info("\tEAL Initialized\n");
2262 if (prox_cfg.flags & DSF_USE_DUMMY_CPU_TOPO)
2265 /* check if all active cores are in enabled in DPDK */
2266 for (uint32_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
2267 if (lcore_id == prox_cfg.master) {
2268 if (!rte_lcore_is_enabled(lcore_id))
2271 else if (rte_lcore_is_enabled(lcore_id) != prox_core_active(lcore_id, 0)) {
2272 plog_err("\tFailed to enable lcore %u\n", lcore_id);
2275 else if (lcore_cfg_init[lcore_id].n_tasks_all != 0 && !rte_lcore_is_enabled(lcore_id)) {
2276 plog_err("\tFailed to enable lcore %u\n", lcore_id);
2281 for (int i = 0; i < n_deferred_ports; i++) {
2282 if (rte_eth_dev_get_port_by_name(deferred_port[i].name, &port_id) != 0) {
2283 plog_err("Did not find port name %s used while reading %s\n", deferred_port[i].name, deferred_port[i].is_rx_port ? "rx port" : "tx_port");
2286 plog_info("\tport %s is port id %d\n", deferred_port[i].name, port_id);
2287 if (deferred_port[i].is_rx_port) {
2288 deferred_port[i].targ->rx_port_queue[0].port = port_id;
2289 deferred_port[i].targ->nb_rxports = 1;
2291 deferred_port[i].targ->tx_port_queue[0].port = port_id;
2292 deferred_port[i].targ->nb_txports = 1;