arch/x86/boot/tools/build.c

   1 /*
   2  *  Copyright (C) 1991, 1992  Linus Torvalds
   3  *  Copyright (C) 1997 Martin Mares
   4  *  Copyright (C) 2007 H. Peter Anvin
   5  */
   6
   7 /*
   8  * This file builds a disk-image from two different files:
   9  *
  10  * - setup: 8086 machine code, sets up system parm
  11  * - system: 80386 code for actual system
  12  *
  13  * It does some checking that all files are of the correct type, and
  14  * just writes the result to stdout, removing headers and padding to
  15  * the right amount. It also writes some system data to stderr.
  16  */
  17
  18 /*
  19  * Changes by tytso to allow root device specification
  20  * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996
  21  * Cross compiling fixes by Gertjan van Wingerde, July 1996
  22  * Rewritten by Martin Mares, April 1997
  23  * Substantially overhauled by H. Peter Anvin, April 2007
  24  */
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <stdarg.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <unistd.h>
  33 #include <fcntl.h>
  34 #include <sys/mman.h>
  35 #include <tools/le_byteshift.h>
  36
  37 typedef unsigned char  u8;
  38 typedef unsigned short u16;
  39 typedef unsigned int   u32;
  40
  41 #define DEFAULT_MAJOR_ROOT 0
  42 #define DEFAULT_MINOR_ROOT 0
  43 #define DEFAULT_ROOT_DEV (DEFAULT_MAJOR_ROOT << 8 | DEFAULT_MINOR_ROOT)
  44
  45 /* Minimal number of setup sectors */
  46 #define SETUP_SECT_MIN 5
  47 #define SETUP_SECT_MAX 64
  48
  49 /* This must be large enough to hold the entire setup */
  50 u8 buf[SETUP_SECT_MAX*512];
  51 int is_big_kernel;
  52
  53 #define PECOFF_RELOC_RESERVE 0x20
  54
  55 unsigned long efi_stub_entry;
  56 unsigned long efi_pe_entry;
  57 unsigned long startup_64;
  58
  59 /*----------------------------------------------------------------------*/
  60
  61 static const u32 crctab32[] = {
  62         0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
  63         0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
  64         0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
  65         0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
  66         0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
  67         0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
  68         0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
  69         0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
  70         0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
  71         0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
  72         0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
  73         0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
  74         0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
  75         0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
  76         0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
  77         0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
  78         0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
  79         0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
  80         0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
  81         0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
  82         0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
  83         0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
  84         0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
  85         0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
  86         0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
  87         0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
  88         0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
  89         0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
  90         0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
  91         0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
  92         0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
  93         0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
  94         0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
  95         0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
  96         0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
  97         0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
  98         0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
  99         0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
 100         0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
 101         0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
 102         0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
 103         0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
 104         0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
 105         0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
 106         0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
 107         0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
 108         0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
 109         0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 110         0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
 111         0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
 112         0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
 113         0x2d02ef8d
 114 };
 115
 116 static u32 partial_crc32_one(u8 c, u32 crc)
 117 {
 118         return crctab32[(crc ^ c) & 0xff] ^ (crc >> 8);
 119 }
 120
 121 static u32 partial_crc32(const u8 *s, int len, u32 crc)
 122 {
 123         while (len--)
 124                 crc = partial_crc32_one(*s++, crc);
 125         return crc;
 126 }
 127
 128 static void die(const char * str, ...)
 129 {
 130         va_list args;
 131         va_start(args, str);
 132         vfprintf(stderr, str, args);
 133         fputc('\n', stderr);
 134         exit(1);
 135 }
 136
 137 static void usage(void)
 138 {
 139         die("Usage: build setup system [zoffset.h] [> image]");
 140 }
 141
 142 #ifdef CONFIG_EFI_STUB
 143
 144 static void update_pecoff_section_header_fields(char *section_name, u32 vma, u32 size, u32 datasz, u32 offset)
 145 {
 146         unsigned int pe_header;
 147         unsigned short num_sections;
 148         u8 *section;
 149
 150         pe_header = get_unaligned_le32(&buf[0x3c]);
 151         num_sections = get_unaligned_le16(&buf[pe_header + 6]);
 152
 153 #ifdef CONFIG_X86_32
 154         section = &buf[pe_header + 0xa8];
 155 #else
 156         section = &buf[pe_header + 0xb8];
 157 #endif
 158
 159         while (num_sections > 0) {
 160                 if (strncmp((char*)section, section_name, 8) == 0) {
 161                         /* section header size field */
 162                         put_unaligned_le32(size, section + 0x8);
 163
 164                         /* section header vma field */
 165                         put_unaligned_le32(vma, section + 0xc);
 166
 167                         /* section header 'size of initialised data' field */
 168                         put_unaligned_le32(datasz, section + 0x10);
 169
 170                         /* section header 'file offset' field */
 171                         put_unaligned_le32(offset, section + 0x14);
 172
 173                         break;
 174                 }
 175                 section += 0x28;
 176                 num_sections--;
 177         }
 178 }
 179
 180 static void update_pecoff_section_header(char *section_name, u32 offset, u32 size)
 181 {
 182         update_pecoff_section_header_fields(section_name, offset, size, size, offset);
 183 }
 184
 185 static void update_pecoff_setup_and_reloc(unsigned int size)
 186 {
 187         u32 setup_offset = 0x200;
 188         u32 reloc_offset = size - PECOFF_RELOC_RESERVE;
 189         u32 setup_size = reloc_offset - setup_offset;
 190
 191         update_pecoff_section_header(".setup", setup_offset, setup_size);
 192         update_pecoff_section_header(".reloc", reloc_offset, PECOFF_RELOC_RESERVE);
 193
 194         /*
 195          * Modify .reloc section contents with a single entry. The
 196          * relocation is applied to offset 10 of the relocation section.
 197          */
 198         put_unaligned_le32(reloc_offset + 10, &buf[reloc_offset]);
 199         put_unaligned_le32(10, &buf[reloc_offset + 4]);
 200 }
 201
 202 static void update_pecoff_text(unsigned int text_start, unsigned int file_sz)
 203 {
 204         unsigned int pe_header;
 205         unsigned int text_sz = file_sz - text_start;
 206
 207         pe_header = get_unaligned_le32(&buf[0x3c]);
 208
 209         /*
 210          * Size of code: Subtract the size of the first sector (512 bytes)
 211          * which includes the header.
 212          */
 213         put_unaligned_le32(file_sz - 512, &buf[pe_header + 0x1c]);
 214
 215         /*
 216          * Address of entry point for PE/COFF executable
 217          */
 218         put_unaligned_le32(text_start + efi_pe_entry, &buf[pe_header + 0x28]);
 219
 220         update_pecoff_section_header(".text", text_start, text_sz);
 221 }
 222
 223 static void update_pecoff_bss(unsigned int file_sz, unsigned int init_sz)
 224 {
 225         unsigned int pe_header;
 226         unsigned int bss_sz = init_sz - file_sz;
 227
 228         pe_header = get_unaligned_le32(&buf[0x3c]);
 229
 230         /* Size of uninitialized data */
 231         put_unaligned_le32(bss_sz, &buf[pe_header + 0x24]);
 232
 233         /* Size of image */
 234         put_unaligned_le32(init_sz, &buf[pe_header + 0x50]);
 235
 236         update_pecoff_section_header_fields(".bss", file_sz, bss_sz, 0, 0);
 237 }
 238
 239 #endif /* CONFIG_EFI_STUB */
 240
 241
 242 /*
 243  * Parse zoffset.h and find the entry points. We could just #include zoffset.h
 244  * but that would mean tools/build would have to be rebuilt every time. It's
 245  * not as if parsing it is hard...
 246  */
 247 #define PARSE_ZOFS(p, sym) do { \
 248         if (!strncmp(p, "#define ZO_" #sym " ", 11+sizeof(#sym)))       \
 249                 sym = strtoul(p + 11 + sizeof(#sym), NULL, 16);         \
 250 } while (0)
 251
 252 static void parse_zoffset(char *fname)
 253 {
 254         FILE *file;
 255         char *p;
 256         int c;
 257
 258         file = fopen(fname, "r");
 259         if (!file)
 260                 die("Unable to open `%s': %m", fname);
 261         c = fread(buf, 1, sizeof(buf) - 1, file);
 262         if (ferror(file))
 263                 die("read-error on `zoffset.h'");
 264         fclose(file);
 265         buf[c] = 0;
 266
 267         p = (char *)buf;
 268
 269         while (p && *p) {
 270                 PARSE_ZOFS(p, efi_stub_entry);
 271                 PARSE_ZOFS(p, efi_pe_entry);
 272                 PARSE_ZOFS(p, startup_64);
 273
 274                 p = strchr(p, '\n');
 275                 while (p && (*p == '\r' || *p == '\n'))
 276                         p++;
 277         }
 278 }
 279
 280 int main(int argc, char ** argv)
 281 {
 282         unsigned int i, sz, setup_sectors;
 283         int c;
 284         u32 sys_size;
 285         struct stat sb;
 286         FILE *file;
 287         int fd;
 288         void *kernel;
 289         u32 crc = 0xffffffffUL;
 290 #ifdef CONFIG_EFI_STUB
 291         unsigned int init_sz;
 292 #endif
 293
 294         /* Defaults for old kernel */
 295 #ifdef CONFIG_X86_32
 296         efi_pe_entry = 0x10;
 297         efi_stub_entry = 0x30;
 298 #else
 299         efi_pe_entry = 0x210;
 300         efi_stub_entry = 0x230;
 301         startup_64 = 0x200;
 302 #endif
 303
 304         if (argc == 4)
 305                 parse_zoffset(argv[3]);
 306         else if (argc != 3)
 307                 usage();
 308
 309         /* Copy the setup code */
 310         file = fopen(argv[1], "r");
 311         if (!file)
 312                 die("Unable to open `%s': %m", argv[1]);
 313         c = fread(buf, 1, sizeof(buf), file);
 314         if (ferror(file))
 315                 die("read-error on `setup'");
 316         if (c < 1024)
 317                 die("The setup must be at least 1024 bytes");
 318         if (get_unaligned_le16(&buf[510]) != 0xAA55)
 319                 die("Boot block hasn't got boot flag (0xAA55)");
 320         fclose(file);
 321
 322 #ifdef CONFIG_EFI_STUB
 323         /* Reserve 0x20 bytes for .reloc section */
 324         memset(buf+c, 0, PECOFF_RELOC_RESERVE);
 325         c += PECOFF_RELOC_RESERVE;
 326 #endif
 327
 328         /* Pad unused space with zeros */
 329         setup_sectors = (c + 511) / 512;
 330         if (setup_sectors < SETUP_SECT_MIN)
 331                 setup_sectors = SETUP_SECT_MIN;
 332         i = setup_sectors*512;
 333         memset(buf+c, 0, i-c);
 334
 335 #ifdef CONFIG_EFI_STUB
 336         update_pecoff_setup_and_reloc(i);
 337 #endif
 338
 339         /* Set the default root device */
 340         put_unaligned_le16(DEFAULT_ROOT_DEV, &buf[508]);
 341
 342         fprintf(stderr, "Setup is %d bytes (padded to %d bytes).\n", c, i);
 343
 344         /* Open and stat the kernel file */
 345         fd = open(argv[2], O_RDONLY);
 346         if (fd < 0)
 347                 die("Unable to open `%s': %m", argv[2]);
 348         if (fstat(fd, &sb))
 349                 die("Unable to stat `%s': %m", argv[2]);
 350         sz = sb.st_size;
 351         fprintf (stderr, "System is %d kB\n", (sz+1023)/1024);
 352         kernel = mmap(NULL, sz, PROT_READ, MAP_SHARED, fd, 0);
 353         if (kernel == MAP_FAILED)
 354                 die("Unable to mmap '%s': %m", argv[2]);
 355         /* Number of 16-byte paragraphs, including space for a 4-byte CRC */
 356         sys_size = (sz + 15 + 4) / 16;
 357
 358         /* Patch the setup code with the appropriate size parameters */
 359         buf[0x1f1] = setup_sectors-1;
 360         put_unaligned_le32(sys_size, &buf[0x1f4]);
 361
 362 #ifdef CONFIG_EFI_STUB
 363         update_pecoff_text(setup_sectors * 512, i + (sys_size * 16));
 364         init_sz = get_unaligned_le32(&buf[0x260]);
 365         update_pecoff_bss(i + (sys_size * 16), init_sz);
 366
 367 #ifdef CONFIG_X86_64 /* Yes, this is really how we defined it :( */
 368         efi_stub_entry -= 0x200;
 369 #endif
 370         put_unaligned_le32(efi_stub_entry, &buf[0x264]);
 371 #endif
 372
 373         crc = partial_crc32(buf, i, crc);
 374         if (fwrite(buf, 1, i, stdout) != i)
 375                 die("Writing setup failed");
 376
 377         /* Copy the kernel code */
 378         crc = partial_crc32(kernel, sz, crc);
 379         if (fwrite(kernel, 1, sz, stdout) != sz)
 380                 die("Writing kernel failed");
 381
 382         /* Add padding leaving 4 bytes for the checksum */
 383         while (sz++ < (sys_size*16) - 4) {
 384                 crc = partial_crc32_one('\0', crc);
 385                 if (fwrite("\0", 1, 1, stdout) != 1)
 386                         die("Writing padding failed");
 387         }
 388
 389         /* Write the CRC */
 390         fprintf(stderr, "CRC %x\n", crc);
 391         put_unaligned_le32(crc, buf);
 392         if (fwrite(buf, 1, 4, stdout) != 4)
 393                 die("Writing CRC failed");
 394
 395         close(fd);
 396
 397         /* Everything is OK */
 398         return 0;
 399 }