[deliverable/linux.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 two different files:
 *
 * - setup: 8086 machine code, sets up system parm
 * - system: 80386 code for actual system
 *
 * It does some checking that all files are of the correct type, and
 * just writes the result to stdout, removing headers and padding to
 * the right amount. It also writes some system data to stderr.
 */

/*
 * 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 efi_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(char *section_name, u32 offset, u32 size)
{
	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(offset, section + 0xc);

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

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

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

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 image */
	put_unaligned_le32(file_sz, &buf[pe_header + 0x50]);

	/*
	 * 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);
}

#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'");
	buf[c] = 0;

	p = (char *)buf;

	while (p && *p) {
		PARSE_ZOFS(p, efi_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;
	int c;
	u32 sys_size;
	struct stat sb;
	FILE *file;
	int fd;
	void *kernel;
	u32 crc = 0xffffffffUL;

	/* Defaults for old kernel */
#ifdef CONFIG_X86_32
	efi_pe_entry = 0x10;
	efi_stub_entry = 0x30;
#else
	efi_pe_entry = 0x210;
	efi_stub_entry = 0x230;
	startup_64 = 0x200;
#endif

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

	/* 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);

#ifdef CONFIG_EFI_STUB
	/* Reserve 0x20 bytes for .reloc section */
	memset(buf+c, 0, PECOFF_RELOC_RESERVE);
	c += PECOFF_RELOC_RESERVE;
#endif

	/* 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);

#ifdef CONFIG_EFI_STUB
	update_pecoff_setup_and_reloc(i);
#endif

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

	fprintf(stderr, "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;
	fprintf (stderr, "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]);

#ifdef CONFIG_EFI_STUB
	update_pecoff_text(setup_sectors * 512, sz + i + ((sys_size * 16) - sz));

#ifdef CONFIG_X86_64 /* Yes, this is really how we defined it :( */
	efi_stub_entry -= 0x200;
#endif
	put_unaligned_le32(efi_stub_entry, &buf[0x264]);
#endif

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

	/* Copy the kernel code */
	crc = partial_crc32(kernel, sz, crc);
	if (fwrite(kernel, 1, sz, stdout) != 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, stdout) != 1)
			die("Writing padding failed");
	}

	/* Write the CRC */
	fprintf(stderr, "CRC %x\n", crc);
	put_unaligned_le32(crc, buf);
	if (fwrite(buf, 1, 4, stdout) != 4)
		die("Writing CRC 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	/*
9aa3909c	8	* This file builds a disk-image from two different files:
1da177e4	9	*
1da177e4 LT	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
4fd06960	23	* Substantially overhauled by H. Peter Anvin, April 2007
1da177e4 LT	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>
1da177e4 LT	32	#include <unistd.h>
1da177e4 LT	33	#include <fcntl.h>
4fd06960	34	#include <sys/mman.h>
92f42c50	35	#include <tools/le_byteshift.h>
1da177e4	36
4fd06960 PA	37	typedef unsigned char u8;
4fd06960 PA	38	typedef unsigned short u16;
a51f4047	39	typedef unsigned int u32;
1da177e4 LT	40
	41	#define DEFAULT_MAJOR_ROOT 0
	42	#define DEFAULT_MINOR_ROOT 0
92f42c50	43	#define DEFAULT_ROOT_DEV (DEFAULT_MAJOR_ROOT << 8 \| DEFAULT_MINOR_ROOT)
1da177e4	44
4fd06960 PA	45	/* Minimal number of setup sectors */
	46	#define SETUP_SECT_MIN 5
	47	#define SETUP_SECT_MAX 64
1da177e4	48
4fd06960 PA	49	/* This must be large enough to hold the entire setup */
4fd06960 PA	50	u8 buf[SETUP_SECT_MAX*512];
1da177e4 LT	51	int is_big_kernel;
1da177e4 LT	52
743628e8 JJ	53	#define PECOFF_RELOC_RESERVE 0x20
743628e8 JJ	54
99f857db DW	55	unsigned long efi_stub_entry;
	56	unsigned long efi_pe_entry;
	57	unsigned long startup_64;
	58
7d6e737c IC	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
4fd06960	128	static void die(const char * str, ...)
1da177e4 LT	129	{
	130	va_list args;
	131	va_start(args, str);
	132	vfprintf(stderr, str, args);
	133	fputc('\n', stderr);
	134	exit(1);
	135	}
	136
4fd06960	137	static void usage(void)
1da177e4	138	{
99f857db	139	die("Usage: build setup system [zoffset.h] [> image]");
1da177e4 LT	140	}
1da177e4 LT	141
291f3632	142	#ifdef CONFIG_EFI_STUB
743628e8 JJ	143
	144	static void update_pecoff_section_header(char *section_name, u32 offset, u32 size)
	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];
