forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
507 lines
10 KiB
507 lines
10 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Boot config tool for initrd image |
|
*/ |
|
#include <stdio.h> |
|
#include <stdlib.h> |
|
#include <sys/types.h> |
|
#include <sys/stat.h> |
|
#include <fcntl.h> |
|
#include <unistd.h> |
|
#include <string.h> |
|
#include <errno.h> |
|
#include <endian.h> |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/bootconfig.h> |
|
|
|
static int xbc_show_value(struct xbc_node *node, bool semicolon) |
|
{ |
|
const char *val, *eol; |
|
char q; |
|
int i = 0; |
|
|
|
eol = semicolon ? ";\n" : "\n"; |
|
xbc_array_for_each_value(node, val) { |
|
if (strchr(val, '"')) |
|
q = '\''; |
|
else |
|
q = '"'; |
|
printf("%c%s%c%s", q, val, q, node->next ? ", " : eol); |
|
i++; |
|
} |
|
return i; |
|
} |
|
|
|
static void xbc_show_compact_tree(void) |
|
{ |
|
struct xbc_node *node, *cnode; |
|
int depth = 0, i; |
|
|
|
node = xbc_root_node(); |
|
while (node && xbc_node_is_key(node)) { |
|
for (i = 0; i < depth; i++) |
|
printf("\t"); |
|
cnode = xbc_node_get_child(node); |
|
while (cnode && xbc_node_is_key(cnode) && !cnode->next) { |
|
printf("%s.", xbc_node_get_data(node)); |
|
node = cnode; |
|
cnode = xbc_node_get_child(node); |
|
} |
|
if (cnode && xbc_node_is_key(cnode)) { |
|
printf("%s {\n", xbc_node_get_data(node)); |
|
depth++; |
|
node = cnode; |
|
continue; |
|
} else if (cnode && xbc_node_is_value(cnode)) { |
|
printf("%s = ", xbc_node_get_data(node)); |
|
xbc_show_value(cnode, true); |
|
} else { |
|
printf("%s;\n", xbc_node_get_data(node)); |
|
} |
|
|
|
if (node->next) { |
|
node = xbc_node_get_next(node); |
|
continue; |
|
} |
|
while (!node->next) { |
|
node = xbc_node_get_parent(node); |
|
if (!node) |
|
return; |
|
if (!xbc_node_get_child(node)->next) |
|
continue; |
|
depth--; |
|
for (i = 0; i < depth; i++) |
|
printf("\t"); |
|
printf("}\n"); |
|
} |
|
node = xbc_node_get_next(node); |
|
} |
|
} |
|
|
|
static void xbc_show_list(void) |
|
{ |
|
char key[XBC_KEYLEN_MAX]; |
|
struct xbc_node *leaf; |
|
const char *val; |
|
int ret = 0; |
|
|
|
xbc_for_each_key_value(leaf, val) { |
|
ret = xbc_node_compose_key(leaf, key, XBC_KEYLEN_MAX); |
|
if (ret < 0) |
|
break; |
|
printf("%s = ", key); |
|
if (!val || val[0] == '\0') { |
|
printf("\"\"\n"); |
|
continue; |
|
} |
|
xbc_show_value(xbc_node_get_child(leaf), false); |
|
} |
|
} |
|
|
|
/* Simple real checksum */ |
|
static int checksum(unsigned char *buf, int len) |
|
{ |
|
int i, sum = 0; |
|
|
|
for (i = 0; i < len; i++) |
|
sum += buf[i]; |
|
|
|
return sum; |
|
} |
|
|
|
#define PAGE_SIZE 4096 |
|
|
|
static int load_xbc_fd(int fd, char **buf, int size) |
|
{ |
|
int ret; |
|
|
|
*buf = malloc(size + 1); |
|
if (!*buf) |
|
return -ENOMEM; |
|
|
|
ret = read(fd, *buf, size); |
|
if (ret < 0) |
|
return -errno; |
|
(*buf)[size] = '\0'; |
|
|
|
return ret; |
|
} |
|
|
|
/* Return the read size or -errno */ |
|
static int load_xbc_file(const char *path, char **buf) |
|
{ |
|
struct stat stat; |
|
int fd, ret; |
|
|
|
fd = open(path, O_RDONLY); |
|
if (fd < 0) |
|
return -errno; |
|
ret = fstat(fd, &stat); |
|
if (ret < 0) |
|
return -errno; |
|
|
|
ret = load_xbc_fd(fd, buf, stat.st_size); |
|
|
|
close(fd); |
|
|
|
return ret; |
|
} |
|
|
|
static int pr_errno(const char *msg, int err) |
|
{ |
|
pr_err("%s: %d\n", msg, err); |
|
return err; |
|
} |
|
|
|
static int load_xbc_from_initrd(int fd, char **buf) |
|
{ |
|
struct stat stat; |
|
int ret; |
|
u32 size = 0, csum = 0, rcsum; |
|
char magic[BOOTCONFIG_MAGIC_LEN]; |
|
const char *msg; |
|
|
|
ret = fstat(fd, &stat); |
|
if (ret < 0) |
|
return -errno; |
|
|
|
if (stat.st_size < 8 + BOOTCONFIG_MAGIC_LEN) |
|
return 0; |
|
|
|
if (lseek(fd, -BOOTCONFIG_MAGIC_LEN, SEEK_END) < 0) |
|
return pr_errno("Failed to lseek for magic", -errno); |
|
|
|
if (read(fd, magic, BOOTCONFIG_MAGIC_LEN) < 0) |
|
return pr_errno("Failed to read", -errno); |
|
|
|
/* Check the bootconfig magic bytes */ |
|
if (memcmp(magic, BOOTCONFIG_MAGIC, BOOTCONFIG_MAGIC_LEN) != 0) |
|
return 0; |
|
|
|
if (lseek(fd, -(8 + BOOTCONFIG_MAGIC_LEN), SEEK_END) < 0) |
|
return pr_errno("Failed to lseek for size", -errno); |
|
|
|
if (read(fd, &size, sizeof(u32)) < 0) |
|
return pr_errno("Failed to read size", -errno); |
|
size = le32toh(size); |
|
|
|
if (read(fd, &csum, sizeof(u32)) < 0) |
|
return pr_errno("Failed to read checksum", -errno); |
|
csum = le32toh(csum); |
|
|
|
/* Wrong size error */ |
|
if (stat.st_size < size + 8 + BOOTCONFIG_MAGIC_LEN) { |
|
pr_err("bootconfig size is too big\n"); |
|
return -E2BIG; |
|
} |
|
|
|
if (lseek(fd, stat.st_size - (size + 8 + BOOTCONFIG_MAGIC_LEN), |
|
SEEK_SET) < 0) |
|
return pr_errno("Failed to lseek", -errno); |
|
|
|
ret = load_xbc_fd(fd, buf, size); |
|
if (ret < 0) |
|
return ret; |
|
|
|
/* Wrong Checksum */ |
|
rcsum = checksum((unsigned char *)*buf, size); |
|
if (csum != rcsum) { |
|
pr_err("checksum error: %d != %d\n", csum, rcsum); |
|
return -EINVAL; |
|
} |
|
|
|
ret = xbc_init(*buf, &msg, NULL); |
|
/* Wrong data */ |
|
if (ret < 0) { |
|
pr_err("parse error: %s.\n", msg); |
|
return ret; |
|
} |
|
|
|
return size; |
|
} |
|
|
|
static void show_xbc_error(const char *data, const char *msg, int pos) |
|
{ |
|
int lin = 1, col, i; |
|
|
|
if (pos < 0) { |
|
pr_err("Error: %s.\n", msg); |
|
return; |
|
} |
|
|
|
/* Note that pos starts from 0 but lin and col should start from 1. */ |
|
col = pos + 1; |
|
for (i = 0; i < pos; i++) { |
|
if (data[i] == '\n') { |
|
lin++; |
|
col = pos - i; |
|
} |
|
} |
|
pr_err("Parse Error: %s at %d:%d\n", msg, lin, col); |
|
|
|
} |
|
|
|
static int init_xbc_with_error(char *buf, int len) |
|
{ |
|
char *copy = strdup(buf); |
|
const char *msg; |
|
int ret, pos; |
|
|
|
if (!copy) |
|
return -ENOMEM; |
|
|
|
ret = xbc_init(buf, &msg, &pos); |
|
if (ret < 0) |
|
show_xbc_error(copy, msg, pos); |
|
free(copy); |
|
|
|
return ret; |
|
} |
|
|
|
static int show_xbc(const char *path, bool list) |
|
{ |
|
int ret, fd; |
|
char *buf = NULL; |
|
struct stat st; |
|
|
|
ret = stat(path, &st); |
|
if (ret < 0) { |
|
ret = -errno; |
|
pr_err("Failed to stat %s: %d\n", path, ret); |
|
return ret; |
|
} |
|
|
|
fd = open(path, O_RDONLY); |
|
if (fd < 0) { |
|
ret = -errno; |
|
pr_err("Failed to open initrd %s: %d\n", path, ret); |
|
return ret; |
|
} |
|
|
|
ret = load_xbc_from_initrd(fd, &buf); |
|
close(fd); |
|
if (ret < 0) { |
|
pr_err("Failed to load a boot config from initrd: %d\n", ret); |
|
goto out; |
|
} |
|
/* Assume a bootconfig file if it is enough small */ |
|
if (ret == 0 && st.st_size <= XBC_DATA_MAX) { |
|
ret = load_xbc_file(path, &buf); |
|
if (ret < 0) { |
|
pr_err("Failed to load a boot config: %d\n", ret); |
|
goto out; |
|
} |
|
if (init_xbc_with_error(buf, ret) < 0) |
|
goto out; |
|
} |
|
if (list) |
|
xbc_show_list(); |
|
else |
|
xbc_show_compact_tree(); |
|
ret = 0; |
|
out: |
|
free(buf); |
|
|
|
return ret; |
|
} |
|
|
|
static int delete_xbc(const char *path) |
|
{ |
|
struct stat stat; |
|
int ret = 0, fd, size; |
|
char *buf = NULL; |
|
|
|
fd = open(path, O_RDWR); |
|
if (fd < 0) { |
|
ret = -errno; |
|
pr_err("Failed to open initrd %s: %d\n", path, ret); |
|
return ret; |
|
} |
|
|
|
size = load_xbc_from_initrd(fd, &buf); |
|
if (size < 0) { |
|
ret = size; |
|
pr_err("Failed to load a boot config from initrd: %d\n", ret); |
|
} else if (size > 0) { |
|
ret = fstat(fd, &stat); |
|
if (!ret) |
|
ret = ftruncate(fd, stat.st_size |
|
- size - 8 - BOOTCONFIG_MAGIC_LEN); |
|
if (ret) |
|
ret = -errno; |
|
} /* Ignore if there is no boot config in initrd */ |
|
|
|
close(fd); |
|
free(buf); |
|
|
|
return ret; |
|
} |
|
|
|
static int apply_xbc(const char *path, const char *xbc_path) |
|
{ |
|
char *buf, *data, *p; |
|
size_t total_size; |
|
struct stat stat; |
|
const char *msg; |
|
u32 size, csum; |
|
int pos, pad; |
|
int ret, fd; |
|
|
|
ret = load_xbc_file(xbc_path, &buf); |
|
if (ret < 0) { |
|
pr_err("Failed to load %s : %d\n", xbc_path, ret); |
|
return ret; |
|
} |
|
size = strlen(buf) + 1; |
|
csum = checksum((unsigned char *)buf, size); |
|
|
|
/* Backup the bootconfig data */ |
|
data = calloc(size + BOOTCONFIG_ALIGN + |
|
sizeof(u32) + sizeof(u32) + BOOTCONFIG_MAGIC_LEN, 1); |
|
if (!data) |
|
return -ENOMEM; |
|
memcpy(data, buf, size); |
|
|
|
/* Check the data format */ |
|
ret = xbc_init(buf, &msg, &pos); |
|
if (ret < 0) { |
|
show_xbc_error(data, msg, pos); |
|
free(data); |
|
free(buf); |
|
|
|
return ret; |
|
} |
|
printf("Apply %s to %s\n", xbc_path, path); |
|
printf("\tNumber of nodes: %d\n", ret); |
|
printf("\tSize: %u bytes\n", (unsigned int)size); |
|
printf("\tChecksum: %d\n", (unsigned int)csum); |
|
|
|
/* TODO: Check the options by schema */ |
|
xbc_destroy_all(); |
|
free(buf); |
|
|
|
/* Remove old boot config if exists */ |
|
ret = delete_xbc(path); |
|
if (ret < 0) { |
|
pr_err("Failed to delete previous boot config: %d\n", ret); |
|
free(data); |
|
return ret; |
|
} |
|
|
|
/* Apply new one */ |
|
fd = open(path, O_RDWR | O_APPEND); |
|
if (fd < 0) { |
|
ret = -errno; |
|
pr_err("Failed to open %s: %d\n", path, ret); |
|
free(data); |
|
return ret; |
|
} |
|
/* TODO: Ensure the @path is initramfs/initrd image */ |
|
if (fstat(fd, &stat) < 0) { |
|
pr_err("Failed to get the size of %s\n", path); |
|
goto out; |
|
} |
|
|
|
/* To align up the total size to BOOTCONFIG_ALIGN, get padding size */ |
|
total_size = stat.st_size + size + sizeof(u32) * 2 + BOOTCONFIG_MAGIC_LEN; |
|
pad = ((total_size + BOOTCONFIG_ALIGN - 1) & (~BOOTCONFIG_ALIGN_MASK)) - total_size; |
|
size += pad; |
|
|
|
/* Add a footer */ |
|
p = data + size; |
|
*(u32 *)p = htole32(size); |
|
p += sizeof(u32); |
|
|
|
*(u32 *)p = htole32(csum); |
|
p += sizeof(u32); |
|
|
|
memcpy(p, BOOTCONFIG_MAGIC, BOOTCONFIG_MAGIC_LEN); |
|
p += BOOTCONFIG_MAGIC_LEN; |
|
|
|
total_size = p - data; |
|
|
|
ret = write(fd, data, total_size); |
|
if (ret < total_size) { |
|
if (ret < 0) |
|
ret = -errno; |
|
pr_err("Failed to apply a boot config: %d\n", ret); |
|
if (ret >= 0) |
|
goto out_rollback; |
|
} else |
|
ret = 0; |
|
|
|
out: |
|
close(fd); |
|
free(data); |
|
|
|
return ret; |
|
|
|
out_rollback: |
|
/* Map the partial write to -ENOSPC */ |
|
if (ret >= 0) |
|
ret = -ENOSPC; |
|
if (ftruncate(fd, stat.st_size) < 0) { |
|
ret = -errno; |
|
pr_err("Failed to rollback the write error: %d\n", ret); |
|
pr_err("The initrd %s may be corrupted. Recommend to rebuild.\n", path); |
|
} |
|
goto out; |
|
} |
|
|
|
static int usage(void) |
|
{ |
|
printf("Usage: bootconfig [OPTIONS] <INITRD>\n" |
|
"Or bootconfig <CONFIG>\n" |
|
" Apply, delete or show boot config to initrd.\n" |
|
" Options:\n" |
|
" -a <config>: Apply boot config to initrd\n" |
|
" -d : Delete boot config file from initrd\n" |
|
" -l : list boot config in initrd or file\n\n" |
|
" If no option is given, show the bootconfig in the given file.\n"); |
|
return -1; |
|
} |
|
|
|
int main(int argc, char **argv) |
|
{ |
|
char *path = NULL; |
|
char *apply = NULL; |
|
bool delete = false, list = false; |
|
int opt; |
|
|
|
while ((opt = getopt(argc, argv, "hda:l")) != -1) { |
|
switch (opt) { |
|
case 'd': |
|
delete = true; |
|
break; |
|
case 'a': |
|
apply = optarg; |
|
break; |
|
case 'l': |
|
list = true; |
|
break; |
|
case 'h': |
|
default: |
|
return usage(); |
|
} |
|
} |
|
|
|
if ((apply && delete) || (delete && list) || (apply && list)) { |
|
pr_err("Error: You can give one of -a, -d or -l at once.\n"); |
|
return usage(); |
|
} |
|
|
|
if (optind >= argc) { |
|
pr_err("Error: No initrd is specified.\n"); |
|
return usage(); |
|
} |
|
|
|
path = argv[optind]; |
|
|
|
if (apply) |
|
return apply_xbc(path, apply); |
|
else if (delete) |
|
return delete_xbc(path); |
|
|
|
return show_xbc(path, list); |
|
}
|
|
|