309 lines · c
1/* SPDX-License-Identifier: GPL-2.0 */2#ifndef _LINUX_XBC_H3#define _LINUX_XBC_H4/*5 * Extra Boot Config6 * Copyright (C) 2019 Linaro Ltd.7 * Author: Masami Hiramatsu <mhiramat@kernel.org>8 */9 10#ifdef __KERNEL__11#include <linux/kernel.h>12#include <linux/types.h>13bool __init cmdline_has_extra_options(void);14#else /* !__KERNEL__ */15/*16 * NOTE: This is only for tools/bootconfig, because tools/bootconfig will17 * run the parser sanity test.18 * This does NOT mean linux/bootconfig.h is available in the user space.19 * However, if you change this file, please make sure the tools/bootconfig20 * has no issue on building and running.21 */22#endif23 24#define BOOTCONFIG_MAGIC "#BOOTCONFIG\n"25#define BOOTCONFIG_MAGIC_LEN 1226#define BOOTCONFIG_ALIGN_SHIFT 227#define BOOTCONFIG_ALIGN (1 << BOOTCONFIG_ALIGN_SHIFT)28#define BOOTCONFIG_ALIGN_MASK (BOOTCONFIG_ALIGN - 1)29 30/**31 * xbc_calc_checksum() - Calculate checksum of bootconfig32 * @data: Bootconfig data.33 * @size: The size of the bootconfig data.34 *35 * Calculate the checksum value of the bootconfig data.36 * The checksum will be used with the BOOTCONFIG_MAGIC and the size for37 * embedding the bootconfig in the initrd image.38 */39static inline __init uint32_t xbc_calc_checksum(void *data, uint32_t size)40{41 unsigned char *p = data;42 uint32_t ret = 0;43 44 while (size--)45 ret += *p++;46 47 return ret;48}49 50/* XBC tree node */51struct xbc_node {52 uint16_t next;53 uint16_t child;54 uint16_t parent;55 uint16_t data;56} __attribute__ ((__packed__));57 58#define XBC_KEY 059#define XBC_VALUE (1 << 15)60/* Maximum size of boot config is 32KB - 1 */61#define XBC_DATA_MAX (XBC_VALUE - 1)62 63#define XBC_NODE_MAX 819264#define XBC_KEYLEN_MAX 25665#define XBC_DEPTH_MAX 1666 67/* Node tree access raw APIs */68struct xbc_node * __init xbc_root_node(void);69int __init xbc_node_index(struct xbc_node *node);70struct xbc_node * __init xbc_node_get_parent(struct xbc_node *node);71struct xbc_node * __init xbc_node_get_child(struct xbc_node *node);72struct xbc_node * __init xbc_node_get_next(struct xbc_node *node);73const char * __init xbc_node_get_data(struct xbc_node *node);74 75/**76 * xbc_node_is_value() - Test the node is a value node77 * @node: An XBC node.78 *79 * Test the @node is a value node and return true if a value node, false if not.80 */81static inline __init bool xbc_node_is_value(struct xbc_node *node)82{83 return node->data & XBC_VALUE;84}85 86/**87 * xbc_node_is_key() - Test the node is a key node88 * @node: An XBC node.89 *90 * Test the @node is a key node and return true if a key node, false if not.91 */92static inline __init bool xbc_node_is_key(struct xbc_node *node)93{94 return !xbc_node_is_value(node);95}96 97/**98 * xbc_node_is_array() - Test the node is an arraied value node99 * @node: An XBC node.100 *101 * Test the @node is an arraied value node.102 */103static inline __init bool xbc_node_is_array(struct xbc_node *node)104{105 return xbc_node_is_value(node) && node->child != 0;106}107 108/**109 * xbc_node_is_leaf() - Test the node is a leaf key node110 * @node: An XBC node.111 *112 * Test the @node is a leaf key node which is a key node and has a value node113 * or no child. Returns true if it is a leaf node, or false if not.114 * Note that the leaf node can have subkey nodes in addition to the115 * value node.116 */117static inline __init bool xbc_node_is_leaf(struct xbc_node *node)118{119 return xbc_node_is_key(node) &&120 (!node->child || xbc_node_is_value(xbc_node_get_child(node)));121}122 123/* Tree-based key-value access APIs */124struct xbc_node * __init xbc_node_find_subkey(struct xbc_node *parent,125 const char *key);126 127const char * __init xbc_node_find_value(struct xbc_node *parent,128 const char *key,129 struct xbc_node **vnode);130 131struct xbc_node * __init xbc_node_find_next_leaf(struct xbc_node *root,132 struct xbc_node *leaf);133 134const char * __init xbc_node_find_next_key_value(struct xbc_node *root,135 struct xbc_node **leaf);136 137/**138 * xbc_find_value() - Find a value which matches the key139 * @key: Search key140 * @vnode: A container pointer of XBC value node.141 *142 * Search a value whose key matches @key from whole of XBC tree and return143 * the value if found. Found value node is stored in *@vnode.144 * Note that this can return 0-length string and store NULL in *@vnode for145 * key-only (non-value) entry.146 */147static inline const char * __init148xbc_find_value(const char *key, struct xbc_node **vnode)149{150 return xbc_node_find_value(NULL, key, vnode);151}152 153/**154 * xbc_find_node() - Find a node which matches the key155 * @key: Search key156 *157 * Search a (key) node whose key matches @key from whole of XBC tree and158 * return the node if found. If not found, returns NULL.159 */160static inline struct xbc_node * __init xbc_find_node(const char *key)161{162 return xbc_node_find_subkey(NULL, key);163}164 165/**166 * xbc_node_get_subkey() - Return the first subkey node if exists167 * @node: Parent node168 *169 * Return the first subkey node of the @node. If the @node has no child170 * or only value node, this will return NULL.171 */172static inline struct xbc_node * __init xbc_node_get_subkey(struct xbc_node *node)173{174 struct xbc_node *child = xbc_node_get_child(node);175 176 if (child && xbc_node_is_value(child))177 return xbc_node_get_next(child);178 else179 return child;180}181 182/**183 * xbc_array_for_each_value() - Iterate value nodes on an array184 * @anode: An XBC arraied value node185 * @value: A value186 *187 * Iterate array value nodes and values starts from @anode. This is expected to188 * be used with xbc_find_value() and xbc_node_find_value(), so that user can189 * process each array entry node.190 */191#define xbc_array_for_each_value(anode, value) \192 for (value = xbc_node_get_data(anode); anode != NULL ; \193 anode = xbc_node_get_child(anode), \194 value = anode ? xbc_node_get_data(anode) : NULL)195 196/**197 * xbc_node_for_each_child() - Iterate child nodes198 * @parent: An XBC node.199 * @child: Iterated XBC node.200 *201 * Iterate child nodes of @parent. Each child nodes are stored to @child.202 * The @child can be mixture of a value node and subkey nodes.203 */204#define xbc_node_for_each_child(parent, child) \205 for (child = xbc_node_get_child(parent); child != NULL ; \206 child = xbc_node_get_next(child))207 208/**209 * xbc_node_for_each_subkey() - Iterate child subkey nodes210 * @parent: An XBC node.211 * @child: Iterated XBC node.212 *213 * Iterate subkey nodes of @parent. Each child nodes are stored to @child.214 * The @child is only the subkey node.215 */216#define xbc_node_for_each_subkey(parent, child) \217 for (child = xbc_node_get_subkey(parent); child != NULL ; \218 child = xbc_node_get_next(child))219 220/**221 * xbc_node_for_each_array_value() - Iterate array entries of geven key222 * @node: An XBC node.223 * @key: A key string searched under @node224 * @anode: Iterated XBC node of array entry.225 * @value: Iterated value of array entry.226 *227 * Iterate array entries of given @key under @node. Each array entry node228 * is stored to @anode and @value. If the @node doesn't have @key node,229 * it does nothing.230 * Note that even if the found key node has only one value (not array)231 * this executes block once. However, if the found key node has no value232 * (key-only node), this does nothing. So don't use this for testing the233 * key-value pair existence.234 */235#define xbc_node_for_each_array_value(node, key, anode, value) \236 for (value = xbc_node_find_value(node, key, &anode); value != NULL; \237 anode = xbc_node_get_child(anode), \238 value = anode ? xbc_node_get_data(anode) : NULL)239 240/**241 * xbc_node_for_each_key_value() - Iterate key-value pairs under a node242 * @node: An XBC node.243 * @knode: Iterated key node244 * @value: Iterated value string245 *246 * Iterate key-value pairs under @node. Each key node and value string are247 * stored in @knode and @value respectively.248 */249#define xbc_node_for_each_key_value(node, knode, value) \250 for (knode = NULL, value = xbc_node_find_next_key_value(node, &knode);\251 knode != NULL; value = xbc_node_find_next_key_value(node, &knode))252 253/**254 * xbc_for_each_key_value() - Iterate key-value pairs255 * @knode: Iterated key node256 * @value: Iterated value string257 *258 * Iterate key-value pairs in whole XBC tree. Each key node and value string259 * are stored in @knode and @value respectively.260 */261#define xbc_for_each_key_value(knode, value) \262 xbc_node_for_each_key_value(NULL, knode, value)263 264/* Compose partial key */265int __init xbc_node_compose_key_after(struct xbc_node *root,266 struct xbc_node *node, char *buf, size_t size);267 268/**269 * xbc_node_compose_key() - Compose full key string of the XBC node270 * @node: An XBC node.271 * @buf: A buffer to store the key.272 * @size: The size of the @buf.273 *274 * Compose the full-length key of the @node into @buf. Returns the total275 * length of the key stored in @buf. Or returns -EINVAL if @node is NULL,276 * and -ERANGE if the key depth is deeper than max depth.277 */278static inline int __init xbc_node_compose_key(struct xbc_node *node,279 char *buf, size_t size)280{281 return xbc_node_compose_key_after(NULL, node, buf, size);282}283 284/* XBC node initializer */285int __init xbc_init(const char *buf, size_t size, const char **emsg, int *epos);286 287/* XBC node and size information */288int __init xbc_get_info(int *node_size, size_t *data_size);289 290/* XBC cleanup data structures */291void __init _xbc_exit(bool early);292 293static inline void xbc_exit(void)294{295 _xbc_exit(false);296}297 298/* XBC embedded bootconfig data in kernel */299#ifdef CONFIG_BOOT_CONFIG_EMBED300const char * __init xbc_get_embedded_bootconfig(size_t *size);301#else302static inline const char *xbc_get_embedded_bootconfig(size_t *size)303{304 return NULL;305}306#endif307 308#endif309