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