Index: bootcd/isolinux/syslinux-6.03/efi/main.c
===================================================================
--- bootcd/isolinux/syslinux-6.03/efi/main.c	(revision e16e8f2a41938d263af54a9fd6b4020d6c0d69fa)
+++ bootcd/isolinux/syslinux-6.03/efi/main.c	(revision e16e8f2a41938d263af54a9fd6b4020d6c0d69fa)
@@ -0,0 +1,1344 @@
+/*
+ * Copyright 2011-2014 Intel Corporation - All Rights Reserved
+ */
+
+#include <codepage.h>
+#include <core.h>
+#include <fs.h>
+#include <com32.h>
+#include <syslinux/memscan.h>
+#include <syslinux/firmware.h>
+#include <syslinux/linux.h>
+#include <sys/ansi.h>
+#include <setjmp.h>
+
+#include "efi.h"
+#include "fio.h"
+#include "version.h"
+
+__export uint16_t PXERetry;
+__export char copyright_str[] = "Copyright (C) 2011-" YEAR_STR "\n";
+uint8_t SerialNotice = 1;
+__export char syslinux_banner[] = "Syslinux " VERSION_STR " (EFI; " DATE_STR ")\n";
+char CurrentDirName[CURRENTDIR_MAX];
+struct com32_sys_args __com32;
+
+uint32_t _IdleTimer = 0;
+char __lowmem_heap[32];
+uint32_t BIOS_timer_next;
+uint32_t timer_irq;
+__export uint8_t KbdMap[256];
+char aux_seg[256];
+
+static jmp_buf load_error_buf;
+
+static inline EFI_STATUS
+efi_close_protocol(EFI_HANDLE handle, EFI_GUID *guid, EFI_HANDLE agent,
+		   EFI_HANDLE controller)
+{
+    return uefi_call_wrapper(BS->CloseProtocol, 4, handle,
+			     guid, agent, controller);
+}
+
+struct efi_binding *efi_create_binding(EFI_GUID *bguid, EFI_GUID *pguid)
+{
+    EFI_SERVICE_BINDING *sbp;
+    struct efi_binding *b;
+    EFI_STATUS status;
+    EFI_HANDLE protocol, child, *handles = NULL;
+    UINTN i, nr_handles = 0;
+
+    b = malloc(sizeof(*b));
+    if (!b)
+	return NULL;
+
+    status = LibLocateHandle(ByProtocol, bguid, NULL, &nr_handles, &handles);
+    if (status != EFI_SUCCESS)
+	goto free_binding;
+
+    for (i = 0; i < nr_handles; i++) {
+	status = uefi_call_wrapper(BS->OpenProtocol, 6, handles[i],
+				   bguid, (void **)&sbp,
+				   image_handle, handles[i],
+				   EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+	if (status == EFI_SUCCESS)
+	    break;
+
+	uefi_call_wrapper(BS->CloseProtocol, 4, handles[i], bguid,
+			  image_handle, handles[i]);
+    }
+
+    if (i == nr_handles)
+	goto free_binding;
+
+    child = NULL;
+
+    status = uefi_call_wrapper(sbp->CreateChild, 2, sbp, (EFI_HANDLE *)&child);
+    if (status != EFI_SUCCESS)
+	goto close_protocol;
+
+    status = uefi_call_wrapper(BS->OpenProtocol, 6, child,
+			      pguid, (void **)&protocol,
+			      image_handle, sbp,
+			      EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+    if (status != EFI_SUCCESS)
+	goto destroy_child;
+
+    b->parent = handles[i];
+    b->binding = sbp;
+    b->child = child;
+    b->this = protocol;
+
+    return b;
+
+destroy_child:
+    uefi_call_wrapper(sbp->DestroyChild, 2, sbp, child);
+
+close_protocol:
+    uefi_call_wrapper(BS->CloseProtocol, 4, handles[i], bguid,
+		      image_handle, handles[i]);
+
+free_binding:
+    free(b);
+    return NULL;
+}
+
+void efi_destroy_binding(struct efi_binding *b, EFI_GUID *guid)
+{
+    efi_close_protocol(b->child, guid, image_handle, b->binding);
+    uefi_call_wrapper(b->binding->DestroyChild, 2, b->binding, b->child);
+    efi_close_protocol(b->parent, guid, image_handle, b->parent);
+
+    free(b);
+}
+
+#undef kaboom
+void kaboom(void)
+{
+}
+
+void printf_init(void)
+{
+}
+
+__export void local_boot(uint16_t ax)
+{
+    /*
+     * Inform the firmware that we failed to execute correctly, which
+     * will trigger the next entry in the EFI Boot Manager list.
+     */
+    longjmp(load_error_buf, 1);
+}
+
+void bios_timer_cleanup(void)
+{
+}
+
+char trackbuf[4096];
+
+void __cdecl core_farcall(uint32_t c, const com32sys_t *a, com32sys_t *b)
+{
+}
+
+__export struct firmware *firmware = NULL;
+__export void *__syslinux_adv_ptr;
+__export size_t __syslinux_adv_size;
+char core_xfer_buf[65536];
+struct iso_boot_info {
+	uint32_t pvd;               /* LBA of primary volume descriptor */
+	uint32_t file;              /* LBA of boot file */
+	uint32_t length;            /* Length of boot file */
+	uint32_t csum;              /* Checksum of boot file */
+	uint32_t reserved[10];      /* Currently unused */
+} iso_boot_info;
+
+uint8_t DHCPMagic;
+uint32_t RebootTime;
+
+void pxenv(void)
+{
+}
+
+uint16_t BIOS_fbm = 1;
+far_ptr_t InitStack;
+far_ptr_t PXEEntry;
+
+void gpxe_unload(void)
+{
+}
+
+void do_idle(void)
+{
+}
+
+void pxe_int1a(void)
+{
+}
+
+uint8_t KeepPXE;
+
+struct semaphore;
+mstime_t sem_down(struct semaphore *sem, mstime_t time)
+{
+	/* EFI is single threaded */
+	return 0;
+}
+
+void sem_up(struct semaphore *sem)
+{
+	/* EFI is single threaded */
+}
+
+__export volatile uint32_t __ms_timer = 0;
+volatile uint32_t __jiffies = 0;
+
+void efi_write_char(uint8_t ch, uint8_t attribute)
+{
+	SIMPLE_TEXT_OUTPUT_INTERFACE *out = ST->ConOut;
+	uint16_t c[2];
+
+	uefi_call_wrapper(out->SetAttribute, 2, out, attribute);
+
+	/* Lookup primary Unicode encoding in the system codepage */
+	c[0] = codepage.uni[0][ch];
+	c[1] = '\0';
+
+	uefi_call_wrapper(out->OutputString, 2, out, c);
+}
+
+static void efi_showcursor(const struct term_state *st)
+{
+	SIMPLE_TEXT_OUTPUT_INTERFACE *out = ST->ConOut;
+	bool cursor = st->cursor ? true : false;
+
+	uefi_call_wrapper(out->EnableCursor, 2, out, cursor);
+}
+
+static void efi_set_cursor(int x, int y, bool visible)
+{
+	SIMPLE_TEXT_OUTPUT_INTERFACE *out = ST->ConOut;
+
+	uefi_call_wrapper(out->SetCursorPosition, 3, out, x, y);
+}
+
+static void efi_scroll_up(uint8_t cols, uint8_t rows, uint8_t attribute)
+{
+	efi_write_char('\n', 0);
+	efi_write_char('\r', 0);
+}
+
+static void efi_get_mode(int *cols, int *rows)
+{
+	SIMPLE_TEXT_OUTPUT_INTERFACE *out = ST->ConOut;
+	UINTN c, r;
+
+	uefi_call_wrapper(out->QueryMode, 4, out, out->Mode->Mode, &c, &r);
+	*rows = r;
+	*cols = c;
+}
+
+static void efi_erase(int x0, int y0, int x1, int y1, uint8_t attribute)
+{
+	SIMPLE_TEXT_OUTPUT_INTERFACE *out = ST->ConOut;
+	int cols, rows;
+
+	efi_get_mode(&cols, &rows);
+
+	/*
+	 * The BIOS version of this function has the ability to erase
+	 * parts or all of the screen - the UEFI console doesn't
+	 * support this so we just set the cursor position unless
+	 * we're clearing the whole screen.
+	 */
+	if (!x0 && y0 == (cols - 1)) {
+		/* Really clear the screen */
+		uefi_call_wrapper(out->ClearScreen, 1, out);
+	} else {
+		uefi_call_wrapper(out->SetCursorPosition, 3, out, y1, x1);
+	}
+}
+
+static void efi_text_mode(void)
+{
+}
+
+static void efi_get_cursor(uint8_t *x, uint8_t *y)
+{
+	SIMPLE_TEXT_OUTPUT_INTERFACE *out = ST->ConOut;
+	*x = out->Mode->CursorColumn;
+	*y = out->Mode->CursorRow;
+}
+
+struct output_ops efi_ops = {
+	.erase = efi_erase,
+	.write_char = efi_write_char,
+	.showcursor = efi_showcursor,
+	.set_cursor = efi_set_cursor,
+	.scroll_up = efi_scroll_up,
+	.get_mode = efi_get_mode,
+	.text_mode = efi_text_mode,
+	.get_cursor = efi_get_cursor,
+};
+
+char SubvolName[2];
+static inline EFI_MEMORY_DESCRIPTOR *
+get_memory_map(UINTN *nr_entries, UINTN *key, UINTN *desc_sz,
+	       uint32_t *desc_ver)
+{
+	return LibMemoryMap(nr_entries, key, desc_sz, desc_ver);
+}
+
+
+int efi_scan_memory(scan_memory_callback_t callback, void *data)
+{
+	UINTN i, nr_entries, key, desc_sz;
+	UINTN buf, bufpos;
+	UINT32 desc_ver;
+	int rv = 0;
+
+	buf = (UINTN)get_memory_map(&nr_entries, &key, &desc_sz, &desc_ver);
+	if (!buf)
+		return -1;
+	bufpos = buf;
+
+	for (i = 0; i < nr_entries; bufpos += desc_sz, i++) {
+		EFI_MEMORY_DESCRIPTOR *m;
+		UINT64 region_sz;
+		enum syslinux_memmap_types type;
+
+		m = (EFI_MEMORY_DESCRIPTOR *)bufpos;
+		region_sz = m->NumberOfPages * EFI_PAGE_SIZE;
+
+		switch (m->Type) {
+                case EfiConventionalMemory:
+			type = SMT_FREE;
+                        break;
+		default:
+			type = SMT_RESERVED;
+			break;
+		}
+
+		rv = callback(data, m->PhysicalStart, region_sz, type);
+		if (rv)
+			break;
+	}
+
+	FreePool((void *)buf);
+	return rv;
+}
+
+static struct syslinux_memscan efi_memscan = {
+    .func = efi_scan_memory,
+};
+
+extern uint16_t *bios_free_mem;
+void efi_init(void)
+{
+	/* XXX timer */
+	*bios_free_mem = 0;
+	syslinux_memscan_add(&efi_memscan);
+	mem_init();
+}
+
+char efi_getchar(char *hi)
+{
+	SIMPLE_INPUT_INTERFACE *in = ST->ConIn;
+	EFI_INPUT_KEY key;
+	EFI_STATUS status;
+
+	do {
+		status = uefi_call_wrapper(in->ReadKeyStroke, 2, in, &key);
+	} while (status == EFI_NOT_READY);
+
+	if (!key.ScanCode)
+		return (char)key.UnicodeChar;
+
+	/*
+	 * We currently only handle scan codes that fit in 8 bits.
+	 */
+	*hi = (char)key.ScanCode;
+	return 0;
+}
+
+int efi_pollchar(void)
+{
+	SIMPLE_INPUT_INTERFACE *in = ST->ConIn;
+	EFI_STATUS status;
+
+	status = WaitForSingleEvent(in->WaitForKey, 1);
+	return status != EFI_TIMEOUT;
+}
+
+struct input_ops efi_iops = {
+	.getchar = efi_getchar,
+	.pollchar = efi_pollchar,
+};
+
+extern void efi_adv_init(void);
+extern int efi_adv_write(void);
+
+struct adv_ops efi_adv_ops = {
+	.init = efi_adv_init,
+	.write = efi_adv_write,
+};
+
+struct efi_info {
+	uint32_t load_signature;
+	uint32_t systab;
+	uint32_t desc_size;
+	uint32_t desc_version;
+	uint32_t memmap;
+	uint32_t memmap_size;
+	uint32_t systab_hi;
+	uint32_t memmap_hi;
+};
+
+#define E820MAX	128
+#define E820_RAM	1
+#define E820_RESERVED	2
+#define E820_ACPI	3
+#define E820_NVS	4
+#define E820_UNUSABLE	5
+
+#define BOOT_SIGNATURE	0xaa55
+#define SYSLINUX_EFILDR	0x30	/* Is this published value? */
+#define DEFAULT_TIMER_TICK_DURATION 	500000 /* 500000 == 500000 * 100 * 10^-9 == 50 msec */
+#define DEFAULT_MSTIMER_INC		0x32	/* 50 msec */
+struct e820_entry {
+	uint64_t start;
+	uint64_t len;
+	uint32_t type;
+} __packed;
+
+struct boot_params {
+	struct screen_info screen_info;
+	uint8_t _pad[0x1c0 - sizeof(struct screen_info)];
+	struct efi_info efi;
+	uint8_t _pad2[8];
+	uint8_t e820_entries;
+	uint8_t _pad3[0x2d0 - 0x1e8 - sizeof(uint8_t)];
+	struct e820_entry e820_map[E820MAX];
+} __packed;
+
+/* Allocate boot parameter block aligned to page */
+#define BOOT_PARAM_BLKSIZE	EFI_SIZE_TO_PAGES(sizeof(struct boot_params)) * EFI_PAGE_SIZE
+
+/* Routines in support of efi boot loader were obtained from
+ * http://git.kernel.org/?p=boot/efilinux/efilinux.git:
+ * kernel_jump(), handover_jump(),
+ * emalloc()/efree, alloc_pages/free_pages
+ * allocate_pool()/free_pool()
+ * memory_map()
+ */ 
+extern void kernel_jump(EFI_PHYSICAL_ADDRESS kernel_start,
+			       struct boot_params *boot_params);
+#if __SIZEOF_POINTER__ == 4
+#define EFI_LOAD_SIG	"EL32"
+#elif __SIZEOF_POINTER__ == 8
+#define EFI_LOAD_SIG	"EL64"
+#else
+#error "unsupported architecture"
+#endif
+
+struct dt_desc {
+	uint16_t limit;
+	uint64_t *base;
+} __packed;
+
+struct dt_desc gdt = { 0x800, (uint64_t *)0 };
+struct dt_desc idt = { 0, 0 };
+
+static inline EFI_MEMORY_DESCRIPTOR *
+get_mem_desc(unsigned long memmap, UINTN desc_sz, int i)
+{
+	return (EFI_MEMORY_DESCRIPTOR *)(memmap + (i * desc_sz));
+}
+
+EFI_HANDLE image_handle;
+
+static inline UINT64 round_up(UINT64 x, UINT64 y)
+{
+	return (((x - 1) | (y - 1)) + 1);
+}
+
+static inline UINT64 round_down(UINT64 x, UINT64 y)
+{
+	return (x & ~(y - 1));
+}
+
+static void find_addr(EFI_PHYSICAL_ADDRESS *first,
+		      EFI_PHYSICAL_ADDRESS *last,
+		      EFI_PHYSICAL_ADDRESS min,
+		      EFI_PHYSICAL_ADDRESS max,
+		      size_t size, size_t align)
+{
+	EFI_MEMORY_DESCRIPTOR *map;
+	UINT32 desc_ver;
+	UINTN i, nr_entries, key, desc_sz;
+
+	map = get_memory_map(&nr_entries, &key, &desc_sz, &desc_ver);
+	if (!map)
+		return;
+
+	for (i = 0; i < nr_entries; i++) {
+		EFI_MEMORY_DESCRIPTOR *m;
+		EFI_PHYSICAL_ADDRESS best;
+		UINT64 start, end;
+
+		m = get_mem_desc((unsigned long)map, desc_sz, i);
+		if (m->Type != EfiConventionalMemory)
+			continue;
+
+		if (m->NumberOfPages < EFI_SIZE_TO_PAGES(size))
+			continue;
+
+		start = m->PhysicalStart;
+		end = m->PhysicalStart + (m->NumberOfPages << EFI_PAGE_SHIFT);
+		if (first) {
+			if (end < min)
+				continue;
+
+			/* What's the best address? */
+			if (start < min && min < end)
+				best = min;
+			else
+				best = m->PhysicalStart;
+
+			start = round_up(best, align);
+			if (start > max)
+				continue;
+
+			/* Have we run out of space in this region? */
+			if (end < start || (start + size) > end)
+				continue;
+
+			if (start < *first)
+				*first = start;
+		}
+
+		if (last) {
+			if (start > max)
+				continue;
+
+			/* What's the best address? */
+			if (start < max && max < end)
+				best = max - size;
+			else
+				best = end - size;
+
+			start = round_down(best, align);
+			if (start < min || start < m->PhysicalStart)
+				continue;
+
+			if (start > *last)
+				*last = start;
+		}
+	}
+
+	FreePool(map);
+}
+
+/**
+ * allocate_pages - Allocate memory pages from the system
+ * @atype: type of allocation to perform
+ * @mtype: type of memory to allocate
+ * @num_pages: number of contiguous 4KB pages to allocate
+ * @memory: used to return the address of allocated pages
+ *
+ * Allocate @num_pages physically contiguous pages from the system
+ * memory and return a pointer to the base of the allocation in
+ * @memory if the allocation succeeds. On success, the firmware memory
+ * map is updated accordingly.
+ *
+ * If @atype is AllocateAddress then, on input, @memory specifies the
+ * address at which to attempt to allocate the memory pages.
+ */
+static inline EFI_STATUS
+allocate_pages(EFI_ALLOCATE_TYPE atype, EFI_MEMORY_TYPE mtype,
+	       UINTN num_pages, EFI_PHYSICAL_ADDRESS *memory)
+{
+	return uefi_call_wrapper(BS->AllocatePages, 4, atype,
+				 mtype, num_pages, memory);
+}
+/**
+ * free_pages - Return memory allocated by allocate_pages() to the firmware
+ * @memory: physical base address of the page range to be freed
+ * @num_pages: number of contiguous 4KB pages to free
+ *
+ * On success, the firmware memory map is updated accordingly.
+ */
+static inline EFI_STATUS
+free_pages(EFI_PHYSICAL_ADDRESS memory, UINTN num_pages)
+{
+	return uefi_call_wrapper(BS->FreePages, 2, memory, num_pages);
+}
+
+static EFI_STATUS allocate_addr(EFI_PHYSICAL_ADDRESS *addr, size_t size)
+{
+	UINTN npages = EFI_SIZE_TO_PAGES(size);
+
+	return uefi_call_wrapper(BS->AllocatePages, 4,
+				   AllocateAddress,
+				   EfiLoaderData, npages,
+				   addr);
+}
+/**
+ * allocate_pool - Allocate pool memory
+ * @type: the type of pool to allocate
+ * @size: number of bytes to allocate from pool of @type
+ * @buffer: used to return the address of allocated memory
+ *
+ * Allocate memory from pool of @type. If the pool needs more memory
+ * pages are allocated from EfiConventionalMemory in order to grow the
+ * pool.
+ *
+ * All allocations are eight-byte aligned.
+ */
+static inline EFI_STATUS
+allocate_pool(EFI_MEMORY_TYPE type, UINTN size, void **buffer)
+{
+	return uefi_call_wrapper(BS->AllocatePool, 3, type, size, buffer);
+}
+
+/**
+ * free_pool - Return pool memory to the system
+ * @buffer: the buffer to free
+ *
+ * Return @buffer to the system. The returned memory is marked as
+ * EfiConventionalMemory.
+ */
+static inline EFI_STATUS free_pool(void *buffer)
+{
+	return uefi_call_wrapper(BS->FreePool, 1, buffer);
+}
+
+static void free_addr(EFI_PHYSICAL_ADDRESS addr, size_t size)
+{
+	UINTN npages = EFI_SIZE_TO_PAGES(size);
+
+	uefi_call_wrapper(BS->FreePages, 2, addr, npages);
+}
+
+/* cancel the established timer */
+static EFI_STATUS cancel_timer(EFI_EVENT ev)
+{
+	return uefi_call_wrapper(BS->SetTimer, 3, ev, TimerCancel, 0);
+}
+
+/* Check if timer went off and update default timer counter */
+void timer_handler(EFI_EVENT ev, VOID *ctx)
+{
+	__ms_timer += DEFAULT_MSTIMER_INC;
+	++__jiffies;
+}
+
+/* Setup a default periodic timer */
+static EFI_STATUS setup_default_timer(EFI_EVENT *ev)
+{
+	EFI_STATUS efi_status;
+
+	*ev = NULL;
+	efi_status = uefi_call_wrapper( BS->CreateEvent, 5, EVT_TIMER|EVT_NOTIFY_SIGNAL, TPL_NOTIFY, (EFI_EVENT_NOTIFY)timer_handler, NULL, ev);
+	if (efi_status == EFI_SUCCESS) {
+		efi_status = uefi_call_wrapper(BS->SetTimer, 3, *ev, TimerPeriodic, DEFAULT_TIMER_TICK_DURATION);
+	}
+	return efi_status;
+}
+
+/**
+ * emalloc - Allocate memory with a strict alignment requirement
+ * @size: size in bytes of the requested allocation
+ * @align: the required alignment of the allocation
+ * @addr: a pointer to the allocated address on success
+ *
+ * If we cannot satisfy @align we return 0.
+ */
+EFI_STATUS emalloc(UINTN size, UINTN align, EFI_PHYSICAL_ADDRESS *addr)
+{
+	UINTN i, nr_entries, map_key, desc_size;
+	EFI_MEMORY_DESCRIPTOR *map_buf;
+	UINTN d;
+	UINT32 desc_version;
+	EFI_STATUS err;
+	UINTN nr_pages = EFI_SIZE_TO_PAGES(size);
+
+	map_buf = get_memory_map(&nr_entries, &map_key,
+				 &desc_size, &desc_version);
+	if (!map_buf)
+		goto fail;
+
+	d = (UINTN)map_buf;
+
+	for (i = 0; i < nr_entries; i++, d += desc_size) {
+		EFI_MEMORY_DESCRIPTOR *desc;
+		EFI_PHYSICAL_ADDRESS start, end, aligned;
+
+		desc = (EFI_MEMORY_DESCRIPTOR *)d;
+		if (desc->Type != EfiConventionalMemory)
+			continue;
+
+		if (desc->NumberOfPages < nr_pages)
+			continue;
+
+		start = desc->PhysicalStart;
+		end = start + (desc->NumberOfPages << EFI_PAGE_SHIFT);
+
+		/* Low-memory is super-precious! */
+		if (end <= 1 << 20)
+			continue;
+		if (start < 1 << 20)
+			start = (1 << 20);
+
+		aligned = (start + align -1) & ~(align -1);
+
+		if ((aligned + size) <= end) {
+			err = allocate_pages(AllocateAddress, EfiLoaderData,
+					     nr_pages, &aligned);
+			if (err == EFI_SUCCESS) {
+				*addr = aligned;
+				break;
+			}
+		}
+	}
+
+	if (i == nr_entries)
+		err = EFI_OUT_OF_RESOURCES;
+
+	free_pool(map_buf);
+fail:
+	return err;
+}
+/**
+ * efree - Return memory allocated with emalloc
+ * @memory: the address of the emalloc() allocation
+ * @size: the size of the allocation
+ */
+void efree(EFI_PHYSICAL_ADDRESS memory, UINTN size)
+{
+	UINTN nr_pages = EFI_SIZE_TO_PAGES(size);
+
+	free_pages(memory, nr_pages);
+}
+
+/*
+ * Check whether 'buf' contains a PE/COFF header and that the PE/COFF
+ * file can be executed by this architecture.
+ */
+static bool valid_pecoff_image(char *buf)
+{
+    struct pe_header {
+	uint16_t signature;
+	uint8_t _pad[0x3a];
+	uint32_t offset;
+    } *pehdr = (struct pe_header *)buf;
+    struct coff_header {
+	uint32_t signature;
+	uint16_t machine;
+    } *chdr;
+
+    if (pehdr->signature != 0x5a4d) {
+	dprintf("Invalid MS-DOS header signature\n");
+	return false;
+    }
+
+    if (!pehdr->offset || pehdr->offset > 512) {
+	dprintf("Invalid PE header offset\n");
+	return false;
+    }
+
+    chdr = (struct coff_header *)&buf[pehdr->offset];
+    if (chdr->signature != 0x4550) {
+	dprintf("Invalid PE header signature\n");
+	return false;
+    }
+
+#if defined(__x86_64__)
+    if (chdr->machine != 0x8664) {
+	dprintf("Invalid PE machine field\n");
+	return false;
+    }
+#else
+    if (chdr->machine != 0x14c) {
+	dprintf("Invalid PE machine field\n");
+	return false;
+    }
+#endif
+
+    return true;
+}
+
+/*
+ * Boot a Linux kernel using the EFI boot stub handover protocol.
+ *
+ * This function will not return to its caller if booting the kernel
+ * image succeeds. If booting the kernel image fails, a legacy boot
+ * method should be attempted.
+ */
+static void handover_boot(struct linux_header *hdr, struct boot_params *bp)
+{
+    unsigned long address = hdr->code32_start + hdr->handover_offset;
+    handover_func_t *func = efi_handover;
+
+    dprintf("Booting kernel using handover protocol\n");
+
+    /*
+     * Ensure that the kernel is a valid PE32(+) file and that the
+     * architecture of the file matches this version of Syslinux - we
+     * can't mix firmware and kernel bitness (e.g. 32-bit kernel on
+     * 64-bit EFI firmware) using the handover protocol.
+     */
+    if (!valid_pecoff_image((char *)hdr))
+	return;
+
+    if (hdr->version >= 0x20c) {
+	if (hdr->xloadflags & XLF_EFI_HANDOVER_32)
+	    func = efi_handover_32;
+
+	if (hdr->xloadflags & XLF_EFI_HANDOVER_64)
+	    func = efi_handover_64;
+    }
+
+    efi_console_restore();
+    func(image_handle, ST, bp, address);
+}
+
+static int check_linux_header(struct linux_header *hdr)
+{
+	if (hdr->version < 0x205)
+		hdr->relocatable_kernel = 0;
+
+	/* FIXME: check boot sector signature */
+	if (hdr->boot_flag != BOOT_SIGNATURE) {
+		printf("Invalid Boot signature 0x%x, bailing out\n", hdr->boot_flag);
+		return -1;
+	}
+
+	return 0;
+}
+
+static char *build_cmdline(char *str)
+{
+	EFI_PHYSICAL_ADDRESS addr;
+	EFI_STATUS status;
+	char *cmdline = NULL; /* internal, in efi_physical below 0x3FFFFFFF */
+
+	/*
+	 * The kernel expects cmdline to be allocated pretty low,
+	 * Documentation/x86/boot.txt says,
+	 *
+	 *	"The kernel command line can be located anywhere
+	 *	between the end of the setup heap and 0xA0000"
+	 */
+	addr = 0xA0000;
+	status = allocate_pages(AllocateMaxAddress, EfiLoaderData,
+			     EFI_SIZE_TO_PAGES(strlen(str) + 1),
+			     &addr);
+	if (status != EFI_SUCCESS) {
+		printf("Failed to allocate memory for kernel command line, bailing out\n");
+		return NULL;
+	}
+	cmdline = (char *)(UINTN)addr;
+	memcpy(cmdline, str, strlen(str) + 1);
+	return cmdline;
+}
+
+static int build_gdt(void)
+{
+	EFI_STATUS status;
+
+	/* Allocate gdt consistent with the alignment for architecture */
+	status = emalloc(gdt.limit, __SIZEOF_POINTER__ , (EFI_PHYSICAL_ADDRESS *)&gdt.base);
+	if (status != EFI_SUCCESS) {
+		printf("Failed to allocate memory for GDT, bailing out\n");
+		return -1;
+	}
+	memset(gdt.base, 0x0, gdt.limit);
+
+	/*
+         * 4Gb - (0x100000*0x1000 = 4Gb)
+         * base address=0
+         * code read/exec
+         * granularity=4096, 386 (+5th nibble of limit)
+         */
+        gdt.base[2] = 0x00cf9a000000ffff;
+
+        /*
+         * 4Gb - (0x100000*0x1000 = 4Gb)
+         * base address=0
+         * data read/write
+         * granularity=4096, 386 (+5th nibble of limit)
+         */
+        gdt.base[3] = 0x00cf92000000ffff;
+
+        /* Task segment value */
+        gdt.base[4] = 0x0080890000000000;
+
+	return 0;
+}
+
+/*
+ * Callers use ->ramdisk_size to check whether any memory was
+ * allocated (and therefore needs free'ing). The return value indicates
+ * hard error conditions, such as failing to alloc memory for the
+ * ramdisk image. Having no initramfs is not an error.
+ */
+static int handle_ramdisks(struct linux_header *hdr,
+			   struct initramfs *initramfs)
+{
+	EFI_PHYSICAL_ADDRESS last;
+	struct initramfs *ip;
+	EFI_STATUS status;
+	addr_t irf_size;
+	addr_t next_addr, len, pad;
+
+	hdr->ramdisk_image = 0;
+	hdr->ramdisk_size = 0;
+
+	/*
+	 * Figure out the size of the initramfs, and where to put it.
+	 * We should put it at the highest possible address which is
+	 * <= hdr->initrd_addr_max, which fits the entire initramfs.
+	 */
+	irf_size = initramfs_size(initramfs);	/* Handles initramfs == NULL */
+	if (!irf_size)
+		return 0;
+
+	last = 0;
+	find_addr(NULL, &last, 0x1000, hdr->initrd_addr_max,
+		  irf_size, INITRAMFS_MAX_ALIGN);
+	if (last)
+		status = allocate_addr(&last, irf_size);
+
+	if (!last || status != EFI_SUCCESS) {
+		printf("Failed to allocate initramfs memory, bailing out\n");
+		return -1;
+	}
+
+	hdr->ramdisk_image = (uint32_t)last;
+	hdr->ramdisk_size = irf_size;
+
+	/* Copy initramfs into allocated memory */
+	for (ip = initramfs->next; ip->len; ip = ip->next) {
+		len = ip->len;
+		next_addr = last + len;
+
+		/*
+		 * If this isn't the last entry, extend the
+		 * zero-pad region to enforce the alignment of
+		 * the next chunk.
+		 */
+		if (ip->next->len) {
+			pad = -next_addr & (ip->next->align - 1);
+			len += pad;
+			next_addr += pad;
+		}
+
+		if (ip->data_len)
+			memcpy((void *)(UINTN)last, ip->data, ip->data_len);
+
+		if (len > ip->data_len)
+			memset((void *)(UINTN)(last + ip->data_len), 0,
+			       len - ip->data_len);
+
+		last = next_addr;
+	}
+	return 0;
+}
+
+static int exit_boot(struct boot_params *bp)
+{
+	struct e820_entry *e820buf, *e;
+	EFI_MEMORY_DESCRIPTOR *map;
+	EFI_STATUS status;
+	uint32_t e820_type;
+	UINTN i, nr_entries, key, desc_sz;
+	UINT32 desc_ver;
+
+	/* Build efi memory map */
+	map = get_memory_map(&nr_entries, &key, &desc_sz, &desc_ver);
+	if (!map)
+		return -1;
+
+	bp->efi.memmap = (uint32_t)(unsigned long)map;
+	bp->efi.memmap_size = nr_entries * desc_sz;
+	bp->efi.systab = (uint32_t)(unsigned long)ST;
+	bp->efi.desc_size = desc_sz;
+	bp->efi.desc_version = desc_ver;
+#if defined(__x86_64__)
+        bp->efi.systab_hi = ((unsigned long)ST) >> 32;
+        bp->efi.memmap_hi = ((unsigned long)map) >> 32;
+#endif
+
+
+	/*
+	 * Even though 'memmap' contains the memory map we provided
+	 * previously in efi_scan_memory(), we should recalculate the
+	 * e820 map because it will most likely have changed in the
+	 * interim.
+	 */
+	e = e820buf = bp->e820_map;
+	for (i = 0; i < nr_entries && i < E820MAX; i++) {
+		struct e820_entry *prev = NULL;
+
+		if (e > e820buf)
+			prev = e - 1;
+
+		map = get_mem_desc(bp->efi.memmap, desc_sz, i);
+		e->start = map->PhysicalStart;
+		e->len = map->NumberOfPages << EFI_PAGE_SHIFT;
+
+		switch (map->Type) {
+		case EfiReservedMemoryType:
+                case EfiRuntimeServicesCode:
+                case EfiRuntimeServicesData:
+                case EfiMemoryMappedIO:
+                case EfiMemoryMappedIOPortSpace:
+                case EfiPalCode:
+                        e820_type = E820_RESERVED;
+                        break;
+
+                case EfiUnusableMemory:
+                        e820_type = E820_UNUSABLE;
+                        break;
+
+                case EfiACPIReclaimMemory:
+                        e820_type = E820_ACPI;
+                        break;
+
+                case EfiLoaderCode:
+                case EfiLoaderData:
+                case EfiBootServicesCode:
+                case EfiBootServicesData:
+                case EfiConventionalMemory:
+			e820_type = E820_RAM;
+			break;
+
+		case EfiACPIMemoryNVS:
+			e820_type = E820_NVS;
+			break;
+		default:
+			continue;
+		}
+
+		e->type = e820_type;
+
+		/* Check for adjacent entries we can merge. */
+		if (prev && (prev->start + prev->len) == e->start &&
+		    prev->type == e->type)
+			prev->len += e->len;
+		else
+			e++;
+	}
+
+	bp->e820_entries = e - e820buf;
+
+	status = uefi_call_wrapper(BS->ExitBootServices, 2, image_handle, key);
+	if (status != EFI_SUCCESS) {
+		printf("Failed to exit boot services: 0x%016lx\n", status);
+		FreePool(map);
+		return -1;
+	}
+
+	return 0;
+}
+
+/* efi_boot_linux: 
+ * Boots the linux kernel using the image and parameters to boot with.
+ * The EFI boot loader is reworked taking the cue from
+ * http://git.kernel.org/?p=boot/efilinux/efilinux.git on the need to
+ * cap key kernel data structures at * 0x3FFFFFFF.
+ * The kernel image, kernel command line and boot parameter block are copied
+ * into allocated memory areas that honor the address capping requirement
+ * prior to kernel handoff. 
+ *
+ * FIXME
+ * Can we move this allocation requirement to com32 linux loader in order
+ * to avoid double copying kernel image?
+ */
+int efi_boot_linux(void *kernel_buf, size_t kernel_size,
+		   struct initramfs *initramfs,
+		   struct setup_data *setup_data,
+		   char *cmdline)
+{
+	struct linux_header *hdr;
+	struct boot_params *bp;
+	EFI_STATUS status;
+	EFI_PHYSICAL_ADDRESS addr, pref_address, kernel_start = 0;
+	UINT64 setup_sz, init_size = 0;
+	char *_cmdline;
+
+	if (check_linux_header(kernel_buf))
+		goto bail;
+
+	/* allocate for boot parameter block */
+	addr = 0x3FFFFFFF;
+	status = allocate_pages(AllocateMaxAddress, EfiLoaderData,
+			     BOOT_PARAM_BLKSIZE, &addr);
+	if (status != EFI_SUCCESS) {
+		printf("Failed to allocate memory for kernel boot parameter block, bailing out\n");
+		goto bail;
+	}
+
+	bp = (struct boot_params *)(UINTN)addr;
+
+	memset((void *)bp, 0x0, BOOT_PARAM_BLKSIZE);
+	/* Copy the first two sectors to boot_params */
+	memcpy((char *)bp, kernel_buf, 2 * 512);
+	hdr = (struct linux_header *)bp;
+
+	setup_sz = (hdr->setup_sects + 1) * 512;
+	if (hdr->version >= 0x20a) {
+		pref_address = hdr->pref_address;
+		init_size = hdr->init_size;
+	} else {
+		pref_address = 0x100000;
+
+		/*
+		 * We need to account for the fact that the kernel
+		 * needs room for decompression, otherwise we could
+		 * end up trashing other chunks of allocated memory.
+		 */
+		init_size = (kernel_size - setup_sz) * 3;
+	}
+	hdr->type_of_loader = SYSLINUX_EFILDR;	/* SYSLINUX boot loader module */
+	_cmdline = build_cmdline(cmdline);
+	if (!_cmdline)
+		goto bail;
+
+	hdr->cmd_line_ptr = (UINT32)(UINTN)_cmdline;
+
+	addr = pref_address;
+	status = allocate_pages(AllocateAddress, EfiLoaderData,
+			     EFI_SIZE_TO_PAGES(init_size), &addr);
+	if (status != EFI_SUCCESS) {
+		/*
+		 * We failed to allocate the preferred address, so
+		 * just allocate some memory and hope for the best.
+		 */
+		if (!hdr->relocatable_kernel) {
+			printf("Cannot relocate kernel, bailing out\n");
+			goto bail;
+		}
+
+		status = emalloc(init_size, hdr->kernel_alignment, &addr);
+		if (status != EFI_SUCCESS) {
+			printf("Failed to allocate memory for kernel image, bailing out\n");
+			goto free_map;
+		}
+	}
+	kernel_start = addr;
+	/* FIXME: we copy the kernel into the physical memory allocated here
+	 * The syslinux kernel image load elsewhere could allocate the EFI memory from here
+	 * prior to copying kernel and save an extra copy
+	 */
+	memcpy((void *)(UINTN)kernel_start, kernel_buf+setup_sz, kernel_size-setup_sz);
+
+	hdr->code32_start = (UINT32)((UINT64)kernel_start);
+
+	dprintf("efi_boot_linux: kernel_start 0x%x kernel_size 0x%x initramfs 0x%x setup_data 0x%x cmdline 0x%x\n",
+	kernel_start, kernel_size, initramfs, setup_data, _cmdline);
+
+	if (handle_ramdisks(hdr, initramfs))
+		goto free_map;
+
+	/* Attempt to use the handover protocol if available */
+	if (hdr->version >= 0x20b && hdr->handover_offset)
+		handover_boot(hdr, bp);
+
+	setup_screen(&bp->screen_info);
+
+	if (build_gdt())
+		goto free_map;
+
+	dprintf("efi_boot_linux: setup_sects %d kernel_size %d\n", hdr->setup_sects, kernel_size);
+
+	efi_console_restore();
+
+	if (exit_boot(bp))
+		goto free_map;
+
+	memcpy(&bp->efi.load_signature, EFI_LOAD_SIG, sizeof(uint32_t));
+
+	asm volatile ("lidt %0" :: "m" (idt));
+	asm volatile ("lgdt %0" :: "m" (gdt));
+
+	kernel_jump(kernel_start, bp);
+
+	/* NOTREACHED */
+
+free_map:
+	if (_cmdline)
+		efree((EFI_PHYSICAL_ADDRESS)(unsigned long)_cmdline,
+		      strlen(_cmdline) + 1);
+
+	if (bp)
+		efree((EFI_PHYSICAL_ADDRESS)(unsigned long)bp,
+		       BOOT_PARAM_BLKSIZE);
+	if (kernel_start) efree(kernel_start, init_size);
+	if (hdr->ramdisk_size)
+		free_addr(hdr->ramdisk_image, hdr->ramdisk_size);
+bail:
+	return -1;
+}
+
+extern struct disk *efi_disk_init(EFI_HANDLE);
+extern void serialcfg(uint16_t *, uint16_t *, uint16_t *);
+
+extern struct vesa_ops efi_vesa_ops;
+
+struct mem_ops efi_mem_ops = {
+	.malloc = efi_malloc,
+	.realloc = efi_realloc,
+	.free = efi_free,
+};
+
+struct firmware efi_fw = {
+	.init = efi_init,
+	.disk_init = efi_disk_init,
+	.o_ops = &efi_ops,
+	.i_ops = &efi_iops,
+	.get_serial_console_info = serialcfg,
+	.adv_ops = &efi_adv_ops,
+	.boot_linux = efi_boot_linux,
+	.vesa = &efi_vesa_ops,
+	.mem = &efi_mem_ops,
+};
+
+static inline void syslinux_register_efi(void)
+{
+	firmware = &efi_fw;
+}
+
+extern void init(void);
+extern const struct fs_ops vfat_fs_ops;
+extern const struct fs_ops pxe_fs_ops;
+
+char free_high_memory[4096];
+
+extern char __bss_start[];
+extern char __bss_end[];
+
+static void efi_setcwd(CHAR16 *dp)
+{
+	CHAR16 *c16;
+	char *c8;
+	int i, j;
+
+	/* Search for the start of the last path component */
+	for (i = StrLen(dp) - 1; i >= 0; i--) {
+		if (dp[i] == '\\' || dp[i] == '/')
+			break;
+	}
+
+	if (i < 0 || i > CURRENTDIR_MAX) {
+		dp = L"\\";
+		i = 1;
+	}
+
+	c8 = CurrentDirName;
+	c16 = dp;
+
+	for (j = 0; j < i; j++) {
+		if (*c16 == '\\') {
+			*c8++ = '/';
+			c16++;
+		} else
+			*c8++ = *c16++;
+	}
+
+	*c8 = '\0';
+}
+
+EFI_STATUS efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *table)
+{
+	EFI_PXE_BASE_CODE *pxe;
+	EFI_LOADED_IMAGE *info;
+	EFI_STATUS status = EFI_SUCCESS;
+	const struct fs_ops *ops[] = { NULL, NULL };
+	unsigned long len = (unsigned long)__bss_end - (unsigned long)__bss_start;
+	static struct efi_disk_private priv;
+	SIMPLE_INPUT_INTERFACE *in;
+	EFI_INPUT_KEY key;
+	EFI_EVENT timer_ev;
+
+	memset(__bss_start, 0, len);
+	InitializeLib(image, table);
+
+	image_handle = image;
+	syslinux_register_efi();
+
+	efi_console_save();
+	init();
+
+	status = uefi_call_wrapper(BS->HandleProtocol, 3, image,
+				   &LoadedImageProtocol, (void **)&info);
+	if (status != EFI_SUCCESS) {
+		Print(L"Failed to lookup LoadedImageProtocol\n");
+		goto out;
+	}
+
+	status = uefi_call_wrapper(BS->HandleProtocol, 3, info->DeviceHandle,
+				   &PxeBaseCodeProtocol, (void **)&pxe);
+	if (status != EFI_SUCCESS) {
+		/*
+		 * Use device handle to set up the volume root to
+		 * proceed with ADV init.
+		 */
+		if (EFI_ERROR(efi_set_volroot(info->DeviceHandle))) {
+			Print(L"Failed to locate root device to prep for ");
+			Print(L"file operations & ADV initialization\n");
+			goto out;
+		}
+
+		efi_derivative(SYSLINUX_FS_SYSLINUX);
+		ops[0] = &vfat_fs_ops;
+	} else {
+		efi_derivative(SYSLINUX_FS_PXELINUX);
+		ops[0] = &pxe_fs_ops;
+	}
+
+	/* setup timer for boot menu system support */
+	status = setup_default_timer(&timer_ev);
+	if (status != EFI_SUCCESS) {
+		Print(L"Failed to set up EFI timer support, bailing out\n");
+		goto out;
+	}
+
+	/* TODO: once all errors are captured in efi_errno, bail out if necessary */
+
+	priv.dev_handle = info->DeviceHandle;
+
+	/*
+	 * Set the current working directory, which should be the
+	 * directory that syslinux.efi resides in.
+	 */
+	efi_setcwd(DevicePathToStr(info->FilePath));
+
+	fs_init(ops, (void *)&priv);
+
+	/*
+	 * There may be pending user input that wasn't processed by
+	 * whatever application invoked us. Consume and discard that
+	 * data now.
+	 */
+	in = ST->ConIn;
+	do {
+		status = uefi_call_wrapper(in->ReadKeyStroke, 2, in, &key);
+	} while (status != EFI_NOT_READY);
+
+	if (!setjmp(load_error_buf))
+		load_env32(NULL);
+
+	/* load_env32() failed.. cancel timer and bailout */
+	status = cancel_timer(timer_ev);
+	if (status != EFI_SUCCESS)
+		Print(L"Failed to cancel EFI timer: %x\n", status);
+
+	/*
+	 * Tell the firmware that Syslinux failed to load.
+	 */
+	status = EFI_LOAD_ERROR;
+out:
+	efi_console_restore();
+	return status;
+}
