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