1 /* tools/mkbootimg/mkbootimg.c
2 **
3 ** Copyright 2007, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <unistd.h>
22 #include <fcntl.h>
23 #include <errno.h>
24
25 #include "mincrypt/sha.h"
26 #include "bootimg.h"
27
load_file(const char * fn,unsigned * _sz)28 static void *load_file(const char *fn, unsigned *_sz)
29 {
30 char *data;
31 int sz;
32 int fd;
33
34 data = 0;
35 fd = open(fn, O_RDONLY);
36 if(fd < 0) return 0;
37
38 sz = lseek(fd, 0, SEEK_END);
39 if(sz < 0) goto oops;
40
41 if(lseek(fd, 0, SEEK_SET) != 0) goto oops;
42
43 data = (char*) malloc(sz);
44 if(data == 0) goto oops;
45
46 if(read(fd, data, sz) != sz) goto oops;
47 close(fd);
48
49 if(_sz) *_sz = sz;
50 return data;
51
52 oops:
53 close(fd);
54 if(data != 0) free(data);
55 return 0;
56 }
57
usage(void)58 int usage(void)
59 {
60 fprintf(stderr,"usage: mkbootimg\n"
61 " --kernel <filename>\n"
62 " --ramdisk <filename>\n"
63 " [ --second <2ndbootloader-filename> ]\n"
64 " [ --cmdline <kernel-commandline> ]\n"
65 " [ --board <boardname> ]\n"
66 " [ --base <address> ]\n"
67 " [ --pagesize <pagesize> ]\n"
68 " -o|--output <filename>\n"
69 );
70 return 1;
71 }
72
73
74
75 static unsigned char padding[16384] = { 0, };
76
write_padding(int fd,unsigned pagesize,unsigned itemsize)77 int write_padding(int fd, unsigned pagesize, unsigned itemsize)
78 {
79 unsigned pagemask = pagesize - 1;
80 unsigned count;
81
82 if((itemsize & pagemask) == 0) {
83 return 0;
84 }
85
86 count = pagesize - (itemsize & pagemask);
87
88 if(write(fd, padding, count) != count) {
89 return -1;
90 } else {
91 return 0;
92 }
93 }
94
main(int argc,char ** argv)95 int main(int argc, char **argv)
96 {
97 boot_img_hdr hdr;
98
99 char *kernel_fn = 0;
100 void *kernel_data = 0;
101 char *ramdisk_fn = 0;
102 void *ramdisk_data = 0;
103 char *second_fn = 0;
104 void *second_data = 0;
105 char *cmdline = "";
106 char *bootimg = 0;
107 char *board = "";
108 unsigned pagesize = 2048;
109 int fd;
110 SHA_CTX ctx;
111 uint8_t* sha;
112 unsigned base = 0x10000000;
113 unsigned kernel_offset = 0x00008000;
114 unsigned ramdisk_offset = 0x01000000;
115 unsigned second_offset = 0x00f00000;
116 unsigned tags_offset = 0x00000100;
117
118 argc--;
119 argv++;
120
121 memset(&hdr, 0, sizeof(hdr));
122
123 while(argc > 0){
124 char *arg = argv[0];
125 char *val = argv[1];
126 if(argc < 2) {
127 return usage();
128 }
129 argc -= 2;
130 argv += 2;
131 if(!strcmp(arg, "--output") || !strcmp(arg, "-o")) {
132 bootimg = val;
133 } else if(!strcmp(arg, "--kernel")) {
134 kernel_fn = val;
135 } else if(!strcmp(arg, "--ramdisk")) {
136 ramdisk_fn = val;
137 } else if(!strcmp(arg, "--second")) {
138 second_fn = val;
139 } else if(!strcmp(arg, "--cmdline")) {
140 cmdline = val;
141 } else if(!strcmp(arg, "--base")) {
142 base = strtoul(val, 0, 16);
143 } else if(!strcmp(arg, "--kernel_offset")) {
144 kernel_offset = strtoul(val, 0, 16);
145 } else if(!strcmp(arg, "--ramdisk_offset")) {
146 ramdisk_offset = strtoul(val, 0, 16);
147 } else if(!strcmp(arg, "--second_offset")) {
148 second_offset = strtoul(val, 0, 16);
149 } else if(!strcmp(arg, "--tags_offset")) {
150 tags_offset = strtoul(val, 0, 16);
151 } else if(!strcmp(arg, "--board")) {
152 board = val;
153 } else if(!strcmp(arg,"--pagesize")) {
154 pagesize = strtoul(val, 0, 10);
155 if ((pagesize != 2048) && (pagesize != 4096)
156 && (pagesize != 8192) && (pagesize != 16384)) {
157 fprintf(stderr,"error: unsupported page size %d\n", pagesize);
158 return -1;
159 }
160 } else {
161 return usage();
162 }
163 }
164 hdr.page_size = pagesize;
165
166 hdr.kernel_addr = base + kernel_offset;
167 hdr.ramdisk_addr = base + ramdisk_offset;
168 hdr.second_addr = base + second_offset;
169 hdr.tags_addr = base + tags_offset;
170
171 if(bootimg == 0) {
172 fprintf(stderr,"error: no output filename specified\n");
173 return usage();
174 }
175
176 if(kernel_fn == 0) {
177 fprintf(stderr,"error: no kernel image specified\n");
178 return usage();
179 }
180
181 if(ramdisk_fn == 0) {
182 fprintf(stderr,"error: no ramdisk image specified\n");
183 return usage();
184 }
185
186 if(strlen(board) >= BOOT_NAME_SIZE) {
187 fprintf(stderr,"error: board name too large\n");
188 return usage();
189 }
190
191 strcpy(hdr.name, board);
192
193 memcpy(hdr.magic, BOOT_MAGIC, BOOT_MAGIC_SIZE);
194
195 if(strlen(cmdline) > (BOOT_ARGS_SIZE - 1)) {
196 fprintf(stderr,"error: kernel commandline too large\n");
197 return 1;
198 }
199 strcpy((char*)hdr.cmdline, cmdline);
200
201 kernel_data = load_file(kernel_fn, &hdr.kernel_size);
202 if(kernel_data == 0) {
203 fprintf(stderr,"error: could not load kernel '%s'\n", kernel_fn);
204 return 1;
205 }
206
207 if(!strcmp(ramdisk_fn,"NONE")) {
208 ramdisk_data = 0;
209 hdr.ramdisk_size = 0;
210 } else {
211 ramdisk_data = load_file(ramdisk_fn, &hdr.ramdisk_size);
212 if(ramdisk_data == 0) {
213 fprintf(stderr,"error: could not load ramdisk '%s'\n", ramdisk_fn);
214 return 1;
215 }
216 }
217
218 if(second_fn) {
219 second_data = load_file(second_fn, &hdr.second_size);
220 if(second_data == 0) {
221 fprintf(stderr,"error: could not load secondstage '%s'\n", second_fn);
222 return 1;
223 }
224 }
225
226 /* put a hash of the contents in the header so boot images can be
227 * differentiated based on their first 2k.
228 */
229 SHA_init(&ctx);
230 SHA_update(&ctx, kernel_data, hdr.kernel_size);
231 SHA_update(&ctx, &hdr.kernel_size, sizeof(hdr.kernel_size));
232 SHA_update(&ctx, ramdisk_data, hdr.ramdisk_size);
233 SHA_update(&ctx, &hdr.ramdisk_size, sizeof(hdr.ramdisk_size));
234 SHA_update(&ctx, second_data, hdr.second_size);
235 SHA_update(&ctx, &hdr.second_size, sizeof(hdr.second_size));
236 sha = SHA_final(&ctx);
237 memcpy(hdr.id, sha,
238 SHA_DIGEST_SIZE > sizeof(hdr.id) ? sizeof(hdr.id) : SHA_DIGEST_SIZE);
239
240 fd = open(bootimg, O_CREAT | O_TRUNC | O_WRONLY, 0644);
241 if(fd < 0) {
242 fprintf(stderr,"error: could not create '%s'\n", bootimg);
243 return 1;
244 }
245
246 if(write(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) goto fail;
247 if(write_padding(fd, pagesize, sizeof(hdr))) goto fail;
248
249 if(write(fd, kernel_data, hdr.kernel_size) != hdr.kernel_size) goto fail;
250 if(write_padding(fd, pagesize, hdr.kernel_size)) goto fail;
251
252 if(write(fd, ramdisk_data, hdr.ramdisk_size) != hdr.ramdisk_size) goto fail;
253 if(write_padding(fd, pagesize, hdr.ramdisk_size)) goto fail;
254
255 if(second_data) {
256 if(write(fd, second_data, hdr.second_size) != hdr.second_size) goto fail;
257 if(write_padding(fd, pagesize, hdr.ramdisk_size)) goto fail;
258 }
259
260 return 0;
261
262 fail:
263 unlink(bootimg);
264 close(fd);
265 fprintf(stderr,"error: failed writing '%s': %s\n", bootimg,
266 strerror(errno));
267 return 1;
268 }
269