1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
/* Copyright 2012 The ChromiumOS Authors
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*
* Exports the kernel commandline from a given partition/image.
*/
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#if !defined (__FreeBSD__) && !defined(__OpenBSD__)
#include <sys/sysmacros.h>
#endif
#include <sys/types.h>
#include <unistd.h>
#include "futility.h"
#include "host_common.h"
#include "kernel_blob.h"
#include "vboot_api.h"
#include "vboot_host.h"
typedef ssize_t (*ReadFullyFn)(void *ctx, void *buf, size_t count);
static ssize_t ReadFullyWithRead(void *ctx, void *buf, size_t count)
{
ssize_t nr_read = 0;
int fd = *((int*)ctx);
while (nr_read < count) {
ssize_t to_read = count - nr_read;
ssize_t chunk = read(fd, buf + nr_read, to_read);
if (chunk < 0) {
return -1;
} else if (chunk == 0) {
break;
}
nr_read += chunk;
}
return nr_read;
}
/* Skip the stream by calling |read_fn| many times. Return 0 on success. */
static int SkipWithRead(void *ctx, ReadFullyFn read_fn, size_t count)
{
char buf[1024];
ssize_t nr_skipped = 0;
while (nr_skipped < count) {
ssize_t to_read = count - nr_skipped;
if (to_read > sizeof(buf)) {
to_read = sizeof(buf);
}
if (read_fn(ctx, buf, to_read) != to_read) {
return -1;
}
nr_skipped += to_read;
}
return 0;
}
static char *FindKernelConfigFromStream(void *ctx, ReadFullyFn read_fn,
uint64_t kernel_body_load_address)
{
struct vb2_keyblock keyblock;
struct vb2_kernel_preamble preamble;
uint32_t now = 0;
uint32_t offset = 0;
/* Skip the keyblock */
if (read_fn(ctx, &keyblock, sizeof(keyblock)) != sizeof(keyblock)) {
FATAL("not enough data to fill keyblock header\n");
return NULL;
}
ssize_t to_skip = keyblock.keyblock_size - sizeof(keyblock);
if (to_skip < 0 || SkipWithRead(ctx, read_fn, to_skip)) {
FATAL("keyblock_size advances past the end of the blob\n");
return NULL;
}
now += keyblock.keyblock_size;
/* Open up the preamble */
if (read_fn(ctx, &preamble, sizeof(preamble)) != sizeof(preamble)) {
FATAL("not enough data to fill preamble\n");
return NULL;
}
to_skip = preamble.preamble_size - sizeof(preamble);
if (to_skip < 0 || SkipWithRead(ctx, read_fn, to_skip)) {
FATAL("preamble_size advances past the end of the blob\n");
return NULL;
}
now += preamble.preamble_size;
/* Read body_load_address from preamble if no
* kernel_body_load_address */
if (kernel_body_load_address == USE_PREAMBLE_LOAD_ADDR)
kernel_body_load_address = preamble.body_load_address;
/* The x86 kernels have a pointer to the kernel commandline in the
* zeropage table, but that's irrelevant for ARM. Both types keep the
* config blob in the same place, so just go find it. */
offset = preamble.bootloader_address -
(kernel_body_load_address + CROS_PARAMS_SIZE +
CROS_CONFIG_SIZE) + now;
to_skip = offset - now;
if (to_skip < 0 || SkipWithRead(ctx, read_fn, to_skip)) {
FATAL("params are outside of the memory blob: %x\n", offset);
return NULL;
}
char *ret = malloc(CROS_CONFIG_SIZE);
if (!ret) {
FATAL("No memory\n");
return NULL;
}
if (read_fn(ctx, ret, CROS_CONFIG_SIZE) != CROS_CONFIG_SIZE) {
FATAL("Cannot read kernel config\n");
free(ret);
ret = NULL;
}
return ret;
}
char *FindKernelConfig(const char *infile, uint64_t kernel_body_load_address)
{
char *newstr = NULL;
int fd = open(infile, O_RDONLY | O_CLOEXEC
#if !defined(__FreeBSD__) && !defined(__OpenBSD__)
| O_LARGEFILE
#endif
);
if (fd < 0) {
FATAL("Cannot open %s\n", infile);
return NULL;
}
void *ctx = &fd;
ReadFullyFn read_fn = ReadFullyWithRead;
newstr = FindKernelConfigFromStream(ctx, read_fn,
kernel_body_load_address);
close(fd);
return newstr;
}
|
