[linux-block.git] / include / linux / bootconfig.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_XBC_H
#define _LINUX_XBC_H
/*
 * Extra Boot Config
 * Copyright (C) 2019 Linaro Ltd.
 * Author: Masami Hiramatsu <mhiramat@kernel.org>
 */

#include <linux/kernel.h>
#include <linux/types.h>

#define BOOTCONFIG_MAGIC	"#BOOTCONFIG\n"
#define BOOTCONFIG_MAGIC_LEN	12
#define BOOTCONFIG_ALIGN_SHIFT	2
#define BOOTCONFIG_ALIGN	(1 << BOOTCONFIG_ALIGN_SHIFT)
#define BOOTCONFIG_ALIGN_MASK	(BOOTCONFIG_ALIGN - 1)

/**
 * xbc_calc_checksum() - Calculate checksum of bootconfig
 * @data: Bootconfig data.
 * @size: The size of the bootconfig data.
 *
 * Calculate the checksum value of the bootconfig data.
 * The checksum will be used with the BOOTCONFIG_MAGIC and the size for
 * embedding the bootconfig in the initrd image.
 */
static inline __init u32 xbc_calc_checksum(void *data, u32 size)
{
	unsigned char *p = data;
	u32 ret = 0;

	while (size--)
		ret += *p++;

	return ret;
}

/* XBC tree node */
struct xbc_node {
	u16 next;
	u16 child;
	u16 parent;
	u16 data;
} __attribute__ ((__packed__));

#define XBC_KEY		0
#define XBC_VALUE	(1 << 15)
/* Maximum size of boot config is 32KB - 1 */
#define XBC_DATA_MAX	(XBC_VALUE - 1)

#define XBC_NODE_MAX	1024
#define XBC_KEYLEN_MAX	256
#define XBC_DEPTH_MAX	16

/* Node tree access raw APIs */
struct xbc_node * __init xbc_root_node(void);
int __init xbc_node_index(struct xbc_node *node);
struct xbc_node * __init xbc_node_get_parent(struct xbc_node *node);
struct xbc_node * __init xbc_node_get_child(struct xbc_node *node);
struct xbc_node * __init xbc_node_get_next(struct xbc_node *node);
const char * __init xbc_node_get_data(struct xbc_node *node);

/**
 * xbc_node_is_value() - Test the node is a value node
 * @node: An XBC node.
 *
 * Test the @node is a value node and return true if a value node, false if not.
 */
static inline __init bool xbc_node_is_value(struct xbc_node *node)
{
	return node->data & XBC_VALUE;
}

/**
 * xbc_node_is_key() - Test the node is a key node
 * @node: An XBC node.
 *
 * Test the @node is a key node and return true if a key node, false if not.
 */
static inline __init bool xbc_node_is_key(struct xbc_node *node)
{
	return !xbc_node_is_value(node);
}

/**
 * xbc_node_is_array() - Test the node is an arraied value node
 * @node: An XBC node.
 *
 * Test the @node is an arraied value node.
 */
static inline __init bool xbc_node_is_array(struct xbc_node *node)
{
	return xbc_node_is_value(node) && node->child != 0;
}

/**
 * xbc_node_is_leaf() - Test the node is a leaf key node
 * @node: An XBC node.
 *
 * Test the @node is a leaf key node which is a key node and has a value node
 * or no child. Returns true if it is a leaf node, or false if not.
 * Note that the leaf node can have subkey nodes in addition to the
 * value node.
 */
static inline __init bool xbc_node_is_leaf(struct xbc_node *node)
{
	return xbc_node_is_key(node) &&
		(!node->child || xbc_node_is_value(xbc_node_get_child(node)));
}

/* Tree-based key-value access APIs */
struct xbc_node * __init xbc_node_find_subkey(struct xbc_node *parent,
					     const char *key);

const char * __init xbc_node_find_value(struct xbc_node *parent,
					const char *key,
					struct xbc_node **vnode);

struct xbc_node * __init xbc_node_find_next_leaf(struct xbc_node *root,
						 struct xbc_node *leaf);

const char * __init xbc_node_find_next_key_value(struct xbc_node *root,
						 struct xbc_node **leaf);

/**
 * xbc_find_value() - Find a value which matches the key
 * @key: Search key
 * @vnode: A container pointer of XBC value node.
 *
 * Search a value whose key matches @key from whole of XBC tree and return
 * the value if found. Found value node is stored in *@vnode.
 * Note that this can return 0-length string and store NULL in *@vnode for
 * key-only (non-value) entry.
 */
static inline const char * __init
xbc_find_value(const char *key, struct xbc_node **vnode)
{
	return xbc_node_find_value(NULL, key, vnode);
}

/**
 * xbc_find_node() - Find a node which matches the key
 * @key: Search key
 *
 * Search a (key) node whose key matches @key from whole of XBC tree and
 * return the node if found. If not found, returns NULL.
 */
