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