Home | History | Annotate | Download | only in mkbootimg
      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 
     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 
     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 
     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 
     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