Commit | Line | Data |
---|---|---|
76db5a27 MH |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Extra Boot Config | |
4 | * Masami Hiramatsu <mhiramat@kernel.org> | |
5 | */ | |
6 | ||
7 | #define pr_fmt(fmt) "bootconfig: " fmt | |
8 | ||
a91e4f12 | 9 | #include <linux/bootconfig.h> |
76db5a27 MH |
10 | #include <linux/bug.h> |
11 | #include <linux/ctype.h> | |
12 | #include <linux/errno.h> | |
13 | #include <linux/kernel.h> | |
a91e4f12 | 14 | #include <linux/memblock.h> |
76db5a27 | 15 | #include <linux/printk.h> |
76db5a27 MH |
16 | #include <linux/string.h> |
17 | ||
18 | /* | |
19 | * Extra Boot Config (XBC) is given as tree-structured ascii text of | |
20 | * key-value pairs on memory. | |
21 | * xbc_parse() parses the text to build a simple tree. Each tree node is | |
22 | * simply a key word or a value. A key node may have a next key node or/and | |
23 | * a child node (both key and value). A value node may have a next value | |
24 | * node (for array). | |
25 | */ | |
26 | ||
a91e4f12 | 27 | static struct xbc_node *xbc_nodes __initdata; |
76db5a27 MH |
28 | static int xbc_node_num __initdata; |
29 | static char *xbc_data __initdata; | |
30 | static size_t xbc_data_size __initdata; | |
31 | static struct xbc_node *last_parent __initdata; | |
89b74cac MH |
32 | static const char *xbc_err_msg __initdata; |
33 | static int xbc_err_pos __initdata; | |
ead1e19a MH |
34 | static int open_brace[XBC_DEPTH_MAX] __initdata; |
35 | static int brace_index __initdata; | |
76db5a27 MH |
36 | |
37 | static int __init xbc_parse_error(const char *msg, const char *p) | |
38 | { | |
89b74cac MH |
39 | xbc_err_msg = msg; |
40 | xbc_err_pos = (int)(p - xbc_data); | |
76db5a27 | 41 | |
76db5a27 MH |
42 | return -EINVAL; |
43 | } | |
44 | ||
45 | /** | |
46 | * xbc_root_node() - Get the root node of extended boot config | |
47 | * | |
48 | * Return the address of root node of extended boot config. If the | |
49 | * extended boot config is not initiized, return NULL. | |
50 | */ | |
51 | struct xbc_node * __init xbc_root_node(void) | |
52 | { | |
53 | if (unlikely(!xbc_data)) | |
54 | return NULL; | |
55 | ||
56 | return xbc_nodes; | |
57 | } | |
58 | ||
59 | /** | |
60 | * xbc_node_index() - Get the index of XBC node | |
61 | * @node: A target node of getting index. | |
62 | * | |
63 | * Return the index number of @node in XBC node list. | |
64 | */ | |
65 | int __init xbc_node_index(struct xbc_node *node) | |
66 | { | |
67 | return node - &xbc_nodes[0]; | |
68 | } | |
69 | ||
70 | /** | |
71 | * xbc_node_get_parent() - Get the parent XBC node | |
72 | * @node: An XBC node. | |
73 | * | |
74 | * Return the parent node of @node. If the node is top node of the tree, | |
75 | * return NULL. | |
76 | */ | |
77 | struct xbc_node * __init xbc_node_get_parent(struct xbc_node *node) | |
78 | { | |
79 | return node->parent == XBC_NODE_MAX ? NULL : &xbc_nodes[node->parent]; | |
80 | } | |
81 | ||
82 | /** | |
83 | * xbc_node_get_child() - Get the child XBC node | |
84 | * @node: An XBC node. | |
85 | * | |
86 | * Return the first child node of @node. If the node has no child, return | |
87 | * NULL. | |
88 | */ | |
89 | struct xbc_node * __init xbc_node_get_child(struct xbc_node *node) | |
90 | { | |
91 | return node->child ? &xbc_nodes[node->child] : NULL; | |
92 | } | |
93 | ||
94 | /** | |
95 | * xbc_node_get_next() - Get the next sibling XBC node | |
96 | * @node: An XBC node. | |
97 | * | |
98 | * Return the NEXT sibling node of @node. If the node has no next sibling, | |
99 | * return NULL. Note that even if this returns NULL, it doesn't mean @node | |
100 | * has no siblings. (You also has to check whether the parent's child node | |
101 | * is @node or not.) | |
102 | */ | |
103 | struct xbc_node * __init xbc_node_get_next(struct xbc_node *node) | |
104 | { | |
105 | return node->next ? &xbc_nodes[node->next] : NULL; | |
106 | } | |
107 | ||
108 | /** | |
109 | * xbc_node_get_data() - Get the data of XBC node | |
110 | * @node: An XBC node. | |
111 | * | |
112 | * Return the data (which is always a null terminated string) of @node. | |
113 | * If the node has invalid data, warn and return NULL. | |
114 | */ | |
115 | const char * __init xbc_node_get_data(struct xbc_node *node) | |
116 | { | |
117 | int offset = node->data & ~XBC_VALUE; | |
118 | ||
119 | if (WARN_ON(offset >= xbc_data_size)) | |
120 | return NULL; | |
121 | ||
122 | return xbc_data + offset; | |
123 | } | |
124 | ||
125 | static bool __init | |
126 | xbc_node_match_prefix(struct xbc_node *node, const char **prefix) | |
127 | { | |
128 | const char *p = xbc_node_get_data(node); | |
129 | int len = strlen(p); | |
130 | ||
131 | if (strncmp(*prefix, p, len)) | |
132 | return false; | |
133 | ||
134 | p = *prefix + len; | |
135 | if (*p == '.') | |
136 | p++; | |
137 | else if (*p != '\0') | |
138 | return false; | |
139 | *prefix = p; | |
140 | ||
141 | return true; | |
142 | } | |
143 | ||
144 | /** | |
5dfe50b0 | 145 | * xbc_node_find_subkey() - Find a subkey node which matches given key |
76db5a27 MH |
146 | * @parent: An XBC node. |
147 | * @key: A key string. | |
148 | * | |
5dfe50b0 | 149 | * Search a key node under @parent which matches @key. The @key can contain |
76db5a27 MH |
150 | * several words jointed with '.'. If @parent is NULL, this searches the |
151 | * node from whole tree. Return NULL if no node is matched. | |
152 | */ | |
153 | struct xbc_node * __init | |
5dfe50b0 | 154 | xbc_node_find_subkey(struct xbc_node *parent, const char *key) |
76db5a27 MH |
155 | { |
156 | struct xbc_node *node; | |
157 | ||
158 | if (parent) | |
e5efaeb8 | 159 | node = xbc_node_get_subkey(parent); |
76db5a27 MH |
160 | else |
161 | node = xbc_root_node(); | |
162 | ||
163 | while (node && xbc_node_is_key(node)) { | |
164 | if (!xbc_node_match_prefix(node, &key)) | |
165 | node = xbc_node_get_next(node); | |
166 | else if (*key != '\0') | |
e5efaeb8 | 167 | node = xbc_node_get_subkey(node); |
76db5a27 MH |
168 | else |
169 | break; | |
170 | } | |
171 | ||
172 | return node; | |
173 | } | |
174 | ||
175 | /** | |
176 | * xbc_node_find_value() - Find a value node which matches given key | |
177 | * @parent: An XBC node. | |
178 | * @key: A key string. | |
179 | * @vnode: A container pointer of found XBC node. | |
180 | * | |
181 | * Search a value node under @parent whose (parent) key node matches @key, | |
182 | * store it in *@vnode, and returns the value string. | |
183 | * The @key can contain several words jointed with '.'. If @parent is NULL, | |
184 | * this searches the node from whole tree. Return the value string if a | |
185 | * matched key found, return NULL if no node is matched. | |
186 | * Note that this returns 0-length string and stores NULL in *@vnode if the | |
187 | * key has no value. And also it will return the value of the first entry if | |
188 | * the value is an array. | |
189 | */ | |
190 | const char * __init | |
191 | xbc_node_find_value(struct xbc_node *parent, const char *key, | |
192 | struct xbc_node **vnode) | |
193 | { | |
5dfe50b0 | 194 | struct xbc_node *node = xbc_node_find_subkey(parent, key); |
76db5a27 MH |
195 | |
196 | if (!node || !xbc_node_is_key(node)) | |
197 | return NULL; | |
198 | ||
199 | node = xbc_node_get_child(node); | |
200 | if (node && !xbc_node_is_value(node)) | |
201 | return NULL; | |
202 | ||
203 | if (vnode) | |
204 | *vnode = node; | |
205 | ||
206 | return node ? xbc_node_get_data(node) : ""; | |
207 | } | |
208 | ||
209 | /** | |
210 | * xbc_node_compose_key_after() - Compose partial key string of the XBC node | |
211 | * @root: Root XBC node | |
212 | * @node: Target XBC node. | |
213 | * @buf: A buffer to store the key. | |
214 | * @size: The size of the @buf. | |
215 | * | |
216 | * Compose the partial key of the @node into @buf, which is starting right | |
217 | * after @root (@root is not included.) If @root is NULL, this returns full | |
218 | * key words of @node. | |
219 | * Returns the total length of the key stored in @buf. Returns -EINVAL | |
220 | * if @node is NULL or @root is not the ancestor of @node or @root is @node, | |
221 | * or returns -ERANGE if the key depth is deeper than max depth. | |
222 | * This is expected to be used with xbc_find_node() to list up all (child) | |
223 | * keys under given key. | |
224 | */ | |
225 | int __init xbc_node_compose_key_after(struct xbc_node *root, | |
226 | struct xbc_node *node, | |
227 | char *buf, size_t size) | |
228 | { | |
229 | u16 keys[XBC_DEPTH_MAX]; | |
230 | int depth = 0, ret = 0, total = 0; | |
231 | ||
232 | if (!node || node == root) | |
233 | return -EINVAL; | |
234 | ||
235 | if (xbc_node_is_value(node)) | |
236 | node = xbc_node_get_parent(node); | |
237 | ||
238 | while (node && node != root) { | |
239 | keys[depth++] = xbc_node_index(node); | |
240 | if (depth == XBC_DEPTH_MAX) | |
241 | return -ERANGE; | |
242 | node = xbc_node_get_parent(node); | |
243 | } | |
244 | if (!node && root) | |
245 | return -EINVAL; | |
246 | ||
247 | while (--depth >= 0) { | |
248 | node = xbc_nodes + keys[depth]; | |
249 | ret = snprintf(buf, size, "%s%s", xbc_node_get_data(node), | |
250 | depth ? "." : ""); | |
251 | if (ret < 0) | |
252 | return ret; | |
253 | if (ret > size) { | |
254 | size = 0; | |
255 | } else { | |
256 | size -= ret; | |
257 | buf += ret; | |
258 | } | |
259 | total += ret; | |
260 | } | |
261 | ||
262 | return total; | |
263 | } | |
264 | ||
265 | /** | |
266 | * xbc_node_find_next_leaf() - Find the next leaf node under given node | |
267 | * @root: An XBC root node | |
268 | * @node: An XBC node which starts from. | |
269 | * | |
270 | * Search the next leaf node (which means the terminal key node) of @node | |
271 | * under @root node (including @root node itself). | |
272 | * Return the next node or NULL if next leaf node is not found. | |
273 | */ | |
274 | struct xbc_node * __init xbc_node_find_next_leaf(struct xbc_node *root, | |
275 | struct xbc_node *node) | |
276 | { | |
e5efaeb8 MH |
277 | struct xbc_node *next; |
278 | ||
76db5a27 MH |
279 | if (unlikely(!xbc_data)) |
280 | return NULL; | |
281 | ||
282 | if (!node) { /* First try */ | |
283 | node = root; | |
284 | if (!node) | |
285 | node = xbc_nodes; | |
286 | } else { | |
e5efaeb8 MH |
287 | /* Leaf node may have a subkey */ |
288 | next = xbc_node_get_subkey(node); | |
289 | if (next) { | |
290 | node = next; | |
291 | goto found; | |
292 | } | |
293 | ||
76db5a27 MH |
294 | if (node == root) /* @root was a leaf, no child node. */ |
295 | return NULL; | |
296 | ||
297 | while (!node->next) { | |
298 | node = xbc_node_get_parent(node); | |
299 | if (node == root) | |
300 | return NULL; | |
301 | /* User passed a node which is not uder parent */ | |
302 | if (WARN_ON(!node)) | |
303 | return NULL; | |
304 | } | |
305 | node = xbc_node_get_next(node); | |
306 | } | |
307 | ||
e5efaeb8 | 308 | found: |
76db5a27 MH |
309 | while (node && !xbc_node_is_leaf(node)) |
310 | node = xbc_node_get_child(node); | |
311 | ||
312 | return node; | |
313 | } | |
314 | ||
315 | /** | |
316 | * xbc_node_find_next_key_value() - Find the next key-value pair nodes | |
317 | * @root: An XBC root node | |
318 | * @leaf: A container pointer of XBC node which starts from. | |
319 | * | |
320 | * Search the next leaf node (which means the terminal key node) of *@leaf | |
321 | * under @root node. Returns the value and update *@leaf if next leaf node | |
322 | * is found, or NULL if no next leaf node is found. | |
323 | * Note that this returns 0-length string if the key has no value, or | |
324 | * the value of the first entry if the value is an array. | |
325 | */ | |
326 | const char * __init xbc_node_find_next_key_value(struct xbc_node *root, | |
327 | struct xbc_node **leaf) | |
328 | { | |
329 | /* tip must be passed */ | |
330 | if (WARN_ON(!leaf)) | |
331 | return NULL; | |
332 | ||
333 | *leaf = xbc_node_find_next_leaf(root, *leaf); | |
334 | if (!*leaf) | |
335 | return NULL; | |
336 | if ((*leaf)->child) | |
337 | return xbc_node_get_data(xbc_node_get_child(*leaf)); | |
338 | else | |
339 | return ""; /* No value key */ | |
340 | } | |
341 | ||
342 | /* XBC parse and tree build */ | |
343 | ||
a2de2f86 MH |
344 | static int __init xbc_init_node(struct xbc_node *node, char *data, u32 flag) |
345 | { | |
346 | unsigned long offset = data - xbc_data; | |
347 | ||
348 | if (WARN_ON(offset >= XBC_DATA_MAX)) | |
349 | return -EINVAL; | |
350 | ||
351 | node->data = (u16)offset | flag; | |
352 | node->child = 0; | |
353 | node->next = 0; | |
354 | ||
355 | return 0; | |
356 | } | |
357 | ||
76db5a27 MH |
358 | static struct xbc_node * __init xbc_add_node(char *data, u32 flag) |
359 | { | |
360 | struct xbc_node *node; | |
76db5a27 MH |
361 | |
362 | if (xbc_node_num == XBC_NODE_MAX) | |
363 | return NULL; | |
364 | ||
365 | node = &xbc_nodes[xbc_node_num++]; | |
a2de2f86 | 366 | if (xbc_init_node(node, data, flag) < 0) |
76db5a27 | 367 | return NULL; |
76db5a27 MH |
368 | |
369 | return node; | |
370 | } | |
371 | ||
372 | static inline __init struct xbc_node *xbc_last_sibling(struct xbc_node *node) | |
373 | { | |
374 | while (node->next) | |
375 | node = xbc_node_get_next(node); | |
376 | ||
377 | return node; | |
378 | } | |
379 | ||
ca24306d MH |
380 | static inline __init struct xbc_node *xbc_last_child(struct xbc_node *node) |
381 | { | |
382 | while (node->child) | |
383 | node = xbc_node_get_child(node); | |
384 | ||
385 | return node; | |
386 | } | |
387 | ||
e5efaeb8 | 388 | static struct xbc_node * __init __xbc_add_sibling(char *data, u32 flag, bool head) |
76db5a27 MH |
389 | { |
390 | struct xbc_node *sib, *node = xbc_add_node(data, flag); | |
391 | ||
392 | if (node) { | |
393 | if (!last_parent) { | |
e5efaeb8 | 394 | /* Ignore @head in this case */ |
76db5a27 MH |
395 | node->parent = XBC_NODE_MAX; |
396 | sib = xbc_last_sibling(xbc_nodes); | |
397 | sib->next = xbc_node_index(node); | |
398 | } else { | |
399 | node->parent = xbc_node_index(last_parent); | |
e5efaeb8 MH |
400 | if (!last_parent->child || head) { |
401 | node->next = last_parent->child; | |
76db5a27 MH |
402 | last_parent->child = xbc_node_index(node); |
403 | } else { | |
404 | sib = xbc_node_get_child(last_parent); | |
405 | sib = xbc_last_sibling(sib); | |
406 | sib->next = xbc_node_index(node); | |
407 | } | |
408 | } | |
597c0e3b MH |
409 | } else |
410 | xbc_parse_error("Too many nodes", data); | |
76db5a27 MH |
411 | |
412 | return node; | |
413 | } | |
414 | ||
e5efaeb8 MH |
415 | static inline struct xbc_node * __init xbc_add_sibling(char *data, u32 flag) |
416 | { | |
417 | return __xbc_add_sibling(data, flag, false); | |
418 | } | |
419 | ||
420 | static inline struct xbc_node * __init xbc_add_head_sibling(char *data, u32 flag) | |
421 | { | |
422 | return __xbc_add_sibling(data, flag, true); | |
423 | } | |
424 | ||
76db5a27 MH |
425 | static inline __init struct xbc_node *xbc_add_child(char *data, u32 flag) |
426 | { | |
427 | struct xbc_node *node = xbc_add_sibling(data, flag); | |
428 | ||
429 | if (node) | |
430 | last_parent = node; | |
431 | ||
432 | return node; | |
433 | } | |
434 | ||
435 | static inline __init bool xbc_valid_keyword(char *key) | |
436 | { | |
437 | if (key[0] == '\0') | |
438 | return false; | |
439 | ||
440 | while (isalnum(*key) || *key == '-' || *key == '_') | |
441 | key++; | |
442 | ||
443 | return *key == '\0'; | |
444 | } | |
445 | ||
446 | static char *skip_comment(char *p) | |
447 | { | |
448 | char *ret; | |
449 | ||
450 | ret = strchr(p, '\n'); | |
451 | if (!ret) | |
452 | ret = p + strlen(p); | |
453 | else | |
454 | ret++; | |
455 | ||
456 | return ret; | |
457 | } | |
458 | ||
459 | static char *skip_spaces_until_newline(char *p) | |
460 | { | |
461 | while (isspace(*p) && *p != '\n') | |
462 | p++; | |
463 | return p; | |
464 | } | |
465 | ||
ead1e19a | 466 | static int __init __xbc_open_brace(char *p) |
76db5a27 | 467 | { |
ead1e19a MH |
468 | /* Push the last key as open brace */ |
469 | open_brace[brace_index++] = xbc_node_index(last_parent); | |
470 | if (brace_index >= XBC_DEPTH_MAX) | |
471 | return xbc_parse_error("Exceed max depth of braces", p); | |
76db5a27 MH |
472 | |
473 | return 0; | |
474 | } | |
475 | ||
476 | static int __init __xbc_close_brace(char *p) | |
477 | { | |
ead1e19a MH |
478 | brace_index--; |
479 | if (!last_parent || brace_index < 0 || | |
480 | (open_brace[brace_index] != xbc_node_index(last_parent))) | |
76db5a27 MH |
481 | return xbc_parse_error("Unexpected closing brace", p); |
482 | ||
ead1e19a MH |
483 | if (brace_index == 0) |
484 | last_parent = NULL; | |
485 | else | |
486 | last_parent = &xbc_nodes[open_brace[brace_index - 1]]; | |
76db5a27 MH |
487 | |
488 | return 0; | |
489 | } | |
490 | ||
491 | /* | |
492 | * Return delimiter or error, no node added. As same as lib/cmdline.c, | |
493 | * you can use " around spaces, but can't escape " for value. | |
494 | */ | |
495 | static int __init __xbc_parse_value(char **__v, char **__n) | |
496 | { | |
497 | char *p, *v = *__v; | |
498 | int c, quotes = 0; | |
499 | ||
500 | v = skip_spaces(v); | |
501 | while (*v == '#') { | |
502 | v = skip_comment(v); | |
503 | v = skip_spaces(v); | |
504 | } | |
505 | if (*v == '"' || *v == '\'') { | |
506 | quotes = *v; | |
507 | v++; | |
508 | } | |
509 | p = v - 1; | |
510 | while ((c = *++p)) { | |
511 | if (!isprint(c) && !isspace(c)) | |
512 | return xbc_parse_error("Non printable value", p); | |
513 | if (quotes) { | |
514 | if (c != quotes) | |
515 | continue; | |
516 | quotes = 0; | |
517 | *p++ = '\0'; | |
518 | p = skip_spaces_until_newline(p); | |
519 | c = *p; | |
520 | if (c && !strchr(",;\n#}", c)) | |
521 | return xbc_parse_error("No value delimiter", p); | |
522 | if (*p) | |
523 | p++; | |
524 | break; | |
525 | } | |
526 | if (strchr(",;\n#}", c)) { | |
76db5a27 | 527 | *p++ = '\0'; |
c7af4ecd | 528 | v = strim(v); |
76db5a27 MH |
529 | break; |
530 | } | |
531 | } | |
532 | if (quotes) | |
533 | return xbc_parse_error("No closing quotes", p); | |
534 | if (c == '#') { | |
535 | p = skip_comment(p); | |
536 | c = '\n'; /* A comment must be treated as a newline */ | |
537 | } | |
538 | *__n = p; | |
539 | *__v = v; | |
540 | ||
541 | return c; | |
542 | } | |
543 | ||
544 | static int __init xbc_parse_array(char **__v) | |
545 | { | |
546 | struct xbc_node *node; | |
547 | char *next; | |
548 | int c = 0; | |
549 | ||
ca24306d MH |
550 | if (last_parent->child) |
551 | last_parent = xbc_node_get_child(last_parent); | |
552 | ||
76db5a27 MH |
553 | do { |
554 | c = __xbc_parse_value(__v, &next); | |
555 | if (c < 0) | |
556 | return c; | |
557 | ||
ca24306d | 558 | node = xbc_add_child(*__v, XBC_VALUE); |
76db5a27 MH |
559 | if (!node) |
560 | return -ENOMEM; | |
561 | *__v = next; | |
562 | } while (c == ','); | |
ca24306d | 563 | node->child = 0; |
76db5a27 MH |
564 | |
565 | return c; | |
566 | } | |
567 | ||
568 | static inline __init | |
569 | struct xbc_node *find_match_node(struct xbc_node *node, char *k) | |
570 | { | |
571 | while (node) { | |
572 | if (!strcmp(xbc_node_get_data(node), k)) | |
573 | break; | |
574 | node = xbc_node_get_next(node); | |
575 | } | |
576 | return node; | |
577 | } | |
578 | ||
579 | static int __init __xbc_add_key(char *k) | |
580 | { | |
a24d286f | 581 | struct xbc_node *node, *child; |
76db5a27 MH |
582 | |
583 | if (!xbc_valid_keyword(k)) | |
584 | return xbc_parse_error("Invalid keyword", k); | |
585 | ||
586 | if (unlikely(xbc_node_num == 0)) | |
587 | goto add_node; | |
588 | ||
589 | if (!last_parent) /* the first level */ | |
590 | node = find_match_node(xbc_nodes, k); | |
a24d286f MH |
591 | else { |
592 | child = xbc_node_get_child(last_parent); | |
e5efaeb8 | 593 | /* Since the value node is the first child, skip it. */ |
a24d286f | 594 | if (child && xbc_node_is_value(child)) |
e5efaeb8 | 595 | child = xbc_node_get_next(child); |
a24d286f MH |
596 | node = find_match_node(child, k); |
597 | } | |
76db5a27 MH |
598 | |
599 | if (node) | |
600 | last_parent = node; | |
601 | else { | |
602 | add_node: | |
603 | node = xbc_add_child(k, XBC_KEY); | |
604 | if (!node) | |
605 | return -ENOMEM; | |
606 | } | |
607 | return 0; | |
608 | } | |
609 | ||
610 | static int __init __xbc_parse_keys(char *k) | |
611 | { | |
612 | char *p; | |
613 | int ret; | |
614 | ||
615 | k = strim(k); | |
616 | while ((p = strchr(k, '.'))) { | |
617 | *p++ = '\0'; | |
618 | ret = __xbc_add_key(k); | |
619 | if (ret) | |
620 | return ret; | |
621 | k = p; | |
622 | } | |
623 | ||
624 | return __xbc_add_key(k); | |
625 | } | |
626 | ||
5f811c57 | 627 | static int __init xbc_parse_kv(char **k, char *v, int op) |
76db5a27 MH |
628 | { |
629 | struct xbc_node *prev_parent = last_parent; | |
4e4694d8 | 630 | struct xbc_node *child; |
76db5a27 MH |
631 | char *next; |
632 | int c, ret; | |
633 | ||
634 | ret = __xbc_parse_keys(*k); | |
635 | if (ret) | |
636 | return ret; | |
637 | ||
638 | c = __xbc_parse_value(&v, &next); | |
639 | if (c < 0) | |
640 | return c; | |
641 | ||
e5efaeb8 MH |
642 | child = xbc_node_get_child(last_parent); |
643 | if (child && xbc_node_is_value(child)) { | |
644 | if (op == '=') | |
645 | return xbc_parse_error("Value is redefined", v); | |
646 | if (op == ':') { | |
647 | unsigned short nidx = child->next; | |
648 | ||
649 | xbc_init_node(child, v, XBC_VALUE); | |
650 | child->next = nidx; /* keep subkeys */ | |
651 | goto array; | |
652 | } | |
653 | /* op must be '+' */ | |
654 | last_parent = xbc_last_child(child); | |
ca24306d | 655 | } |
e5efaeb8 MH |
656 | /* The value node should always be the first child */ |
657 | if (!xbc_add_head_sibling(v, XBC_VALUE)) | |
658 | return -ENOMEM; | |
76db5a27 | 659 | |
e5efaeb8 | 660 | array: |
76db5a27 MH |
661 | if (c == ',') { /* Array */ |
662 | c = xbc_parse_array(&next); | |
663 | if (c < 0) | |
664 | return c; | |
665 | } | |
666 | ||
667 | last_parent = prev_parent; | |
668 | ||
669 | if (c == '}') { | |
670 | ret = __xbc_close_brace(next - 1); | |
671 | if (ret < 0) | |
672 | return ret; | |
673 | } | |
674 | ||
675 | *k = next; | |
676 | ||
677 | return 0; | |
678 | } | |
679 | ||
680 | static int __init xbc_parse_key(char **k, char *n) | |
681 | { | |
682 | struct xbc_node *prev_parent = last_parent; | |
683 | int ret; | |
684 | ||
685 | *k = strim(*k); | |
686 | if (**k != '\0') { | |
687 | ret = __xbc_parse_keys(*k); | |
688 | if (ret) | |
689 | return ret; | |
690 | last_parent = prev_parent; | |
691 | } | |
692 | *k = n; | |
693 | ||
694 | return 0; | |
695 | } | |
696 | ||
697 | static int __init xbc_open_brace(char **k, char *n) | |
698 | { | |
699 | int ret; | |
700 | ||
701 | ret = __xbc_parse_keys(*k); | |
702 | if (ret) | |
703 | return ret; | |
704 | *k = n; | |
705 | ||
ead1e19a | 706 | return __xbc_open_brace(n - 1); |
76db5a27 MH |
707 | } |
708 | ||
709 | static int __init xbc_close_brace(char **k, char *n) | |
710 | { | |
711 | int ret; | |
712 | ||
713 | ret = xbc_parse_key(k, n); | |
714 | if (ret) | |
715 | return ret; | |
716 | /* k is updated in xbc_parse_key() */ | |
717 | ||
718 | return __xbc_close_brace(n - 1); | |
719 | } | |
720 | ||
721 | static int __init xbc_verify_tree(void) | |
722 | { | |
723 | int i, depth, len, wlen; | |
724 | struct xbc_node *n, *m; | |
725 | ||
ead1e19a MH |
726 | /* Brace closing */ |
727 | if (brace_index) { | |
728 | n = &xbc_nodes[open_brace[brace_index]]; | |
729 | return xbc_parse_error("Brace is not closed", | |
730 | xbc_node_get_data(n)); | |
731 | } | |
732 | ||
76db5a27 | 733 | /* Empty tree */ |
597c0e3b MH |
734 | if (xbc_node_num == 0) { |
735 | xbc_parse_error("Empty config", xbc_data); | |
76db5a27 | 736 | return -ENOENT; |
597c0e3b | 737 | } |
76db5a27 MH |
738 | |
739 | for (i = 0; i < xbc_node_num; i++) { | |
740 | if (xbc_nodes[i].next > xbc_node_num) { | |
741 | return xbc_parse_error("No closing brace", | |
742 | xbc_node_get_data(xbc_nodes + i)); | |
743 | } | |
744 | } | |
745 | ||
746 | /* Key tree limitation check */ | |
747 | n = &xbc_nodes[0]; | |
748 | depth = 1; | |
749 | len = 0; | |
750 | ||
751 | while (n) { | |
752 | wlen = strlen(xbc_node_get_data(n)) + 1; | |
753 | len += wlen; | |
754 | if (len > XBC_KEYLEN_MAX) | |
755 | return xbc_parse_error("Too long key length", | |
756 | xbc_node_get_data(n)); | |
757 | ||
758 | m = xbc_node_get_child(n); | |
759 | if (m && xbc_node_is_key(m)) { | |
760 | n = m; | |
761 | depth++; | |
762 | if (depth > XBC_DEPTH_MAX) | |
763 | return xbc_parse_error("Too many key words", | |
764 | xbc_node_get_data(n)); | |
765 | continue; | |
766 | } | |
767 | len -= wlen; | |
768 | m = xbc_node_get_next(n); | |
769 | while (!m) { | |
770 | n = xbc_node_get_parent(n); | |
771 | if (!n) | |
772 | break; | |
773 | len -= strlen(xbc_node_get_data(n)) + 1; | |
774 | depth--; | |
775 | m = xbc_node_get_next(n); | |
776 | } | |
777 | n = m; | |
778 | } | |
779 | ||
780 | return 0; | |
781 | } | |
782 | ||
783 | /** | |
784 | * xbc_destroy_all() - Clean up all parsed bootconfig | |
785 | * | |
786 | * This clears all data structures of parsed bootconfig on memory. | |
787 | * If you need to reuse xbc_init() with new boot config, you can | |
788 | * use this. | |
789 | */ | |
790 | void __init xbc_destroy_all(void) | |
791 | { | |
792 | xbc_data = NULL; | |
793 | xbc_data_size = 0; | |
794 | xbc_node_num = 0; | |
77e02cf5 | 795 | memblock_free_ptr(xbc_nodes, sizeof(struct xbc_node) * XBC_NODE_MAX); |
a91e4f12 | 796 | xbc_nodes = NULL; |
ead1e19a | 797 | brace_index = 0; |
76db5a27 MH |
798 | } |
799 | ||
800 | /** | |
801 | * xbc_init() - Parse given XBC file and build XBC internal tree | |
802 | * @buf: boot config text | |
89b74cac MH |
803 | * @emsg: A pointer of const char * to store the error message |
804 | * @epos: A pointer of int to store the error position | |
76db5a27 MH |
805 | * |
806 | * This parses the boot config text in @buf. @buf must be a | |
807 | * null terminated string and smaller than XBC_DATA_MAX. | |
0f0d0a77 MH |
808 | * Return the number of stored nodes (>0) if succeeded, or -errno |
809 | * if there is any error. | |
89b74cac MH |
810 | * In error cases, @emsg will be updated with an error message and |
811 | * @epos will be updated with the error position which is the byte offset | |
812 | * of @buf. If the error is not a parser error, @epos will be -1. | |
76db5a27 | 813 | */ |
89b74cac | 814 | int __init xbc_init(char *buf, const char **emsg, int *epos) |
76db5a27 MH |
815 | { |
816 | char *p, *q; | |
817 | int ret, c; | |
818 | ||
89b74cac MH |
819 | if (epos) |
820 | *epos = -1; | |
821 | ||
597c0e3b | 822 | if (xbc_data) { |
89b74cac MH |
823 | if (emsg) |
824 | *emsg = "Bootconfig is already initialized"; | |
76db5a27 | 825 | return -EBUSY; |
597c0e3b | 826 | } |
76db5a27 MH |
827 | |
828 | ret = strlen(buf); | |
597c0e3b | 829 | if (ret > XBC_DATA_MAX - 1 || ret == 0) { |
89b74cac MH |
830 | if (emsg) |
831 | *emsg = ret ? "Config data is too big" : | |
832 | "Config data is empty"; | |
76db5a27 | 833 | return -ERANGE; |
597c0e3b | 834 | } |
76db5a27 | 835 | |
a91e4f12 MH |
836 | xbc_nodes = memblock_alloc(sizeof(struct xbc_node) * XBC_NODE_MAX, |
837 | SMP_CACHE_BYTES); | |
838 | if (!xbc_nodes) { | |
89b74cac MH |
839 | if (emsg) |
840 | *emsg = "Failed to allocate bootconfig nodes"; | |
a91e4f12 MH |
841 | return -ENOMEM; |
842 | } | |
843 | memset(xbc_nodes, 0, sizeof(struct xbc_node) * XBC_NODE_MAX); | |
76db5a27 MH |
844 | xbc_data = buf; |
845 | xbc_data_size = ret + 1; | |
846 | last_parent = NULL; | |
847 | ||
848 | p = buf; | |
849 | do { | |
a2de2f86 | 850 | q = strpbrk(p, "{}=+;:\n#"); |
76db5a27 MH |
851 | if (!q) { |
852 | p = skip_spaces(p); | |
853 | if (*p != '\0') | |
854 | ret = xbc_parse_error("No delimiter", p); | |
855 | break; | |
856 | } | |
857 | ||
858 | c = *q; | |
859 | *q++ = '\0'; | |
860 | switch (c) { | |
a2de2f86 | 861 | case ':': |
5f811c57 MH |
862 | case '+': |
863 | if (*q++ != '=') { | |
a2de2f86 MH |
864 | ret = xbc_parse_error(c == '+' ? |
865 | "Wrong '+' operator" : | |
866 | "Wrong ':' operator", | |
5f811c57 MH |
867 | q - 2); |
868 | break; | |
869 | } | |
4c1ca831 | 870 | fallthrough; |
76db5a27 | 871 | case '=': |
5f811c57 | 872 | ret = xbc_parse_kv(&p, q, c); |
76db5a27 MH |
873 | break; |
874 | case '{': | |
875 | ret = xbc_open_brace(&p, q); | |
876 | break; | |
877 | case '#': | |
878 | q = skip_comment(q); | |
4c1ca831 | 879 | fallthrough; |
76db5a27 MH |
880 | case ';': |
881 | case '\n': | |
882 | ret = xbc_parse_key(&p, q); | |
883 | break; | |
884 | case '}': | |
885 | ret = xbc_close_brace(&p, q); | |
886 | break; | |
887 | } | |
888 | } while (!ret); | |
889 | ||
890 | if (!ret) | |
891 | ret = xbc_verify_tree(); | |
892 | ||
89b74cac MH |
893 | if (ret < 0) { |
894 | if (epos) | |
895 | *epos = xbc_err_pos; | |
896 | if (emsg) | |
897 | *emsg = xbc_err_msg; | |
76db5a27 | 898 | xbc_destroy_all(); |
89b74cac | 899 | } else |
0f0d0a77 | 900 | ret = xbc_node_num; |
76db5a27 MH |
901 | |
902 | return ret; | |
903 | } | |
904 | ||
905 | /** | |
906 | * xbc_debug_dump() - Dump current XBC node list | |
907 | * | |
908 | * Dump the current XBC node list on printk buffer for debug. | |
909 | */ | |
910 | void __init xbc_debug_dump(void) | |
911 | { | |
912 | int i; | |
913 | ||
914 | for (i = 0; i < xbc_node_num; i++) { | |
915 | pr_debug("[%d] %s (%s) .next=%d, .child=%d .parent=%d\n", i, | |
916 | xbc_node_get_data(xbc_nodes + i), | |
917 | xbc_node_is_value(xbc_nodes + i) ? "value" : "key", | |
918 | xbc_nodes[i].next, xbc_nodes[i].child, | |
919 | xbc_nodes[i].parent); | |
920 | } | |
921 | } |