1#pragma once
2
3#include <asm.h>
4#include <cmdline.h>
5#include <compiler/intrinsic.h>
6#include <console/panic.h>
7#include <console/printf.h>
8#include <enforce.h>
9#include <err.h>
10#include <global.h>
11#include <log.h>
12#include <math/bit.h>
13#include <math/fixed.h>
14#include <math/range.h>
15#include <mem/alloc.h>
16#include <mem/nofail.h>
17#include <parse.h>
18#include <string.h>
19#include <stringify.h>
20
21LINKER_SECTION_EXTERN(struct cmdline_entry, cmdline_entries);
22LINKER_SECTION_EXTERN(struct cmdline_schema, cmdline_schemas);
23
24#define MAX_VAR_LEN 128
25#define MAX_VAL_LEN 256
26#define CMDLINE_MAX_TYPE_ARGS 5
27
28#define CMDLINE_TYPE_LIST_DEF(X) \
29 /* Enum, Ident, Arg Hint, Raw Hint */ \
30 X(CMDLINE_TYPE_BOOL, "bool", "<on/off>", "on/off") \
31 X(CMDLINE_TYPE_INT, "int", "<integer>", "integer") \
32 X(CMDLINE_TYPE_UINT, "uint", "<unsigned-int>", "unsigned-int") \
33 X(CMDLINE_TYPE_FX, "fx", "<float>", "float") \
34 X(CMDLINE_TYPE_DURATION, "duration", "<time>", "time") \
35 X(CMDLINE_TYPE_DATA_SIZE, "data_size", "<size>", "size") \
36 X(CMDLINE_TYPE_RANGE, "range", "<start-end>", "start-end") \
37 X(CMDLINE_TYPE_CPU_MASK, "cpu_mask", "<cpus>", "cpus") \
38 X(CMDLINE_TYPE_MAC, "mac", "<mac-addr>", "mac-addr") \
39 X(CMDLINE_TYPE_STRING, "string", "<string>", "string") \
40 X(CMDLINE_TYPE_LIST, "list", "<list>", "list")
41
42STRINGIFY_DECLARE_ENUM(cmdline_type) {
43 switch (stringify_in) {
44#define _CMDLINE_TYPE_STR(e, ident, ...) \
45 case e: return ident;
46 CMDLINE_TYPE_LIST_DEF(_CMDLINE_TYPE_STR)
47#undef _CMDLINE_TYPE_STR
48 case CMDLINE_TYPE_ERR: return "err";
49 case CMDLINE_TYPE_NONE: return "none";
50 default: return "unknown";
51 }
52}
53
54STRINGIFY_DECLARE(cmdline_expr_type_to_str, enum cmdline_type) {
55 switch (stringify_in) {
56#define _CMDLINE_TYPE_ARG(e, ident, hint, ...) \
57 case e: return hint;
58 CMDLINE_TYPE_LIST_DEF(_CMDLINE_TYPE_ARG)
59#undef _CMDLINE_TYPE_ARG
60 default: return "<undefined>";
61 }
62}
63#define CMDLINE_EXPR_TYPE_TO_STR(type) cmdline_expr_type_to_str(type)
64
65static inline const char *cmdline_type_raw_hint(enum cmdline_type type) {
66 switch (type) {
67#define _CMDLINE_TYPE_RAW(e, ident, hint, raw, ...) \
68 case e: return raw;
69 CMDLINE_TYPE_LIST_DEF(_CMDLINE_TYPE_RAW)
70#undef _CMDLINE_TYPE_RAW
71 case CMDLINE_TYPE_ERR: return "err";
72 case CMDLINE_TYPE_NONE: return "none";
73 default: return "unknown";
74 }
75}
76
77typedef enum err (*cmdline_parse_fn)(void *write_to, const char *text);
78typedef bool (*cmdline_detect_fn)(const char *text, void *out_val);
79
80struct cmdline_type_parser {
81 enum cmdline_type type;
82 const char *name;
83 const char *arg_hint;
84 size_t value_size;
85 bool uses_allocated_ptr; /* true if heap allocation needed for generic
86 cmdline_value */
87
88 cmdline_detect_fn detect;
89 cmdline_parse_fn parse;
90};
91
92extern const struct cmdline_type_parser cmdline_parsers[];
93extern const size_t cmdline_parsers_count;
94
95static inline bool cmdline_value_is_typed(const struct cmdline_value *val) {
96 return val->mode == CMDLINE_MODE_VAR;
97}
98
99static inline bool cmdline_entry_is_typed(const struct cmdline_entry *e) {
100 return cmdline_value_is_typed(val: &e->value);
101}
102
103static inline enum cmdline_type
104cmdline_type_enum_to_cmdline_type(enum type_enum t) {
105 switch (t) {
106 case TYPE_BOOL: return CMDLINE_TYPE_BOOL;
107 case TYPE_INT8:
108 case TYPE_INT16:
109 case TYPE_INT32:
110 case TYPE_INT64: return CMDLINE_TYPE_INT;
111 case TYPE_UINT8:
112 case TYPE_UINT16:
113 case TYPE_UINT32:
114 case TYPE_UINT64: return CMDLINE_TYPE_UINT;
115 default: return CMDLINE_TYPE_NONE;
116 }
117}
118
119static inline uint64_t
120cmdline_entry_get_accepted_mask(const struct cmdline_entry *e) {
121 if (e->types >= BIT(CMDLINE_TYPE_OFFSET)) {
122 enforce((e->types & (BIT(CMDLINE_TYPE_OFFSET) - 1)) == 0);
123 return e->types;
124 }
125 if (e->types >= CMDLINE_TYPE_OFFSET && e->types < CMDLINE_TYPE_NONE) {
126 return BIT(e->types);
127 }
128 if (cmdline_value_is_typed(val: &e->value) && e->value.c_type != TYPE_NONE) {
129 switch (e->value.c_type) {
130 case TYPE_BOOL: return BIT(CMDLINE_TYPE_BOOL);
131 case TYPE_INT8:
132 case TYPE_INT16:
133 case TYPE_INT32:
134 case TYPE_INT64: return BIT(CMDLINE_TYPE_INT) | BIT(CMDLINE_TYPE_UINT);
135 case TYPE_UINT8:
136 case TYPE_UINT16:
137 case TYPE_UINT32:
138 case TYPE_UINT64: return BIT(CMDLINE_TYPE_UINT);
139 case TYPE_POINTER: return BIT(CMDLINE_TYPE_STRING);
140 default: break;
141 }
142 }
143 return UINT64_MAX;
144}
145
146static inline enum cmdline_type
147cmdline_entry_effective_type(const struct cmdline_entry *e) {
148 if (e->types != 0 && !(e->types & (e->types - 1)))
149 return (enum cmdline_type) ci_ctzll(e->types);
150 if (e->value.mode == CMDLINE_MODE_VAR)
151 return cmdline_type_enum_to_cmdline_type(t: e->value.c_type);
152 return e->value.type;
153}
154
155static inline bool cmdline_entry_has_range(const struct cmdline_entry *e) {
156 return RANGE_VALID(e->range);
157}
158
159static inline size_t
160cmdline_extract_type_bits(uint64_t mask,
161 enum cmdline_type out[CMDLINE_MAX_TYPE_ARGS]) {
162 size_t found = 0;
163 for (size_t bit = CMDLINE_TYPE_OFFSET;
164 bit < 64 && found < CMDLINE_MAX_TYPE_ARGS; bit++) {
165 if ((mask >> bit) & 1ULL) {
166 out[found++] = (enum cmdline_type) bit;
167 }
168 }
169 return found;
170}
171
172static inline void cmdline_write_typed_uint(struct cmdline_value *val,
173 uint64_t raw_val) {
174 if (!val->write_to)
175 return;
176 switch (val->c_type) {
177 case TYPE_UINT8: *(uint8_t *) val->write_to = (uint8_t) raw_val; break;
178 case TYPE_UINT16: *(uint16_t *) val->write_to = (uint16_t) raw_val; break;
179 case TYPE_UINT32: *(uint32_t *) val->write_to = (uint32_t) raw_val; break;
180 case TYPE_UINT64: *(uint64_t *) val->write_to = (uint64_t) raw_val; break;
181 case TYPE_INT8: *(int8_t *) val->write_to = (int8_t) raw_val; break;
182 case TYPE_INT16: *(int16_t *) val->write_to = (int16_t) raw_val; break;
183 case TYPE_INT32: *(int32_t *) val->write_to = (int32_t) raw_val; break;
184 case TYPE_INT64: *(int64_t *) val->write_to = (int64_t) raw_val; break;
185 case TYPE_BOOL: *(bool *) val->write_to = (raw_val != 0); break;
186 default: break;
187 }
188}
189
190static inline bool cmdline_has_choice(const char *const *choices,
191 const char *val) {
192 if (!choices || !val)
193 return true;
194 for (const char *const *c = choices; *c; c++) {
195 if (strcmp(str1: *c, str2: val) == 0)
196 return true;
197 }
198 return false;
199}
200
201static inline bool cmdline_lookup_mapping(const struct cmdline_map *mappings,
202 const char *val, uint64_t *out) {
203 if (!mappings || !val)
204 return false;
205 for (const struct cmdline_map *m = mappings; m->name; m++) {
206 if (strcmp(str1: m->name, str2: val) == 0) {
207 if (out)
208 *out = m->value;
209 return true;
210 }
211 }
212 return false;
213}
214
215static inline bool cmdline_parse_flags(const struct cmdline_flag *table,
216 const char *val, uint64_t *out_mask,
217 const char **err_token,
218 size_t *err_len) {
219 if (!table || !val)
220 return false;
221 uint64_t mask = 0;
222 const char *p = val;
223 while (*p) {
224 while (*p == ',' || *p == '|' || *p == ' ' || *p == '\t')
225 p++;
226 if (!*p)
227 break;
228 const char *start = p;
229 while (*p && *p != ',' && *p != '|' && *p != ' ' && *p != '\t')
230 p++;
231 size_t len = (size_t) (p - start);
232
233 bool matched = false;
234 for (const struct cmdline_flag *f = table; f->name; f++) {
235 if (strlen(str: f->name) == len && strncmp(s1: f->name, s2: start, n: len) == 0) {
236 mask |= f->value;
237 matched = true;
238 break;
239 }
240 }
241 if (!matched) {
242 if (err_token)
243 *err_token = start;
244 if (err_len)
245 *err_len = len;
246 return false;
247 }
248 }
249 if (out_mask)
250 *out_mask = mask;
251 return true;
252}
253
254void cmdline_functional_name(const struct cmdline_entry *ent,
255 char name_out[CMDLINE_ENTRY_NAME_LEN_MAX]);
256void cmdline_check_for_duplicates(void);
257void cmdline_check_for_unfilled(void);
258void cmdline_apply_defaults(void);
259void cmdline_print_all(void);
260
261void dispatch_parse_value(struct cmdline_entry *e, const char *name,
262 const char *var, const char *val);
263void cmdline_assign_all_args(void);
264const char *cmdline_intern_composite_arg(uint64_t mask,
265 const enum cmdline_type *types,
266 size_t num_types);
267struct cmdline_value cmdline_parse_value_for(const char *value,
268 uint64_t accepted);
269struct cmdline_value cmdline_parse_value(struct cmdline_entry *ent,
270 const char *value);
271bool cmdline_has_list_separator(const char *value);
272struct cmdline_value cmdline_parse_list(const char *value, uint64_t accepted);
273
274/* Parser functions */
275enum err cmdline_parse_i64(void *write_to, const char *text);
276enum err cmdline_parse_u64(void *write_to, const char *text);
277enum err cmdline_parse_bool(void *write_to, const char *text);
278enum err cmdline_parse_fx(void *write_to, const char *text);
279enum err cmdline_parse_duration(void *write_to, const char *text);
280enum err cmdline_parse_data_size(void *write_to, const char *text);
281enum err cmdline_parse_cpu_mask(void *write_to, const char *text);
282enum err cmdline_parse_mac(void *write_to, const char *text);
283enum err cmdline_parse_range(void *write_to, const char *text);
284enum err cmdline_parse_string(void *write_to, const char *text);
285
286/* Dispatch & Validation prototypes */
287void cmdline_dispatch(const char *var, const char *val);
288void cmdline_validate_defaults(void);
289