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 } 529