static inline struct xbc_node * __init xbc_find_node(const char *key)
{
	return xbc_node_find_subkey(NULL, key);
}

/**
 * xbc_node_get_subkey() - Return the first subkey node if exists
 * @node: Parent node
 *
 * Return the first subkey node of the @node. If the @node has no child
 * or only value node, this will return NULL.
 */
static inline struct xbc_node * __init xbc_node_get_subkey(struct xbc_node *node)
{
	struct xbc_node *child = xbc_node_get_child(node);

	if (child && xbc_node_is_value(child))
		return xbc_node_get_next(child);
	else
		return child;
}

/**
 * xbc_array_for_each_value() - Iterate value nodes on an array
 * @anode: An XBC arraied value node
 * @value: A value
 *
 * Iterate array value nodes and values starts from @anode. This is expected to
 * be used with xbc_find_value() and xbc_node_find_value(), so that user can
 * process each array entry node.
 */
#define xbc_array_for_each_value(anode, value)				\
	for (value = xbc_node_get_data(anode); anode != NULL ;		\
	     anode = xbc_node_get_child(anode),				\
	     value = anode ? xbc_node_get_data(anode) : NULL)

/**
 * xbc_node_for_each_child() - Iterate child nodes
 * @parent: An XBC node.
 * @child: Iterated XBC node.
 *
 * Iterate child nodes of @parent. Each child nodes are stored to @child.
 * The @child can be mixture of a value node and subkey nodes.
 */
#define xbc_node_for_each_child(parent, child)				\
	for (child = xbc_node_get_child(parent); child != NULL ;	\
	     child = xbc_node_get_next(child))

/**
 * xbc_node_for_each_subkey() - Iterate child subkey nodes
 * @parent: An XBC node.
 * @child: Iterated XBC node.
 *
 * Iterate subkey nodes of @parent. Each child nodes are stored to @child.
 * The @child is only the subkey node.
 */
#define xbc_node_for_each_subkey(parent, child)				\
	for (child = xbc_node_get_subkey(parent); child != NULL ;	\
	     child = xbc_node_get_next(child))

/**
 * xbc_node_for_each_array_value() - Iterate array entries of geven key
 * @node: An XBC node.
 * @key: A key string searched under @node
 * @anode: Iterated XBC node of array entry.
 * @value: Iterated value of array entry.
 *
 * Iterate array entries of given @key under @node. Each array entry node
 * is stored to @anode and @value. If the @node doesn't have @key node,
 * it does nothing.
 * Note that even if the found key node has only one value (not array)
 * this executes block once. However, if the found key node has no value
 * (key-only node), this does nothing. So don't use this for testing the
 * key-value pair existence.
 */
#define xbc_node_for_each_array_value(node, key, anode, value)		\
	for (value = xbc_node_find_value(node, key, &anode); value != NULL; \
	     anode = xbc_node_get_child(anode),				\
	     value = anode ? xbc_node_get_data(anode) : NULL)

/**
 * xbc_node_for_each_key_value() - Iterate key-value pairs under a node
 * @node: An XBC node.
 * @knode: Iterated key node
 * @value: Iterated value string
 *
 * Iterate key-value pairs under @node. Each key node and value string are
 * stored in @knode and @value respectively.
 */
#define xbc_node_for_each_key_value(node, knode, value)			\
	for (knode = NULL, value = xbc_node_find_next_key_value(node, &knode);\
	     knode != NULL; value = xbc_node_find_next_key_value(node, &knode))

/**
 * xbc_for_each_key_value() - Iterate key-value pairs
 * @knode: Iterated key node
 * @value: Iterated value string
 *
 * Iterate key-value pairs in whole XBC tree. Each key node and value string
 * are stored in @knode and @value respectively.
 */
#define xbc_for_each_key_value(knode, value)				\
	xbc_node_for_each_key_value(NULL, knode, value)

/* Compose partial key */
int __init xbc_node_compose_key_after(struct xbc_node *root,
			struct xbc_node *node, char *buf, size_t size);

/**
 * xbc_node_compose_key() - Compose full key string of the XBC node
 * @node: An XBC node.
 * @buf: A buffer to store the key.
 * @size: The size of the @buf.
 *
 * Compose the full-length key of the @node into @buf. Returns the total
 * length of the key stored in @buf. Or returns -EINVAL if @node is NULL,
 * and -ERANGE if the key depth is deeper than max depth.
 */
static inline int __init xbc_node_compose_key(struct xbc_node *node,
					      char *buf, size_t size)
{
	return xbc_node_compose_key_after(NULL, node, buf, size);
}

/* XBC node initializer */
int __init xbc_init(char *buf, const char **emsg, int *epos);


/* XBC cleanup data structures */
void __init xbc_destroy_all(void);

/* Debug dump functions */
void __init xbc_debug_dump(void);

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