xref: /linux/tools/bootconfig/main.c (revision 03ab8e6297acd1bc0eedaa050e2a1635c576fd11)
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 
xbc_show_value(struct xbc_node * node,bool semicolon)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 
xbc_show_compact_tree(void)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 
xbc_show_list(void)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 
load_xbc_fd(int fd,char ** buf,int size)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 */
load_xbc_file(const char * path,char ** buf)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 
pr_errno(const char * msg,int err)170 static int pr_errno(const char *msg, int err)
171 {
172 	pr_err("%s: %d\n", msg, err);
173 	return err;
174 }
175 
load_xbc_from_initrd(int fd,char ** buf)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 
show_xbc_error(const char * data,const char * msg,int pos)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 
init_xbc_with_error(char * buf,int len)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 
show_xbc(const char * path,bool list)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 
delete_xbc(const char * path)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 
apply_xbc(const char * path,const char * xbc_path)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 
usage(void)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 
main(int argc,char ** argv)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