mkbootimg.c revision 81ce3a79ff0d828f8eafc1395851ae535dd151d4 
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
28static 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
52oops:
53    close(fd);
54    if(data != 0) free(data);
55    return 0;
56}
57
58int 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
75static unsigned char padding[16384] = { 0, };
76
77int 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
95int 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
262fail:
263    unlink(bootimg);
264    close(fd);
265    fprintf(stderr,"error: failed writing '%s': %s\n", bootimg,
266            strerror(errno));
267    return 1;
268}
269