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