[mirror_ubuntu-bionic-kernel.git] / arch / x86 / boot / tools / build.c

/*
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *  Copyright (C) 1997 Martin Mares
 *  Copyright (C) 2007 H. Peter Anvin
 */

/*
 * This file builds a disk-image from three different files:
 *
 * - setup: 8086 machine code, sets up system parm
 * - system: 80386 code for actual system
 * - zoffset.h: header with ZO_* defines
 *
 * It does some checking that all files are of the correct type, and writes
 * the result to the specified destination, removing headers and padding to
 * the right amount. It also writes some system data to stdout.
 */

/*
 * Changes by tytso to allow root device specification
 * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996
 * Cross compiling fixes by Gertjan van Wingerde, July 1996
 * Rewritten by Martin Mares, April 1997
 * Substantially overhauled by H. Peter Anvin, April 2007
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <tools/le_byteshift.h>

typedef unsigned char  u8;
typedef unsigned short u16;
typedef unsigned int   u32;

#define DEFAULT_MAJOR_ROOT 0
#define DEFAULT_MINOR_ROOT 0
#define DEFAULT_ROOT_DEV (DEFAULT_MAJOR_ROOT << 8 | DEFAULT_MINOR_ROOT)

/* Minimal number of setup sectors */
#define SETUP_SECT_MIN 5
#define SETUP_SECT_MAX 64

/* This must be large enough to hold the entire setup */
u8 buf[SETUP_SECT_MAX*512];
int is_big_kernel;

#define PECOFF_RELOC_RESERVE 0x20

unsigned long efi32_stub_entry;
unsigned long efi64_stub_entry;
unsigned long efi_pe_entry;
unsigned long startup_64;

/*----------------------------------------------------------------------*/

static const u32 crctab32[] = {
	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
	0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
	0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
	0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
	0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
	0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
	0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
	0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
	0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
	0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
	0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
	0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
	0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
	0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
	0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
	0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
	0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
	0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
	0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
	0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
	0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
	0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
	0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
	0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
	0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
	0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
	0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
	0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
	0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
	0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
	0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
	0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
	0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
	0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
	0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
	0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
	0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
	0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
	0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
	0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
	0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
	0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
	0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
	0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
	0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
	0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
	0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
	0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
	0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
	0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
	0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
	0x2d02ef8d
};

static u32 partial_crc32_one(u8 c, u32 crc)
{
	return crctab32[(crc ^ c) & 0xff] ^ (crc >> 8);
}

static u32 partial_crc32(const u8 *s, int len, u32 crc)
{
	while (len--)
		crc = partial_crc32_one(*s++, crc);
	return crc;
}

static void die(const char * str, ...)
{
	va_list args;
	va_start(args, str);
	vfprintf(stderr, str, args);
	fputc('\n', stderr);
	exit(1);
}

static void usage(void)
{
	die("Usage: build setup system zoffset.h image");
}

#ifdef CONFIG_EFI_STUB

static void update_pecoff_section_header_fields(char *section_name, u32 vma, u32 size, u32 datasz, u32 offset)
{
	unsigned int pe_header;
	unsigned short num_sections;
	u8 *section;

	pe_header = get_unaligned_le32(&buf[0x3c]);
	num_sections = get_unaligned_le16(&buf[pe_header + 6]);

#ifdef CONFIG_X86_32
	section = &buf[pe_header + 0xa8];
#else
	section = &buf[pe_header + 0xb8];
#endif

	while (num_sections > 0) {
		if (strncmp((char*)section, section_name, 8) == 0) {
			/* section header size field */
			put_unaligned_le32(size, section + 0x8);

			/* section header vma field */
			put_unaligned_le32(vma, section + 0xc);

			/* section header 'size of initialised data' field */
			put_unaligned_le32(datasz, section + 0x10);

			/* section header 'file offset' field */
			put_unaligned_le32(offset, section + 0x14);

			break;
		}
		section += 0x28;
		num_sections--;
	}
}

