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