include/linux/bootconfig.h

   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  */
  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    1024
  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  */
  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  */
  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  */
 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  */
 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
 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  */
 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  */
 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  */
 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(void);
 291
 292 #endif