tools/bootconfig/main.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Boot config tool for initrd image
   4  */
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <sys/types.h>
   8 #include <sys/stat.h>
   9 #include <fcntl.h>
  10 #include <unistd.h>
  11 #include <string.h>
  12 #include <errno.h>
  13 #include <endian.h>
  14
  15 #include <linux/bootconfig.h>
  16
  17 #define pr_err(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)
  18
  19 static int xbc_show_value(struct xbc_node *node, bool semicolon)
  20 {
  21         const char *val, *eol;
  22         char q;
  23         int i = 0;
  24
  25         eol = semicolon ? ";\n" : "\n";
  26         xbc_array_for_each_value(node, val) {
  27                 if (strchr(val, '"'))
  28                         q = '\'';
  29                 else
  30                         q = '"';
  31                 printf("%c%s%c%s", q, val, q, xbc_node_is_array(node) ? ", " : eol);
  32                 i++;
  33         }
  34         return i;
  35 }
  36
  37 static void xbc_show_compact_tree(void)
  38 {
  39         struct xbc_node *node, *cnode = NULL, *vnode;
  40         int depth = 0, i;
  41
  42         node = xbc_root_node();
  43         while (node && xbc_node_is_key(node)) {
  44                 for (i = 0; i < depth; i++)
  45                         printf("\t");
  46                 if (!cnode)
  47                         cnode = xbc_node_get_child(node);
  48                 while (cnode && xbc_node_is_key(cnode) && !cnode->next) {
  49                         vnode = xbc_node_get_child(cnode);
  50                         /*
  51                          * If @cnode has value and subkeys, this
  52                          * should show it as below.
  53                          *
  54                          * key(@node) {
  55                          *      key(@cnode) = value;
  56                          *      key(@cnode) {
  57                          *          subkeys;
  58                          *      }
  59                          * }
  60                          */
  61                         if (vnode && xbc_node_is_value(vnode) && vnode->next)
  62                                 break;
  63                         printf("%s.", xbc_node_get_data(node));
  64                         node = cnode;
  65                         cnode = vnode;
  66                 }
  67                 if (cnode && xbc_node_is_key(cnode)) {
  68                         printf("%s {\n", xbc_node_get_data(node));
  69                         depth++;
  70                         node = cnode;
  71                         cnode = NULL;
  72                         continue;
  73                 } else if (cnode && xbc_node_is_value(cnode)) {
  74                         printf("%s = ", xbc_node_get_data(node));
  75                         xbc_show_value(cnode, true);
  76                         /*
  77                          * If @node has value and subkeys, continue
  78                          * looping on subkeys with same node.
  79                          */
  80                         if (cnode->next) {
  81                                 cnode = xbc_node_get_next(cnode);
  82                                 continue;
  83                         }
  84                 } else {
  85                         printf("%s;\n", xbc_node_get_data(node));
  86                 }
  87                 cnode = NULL;
  88
  89                 if (node->next) {
  90                         node = xbc_node_get_next(node);
  91                         continue;
  92                 }
  93                 while (!node->next) {
  94                         node = xbc_node_get_parent(node);
  95                         if (!node)
  96                                 return;
  97                         if (!xbc_node_get_child(node)->next)
  98                                 continue;
  99                         if (depth) {
 100                                 depth--;
 101                                 for (i = 0; i < depth; i++)
 102                                         printf("\t");
 103                                 printf("}\n");
 104                         }
 105                 }
 106                 node = xbc_node_get_next(node);
 107         }
 108 }
 109
 110 static void xbc_show_list(void)
 111 {
 112         char key[XBC_KEYLEN_MAX];
 113         struct xbc_node *leaf;
 114         const char *val;
 115         int ret;
 116
 117         xbc_for_each_key_value(leaf, val) {
 118                 ret = xbc_node_compose_key(leaf, key, XBC_KEYLEN_MAX);
 119                 if (ret < 0) {
 120                         fprintf(stderr, "Failed to compose key %d\n", ret);
 121                         break;
 122                 }
 123                 printf("%s = ", key);
 124                 if (!val || val[0] == '\0') {
 125                         printf("\"\"\n");
 126                         continue;
 127                 }
 128                 xbc_show_value(xbc_node_get_child(leaf), false);
 129         }
 130 }
 131
 132 #define PAGE_SIZE       4096
 133
 134 static int load_xbc_fd(int fd, char **buf, int size)
 135 {
 136         int ret;
 137
 138         *buf = malloc(size + 1);
 139         if (!*buf)
 140                 return -ENOMEM;
 141
 142         ret = read(fd, *buf, size);
 143         if (ret < 0)
 144                 return -errno;
 145         (*buf)[size] = '\0';
 146
 147         return ret;
 148 }
 149
 150 /* Return the read size or -errno */
 151 static int load_xbc_file(const char *path, char **buf)
 152 {
 153         struct stat stat;
 154         int fd, ret;
 155
 156         fd = open(path, O_RDONLY);
 157         if (fd < 0)
 158                 return -errno;
 159         ret = fstat(fd, &stat);
 160         if (ret < 0)
 161                 return -errno;
 162
 163         ret = load_xbc_fd(fd, buf, stat.st_size);
 164
 165         close(fd);
 166
 167         return ret;
 168 }
 169
 170 static int pr_errno(const char *msg, int err)
 171 {
 172         pr_err("%s: %d\n", msg, err);
 173         return err;
 174 }
 175
 176 static int load_xbc_from_initrd(int fd, char **buf)
 177 {
 178         struct stat stat;
 179         int ret;
 180         uint32_t size = 0, csum = 0, rcsum;
 181         char magic[BOOTCONFIG_MAGIC_LEN];
 182         const char *msg;
 183
 184         ret = fstat(fd, &stat);
 185         if (ret < 0)
 186                 return -errno;
 187
 188         if (stat.st_size < 8 + BOOTCONFIG_MAGIC_LEN)
 189                 return 0;
 190
 191         if (lseek(fd, -BOOTCONFIG_MAGIC_LEN, SEEK_END) < 0)
 192                 return pr_errno("Failed to lseek for magic", -errno);
 193
 194         if (read(fd, magic, BOOTCONFIG_MAGIC_LEN) < 0)
 195                 return pr_errno("Failed to read", -errno);
 196
 197         /* Check the bootconfig magic bytes */
 198         if (memcmp(magic, BOOTCONFIG_MAGIC, BOOTCONFIG_MAGIC_LEN) != 0)
 199                 return 0;
 200
 201         if (lseek(fd, -(8 + BOOTCONFIG_MAGIC_LEN), SEEK_END) < 0)
 202                 return pr_errno("Failed to lseek for size", -errno);
 203
 204         if (read(fd, &size, sizeof(uint32_t)) < 0)
 205                 return pr_errno("Failed to read size", -errno);
 206         size = le32toh(size);
 207
 208         if (read(fd, &csum, sizeof(uint32_t)) < 0)
 209                 return pr_errno("Failed to read checksum", -errno);
 210         csum = le32toh(csum);
 211
 212         /* Wrong size error  */
 213         if (stat.st_size < size + 8 + BOOTCONFIG_MAGIC_LEN) {
 214                 pr_err("bootconfig size is too big\n");
 215                 return -E2BIG;
 216         }
 217
 218         if (lseek(fd, stat.st_size - (size + 8 + BOOTCONFIG_MAGIC_LEN),
 219                   SEEK_SET) < 0)
 220                 return pr_errno("Failed to lseek", -errno);
 221
 222         ret = load_xbc_fd(fd, buf, size);
 223         if (ret < 0)
 224                 return ret;
 225
 226         /* Wrong Checksum */
 227         rcsum = xbc_calc_checksum(*buf, size);
 228         if (csum != rcsum) {
 229                 pr_err("checksum error: %d != %d\n", csum, rcsum);
 230                 return -EINVAL;
 231         }
 232
 233         ret = xbc_init(*buf, size, &msg, NULL);
 234         /* Wrong data */
 235         if (ret < 0) {
 236                 pr_err("parse error: %s.\n", msg);
 237                 return ret;
 238         }
 239
 240         return size;
 241 }
 242
 243 static void show_xbc_error(const char *data, const char *msg, int pos)
 244 {
 245         int lin = 1, col, i;
 246
 247         if (pos < 0) {
 248                 pr_err("Error: %s.\n", msg);
 249                 return;
 250         }
 251
 252         /* Note that pos starts from 0 but lin and col should start from 1. */
 253         col = pos + 1;
 254         for (i = 0; i < pos; i++) {
 255                 if (data[i] == '\n') {
 256                         lin++;
 257                         col = pos - i;
 258                 }
 259         }
 260         pr_err("Parse Error: %s at %d:%d\n", msg, lin, col);
 261
 262 }
 263
 264 static int init_xbc_with_error(char *buf, int len)
 265 {
 266         char *copy = strdup(buf);
 267         const char *msg;
 268         int ret, pos;
 269
 270         if (!copy)
 271                 return -ENOMEM;
 272
 273         ret = xbc_init(buf, len, &msg, &pos);
 274         if (ret < 0)
 275                 show_xbc_error(copy, msg, pos);
 276         free(copy);
 277
 278         return ret;
 279 }
 280
 281 static int show_xbc(const char *path, bool list)
 282 {
 283         int ret, fd;
 284         char *buf = NULL;
 285         struct stat st;
 286
 287         ret = stat(path, &st);
 288         if (ret < 0) {
 289                 ret = -errno;
 290                 pr_err("Failed to stat %s: %d\n", path, ret);
 291                 return ret;
 292         }
 293
 294         fd = open(path, O_RDONLY);
 295         if (fd < 0) {
 296                 ret = -errno;
 297                 pr_err("Failed to open initrd %s: %d\n", path, ret);
 298                 return ret;
 299         }
 300
 301         ret = load_xbc_from_initrd(fd, &buf);
 302         close(fd);
 303         if (ret < 0) {
 304                 pr_err("Failed to load a boot config from initrd: %d\n", ret);
 305                 goto out;
 306         }
 307         /* Assume a bootconfig file if it is enough small */
 308         if (ret == 0 && st.st_size <= XBC_DATA_MAX) {
 309                 ret = load_xbc_file(path, &buf);
 310                 if (ret < 0) {
 311                         pr_err("Failed to load a boot config: %d\n", ret);
 312                         goto out;
 313                 }
 314                 if (init_xbc_with_error(buf, ret) < 0)
 315                         goto out;
 316         }
 317         if (list)
 318                 xbc_show_list();
 319         else
 320                 xbc_show_compact_tree();
 321         ret = 0;
 322 out:
 323         free(buf);
 324
 325         return ret;
 326 }
 327
 328 static int delete_xbc(const char *path)
 329 {
 330         struct stat stat;
 331         int ret = 0, fd, size;
 332         char *buf = NULL;
 333
 334         fd = open(path, O_RDWR);
 335         if (fd < 0) {
 336                 ret = -errno;
 337                 pr_err("Failed to open initrd %s: %d\n", path, ret);
 338                 return ret;
 339         }
 340
 341         size = load_xbc_from_initrd(fd, &buf);
 342         if (size < 0) {
 343                 ret = size;
 344                 pr_err("Failed to load a boot config from initrd: %d\n", ret);
 345         } else if (size > 0) {
 346                 ret = fstat(fd, &stat);
 347                 if (!ret)
 348                         ret = ftruncate(fd, stat.st_size
 349                                         - size - 8 - BOOTCONFIG_MAGIC_LEN);
 350                 if (ret)
 351                         ret = -errno;
 352         } /* Ignore if there is no boot config in initrd */
 353
 354         close(fd);
 355         free(buf);
 356
 357         return ret;
 358 }
 359
 360 static int apply_xbc(const char *path, const char *xbc_path)
 361 {
 362         char *buf, *data, *p;
 363         size_t total_size;
 364         struct stat stat;
 365         const char *msg;
 366         uint32_t size, csum;
 367         int pos, pad;
 368         int ret, fd;
 369
 370         ret = load_xbc_file(xbc_path, &buf);
 371         if (ret < 0) {
 372                 pr_err("Failed to load %s : %d\n", xbc_path, ret);
 373                 return ret;
 374         }
 375         size = strlen(buf) + 1;
 376         csum = xbc_calc_checksum(buf, size);
 377
 378         /* Backup the bootconfig data */
 379         data = calloc(size + BOOTCONFIG_ALIGN +
 380                       sizeof(uint32_t) + sizeof(uint32_t) + BOOTCONFIG_MAGIC_LEN, 1);
 381         if (!data)
 382                 return -ENOMEM;
 383         memcpy(data, buf, size);
 384
 385         /* Check the data format */
 386         ret = xbc_init(buf, size, &msg, &pos);
 387         if (ret < 0) {
 388                 show_xbc_error(data, msg, pos);
 389                 free(data);
 390                 free(buf);
 391
 392                 return ret;
 393         }
 394         printf("Apply %s to %s\n", xbc_path, path);
 395         xbc_get_info(&ret, NULL);
 396         printf("\tNumber of nodes: %d\n", ret);
 397         printf("\tSize: %u bytes\n", (unsigned int)size);
 398         printf("\tChecksum: %d\n", (unsigned int)csum);
 399
 400         /* TODO: Check the options by schema */
 401         xbc_exit();
 402         free(buf);
 403
 404         /* Remove old boot config if exists */
 405         ret = delete_xbc(path);
 406         if (ret < 0) {
 407                 pr_err("Failed to delete previous boot config: %d\n", ret);
 408                 free(data);
 409                 return ret;
 410         }
 411
 412         /* Apply new one */
 413         fd = open(path, O_RDWR | O_APPEND);
 414         if (fd < 0) {
 415                 ret = -errno;
 416                 pr_err("Failed to open %s: %d\n", path, ret);
 417                 free(data);
 418                 return ret;
 419         }
 420         /* TODO: Ensure the @path is initramfs/initrd image */
 421         if (fstat(fd, &stat) < 0) {
 422                 ret = -errno;
 423                 pr_err("Failed to get the size of %s\n", path);
 424                 goto out;
 425         }
 426
 427         /* To align up the total size to BOOTCONFIG_ALIGN, get padding size */
 428         total_size = stat.st_size + size + sizeof(uint32_t) * 2 + BOOTCONFIG_MAGIC_LEN;
 429         pad = ((total_size + BOOTCONFIG_ALIGN - 1) & (~BOOTCONFIG_ALIGN_MASK)) - total_size;
 430         size += pad;
 431
 432         /* Add a footer */
 433         p = data + size;
 434         *(uint32_t *)p = htole32(size);
 435         p += sizeof(uint32_t);
 436
 437         *(uint32_t *)p = htole32(csum);
 438         p += sizeof(uint32_t);
 439
 440         memcpy(p, BOOTCONFIG_MAGIC, BOOTCONFIG_MAGIC_LEN);
 441         p += BOOTCONFIG_MAGIC_LEN;
 442
 443         total_size = p - data;
 444
 445         ret = write(fd, data, total_size);
 446         if (ret < total_size) {
 447                 if (ret < 0)
 448                         ret = -errno;
 449                 pr_err("Failed to apply a boot config: %d\n", ret);
 450                 if (ret >= 0)
 451                         goto out_rollback;
 452         } else
 453                 ret = 0;
 454
 455 out:
 456         close(fd);
 457         free(data);
 458
 459         return ret;
 460
 461 out_rollback:
 462         /* Map the partial write to -ENOSPC */
 463         if (ret >= 0)
 464                 ret = -ENOSPC;
 465         if (ftruncate(fd, stat.st_size) < 0) {
 466                 ret = -errno;
 467                 pr_err("Failed to rollback the write error: %d\n", ret);
 468                 pr_err("The initrd %s may be corrupted. Recommend to rebuild.\n", path);
 469         }
 470         goto out;
 471 }
 472
 473 static int usage(void)
 474 {
 475         printf("Usage: bootconfig [OPTIONS] <INITRD>\n"
 476                 "Or     bootconfig <CONFIG>\n"
 477                 " Apply, delete or show boot config to initrd.\n"
 478                 " Options:\n"
 479                 "               -a <config>: Apply boot config to initrd\n"
 480                 "               -d : Delete boot config file from initrd\n"
 481                 "               -l : list boot config in initrd or file\n\n"
 482                 " If no option is given, show the bootconfig in the given file.\n");
 483         return -1;
 484 }
 485
 486 int main(int argc, char **argv)
 487 {
 488         char *path = NULL;
 489         char *apply = NULL;
 490         bool delete = false, list = false;
 491         int opt;
 492
 493         while ((opt = getopt(argc, argv, "hda:l")) != -1) {
 494                 switch (opt) {
 495                 case 'd':
 496                         delete = true;
 497                         break;
 498                 case 'a':
 499                         apply = optarg;
 500                         break;
 501                 case 'l':
 502                         list = true;
 503                         break;
 504                 case 'h':
 505                 default:
 506                         return usage();
 507                 }
 508         }
 509
 510         if ((apply && delete) || (delete && list) || (apply && list)) {
 511                 pr_err("Error: You can give one of -a, -d or -l at once.\n");
 512                 return usage();
 513         }
 514
 515         if (optind >= argc) {
 516                 pr_err("Error: No initrd is specified.\n");
 517                 return usage();
 518         }
 519
 520         path = argv[optind];
 521
 522         if (apply)
 523                 return apply_xbc(path, apply);
 524         else if (delete)
 525                 return delete_xbc(path);
 526
 527         return show_xbc(path, list);
 528 }