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 #include <linux/kernel.h>
  11 #include <linux/types.h>
  12
  13 #define BOOTCONFIG_MAGIC        "#BOOTCONFIG\n"
  14 #define BOOTCONFIG_MAGIC_LEN    12
  15 #define BOOTCONFIG_ALIGN_SHIFT  2
  16 #define BOOTCONFIG_ALIGN        (1 << BOOTCONFIG_ALIGN_SHIFT)
  17 #define BOOTCONFIG_ALIGN_MASK   (BOOTCONFIG_ALIGN - 1)
  18
  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
  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 {
  94         return xbc_node_is_value(node) && node->child != 0;
  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.
 103  * Note that the leaf node can have subkey nodes in addition to the
 104  * value node.
 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 */
 113 struct xbc_node * __init xbc_node_find_child(struct xbc_node *parent,
 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 {
 151         return xbc_node_find_child(NULL, key);
 152 }
 153
 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
 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 ;          \
 182              anode = xbc_node_get_child(anode),                         \
 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.
 191  * The @child can be mixture of a value node and subkey nodes.
 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
 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
 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
 217  * is stored to @anode and @value. If the @node doesn't have @key node,
 218  * it does nothing.
 219  * Note that even if the found key node has only one value (not array)
 220  * this executes block once. However, if the found key node has no value
 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; \
 226              anode = xbc_node_get_child(anode),                         \
 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 */
 274 int __init xbc_init(char *buf, const char **emsg, int *epos);
 275
 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