2 // Copyright (c) 2010-2017 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.
25 #include <rte_ether.h>
26 #include <rte_string_fns.h>
31 #include "parse_utils.h"
32 #include "prox_globals.h"
36 #include "prox_lua_types.h"
37 #include "prox_compat.h"
39 #define MAX_NB_PORT_NAMES PROX_MAX_PORTS
40 #define MAX_LEN_PORT_NAME 24
41 #define MAX_LEN_VAR_NAME 24
42 #define MAX_LEN_VAL 512
43 #define MAX_NB_VARS 32
45 #if MAX_WT_PER_LB > MAX_INDEX
46 #error MAX_WT_PER_LB > MAX_INDEX
49 /* The CPU topology of the system is used to parse "socket
50 notation". This notation allows to refer to cores on specific
51 sockets and the hyper-thread of those cores. The CPU topology is
52 loaded only if the socket notation is used at least once. */
55 int socket[MAX_SOCKETS][RTE_MAX_LCORE][2];
56 uint32_t n_cores[MAX_SOCKETS];
60 struct cpu_topology cpu_topo;
64 char name[MAX_LEN_PORT_NAME];
67 static struct port_name port_names[MAX_NB_PORT_NAMES];
68 static uint8_t nb_port_names;
72 char name[MAX_LEN_VAR_NAME];
73 char val[MAX_LEN_VAL];
76 static struct var vars[MAX_NB_VARS];
77 static uint8_t nb_vars;
79 static char format_err_str[256];
80 static const char *err_str = "";
82 const char *get_parse_err(void)
87 static int read_cpu_topology(void);
89 static int parse_core(int *socket, int *core, int *ht, const char* str);
91 static void set_errf(const char *format, ...)
95 vsnprintf(format_err_str, sizeof(format_err_str), format, ap);
97 err_str = format_err_str;
100 static struct var *var_lookup(const char *name)
102 for (uint8_t i = 0; i < nb_vars; ++i) {
103 if (!strcmp(name, vars[i].name)) {
110 int parse_single_var(char *val, size_t len, const char *name)
114 match = var_lookup(name);
116 if (strlen(match->val) + 1 > len) {
117 set_errf("Variables '%s' with value '%s' is too long\n",
118 match->name, match->val);
121 prox_strncpy(val, match->val, len);
125 /* name + 1 to skip leading '$' */
126 if (lua_to_string(prox_lua(), GLOBAL, name + 1, val, len) >= 0)
130 set_errf("Variable '%s' not defined!", name);
134 /* Replace $... and each occurrence of ${...} with variable values */
135 int parse_vars(char *val, size_t len, const char *name)
137 static char result[MAX_CFG_STRING_LEN];
138 static char cur_var[MAX_CFG_STRING_LEN];
139 char parsed[MAX_CFG_STRING_LEN];
140 size_t name_len = strlen(name);
141 enum parse_vars_state {NO_VAR, WHOLE_VAR, INLINE_VAR} state = NO_VAR;
142 size_t result_len = 0;
143 size_t start_var = 0;
145 memset(result, 0, sizeof(result));
146 PROX_PANIC(name_len > sizeof(result), "\tUnable to parse var %s: too long\n", name);
148 for (size_t i = 0; i < name_len; ++i) {
151 if (name[i] == '$') {
152 if (i != name_len - 1 && name[i + 1] == '{') {
157 else if (i == 0 && i != name_len - 1) {
161 set_errf("Invalid variable syntax");
166 result[result_len++] = name[i];
170 if (name[i] == '}') {
172 size_t var_len = i - start_var;
174 set_errf("Empty variable are not allowed");
178 strncpy(&cur_var[1], &name[start_var], var_len);
179 cur_var[1 + var_len] = 0;
180 if (parse_single_var(parsed, sizeof(parsed), cur_var)) {
183 strcpy(&result[result_len], parsed);
184 result_len += strlen(parsed);
187 else if (i == name_len - 1) {
188 set_errf("Invalid variable syntax, expected '}'.");
193 if (i == name_len - 1) {
194 return parse_single_var(val, len, name);
199 prox_strncpy(val, result, len);
204 int parse_int_mask(uint32_t *val, uint32_t *mask, const char *str2)
206 char str[MAX_STR_LEN_PROC];
209 if (parse_vars(str, sizeof(str), str2))
212 mask_str = strchr(str, '&');
214 if (mask_str == NULL) {
215 set_errf("Missing '&' when parsing mask");
221 if (parse_int(val, str))
223 if (parse_int(mask, mask_str + 1))
229 int parse_range(uint32_t* lo, uint32_t* hi, const char *str2)
231 char str[MAX_STR_LEN_PROC];
234 if (parse_vars(str, sizeof(str), str2))
237 dash = strstr(str, "-");
240 set_errf("Missing '-' when parsing mask");
246 if (parse_int(lo, str))
248 if (parse_int(hi, dash + 1))
251 int64_t tmp = strtol(str, 0, 0);
252 if (tmp > UINT32_MAX) {
253 set_errf("Integer is bigger than %u", UINT32_MAX);
257 set_errf("Integer is negative");
263 tmp = strtol(dash + 1, 0, 0);
264 if (tmp > UINT32_MAX) {
265 set_errf("Integer is bigger than %u", UINT32_MAX);
269 set_errf("Integer is negative");
276 set_errf("Low boundary is above high boundary in range");
283 int parse_ip(uint32_t *addr, const char *str2)
285 char str[MAX_STR_LEN_PROC];
287 if (parse_vars(str, sizeof(str), str2))
292 if (strlen(str) > MAX_STR_LEN_PROC) {
293 set_errf("String too long (max supported: %d)", MAX_STR_LEN_PROC);
297 if (4 != rte_strsplit(str, strlen(str), ip_parts, 5, '.')) {
298 set_errf("Expecting 4 octets in ip.");
303 for (uint8_t i = 0; i < 4; ++i) {
304 val = atoi(ip_parts[i]);
306 set_errf("Maximum value for octet is 255 but octet %u is %u", i, val);
309 *addr = *addr << 8 | val;
314 int parse_ip4_cidr(struct ip4_subnet *val, const char *str2)
316 char str[MAX_STR_LEN_PROC];
320 if (parse_vars(str, sizeof(str), str2))
323 slash = strstr(str, "/");
326 set_errf("Missing '/' when parsing CIDR notation");
331 prefix = atoi(slash + 1);
332 val->prefix = prefix;
335 set_errf("Prefix %d is too big", prefix);
339 set_errf("Prefix %d is too small", prefix);
341 if (parse_ip(&val->ip, str))
344 /* Apply mask making all bits outside the prefix zero */
345 val->ip &= ((int)(1 << 31)) >> (prefix - 1);
350 int parse_ip6_cidr(struct ip6_subnet *val, const char *str2)
352 char str[MAX_STR_LEN_PROC];
356 if (parse_vars(str, sizeof(str), str2))
359 slash = strstr(str, "/");
362 set_errf("Missing '/' when parsing CIDR notation");
367 prefix = atoi(slash + 1);
368 val->prefix = prefix;
370 parse_ip6((struct ipv6_addr *)&val->ip, str);
372 /* Apply mask making all bits outside the prefix zero */
377 while (p >= prefix) {
383 if (prefix % 8 != 0) {
384 val->ip[15-cnt] &= ((int8_t)(1 << 7)) >> ((prefix %8) - 1);
390 int parse_ip6(struct ipv6_addr *addr, const char *str2)
392 char str[MAX_STR_LEN_PROC];
395 if (parse_vars(str, sizeof(str), str2))
398 uint8_t ret = rte_strsplit(str, strlen(str), addr_parts, 9, ':');
401 set_errf("Invalid IPv6 address");
407 for (uint8_t i = 0, j = 0; i < ret; ++i, ++j) {
408 if (*addr_parts[i] == 0) {
410 set_errf("Can only omit zeros once");
417 uint16_t w = strtoll(addr_parts[i], NULL, 16);
418 addr->bytes[j++] = (w >> 8) & 0xff;
419 addr->bytes[j] = w & 0xff;
425 int parse_mac(prox_rte_ether_addr *ether_addr, const char *str2)
427 char str[MAX_STR_LEN_PROC];
430 if (parse_vars(str, sizeof(str), str2))
433 uint8_t ret = rte_strsplit(str, strlen(str), addr_parts, 7, ':');
435 ret = rte_strsplit(str, strlen(str), addr_parts, 7, ' ');
438 set_errf("Invalid MAC address format");
442 for (uint8_t i = 0; i < 6; ++i) {
443 if (2 != strlen(addr_parts[i])) {
444 set_errf("Invalid MAC address format");
447 ether_addr->addr_bytes[i] = strtol(addr_parts[i], NULL, 16);
453 char* get_cfg_key(char *str)
455 char *pkey = strchr(str, '=');
462 /* remove leading spaces */
463 while (isspace(*pkey)) {
466 if (*pkey == '\0') { /* an empty key */
473 void strip_spaces(char *strings[], const uint32_t count)
475 for (uint32_t i = 0; i < count; ++i) {
476 while (isspace(strings[i][0])) {
479 size_t len = strlen(strings[i]);
481 while (len && isspace(strings[i][len - 1])) {
482 strings[i][len - 1] = '\0';
488 int is_virtualized(void)
490 char buf[1024]= "/proc/cpuinfo";
492 FILE* fd = fopen(buf, "r");
494 set_errf("Could not open %s", buf);
497 while (fgets(buf, sizeof(buf), fd) != NULL) {
498 if ((strstr(buf, "flags") != NULL) && (strstr(buf, "hypervisor") != NULL))
505 static int get_phys_core(uint32_t *dst, int lcore_id)
509 snprintf(buf, sizeof(buf), "/sys/devices/system/cpu/cpu%u/topology/thread_siblings_list", lcore_id);
510 FILE* ht_fd = fopen(buf, "r");
513 set_errf("Could not open cpu topology %s", buf);
517 if (fgets(buf, sizeof(buf), ht_fd) == NULL) {
518 set_errf("Could not read cpu topology");
523 uint32_t list[2] = {-1,-1};
524 parse_list_set(list, buf, 2);
531 static int get_socket(uint32_t core_id, uint32_t *socket)
535 snprintf(buf, sizeof(buf), "/sys/devices/system/cpu/cpu%u/topology/physical_package_id", core_id);
536 FILE* fd = fopen(buf, "r");
543 if (fgets(buf, sizeof(buf), fd) != NULL) {
549 *socket = (ret == -1 ? 0 : ret);
554 int lcore_to_socket_core_ht(uint32_t lcore_id, char *dst, size_t len)
556 if (cpu_topo.n_sockets == 0) {
557 if (read_cpu_topology() == -1) {
562 for (uint32_t s = 0; s < cpu_topo.n_sockets; s++) {
563 for (uint32_t i = 0; i < cpu_topo.n_cores[s]; ++i) {
564 if ((uint32_t)cpu_topo.socket[s][i][0] == lcore_id) {
565 snprintf(dst, len, "%us%u", i, s);
567 } else if ((uint32_t)cpu_topo.socket[s][i][1] == lcore_id) {
568 snprintf(dst, len, "%us%uh", i, s);
577 static int get_lcore_id(uint32_t socket_id, uint32_t core_id, int ht)
579 if (cpu_topo.n_sockets == 0) {
580 if (read_cpu_topology() == -1) {
585 if (socket_id == UINT32_MAX)
588 if (socket_id >= MAX_SOCKETS) {
589 set_errf("Socket id %d too high (max allowed is %d)", MAX_SOCKETS);
592 if (core_id >= RTE_MAX_LCORE) {
593 set_errf("Core id %d too high (max allowed is %d)", RTE_MAX_LCORE);
596 if (socket_id >= cpu_topo.n_sockets) {
597 set_errf("Current CPU topology reported that there are %u CPU sockets, CPU topology = %u socket(s), %u physical cores per socket, %u thread(s) per physical core",
598 cpu_topo.n_sockets, cpu_topo.n_sockets, cpu_topo.n_cores[0], cpu_topo.socket[0][0][1] == -1? 1: 2);
601 if (core_id >= cpu_topo.n_cores[socket_id]) {
602 set_errf("Core %u on socket %u does not exist, CPU topology = %u socket(s), %u physical cores per socket, %u thread(s) per physical core",
603 core_id, socket_id, cpu_topo.n_sockets, cpu_topo.n_cores[0], cpu_topo.socket[socket_id][0][1] == -1? 1: 2);
606 if (cpu_topo.socket[socket_id][core_id][!!ht] == -1) {
607 set_errf("Core %u %son socket %u has no hyper-thread, CPU topology = %u socket(s), %u physical cores per socket, %u thread(s) per physical core",
608 core_id, ht ? "(hyper-thread) " : "", socket_id, cpu_topo.n_sockets, cpu_topo.n_cores[0], cpu_topo.socket[socket_id][core_id][1] == -1? 1: 2);
612 return cpu_topo.socket[socket_id][core_id][!!ht];
615 /* Returns 0 on success, negative on error. Parses the syntax XsYh
616 where sYh is optional. If sY is specified, Y is stored in the
617 socket argument. If, in addition, h is specified, *ht is set to
618 1. In case the input is only a number, socket and ht are set to
620 static int parse_core(int *socket, int *core, int *ht, const char* str)
628 *core = strtol(str, &end, 10);
634 if (cpu_topo.n_sockets == 0) {
635 if (read_cpu_topology() == -1) {
641 *socket = strtol(end, &end, 10);
642 if (*socket >= MAX_SOCKETS) {
643 set_errf("Socket id %d too high (max allowed is %d)", *socket, MAX_SOCKETS - 1);
656 set_errf("Can't find hyper-thread since socket has not been specified");
663 static int parse_task(const char *str, uint32_t *socket, uint32_t *core, uint32_t *task, uint32_t *ht, enum ctrl_type *type)
665 const char *str_beg = str;
668 *core = strtol(str, &end, 10);
670 set_errf("Expected number to in core-task definition:\n"
671 "\t(i.e. 5s1t0 for task 0 on core 5 on socket 1)\n"
672 "\tHave: '%s'.", end);
688 *socket = strtol(str, &end, 10);
697 *task = strtol(str, &end, 10);
700 *type = CTRL_TYPE_PKT;
703 else if (*str == 'm') {
704 *type = CTRL_TYPE_MSG;
710 set_errf("Can't find hyper-thread since socket has not been specified");
715 *task = strtol(str, &end, 10);
718 *type = CTRL_TYPE_PKT;
721 else if (*str == 'm') {
722 *type = CTRL_TYPE_MSG;
727 return str - str_beg;
730 static int core_task_set_add(struct core_task_set *val, uint32_t core, uint32_t task, enum ctrl_type type)
732 if (val->n_elems == sizeof(val->core_task)/sizeof(val->core_task[0]))
735 val->core_task[val->n_elems].core = core;
736 val->core_task[val->n_elems].task = task;
737 val->core_task[val->n_elems].type = type;
743 int parse_task_set(struct core_task_set *cts, const char *str2)
745 char str[MAX_STR_LEN_PROC];
747 if (parse_vars(str, sizeof(str), str2))
754 uint32_t socket_beg, core_beg, task_beg, ht_beg,
755 socket_end, core_end, task_end, ht_end;
756 enum ctrl_type type_beg, type_end;
757 uint32_t task_group_start = -1;
759 while (*str3 && *str3 != ' ') {
761 task_group_start = cts->n_elems;
765 if (*str3 == ')' && *(str3 + 1) == 't') {
768 uint32_t t = strtol(str3, &end, 10);
769 enum ctrl_type type = 0;
773 type = CTRL_TYPE_PKT;
776 else if (*str3 == 'm') {
777 type = CTRL_TYPE_MSG;
781 for (uint32_t i = task_group_start; i < cts->n_elems; ++i) {
782 cts->core_task[i].task = t;
783 cts->core_task[i].type = type;
787 ret = parse_task(str3, &socket_beg, &core_beg, &task_beg, &ht_beg, &type_beg);
791 socket_end = socket_beg;
799 ret = parse_task(str3, &socket_end, &core_end, &task_end, &ht_end, &type_end);
808 if (socket_end != socket_beg) {
809 set_errf("Same socket must be used in range syntax.");
811 } else if (ht_beg != ht_end) {
812 set_errf("If 'h' syntax is in range, it must be specified everywhere.\n");
814 } else if (task_end != task_beg && core_end != core_beg) {
815 set_errf("Same task must be used in range syntax when cores are different.\n");
817 } else if (task_end < task_beg) {
818 set_errf("Task for end of range must be higher than task for beginning of range.\n");
820 } else if (type_end != type_beg) {
821 set_errf("Task type for end of range must be the same as task type for beginning.\n");
823 } else if (core_end < core_beg) {
824 set_errf("Core for end of range must be higher than core for beginning of range.\n");
828 for (uint32_t j = core_beg; j <= core_end; ++j) {
829 if (socket_beg != UINT32_MAX && ht_beg != UINT32_MAX)
830 ret = get_lcore_id(socket_beg, j, ht_beg);
835 for (uint32_t k = task_beg; k <= task_end; ++k) {
836 core_task_set_add(cts, ret, k, type_beg);
843 int parse_list_set(uint32_t *list, const char *str2, uint32_t max_list)
845 char str[MAX_STR_LEN_PROC];
846 char *parts[MAX_STR_LEN_PROC];
848 if (parse_vars(str, sizeof(str), str2))
851 int n_parts = rte_strsplit(str, strlen(str), parts, MAX_STR_LEN_PROC, ',');
852 size_t list_count = 0;
854 for (int i = 0; i < n_parts; ++i) {
855 char *cur_part = parts[i];
857 int n_sub_parts = rte_strsplit(cur_part, strlen(cur_part), sub_parts, 3, '-');
858 int socket1, socket2;
863 if (n_sub_parts == 1) {
864 if (parse_core(&socket1, &core1, &ht1, sub_parts[0]))
870 } else if (n_sub_parts == 2) {
871 if (parse_core(&socket1, &core1, &ht1, sub_parts[0]))
873 if (parse_core(&socket2, &core2, &ht2, sub_parts[1]))
875 } else if (n_sub_parts >= 3) {
876 set_errf("Multiple '-' characters in range syntax found");
879 set_errf("Invalid list syntax");
883 if (socket1 != socket2) {
884 set_errf("Same socket must be used in range syntax");
887 else if (ht1 != ht2) {
888 set_errf("If 'h' syntax is in range, it must be specified everywhere.");
892 for (int cur_core = core1; cur_core <= core2; ++cur_core) {
896 effective_core = get_lcore_id(socket1, cur_core, ht1);
898 effective_core = cur_core;
900 if (list_count >= max_list) {
901 set_errf("Too many elements in list");
904 list[list_count++] = effective_core;
911 int parse_kmg(uint32_t* val, const char *str2)
913 char str[MAX_STR_LEN_PROC];
915 if (parse_vars(str, sizeof(str), str2))
918 char c = str[strlen(str) - 1];
926 // __attribute__ ((fallthrough));
931 // __attribute__ ((fallthrough));
938 /* only support optional KMG suffix */
939 if (c < '0' || c > '9') {
940 set_errf("Unknown syntax for KMG suffix '%c' (expected K, M or G)", c);
948 int parse_bool(uint32_t* val, const char *str2)
950 char str[MAX_STR_LEN_PROC];
952 if (parse_vars(str, sizeof(str), str2))
955 if (!strcmp(str, "yes")) {
959 else if (!strcmp(str, "no")) {
963 set_errf("Unknown syntax for bool '%s' (expected yes or no)", str);
967 int parse_flag(uint32_t* val, uint32_t flag, const char *str2)
969 char str[MAX_STR_LEN_PROC];
971 if (parse_vars(str, sizeof(str), str2))
975 if (parse_bool(&tmp, str))
986 int parse_int(uint32_t* val, const char *str2)
988 char str[MAX_STR_LEN_PROC];
990 if (parse_vars(str, sizeof(str), str2))
993 int64_t tmp = strtol(str, 0, 0);
994 if (tmp > UINT32_MAX) {
995 set_errf("Integer is bigger than %u", UINT32_MAX);
999 set_errf("Integer is negative");
1007 int parse_float(float* val, const char *str2)
1009 char str[MAX_STR_LEN_PROC];
1011 if (parse_vars(str, sizeof(str), str2))
1014 float tmp = strtof(str, 0);
1015 if ((tmp >= HUGE_VALF) || (tmp <= -HUGE_VALF)) {
1016 set_errf("Unable to parse float\n");
1024 int parse_u64(uint64_t* val, const char *str2)
1026 char str[MAX_STR_LEN_PROC];
1028 if (parse_vars(str, sizeof(str), str2))
1032 uint64_t tmp = strtoul(str, NULL, 0);
1034 set_errf("Invalid u64 '%s' (%s)", str, strerror(errno));
1042 int parse_str(char* dst, const char *str2, size_t max_len)
1044 char str[MAX_STR_LEN_PROC];
1046 if (parse_vars(str, sizeof(str), str2))
1049 if (strlen(str) > max_len - 1) {
1050 set_errf("String too long (%u > %u)", strlen(str), max_len - 1);
1054 prox_strncpy(dst, str, max_len);
1058 int parse_path(char *dst, const char *str, size_t max_len)
1060 if (parse_str(dst, str, max_len))
1062 if (access(dst, F_OK)) {
1063 set_errf("Invalid file '%s' (%s)", dst, strerror(errno));
1069 int parse_port_name(uint32_t *val, const char *str2)
1071 char str[MAX_STR_LEN_PROC];
1073 if (parse_vars(str, sizeof(str), str2))
1076 for (uint8_t i = 0; i < nb_port_names; ++i) {
1077 if (!strcmp(str, port_names[i].name)) {
1078 *val = port_names[i].id;
1082 set_errf("Port with name %s not defined", str);
1086 int parse_port_name_list(uint32_t *val, uint32_t* tot, uint8_t max_vals, const char *str2)
1088 char *elements[PROX_MAX_PORTS + 1];
1089 char str[MAX_STR_LEN_PROC];
1093 if (parse_str(str, str2, sizeof(str)))
1096 ret = rte_strsplit(str, strlen(str), elements, PROX_MAX_PORTS + 1, ',');
1098 if (ret == PROX_MAX_PORTS + 1 || ret > max_vals) {
1099 set_errf("Too many ports in port list");
1103 strip_spaces(elements, ret);
1104 for (uint8_t i = 0; i < ret; ++i) {
1105 if (parse_port_name(&cur, elements[i])) {
1116 int parse_remap(uint8_t *mapping, const char *str)
1118 char *elements[PROX_MAX_PORTS + 1];
1119 char *elements2[PROX_MAX_PORTS + 1];
1120 char str_cpy[MAX_STR_LEN_PROC];
1124 if (strlen(str) > MAX_STR_LEN_PROC) {
1125 set_errf("String too long (max supported: %d)", MAX_STR_LEN_PROC);
1128 prox_strncpy(str_cpy, str, MAX_STR_LEN_PROC);
1130 ret = rte_strsplit(str_cpy, strlen(str_cpy), elements, PROX_MAX_PORTS + 1, ',');
1132 set_errf("Invalid remap syntax");
1135 else if (ret > PROX_MAX_PORTS) {
1136 set_errf("Too many remaps");
1140 strip_spaces(elements, ret);
1141 for (uint8_t i = 0; i < ret; ++i) {
1142 ret2 = rte_strsplit(elements[i], strlen(elements[i]), elements2, PROX_MAX_PORTS + 1, '|');
1143 strip_spaces(elements2, ret2);
1144 if (ret2 > PROX_MAX_PORTS) {
1145 set_errf("Too many remaps");
1148 for (uint8_t j = 0; j < ret2; ++j) {
1149 if (parse_port_name(&val, elements2[j])) {
1153 /* This port will be mapped to the i'th
1154 element specified before remap=. */
1162 int add_port_name(uint32_t val, const char *str2)
1164 char str[MAX_STR_LEN_PROC];
1166 if (parse_vars(str, sizeof(str), str2))
1169 struct port_name* pn;
1171 if (nb_port_names == MAX_NB_PORT_NAMES) {
1172 set_errf("Too many ports defined (can define %d)", MAX_NB_PORT_NAMES);
1176 for (uint8_t i = 0; i < nb_port_names; ++i) {
1177 /* each port has to have a unique name*/
1178 if (!strcmp(str, port_names[i].name)) {
1179 set_errf("Port with name %s is already defined", str);
1184 pn = &port_names[nb_port_names];
1185 prox_strncpy(pn->name, str, sizeof(pn->name));
1192 int set_self_var(const char *str)
1194 for (uint8_t i = 0; i < nb_vars; ++i) {
1195 if (!strcmp("$self", vars[i].name)) {
1196 sprintf(vars[i].val, "%s", str);
1201 struct var *v = &vars[nb_vars];
1203 prox_strncpy(v->name, "$self", strlen("$self") + 1);
1204 sprintf(v->val, "%s", str);
1210 int add_var(const char* name, const char *str2, uint8_t cli)
1214 char str[MAX_STR_LEN_PROC];
1216 if (parse_vars(str, sizeof(str), str2))
1219 if (strlen(name) == 0 || strlen(name) == 1) {
1220 set_errf("Can't define variables with empty name");
1224 if (name[0] != '$') {
1225 set_errf("Each variable should start with the $ character");
1229 if (nb_vars == MAX_NB_VARS) {
1230 set_errf("Too many variables defined (can define %d)", MAX_NB_VARS);
1234 for (uint8_t i = 0; i < nb_vars; ++i) {
1235 if (!strcmp(name, vars[i].name)) {
1237 /* Variables defined through program arguments
1239 if (!cli && vars[i].cli) {
1243 set_errf("Variable with name %s is already defined", name);
1249 PROX_PANIC(strlen(name) > sizeof(v->name), "\tUnable to parse var %s: too long\n", name);
1250 PROX_PANIC(strlen(str) > sizeof(v->val), "\tUnable to parse var %s=%s: too long\n", name,str);
1251 prox_strncpy(v->name, name, sizeof(v->name));
1252 prox_strncpy(v->val, str, sizeof(v->val));
1259 static int read_cores_present(uint32_t *cores, int max_cores, int *res)
1261 FILE* fd = fopen("/sys/devices/system/cpu/present", "r");
1265 set_errf("Could not opening file /sys/devices/system/cpu/present");
1269 if (fgets(buf, sizeof(buf), fd) == NULL) {
1270 set_errf("Could not read cores range");
1276 int ret = parse_list_set(cores, buf, max_cores);
1285 static int set_dummy_topology(void)
1289 for (int s = 0; s < MAX_SOCKETS; s++) {
1290 for (int i = 0; i < 32; ++i) {
1291 cpu_topo.socket[s][i][0] = core_count++;
1292 cpu_topo.socket[s][i][1] = core_count++;
1293 cpu_topo.n_cores[s]++;
1296 cpu_topo.n_sockets = MAX_SOCKETS;
1300 static int read_cpu_topology(void)
1302 if (cpu_topo.n_sockets != 0)
1304 if (prox_cfg.flags & DSF_USE_DUMMY_CPU_TOPO)
1305 return set_dummy_topology();
1307 uint32_t cores[RTE_MAX_LCORE];
1310 if (read_cores_present(cores, sizeof(cores)/sizeof(cores[0]), &n_cores) != 0)
1313 for (int s = 0; s < MAX_SOCKETS; s++) {
1314 for (int i = 0; i < RTE_MAX_LCORE; ++i) {
1315 cpu_topo.socket[s][i][0] = -1;
1316 cpu_topo.socket[s][i][1] = -1;
1320 for (int i = 0; i < n_cores; ++i) {
1321 uint32_t socket_id, lcore_id, phys;
1323 lcore_id = cores[i];
1324 if (get_socket(lcore_id, &socket_id) != 0)
1326 if (socket_id >= MAX_SOCKETS) {
1327 set_errf("Can't read CPU topology due too high socket ID (max allowed is %d)",
1331 if (socket_id >= cpu_topo.n_sockets) {
1332 cpu_topo.n_sockets = socket_id + 1;
1334 if (get_phys_core(&phys, lcore_id) != 0)
1336 if (phys >= RTE_MAX_LCORE) {
1337 set_errf("Core ID %u too high", phys);
1341 if (cpu_topo.socket[socket_id][phys][0] == -1) {
1342 cpu_topo.socket[socket_id][phys][0] = lcore_id;
1343 cpu_topo.n_cores[socket_id]++;
1345 else if (cpu_topo.socket[socket_id][phys][1] == -1) {
1346 cpu_topo.socket[socket_id][phys][1] = lcore_id;
1349 set_errf("Too many core siblings");
1354 /* There can be holes in the cpu_topo description at this
1355 point. An example for this is a CPU topology where the
1356 lowest core ID of 2 hyper-threads is always an even
1357 number. Before finished up this phase, compact all the
1358 cores to make the numbers consecutive. */
1360 for (uint32_t i = 0; i < cpu_topo.n_sockets; ++i) {
1361 int spread = 0, compact = 0;
1362 while (cpu_topo.socket[i][spread][0] == -1)
1365 for (uint32_t c = 0; c < cpu_topo.n_cores[i]; ++c) {
1366 cpu_topo.socket[i][compact][0] = cpu_topo.socket[i][spread][0];
1367 cpu_topo.socket[i][compact][1] = cpu_topo.socket[i][spread][1];
1371 while (cpu_topo.socket[i][spread][0] == -1)
1379 static int bit_len_valid(uint32_t len, const char *str)
1382 set_errf("Maximum random length is 32, but length of '%s' is %zu\n", str, len);
1386 plog_err("Random should be multiple of 8 long\n");
1390 plog_err("Random should be at least 1 byte long\n");
1396 int parse_random_str(uint32_t *mask, uint32_t *fixed, uint32_t *len, const char *str)
1398 const size_t len_bits = strlen(str);
1400 if (!bit_len_valid(len_bits, str))
1405 *len = len_bits / 8;
1407 for (uint32_t j = 0; j < len_bits; ++j) {
1408 /* Store in the lower bits the value of the rand string (note
1409 that these are the higher bits in LE). */
1412 *mask |= 1 << (len_bits - 1 - j);
1415 *fixed |= 1 << (len_bits - 1 - j);
1420 set_errf("Unexpected %c\n", str[j]);