static void update_pecoff_section_header(char *section_name, u32 offset, u32 size)
{
	update_pecoff_section_header_fields(section_name, offset, size, size, offset);
}

static void update_pecoff_setup_and_reloc(unsigned int size)
{
	u32 setup_offset = 0x200;
	u32 reloc_offset = size - PECOFF_RELOC_RESERVE;
	u32 setup_size = reloc_offset - setup_offset;

	update_pecoff_section_header(".setup", setup_offset, setup_size);
	update_pecoff_section_header(".reloc", reloc_offset, PECOFF_RELOC_RESERVE);

	/*
	 * Modify .reloc section contents with a single entry. The
	 * relocation is applied to offset 10 of the relocation section.
	 */
	put_unaligned_le32(reloc_offset + 10, &buf[reloc_offset]);
	put_unaligned_le32(10, &buf[reloc_offset + 4]);
}

static void update_pecoff_text(unsigned int text_start, unsigned int file_sz)
{
	unsigned int pe_header;
	unsigned int text_sz = file_sz - text_start;

	pe_header = get_unaligned_le32(&buf[0x3c]);

	/*
	 * Size of code: Subtract the size of the first sector (512 bytes)
	 * which includes the header.
	 */
	put_unaligned_le32(file_sz - 512, &buf[pe_header + 0x1c]);

	/*
	 * Address of entry point for PE/COFF executable
	 */
	put_unaligned_le32(text_start + efi_pe_entry, &buf[pe_header + 0x28]);

	update_pecoff_section_header(".text", text_start, text_sz);
}

static void update_pecoff_bss(unsigned int file_sz, unsigned int init_sz)
{
	unsigned int pe_header;
	unsigned int bss_sz = init_sz - file_sz;

	pe_header = get_unaligned_le32(&buf[0x3c]);

	/* Size of uninitialized data */
	put_unaligned_le32(bss_sz, &buf[pe_header + 0x24]);

	/* Size of image */
	put_unaligned_le32(init_sz, &buf[pe_header + 0x50]);

	update_pecoff_section_header_fields(".bss", file_sz, bss_sz, 0, 0);
}

static int reserve_pecoff_reloc_section(int c)
{
	/* Reserve 0x20 bytes for .reloc section */
	memset(buf+c, 0, PECOFF_RELOC_RESERVE);
	return PECOFF_RELOC_RESERVE;
}

static void efi_stub_defaults(void)
{
	/* Defaults for old kernel */
#ifdef CONFIG_X86_32
	efi_pe_entry = 0x10;
#else
	efi_pe_entry = 0x210;
	startup_64 = 0x200;
#endif
}

static void efi_stub_entry_update(void)
{
	unsigned long addr = efi32_stub_entry;

#ifdef CONFIG_X86_64
	/* Yes, this is really how we defined it :( */
	addr = efi64_stub_entry - 0x200;
#endif

#ifdef CONFIG_EFI_MIXED
	if (efi32_stub_entry != addr)
		die("32-bit and 64-bit EFI entry points do not match\n");
#endif
	put_unaligned_le32(addr, &buf[0x264]);
}

#else

static inline void update_pecoff_setup_and_reloc(unsigned int size) {}
static inline void update_pecoff_text(unsigned int text_start,
				      unsigned int file_sz) {}
static inline void update_pecoff_bss(unsigned int file_sz,
				     unsigned int init_sz) {}
static inline void efi_stub_defaults(void) {}
static inline void efi_stub_entry_update(void) {}

static inline int reserve_pecoff_reloc_section(int c)
{
	return 0;
}
#endif /* CONFIG_EFI_STUB */


/*
 * Parse zoffset.h and find the entry points. We could just #include zoffset.h
 * but that would mean tools/build would have to be rebuilt every time. It's
 * not as if parsing it is hard...
 */
