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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
/* Copyright 2012 The Chromium OS Authors. All rights reserved.
* 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 <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "host_common.h"
#include "kernel_blob.h"
#include "vboot_api.h"
#include "vboot_host.h"
#ifdef USE_MTD
#include <linux/major.h>
#include <mtd/mtd-user.h>
#include <mtdutils.h>
#endif
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;
}
#ifdef USE_MTD
static ssize_t ReadFullyWithMtdRead(void *ctx, void *buf, size_t count)
{
MtdReadContext *mtd_ctx = (MtdReadContext*)ctx;
return mtd_read_data(mtd_ctx, buf, count);
}
#endif
/* 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)
{
VbKeyBlockHeader key_block;
VbKernelPreambleHeader preamble;
uint32_t now = 0;
uint32_t offset = 0;
/* Skip the key block */
if (read_fn(ctx, &key_block, sizeof(key_block)) != sizeof(key_block)) {
VbExError("not enough data to fill key block header\n");
return NULL;
}
ssize_t to_skip = key_block.key_block_size - sizeof(key_block);
if (to_skip < 0 || SkipWithRead(ctx, read_fn, to_skip)) {
VbExError("key_block_size advances past the end of the blob\n");
return NULL;
}
now += key_block.key_block_size;
/* Open up the preamble */
if (read_fn(ctx, &preamble, sizeof(preamble)) != sizeof(preamble)) {
VbExError("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)) {
VbExError("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)) {
VbExError("params are outside of the memory blob: %x\n",
offset);
return NULL;
}
char *ret = malloc(CROS_CONFIG_SIZE);
if (!ret) {
VbExError("No memory\n");
return NULL;
}
if (read_fn(ctx, ret, CROS_CONFIG_SIZE) != CROS_CONFIG_SIZE) {
VbExError("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 | O_LARGEFILE);
if (fd < 0) {
VbExError("Cannot open %s\n", infile);
return NULL;
}
void *ctx = &fd;
ReadFullyFn read_fn = ReadFullyWithRead;
#ifdef USE_MTD
struct stat stat_buf;
if (fstat(fd, &stat_buf)) {
VbExError("Cannot stat %s\n", infile);
return NULL;
}
int is_mtd = (major(stat_buf.st_rdev) == MTD_CHAR_MAJOR);
if (is_mtd) {
ctx = mtd_read_descriptor(fd, infile);
if (!ctx) {
VbExError("Cannot read from MTD device %s\n", infile);
return NULL;
}
read_fn = ReadFullyWithMtdRead;
}
#endif
newstr = FindKernelConfigFromStream(ctx, read_fn,
kernel_body_load_address);
#ifdef USE_MTD
if (is_mtd) {
mtd_read_close(ctx);
}
#endif
close(fd);
return newstr;
}
|
