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