1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _LINUX_XBC_H
3 #define _LINUX_XBC_H
4 /*
5 * Extra Boot Config
6 * 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>
13 #else /* !__KERNEL__ */
14 /*
15 * NOTE: This is only for tools/bootconfig, because tools/bootconfig will
16 * run the parser sanity test.
17 * This does NOT mean linux/bootconfig.h is available in the user space.
18 * However, if you change this file, please make sure the tools/bootconfig
19 * has no issue on building and running.
20 */
21 #endif
22
23 #define BOOTCONFIG_MAGIC "#BOOTCONFIG\n"
24 #define BOOTCONFIG_MAGIC_LEN 12
25 #define BOOTCONFIG_ALIGN_SHIFT 2
26 #define BOOTCONFIG_ALIGN (1 << BOOTCONFIG_ALIGN_SHIFT)
27 #define BOOTCONFIG_ALIGN_MASK (BOOTCONFIG_ALIGN - 1)
28
29 /**
30 * xbc_calc_checksum() - Calculate checksum of bootconfig
31 * @data: Bootconfig data.
32 * @size: The size of the bootconfig data.
33 *
34 * Calculate the checksum value of the bootconfig data.
35 * The checksum will be used with the BOOTCONFIG_MAGIC and the size for
36 * embedding the bootconfig in the initrd image.
37 */
xbc_calc_checksum(void * data,uint32_t size)38 static inline __init uint32_t xbc_calc_checksum(void *data, uint32_t size)
39 {
40 unsigned char *p = data;
41 uint32_t ret = 0;
42
43 while (size--)
44 ret += *p++;
45
46 return ret;
47 }
48
49 /* XBC tree node */
50 struct xbc_node {
51 uint16_t next;
52 uint16_t child;
53 uint16_t parent;
54 uint16_t data;
55 } __attribute__ ((__packed__));
56
57 #define XBC_KEY 0
58 #define XBC_VALUE (1 << 15)
59 /* Maximum size of boot config is 32KB - 1 */
60 #define XBC_DATA_MAX (XBC_VALUE - 1)
61
62 #define XBC_NODE_MAX 8192
63 #define XBC_KEYLEN_MAX 256
64 #define XBC_DEPTH_MAX 16
65
66 /* Node tree access raw APIs */
67 struct xbc_node * __init xbc_root_node(void);
68 int __init xbc_node_index(struct xbc_node *node);
69 struct xbc_node * __init xbc_node_get_parent(struct xbc_node *node);
70 struct xbc_node * __init xbc_node_get_child(struct xbc_node *node);
71 struct xbc_node * __init xbc_node_get_next(struct xbc_node *node);
72 const char * __init xbc_node_get_data(struct xbc_node *node);
73
74 /**
75 * xbc_node_is_value() - Test the node is a value node
76 * @node: An XBC node.
77 *
78 * Test the @node is a value node and return true if a value node, false if not.
79 */
xbc_node_is_value(struct xbc_node * node)80 static inline __init bool xbc_node_is_value(struct xbc_node *node)
81 {
82 return node->data & XBC_VALUE;
83 }
84
85 /**
86 * xbc_node_is_key() - Test the node is a key node
87 * @node: An XBC node.
88 *
89 * Test the @node is a key node and return true if a key node, false if not.
90 */
xbc_node_is_key(struct xbc_node * node)91 static inline __init bool xbc_node_is_key(struct xbc_node *node)
92 {
93 return !xbc_node_is_value(node);
94 }
95
96 /**
97 * xbc_node_is_array() - Test the node is an arraied value node
98 * @node: An XBC node.
99 *
100 * Test the @node is an arraied value node.
101 */
xbc_node_is_array(struct xbc_node * node)102 static inline __init bool xbc_node_is_array(struct xbc_node *node)
103 {
104 return xbc_node_is_value(node) && node->child != 0;
105 }
106
107 /**
108 * xbc_node_is_leaf() - Test the node is a leaf key node
109 * @node: An XBC node.
110 *
111 * Test the @node is a leaf key node which is a key node and has a value node
112 * or no child. Returns true if it is a leaf node, or false if not.
113 * Note that the leaf node can have subkey nodes in addition to the
114 * value node.
115 */
xbc_node_is_leaf(struct xbc_node * node)116 static inline __init bool xbc_node_is_leaf(struct xbc_node *node)
117 {
118 return xbc_node_is_key(node) &&
119 (!node->child || xbc_node_is_value(xbc_node_get_child(node)));
120 }
121
122 /* Tree-based key-value access APIs */
123 struct xbc_node * __init xbc_node_find_subkey(struct xbc_node *parent,
124 const char *key);
125
126 const char * __init xbc_node_find_value(struct xbc_node *parent,
127 const char *key,
128 struct xbc_node **vnode);
129
130 struct xbc_node * __init xbc_node_find_next_leaf(struct xbc_node *root,
131 struct xbc_node *leaf);
132
133 const char * __init xbc_node_find_next_key_value(struct xbc_node *root,
134 struct xbc_node **leaf);
135
136 /**
137 * xbc_find_value() - Find a value which matches the key
138 * @key: Search key
139 * @vnode: A container pointer of XBC value node.
140 *
141 * Search a value whose key matches @key from whole of XBC tree and return
142 * the value if found. Found value node is stored in *@vnode.
143 * Note that this can return 0-length string and store NULL in *@vnode for
144 * key-only (non-value) entry.
145 */
146 static inline const char * __init
xbc_find_value(const char * key,struct xbc_node ** vnode)147 xbc_find_value(const char *key, struct xbc_node **vnode)
148 {
149 return xbc_node_find_value(NULL, key, vnode);
150 }
151
152 /**
153 * xbc_find_node() - Find a node which matches the key
154 * @key: Search key
155 *
156 * Search a (key) node whose key matches @key from whole of XBC tree and
157 * return the node if found. If not found, returns NULL.
158 */
xbc_find_node(const char * key)159 static inline struct xbc_node * __init xbc_find_node(const char *key)
160 {
161 return xbc_node_find_subkey(NULL, key);
162 }
163
164 /**
165 * xbc_node_get_subkey() - Return the first subkey node if exists
166 * @node: Parent node
167 *
168 * Return the first subkey node of the @node. If the @node has no child
169 * or only value node, this will return NULL.
170 */
xbc_node_get_subkey(struct xbc_node * node)171 static inline struct xbc_node * __init xbc_node_get_subkey(struct xbc_node *node)
172 {
173 struct xbc_node *child = xbc_node_get_child(node);
174
175 if (child && xbc_node_is_value(child))
176 return xbc_node_get_next(child);
177 else
178 return child;
179 }
180
181 /**
182 * xbc_array_for_each_value() - Iterate value nodes on an array
183 * @anode: An XBC arraied value node
184 * @value: A value
185 *
186 * Iterate array value nodes and values starts from @anode. This is expected to
187 * be used with xbc_find_value() and xbc_node_find_value(), so that user can
188 * process each array entry node.
189 */
190 #define xbc_array_for_each_value(anode, value) \
191 for (value = xbc_node_get_data(anode); anode != NULL ; \
192 anode = xbc_node_get_child(anode), \
193 value = anode ? xbc_node_get_data(anode) : NULL)
194
195 /**
196 * xbc_node_for_each_child() - Iterate child nodes
197 * @parent: An XBC node.
198 * @child: Iterated XBC node.
199 *
200 * Iterate child nodes of @parent. Each child nodes are stored to @child.
201 * The @child can be mixture of a value node and subkey nodes.
202 */
203 #define xbc_node_for_each_child(parent, child) \
204 for (child = xbc_node_get_child(parent); child != NULL ; \
205 child = xbc_node_get_next(child))
206
207 /**
208 * xbc_node_for_each_subkey() - Iterate child subkey nodes
209 * @parent: An XBC node.
210 * @child: Iterated XBC node.
211 *
212 * Iterate subkey nodes of @parent. Each child nodes are stored to @child.
213 * The @child is only the subkey node.
214 */
215 #define xbc_node_for_each_subkey(parent, child) \
216 for (child = xbc_node_get_subkey(parent); child != NULL ; \
217 child = xbc_node_get_next(child))
218
219 /**
220 * xbc_node_for_each_array_value() - Iterate array entries of geven key
221 * @node: An XBC node.
222 * @key: A key string searched under @node
223 * @anode: Iterated XBC node of array entry.
224 * @value: Iterated value of array entry.
225 *
226 * Iterate array entries of given @key under @node. Each array entry node
227 * is stored to @anode and @value. If the @node doesn't have @key node,
228 * it does nothing.
229 * Note that even if the found key node has only one value (not array)
230 * this executes block once. However, if the found key node has no value
231 * (key-only node), this does nothing. So don't use this for testing the
232 * key-value pair existence.
233 */
234 #define xbc_node_for_each_array_value(node, key, anode, value) \
235 for (value = xbc_node_find_value(node, key, &anode); value != NULL; \
236 anode = xbc_node_get_child(anode), \
237 value = anode ? xbc_node_get_data(anode) : NULL)
238
239 /**
240 * xbc_node_for_each_key_value() - Iterate key-value pairs under a node
241 * @node: An XBC node.
242 * @knode: Iterated key node
243 * @value: Iterated value string
244 *
245 * Iterate key-value pairs under @node. Each key node and value string are
246 * stored in @knode and @value respectively.
247 */
248 #define xbc_node_for_each_key_value(node, knode, value) \
249 for (knode = NULL, value = xbc_node_find_next_key_value(node, &knode);\
250 knode != NULL; value = xbc_node_find_next_key_value(node, &knode))
251
252 /**
253 * xbc_for_each_key_value() - Iterate key-value pairs
254 * @knode: Iterated key node
255 * @value: Iterated value string
256 *
257 * Iterate key-value pairs in whole XBC tree. Each key node and value string
258 * are stored in @knode and @value respectively.
259 */
260 #define xbc_for_each_key_value(knode, value) \
261 xbc_node_for_each_key_value(NULL, knode, value)
262
263 /* Compose partial key */
264 int __init xbc_node_compose_key_after(struct xbc_node *root,
265 struct xbc_node *node, char *buf, size_t size);
266
267 /**
268 * xbc_node_compose_key() - Compose full key string of the XBC node
269 * @node: An XBC node.
270 * @buf: A buffer to store the key.
271 * @size: The size of the @buf.
272 *
273 * Compose the full-length key of the @node into @buf. Returns the total
274 * length of the key stored in @buf. Or returns -EINVAL if @node is NULL,
275 * and -ERANGE if the key depth is deeper than max depth.
276 */
xbc_node_compose_key(struct xbc_node * node,char * buf,size_t size)277 static inline int __init xbc_node_compose_key(struct xbc_node *node,
278 char *buf, size_t size)
279 {
280 return xbc_node_compose_key_after(NULL, node, buf, size);
281 }
282
283 /* XBC node initializer */
284 int __init xbc_init(const char *buf, size_t size, const char **emsg, int *epos);
285
286 /* XBC node and size information */
287 int __init xbc_get_info(int *node_size, size_t *data_size);
288
289 /* XBC cleanup data structures */
290 void __init _xbc_exit(bool early);
291
xbc_exit(void)292 static inline void xbc_exit(void)
293 {
294 _xbc_exit(false);
295 }
296
297 /* XBC embedded bootconfig data in kernel */
298 #ifdef CONFIG_BOOT_CONFIG_EMBED
299 const char * __init xbc_get_embedded_bootconfig(size_t *size);
300 #else
xbc_get_embedded_bootconfig(size_t * size)301 static inline const char *xbc_get_embedded_bootconfig(size_t *size)
302 {
303 return NULL;
304 }
305 #endif
306
307 #endif
308