291f3632	157	#endif
743628e8 JJ	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(offset, section + 0xc);
	166
	167	/* section header 'size of initialised data' field */
	168	put_unaligned_le32(size, 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_setup_and_reloc(unsigned int size)
	181	{
	182	u32 setup_offset = 0x200;
	183	u32 reloc_offset = size - PECOFF_RELOC_RESERVE;
	184	u32 setup_size = reloc_offset - setup_offset;
	185
	186	update_pecoff_section_header(".setup", setup_offset, setup_size);
	187	update_pecoff_section_header(".reloc", reloc_offset, PECOFF_RELOC_RESERVE);
	188
	189	/*
	190	* Modify .reloc section contents with a single entry. The
	191	* relocation is applied to offset 10 of the relocation section.
	192	*/
	193	put_unaligned_le32(reloc_offset + 10, &buf[reloc_offset]);
	194	put_unaligned_le32(10, &buf[reloc_offset + 4]);
	195	}
	196
	197	static void update_pecoff_text(unsigned int text_start, unsigned int file_sz)
	198	{
	199	unsigned int pe_header;
	200	unsigned int text_sz = file_sz - text_start;
	201
	202	pe_header = get_unaligned_le32(&buf[0x3c]);
	203
	204	/* Size of image */
	205	put_unaligned_le32(file_sz, &buf[pe_header + 0x50]);
	206
	207	/*
	208	* Size of code: Subtract the size of the first sector (512 bytes)
	209	* which includes the header.
	210	*/
	211	put_unaligned_le32(file_sz - 512, &buf[pe_header + 0x1c]);
	212
743628e8	213	/*
99f857db	214	* Address of entry point for PE/COFF executable
743628e8	215	*/
99f857db	216	put_unaligned_le32(text_start + efi_pe_entry, &buf[pe_header + 0x28]);
743628e8 JJ	217
	218	update_pecoff_section_header(".text", text_start, text_sz);
	219	}
	220
	221	#endif /* CONFIG_EFI_STUB */
	222
99f857db DW	223
	224	/*
	225	* Parse zoffset.h and find the entry points. We could just #include zoffset.h
	226	* but that would mean tools/build would have to be rebuilt every time. It's
	227	* not as if parsing it is hard...
	228	*/
	229	#define PARSE_ZOFS(p, sym) do { \
	230	if (!strncmp(p, "#define ZO_" #sym " ", 11+sizeof(#sym))) \
	231	sym = strtoul(p + 11 + sizeof(#sym), NULL, 16); \
	232	} while (0)
	233
	234	static void parse_zoffset(char *fname)
	235	{
	236	FILE *file;
	237	char *p;
	238	int c;
	239
	240	file = fopen(fname, "r");
	241	if (!file)
	242	die("Unable to open `%s': %m", fname);
	243	c = fread(buf, 1, sizeof(buf) - 1, file);
	244	if (ferror(file))
	245	die("read-error on `zoffset.h'");
	246	buf[c] = 0;
	247
	248	p = (char *)buf;
	249
	250	while (p && *p) {
	251	PARSE_ZOFS(p, efi_stub_entry);
	252	PARSE_ZOFS(p, efi_pe_entry);
	253	PARSE_ZOFS(p, startup_64);
	254
	255	p = strchr(p, '\n');
	256	while (p && (p == '\r' \|\| p == '\n'))
	257	p++;
	258	}
	259	}
	260
743628e8 JJ	261	int main(int argc, char ** argv)
743628e8 JJ	262	{
a8f50345 KZ	263	unsigned int i, sz, setup_sectors;
a8f50345 KZ	264	int c;
1da177e4	265	u32 sys_size;
1da177e4	266	struct stat sb;
4fd06960 PA	267	FILE *file;
	268	int fd;
	269	void *kernel;
7d6e737c	270	u32 crc = 0xffffffffUL;
1da177e4	271
99f857db DW	272	/* Defaults for old kernel */
	273	#ifdef CONFIG_X86_32
	274	efi_pe_entry = 0x10;
	275	efi_stub_entry = 0x30;
	276	#else
	277	efi_pe_entry = 0x210;
	278	efi_stub_entry = 0x230;
	279	startup_64 = 0x200;
	280	#endif
	281
	282	if (argc == 4)
	283	parse_zoffset(argv[3]);
	284	else if (argc != 3)
1da177e4	285	usage();
1da177e4	286
4fd06960 PA	287	/* Copy the setup code */
	288	file = fopen(argv[1], "r");
	289	if (!file)
	290	die("Unable to open `%s': %m", argv[1]);
	291	c = fread(buf, 1, sizeof(buf), file);
	292	if (ferror(file))
	293	die("read-error on `setup'");
	294	if (c < 1024)
	295	die("The setup must be at least 1024 bytes");
92f42c50	296	if (get_unaligned_le16(&buf[510]) != 0xAA55)
1da177e4	297	die("Boot block hasn't got boot flag (0xAA55)");
4fd06960 PA	298	fclose(file);
4fd06960 PA	299
743628e8 JJ	300	#ifdef CONFIG_EFI_STUB
	301	/* Reserve 0x20 bytes for .reloc section */
	302	memset(buf+c, 0, PECOFF_RELOC_RESERVE);
	303	c += PECOFF_RELOC_RESERVE;
	304	#endif
	305
4fd06960 PA	306	/* Pad unused space with zeros */
	307	setup_sectors = (c + 511) / 512;
	308	if (setup_sectors < SETUP_SECT_MIN)
	309	setup_sectors = SETUP_SECT_MIN;
	310	i = setup_sectors*512;
	311	memset(buf+c, 0, i-c);
	312
743628e8 JJ	313	#ifdef CONFIG_EFI_STUB
	314	update_pecoff_setup_and_reloc(i);
	315	#endif
	316
4fd06960	317	/* Set the default root device */
92f42c50	318	put_unaligned_le16(DEFAULT_ROOT_DEV, &buf[508]);
1da177e4	319
4fd06960 PA	320	fprintf(stderr, "Setup is %d bytes (padded to %d bytes).\n", c, i);
	321
	322	/* Open and stat the kernel file */
	323	fd = open(argv[2], O_RDONLY);
	324	if (fd < 0)
	325	die("Unable to open `%s': %m", argv[2]);
	326	if (fstat(fd, &sb))
	327	die("Unable to stat `%s': %m", argv[2]);
1da177e4	328	sz = sb.st_size;
4fd06960 PA	329	fprintf (stderr, "System is %d kB\n", (sz+1023)/1024);
	330	kernel = mmap(NULL, sz, PROT_READ, MAP_SHARED, fd, 0);
	331	if (kernel == MAP_FAILED)
	332	die("Unable to mmap '%s': %m", argv[2]);
7d6e737c IC	333	/* Number of 16-byte paragraphs, including space for a 4-byte CRC */
7d6e737c IC	334	sys_size = (sz + 15 + 4) / 16;
4fd06960 PA	335
	336	/* Patch the setup code with the appropriate size parameters */
	337	buf[0x1f1] = setup_sectors-1;
92f42c50	338	put_unaligned_le32(sys_size, &buf[0x1f4]);
4fd06960	339
291f3632	340	#ifdef CONFIG_EFI_STUB
743628e8	341	update_pecoff_text(setup_sectors * 512, sz + i + ((sys_size * 16) - sz));
99f857db DW	342
	343	#ifdef CONFIG_X86_64 /* Yes, this is really how we defined it :( */
	344	efi_stub_entry -= 0x200;
	345	#endif
	346	put_unaligned_le32(efi_stub_entry, &buf[0x264]);
743628e8	347	#endif
291f3632	348
7d6e737c	349	crc = partial_crc32(buf, i, crc);
4fd06960 PA	350	if (fwrite(buf, 1, i, stdout) != i)
	351	die("Writing setup failed");
	352
	353	/* Copy the kernel code */
7d6e737c	354	crc = partial_crc32(kernel, sz, crc);
4fd06960 PA	355	if (fwrite(kernel, 1, sz, stdout) != sz)
4fd06960 PA	356	die("Writing kernel failed");
7d6e737c IC	357
	358	/* Add padding leaving 4 bytes for the checksum */
	359	while (sz++ < (sys_size*16) - 4) {
	360	crc = partial_crc32_one('\0', crc);
	361	if (fwrite("\0", 1, 1, stdout) != 1)
	362	die("Writing padding failed");
	363	}
	364
	365	/* Write the CRC */
a51f4047 PA	366	fprintf(stderr, "CRC %x\n", crc);
	367	put_unaligned_le32(crc, buf);
	368	if (fwrite(buf, 1, 4, stdout) != 4)
7d6e737c IC	369	die("Writing CRC failed");
7d6e737c IC	370
1da177e4 LT	371	close(fd);
1da177e4 LT	372
4fd06960 PA	373	/* Everything is OK */
4fd06960 PA	374	return 0;
1da177e4	375	}