system/core/mkbootimg/mkbootimg.c

   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[4096] = { 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
 113     argc--;
 114     argv++;
 115
 116     memset(&hdr, 0, sizeof(hdr));
 117
 118         /* default load addresses */
 119     hdr.kernel_addr =  0x10008000;
 120     hdr.ramdisk_addr = 0x11000000;
 121     hdr.second_addr =  0x10F00000;
 122     hdr.tags_addr =    0x10000100;
 123
 124     while(argc > 0){
 125         char *arg = argv[0];
 126         char *val = argv[1];
 127         if(argc < 2) {
 128             return usage();
 129         }
 130         argc -= 2;
 131         argv += 2;
 132         if(!strcmp(arg, "--output") || !strcmp(arg, "-o")) {
 133             bootimg = val;
 134         } else if(!strcmp(arg, "--kernel")) {
 135             kernel_fn = val;
 136         } else if(!strcmp(arg, "--ramdisk")) {
 137             ramdisk_fn = val;
 138         } else if(!strcmp(arg, "--second")) {
 139             second_fn = val;
 140         } else if(!strcmp(arg, "--cmdline")) {
 141             cmdline = val;
 142         } else if(!strcmp(arg, "--base")) {
 143             unsigned base = strtoul(val, 0, 16);
 144             hdr.kernel_addr =  base + 0x00008000;
 145             hdr.ramdisk_addr = base + 0x04000000;
 146             hdr.second_addr =  base + 0x00F00000;
 147             hdr.tags_addr =    base + 0x00000100;
 148         } else if(!strcmp(arg, "--board")) {
 149             board = val;
 150         } else if(!strcmp(arg,"--pagesize")) {
 151             pagesize = strtoul(val, 0, 10);
 152             if ((pagesize != 2048) && (pagesize != 4096)) {
 153                 fprintf(stderr,"error: unsupported page size %d\n", pagesize);
 154                 return -1;
 155             }
 156         } else {
 157             return usage();
 158         }
 159     }
 160     hdr.page_size = pagesize;
 161
 162
 163     if(bootimg == 0) {
 164         fprintf(stderr,"error: no output filename specified\n");
 165         return usage();
 166     }
 167
 168     if(kernel_fn == 0) {
 169         fprintf(stderr,"error: no kernel image specified\n");
 170         return usage();
 171     }
 172
 173     if(ramdisk_fn == 0) {
 174         fprintf(stderr,"error: no ramdisk image specified\n");
 175         return usage();
 176     }
 177
 178     if(strlen(board) >= BOOT_NAME_SIZE) {
 179         fprintf(stderr,"error: board name too large\n");
 180         return usage();
 181     }
 182
 183     strcpy(hdr.name, board);
 184
 185     memcpy(hdr.magic, BOOT_MAGIC, BOOT_MAGIC_SIZE);
 186
 187     if(strlen(cmdline) > (BOOT_ARGS_SIZE - 1)) {
 188         fprintf(stderr,"error: kernel commandline too large\n");
 189         return 1;
 190     }
 191     strcpy((char*)hdr.cmdline, cmdline);
 192
 193     kernel_data = load_file(kernel_fn, &hdr.kernel_size);
 194     if(kernel_data == 0) {
 195         fprintf(stderr,"error: could not load kernel '%s'\n", kernel_fn);
 196         return 1;
 197     }
 198
 199     if(!strcmp(ramdisk_fn,"NONE")) {
 200         ramdisk_data = 0;
 201         hdr.ramdisk_size = 0;
 202     } else {
 203         ramdisk_data = load_file(ramdisk_fn, &hdr.ramdisk_size);
 204         if(ramdisk_data == 0) {
 205             fprintf(stderr,"error: could not load ramdisk '%s'\n", ramdisk_fn);
 206             return 1;
 207         }
 208     }
 209
 210     if(second_fn) {
 211         second_data = load_file(second_fn, &hdr.second_size);
 212         if(second_data == 0) {
 213             fprintf(stderr,"error: could not load secondstage '%s'\n", second_fn);
 214             return 1;
 215         }
 216     }
 217
 218     /* put a hash of the contents in the header so boot images can be
 219      * differentiated based on their first 2k.
 220      */
 221     SHA_init(&ctx);
 222     SHA_update(&ctx, kernel_data, hdr.kernel_size);
 223     SHA_update(&ctx, &hdr.kernel_size, sizeof(hdr.kernel_size));
 224     SHA_update(&ctx, ramdisk_data, hdr.ramdisk_size);
 225     SHA_update(&ctx, &hdr.ramdisk_size, sizeof(hdr.ramdisk_size));
 226     SHA_update(&ctx, second_data, hdr.second_size);
 227     SHA_update(&ctx, &hdr.second_size, sizeof(hdr.second_size));
 228     sha = SHA_final(&ctx);
 229     memcpy(hdr.id, sha,
 230            SHA_DIGEST_SIZE > sizeof(hdr.id) ? sizeof(hdr.id) : SHA_DIGEST_SIZE);
 231
 232     fd = open(bootimg, O_CREAT | O_TRUNC | O_WRONLY, 0644);
 233     if(fd < 0) {
 234         fprintf(stderr,"error: could not create '%s'\n", bootimg);
 235         return 1;
 236     }
 237
 238     if(write(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) goto fail;
 239     if(write_padding(fd, pagesize*2, sizeof(hdr))) goto fail;
 240
 241     if(write(fd, kernel_data, hdr.kernel_size) != hdr.kernel_size) goto fail;
 242     if(write_padding(fd, pagesize*2, hdr.kernel_size)) goto fail;
 243
 244     if(write(fd, ramdisk_data, hdr.ramdisk_size) != hdr.ramdisk_size) goto fail;
 245     if(write_padding(fd, pagesize, hdr.ramdisk_size)) goto fail;
 246
 247     if(second_data) {
 248         if(write(fd, second_data, hdr.second_size) != hdr.second_size) goto fail;
 249         if(write_padding(fd, pagesize, hdr.ramdisk_size)) goto fail;
 250     }
 251
 252     return 0;
 253
 254 fail:
 255     unlink(bootimg);
 256     close(fd);
 257     fprintf(stderr,"error: failed writing '%s': %s\n", bootimg,
 258             strerror(errno));
 259     return 1;
 260 }