#define PARSE_ZOFS(p, sym) do { \
	if (!strncmp(p, "#define ZO_" #sym " ", 11+sizeof(#sym)))	\
		sym = strtoul(p + 11 + sizeof(#sym), NULL, 16);		\
} while (0)

static void parse_zoffset(char *fname)
{
	FILE *file;
	char *p;
	int c;

	file = fopen(fname, "r");
	if (!file)
		die("Unable to open `%s': %m", fname);
	c = fread(buf, 1, sizeof(buf) - 1, file);
	if (ferror(file))
		die("read-error on `zoffset.h'");
	fclose(file);
	buf[c] = 0;

	p = (char *)buf;

	while (p && *p) {
		PARSE_ZOFS(p, efi32_stub_entry);
		PARSE_ZOFS(p, efi64_stub_entry);
		PARSE_ZOFS(p, efi_pe_entry);
		PARSE_ZOFS(p, startup_64);

		p = strchr(p, '\n');
		while (p && (*p == '\r' || *p == '\n'))
			p++;
	}
}

int main(int argc, char ** argv)
{
	unsigned int i, sz, setup_sectors, init_sz;
	int c;
	u32 sys_size;
	struct stat sb;
	FILE *file, *dest;
	int fd;
	void *kernel;
	u32 crc = 0xffffffffUL;

	efi_stub_defaults();

	if (argc != 5)
		usage();
	parse_zoffset(argv[3]);

	dest = fopen(argv[4], "w");
	if (!dest)
		die("Unable to write `%s': %m", argv[4]);

	/* Copy the setup code */
	file = fopen(argv[1], "r");
	if (!file)
		die("Unable to open `%s': %m", argv[1]);
	c = fread(buf, 1, sizeof(buf), file);
	if (ferror(file))
		die("read-error on `setup'");
	if (c < 1024)
		die("The setup must be at least 1024 bytes");
	if (get_unaligned_le16(&buf[510]) != 0xAA55)
		die("Boot block hasn't got boot flag (0xAA55)");
	fclose(file);

	c += reserve_pecoff_reloc_section(c);

	/* Pad unused space with zeros */
	setup_sectors = (c + 511) / 512;
	if (setup_sectors < SETUP_SECT_MIN)
		setup_sectors = SETUP_SECT_MIN;
	i = setup_sectors*512;
	memset(buf+c, 0, i-c);

	update_pecoff_setup_and_reloc(i);

	/* Set the default root device */
	put_unaligned_le16(DEFAULT_ROOT_DEV, &buf[508]);

	printf("Setup is %d bytes (padded to %d bytes).\n", c, i);

	/* Open and stat the kernel file */
	fd = open(argv[2], O_RDONLY);
	if (fd < 0)
		die("Unable to open `%s': %m", argv[2]);
	if (fstat(fd, &sb))
		die("Unable to stat `%s': %m", argv[2]);
	sz = sb.st_size;
	printf("System is %d kB\n", (sz+1023)/1024);
	kernel = mmap(NULL, sz, PROT_READ, MAP_SHARED, fd, 0);
	if (kernel == MAP_FAILED)
		die("Unable to mmap '%s': %m", argv[2]);
	/* Number of 16-byte paragraphs, including space for a 4-byte CRC */
	sys_size = (sz + 15 + 4) / 16;

	/* Patch the setup code with the appropriate size parameters */
	buf[0x1f1] = setup_sectors-1;
	put_unaligned_le32(sys_size, &buf[0x1f4]);

	update_pecoff_text(setup_sectors * 512, i + (sys_size * 16));
	init_sz = get_unaligned_le32(&buf[0x260]);
	update_pecoff_bss(i + (sys_size * 16), init_sz);

	efi_stub_entry_update();

	crc = partial_crc32(buf, i, crc);
	if (fwrite(buf, 1, i, dest) != i)
		die("Writing setup failed");

	/* Copy the kernel code */
	crc = partial_crc32(kernel, sz, crc);
	if (fwrite(kernel, 1, sz, dest) != sz)
		die("Writing kernel failed");

	/* Add padding leaving 4 bytes for the checksum */
	while (sz++ < (sys_size*16) - 4) {
		crc = partial_crc32_one('\0', crc);
		if (fwrite("\0", 1, 1, dest) != 1)
			die("Writing padding failed");
	}

	/* Write the CRC */
	printf("CRC %x\n", crc);
	put_unaligned_le32(crc, buf);
	if (fwrite(buf, 1, 4, dest) != 4)
		die("Writing CRC failed");

	/* Catch any delayed write failures */
	if (fclose(dest))
		die("Writing image failed");

	close(fd);

	/* Everything is OK */
	return 0;
}
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* Copyright (C) 1991, 1992 Linus Torvalds
1da177e4 LT	3	* Copyright (C) 1997 Martin Mares
4fd06960	4	* Copyright (C) 2007 H. Peter Anvin
1da177e4 LT	5	*/
	6
	7	/*
809373e2	8	* This file builds a disk-image from three different files:
1da177e4	9	*
1da177e4 LT	10	* - setup: 8086 machine code, sets up system parm
1da177e4 LT	11	* - system: 80386 code for actual system
809373e2	12	* - zoffset.h: header with ZO_* defines
1da177e4	13	*
809373e2 KC	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.
1da177e4 LT	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
4fd06960	24	* Substantially overhauled by H. Peter Anvin, April 2007
1da177e4 LT	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>
1da177e4 LT	33	#include <unistd.h>
1da177e4 LT	34	#include <fcntl.h>
4fd06960	35	#include <sys/mman.h>
92f42c50	36	#include <tools/le_byteshift.h>
1da177e4	37
4fd06960 PA	38	typedef unsigned char u8;
4fd06960 PA	39	typedef unsigned short u16;
a51f4047	40	typedef unsigned int u32;
1da177e4 LT	41
	42	#define DEFAULT_MAJOR_ROOT 0
	43	#define DEFAULT_MINOR_ROOT 0
92f42c50	44	#define DEFAULT_ROOT_DEV (DEFAULT_MAJOR_ROOT << 8 \| DEFAULT_MINOR_ROOT)
1da177e4	45
4fd06960 PA	46	/* Minimal number of setup sectors */
	47	#define SETUP_SECT_MIN 5
	48	#define SETUP_SECT_MAX 64
1da177e4	49
4fd06960 PA	50	/* This must be large enough to hold the entire setup */
4fd06960 PA	51	u8 buf[SETUP_SECT_MAX*512];
1da177e4 LT	52	int is_big_kernel;
1da177e4 LT	53
743628e8 JJ	54	#define PECOFF_RELOC_RESERVE 0x20
743628e8 JJ	55
b8ff87a6 MF	56	unsigned long efi32_stub_entry;
b8ff87a6 MF	57	unsigned long efi64_stub_entry;
99f857db DW	58	unsigned long efi_pe_entry;
	59	unsigned long startup_64;
	60
7d6e737c IC	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
4fd06960	130	static void die(const char * str, ...)
1da177e4 LT	131	{
	132	va_list args;
	133	va_start(args, str);
	134	vfprintf(stderr, str, args);
	135	fputc('\n', stderr);
	136	exit(1);
	137	}
	138
4fd06960	139	static void usage(void)
1da177e4	140	{
809373e2	141	die("Usage: build setup system zoffset.h image");
1da177e4 LT	142	}
1da177e4 LT	143
291f3632	144	#ifdef CONFIG_EFI_STUB
743628e8	145
c7fb93ec	146	static void update_pecoff_section_header_fields(char *section_name, u32 vma, u32 size, u32 datasz, u32 offset)
743628e8 JJ	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];
291f3632	159	#endif
743628e8 JJ	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 */
c7fb93ec	167	put_unaligned_le32(vma, section + 0xc);
743628e8 JJ	168
743628e8 JJ	169	/* section header 'size of initialised data' field */
c7fb93ec	170	put_unaligned_le32(datasz, section + 0x10);
743628e8 JJ	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
c7fb93ec MB	182	static void update_pecoff_section_header(char *section_name, u32 offset, u32 size)
	183	{
	184	update_pecoff_section_header_fields(section_name, offset, size, size, offset);
	185	}
	186
743628e8 JJ	187	static void update_pecoff_setup_and_reloc(unsigned int size)
	188	{
	189	u32 setup_offset = 0x200;
	190	u32 reloc_offset = size - PECOFF_RELOC_RESERVE;
	191	u32 setup_size = reloc_offset - setup_offset;
	192
	193	update_pecoff_section_header(".setup", setup_offset, setup_size);
	194	update_pecoff_section_header(".reloc", reloc_offset, PECOFF_RELOC_RESERVE);
	195
	196	/*
	197	* Modify .reloc section contents with a single entry. The
	198	* relocation is applied to offset 10 of the relocation section.
	199	*/
	200	put_unaligned_le32(reloc_offset + 10, &buf[reloc_offset]);
	201	put_unaligned_le32(10, &buf[reloc_offset + 4]);
	202	}
	203
	204	static void update_pecoff_text(unsigned int text_start, unsigned int file_sz)
	205	{
	206	unsigned int pe_header;
	207	unsigned int text_sz = file_sz - text_start;
	208
	209	pe_header = get_unaligned_le32(&buf[0x3c]);
	210
743628e8 JJ	211	/*
	212	* Size of code: Subtract the size of the first sector (512 bytes)
	213	* which includes the header.
	214	*/
	215	put_unaligned_le32(file_sz - 512, &buf[pe_header + 0x1c]);
	216
743628e8	217	/*
99f857db	218	* Address of entry point for PE/COFF executable
743628e8	219	*/
99f857db	220	put_unaligned_le32(text_start + efi_pe_entry, &buf[pe_header + 0x28]);
743628e8 JJ	221
	222	update_pecoff_section_header(".text", text_start, text_sz);
	223	}
	224
c7fb93ec MB	225	static void update_pecoff_bss(unsigned int file_sz, unsigned int init_sz)
	226	{
	227	unsigned int pe_header;
	228	unsigned int bss_sz = init_sz - file_sz;
	229
	230	pe_header = get_unaligned_le32(&buf[0x3c]);
	231
	232	/* Size of uninitialized data */
	233	put_unaligned_le32(bss_sz, &buf[pe_header + 0x24]);
	234
	235	/* Size of image */
	236	put_unaligned_le32(init_sz, &buf[pe_header + 0x50]);
	237
	238	update_pecoff_section_header_fields(".bss", file_sz, bss_sz, 0, 0);
	239	}
	240
993c30a0 MF	241	static int reserve_pecoff_reloc_section(int c)
	242	{
	243	/* Reserve 0x20 bytes for .reloc section */
	244	memset(buf+c, 0, PECOFF_RELOC_RESERVE);
	245	return PECOFF_RELOC_RESERVE;
	246	}
	247
	248	static void efi_stub_defaults(void)
	249	{
	250	/* Defaults for old kernel */
	251	#ifdef CONFIG_X86_32
	252	efi_pe_entry = 0x10;
993c30a0 MF	253	#else
993c30a0 MF	254	efi_pe_entry = 0x210;
993c30a0 MF	255	startup_64 = 0x200;
	256	#endif
	257	}
	258
	259	static void efi_stub_entry_update(void)
	260	{
b8ff87a6 MF	261	unsigned long addr = efi32_stub_entry;
	262
	263	#ifdef CONFIG_X86_64
	264	/* Yes, this is really how we defined it :( */
	265	addr = efi64_stub_entry - 0x200;
	266	#endif
	267
	268	#ifdef CONFIG_EFI_MIXED
	269	if (efi32_stub_entry != addr)
	270	die("32-bit and 64-bit EFI entry points do not match\n");
993c30a0	271	#endif
b8ff87a6	272	put_unaligned_le32(addr, &buf[0x264]);
993c30a0 MF	273	}
	274
	275	#else
	276
b663a685 MF	277	static inline void update_pecoff_setup_and_reloc(unsigned int size) {}
	278	static inline void update_pecoff_text(unsigned int text_start,
	279	unsigned int file_sz) {}
c7fb93ec MB	280	static inline void update_pecoff_bss(unsigned int file_sz,
c7fb93ec MB	281	unsigned int init_sz) {}
993c30a0	282	static inline void efi_stub_defaults(void) {}
b663a685	283	static inline void efi_stub_entry_update(void) {}
993c30a0 MF	284
	285	static inline int reserve_pecoff_reloc_section(int c)
	286	{
	287	return 0;
	288	}
743628e8 JJ	289	#endif /* CONFIG_EFI_STUB */
743628e8 JJ	290
99f857db DW	291
	292	/*
	293	* Parse zoffset.h and find the entry points. We could just #include zoffset.h
	294	* but that would mean tools/build would have to be rebuilt every time. It's
	295	* not as if parsing it is hard...
	296	*/
	297	#define PARSE_ZOFS(p, sym) do { \
	298	if (!strncmp(p, "#define ZO_" #sym " ", 11+sizeof(#sym))) \
	299	sym = strtoul(p + 11 + sizeof(#sym), NULL, 16); \
	300	} while (0)
	301
	302	static void parse_zoffset(char *fname)
	303	{
	304	FILE *file;
	305	char *p;
	306	int c;
	307
	308	file = fopen(fname, "r");
	309	if (!file)
	310	die("Unable to open `%s': %m", fname);
	311	c = fread(buf, 1, sizeof(buf) - 1, file);
	312	if (ferror(file))
	313	die("read-error on `zoffset.h'");
062f4871	314	fclose(file);
99f857db DW	315	buf[c] = 0;
	316
	317	p = (char *)buf;
	318
	319	while (p && *p) {
b8ff87a6 MF	320	PARSE_ZOFS(p, efi32_stub_entry);
b8ff87a6 MF	321	PARSE_ZOFS(p, efi64_stub_entry);
99f857db DW	322	PARSE_ZOFS(p, efi_pe_entry);
	323	PARSE_ZOFS(p, startup_64);
	324
	325	p = strchr(p, '\n');
	326	while (p && (p == '\r' \|\| p == '\n'))
	327	p++;
	328	}
	329	}
	330
743628e8 JJ	331	int main(int argc, char ** argv)
743628e8 JJ	332	{
c7fb93ec	333	unsigned int i, sz, setup_sectors, init_sz;
a8f50345	334	int c;
1da177e4	335	u32 sys_size;
1da177e4	336	struct stat sb;
809373e2	337	FILE file, dest;
4fd06960 PA	338	int fd;
4fd06960 PA	339	void *kernel;
7d6e737c	340	u32 crc = 0xffffffffUL;
1da177e4	341
993c30a0	342	efi_stub_defaults();
99f857db	343
809373e2	344	if (argc != 5)
1da177e4	345	usage();
809373e2 KC	346	parse_zoffset(argv[3]);
	347
	348	dest = fopen(argv[4], "w");
	349	if (!dest)
	350	die("Unable to write `%s': %m", argv[4]);
1da177e4	351
4fd06960 PA	352	/* Copy the setup code */
	353	file = fopen(argv[1], "r");
	354	if (!file)
	355	die("Unable to open `%s': %m", argv[1]);
	356	c = fread(buf, 1, sizeof(buf), file);
	357	if (ferror(file))
	358	die("read-error on `setup'");
	359	if (c < 1024)
	360	die("The setup must be at least 1024 bytes");
92f42c50	361	if (get_unaligned_le16(&buf[510]) != 0xAA55)
1da177e4	362	die("Boot block hasn't got boot flag (0xAA55)");
4fd06960 PA	363	fclose(file);
4fd06960 PA	364
993c30a0	365	c += reserve_pecoff_reloc_section(c);
743628e8	366
4fd06960 PA	367	/* Pad unused space with zeros */
	368	setup_sectors = (c + 511) / 512;
	369	if (setup_sectors < SETUP_SECT_MIN)
	370	setup_sectors = SETUP_SECT_MIN;
	371	i = setup_sectors*512;
	372	memset(buf+c, 0, i-c);
	373
743628e8	374	update_pecoff_setup_and_reloc(i);
743628e8	375
4fd06960	376	/* Set the default root device */
92f42c50	377	put_unaligned_le16(DEFAULT_ROOT_DEV, &buf[508]);
1da177e4	378
809373e2	379	printf("Setup is %d bytes (padded to %d bytes).\n", c, i);
4fd06960 PA	380
	381	/* Open and stat the kernel file */
	382	fd = open(argv[2], O_RDONLY);
	383	if (fd < 0)
	384	die("Unable to open `%s': %m", argv[2]);
	385	if (fstat(fd, &sb))
	386	die("Unable to stat `%s': %m", argv[2]);
1da177e4	387	sz = sb.st_size;
809373e2	388	printf("System is %d kB\n", (sz+1023)/1024);
4fd06960 PA	389	kernel = mmap(NULL, sz, PROT_READ, MAP_SHARED, fd, 0);
	390	if (kernel == MAP_FAILED)
	391	die("Unable to mmap '%s': %m", argv[2]);
7d6e737c IC	392	/* Number of 16-byte paragraphs, including space for a 4-byte CRC */
7d6e737c IC	393	sys_size = (sz + 15 + 4) / 16;
4fd06960 PA	394
	395	/* Patch the setup code with the appropriate size parameters */
	396	buf[0x1f1] = setup_sectors-1;
92f42c50	397	put_unaligned_le32(sys_size, &buf[0x1f4]);
4fd06960	398
c7fb93ec MB	399	update_pecoff_text(setup_sectors * 512, i + (sys_size * 16));
	400	init_sz = get_unaligned_le32(&buf[0x260]);
	401	update_pecoff_bss(i + (sys_size * 16), init_sz);
99f857db	402
993c30a0	403	efi_stub_entry_update();
291f3632	404
7d6e737c	405	crc = partial_crc32(buf, i, crc);
809373e2	406	if (fwrite(buf, 1, i, dest) != i)
4fd06960 PA	407	die("Writing setup failed");
	408
	409	/* Copy the kernel code */
7d6e737c	410	crc = partial_crc32(kernel, sz, crc);
809373e2	411	if (fwrite(kernel, 1, sz, dest) != sz)
4fd06960	412	die("Writing kernel failed");
7d6e737c IC	413
	414	/* Add padding leaving 4 bytes for the checksum */
	415	while (sz++ < (sys_size*16) - 4) {
	416	crc = partial_crc32_one('\0', crc);
809373e2	417	if (fwrite("\0", 1, 1, dest) != 1)
7d6e737c IC	418	die("Writing padding failed");
	419	}
	420
	421	/* Write the CRC */
809373e2	422	printf("CRC %x\n", crc);
a51f4047	423	put_unaligned_le32(crc, buf);
809373e2	424	if (fwrite(buf, 1, 4, dest) != 4)
7d6e737c IC	425	die("Writing CRC failed");
7d6e737c IC	426
809373e2 KC	427	/* Catch any delayed write failures */
	428	if (fclose(dest))
	429	die("Writing image failed");
	430
1da177e4 LT	431	close(fd);
1da177e4 LT	432
4fd06960 PA	433	/* Everything is OK */
4fd06960 PA	434	return 0;
1da177e4	435	}